public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var texture = DryTexture;
if (descriptor.Metadata == (byte)FarmlandBlock.MoistureLevel.Moist)
{
texture = MoistTexture;
}
var lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
var overhead = new Vector3(0.5f, 0.5f, 0.5f);
var cube = CreateUniformCube(overhead, texture, faces, indiciesOffset, out indicies, Color.White, lighting);
for (int i = 0; i < cube.Length; i++)
{
if (cube[i].Position.Y > 0)
{
cube[i].Position.Y *= 15f / 16f;
}
cube[i].Position += offset;
cube[i].Position -= overhead;
}
return(cube);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Microsoft.Xna.Framework.Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var texture = Texture;
if (descriptor.Coordinates.Y < World.Height && descriptor.Chunk != null)
{
if (descriptor.Chunk.GetBlockID(descriptor.Coordinates + Coordinates3D.Up) == SnowfallBlock.BlockID)
{
texture = SnowTexture;
}
}
var lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
var cube = CreateUniformCube(offset, texture, faces, indiciesOffset, out indicies, Color.White, lighting);
// Apply biome colors to top of cube
for (int i = (int)(CubeFace.PositiveY) * 4; i < (int)(CubeFace.PositiveY) * 4 + 4; i++)
{
cube[i].Color = new Color(cube[i].Color.ToVector3() * BiomeColor.ToVector3()); // TODO: Take this from biome
}
return(cube);
}
static void build_horizon(Vector3 p, VisibleFaces visible, Face start_face, int start_edge = 0)
{
start_face.Visited = true;
start_face.Dropped = true;
visible.Add(start_face);
var edges = start_face.Edges(start_edge);
while (edges.MoveNext())
{
var e = edges.Current;
if (e.Neighbour.Visited || e.Neighbour.Dropped)
{
continue;
}
if (e.Neighbour.Visible(p))
{
build_horizon(p, visible, e.Neighbour, e.NeighbourIndex);
}
else
{
visible.Horizon.Add(e.NeigbourEdge);
}
}
start_face.Visited = false;
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
var lighting = new int[6];
for (var i = 0; i < 6; i++)
{
var coords = descriptor.Coordinates + FaceCoords[i];
lighting[i] = GetLight(descriptor.Chunk, coords);
}
switch ((WoodBlock.WoodType)descriptor.Metadata)
{
case WoodBlock.WoodType.Spruce:
return(CreateUniformCube(offset, SpruceTexture, faces, indicesOffset, out indices, Color.White,
lighting));
case WoodBlock.WoodType.Birch:
return(CreateUniformCube(offset, BirchTexture, faces, indicesOffset, out indices, Color.White,
lighting));
case WoodBlock.WoodType.Oak:
default:
return(CreateUniformCube(offset, BaseTexture, faces, indicesOffset, out indices, Color.White,
lighting));
}
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
var lighting = new int[6];
for (var i = 0; i < 6; i++)
{
var coords = descriptor.Coordinates + FaceCoords[i];
lighting[i] = GetLight(descriptor.Chunk, coords);
}
// TODO: Rest of water rendering (shape and level and so on)
var overhead = new Vector3(0.5f, 0.5f, 0.5f);
var cube = CreateUniformCube(overhead, Texture, faces, indicesOffset, out indices, Color.Blue, lighting);
for (var i = 0; i < cube.Length; i++)
{
if (cube[i].Position.Y > 0)
{
cube[i].Position.Y *= 14f / 16f;
}
cube[i].Position += offset;
cube[i].Position -= overhead;
}
return(cube);
}
private void AddTransparentBlock(Coordinates3D coords, RenderState state, ReadOnlyChunk chunk)
{
// Add adjacent blocks
VisibleFaces faces = VisibleFaces.None;
for (int i = 0; i < AdjacentCoordinates.Length; i++)
{
var next = coords + AdjacentCoordinates[i];
if (next.X < 0 || next.X >= Chunk.Width ||
next.Y < 0 || next.Y >= Chunk.Height ||
next.Z < 0 || next.Z >= Chunk.Depth)
{
faces |= AdjacentCoordFaces[i];
continue;
}
if (chunk.GetBlockId(next) == 0)
{
faces |= AdjacentCoordFaces[i];
}
}
if (faces != VisibleFaces.None)
{
state.DrawableCoordinates[coords] = faces;
}
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
// This is similar to how wheat is rendered
indicies = new int[5 * 6];
var verticies = new VertexPositionNormalColorTexture[5 * 6];
int[] _indicies;
var center = new Vector3(-0.5f, -0.5f, -0.5f);
CubeFace side;
VertexPositionNormalColorTexture[] quad;
for (int _side = 0; _side < 4; _side++)
{
side = (CubeFace)_side;
quad = CreateQuad(side, center, Texture, 0, indiciesOffset, out _indicies, Color.White);
if (side == CubeFace.NegativeX || side == CubeFace.PositiveX)
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.X *= 14f / 16f;
quad[i].Position += offset;
}
}
else
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.Z *= 14f / 16f;
quad[i].Position += offset;
}
}
Array.Copy(quad, 0, verticies, _side * 4, 4);
Array.Copy(_indicies, 0, indicies, _side * 6, 6);
}
side = CubeFace.PositiveY;
quad = CreateQuad(side, center, TopTexture, 0, indiciesOffset, out _indicies, Color.White);
if (side == CubeFace.NegativeX || side == CubeFace.PositiveX)
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.X *= 14f / 16f;
quad[i].Position += offset;
}
}
else
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.Z *= 14f / 16f;
quad[i].Position += offset;
}
}
Array.Copy(quad, 0, verticies, (int)side * 4, 4);
Array.Copy(_indicies, 0, indicies, (int)side * 6, 6);
for (int i = 0; i < verticies.Length; i++)
{
verticies[i].Position.Y -= 1 / 16f;
verticies[i].Position -= center;
}
return verticies;
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
var lighting = new int[6];
for (var i = 0; i < 6; i++)
{
var coords = descriptor.Coordinates + FaceCoords[i];
lighting[i] = GetLight(descriptor.Chunk, coords);
}
var cube = CreateUniformCube(Vector3.Zero, Texture, faces, indicesOffset, out indices,
Color.White, lighting);
var heightMultiplier = new Vector3(1, (descriptor.Metadata + 1) / 16f, 1);
for (var i = 0; i < cube.Length; i++)
{
if (cube[i].Position.Y > 0)
{
cube[i].Position *= heightMultiplier;
}
cube[i].Position += offset;
}
return(cube);
}
public virtual VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
var texCoords = new Vector2(textureMap.Item1, textureMap.Item2);
var texture = new[]
{
texCoords + Vector2.UnitX + Vector2.UnitY,
texCoords + Vector2.UnitY,
texCoords,
texCoords + Vector2.UnitX
};
for (var i = 0; i < texture.Length; i++)
{
texture[i] *= new Vector2(16f / 256f);
}
var lighting = new int[6];
for (var i = 0; i < 6; i++)
{
var coords = descriptor.Coordinates + FaceCoords[i];
lighting[i] = GetLight(descriptor.Chunk, coords);
}
return(CreateUniformCube(offset, texture, faces, indicesOffset, out indices, Color.White, lighting));
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
int[] lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
var centerized = new Vector3(7f / 16f, 0, 7f / 16f);
var cube = CreateUniformCube(Vector3.Zero, Texture, VisibleFaces.All,
indiciesOffset, out indicies, Color.White, lighting);
for (int i = 0; i < cube.Length; i++)
{
cube[i].Position.X *= 1f / 8f;
cube[i].Position.Z *= 1f / 8f;
if (cube[i].Position.Y > 0)
cube[i].Position.Y *= 5f / 8f;
switch ((TorchBlock.TorchDirection)descriptor.Metadata)
{
case TorchBlock.TorchDirection.West:
if (cube[i].Position.Y == 0)
cube[i].Position.X += 8f / 16f;
else
cube[i].Position.X += 3f / 16f;
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.East:
if (cube[i].Position.Y == 0)
cube[i].Position.X -= 8f / 16f;
else
cube[i].Position.X -= 3f / 16f;
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.North:
if (cube[i].Position.Y == 0)
cube[i].Position.Z += 8f / 16f;
else
cube[i].Position.Z += 3f / 16f;
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.South:
if (cube[i].Position.Y == 0)
cube[i].Position.Z -= 8f / 16f;
else
cube[i].Position.Z -= 3f / 16f;
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.Ground:
default:
// nop
break;
}
cube[i].Position += offset;
cube[i].Position += centerized;
}
return cube;
}
public static VertexPositionNormalColorTexture[] RenderBlock(IBlockProvider provider, BlockDescriptor descriptor,
VisibleFaces faces, Vector3 offset, int indiciesOffset, out int[] indicies)
{
var textureMap = provider.GetTextureMap(descriptor.Metadata);
if (textureMap == null)
textureMap = new Tuple<int, int>(0, 0); // TODO: handle this better
return Renderers[descriptor.ID].Render(descriptor, offset, faces, textureMap, indiciesOffset, out indicies);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
if (descriptor.Id == SlabBlock.BlockId)
{
return(RenderSlab(descriptor, offset, textureMap, indicesOffset, out indices));
}
return(RenderDoubleSlab(descriptor, offset, textureMap, indicesOffset, out indices));
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indiciesOffset, out int[] indicies)
{
int[] lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
VertexPositionNormalColorTexture[] verticies;
Vector3 correction;
int faceCorrection = 0;
switch ((LadderBlock.LadderDirection)descriptor.Metadata)
{
case LadderBlock.LadderDirection.North:
verticies = CreateQuad(CubeFace.PositiveZ, offset, Texture, 0, indiciesOffset, out indicies, Color.White);
correction = Vector3.Forward;
faceCorrection = (int)CubeFace.PositiveZ * 4;
break;
case LadderBlock.LadderDirection.South:
verticies = CreateQuad(CubeFace.NegativeZ, offset, Texture, 0, indiciesOffset, out indicies, Color.White);
correction = Vector3.Backward;
faceCorrection = (int)CubeFace.NegativeZ * 4;
break;
case LadderBlock.LadderDirection.East:
verticies = CreateQuad(CubeFace.NegativeX, offset, Texture, 0, indiciesOffset, out indicies, Color.White);
correction = Vector3.Right;
faceCorrection = (int)CubeFace.NegativeX * 4;
break;
case LadderBlock.LadderDirection.West:
verticies = CreateQuad(CubeFace.PositiveX, offset, Texture, 0, indiciesOffset, out indicies, Color.White);
correction = Vector3.Left;
faceCorrection = (int)CubeFace.PositiveX * 4;
break;
default:
// Should never happen
verticies = CreateUniformCube(offset, Texture, VisibleFaces.All,
indiciesOffset, out indicies, Color.White);
correction = Vector3.Zero;
break;
}
for (int i = 0; i < verticies.Length; i++)
{
verticies[i].Position += correction;
}
for (int i = 0; i < indicies.Length; i++)
{
indicies[i] -= faceCorrection;
}
return(verticies);
}
public static VertexPositionNormalColorTexture[] RenderBlock(IBlockProvider provider, BlockDescriptor descriptor,
VisibleFaces faces, Vector3 offset, int indiciesOffset, out int[] indicies)
{
var textureMap = provider.GetTextureMap(descriptor.Metadata);
if (textureMap == null)
{
textureMap = new Tuple <int, int>(0, 0); // TODO: handle this better
}
return(Renderers[descriptor.ID].Render(descriptor, offset, faces, textureMap, indiciesOffset, out indicies));
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var overhead = new Vector3(0.5f, 0.5f, 0.5f);
var centerized = new Vector3(7f / 16f, 0, 7f / 16f);
var cube = CreateUniformCube(overhead, Texture, VisibleFaces.All, indiciesOffset, out indicies, Color.White);
for (int i = 0; i < cube.Length; i++)
{
cube[i].Position.X *= 1f / 8f;
cube[i].Position.Z *= 1f / 8f;
if (cube[i].Position.Y > 0)
cube[i].Position.Y *= 5f / 8f;
switch ((TorchBlock.TorchDirection)descriptor.Metadata)
{
case TorchBlock.TorchDirection.West:
if (cube[i].Position.Y == 0)
cube[i].Position.X += 8f / 16f;
else
cube[i].Position.X += 3f / 16f;
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.East:
if (cube[i].Position.Y == 0)
cube[i].Position.X -= 8f / 16f;
else
cube[i].Position.X -= 3f / 16f;
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.North:
if (cube[i].Position.Y == 0)
cube[i].Position.Z += 8f / 16f;
else
cube[i].Position.Z += 3f / 16f;
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.South:
if (cube[i].Position.Y == 0)
cube[i].Position.Z -= 8f / 16f;
else
cube[i].Position.Z -= 3f / 16f;
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.Ground:
default:
// nop
break;
}
cube[i].Position += offset;
cube[i].Position += centerized;
cube[i].Position -= overhead;
}
return cube;
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
return CreateUniformCube(offset, Texture, faces, indiciesOffset, out indicies, Color.White, lighting);
}
/// <summary>
/// Incrementally update the existing hull using provided points.
/// </summary>
/// <param name="points">Points used to update the hull.</param>
public void Update(IList <Vector3> points)
{
var visible = new VisibleFaces();
var working_set = new LinkedList <Face>(Faces);
var final_set = new LinkedList <Face>();
sort_points(points, Faces); Faces.Clear();
while (working_set.Count > 0)
{
Face f = working_set.Pop();
//if the face was dropped, skip it
if (f.Dropped)
{
continue;
}
//if the face has no visible points it belongs to the hull
if (f.VisiblePoints.Count == 0)
{
final_set.AddFirst(f); continue;
}
//if not, build the visible set of faces and the horizon for the furthest visible point
visible.Clear();
build_horizon(f.Furthest, visible, f);
//create new faces
var new_faces = make_pyramid(f.Furthest, visible.Horizon);
//add points from visible faces to the new faces
for (int i = 0; i < visible.Count; i++)
{
sort_points(visible[i].VisiblePoints, new_faces);
}
//add new faces to the working set
for (int i = 0; i < new_faces.Count; i++)
{
working_set.AddFirst(new_faces[i]);
}
}
//filter out faces that are still visible
Faces.AddRange(from f in final_set where !f.Dropped select f);
//build a list of unique hull points
Volume = Area = 0;
var _Points = new HashSet <Vector3>();
for (int i = 0; i < Faces.Count; i++)
{
var f = Faces[i];
float area;
Volume += f.Volume(out area);
Area += area;
_Points.Add(f.v0); _Points.Add(f.v1); _Points.Add(f.v2);
}
Points = new List <Vector3>(_Points.Count);
Points.AddRange(_Points);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
var lighting = new int[6];
for (var i = 0; i < 6; i++)
{
var coords = descriptor.Coordinates + FaceCoords[i];
lighting[i] = GetLight(descriptor.Chunk, coords);
}
return(CreateUniformCube(offset, Texture, faces, indicesOffset, out indices, Color.White, lighting));
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var cube = CreateUniformCube(Vector3.Zero, Texture, faces, indiciesOffset, out indicies, Color.White);
var heightMultiplier = new Vector3(1, ((descriptor.Metadata + 1) / 16f), 1);
for (int i = 0; i < cube.Length; i++)
{
if (cube[i].Position.Y > 0)
cube[i].Position *= heightMultiplier;
cube[i].Position += offset;
}
return cube;
}
private void UpdateFacesFromAdjacent(Coordinates3D adjacent, ReadOnlyChunk chunk,
VisibleFaces mod, ref VisibleFaces faces)
{
if (chunk == null)
{
return;
}
var provider = BlockRepository.GetBlockProvider(chunk.GetBlockId(adjacent));
if (!provider.Opaque)
{
faces |= mod;
}
}
public static VertexPositionNormalColorTexture[] CreateUniformCube(Vector3 offset, Vector2[] texture,
VisibleFaces faces, int indiciesOffset, out int[] indicies, Color color, int[] lighting = null)
{
faces = VisibleFaces.All; // Temporary
if (lighting == null)
{
lighting = DefaultLighting;
}
var totalFaces = 0;
var f = (uint)faces;
while (f != 0)
{
if ((f & 1) == 1)
{
totalFaces++;
}
f >>= 1;
}
indicies = new int[6 * totalFaces];
var verticies = new VertexPositionNormalColorTexture[4 * totalFaces];
int[] _indicies;
var textureIndex = 0;
var sidesSoFar = 0;
for (var _side = 0; _side < 6; _side++)
{
if ((faces & VisibleForCubeFace[_side]) == 0)
{
textureIndex += 4;
continue;
}
var lightColor = LightColor.ToVector3() * CubeBrightness[lighting[_side]];
var side = (CubeFace)_side;
var quad = CreateQuad(side, offset, texture, textureIndex % texture.Length, indiciesOffset,
out _indicies, new Color(lightColor * color.ToVector3()));
Array.Copy(quad, 0, verticies, sidesSoFar * 4, 4);
Array.Copy(_indicies, 0, indicies, sidesSoFar * 6, 6);
textureIndex += 4;
sidesSoFar++;
}
return(verticies);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var cube = CreateUniformCube(Vector3.Zero, Texture, faces, indiciesOffset, out indicies, Color.White);
var heightMultiplier = new Vector3(1, ((descriptor.Metadata + 1) / 16f), 1);
for (int i = 0; i < cube.Length; i++)
{
if (cube[i].Position.Y > 0)
{
cube[i].Position *= heightMultiplier;
}
cube[i].Position += offset;
}
return(cube);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
int[] lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
VertexPositionNormalColorTexture[] verticies;
Vector3 correction;
int faceCorrection = 0;
switch ((LadderBlock.LadderDirection)descriptor.Metadata)
{
case LadderBlock.LadderDirection.North:
verticies = CreateQuad(CubeFace.PositiveZ, offset, Texture, 0, indiciesOffset, out indicies, Color.White);
correction = Vector3.Forward;
faceCorrection = (int)CubeFace.PositiveZ * 4;
break;
case LadderBlock.LadderDirection.South:
verticies = CreateQuad(CubeFace.NegativeZ, offset, Texture, 0, indiciesOffset, out indicies, Color.White);
correction = Vector3.Backward;
faceCorrection = (int)CubeFace.NegativeZ * 4;
break;
case LadderBlock.LadderDirection.East:
verticies = CreateQuad(CubeFace.NegativeX, offset, Texture, 0, indiciesOffset, out indicies, Color.White);
correction = Vector3.Right;
faceCorrection = (int)CubeFace.NegativeX * 4;
break;
case LadderBlock.LadderDirection.West:
verticies = CreateQuad(CubeFace.PositiveX, offset, Texture, 0, indiciesOffset, out indicies, Color.White);
correction = Vector3.Left;
faceCorrection = (int)CubeFace.PositiveX * 4;
break;
default:
// Should never happen
verticies = CreateUniformCube(offset, Texture, VisibleFaces.All,
indiciesOffset, out indicies, Color.White);
correction = Vector3.Zero;
break;
}
for (int i = 0; i < verticies.Length; i++)
verticies[i].Position += correction;
for (int i = 0; i < indicies.Length; i++)
indicies[i] -= faceCorrection;
return verticies;
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
// TODO: Rest of water rendering (shape and level and so on)
var overhead = new Vector3(0.5f, 0.5f, 0.5f);
var cube = CreateUniformCube(overhead, Texture, faces, indiciesOffset, out indicies, Color.DarkBlue);
for (int i = 0; i < cube.Length; i++)
{
if (cube[i].Position.Y > 0)
{
cube[i].Position.Y *= 14f / 16f;
}
cube[i].Position += offset;
cube[i].Position -= overhead;
}
return cube;
}
private void AddChunkBoundaryBlocks(Coordinates3D coords, RenderState state, ReadOnlyChunk chunk)
{
VisibleFaces faces;
if (!state.DrawableCoordinates.TryGetValue(coords, out faces))
{
faces = VisibleFaces.None;
}
VisibleFaces oldFaces = faces;
if (coords.X == 0)
{
var adjacent = coords;
adjacent.X = Chunk.Width - 1;
var nextChunk = World.GetChunk(chunk.Chunk.Coordinates + Coordinates2D.West);
UpdateFacesFromAdjacent(adjacent, nextChunk, VisibleFaces.West, ref faces);
}
else if (coords.X == Chunk.Width - 1)
{
var adjacent = coords;
adjacent.X = 0;
var nextChunk = World.GetChunk(chunk.Chunk.Coordinates + Coordinates2D.East);
UpdateFacesFromAdjacent(adjacent, nextChunk, VisibleFaces.East, ref faces);
}
if (coords.Z == 0)
{
var adjacent = coords;
adjacent.Z = Chunk.Depth - 1;
var nextChunk = World.GetChunk(chunk.Chunk.Coordinates + Coordinates2D.North);
UpdateFacesFromAdjacent(adjacent, nextChunk, VisibleFaces.North, ref faces);
}
else if (coords.Z == Chunk.Depth - 1)
{
var adjacent = coords;
adjacent.Z = 0;
var nextChunk = World.GetChunk(chunk.Chunk.Coordinates + Coordinates2D.South);
UpdateFacesFromAdjacent(adjacent, nextChunk, VisibleFaces.South, ref faces);
}
if (oldFaces != faces)
{
state.DrawableCoordinates[coords] = faces;
}
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
if (descriptor.Id == RoseBlock.BlockId)
{
return(RenderQuads(descriptor, offset, RoseTexture, indicesOffset, out indices, Color.White));
}
if (descriptor.Id == DandelionBlock.BlockId)
{
return(RenderQuads(descriptor, offset, DandelionTexture, indicesOffset, out indices, Color.White));
}
if (descriptor.Id == SaplingBlock.BlockId)
{
switch ((SaplingBlock.SaplingType)descriptor.Metadata)
{
case SaplingBlock.SaplingType.Oak:
default:
return(RenderQuads(descriptor, offset, OakSaplingTexture, indicesOffset, out indices,
Color.White));
case SaplingBlock.SaplingType.Spruce:
return(RenderQuads(descriptor, offset, SpruceSaplingTexture, indicesOffset, out indices,
Color.White));
case SaplingBlock.SaplingType.Birch:
return(RenderQuads(descriptor, offset, BirchSaplingTexture, indicesOffset, out indices,
Color.White));
}
}
switch ((TallGrassBlock.TallGrassType)descriptor.Metadata)
{
case TallGrassBlock.TallGrassType.DeadBush:
return(RenderQuads(descriptor, offset, DeadBushTexture, indicesOffset, out indices, Color.White));
case TallGrassBlock.TallGrassType.Fern:
return(RenderQuads(descriptor, offset, FernTexture, indicesOffset, out indices,
GrassRenderer.BiomeColor));
case TallGrassBlock.TallGrassType.TallGrass:
default:
return(RenderQuads(descriptor, offset, TallGrassTexture, indicesOffset, out indices,
GrassRenderer.BiomeColor));
}
}
public static VertexPositionNormalColorTexture[] CreateUniformCube(Vector3 offset, Vector2[] texture,
VisibleFaces faces, int indiciesOffset, out int[] indicies, Color color, int[] lighting = null)
{
faces = VisibleFaces.All; // Temporary
if (lighting == null)
lighting = DefaultLighting;
int totalFaces = 0;
uint f = (uint)faces;
while (f != 0)
{
if ((f & 1) == 1)
totalFaces++;
f >>= 1;
}
indicies = new int[6 * totalFaces];
var verticies = new VertexPositionNormalColorTexture[4 * totalFaces];
int[] _indicies;
int textureIndex = 0;
int sidesSoFar = 0;
for (int _side = 0; _side < 6; _side++)
{
if ((faces & VisibleForCubeFace[_side]) == 0)
{
textureIndex += 4;
continue;
}
var lightColor = LightColor.ToVector3() * CubeBrightness[lighting[_side]];
var side = (CubeFace)_side;
var quad = CreateQuad(side, offset, texture, textureIndex % texture.Length, indiciesOffset,
out _indicies, new Color(lightColor * color.ToVector3()));
Array.Copy(quad, 0, verticies, sidesSoFar * 4, 4);
Array.Copy(_indicies, 0, indicies, sidesSoFar * 6, 6);
textureIndex += 4;
sidesSoFar++;
}
return verticies;
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
// TODO: Rest of water rendering (shape and level and so on)
var overhead = new Vector3(0.5f, 0.5f, 0.5f);
var cube = CreateUniformCube(overhead, Texture, faces, indiciesOffset, out indicies, Color.Blue, lighting);
for (int i = 0; i < cube.Length; i++)
{
if (cube[i].Position.Y > 0)
{
cube[i].Position.Y *= 14f / 16f;
}
cube[i].Position += offset;
cube[i].Position -= overhead;
}
return cube;
}
public virtual VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var texCoords = new Vector2(textureMap.Item1, textureMap.Item2);
var texture = new[]
{
texCoords + Vector2.UnitX + Vector2.UnitY,
texCoords + Vector2.UnitY,
texCoords,
texCoords + Vector2.UnitX
};
for (int i = 0; i < texture.Length; i++)
texture[i] *= new Vector2(16f / 256f);
var lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
return CreateUniformCube(offset, texture, faces, indiciesOffset, out indicies, Color.White, lighting);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
switch ((WoodBlock.WoodType)descriptor.Metadata)
{
case WoodBlock.WoodType.Spruce:
return CreateUniformCube(offset, SpruceTextures, VisibleFaces.All,
indiciesOffset, out indicies, GrassRenderer.BiomeColor, lighting);
case WoodBlock.WoodType.Birch:
return CreateUniformCube(offset, BaseTextures, VisibleFaces.All,
indiciesOffset, out indicies, GrassRenderer.BiomeColor, lighting);
case WoodBlock.WoodType.Oak:
default:
return CreateUniformCube(offset, BaseTextures, VisibleFaces.All,
indiciesOffset, out indicies, GrassRenderer.BiomeColor, lighting);
}
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
// Wheat is rendered by rendering the four vertical faces of a cube, then moving them
// towards the middle. We also render a second set of four faces so that you can see
// each face from the opposite side (to avoid culling)
var texture = Textures[0];
if (descriptor.Metadata < Textures.Length)
texture = Textures[descriptor.Metadata];
indicies = new int[4 * 2 * 6];
var verticies = new VertexPositionNormalColorTexture[4 * 2 * 6];
int[] _indicies;
for (int _side = 0; _side < 4; _side++) // Y faces are the last two in the CubeFace enum, so we can just iterate to 4
{
var side = (CubeFace)_side;
var quad = CreateQuad(side, Vector3.Zero, texture, 0, indiciesOffset, out _indicies, Color.White);
if (side == CubeFace.NegativeX || side == CubeFace.PositiveX)
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.X *= 0.5f;
quad[i].Position += offset;
}
}
else
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.Z *= 0.5f;
quad[i].Position += offset;
}
}
Array.Copy(quad, 0, verticies, _side * 4, 4);
Array.Copy(_indicies, 0, indicies, _side * 6, 6);
}
indiciesOffset += 4 * 6;
for (int _side = 0; _side < 4; _side++)
{
var side = (CubeFace)_side;
var quad = CreateQuad(side, Vector3.Zero, texture, 0, indiciesOffset, out _indicies, Color.White);
if (side == CubeFace.NegativeX || side == CubeFace.PositiveX)
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.X *= 0.5f;
quad[i].Position.X = -quad[i].Position.X;
quad[i].Position += offset;
}
}
else
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.Z *= 0.5f;
quad[i].Position.Z = -quad[i].Position.Z;
quad[i].Position += offset;
}
}
Array.Copy(quad, 0, verticies, _side * 4 + 4 * 4, 4);
Array.Copy(_indicies, 0, indicies, _side * 6 + 6 * 4, 6);
}
for (int i = 0; i < verticies.Length; i++)
{
verticies[i].Position.Y -= 1 / 16f;
}
return verticies;
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
return CreateUniformCube(offset, Texture, faces, indiciesOffset, out indicies, Color.White);
}
private void RenderSilhouetteTolerance(ProjectedGeometry geometry, RenderBuffer rasterization, VisibleFaces faces)
{
List <Edge> silhouetteEdges = null;
// Choose list based on triangle winding/facing
switch (faces)
{
case VisibleFaces.Front:
silhouetteEdges = geometry.FrontFaceSilhouetteEdges;
break;
case VisibleFaces.Back:
silhouetteEdges = geometry.BackFaceSilhouetteEdges;
break;
default:
throw new NotSupportedException("Cannot render these type of faces: " + faces);
}
// Outline edge detection
if (RenderTolerance.SilhouetteEdgeTolerance > 0)
{
// Create a set of triangles that will draw lines on the tolerance buffer
SilhouetteEdgeTriangle[] edgeTriangles = new SilhouetteEdgeTriangle[2 * silhouetteEdges.Count];
int count = 0;
//double the silhouette pixel tolerance in nonstandard DPI scenario.
//This compensates for differences in anti-aliasing sampling patterns in high and low DPI
double tolerance = RenderTolerance.SilhouetteEdgeTolerance;
if (!RenderTolerance.IsSquare96Dpi)
{
tolerance *= 4;
}
foreach (Edge edge in silhouetteEdges)
{
// FWD triangle
edgeTriangles[count++] = new SilhouetteEdgeTriangle(edge.Start, edge.End, tolerance);
// BWD triangle
edgeTriangles[count++] = new SilhouetteEdgeTriangle(edge.End, edge.Start, tolerance);
}
// Render our ignore geometry onto the tolerance buffer.
RenderToToleranceShader edgeIgnore = new RenderToToleranceShader(edgeTriangles, rasterization);
edgeIgnore.Rasterize(bounds.RenderBounds);
}
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
if (descriptor.ID == RoseBlock.BlockID)
return RenderQuads(descriptor, offset, RoseTexture, indiciesOffset, out indicies, Color.White);
else if (descriptor.ID == DandelionBlock.BlockID)
return RenderQuads(descriptor, offset, DandelionTexture, indiciesOffset, out indicies, Color.White);
else if (descriptor.ID == SaplingBlock.BlockID)
{
switch ((SaplingBlock.SaplingType)descriptor.Metadata)
{
case SaplingBlock.SaplingType.Oak:
default:
return RenderQuads(descriptor, offset, OakSaplingTexture, indiciesOffset, out indicies, Color.White);
case SaplingBlock.SaplingType.Spruce:
return RenderQuads(descriptor, offset, SpruceSaplingTexture, indiciesOffset, out indicies, Color.White);
case SaplingBlock.SaplingType.Birch:
return RenderQuads(descriptor, offset, BirchSaplingTexture, indiciesOffset, out indicies, Color.White);
}
}
else
{
switch ((TallGrassBlock.TallGrassType)descriptor.Metadata)
{
case TallGrassBlock.TallGrassType.DeadBush:
return RenderQuads(descriptor, offset, DeadBushTexture, indiciesOffset, out indicies, Color.White);
case TallGrassBlock.TallGrassType.Fern:
return RenderQuads(descriptor, offset, FernTexture, indiciesOffset, out indicies, GrassRenderer.BiomeColor);
case TallGrassBlock.TallGrassType.TallGrass:
default:
return RenderQuads(descriptor, offset, TallGrassTexture, indiciesOffset, out indicies, GrassRenderer.BiomeColor);
}
}
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
switch ((WoodBlock.WoodType)descriptor.Metadata)
{
case WoodBlock.WoodType.Spruce:
return CreateUniformCube(offset, SpruceTexture, faces, indiciesOffset, out indicies, Color.White);
case WoodBlock.WoodType.Birch:
return CreateUniformCube(offset, BirchTexture, faces, indiciesOffset, out indicies, Color.White);
case WoodBlock.WoodType.Oak:
default:
return CreateUniformCube(offset, BaseTexture, faces, indiciesOffset, out indicies, Color.White);
}
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Microsoft.Xna.Framework.Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var texture = Texture;
if (descriptor.Coordinates.Y < World.Height && descriptor.Chunk != null)
{
if (descriptor.Chunk.GetBlockID(descriptor.Coordinates + Coordinates3D.Up) == SnowfallBlock.BlockID)
{
texture = SnowTexture;
}
}
var cube = CreateUniformCube(offset, texture, faces, indiciesOffset, out indicies, Color.White);
// Apply biome colors to top of cube
for (int i = (int)(CubeFace.PositiveY) * 4; i < (int)(CubeFace.PositiveY) * 4 + 4; i++)
{
cube[i].Color = new Color(cube[i].Color.ToVector3() * BiomeColor.ToVector3()); // TODO: Take this from biome
}
return cube;
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indiciesOffset, out int[] indicies)
{
int[] lighting = new int[6];
for (int i = 0; i < 6; i++)
{
var coords = (descriptor.Coordinates + FaceCoords[i]);
lighting[i] = GetLight(descriptor.Chunk, coords);
}
var centerized = new Vector3(7f / 16f, 0, 7f / 16f);
var cube = CreateUniformCube(Vector3.Zero, Texture, VisibleFaces.All,
indiciesOffset, out indicies, Color.White, lighting);
for (int i = 0; i < cube.Length; i++)
{
cube[i].Position.X *= 1f / 8f;
cube[i].Position.Z *= 1f / 8f;
if (cube[i].Position.Y > 0)
{
cube[i].Position.Y *= 5f / 8f;
}
switch ((TorchBlock.TorchDirection)descriptor.Metadata)
{
case TorchBlock.TorchDirection.West:
if (cube[i].Position.Y == 0)
{
cube[i].Position.X += 8f / 16f;
}
else
{
cube[i].Position.X += 3f / 16f;
}
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.East:
if (cube[i].Position.Y == 0)
{
cube[i].Position.X -= 8f / 16f;
}
else
{
cube[i].Position.X -= 3f / 16f;
}
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.North:
if (cube[i].Position.Y == 0)
{
cube[i].Position.Z += 8f / 16f;
}
else
{
cube[i].Position.Z += 3f / 16f;
}
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.South:
if (cube[i].Position.Y == 0)
{
cube[i].Position.Z -= 8f / 16f;
}
else
{
cube[i].Position.Z -= 3f / 16f;
}
cube[i].Position.Y += 5f / 16f;
break;
case TorchBlock.TorchDirection.Ground:
default:
// nop
break;
}
cube[i].Position += offset;
cube[i].Position += centerized;
}
return(cube);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
// This is similar to how wheat is rendered
indices = new int[5 * 6];
var verticies = new VertexPositionNormalColorTexture[5 * 6];
int[] _indicies;
var center = new Vector3(-0.5f, -0.5f, -0.5f);
CubeFace side;
VertexPositionNormalColorTexture[] quad;
for (var _side = 0; _side < 4; _side++)
{
side = (CubeFace)_side;
quad = CreateQuad(side, center, Texture, 0, indicesOffset, out _indicies, Color.White);
if (side == CubeFace.NegativeX || side == CubeFace.PositiveX)
{
for (var i = 0; i < quad.Length; i++)
{
quad[i].Position.X *= 14f / 16f;
quad[i].Position += offset;
}
}
else
{
for (var i = 0; i < quad.Length; i++)
{
quad[i].Position.Z *= 14f / 16f;
quad[i].Position += offset;
}
}
Array.Copy(quad, 0, verticies, _side * 4, 4);
Array.Copy(_indicies, 0, indices, _side * 6, 6);
}
side = CubeFace.PositiveY;
quad = CreateQuad(side, center, TopTexture, 0, indicesOffset, out _indicies, Color.White);
if (side == CubeFace.NegativeX || side == CubeFace.PositiveX)
{
for (var i = 0; i < quad.Length; i++)
{
quad[i].Position.X *= 14f / 16f;
quad[i].Position += offset;
}
}
else
{
for (var i = 0; i < quad.Length; i++)
{
quad[i].Position.Z *= 14f / 16f;
quad[i].Position += offset;
}
}
Array.Copy(quad, 0, verticies, (int)side * 4, 4);
Array.Copy(_indicies, 0, indices, (int)side * 6, 6);
for (var i = 0; i < verticies.Length; i++)
{
verticies[i].Position.Y -= 1 / 16f;
verticies[i].Position -= center;
}
return(verticies);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indiciesOffset, out int[] indicies)
{
// Wheat is rendered by rendering the four vertical faces of a cube, then moving them
// towards the middle. We also render a second set of four faces so that you can see
// each face from the opposite side (to avoid culling)
var texture = Textures[0];
if (descriptor.Metadata < Textures.Length)
{
texture = Textures[descriptor.Metadata];
}
indicies = new int[4 * 2 * 6];
var verticies = new VertexPositionNormalColorTexture[4 * 2 * 6];
int[] _indicies;
var center = new Vector3(-0.5f, -0.5f, -0.5f);
for (int _side = 0; _side < 4; _side++) // Y faces are the last two in the CubeFace enum, so we can just iterate to 4
{
var side = (CubeFace)_side;
var quad = CreateQuad(side, center, texture, 0, indiciesOffset, out _indicies, Color.White);
if (side == CubeFace.NegativeX || side == CubeFace.PositiveX)
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.X *= 0.5f;
quad[i].Position += offset;
}
}
else
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.Z *= 0.5f;
quad[i].Position += offset;
}
}
Array.Copy(quad, 0, verticies, _side * 4, 4);
Array.Copy(_indicies, 0, indicies, _side * 6, 6);
}
indiciesOffset += 4 * 6;
for (int _side = 0; _side < 4; _side++)
{
var side = (CubeFace)_side;
var quad = CreateQuad(side, center, texture, 0, indiciesOffset, out _indicies, Color.White);
if (side == CubeFace.NegativeX || side == CubeFace.PositiveX)
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.X *= 0.5f;
quad[i].Position.X = -quad[i].Position.X;
quad[i].Position += offset;
}
}
else
{
for (int i = 0; i < quad.Length; i++)
{
quad[i].Position.Z *= 0.5f;
quad[i].Position.Z = -quad[i].Position.Z;
quad[i].Position += offset;
}
}
Array.Copy(quad, 0, verticies, _side * 4 + 4 * 4, 4);
Array.Copy(_indicies, 0, indicies, _side * 6 + 6 * 4, 6);
}
for (int i = 0; i < verticies.Length; i++)
{
verticies[i].Position.Y -= 1 / 16f;
verticies[i].Position -= center;
}
return(verticies);
}
public virtual VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var texCoords = new Vector2(textureMap.Item1, textureMap.Item2);
var texture = new[]
{
texCoords + Vector2.UnitX + Vector2.UnitY,
texCoords + Vector2.UnitY,
texCoords,
texCoords + Vector2.UnitX
};
for (int i = 0; i < texture.Length; i++)
texture[i] *= new Vector2(16f / 256f);
return CreateUniformCube(offset, texture, faces, indiciesOffset, out indicies, Color.White, descriptor.BlockLight);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
var texture = DryTexture;
if (descriptor.Metadata == (byte)FarmlandBlock.MoistureLevel.Moist)
texture = MoistTexture;
var overhead = new Vector3(0.5f, 0.5f, 0.5f);
var cube = CreateUniformCube(overhead, texture, faces, indiciesOffset, out indicies, Color.White);
for (int i = 0; i < cube.Length; i++)
{
if (cube[i].Position.Y > 0)
{
cube[i].Position.Y *= 15f / 16f;
}
cube[i].Position += offset;
cube[i].Position -= overhead;
}
return cube;
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple<int, int> textureMap, int indiciesOffset, out int[] indicies)
{
if (descriptor.ID == SlabBlock.BlockID)
return RenderSlab(descriptor, offset, textureMap, indiciesOffset, out indicies);
else
return RenderDoubleSlab(descriptor, offset, textureMap, indiciesOffset, out indicies);
}
public override VertexPositionNormalColorTexture[] Render(BlockDescriptor descriptor, Vector3 offset,
VisibleFaces faces, Tuple <int, int> textureMap, int indicesOffset, out int[] indices)
{
return(RenderQuads(descriptor, offset, Texture, indicesOffset, out indices, Color.White));
}
private void RenderGeometry(ProjectedGeometry pg, Matrix3D view, Material material, VisibleFaces faces)
{
if (material == null)
{
return;
}
Triangle[] triangles = null;
// Choose list based on triangle winding/facing
switch (faces)
{
case VisibleFaces.Front:
triangles = pg.FrontFaceTriangles;
break;
case VisibleFaces.Back:
triangles = pg.BackFaceTriangles;
break;
default:
throw new NotSupportedException("Cannot render these type of faces: " + faces.ToString());
}
// We should only look into materials if we have any geometry to render.
// Doing otherwise will throw exceptions when trying to use screen-space
// bounds or UV coordinates.
if (triangles.Length > 0)
{
// Create a flat, ordered list of textures to apply to this model
List <Material> materials = ExtractMaterials(material);
// Create a list of textures from the materials
TextureFilter[] textures = TextureFilter.CreateTextures(
materials, pg.OriginalMinUV, pg.OriginalMaxUV, Rect.Intersect(bounds.RenderBounds, pg.ScreenSpaceBounds));
// Use a precomputed light shader
Shader shader = null;
if (interpolation == InterpolationMode.Phong)
{
shader = new PrecomputedPhongShader(triangles, buffer, lights, textures, view);
}
else
{
shader = new PrecomputedGouraudShader(triangles, buffer, lights, textures, view);
}
shader.Rasterize(bounds.RenderBounds);
RenderSilhouetteTolerance(pg, buffer, faces);
}
}
