NewGamePhysics.Utilities.PrimitiveBatch Class Reference

Class to handle efficient rendering of lines, points, and triangles to the screen. More...

List of all members.

Public Member Functions
	PrimitiveBatch (GraphicsDevice graphicsDevice)
	Creates a new PrimitiveBatch instance.
void	Dispose ()
	Dispose interface.
void	Begin (PrimitiveType primitiveType)
	Begin is called to tell the PrimitiveBatch what kind of primitives will be drawn, and to prepare the graphics card to render those primitives.
void	AddVertex (Vector2 vertex, Color color)
	AddVertex is called to add another vertex to be rendered. To draw a point, AddVertex must be called once. for lines, twice, and for triangles 3 times. this function can only be called once begin has been called. if there is not enough room in the vertices buffer, Flush is called automatically.
void	End ()
	End is called once all the primitives have been drawn using AddVertex. it will call Flush to actually submit the draw call to the graphics card, and then tell the basic effect to end.
Protected Member Functions
virtual void	Dispose (bool disposing)
	Dispose interface with flag.

---

Detailed Description

Class to handle efficient rendering of lines, points, and triangles to the screen.

Definition at line 16 of file PrimitiveBatch.cs.

---

Constructor & Destructor Documentation

NewGamePhysics.Utilities.PrimitiveBatch.PrimitiveBatch

(

GraphicsDevice

graphicsDevice

)

Creates a new PrimitiveBatch instance.

Definition at line 87 of file PrimitiveBatch.cs.

        {
            if (graphicsDevice == null)
            {
                throw new ArgumentNullException("graphicsDevice");
            }

            device = graphicsDevice;

            // create a vertex declaration, which tells the graphics card what kind of
            // data to expect during a draw call. We're drawing using
            // VertexPositionColors, so we'll use those vertex elements.
            vertexDeclaration = new VertexDeclaration(graphicsDevice,
                VertexPositionColor.VertexElements);

            // set up a new basic effect, and enable vertex colors.
            basicEffect = new BasicEffect(graphicsDevice, null);
            basicEffect.VertexColorEnabled = true;

            // projection uses CreateOrthographicOffCenter to create 2d projection
            // matrix with 0,0 in the upper left.
            basicEffect.Projection = Matrix.CreateOrthographicOffCenter
                (0, graphicsDevice.Viewport.Width,
                graphicsDevice.Viewport.Height, 0,
                0, 1);
        }

---

Member Function Documentation

void NewGamePhysics.Utilities.PrimitiveBatch.AddVertex	(	Vector2	vertex,
		Color	color
	)

AddVertex is called to add another vertex to be rendered. To draw a point, AddVertex must be called once. for lines, twice, and for triangles 3 times. this function can only be called once begin has been called. if there is not enough room in the vertices buffer, Flush is called automatically.

Parameters:

	vertex	The vertex to add.
	color	The color of this vertex.

Definition at line 193 of file PrimitiveBatch.cs.

        {
            if (!hasBegun)
            {
                throw new InvalidOperationException
                    ("Begin must be called before AddVertex can be called.");
            }

            // are we starting a new primitive? if so, and there will not be enough room
            // for a whole primitive, flush.
            bool newPrimitive = ((positionInBuffer % numVertsPerPrimitive) == 0);

            if (newPrimitive &&
                (positionInBuffer + numVertsPerPrimitive) >= vertices.Length)
            {
                Flush();
            }

            // once we know there's enough room, set the vertex in the buffer,
            // and increase position.
            vertices[positionInBuffer].Position = new Vector3(vertex, 0);
            vertices[positionInBuffer].Color = color;

            positionInBuffer++;
        }

void NewGamePhysics.Utilities.PrimitiveBatch.Begin

(

PrimitiveType

primitiveType

)

Begin is called to tell the PrimitiveBatch what kind of primitives will be drawn, and to prepare the graphics card to render those primitives.

Parameters:

primitiveType

The primitive types to draw.

Definition at line 150 of file PrimitiveBatch.cs.

        {
            if (hasBegun)
            {
                throw new InvalidOperationException
                    ("End must be called before Begin can be called again.");
            }

            // these three types reuse vertices, so we can't flush properly without more
            // complex logic.
            if (primitiveType == PrimitiveType.LineStrip ||
                primitiveType == PrimitiveType.TriangleFan ||
                primitiveType == PrimitiveType.TriangleStrip)
            {
                throw new NotSupportedException
                    ("The specified primitiveType is not supported by PrimitiveBatch.");
            }

            this.primitiveType = primitiveType;

            // how many verts will each of these primitives require?
            this.numVertsPerPrimitive = NumVertsPerPrimitive(primitiveType);

            // prepare the graphics device for drawing by setting the vertex declaration
            // and telling our basic effect to begin.
            device.VertexDeclaration = vertexDeclaration;
            basicEffect.Begin();
            basicEffect.CurrentTechnique.Passes[0].Begin();

            // flip the error checking boolean. It's now ok to call AddVertex, Flush,
            // and End.
            hasBegun = true;
        }

virtual void NewGamePhysics.Utilities.PrimitiveBatch.Dispose

(

bool

disposing

)

[protected, virtual]

Dispose interface with flag.

Parameters:

disposing

Flag indicating if we are disposing the object.

Definition at line 127 of file PrimitiveBatch.cs.

        {
            if (disposing && !isDisposed)
            {
                if (vertexDeclaration != null)
                {
                    vertexDeclaration.Dispose();
                }

                if (basicEffect != null)
                {
                    basicEffect.Dispose();
                }

                isDisposed = true;
            }
        }

void NewGamePhysics.Utilities.PrimitiveBatch.Dispose

(

)

Dispose interface.

Definition at line 117 of file PrimitiveBatch.cs.

        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

void NewGamePhysics.Utilities.PrimitiveBatch.End

(

)

End is called once all the primitives have been drawn using AddVertex. it will call Flush to actually submit the draw call to the graphics card, and then tell the basic effect to end.

Definition at line 224 of file PrimitiveBatch.cs.

        {
            if (!hasBegun)
            {
                throw new InvalidOperationException
                    ("Begin must be called before End can be called.");
            }

            // Draw whatever the user wanted us to draw
            Flush();

            // and then tell basic effect that we're done.
            basicEffect.CurrentTechnique.Passes[0].End();
            basicEffect.End();
            hasBegun = false;
        }

---

The documentation for this class was generated from the following file:

• C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Utilities/PrimitiveBatch.cs