Efficient way render primitives or line?

Can anyone share how to render 3d primitives or 3d line in an efficient way.
eg. render a massive amount of boudingbox or simple shape

This is how I render all my stars in 3D.

        public override void Draw(GraphicsDevice dev)
        {
            if (WorldState.GetWorldState().SunDirection.Y > 0.02)
            {
                world = Matrix.CreateScale(1, -1, 1);
                Matrix trans = Matrix.CreateRotationY(-MathHelper.ToRadians((float)WorldState.GetWorldState().LST)) * Matrix.CreateFromYawPitchRoll((float)WorldState.GetWorldState().CameraLongitude, (float)WorldState.GetWorldState().CameraLatitude, 0);

                effect.World = world;
                effect.View = Matrix.Identity;
                effect.Projection = WorldState.GetWorldState().Projection;

                Matrix mw = WorldState.GetWorldState().View * world;
                Vector2 Origin = new Vector2(texture.Width / 2, texture.Height / 2);

                batch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied, null, DepthStencilState.None, RasterizerState.CullNone, effect);
                for (int i = 0; i < Verts.Count; i++)
                {
                    Vector3 worldspace = Vector3.Transform(Verts[i], trans);
                    Vector3 viewSpaceTextPosition = Vector3.Transform(worldspace, mw);
                    batch.Draw(texture, new Vector2(viewSpaceTextPosition.X, viewSpaceTextPosition.Y), null, Colours[i], 0.0f, Origin, 1.0f, SpriteEffects.None, viewSpaceTextPosition.Z);
                }
                batch.End();
            }
        }

It’s very efficient

You can get a SpriteBatch extension that draws primitives with a quick google search

.
.
Can anyone share how to render 3d primitives or 3d line
.
.

public class Grid3dOrientation
{
    public Grid3d gridForward;
    public Grid3d gridRight;
    public Grid3d gridUp;
    public bool autoNoCull = true;

    /// <summary>
    /// Uses a better version, width height applys to each side of the center.
    /// Draws 3 3d grids, linewith should be very small like .001.
    /// </summary>
    public Grid3dOrientation(int rows, int columns, float width, float height, float lineWidth)
    {
        gridForward = new Grid3d(rows, columns, width, height, lineWidth, true, 0);
        gridRight = new Grid3d(rows, columns, width, height, lineWidth, true, 1);
        gridUp = new Grid3d(rows, columns, width, height, lineWidth, true, 2);
    }
    /// <summary>
    /// Draws 3 3d grids, linewith should be very small like .001
    /// </summary>
    public Grid3dOrientation(int x, int y, float lineWidth)
    {
        gridForward = new Grid3d(x, y, lineWidth, true, 0);
        gridRight = new Grid3d(x, y, lineWidth, true, 1);
        gridUp = new Grid3d(x, y, lineWidth, true, 2);
    }
    /// <summary>
    /// Draws 3 3d grids, linewith should be very small like .001
    /// </summary>
    public Grid3dOrientation(int x, int y, float scale, float lineWidth)
    {
        gridForward = new Grid3d(x, y, scale, lineWidth, true, 0);
        gridRight = new Grid3d(x, y, scale, lineWidth, true, 1);
        gridUp = new Grid3d(x, y, scale, lineWidth, true, 2);
    }

    /// <summary>
    /// Draws this world grid with basic effect.
    /// </summary>
    public void DrawWithBasicEffect(GraphicsDevice gd, BasicEffect effect, Matrix world, float scale, Texture2D forwardTexture, Texture2D upTexture, Texture2D rightTexture)
    {
        // Draw a 3d full orientation grid
        if (autoNoCull)
            gd.RasterizerState = RasterizerState.CullNone;
        effect.World = Matrix.CreateScale(scale) * world;
        bool isLighting = effect.LightingEnabled;
        effect.LightingEnabled = false;
        effect.Texture = upTexture;
        gridForward.Draw(gd, effect);
        effect.Texture = forwardTexture;
        gridRight.Draw(gd, effect);
        effect.Texture = rightTexture;
        gridUp.Draw(gd, effect);
        if (isLighting)
            effect.LightingEnabled = true;
    }

