protected override void BuildVerticiesAndIndicies()
{
List<int> indices;
using (LargeObjectPools.IndexListPool.Borrow(out indices))
{
List <WCell.Util.Graphics.Vector3> vertices;
using (LargeObjectPools.Vector3ListPool.Borrow(out vertices))
{
indices.Clear();
vertices.Clear();
var tempVertices = new List<VertexPositionNormalColored>();
tile.GenerateLiquidMesh(indices, vertices);
if (vertices.Count == 0) return;
foreach (var vertex in vertices)
{
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(),
WaterColor,
Vector3.Zero);
tempVertices.Add(vertexPosNmlCol);
}
_cachedIndices = indices.ToArray();
_cachedVertices = tempVertices.ToArray();
}
}
_renderCached = true;
}
protected override void BuildVerticiesAndIndicies()
{
var viewer = (TerrainViewer) Game;
var tile = viewer.Tile;
List<int> indices;
using (LargeObjectPools.IndexListPool.Borrow(out indices))
{
List <WCell.Util.Graphics.Vector3> vertices;
using (LargeObjectPools.Vector3ListPool.Borrow(out vertices))
{
var tempVertices = new List<VertexPositionNormalColored>();
tile.GenerateLiquidMesh(indices, vertices);
if (vertices != null)
{
for (var v = 0; v < vertices.Count; v++)
{
var vertex = vertices[v];
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(),
WaterColor,
Vector3.Zero);
tempVertices.Add(vertexPosNmlCol);
}
}
_cachedIndices = indices.ToArray();
_cachedVertices = tempVertices.ToArray();
}
}
_renderCached = true;
}
protected override bool BuildPolyVerticiesAndIndicies()
{
List <Vector3> vertices;
List <int> indices;
_manager.GetMeshVerticesAndIndices(out vertices, out indices);
if (vertices.Count == 0 || indices.Count == 0)
{
return(false);
}
_cachedPolyVertices = new VertexPositionNormalColored[vertices.Count];
for (var i = 0; i < vertices.Count; i++)
{
_cachedPolyVertices[i] = new VertexPositionNormalColored(vertices[i].ToXna(), MeshPolyColor,
Vector3.Up.ToXna());
PositionUtil.TransformWoWCoordsToXNACoords(ref _cachedPolyVertices[i]);
}
_cachedPolyIndices = new int[indices.Count];
for (int i = 0; i < indices.Count; i++)
{
_cachedPolyIndices[i] = indices[i];
}
RenderPolyCached = true;
return(true);
}
protected override void BuildVerticiesAndIndicies()
{
var tile = Viewer.Tile;
var tempVertices = new List<VertexPositionNormalColored>();
var tempIndicies = new List<int>();
for (var v = 0; v < tile.TerrainVertices.Length; v++)
{
var vertex1 = tile.TerrainVertices[v];
var vertexPosNmlCol1 = new VertexPositionNormalColored(vertex1.ToXna(),
TerrainColor,
Vector3.Zero);
tempVertices.Add(vertexPosNmlCol1);
}
for (var i = 0; i < tile.TerrainIndices.Length; i += 3)
{
var index1 = tile.TerrainIndices[i];
var index2 = tile.TerrainIndices[i+1];
var index3 = tile.TerrainIndices[i+2];
tempIndicies.Add(index1);
tempIndicies.Add(index2);
tempIndicies.Add(index3);
}
_cachedIndices = tempIndicies.ToArray();
_cachedVertices = tempVertices.ToArray();
_renderCached = true;
}
private void BuildVerticiesAndIndicies()
{
// Cycle through each ADT
var tempVertices = new List <VertexPositionNormalColored>();
var tempIndicies = new List <int>();
var offset = 0;
foreach (var adt in _manager.MapTiles)
{
// Handle the ADTs
for (var v = 0; v < adt.TerrainVertices.Count; v++)
{
var vertex = adt.TerrainVertices[v];
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(), TerrainColor,
Microsoft.Xna.Framework.Vector3.Down);
tempVertices.Add(vertexPosNmlCol);
}
for (var i = 0; i < adt.Indices.Count; i++)
{
tempIndicies.Add(adt.Indices[i] + offset);
}
offset = tempVertices.Count;
//if (!DrawLiquids) continue;
for (var v = 0; v < adt.LiquidVertices.Count; v++)
{
var vertex = adt.LiquidVertices[v];
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(), WaterColor,
Microsoft.Xna.Framework.Vector3.Down);
tempVertices.Add(vertexPosNmlCol);
}
for (var i = 0; i < adt.LiquidIndices.Count; i++)
{
tempIndicies.Add(adt.LiquidIndices[i] + offset);
}
offset = tempVertices.Count;
}
_cachedIndices = tempIndicies.ToArray();
_cachedVertices = tempVertices.ToArray();
_renderCached = true;
for (var i = 0; i < _cachedVertices.Length; i++)
{
PositionUtil.TransformWoWCoordsToXNACoords(ref _cachedVertices[i]);
}
}
protected override void BuildVerticiesAndIndicies()
{
_cachedVertices = new VertexPositionNormalColored[_manager.Vertices.Count];
_cachedIndices = new int[_manager.Indices.Count];
for (var i = 0; i < _manager.Vertices.Count; i++)
{
var position = _manager.Vertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref position);
_cachedVertices[i] = new VertexPositionNormalColored(position.ToXna(), SelectedTriangleColor,
Vector3.Up);
}
for (var i = 0; i < _manager.Indices.Count; i++)
{
_cachedIndices[i] = _manager.Indices[i];
}
}
public static int GetVertexSize(VertexFormatBits format)
{
switch (format)
{
case VertexFormatBits.Position: return(VertexPosition.GetSizeInFloats());
case VertexFormatBits.PositionColored:
return(VertexPositionColored.GetSizeInFloats());
case VertexFormatBits.PositionNormal:
return(VertexPositionNormal.GetSizeInFloats());
case VertexFormatBits.PositionNormalColored:
return(VertexPositionNormalColored.GetSizeInFloats());
default: break;
}
return(VertexPosition.GetSizeInFloats());
}
void BuildVerticesAndIndices()
{
_cachedVertices = new VertexPositionNormalColored[environment.RenderingVerticies.Length * 2];
for (var i = 0; i < environment.RenderingVerticies.Length; i++)
{
var vertPosNmlClr = environment.RenderingVerticies[i];
_cachedVertices[i * 2] = new VertexPositionNormalColored(vertPosNmlClr.Position, vertColor,
vertPosNmlClr.Normal);
_cachedVertices[i * 2 + 1] = new VertexPositionNormalColored(vertPosNmlClr.Position + vertPosNmlClr.Normal,
vertColor, vertPosNmlClr.Normal);
}
_cachedIndices = new int[_cachedVertices.Length];
for (var i = 0; i < _cachedVertices.Length; i++)
{
_cachedIndices[i] = i;
}
RebuildBuffers();
_renderCached = true;
}
public void Select(ref Triangle tri, bool doNotReplace, Color color)
{
var v = _cachedVertices.Length;
var i = _cachedIndices.Length;
if (doNotReplace)
{
Array.Resize(ref _cachedVertices, _cachedVertices.Length + 3);
Array.Resize(ref _cachedIndices, _cachedIndices.Length + 3);
}
else
{
v = i = 0;
_cachedVertices = new VertexPositionNormalColored[3];
_cachedIndices = new int[3];
}
// add vertices
var normal = WCell.Util.Graphics.Vector3.Cross(tri.Point3 - tri.Point1, tri.Point2 - tri.Point1).ToXna();
normal.Normalize();
_cachedVertices[v] = new VertexPositionNormalColored(tri.Point1.ToXna(),
color,
normal);
_cachedVertices[v + 1] = new VertexPositionNormalColored(tri.Point2.ToXna(),
color,
normal);
_cachedVertices[v + 2] = new VertexPositionNormalColored(tri.Point3.ToXna(),
color,
normal);
// add indices
_cachedIndices[i] = v;
_cachedIndices[i + 1] = v + 1;
_cachedIndices[i + 2] = v + 2;
}
public void Select(ref Triangle tri, bool doNotReplace, Color color)
{
var v = _cachedVertices.Length;
var i = _cachedIndices.Length;
if (doNotReplace)
{
Array.Resize(ref _cachedVertices, _cachedVertices.Length + 3);
Array.Resize(ref _cachedIndices, _cachedIndices.Length + 3);
}
else
{
v = i = 0;
_cachedVertices = new VertexPositionNormalColored[3];
_cachedIndices = new int[3];
}
// add vertices
var normal = WCell.Util.Graphics.Vector3.Cross(tri.Point3 - tri.Point1, tri.Point2 - tri.Point1).ToXna();
normal.Normalize();
_cachedVertices[v] = new VertexPositionNormalColored(tri.Point1.ToXna(),
color,
normal);
_cachedVertices[v+1] = new VertexPositionNormalColored(tri.Point2.ToXna(),
color,
normal);
_cachedVertices[v+2] = new VertexPositionNormalColored(tri.Point3.ToXna(),
color,
normal);
// add indices
_cachedIndices[i] = v;
_cachedIndices[i+1] = v+1;
_cachedIndices[i+2] = v+2;
}
protected override void BuildVerticiesAndIndicies()
{
// Cycle through each M2
var tempVertices = _manager.RenderVertices;
var tempIndicies = _manager.RenderIndices;
_cachedVertices = new VertexPositionNormalColored[tempVertices.Count];
for (var i = 0; i < tempVertices.Count; i++)
{
var vec = tempVertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref vec);
_cachedVertices[i] = new VertexPositionNormalColored(vec.ToXna(), M2Color,
Microsoft.Xna.Framework.Vector3.Down);
}
_cachedIndices = new int[tempIndicies.Count];
for (var i = 0; i < tempIndicies.Count; i++)
{
_cachedIndices[i] = tempIndicies[i];
}
_renderCached = true;
}
protected override void BuildVerticiesAndIndicies()
{
var tempIndices = new List <int>();
var tempVertices = new List <VertexPositionNormalColored>();
foreach (var vertex in tile.TerrainVertices)
{
var vertexPosNmlCol1 = new VertexPositionNormalColored(vertex.ToXna(),
TerrainColor,
Vector3.Zero);
tempVertices.Add(vertexPosNmlCol1);
}
foreach (var index in tile.TerrainIndices)
{
tempIndices.Add(index);
}
_cachedVertices = tempVertices.ToArray();
_cachedIndices = tempIndices.ToArray();
_renderCached = true;
}
protected override void BuildVerticiesAndIndicies()
{
var tempIndices = new List<int>();
var tempVertices = new List<VertexPositionNormalColored>();
foreach (var vertex in tile.TerrainVertices)
{
var vertexPosNmlCol1 = new VertexPositionNormalColored(vertex.ToXna(),
TerrainColor,
Vector3.Zero);
tempVertices.Add(vertexPosNmlCol1);
}
foreach (var index in tile.TerrainIndices)
{
tempIndices.Add(index);
}
_cachedVertices = tempVertices.ToArray();
_cachedIndices = tempIndices.ToArray();
_renderCached = true;
}
protected override void BuildVerticiesAndIndicies()
{
// Cycle through each M2
var tempVertices = _manager.RenderVertices;
var tempIndicies = _manager.RenderIndices;
_cachedVertices = new VertexPositionNormalColored[tempVertices.Count];
for (var i = 0; i < tempVertices.Count; i++)
{
var vec = tempVertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref vec);
_cachedVertices[i] = new VertexPositionNormalColored(vec.ToXna(), M2Color,
Microsoft.Xna.Framework.Vector3.Down);
}
_cachedIndices = new int[tempIndicies.Count];
for (var i = 0; i < tempIndicies.Count; i++)
{
_cachedIndices[i] = tempIndicies[i];
}
_renderCached = true;
}
protected override void BuildVerticiesAndIndicies()
{
List <int> indices;
using (LargeObjectPools.IndexListPool.Borrow(out indices))
{
List <WCell.Util.Graphics.Vector3> vertices;
using (LargeObjectPools.Vector3ListPool.Borrow(out vertices))
{
indices.Clear();
vertices.Clear();
var tempVertices = new List <VertexPositionNormalColored>();
tile.GenerateLiquidMesh(indices, vertices);
if (vertices.Count == 0)
{
return;
}
foreach (var vertex in vertices)
{
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(),
WaterColor,
Vector3.Zero);
tempVertices.Add(vertexPosNmlCol);
}
_cachedIndices = indices.ToArray();
_cachedVertices = tempVertices.ToArray();
}
}
_renderCached = true;
}
public TriangleList Optimize()
{
IList <VertexPositionNormalColored> vertices = Vertices;
IList <int> indices = Indices;
var hash = new Dictionary <VertexPositionNormalColored, int>();
var resultIndices = new List <int>();
for (int i = 0; i < indices.Count; i++)
{
VertexPositionNormalColored vertex = vertices[indices[i]];
int index;
if (!hash.TryGetValue(vertex, out index))
{
index = hash.Count;
hash.Add(vertex, index);
}
resultIndices.Add(index);
}
return(new TriangleList()
{
Indices = resultIndices.ToArray(),
Vertices = hash.Keys.ToArray(),
});
}
protected override bool BuildPolyVerticiesAndIndicies()
{
List<Vector3> polyVertices;
List<int> polyIndices;
_manager.GetMeshVerticesAndIndices(out polyVertices, out polyIndices);
if (polyVertices.Count == 0 || polyIndices == null) return false;
_cachedPolyVertices = new VertexPositionNormalColored[polyVertices.Count];
for (var i = 0; i < polyVertices.Count; i++)
{
_cachedPolyVertices[i] = new VertexPositionNormalColored(polyVertices[i].ToXna(), RecastFrameColor,
Vector3.Up.ToXna());
PositionUtil.TransformWoWCoordsToXNACoords(ref _cachedPolyVertices[i]);
}
_cachedPolyIndices = new int[polyIndices.Count];
for (int i = 0; i < polyIndices.Count; i++)
{
_cachedPolyIndices[i] = polyIndices[i];
}
RenderPolyCached = true;
return true;
}
public GenericRenderer(Game game)
: base(game)
{
_cachedVertices = new VertexPositionNormalColored[0];
_cachedIndices = new int[0];
}
protected static VertexBuffer ToVertexBuffer
(
Rhino.Geometry.Mesh mesh,
Primitive.Part part,
out VertexFormatBits vertexFormatBits,
System.Drawing.Color color = default
)
{
int verticesCount = part.EndVertexIndex - part.StartVertexIndex;
int normalCount = mesh.Normals.Count == mesh.Vertices.Count ? verticesCount : 0;
int colorsCount = color.IsEmpty ? (mesh.VertexColors.Count == mesh.Vertices.Count ? verticesCount : 0) : verticesCount;
bool hasVertices = verticesCount > 0;
bool hasNormals = normalCount > 0;
bool hasColors = colorsCount > 0;
if (hasVertices)
{
var vertices = mesh.Vertices;
if (hasNormals)
{
var normals = mesh.Normals;
if (hasColors)
{
vertexFormatBits = VertexFormatBits.PositionNormalColored;
var colors = mesh.VertexColors;
var vb = new VertexBuffer(verticesCount * VertexPositionNormalColored.GetSizeInFloats());
vb.Map(verticesCount * VertexPositionNormalColored.GetSizeInFloats());
using (var stream = vb.GetVertexStreamPositionNormalColored())
{
for (int v = part.StartVertexIndex; v < part.EndVertexIndex; ++v)
{
var c = !color.IsEmpty ? color : colors[v];
uint T = Math.Max(1, 255u - c.A);
stream.AddVertex(new VertexPositionNormalColored(RawEncoder.ToHost(vertices[v]), RawEncoder.ToHost(normals[v]), new ColorWithTransparency(c.R, c.G, c.B, T)));
}
}
vb.Unmap();
return(vb);
}
else
{
vertexFormatBits = VertexFormatBits.PositionNormal;
var vb = new VertexBuffer(verticesCount * VertexPositionNormal.GetSizeInFloats());
vb.Map(verticesCount * VertexPositionNormal.GetSizeInFloats());
using (var stream = vb.GetVertexStreamPositionNormal())
{
for (int v = part.StartVertexIndex; v < part.EndVertexIndex; ++v)
{
stream.AddVertex(new VertexPositionNormal(RawEncoder.ToHost(vertices[v]), RawEncoder.ToHost(normals[v])));
}
}
vb.Unmap();
return(vb);
}
}
else
{
if (hasColors)
{
vertexFormatBits = VertexFormatBits.PositionColored;
var colors = mesh.VertexColors;
var vb = new VertexBuffer(verticesCount * VertexPositionColored.GetSizeInFloats());
vb.Map(verticesCount * VertexPositionColored.GetSizeInFloats());
using (var stream = vb.GetVertexStreamPositionColored())
{
for (int v = part.StartVertexIndex; v < part.EndVertexIndex; ++v)
{
var c = !color.IsEmpty ? color : colors[v];
uint T = Math.Max(1, 255u - c.A);
stream.AddVertex(new VertexPositionColored(RawEncoder.ToHost(vertices[v]), new ColorWithTransparency(c.R, c.G, c.B, T)));
}
}
vb.Unmap();
return(vb);
}
else
{
vertexFormatBits = VertexFormatBits.Position;
var vb = new VertexBuffer(verticesCount * VertexPosition.GetSizeInFloats());
vb.Map(verticesCount * VertexPosition.GetSizeInFloats());
using (var stream = vb.GetVertexStreamPosition())
{
for (int v = part.StartVertexIndex; v < part.EndVertexIndex; ++v)
{
stream.AddVertex(new VertexPosition(RawEncoder.ToHost(vertices[v])));
}
}
vb.Unmap();
return(vb);
}
}
}
vertexFormatBits = 0;
return(null);
}
protected static int ToPointsBuffer
(
Rhino.Geometry.PointCloud pointCloud,
Primitive.Part part,
out VertexFormatBits vertexFormatBits,
out VertexBuffer vb, out int vertexCount,
out IndexBuffer ib
)
{
int pointsCount = part.VertexCount;
int normalCount = pointCloud.ContainsNormals ? pointsCount : 0;
int colorsCount = pointCloud.ContainsColors ? pointsCount : 0;
bool hasPoints = pointsCount > 0;
bool hasNormals = normalCount == pointsCount;
bool hasColors = colorsCount == pointsCount;
if (hasPoints)
{
if (hasNormals)
{
if (hasColors)
{
vertexFormatBits = VertexFormatBits.PositionNormalColored;
vb = new VertexBuffer(pointsCount * VertexPositionNormalColored.GetSizeInFloats());
vb.Map(pointsCount * VertexPositionNormalColored.GetSizeInFloats());
using (var vstream = vb.GetVertexStreamPositionNormalColored())
{
for (int p = part.StartVertexIndex; p < part.EndVertexIndex; ++p)
{
var point = pointCloud[p];
var c = new ColorWithTransparency(point.Color.R, point.Color.G, point.Color.B, 255u - point.Color.A);
vstream.AddVertex(new VertexPositionNormalColored(RawEncoder.ToHost(point.Location), RawEncoder.ToHost(point.Normal), c));
}
}
vb.Unmap();
}
else
{
vertexFormatBits = VertexFormatBits.PositionNormal;
vb = new VertexBuffer(pointsCount * VertexPositionNormal.GetSizeInFloats());
vb.Map(pointsCount * VertexPositionNormal.GetSizeInFloats());
using (var vstream = vb.GetVertexStreamPositionNormal())
{
for (int p = part.StartVertexIndex; p < part.EndVertexIndex; ++p)
{
var point = pointCloud[p];
vstream.AddVertex(new VertexPositionNormal(RawEncoder.ToHost(point.Location), RawEncoder.ToHost(point.Normal)));
}
}
vb.Unmap();
}
}
else
{
if (hasColors)
{
vertexFormatBits = VertexFormatBits.PositionColored;
vb = new VertexBuffer(pointsCount * VertexPositionColored.GetSizeInFloats());
vb.Map(pointsCount * VertexPositionColored.GetSizeInFloats());
using (var vstream = vb.GetVertexStreamPositionColored())
{
for (int p = part.StartVertexIndex; p < part.EndVertexIndex; ++p)
{
var point = pointCloud[p];
var c = new ColorWithTransparency(point.Color.R, point.Color.G, point.Color.B, 255u - point.Color.A);
vstream.AddVertex(new VertexPositionColored(RawEncoder.ToHost(point.Location), c));
}
}
vb.Unmap();
}
else
{
vertexFormatBits = VertexFormatBits.Position;
vb = new VertexBuffer(pointsCount * VertexPosition.GetSizeInFloats());
vb.Map(pointsCount * VertexPosition.GetSizeInFloats());
using (var vstream = vb.GetVertexStreamPosition())
{
for (int p = part.StartVertexIndex; p < part.EndVertexIndex; ++p)
{
var point = pointCloud[p];
vstream.AddVertex(new VertexPosition(RawEncoder.ToHost(point.Location)));
}
}
vb.Unmap();
}
}
ib = IndexPointsBuffer(pointsCount);
}
else
{
vertexFormatBits = 0;
vb = null;
ib = null;
}
vertexCount = pointsCount;
return(pointsCount);
}
void BuildVerticesAndIndices()
{
_cachedVertices = new VertexPositionNormalColored[environment.RenderingVerticies.Length*2];
for (var i = 0; i < environment.RenderingVerticies.Length; i++)
{
var vertPosNmlClr = environment.RenderingVerticies[i];
_cachedVertices[i*2] = new VertexPositionNormalColored(vertPosNmlClr.Position, vertColor,
vertPosNmlClr.Normal);
_cachedVertices[i*2 + 1] = new VertexPositionNormalColored(vertPosNmlClr.Position + vertPosNmlClr.Normal,
vertColor, vertPosNmlClr.Normal);
}
_cachedIndices = new int[_cachedVertices.Length];
for (var i = 0; i < _cachedVertices.Length; i++)
{
_cachedIndices[i] = i;
}
RebuildBuffers();
_renderCached = true;
}
protected override void BuildVerticiesAndIndicies()
{
var mesh = Viewer.Tile.NavMesh;
var vertices = mesh.Vertices;
List<int> indices;
mesh.GetTriangles(out indices);
if (vertices.Length == 0 || indices.Count == 0) return;
_cachedVertices = new VertexPositionNormalColored[vertices.Length];
for (var i = 0; i < vertices.Length; i++)
{
var vertex = vertices[i];
_cachedVertices[i] = new VertexPositionNormalColored(vertex.ToXna(),
RenderColor,
Microsoft.Xna.Framework.Vector3.Zero);
}
_cachedIndices = new int[indices.Count];
for (int i = 0; i < indices.Count; i++)
{
_cachedIndices[i] = indices[i];
}
_renderCached = true;
}
protected override void BuildVerticiesAndIndicies()
{
var vertCount = _manager.WmoVertices.Count +
_manager.WmoM2Vertices.Count +
_manager.WmoLiquidVertices.Count;
_cachedVertices = new VertexPositionNormalColored[vertCount];
var idxCount = _manager.WmoIndices.Count +
_manager.WmoM2Indices.Count +
_manager.WmoLiquidIndices.Count;
_cachedIndices = new int[idxCount];
var vertices = _manager.WmoVertices;
var indices = _manager.WmoIndices;
for (var i = 0; i < vertices.Count; i++)
{
var vec = vertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref vec);
_cachedVertices[i] = new VertexPositionNormalColored(vec.ToXna(), WMOColor, Vector3.Down);
}
for (var i = 0; i < indices.Count; i++)
{
_cachedIndices[i] = indices[i];
}
// Add the M2 stuff
var vecOffset = vertices.Count;
vertices = _manager.WmoM2Vertices;
for (var i = 0; i < vertices.Count; i++)
{
var vec = vertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref vec);
_cachedVertices[i + vecOffset] = new VertexPositionNormalColored(vec.ToXna(), WMOModelColor,
Vector3.Down);
}
var idxOffset = indices.Count;
indices = _manager.WmoM2Indices;
for (var i = 0; i < indices.Count; i++)
{
_cachedIndices[i + idxOffset] = indices[i] + vecOffset;
}
// Add the Liquid stuff
vecOffset += vertices.Count;
vertices = _manager.WmoLiquidVertices;
for (var i = 0; i < vertices.Count; i++)
{
var vec = vertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref vec);
_cachedVertices[i + vecOffset] = new VertexPositionNormalColored(vec.ToXna(), WMOWaterColor,
Vector3.Down);
}
idxOffset += indices.Count;
indices = _manager.WmoLiquidIndices;
for (var i = 0; i < indices.Count; i++)
{
_cachedIndices[i + idxOffset] = indices[i] + vecOffset;
}
_renderCached = true;
}
private void CopyToTerrainBuffers(VertexPositionNormalColored[] vertices, int[] indices)
{
terrainVertexBuffer = new VertexBuffer(device, typeof(VertexPositionNormalColored), vertices.Length, BufferUsage.WriteOnly);
terrainVertexBuffer.SetData(vertices);
terrainIndexBuffer = new IndexBuffer(device, typeof(int), indices.Length, BufferUsage.WriteOnly);
terrainIndexBuffer.SetData(indices);
}
private VertexPositionNormalColored[] CalculateNormals(VertexPositionNormalColored[] vertices, int[] indices)
{
for (int i = 0; i < vertices.Length; i++)
vertices[i].Normal = new Vector3(0, 0, 0);
for (int i = 0; i < indices.Length / 3; i++)
{
int index1 = indices[i * 3];
int index2 = indices[i * 3 + 1];
int index3 = indices[i * 3 + 2];
Vector3 side1 = vertices[index1].Position - vertices[index3].Position;
Vector3 side2 = vertices[index1].Position - vertices[index2].Position;
Vector3 normal = Vector3.Cross(side1, side2);
vertices[index1].Normal += normal;
vertices[index2].Normal += normal;
vertices[index3].Normal += normal;
}
for (int i = 0; i < vertices.Length; i++)
vertices[i].Normal.Normalize();
return vertices;
}
protected override void BuildVerticiesAndIndicies()
{
var vertCount = _manager.WmoVertices.Count +
_manager.WmoM2Vertices.Count +
_manager.WmoLiquidVertices.Count;
_cachedVertices = new VertexPositionNormalColored[vertCount];
var idxCount = _manager.WmoIndices.Count +
_manager.WmoM2Indices.Count +
_manager.WmoLiquidIndices.Count;
_cachedIndices = new int[idxCount];
var vertices = _manager.WmoVertices;
var indices = _manager.WmoIndices;
for (var i = 0; i < vertices.Count; i++)
{
var vec = vertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref vec);
_cachedVertices[i] = new VertexPositionNormalColored(vec.ToXna(), WMOColor, Vector3.Down);
}
for (var i = 0; i < indices.Count; i++)
{
_cachedIndices[i] = indices[i];
}
// Add the M2 stuff
var vecOffset = vertices.Count;
vertices = _manager.WmoM2Vertices;
for (var i = 0; i < vertices.Count; i++)
{
var vec = vertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref vec);
_cachedVertices[i + vecOffset] = new VertexPositionNormalColored(vec.ToXna(), WMOModelColor,
Vector3.Down);
}
var idxOffset = indices.Count;
indices = _manager.WmoM2Indices;
for (var i = 0; i < indices.Count; i++)
{
_cachedIndices[i + idxOffset] = indices[i] + vecOffset;
}
// Add the Liquid stuff
vecOffset += vertices.Count;
vertices = _manager.WmoLiquidVertices;
for (var i = 0; i < vertices.Count; i++)
{
var vec = vertices[i];
PositionUtil.TransformWoWCoordsToXNACoords(ref vec);
_cachedVertices[i + vecOffset] = new VertexPositionNormalColored(vec.ToXna(), WMOWaterColor,
Vector3.Down);
}
idxOffset += indices.Count;
indices = _manager.WmoLiquidIndices;
for (var i = 0; i < indices.Count; i++)
{
_cachedIndices[i + idxOffset] = indices[i] + vecOffset;
}
_renderCached = true;
}
/// <summary>
/// Changes the coodinate system of a vertex from WoW based to XNA based.
/// </summary>
/// <param name="vertex">A vertex with WoW coords</param>
public static void TransformWoWCoordsToXNACoords(ref VertexPositionNormalColored vertex)
{
TransformWoWCoordsToXNACoords(ref vertex.Position);
}
public GenericRenderer(Game game)
: base(game)
{
_cachedVertices = new VertexPositionNormalColored[0];
_cachedIndices = new int[0];
}
// Create and populate a pair of vertex and index buffers. Also update parameters associated with the format of the vertices.
private void ProcessFaces(RenderingPassBufferStorage bufferStorage)
{
List <MeshInfo> meshes = bufferStorage.Meshes;
if (meshes.Count == 0)
{
return;
}
List <int> numVerticesInMeshesBefore = new List <int>();
bool useNormals = this.Inputs.EnableFaceNormal;
// Vertex attributes are stored sequentially in vertex buffers. The attributes can include position, normal vector, and color.
// All vertices within a vertex buffer must have the same format. Possible formats are enumerated by VertexFormatBits.
// Vertex format also determines the type of rendering effect that can be used with the vertex buffer. In this sample,
// the color is always encoded in the vertex attributes.
bufferStorage.FormatBits = useNormals ? VertexFormatBits.PositionNormalColored : VertexFormatBits.PositionColored;
// The format of the vertices determines the size of the vertex buffer.
int vertexBufferSizeInFloats = (useNormals ? VertexPositionNormalColored.GetSizeInFloats() : VertexPositionColored.GetSizeInFloats()) *
bufferStorage.VertexBufferCount;
numVerticesInMeshesBefore.Add(0);
bufferStorage.VertexBuffer = new VertexBuffer(vertexBufferSizeInFloats);
bufferStorage.VertexBuffer.Map(vertexBufferSizeInFloats);
int numMeshes = meshes.Count;
if (useNormals)
{
// A VertexStream is used to write data into a VertexBuffer.
VertexStreamPositionNormalColored vertexStream = bufferStorage.VertexBuffer.GetVertexStreamPositionNormalColored();
for (int i = 0; i < numMeshes; i++)
{
var meshInfo = meshes[i];
Mesh mesh = meshInfo.Mesh;
foreach (XYZ vertex in mesh.Vertices)
{
vertexStream.AddVertex(new VertexPositionNormalColored(vertex + meshInfo.Offset, meshInfo.Normal, meshInfo.ColorWithTransparency));
}
numVerticesInMeshesBefore.Add(numVerticesInMeshesBefore.Last() + mesh.Vertices.Count);
}
}
else
{
// A VertexStream is used to write data into a VertexBuffer.
VertexStreamPositionColored vertexStream = bufferStorage.VertexBuffer.GetVertexStreamPositionColored();
for (int i = 0; i < numMeshes; i++)
{
var meshInfo = meshes[i];
Mesh mesh = meshInfo.Mesh;
// make the color of all faces white in HLR
ColorWithTransparency color = meshInfo.ColorWithTransparency;
foreach (XYZ vertex in mesh.Vertices)
{
vertexStream.AddVertex(new VertexPositionColored(vertex + meshInfo.Offset, color));
}
numVerticesInMeshesBefore.Add(numVerticesInMeshesBefore.Last() + mesh.Vertices.Count);
}
}
bufferStorage.VertexBuffer.Unmap();
// Primitives are specified using a pair of vertex and index buffers. An index buffer contains a sequence of indices into
// the associated vertex buffer, each index referencing a particular vertex.
int meshNumber = 0;
bufferStorage.IndexBufferCount = bufferStorage.PrimitiveCount * IndexTriangle.GetSizeInShortInts();
int indexBufferSizeInShortInts = 1 * bufferStorage.IndexBufferCount;
bufferStorage.IndexBuffer = new IndexBuffer(indexBufferSizeInShortInts);
bufferStorage.IndexBuffer.Map(indexBufferSizeInShortInts);
{
// An IndexStream is used to write data into an IndexBuffer.
IndexStreamTriangle indexStream = bufferStorage.IndexBuffer.GetIndexStreamTriangle();
foreach (MeshInfo meshInfo in meshes)
{
Mesh mesh = meshInfo.Mesh;
int startIndex = numVerticesInMeshesBefore[meshNumber];
for (int i = 0; i < mesh.NumTriangles; i++)
{
MeshTriangle mt = mesh.get_Triangle(i);
// Add three indices that define a triangle.
indexStream.AddTriangle(new IndexTriangle((int)(startIndex + mt.get_Index(0)),
(int)(startIndex + mt.get_Index(1)),
(int)(startIndex + mt.get_Index(2))));
}
meshNumber++;
}
}
bufferStorage.IndexBuffer.Unmap();
// VertexFormat is a specification of the data that is associated with a vertex (e.g., position).
bufferStorage.VertexFormat = new VertexFormat(bufferStorage.FormatBits);
// Effect instance is a specification of the appearance of geometry. For example, it may be used to specify color, if there is no color information provided with the vertices.
bufferStorage.EffectInstance = new EffectInstance(bufferStorage.FormatBits);
}
// Create and populate a pair of vertex and index buffers. Also update parameters associated with the format of the vertices.
private void ProcessTriangles(RenderingPassBufferStorage bufferStorage)
{
List <TriangleInfo> triangles = bufferStorage.Triangles;
if (triangles.Count == 0)
{
return;
}
bool useNormals = this.Inputs.EnableFaceNormal;
// Vertex attributes are stored sequentially in vertex buffers. The attributes can include position, normal vector, and color.
// All vertices within a vertex buffer must have the same format. Possible formats are enumerated by VertexFormatBits.
// Vertex format also determines the type of rendering effect that can be used with the vertex buffer. In this sample,
// the color is always encoded in the vertex attributes.
bufferStorage.FormatBits = useNormals ? VertexFormatBits.PositionNormalColored : VertexFormatBits.PositionColored;
// The format of the vertices determines the size of the vertex buffer.
int vertexBufferSizeInFloats = (useNormals ? VertexPositionNormalColored.GetSizeInFloats() : VertexPositionColored.GetSizeInFloats()) *
bufferStorage.VertexBufferCount;
bufferStorage.VertexBuffer = new VertexBuffer(vertexBufferSizeInFloats);
bufferStorage.VertexBuffer.Map(vertexBufferSizeInFloats);
int numTriangles = triangles.Count;
if (useNormals)
{
// A VertexStream is used to write data into a VertexBuffer.
VertexStreamPositionNormalColored vertexStream = bufferStorage.VertexBuffer.GetVertexStreamPositionNormalColored();
for (int i = 0; i < numTriangles; i++)
{
var triangleInfo = triangles[i];
g3.Triangle3d triangle = triangleInfo.Triangle;
vertexStream.AddVertex(new VertexPositionNormalColored(triangle.V0.ToXYZ() + triangleInfo.Offset, triangleInfo.Normal, triangleInfo.ColorWithTransparency));
vertexStream.AddVertex(new VertexPositionNormalColored(triangle.V1.ToXYZ() + triangleInfo.Offset, triangleInfo.Normal, triangleInfo.ColorWithTransparency));
vertexStream.AddVertex(new VertexPositionNormalColored(triangle.V2.ToXYZ() + triangleInfo.Offset, triangleInfo.Normal, triangleInfo.ColorWithTransparency));
}
}
else
{
// A VertexStream is used to write data into a VertexBuffer.
VertexStreamPositionColored vertexStream = bufferStorage.VertexBuffer.GetVertexStreamPositionColored();
for (int i = 0; i < numTriangles; i++)
{
var triangleInfo = triangles[i];
g3.Triangle3d triangle = triangleInfo.Triangle;
// make the color of all faces white in HLR
ColorWithTransparency color = triangleInfo.ColorWithTransparency;
vertexStream.AddVertex(new VertexPositionColored(triangle.V0.ToXYZ() + triangleInfo.Offset, color));
vertexStream.AddVertex(new VertexPositionColored(triangle.V1.ToXYZ() + triangleInfo.Offset, color));
vertexStream.AddVertex(new VertexPositionColored(triangle.V2.ToXYZ() + triangleInfo.Offset, color));
}
}
bufferStorage.VertexBuffer.Unmap();
// Primitives are specified using a pair of vertex and index buffers. An index buffer contains a sequence of indices into
// the associated vertex buffer, each index referencing a particular vertex.
bufferStorage.IndexBufferCount = bufferStorage.PrimitiveCount * IndexTriangle.GetSizeInShortInts();
int indexBufferSizeInShortInts = 1 * bufferStorage.IndexBufferCount;
bufferStorage.IndexBuffer = new IndexBuffer(indexBufferSizeInShortInts);
bufferStorage.IndexBuffer.Map(indexBufferSizeInShortInts);
// An IndexStream is used to write data into an IndexBuffer.
IndexStreamTriangle indexStream = bufferStorage.IndexBuffer.GetIndexStreamTriangle();
int currIndex = 0;
for (int i = 0; i < numTriangles; i++)
{
// Add three indices that define a triangle.
indexStream.AddTriangle(new IndexTriangle(currIndex + 0, currIndex + 1, currIndex + 2));
currIndex += 3;
}
bufferStorage.IndexBuffer.Unmap();
// VertexFormat is a specification of the data that is associated with a vertex (e.g., position).
bufferStorage.VertexFormat = new VertexFormat(bufferStorage.FormatBits);
// Effect instance is a specification of the appearance of geometry. For example, it may be used to specify color, if there is no color information provided with the vertices.
bufferStorage.EffectInstance = new EffectInstance(bufferStorage.FormatBits);
}
private VertexPositionNormalColored[] SetUpTerrainVertices()
{
VertexPositionNormalColored[] terrainVertices = new VertexPositionNormalColored[terrainWidth * terrainLength];
for (int x = 0; x < terrainWidth; x++)
{
for (int y = 0; y < terrainLength; y++)
{
terrainVertices[x + y * terrainWidth].Position = new Vector3(x, heightData[x, y], -y);
if (heightData[x, y] < 6) { terrainVertices[x + y * terrainWidth].Color = Color.Blue; }
else if (heightData[x, y] < 8) { terrainVertices[x + y * terrainWidth].Color = Color.Aquamarine; }
else if (heightData[x, y] < 10) { terrainVertices[x + y * terrainWidth].Color = Color.SandyBrown; }
else if (heightData[x, y] < 15) { terrainVertices[x + y * terrainWidth].Color = Color.Green; }
else if (heightData[x, y] < 18) { terrainVertices[x + y * terrainWidth].Color = Color.ForestGreen; }
else if (heightData[x, y] < 25) { terrainVertices[x + y * terrainWidth].Color = Color.SaddleBrown; }
else if (heightData[x, y] < 30) { terrainVertices[x + y * terrainWidth].Color = Color.DimGray; }
else { terrainVertices[x + y * terrainWidth].Color = Color.White; }
}
}
return terrainVertices;
}
private void BuildVerticiesAndIndicies()
{
// Cycle through each ADT
var tempVertices = new List<VertexPositionNormalColored>();
var tempIndicies = new List<int>();
var offset = 0;
foreach (var adt in _manager.MapTiles)
{
// Handle the ADTs
for (var v = 0; v < adt.TerrainVertices.Count; v++)
{
var vertex = adt.TerrainVertices[v];
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(), TerrainColor,
Microsoft.Xna.Framework.Vector3.Down);
tempVertices.Add(vertexPosNmlCol);
}
for (var i = 0; i < adt.Indices.Count; i++)
{
tempIndicies.Add(adt.Indices[i] + offset);
}
offset = tempVertices.Count;
//if (!DrawLiquids) continue;
for (var v = 0; v < adt.LiquidVertices.Count; v++)
{
var vertex = adt.LiquidVertices[v];
var vertexPosNmlCol = new VertexPositionNormalColored(vertex.ToXna(), WaterColor,
Microsoft.Xna.Framework.Vector3.Down);
tempVertices.Add(vertexPosNmlCol);
}
for (var i = 0; i < adt.LiquidIndices.Count; i++)
{
tempIndicies.Add(adt.LiquidIndices[i] + offset);
}
offset = tempVertices.Count;
}
_cachedIndices = tempIndicies.ToArray();
_cachedVertices = tempVertices.ToArray();
_renderCached = true;
for (var i = 0; i < _cachedVertices.Length; i++)
{
PositionUtil.TransformWoWCoordsToXNACoords(ref _cachedVertices[i]);
}
}
/// <summary>
/// Changes the coodinate system of a vertex from WoW based to XNA based.
/// </summary>
/// <param name="vertex">A vertex with WoW coords</param>
public static void TransformWoWCoordsToXNACoords(ref VertexPositionNormalColored vertex)
{
TransformWoWCoordsToXNACoords(ref vertex.Position);
}
