public override void OnRender(RenderView view)
{
List<Matrix>[] transforms = new List<Matrix>[grassHighDetail.Length];
BoundingFrustum frustum = view.GetFrustum();
for (int i = 0; i < grassTransforms.Keys.Count; i++)
{
int key = grassTransforms.Keys[i];
//if (frustum.Contains(grassTransforms[key].Bounds) != ContainmentType.Disjoint)
{
int index = grassTransforms[key].GrassGeometryIndex;
if(transforms[index] == null)
transforms[index] = new List<Matrix>();
transforms[index].Add(grassTransforms[key].Transform);
}
}
for (int i = 0; i < grassHighDetail.Length; i++)
{
if (transforms[i] != null)
{
grassHighDetail[i].Transform = transforms[i].ToArray();
view.AddElement(grassMaterial, grassHighDetail[i]);
}
}
base.OnRender(view);
}
public override void OnRender(RenderView view)
{
base.OnRender(view);
int zStart = camZ - CloudBlocksH;
int zEnd = camZ + CloudBlocksH;
int yStart = camY - CloudBlocksV;
int yEnd = camY + CloudBlocksV;
int xStart = camX - CloudBlocksH;
int xEnd = camX + CloudBlocksH;
Vector3 camPos = view.GetPosition();
BoundingFrustum camFrustum = view.GetFrustum();
for (int z = zStart; z <= zEnd; z++)
{
long zOff = sliceArea * (long)z;
for (int y = yStart; y <= yEnd; y++)
{
long yOff = width * (long)y;
for (int x = xStart; x <= xEnd; x++)
{
long idx = (long)x + yOff + zOff;
if (clusterCollection.ContainsKey(idx))
{
ForestManager currCluster = clusterCollection[idx];
clusterCollection[idx].OnRender(view);
}
}
}
}
}
public override void OnRender(RenderView view)
{
BoundingFrustum frustum = view.GetFrustum();
if (frustum.Contains(boundingBox) != ContainmentType.Disjoint && !collected)
{
}
base.OnRender(view);
}
public override void OnRender(RenderView view)
{
BoundingFrustum frustum = view.GetFrustum();
if (frustum.Contains(bounds) != ContainmentType.Disjoint)
{
view.AddElement(gateMaterial, gateGeometry.renderElement);
}
base.OnRender(view);
}
public override void OnRender(RenderView view)
{
base.OnRender(view);
if (view.GetRenderType() == RenderViewType.MAIN)
{
if (view.GetFrustum().Contains(bounds) != ContainmentType.Disjoint)
{
MainRenderView renderView = (MainRenderView)view;
renderView.AddDecalElement(material, transform);
}
}
}
public override void OnRender(RenderView view)
{
BoundingFrustum frustm = view.GetFrustum();
for (int i = 0; i < Voxels.Count; i++)
{
if(Voxels.Values[i].CanRender)//if (frustm.Contains(VoxelBounds.Values[i]) != ContainmentType.Disjoint && Voxels.Values[i].CanRender)
{
view.AddElement(terrainMaterial, Voxels.Values[i].renderElement);
}
}
base.OnRender(view);
}
public override void OnRender(RenderView view)
{
BoundingFrustum frustum = view.GetFrustum();
if (frustum.Contains(boundingBox) != ContainmentType.Disjoint)
{
int barkNum = varyTreeNum / 2;
view.AddElement(treeMaterials[8 + barkNum], Voxels[0]);
view.AddElement(treeMaterials[varyTreeNum], Voxels[1]);
}
base.OnRender(view);
}
public override void OnRender(RenderView view)
{
BoundingFrustum frustum = view.GetFrustum();
for (int i = 0; i < clusterCollection.Values.Count; i++)
{
ShapeCluster currCluster = clusterCollection.Values[i];
if (currCluster != null && frustum.Contains(currCluster.Bounds) != ContainmentType.Disjoint)
{
for (int j = 0; j < currCluster.Transforms.Count; j++)
{
int currKey = currCluster.Transforms.Keys[j];
for (int l = 0; l < currCluster.Transforms[currKey].Count; l++)
{
meshSets[currKey].Render(currCluster.Transforms[currKey][l], view, true);
}
}
}
}
base.OnRender(view);
}
public override void OnRender(RenderView view)
{
BoundingFrustum frustum = view.GetFrustum();
view.AddElement(terrainQuadMaterial, giantQuadElement);
RecursivelyRender(voxelKDTree.GetRoot(), view);
/*
if (view.GetRenderType() == RenderViewType.MAIN)
{
RecursivelyRenderDebug(voxelKDTree.GetRoot(), view, 0, false);
GUIElementManager guiElem = GFX.Inst.GetGUI();
guiElem.AddElement(new GUITextElement(new Vector2(-0.85f, 0.95f), "Depth: " + maxDepth));
}
for (int i = 0; i < Voxels.Length; i++)
{
if (Voxels[i].CanRender && frustum.Contains(VoxelBounds[i]) != ContainmentType.Disjoint)
{
view.AddElement(terrainMaterial, Voxels[i].renderElement);
}
}
*/
base.OnRender(view);
}
void RecursivelyRender(KDNode<VoxelElement> node, RenderView view)
{
if (node == null || (view.GetFrustum().Contains(node.bounds) == ContainmentType.Disjoint))// && node.bounds.Contains(view.GetPosition()) == ContainmentType.Disjoint))
return;
if (node.element != null && (view.GetFrustum().Contains(node.element.bounds) != ContainmentType.Disjoint))
{
view.AddElement(terrainMaterial, node.element.geometry.renderElement);
}
RecursivelyRender(node.leftChild, view);
RecursivelyRender(node.rightChild, view);
}
public void OnRender(RenderView view, bool performCulling)
{
if (performCulling && view.GetFrustum().Contains(hitBounds) == ContainmentType.Disjoint)
return;
if (rootNodes != null && rootNodes.Length > 0)
{
//mesh.Render(worldMat, vertexBuffer, view, performCulling);
mesh.Render(transforms, view, performCulling);
}
else
mesh.Render(worldMat, view, performCulling);
}
void RecursivelyRender(KDNode<ForestElement> node, RenderView view)
{
if (node == null || view.GetFrustum().Contains(node.bounds) == ContainmentType.Disjoint)
return;
node.element.Mesh.Render(node.element.Transform.GetTransform(), view, false);
RecursivelyRender(node.leftChild, view);
RecursivelyRender(node.rightChild, view);
}
public void RenderImposters(Matrix transform, RenderView view, bool performCulling)
{
if (useInstancing && !addedToView)
{
view.AddMeshToRender(this);
addedToView = true;
}
if (performCulling)
{
BoundingFrustum frustum = view.GetFrustum();
Matrix oldMat = frustum.Matrix;
frustum.Matrix = transform * view.GetViewProjection();
if (imposterGeometry != null && frustum.Contains(meshBounds) != ContainmentType.Disjoint)
{
Matrix tempTransform = imposterGeometry.Scale * transform;
if (useInstancing)
{
imposterGeometry.transforms.Add(tempTransform);
//InjectTransform(ref tempTransform, ref imposterInstanceTemp, ref imposterInstanceCount, ref imposterInstanceTexture);
}
else
{
imposterGeometry.Element.Transform = new Matrix[1] {tempTransform};
view.AddElement(imposterGeometry.ImposterMaterial, imposterGeometry.Element);
}
}
frustum.Matrix = oldMat;
}
else if (imposterGeometry != null)
{
Matrix tempTransform = imposterGeometry.Scale * transform;
if (useInstancing)
{
imposterGeometry.transforms.Add(tempTransform);
//InjectTransform(ref transform, ref imposterInstanceTemp, ref imposterInstanceCount, ref imposterInstanceTexture);
}
else
{
imposterGeometry.Element.Transform = new Matrix[1] {tempTransform};
view.AddElement(imposterGeometry.ImposterMaterial, imposterGeometry.Element);
}
}
}
public void Render(Matrix transform, VertexBuffer animBuffer, RenderView view, bool performCulling)
{
if (performCulling)
{
BoundingFrustum frustum = view.GetFrustum();
Matrix oldMat = frustum.Matrix;
frustum.Matrix = transform * view.GetViewProjection();
for (int i = 0; i < parts.Length; i++)
{
if (frustum.Contains(parts[i].bounds) != ContainmentType.Disjoint)
{
RenderElement element = parts[i].renderElement;
element.VertexBuffer = animBuffer;
element.Transform = new Matrix[1] { transform };
element.IsAnimated = true;
view.AddElement(parts[i].material, element);
}
}
frustum.Matrix = oldMat;
}
else
{
for (int i = 0; i < parts.Length; i++)
{
RenderElement element = parts[i].renderElement;
element.VertexBuffer = animBuffer;
element.Transform = new Matrix[1] { transform };
element.IsAnimated = true;
view.AddElement(parts[i].material, element);
}
}
}
public void Render(Matrix transform, RenderView view, bool performCulling)
{
if (useInstancing && !addedToView)
{
view.AddMeshToRender(this);
addedToView = true;
}
if (performCulling)
{
BoundingFrustum frustum = view.GetFrustum();
Matrix oldMat = frustum.Matrix;
frustum.Matrix = transform * view.GetViewProjection();
if (frustum.Contains(meshBounds) != ContainmentType.Disjoint)
{
if (useInstancing)
{
transforms.Add(transform);
//InjectTransform(ref transform, ref instanceTemp, ref instanceCount, ref instanceTexture);
}
else
{
for (int i = 0; i < parts.Length; i++)
{
if (frustum.Contains(parts[i].bounds) != ContainmentType.Disjoint)
{
parts[i].renderElement.Transform = new Matrix[1] {transform};
view.AddElement(parts[i].material, parts[i].renderElement);
}
}
}
}
frustum.Matrix = oldMat;
}
else
{
if (useInstancing)
{
transforms.Add(transform);
//InjectTransform(ref transform, ref instanceTemp, ref instanceCount, ref instanceTexture);
}
else
{
for (int i = 0; i < parts.Length; i++)
{
parts[i].renderElement.Transform = new Matrix[1] { transform };
view.AddElement(parts[i].material, parts[i].renderElement);
}
}
}
}
public void OnRender(RenderView renderView)
{
BoundingFrustum frustum = renderView.GetFrustum();
for (int j = 0; j < patches.Count; j++)
{
if (patches.Values[j].CanRender && frustum.Contains(patches.Values[j].Bounds) != ContainmentType.Disjoint)
{
for (int i = 0; i < patches.Values[j].Elements.Length; i++)
renderView.AddElement(patches.Values[j].Materials[i], patches.Values[j].Elements[i]);
}
}
}
void RecursivelyRender(KDNode<ForestElement> node, RenderView view)
{
if (node == null || view.GetFrustum().Contains(node.bounds) == ContainmentType.Disjoint)
return;
if (node.element != null && (view.GetFrustum().Contains(node.element.Bounds) != ContainmentType.Disjoint))
{
if (view.GetRenderType() == RenderViewType.MAIN && useImposters)
{
float distToCamera = Vector3.DistanceSquared(node.element.Transform.GetPosition(), view.GetPosition());
node.element.RenderImposters = (distToCamera >= GFXShaderConstants.IMPOSTERDISTANCESQUARED) ? ImposterState.Enabled : ImposterState.Disabled;
if (node.element.RenderImposters == ImposterState.Enabled && distToCamera <= GFXShaderConstants.IMPOSTER_DISTANCE_FALLOFF)
{
node.element.RenderImposters = ImposterState.Both;
}
if (distToCamera > GFXShaderConstants.GRASS_FADE_SQUARED)
node.element.RenderImposters = ImposterState.None;
}
if (useImposters)
{
if (node.element.RenderImposters != ImposterState.None)
{
if (node.element.RenderImposters == ImposterState.Enabled || node.element.RenderImposters == ImposterState.Both)
node.element.Mesh.RenderImposters(node.element.Transform.GetTransform(), view, false);
if (node.element.RenderImposters == ImposterState.Disabled || node.element.RenderImposters == ImposterState.Both)
node.element.Mesh.Render(node.element.Transform.GetTransform(), view, false);
}
}
else
node.element.Mesh.Render(node.element.Transform.GetTransform(), view, false);
nodesRendered++;
}
RecursivelyRender(node.leftChild, view);
RecursivelyRender(node.rightChild, view);
}
public override void OnRender(RenderView view)
{
bool canRender = (view.GetFrustum().Contains(Transformation.GetBounds()) != ContainmentType.Disjoint);
canRender |= (type == LightType.Directional);
if (canRender)
{
LightElementManager lightMgr = (LightElementManager)view.GetRenderElementManager(RenderPass.Light);
if (lightMgr != null)
{
switch (type)
{
case LightType.Directional:
if (castsShadows)
lightMgr.DirectionalShadowLights.Enqueue(this);
else
lightMgr.DirectionalLights.Enqueue(this);
break;
case LightType.Point:
lightMgr.PointLights.Enqueue(this);
break;
case LightType.Spot:
lightMgr.SpotLights.Enqueue(this);
break;
}
}
}
base.OnRender(view);
}
void RecursivelyRenderDebug(KDNode<ForestElement> node, RenderView view, int depth, bool isLeft)
{
if (node == null || view.GetFrustum().Contains(node.bounds) == ContainmentType.Disjoint)
return;
Gaia.Rendering.DebugElementManager debugMgr = (Gaia.Rendering.DebugElementManager)view.GetRenderElementManager(Gaia.Rendering.RenderPass.Debug);
Color currColor = (isLeft) ? nodeColorsLeft[depth % nodeColorsLeft.Length] : nodeColors[depth % nodeColors.Length];
debugMgr.AddElements(DebugHelper.GetVerticesFromBounds(node.bounds, currColor));
/*
if (node.element != null)
{
debugMgr.AddElements(DebugHelper.GetVerticesFromBounds(node.element.Bounds, Color.White));
}*/
depth++;
if (depth < maxDepth)
{
RecursivelyRenderDebug(node.leftChild, view, depth, true);
RecursivelyRenderDebug(node.rightChild, view, depth, false);
}
}