    /// <summary>
    /// The method expects that the shader can accept a parameter named TextureA.
    /// </summary>
    public void Draw(GraphicsDevice gd, Effect effect, Matrix world, float scale, Texture2D forwardTexture, Texture2D upTexture, Texture2D rightTexture)
    {
        // Draw a 3d full orientation grid
        if (autoNoCull)
            gd.RasterizerState = RasterizerState.CullNone;
        effect.Parameters["World"].SetValue(Matrix.CreateScale(scale) * world);
        effect.Parameters["TextureA"].SetValue(upTexture);
        gridForward.Draw(gd, effect);
        effect.Parameters["TextureA"].SetValue(forwardTexture);
        gridRight.Draw(gd, effect);
        effect.Parameters["TextureA"].SetValue(rightTexture);
        gridUp.Draw(gd, effect);
    }
    public void Draw(GraphicsDevice gd, Effect effect)
    {
        if (autoNoCull)
            gd.RasterizerState = RasterizerState.CullNone;
        gridForward.Draw(gd, effect);
        gridRight.Draw(gd, effect);
        gridUp.Draw(gd, effect);
    }
    public void Draw(GraphicsDevice gd, Effect effect, float scale)
    {
        if (autoNoCull)
            gd.RasterizerState = RasterizerState.CullNone;
        effect.Parameters["World"].SetValue(Matrix.CreateScale(scale) * Matrix.Identity);
        gridForward.Draw(gd, effect);
        gridRight.Draw(gd, effect);
        gridUp.Draw(gd, effect);
    }
    public void Draw(GraphicsDevice gd, Effect effect, int part0to2)
    {
        if (autoNoCull)
            gd.RasterizerState = RasterizerState.CullNone;
        if (part0to2 == 0)
        {
            gridForward.Draw(gd, effect);
        }
        else
        {
            if (part0to2 == 1)
                gridRight.Draw(gd, effect);
            else
                gridUp.Draw(gd, effect);
        }
    }
}

public class Grid3d
{
    int xrows;
    int ycol;
    public VertexPositionTexture[] vertices;
    public int[] indices;

    /// <summary>
    /// Use this one its newer and makes more sense.
    /// </summary>
    public Grid3d(int rows, int columns, float width, float height, float lineSize, bool centered, int flipOption)
    {
        CreateGrid3d(rows, columns, width, height, lineSize, centered, flipOption);
    }
    public Grid3d(int rows, int columns, float lineSize, bool centered, int flipOption)
    {
        CreateGrid3d(rows, columns, 1f, lineSize, centered, flipOption);
    }
    public Grid3d(int rows, int columns, float scale, float lineSize, bool centered, int flipOption)
    {
        CreateGrid3d(rows, columns, scale, lineSize, centered, flipOption);
    }

