public static void Draw(VertexPositionColor[] Points, Texture2D Texture)
{
//PUT IN DRAW CODE FOR PARTICLES HERE
mGraphics.Peek.Device().RenderState.PointSpriteEnable = true;
mGraphics.Peek.ToggleAlphaBlending(true);
mGraphics.Peek.Device().RenderState.DepthBufferWriteEnable = false;
mGraphics.Peek.Device().VertexDeclaration = mGraphics.Peek.vdPositionColor;
mEffect.Peek.PointEffect().Parameters["WVPMatrix"].SetValue(Matrix.Identity * mCamera.Peek.ReturnCamera().View * mCamera.Peek.ReturnCamera().Projection);
mEffect.Peek.PointEffect().Parameters["SpriteTexture"].SetValue(Texture);
mEffect.Peek.PointEffect().Parameters["ViewportHeight"].SetValue(mGraphics.Peek.Device().Viewport.Height);
mEffect.Peek.PointEffect().Parameters["ViewportHeight"].SetValue(25.0f);
mEffect.Peek.PointEffect().Begin();
for (int i = 0; i < mEffect.Peek.PointEffect().CurrentTechnique.Passes.Count; i++)
{
mEffect.Peek.PointEffect().CurrentTechnique.Passes[i].Begin();
mGraphics.Peek.Device().DrawUserPrimitives<VertexPositionColor>(PrimitiveType.PointList, Points, 0, Points.Length);
mEffect.Peek.PointEffect().CurrentTechnique.Passes[i].End();
}
mEffect.Peek.PointEffect().End();
mGraphics.Peek.Device().RenderState.PointSpriteEnable = false;
mGraphics.Peek.Device().RenderState.DepthBufferWriteEnable = true;
mGraphics.Peek.ToggleAlphaBlending(false);
}
public static AABBTree AABBTree(Model model, AABBNodeInfo tree_info)
{
List<TriangleVertexIndices> indices = new List<TriangleVertexIndices>();
List<Vector3> points = new List<Vector3>();
AABBFactory.ExtractData(model, points, indices, true);
VertexPositionColor[] vertices = new VertexPositionColor[indices.Count * 3];
List<float[]> triangles = new List<float[]>();
int i = 0;
foreach (TriangleVertexIndices index in indices)
{
vertices[i++] = new VertexPositionColor(points[index.I0], Color.White);
vertices[i++] = new VertexPositionColor(points[index.I1], Color.White);
vertices[i++] = new VertexPositionColor(points[index.I2], Color.White);
float[] tri = new float[3];
tri[0] = points[index.I0].X;
tri[1] = points[index.I1].Y;
tri[2] = points[index.I2].Z;
triangles.Add(tri);
}
return new AABBTree(triangles, tree_info);
}
public static void DrawBBox(List<BoundingBox> boundingBoxes, Matrix Projection, Matrix View,Matrix localWorld)
{
// Use inside a drawing loop
foreach (BoundingBox box in boundingBoxes)
{
Vector3[] corners = box.GetCorners();
VertexPositionColor[] primitiveList = new VertexPositionColor[corners.Length];
// Assign the 8 box vertices
for (int i = 0; i < corners.Length; i++)
{
primitiveList[i] = new VertexPositionColor(corners[i], Color.White);
}
/* Set your own effect parameters here */
boxEffect.World = localWorld;
boxEffect.View = View;
boxEffect.Projection = Projection;
boxEffect.TextureEnabled = false;
// Draw the box with a LineList
foreach (EffectPass pass in boxEffect.CurrentTechnique.Passes)
{
pass.Apply();
device.DrawUserIndexedPrimitives(
PrimitiveType.LineList, primitiveList, 0, 8,
bBoxIndices, 0, 12);
}
}
}
public WorldAxes()
{
// load our vertices and there color
vertices = new VertexPositionColor[3][];
for (int x = 0; x < 3; x++)
{
vertices[x] = new VertexPositionColor[2];
for (int y = 0; y < 2; y++)
vertices[x][y] = new VertexPositionColor();
}
vertices[0][0].Color = Color.Red;
vertices[0][1].Color = Color.Red;
vertices[1][0].Color = Color.Green;
vertices[1][1].Color = Color.Green;
vertices[2][0].Color = Color.Blue;
vertices[2][1].Color = Color.Blue;
// the first vertex is at the origin
vertices[0][0].Position = Vector3.Zero;
vertices[1][0].Position = Vector3.Zero;
vertices[2][0].Position = Vector3.Zero;
Size = 5;
CreateLines();
}
public ConcavePolygonOutline(Vector3 position, Vector3[] points, Color[] pointColors)
{
throw new NotImplementedException();
VertexPositionColor[] vertices = new VertexPositionColor[points.Length];
for (int index = 0; index < points.Length; index++) {
vertices[index] = new VertexPositionColor(points[index], pointColors[index]);
}
List<VertexPositionColor> concavePoints = new List<VertexPositionColor>();
bool isConcave = ConcavePolygonGeometry.Process(vertices, ref concavePoints);
if (!isConcave) {
IComplex convex = new ConvexPolygonOutline(position, points, pointColors);
this.primitives = convex.Primitives;
this.primitivesCount = convex.PrimitivesCount;
//? throw new InvalidOperationException("Given polygon isn't concave!");
}
else {
this.primitives = new IPrimitive[concavePoints.Count];
this.primitivesCount = this.primitives.Length;
for (int index = 0; index < this.primitivesCount - 1; index++) {
this.primitives[index] = new Line(concavePoints[index].Position + position, concavePoints[index + 1].Position + position, concavePoints[index].Color, concavePoints[index + 1].Color);
}
this.primitives[this.primitivesCount - 1] = new Line(concavePoints[0].Position + position, concavePoints[this.primitivesCount - 1].Position + position, concavePoints[0].Color, concavePoints[this.primitivesCount - 1].Color);
}
}
public static void Draw(this Fixture fixture, GraphicsDevice graphics, Color color, Matrix? matrix = null)
{
VertexPositionColor[] vertices;
switch (fixture.ShapeType)
{
case ShapeType.Polygon:
{
vertices = ((PolygonShape)fixture.Shape).ToVertices(color, matrix);
}
break;
case ShapeType.Circle:
{
CircleShape circle = ((CircleShape)fixture.Shape);
vertices = new VertexPositionColor[]
{
new VertexPositionColor(new Vector3(Vector2.Transform(Vector2.Zero, matrix ?? Matrix.Identity), 0.0f), color),
new VertexPositionColor(new Vector3(Vector2.Transform(new Vector2(circle.Radius), matrix ?? Matrix.Identity), 0.0f), color)
};
}
break;
default: throw new InvalidOperationException(String.Format("Unable to render ShapeType {0}", fixture.ShapeType));
}
graphics.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineStrip, vertices, 0, vertices.Length - 1);
}
/// <summary>
/// Change the colour of an existing list of type VertexPositionColor
/// </summary>
/// <param name="pointList">Array of points</param>
/// <param name="colour">The colour e.g. Color.White or Color.Red</param>
public void ChangeColour(ref VertexPositionColor[] pointList, Color colour)
{
for (int i = 0; i < pointList.Length; i++)
{
pointList[i].Color = colour;
}
}
public override void Initialize()
{
Sommets1 = new VertexPositionColor[NB_SOMMETS];
Sommets2 = new VertexPositionColor[NB_SOMMETS];
PositionsSommets = new Vector3[NB_POSITIONS_SOMMETS];
base.Initialize();
}
public static void DrawBoundingBox(BoundingBox bBox, GraphicsDevice device, BasicEffect basicEffect, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix)
{
Vector3 v1 = bBox.Min;
Vector3 v2 = bBox.Max;
VertexPositionColor[] cubeLineVertices = new VertexPositionColor[8];
cubeLineVertices[0] = new VertexPositionColor(v1, Color.White);
cubeLineVertices[1] = new VertexPositionColor(new Vector3(v2.X, v1.Y, v1.Z), Color.Red);
cubeLineVertices[2] = new VertexPositionColor(new Vector3(v2.X, v1.Y, v2.Z), Color.Green);
cubeLineVertices[3] = new VertexPositionColor(new Vector3(v1.X, v1.Y, v2.Z), Color.Blue);
cubeLineVertices[4] = new VertexPositionColor(new Vector3(v1.X, v2.Y, v1.Z), Color.White);
cubeLineVertices[5] = new VertexPositionColor(new Vector3(v2.X, v2.Y, v1.Z), Color.Red);
cubeLineVertices[6] = new VertexPositionColor(v2, Color.Green);
cubeLineVertices[7] = new VertexPositionColor(new Vector3(v1.X, v2.Y, v2.Z), Color.Blue);
short[] cubeLineIndices = { 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 };
basicEffect.World = worldMatrix;
basicEffect.View = viewMatrix;
basicEffect.Projection = projectionMatrix;
basicEffect.VertexColorEnabled = true;
device.RasterizerState = _solidRasterizer;
foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
{
pass.Apply();
device.DrawUserIndexedPrimitives<VertexPositionColor>(PrimitiveType.LineList, cubeLineVertices, 0, 8, cubeLineIndices, 0, 12);
}
}
public static void DrawSphereSpikes(BoundingSphere sphere, GraphicsDevice device, BasicEffect basicEffect, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix)
{
Vector3 up = sphere.Center + sphere.Radius * Vector3.Up;
Vector3 down = sphere.Center + sphere.Radius * Vector3.Down;
Vector3 right = sphere.Center + sphere.Radius * Vector3.Right;
Vector3 left = sphere.Center + sphere.Radius * Vector3.Left;
Vector3 forward = sphere.Center + sphere.Radius * Vector3.Forward;
Vector3 back = sphere.Center + sphere.Radius * Vector3.Backward;
VertexPositionColor[] sphereLineVertices = new VertexPositionColor[6];
sphereLineVertices[0] = new VertexPositionColor(up, Color.White);
sphereLineVertices[1] = new VertexPositionColor(down, Color.White);
sphereLineVertices[2] = new VertexPositionColor(left, Color.White);
sphereLineVertices[3] = new VertexPositionColor(right, Color.White);
sphereLineVertices[4] = new VertexPositionColor(forward, Color.White);
sphereLineVertices[5] = new VertexPositionColor(back, Color.White);
basicEffect.World = worldMatrix;
basicEffect.View = viewMatrix;
basicEffect.Projection = projectionMatrix;
basicEffect.VertexColorEnabled = true;
foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
{
pass.Apply();
// device.VertexDeclaration = new VertexDeclaration(device, VertexPositionColor.VertexElements);
device.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, sphereLineVertices, 0, 3);
}
}
private unsafe void StartDrawing(VertexFragment vertexFragment, out VertexPositionColor* vertices, out VertexPositionNormalTexture* textures, out short* indices, out short baseIndex)
{
textures = null;
if (vertexFragment.PrimitiveType == PrimitiveType.LineList)
{
if ((this.SortMode == DrawingSortMode.Order) && (this._triangleVertexCount > 0))
{
Flush();
StartLineDrawing(vertexFragment, out vertices, out indices, out baseIndex);
}
else
{
StartLineDrawing(vertexFragment, out vertices, out indices, out baseIndex);
}
}
else if (vertexFragment.PrimitiveType == PrimitiveType.TriangleList)
{
if ((this.SortMode == DrawingSortMode.Order) && (this._lineVertexCount > 0))
{
Flush();
StartTriangleDrawing(vertexFragment, out vertices, out textures, out indices, out baseIndex);
}
else
{
StartTriangleDrawing(vertexFragment, out vertices, out textures, out indices, out baseIndex);
}
}
else
{
throw new NotSupportedException(string.Format("PrimitiveType: {0} is not supported.", vertexFragment.PrimitiveType));
}
}
public static void DebugDrawPolyline(DebugDrawContext context, params Vector2[] vertices)
{
var vertexData = new VertexPositionColor[vertices.Length];
for (int i = 0; i < vertices.Length; i++)
vertexData[i] = new VertexPositionColor(new Vector3(vertices[i], DEBUG_DRAW_Z), context.Color);
DebugDraw(context, vertexData, PrimitiveType.LineStrip);
}
public static void RenderVertexPositionColorList(GraphicsDevice gd,
BasicEffect effect, Matrix world, Matrix view, Matrix proj,
VertexPositionColor[] vertices, VertexDeclaration vertexDeclaration,
VertexBuffer vertex_buffer)
{
// gd.VertexDeclaration = vertexDeclaration;
effect.World = world;
effect.View = view;
effect.Projection = proj;
effect.VertexColorEnabled = true;
if (vertex_buffer == null)
{
vertex_buffer = new VertexBuffer(gd, typeof(VertexPositionColor), vertices.Length, BufferUsage.WriteOnly);
vertex_buffer.SetData<VertexPositionColor>(vertices);
}
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
gd.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, vertices, 0, vertices.Length / 3);
}
}
public static VertexPositionColor[] GetVerticesFromBounds(BoundingBox bounds, Color hitboxColor)
{
Vector3[] corners = bounds.GetCorners();
VertexPositionColor[] debugVerts = new VertexPositionColor[24];
debugVerts[0] = new VertexPositionColor(corners[0], hitboxColor);
debugVerts[1] = new VertexPositionColor(corners[1], hitboxColor);
debugVerts[2] = new VertexPositionColor(corners[1], hitboxColor);
debugVerts[3] = new VertexPositionColor(corners[5], hitboxColor);
debugVerts[4] = new VertexPositionColor(corners[5], hitboxColor);
debugVerts[5] = new VertexPositionColor(corners[4], hitboxColor);
debugVerts[6] = new VertexPositionColor(corners[4], hitboxColor);
debugVerts[7] = new VertexPositionColor(corners[0], hitboxColor);
debugVerts[8] = new VertexPositionColor(corners[3], hitboxColor);
debugVerts[9] = new VertexPositionColor(corners[2], hitboxColor);
debugVerts[10] = new VertexPositionColor(corners[2], hitboxColor);
debugVerts[11] = new VertexPositionColor(corners[6], hitboxColor);
debugVerts[12] = new VertexPositionColor(corners[6], hitboxColor);
debugVerts[13] = new VertexPositionColor(corners[7], hitboxColor);
debugVerts[14] = new VertexPositionColor(corners[7], hitboxColor);
debugVerts[15] = new VertexPositionColor(corners[3], hitboxColor);
debugVerts[16] = new VertexPositionColor(corners[3], hitboxColor);
debugVerts[17] = new VertexPositionColor(corners[0], hitboxColor);
debugVerts[18] = new VertexPositionColor(corners[2], hitboxColor);
debugVerts[19] = new VertexPositionColor(corners[1], hitboxColor);
debugVerts[20] = new VertexPositionColor(corners[6], hitboxColor);
debugVerts[21] = new VertexPositionColor(corners[5], hitboxColor);
debugVerts[22] = new VertexPositionColor(corners[7], hitboxColor);
debugVerts[23] = new VertexPositionColor(corners[4], hitboxColor);
return debugVerts;
}
/// <summary>
/// Add a Line
/// You cant remove it
/// </summary>
/// <param name="StartPoint">The start point.</param>
/// <param name="EndPoint">The end point.</param>
/// <param name="color">The box's color.</param>
public void AddLine(Vector3 StartPoint, Vector3 EndPoint, Color color)
{
VertexPositionColor vp1 = new VertexPositionColor(StartPoint, color);
VertexPositionColor vp2 = new VertexPositionColor(EndPoint, color);
verts.Add(vp1);
verts.Add(vp2);
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
zNear = 0.001f;
zFar = 1000.0f;
fov = MathHelper.Pi * 70.0f / 180.0f;
eye = new Vector3(0.0f, 0.7f, 1.5f);
at = new Vector3(0.0f, 0.0f, 0.0f);
up = new Vector3(0.0f, 1.0f, 0.0f);
cube = new VertexPositionColor[8];
cube[0] = new VertexPositionColor(new Vector3(-0.5f, -0.5f, -0.5f), new Color(0.0f, 0.0f, 0.0f));
cube[1] = new VertexPositionColor(new Vector3(-0.5f, -0.5f, 0.5f), new Color(0.0f, 0.0f, 1.0f));
cube[2] = new VertexPositionColor(new Vector3(-0.5f, 0.5f, -0.5f), new Color(0.0f, 1.0f, 0.0f));
cube[3] = new VertexPositionColor(new Vector3(-0.5f, 0.5f, 0.5f), new Color(0.0f, 1.0f, 1.0f));
cube[4] = new VertexPositionColor(new Vector3( 0.5f, -0.5f, -0.5f), new Color(1.0f, 0.0f, 0.0f));
cube[5] = new VertexPositionColor(new Vector3( 0.5f, -0.5f, 0.5f), new Color(1.0f, 0.0f, 1.0f));
cube[6] = new VertexPositionColor(new Vector3( 0.5f, 0.5f, -0.5f), new Color(1.0f, 1.0f, 0.0f));
cube[7] = new VertexPositionColor(new Vector3( 0.5f, 0.5f, 0.5f), new Color(1.0f, 1.0f, 1.0f));
vertexBuffer = new DynamicVertexBuffer(graphics.GraphicsDevice, typeof(VertexPositionColor), 8, BufferUsage.WriteOnly);
indexBuffer = new DynamicIndexBuffer(graphics.GraphicsDevice, typeof(ushort), 36, BufferUsage.WriteOnly);
basicEffect = new BasicEffect(graphics.GraphicsDevice); //(device, null);
basicEffect.LightingEnabled = false;
basicEffect.VertexColorEnabled = true;
basicEffect.TextureEnabled = false;
graphics.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;
base.Initialize();
}
public override void Initialize()
{
int widthNum = this.witdth / Map.GridWidth;
int heightNum = this.heigh / Map.GridWidth;
this.pointMatrics = new VertexPositionColor[heightNum][];
for (int row = 0; row < heightNum; row++)
{
VertexPositionColor[] temp = new VertexPositionColor[widthNum * 2 + 2];
for (int col = 0; col <= widthNum; col++)
{
temp[col * 2].Position = new Vector3(this.start.X + (Map.GridWidth * col),
this.start.Y + (this.start.Y + Map.GridWidth * row) ,
this.start.Z);
temp[col * 2 + 1].Position = new Vector3(this.start.X + (Map.GridWidth * col),
this.start.Y + (this.start.Y + Map.GridWidth * row) + Map.GridWidth,
this.start.Z);
temp[col * 2].Color = Map.DefaultColor;
temp[col * 2 + 1].Color = Map.DefaultColor;
}
this.pointMatrics[row] = temp;
}
base.Initialize();
}
public void DrawDebugWorld(DynamicsWorld world)
{
world.DebugDrawWorld();
if (lines.Count == 0)
return;
if (effect == null)
{
effect = new BasicEffect(graphics.Device);
effect.World = Microsoft.Xna.Framework.Matrix.Identity;
effect.VertexColorEnabled = true;
pass = effect.CurrentTechnique.Passes[0];
}
effect.Projection = graphics.GetEffect().Projection;
effect.View = graphics.GetEffect().View;
pass.Apply();
int pointCount = lines.Count;
int linesCount = pointCount / 2;
VertexPositionColor[] linesArray = new VertexPositionColor[pointCount];
for (int i = 0; i < pointCount; i++)
{
int color = lines[i].Color;
linesArray[i].Color = new Color(color & 0xff, (color & 0xff00) >> 8, (color & 0xff0000) >> 16, 1);
linesArray[i].Position = MathHelper.Convert(lines[i].Position);
}
graphics.Device.DrawUserPrimitives(PrimitiveType.LineList, linesArray, 0, linesCount);
lines.Clear();
}
public static void InitializeGraphics(GraphicsDevice graphicsDevice,
Triangle[] triangles,
Guid id)
{
var basicEffect = new BasicEffect(graphicsDevice)
{
LightingEnabled = false,
VertexColorEnabled = false
};
var index = 0;
var vertices = new VertexPositionColor[triangles.SelectMany(i => i.Points).Count()];
foreach (var point in triangles.SelectMany(triangle => triangle.Points))
vertices[index++] = new VertexPositionColor(new Vector3(point.X,
point.Y,
point.Z),
Color.White);
var vertexBuffer = new VertexBuffer(graphicsDevice,
typeof (VertexPositionColor),
vertices.Length,
BufferUsage.None);
vertexBuffer.SetData(vertices);
Subscriptions.Add(id, new RendererHelperData
{
BasicEffect = basicEffect,
VertexBuffer = vertexBuffer
});
}
private ReferenceAxis()
{
vertices = new VertexPositionColor[3][];
for (int x = 0; x < 3; x++)
{
vertices[x] = new VertexPositionColor[2];
for (int y = 0; y < 2; y++)
vertices[x][y] = new VertexPositionColor();
}
vertices[0][0].Color = Color.Red;
vertices[0][1].Color = Color.Red;
vertices[1][0].Color = Color.Green;
vertices[1][1].Color = Color.Green;
vertices[2][0].Color = Color.Blue;
vertices[2][1].Color = Color.Blue;
// the first vertex is at the origin
vertices[0][0].Position = Vector3.Zero;
vertices[1][0].Position = Vector3.Zero;
vertices[2][0].Position = Vector3.Zero;
Size = 10;
CreateLines();
}
public Earth()
{
Sun = Game.Sun;
Rotation = 0;
RotationInFastSpeed = 0;
RotationAxisPointList = new VertexPositionColor[2];
// vernal equinox
RevolutionBasis = new Vector3(0, 0, -RevolutionRadius);
Scale = Matrix.CreateScale(new Vector3(Radius, Radius, Radius));
BasicEffect = new BasicEffect(Game.GraphicsDevice);
InitLineStrip();
InitRevPointList();
BasicEffect.VertexColorEnabled = true;
BasicEffect.World = Matrix.Identity;
// up
Up = Vector3.Transform(Vector3.Up, Matrix.CreateRotationZ(EclipticObliquity));
Up.Normalize();
// rotation axis
RotationAxis = Up * Radius * 7f;
}
private void InitVertices()
{
vertices = new VertexPositionColor[30];
vertices[0] = new VertexPositionColor(new Vector3(0, 0, 0), Color.White);
vertices[1] = new VertexPositionColor(Vector3.Right * 5, Color.White);
vertices[2] = new VertexPositionColor(new Vector3(5, 0, 0), Color.White);
vertices[3] = new VertexPositionColor(new Vector3(4.5f, 0.5f, 0), Color.White);
vertices[4] = new VertexPositionColor(new Vector3(5, 0, 0), Color.White);
vertices[5] = new VertexPositionColor(new Vector3(4.5f, -0.5f, 0), Color.White);
vertices[6] = new VertexPositionColor(new Vector3(0, 0, 0), Color.White);
vertices[7] = new VertexPositionColor(Vector3.Up * 5, Color.White);
vertices[8] = new VertexPositionColor(new Vector3(0, 5, 0), Color.White);
vertices[9] = new VertexPositionColor(new Vector3(0.5f, 4.5f, 0), Color.White);
vertices[10] = new VertexPositionColor(new Vector3(0, 5, 0), Color.White);
vertices[11] = new VertexPositionColor(new Vector3(-0.5f, 4.5f, 0), Color.White);
vertices[12] = new VertexPositionColor(new Vector3(0, 0, 0), Color.White);
vertices[13] = new VertexPositionColor(-Vector3.Forward * 5, Color.White);
vertices[14] = new VertexPositionColor(new Vector3(0, 0, 5), Color.White);
vertices[15] = new VertexPositionColor(new Vector3(0, 0.5f, 4.5f), Color.White);
vertices[16] = new VertexPositionColor(new Vector3(0, 0, 5), Color.White);
vertices[17] = new VertexPositionColor(new Vector3(0, -0.5f, 4.5f), Color.White);
}
public ControlTriangle(ControlEdge edge1, ControlEdge edge2, ControlEdge edge3)
: this()
{
List<Vector3> temp = new List<Vector3>();
if (!temp.Contains(edge1.FirstVertex))
temp.Add(edge1.FirstVertex);
if (!temp.Contains(edge1.SecondVertex))
temp.Add(edge1.SecondVertex);
if (!temp.Contains(edge2.FirstVertex))
temp.Add(edge2.FirstVertex);
if (!temp.Contains(edge2.SecondVertex))
temp.Add(edge2.SecondVertex);
if (!temp.Contains(edge3.FirstVertex))
temp.Add(edge3.FirstVertex);
if (!temp.Contains(edge3.SecondVertex))
temp.Add(edge3.SecondVertex);
FirstVertex = temp[0];
SecondVertex = temp[1];
ThirdVertex = temp[2];
_vertexData[0] = new VertexPositionColor(FirstVertex, Color.White);
_vertexData[1] = new VertexPositionColor(SecondVertex, Color.White);
_vertexData[2] = new VertexPositionColor(ThirdVertex, Color.White);
}
public CollisionElement(GraphicsDevice device)
{
_texture = new Texture2D(device, 1, 1);
_texture.SetData(new Color[]{ Color.White });
BoxCoords = new Rectangle();
TriangleCoords = new VertexPositionColor[3];
}
public void Draw(GraphicsDevice device, Matrix view, Matrix projection, SpriteBatch batch, SpriteFont font)
{
vertices[0] = new VertexPositionColor(from, color);
vertices[1] = new VertexPositionColor(to, color);
Vector3 delt = Vector3.Multiply(Vector3.Subtract(to, from), 0.1f);
Vector3 perp = Vector3.Cross(Vector3.Forward, delt);
Vector3 arrowBase = Vector3.Subtract(to, delt);
vertices[2] = new VertexPositionColor(Vector3.Add(arrowBase, perp), color);
vertices[3] = new VertexPositionColor(to, color);
vertices[4] = new VertexPositionColor(Vector3.Subtract(arrowBase, perp), color);
vertices[5] = new VertexPositionColor(to, color);
effect.World = Matrix.Identity;
effect.View = view;
effect.Projection = projection;
effect.VertexColorEnabled = true;
effect.LightingEnabled = false;
for (int i = 0; i < effect.CurrentTechnique.Passes.Count; ++i)
{
effect.CurrentTechnique.Passes[i].Apply();
device.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, vertices, 0, 3);
}
Vector3 txtPos = device.Viewport.Project(Vector3.Lerp(from, to, 0.5f), projection, view, Matrix.Identity);
Console.WriteLine(txtPos.ToString());
batch.DrawString(font, text, new Vector2(txtPos.X + 20, txtPos.Y - 10), color);
}
public void Draw(GameTime gameTime, BoundingFrustum VisibleArea)
{
if (units.Count > 0)
{
VertexPositionColor[] display = new VertexPositionColor[units.Count * 2];
int[] pointIndex = new int[units.Count];
for (int i = 0; i < units.Count; i++)
{
display[i * 2] = new VertexPositionColor(units[i].Position, DisplayColor);
pointIndex[i] = i * 2;
if (units[i].Target != null)
{
display[i * 2 + 1] = new VertexPositionColor(units[i].Target.Position, DisplayColor);
}
else
{
display[i * 2 + 1] = display[i * 2];
}
}
Manager.ResetFor3D();
MyGame.graphics.GraphicsDevice.VertexDeclaration = UnitDeclaration;
MyGame.graphics.GraphicsDevice.RenderState.PointSize = 5.0f;
Manager.OrdinaryEffect.CurrentTechnique = Manager.OrdinaryEffect.Techniques["Ordinary"];
Manager.OrdinaryEffect.Parameters["World"].SetValue(Matrix.Identity);
Manager.OrdinaryEffect.Begin();
Manager.OrdinaryEffect.CurrentTechnique.Passes.First<EffectPass>().Begin();
MyGame.graphics.GraphicsDevice.DrawUserPrimitives<VertexPositionColor>(PrimitiveType.LineList, display, 0, display.Length / 2);
MyGame.graphics.GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(PrimitiveType.PointList, display, 0, display.Length
, pointIndex, 0, pointIndex.Length);
Manager.OrdinaryEffect.CurrentTechnique.Passes.First<EffectPass>().End();
Manager.OrdinaryEffect.End();
}
}
public VariableVertexes(Vector3 position, float size, int nLados)
{
this.nLados = nLados;
vertexes = new VertexPositionColor[10];
float graus = 0;
float step = MathHelper.ToRadians(360 / nLados);
Vector3 topo = new Vector3(0, 1, 0);
Vector3 v0 = new Vector3(1, 0, 0);
Vector3 v1 = topo;
Vector3 v2 = new Vector3(0, 0, -1);
Vector3 v3 = topo;
Vector3 v4 = new Vector3(-1, 0, 0);
Vector3 v5 = topo;
Vector3 v6 = new Vector3(0, 0, 1);
Vector3 v7 = topo;
Vector3 v8 = v0;
Vector3 v9 = topo;
vertexes[0] = new VertexPositionColor(v0, Color.Red);
vertexes[1] = new VertexPositionColor(v1, Color.Red);
vertexes[2] = new VertexPositionColor(v2, Color.Red);
vertexes[3] = new VertexPositionColor(v3, Color.Green);
vertexes[4] = new VertexPositionColor(v4, Color.Green);
vertexes[5] = new VertexPositionColor(v5, Color.Green);
vertexes[6] = new VertexPositionColor(v6, Color.Blue);
vertexes[7] = new VertexPositionColor(v7, Color.Blue);
vertexes[8] = new VertexPositionColor(v8, Color.Blue);
vertexes[9] = new VertexPositionColor(v9, Color.Blue);
}
public PyramidIndices()
{
vertexes = new VertexPositionColor[5];
vertexes[0] = new VertexPositionColor(new Vector3(1, 0, 0), Color.Red);
vertexes[1] = new VertexPositionColor(new Vector3(0, 0, -1), Color.Red);
vertexes[2] = new VertexPositionColor(new Vector3(-1, 0, 0), Color.Red);
vertexes[3] = new VertexPositionColor(new Vector3(0, 0, 1), Color.Red);
vertexes[4] = new VertexPositionColor(new Vector3(0, 1, 0), Color.Red);
indices = new short[9];
indices[0] = 0;
indices[1] = 4;
indices[2] = 1;
indices[3] = 4;
indices[4] = 2;
indices[5] = 4;
indices[6] = 3;
indices[7] = 4;
indices[8] = 0;
/*
Gerar estes indices programaticamente:
for(int i = 0; i <= n; i++){
ind[2i] = (i % n);
ind[2i+1] = 4
}
*/
}
public void Draw(
ref BoundingFrustum boundingFrustum,
Effect effect,
ref Color vertexColor)
{
var coners = boundingFrustum.GetCorners();
var vertices = new VertexPositionColor[8];
for (int i = 0; i < 8; i++)
{
vertices[i].Position = coners[i];
vertices[i].Color = vertexColor;
}
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
graphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
PrimitiveType.LineList,
vertices,
0,
8,
indices,
0,
primitiveCount);
}
}
public TerrainModel(ContentManager content, string heightMapTexture, float scale, Vector3 position, Matrix rotation)
{
this.Scale = scale;
this.Position = position;
this.Rotation = rotation;
Texture2D textureTemp = content.Load<Texture2D>(heightMapTexture);
_nCols = textureTemp.Width - 1;
_nRows = textureTemp.Height - 1;
Color[] textureColors = new Color[textureTemp.Width * textureTemp.Height];
textureTemp.GetData(textureColors);
_nVetices = _nCols * _nRows * 6;
_Vetices = new VertexPositionColor[_nVetices];
/*
* --------->x
* A---B |
* | | |
* D---C |
* y
*/
for (int x = 0; x < textureTemp.Height; x++)
for (int z = 0; z < textureTemp.Width; z++)
{
_Vetices[x*z + 1] = new VertexPositionColor(new Vector3(x, textureColors[x * textureTemp.Height + z * textureTemp.Width].R/6, z), Color.White); // A
_Vetices[x * z + 1] = new VertexPositionColor(new Vector3(x + 1, textureColors[(x + 1)* textureTemp.Height + textureTemp.Width].R / 6, z), Color.White); //B
_Vetices[x * z + 1] = new VertexPositionColor(new Vector3(x, textureColors[x * textureTemp.Height + textureTemp.Width].R / 6, z), Color.White); //C
_Vetices[x * z + 1] = new VertexPositionColor(new Vector3(x, textureColors[x * textureTemp.Height + textureTemp.Width].R / 6, z), Color.White);
_Vetices[x * z + 1] = new VertexPositionColor(new Vector3(x, textureColors[x * textureTemp.Height + textureTemp.Width].R / 6, z), Color.White);
_Vetices[x * z + 1] = new VertexPositionColor(new Vector3(x, textureColors[x * textureTemp.Height + textureTemp.Width].R / 6, z), Color.White);
}
}
public void TestSelectWithoutIndices()
{
using (Creator creator = new Creator()) {
TestVertex[] vertices = new TestVertex[9];
creator.BatchDrawer.Select(vertices, 9);
}
}
public void TestSelectMultipleWithoutIndices()
{
using (Creator creator = new Creator()) {
TestVertex[] vertices = new TestVertex[9];
// This will cause the drawer to run out of buffer segments and cause
// a discarding lock on the buffers
for (int index = 0; index < 8; ++index)
{
creator.BatchDrawer.Select(vertices, 9);
}
}
}
public void TestDrawWithoutIndices()
{
using (Creator creator = new Creator()) {
TestVertex[] vertices = new TestVertex[9];
creator.BatchDrawer.Select(vertices, 9);
creator.BatchDrawer.Draw(
0, 9,
PrimitiveType.TriangleList,
new BasicEffectDrawContext(creator.GraphicsDevice)
);
}
}
public static unsafe void _PrepareRing(ref Internal.VertexBuffer <GeometryVertex> vb, ref Internal.IndexBuffer ib, ref GeometryDrawCall dc)
{
int numPoints = ComputeRingPoints(ref dc.Vector2);
const int vertexStride = 2;
const int indexStride = 6;
var vw = vb.GetWriter(numPoints * vertexStride);
var iw = ib.GetWriter((numPoints - 1) * indexStride, ref vw);
float a = dc.Scalar0;
float step = (float)((dc.Scalar1 - dc.Scalar0) / (numPoints - 1));
float cos, sin;
float colorA = 0, colorStep = 1.0f / (numPoints - 1);
var vertexInner = new GeometryVertex(new Vector3(0, 0, dc.Z), dc.Color0);
var vertexOuter = new GeometryVertex(new Vector3(0, 0, dc.Z), dc.Color1);
fixed(GeometryVertex *pVertices = &vw.Storage.Array[vw.Storage.Offset])
fixed(ushort *pIndices = &iw.Storage.Array[iw.Storage.Offset])
for (int i = 0, j = 0, k = 0; i < numPoints; i++, j += vertexStride, k += indexStride)
{
cos = (float)Math.Cos(a);
sin = (float)Math.Sin(a);
vertexInner.Position.X = dc.Vector0.X + (float)(cos * dc.Vector1.X);
vertexInner.Position.Y = dc.Vector0.Y + (float)(sin * dc.Vector1.Y);
vertexInner.Color = Color.Lerp(dc.Color0, dc.Color2, colorA);
pVertices[j] = vertexInner;
vertexOuter.Position.X = dc.Vector0.X + (float)(cos * dc.Vector2.X);
vertexOuter.Position.Y = dc.Vector0.Y + (float)(sin * dc.Vector2.Y);
vertexOuter.Color = Color.Lerp(dc.Color1, dc.Color3, colorA);
pVertices[j + 1] = vertexOuter;
if (i == (numPoints - 1))
{
break;
}
pIndices[k] = (ushort)(j + vw.IndexOffset);
pIndices[k + 1] = (ushort)(j + 1 + vw.IndexOffset);
pIndices[k + 2] = (ushort)(j + 3 + vw.IndexOffset);
pIndices[k + 3] = (ushort)(j + 2 + vw.IndexOffset);
pIndices[k + 4] = (ushort)(j + vw.IndexOffset);
pIndices[k + 5] = (ushort)(j + 3 + vw.IndexOffset);
a += step;
colorA += colorStep;
}
}
/// <summary>Static constructor that initializes the test vertex array</summary>
static QueuerTest()
{
const int TestVertexCount = 64;
TestVertices = new TestVertex[TestVertexCount];
TestIndices = new short[TestVertexCount];
for (int index = 0; index < TestVertexCount; ++index)
{
TestVertices[index] = new TestVertex(
new Vector3((float)index, (float)index, (float)index), Color.White
);
TestIndices[index] = (short)(index + 2);
}
}
protected static void _PrepareQuadBorder(ref Internal.VertexBuffer <GeometryVertex> vb, ref Internal.IndexBuffer ib, ref GeometryDrawCall dc)
{
var vw = vb.GetWriter(8);
var iw = ib.GetWriter(QuadBorderIndices.Length, ref vw);
var tl = dc.Vector0;
var br = dc.Vector1;
var border = dc.Scalar0;
var vInner = new GeometryVertex(new Vector3(tl.X, tl.Y, dc.Z), dc.Color0);
var vOuter = new GeometryVertex(new Vector3(tl.X - border, tl.Y - border, dc.Z), dc.Color1);
vw.Write(ref vInner);
vw.Write(ref vOuter);
vInner.Position.X = br.X;
vOuter.Position.X = br.X + border;
vw.Write(ref vInner);
vw.Write(ref vOuter);
vInner.Position.Y = br.Y;
vOuter.Position.Y = br.Y + border;
vw.Write(ref vInner);
vw.Write(ref vOuter);
vInner.Position.X = tl.X;
vOuter.Position.X = tl.X - border;
vw.Write(ref vInner);
vw.Write(ref vOuter);
iw.Write(QuadBorderIndices);
}
