Erstellen Sie ein 2D-polygon in XNA

Hier ist es, was ich jetzt haben.

Einer Klasse, erzeugt eine BasicEffect mit einigen gewünschten asignments.

public class StandardBasicEffect : BasicEffect
{
    public StandardBasicEffect(GraphicsDevice graphicsDevice)
        : base(graphicsDevice)
    {
        this.VertexColorEnabled = true;
        this.Projection = Matrix.CreateOrthographicOffCenter(
            0, graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height, 0, 0, 1);
    }

    public StandardBasicEffect(BasicEffect effect)
        : base(effect) { }

    public BasicEffect Clone()
    {
        return new StandardBasicEffect(this);
    }
}

Hier ist mein PolygonShape Klasse

///<summary>
///A Polygon object that you will be able to draw.
///Animations are being implemented as we speak.
///</summary>
///<param name="graphicsDevice">The graphicsdevice from a Game object</param>
///<param name="vertices">The vertices in a clockwise order</param>
public PolygonShape(GraphicsDevice graphicsDevice, VertexPositionColor[] vertices)
{
    this.graphicsDevice = graphicsDevice;
    this.vertices = vertices;
    this.triangulated = false;

    triangulatedVertices = new VertexPositionColor[vertices.Length * 3];
    indexes = new int[vertices.Length];
}

///<summary>
///Triangulate the set of VertexPositionColors so it will be drawn correcrly        
///</summary>
///<returns>The triangulated vertices array</returns>}
public VertexPositionColor[] Triangulate()
{
    calculateCenterPoint();{
    setupIndexes();
    for (int i = 0; i < indexes.Length; i++)
    {
        setupDrawableTriangle(indexes[i]);
    }

    triangulated = true;
    return triangulatedVertices;
}

///<summary>
///Calculate the center point needed for triangulation.
///The polygon will be irregular, so this isn't the actual center of the polygon
///but it will do for now, as we only need an extra point to make the triangles with</summary>
private void calculateCenterPoint()
{
    float xCount = 0, yCount = 0;

    foreach (VertexPositionColor vertice in vertices)
    {
        xCount += vertice.Position.X;
        yCount += vertice.Position.Y;
    }

    centerPoint = new Vector3(xCount / vertices.Length, yCount / vertices.Length, 0);
}

private void setupIndexes()
{
    for (int i = 1; i < triangulatedVertices.Length; i = i + 3)
    {
        indexes[i / 3] = i - 1;
    }
}

private void setupDrawableTriangle(int index)
{
    triangulatedVertices[index] = vertices[index / 3]; //No DividedByZeroException?...
    if (index / 3 != vertices.Length - 1)
        triangulatedVertices[index + 1] = vertices[(index / 3) + 1];
    else
        triangulatedVertices[index + 1] = vertices[0];
    triangulatedVertices[index + 2].Position = centerPoint;
}

///<summary>
///Draw the polygon. If you haven't called Triangulate yet, I wil do it for you.
///</summary>
///<param name="effect">The BasicEffect needed for drawing</param>
public void Draw(BasicEffect effect)
{
    try
    {
        if (!triangulated)
            Triangulate();

        draw(effect);
    }
    catch (Exception exception)
    {
        throw exception;
    }
}

private void draw(BasicEffect effect)
{
    effect.CurrentTechnique.Passes[0].Apply();
    graphicsDevice.DrawUserPrimitives<VertexPositionColor>(
        PrimitiveType.TriangleList, triangulatedVertices, 0, vertices.Length);
}

Sorry, es ist ein bisschen viel. Nun zu meiner nächsten quest. Animation meine polygon.

Hoffe, es half Mitmenschen mit dem gleichen problem.

InformationsquelleAutor Jordy Langen

Arbeitete ich mit XNA in der Vergangenheit auf eine Physik-simulation, wo ich zu ziehen hatte, um bounding Boxen mit GraphicsDevice.DrawIndexedPrimitives (sollten Sie google oder MSDN für diese Funktion für mehr gelungene Beispiele.)

Den code unten ist das, was ich in meinem Projekt für das zeichnen einer 3D-geometrie.

///<summary>
///Draw the primitive.
///</summary>
///<param name="world">World Matrix</param>
///<param name="view">View Matrix</param>
///<param name="projection">Projection Matrix</param>
///<param name="color">Color of the primitive</param>
public void Draw(Matrix world, Matrix view, Matrix projection, Color color)
{
    _mGraphicsDevice.VertexDeclaration = _mVertexDeclaration;
    _mGraphicsDevice.Vertices[0].SetSource(_mVertexBuffer, 0, VertexPositionNormal.SizeInBytes);
    _mGraphicsDevice.Indices = _mIndexBuffer;

    _mBasicEffect.DiffuseColor = color.ToVector3();
    _mBasicEffect.World = _mTransform * world;
    _mBasicEffect.View = view;
    _mBasicEffect.Projection = projection;

    int primitiveCount = _mIndex.Count / 3;

    _mBasicEffect.Begin();
    foreach (EffectPass pass in _mBasicEffect.CurrentTechnique.Passes)
    {
        pass.Begin();
        _mGraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, _mVertex.Count, 0, primitiveCount);
        pass.End();
    }
    _mBasicEffect.End();
}

Diese Funktion ist eine member-Methode eines geometrie-Objekt (class) und wird aufgerufen, aus dem Spiel-Klasse' Draw(GameTime) Methode

InformationsquelleAutor Jake