    /// <summary>
    /// Creates a grid for 3d modelspace.
    /// The Width Height is doubled into negative and positive.
    /// linesize should be a very small value less then 1;
    /// flip options range from 0 to 2
    /// </summary>
    public void CreateGrid3d(int rows, int columns, float scale, float lineSize, bool centered, int flipOption)
    {
        rows *= 2;
        columns *= 2;
        Vector3 centerOffset = Vector3.Zero;
        if (centered)
            centerOffset = new Vector3(-.5f, -.5f, 0f);
        xrows = rows;
        ycol = columns;
        int len = xrows * 4 + ycol * 4;
        float xratio = 1f / xrows;
        float yratio = 1f / ycol;
        vertices = new VertexPositionTexture[len];
        indices = new int[(xrows * 6 + ycol * 6) * 2];
        int vIndex = 0;
        int iIndex = 0;
        for (int x = 0; x < xrows; x++)
        {
            int svIndex = vIndex;
            Vector3 xpos = new Vector3(xratio * x, 0f, 0f);

            vertices[vIndex] = new VertexPositionTexture((new Vector3(0f, 0f, 0f) + xpos + centerOffset) * scale, new Vector2(0f, 0f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(0f, 1f, 0f) + xpos + centerOffset) * scale, new Vector2(0f, 1f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(lineSize, 0f, 0f) + xpos + centerOffset) * scale, new Vector2(1f, 0f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(lineSize, 1f, 0f) + xpos + centerOffset) * scale, new Vector2(1f, 1f)); vIndex++;

            indices[iIndex + 0] = svIndex + 0; indices[iIndex + 1] = svIndex + 1; indices[iIndex + 2] = svIndex + 2;// triangle 1        
            indices[iIndex + 3] = svIndex + 2; indices[iIndex + 4] = svIndex + 1; indices[iIndex + 5] = svIndex + 3;// triangle 2               
            indices[iIndex + 0] = svIndex + 2; indices[iIndex + 1] = svIndex + 1; indices[iIndex + 2] = svIndex + 0;// triangle 3 backface             
            indices[iIndex + 3] = svIndex + 3; indices[iIndex + 4] = svIndex + 2; indices[iIndex + 5] = svIndex + 1;// triangle 4 backface
            iIndex += 6 * 2;
        }
        for (int y = 0; y < ycol; y++)
        {
            int svIndex = vIndex;
            Vector3 ypos = new Vector3(0f, yratio * y, 0f);

            vertices[vIndex] = new VertexPositionTexture((new Vector3(0f, 0f, 0f) + ypos + centerOffset) * scale, new Vector2(0f, 0f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(0f, lineSize, 0f) + ypos + centerOffset) * scale, new Vector2(0f, 1f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(1f, 0f, 0f) + ypos + centerOffset) * scale, new Vector2(1f, 0f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(1f, lineSize, 0f) + ypos + centerOffset) * scale, new Vector2(1f, 1f)); vIndex++;

            indices[iIndex + 0] = svIndex + 0; indices[iIndex + 1] = svIndex + 1; indices[iIndex + 2] = svIndex + 2;// triangle 1             
            indices[iIndex + 3] = svIndex + 2; indices[iIndex + 4] = svIndex + 1; indices[iIndex + 5] = svIndex + 3;// triangle 2           
            indices[iIndex + 0] = svIndex + 2; indices[iIndex + 1] = svIndex + 1; indices[iIndex + 2] = svIndex + 0;// triangle 3 backface             
            indices[iIndex + 3] = svIndex + 3; indices[iIndex + 4] = svIndex + 2; indices[iIndex + 5] = svIndex + 1;// triangle 4 backface
            iIndex += 6 * 2;
        }
        Flip(flipOption);
    }

    /// <summary>
    /// Slightly improved version simpler to use makes mores sense.
    /// </summary>
    public void CreateGrid3d(int rows, int columns, float mwidth, float mheight, float lineSize, bool centered, int flipOption)
    {
        rows *= 2;
        columns *= 2;
        mwidth *= 2;
        mheight *= 2;
        Vector3 centerOffset = Vector3.Zero;
        if (centered)
            centerOffset = new Vector3(-mwidth * .5f, -mheight * .5f, 0f);
        xrows = rows;
        ycol = columns;
        int len = xrows * 4 + ycol * 4;
        float xratio = 1f / xrows;
        float yratio = 1f / ycol;
        float xLineRate = mwidth / xrows;
        float yLineRate = mheight / ycol;
        vertices = new VertexPositionTexture[len];
        indices = new int[(xrows * 6 + ycol * 6) * 2];
        int vIndex = 0;
        int iIndex = 0;
        for (int x = 0; x < xrows; x++)
        {
            int svIndex = vIndex;
            Vector3 xpos = new Vector3(xLineRate * x, 0f, 0f);

            vertices[vIndex] = new VertexPositionTexture((new Vector3(0f, 0f, 0f) + xpos + centerOffset), new Vector2(0f, 0f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(0f, mheight, 0f) + xpos + centerOffset), new Vector2(0f, 1f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(lineSize, 0f, 0f) + xpos + centerOffset), new Vector2(1f, 0f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(lineSize, mheight, 0f) + xpos + centerOffset), new Vector2(1f, 1f)); vIndex++;

            indices[iIndex + 0] = svIndex + 0; indices[iIndex + 1] = svIndex + 1; indices[iIndex + 2] = svIndex + 2;// triangle 1        
            indices[iIndex + 3] = svIndex + 2; indices[iIndex + 4] = svIndex + 1; indices[iIndex + 5] = svIndex + 3;// triangle 2               
            indices[iIndex + 0] = svIndex + 2; indices[iIndex + 1] = svIndex + 1; indices[iIndex + 2] = svIndex + 0;// triangle 3 backface             
            indices[iIndex + 3] = svIndex + 3; indices[iIndex + 4] = svIndex + 2; indices[iIndex + 5] = svIndex + 1;// triangle 4 backface
            iIndex += 6 * 2;
        }
        for (int y = 0; y < ycol; y++)
        {
            int svIndex = vIndex;
            Vector3 ypos = new Vector3(0f, yLineRate * y, 0f);

            vertices[vIndex] = new VertexPositionTexture((new Vector3(0f, 0f, 0f) + ypos + centerOffset), new Vector2(0f, 0f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(0f, lineSize, 0f) + ypos + centerOffset), new Vector2(0f, 1f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(mwidth, 0f, 0f) + ypos + centerOffset), new Vector2(1f, 0f)); vIndex++;
            vertices[vIndex] = new VertexPositionTexture((new Vector3(mwidth, lineSize, 0f) + ypos + centerOffset), new Vector2(1f, 1f)); vIndex++;

            indices[iIndex + 0] = svIndex + 0; indices[iIndex + 1] = svIndex + 1; indices[iIndex + 2] = svIndex + 2;// triangle 1             
            indices[iIndex + 3] = svIndex + 2; indices[iIndex + 4] = svIndex + 1; indices[iIndex + 5] = svIndex + 3;// triangle 2           
            indices[iIndex + 0] = svIndex + 2; indices[iIndex + 1] = svIndex + 1; indices[iIndex + 2] = svIndex + 0;// triangle 3 backface             
            indices[iIndex + 3] = svIndex + 3; indices[iIndex + 4] = svIndex + 2; indices[iIndex + 5] = svIndex + 1;// triangle 4 backface
            iIndex += 6 * 2;
        }
        Flip(flipOption);
    }

    void Flip(int flipOption)
    {
        if (flipOption == 1)
        {
            int index = 0;
            for (int x = 0; x < xrows; x++)
            {
                for (int i = 0; i < 4; i++)
                {
                    var p = vertices[index].Position;
                    vertices[index].Position = new Vector3(0f, p.X, p.Y);
                    index++;
                }
            }
            for (int y = 0; y < ycol; y++)
            {
                for (int i = 0; i < 4; i++)
                {
                    var p = vertices[index].Position;
                    vertices[index].Position = new Vector3(0f, p.X, p.Y);
                    index++;
                }
            }
        }
        if (flipOption == 2)
        {
            int index = 0;
            for (int x = 0; x < xrows; x++)
            {
                for (int i = 0; i < 4; i++)
                {
                    var p = vertices[index].Position;
                    vertices[index].Position = new Vector3(p.Y, 0f, p.X);
                    index++;
                }
            }
            for (int y = 0; y < ycol; y++)
            {
                for (int i = 0; i < 4; i++)
                {
                    var p = vertices[index].Position;
                    vertices[index].Position = new Vector3(p.Y, 0f, p.X);
                    index++;
                }
            }
        }
    }

    public void Draw(GraphicsDevice gd, Effect effect)
    {
        foreach (EffectPass pass in effect.CurrentTechnique.Passes)
        {
            pass.Apply();
            gd.DrawUserIndexedPrimitives(PrimitiveType.TriangleList, vertices, 0, vertices.Length, indices, 0, (indices.Length / 3), VertexPositionTexture.VertexDeclaration);
        }
    }
}

You would use a basic effect for this it draws a bunch of lines as grids.

.
.
render a massive amount
.
.

Instancing for massive amounts of the same type of thing.
Other wise if it has to be cpu side make a pooled buffer.

At the bottom is some example instancing code.

http://i936.photobucket.com/albums/ad207/xlightwavex/Gl_instanced_1mllion_zpsotm4qj63.gif