public void RenderLightmaps(Camera renderCamera, DwarfTime gameTime, GraphicsDevice graphicsDevice,
Effect effect, Matrix worldMatrix)
{
RasterizerState state = RasterizerState.CullNone;
RasterizerState origState = graphicsDevice.RasterizerState;
effect.CurrentTechnique = effect.Techniques["Lightmap"];
effect.Parameters["xIllumination"].SetValue(ChunkData.IllumMap);
effect.Parameters["xTexture"].SetValue(ChunkData.Tilemap);
effect.Parameters["xSunGradient"].SetValue(ChunkData.SunMap);
effect.Parameters["xAmbientGradient"].SetValue(ChunkData.AmbientMap);
effect.Parameters["xTorchGradient"].SetValue(ChunkData.TorchMap);
effect.Parameters["xTint"].SetValue(new Vector4(1.0f, 1.0f, 1.0f, 1.0f));
effect.Parameters["SelfIllumination"].SetValue(1);
effect.Parameters["xEnableShadows"].SetValue(GameSettings.Default.UseDynamicShadows ? 1 : 0);
graphicsDevice.RasterizerState = state;
Graphics.BlendState = BlendState.NonPremultiplied;
List<VoxelChunk> renderListCopy = RenderList.ToArray().ToList();
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
foreach (VoxelChunk chunk in renderListCopy)
{
Graphics.SetRenderTarget(chunk.Primitive.Lightmap);
Graphics.Clear(ClearOptions.Target, Color.Black, 0.0f, 0);
chunk.Render(Graphics);
}
}
Graphics.SetRenderTarget(null);
effect.Parameters["SelfIllumination"].SetValue(0);
effect.CurrentTechnique = effect.Techniques["Textured"];
graphicsDevice.RasterizerState = origState;
}
void OnPostRender()
{
if (_renderLists.Count == 0)
{
return;
}
for (int i = 0; i < _renderLists.Count; i++)
{
RenderList renderList = _renderLists [i];
foreach (Rect rectangle in renderList.rectangles)
{
if (renderList.wireframe)
{
DrawWireframe(rectangle, renderList.material);
}
else
{
DrawUtils.DrawQuad(rectangle.center, rectangle.width, rectangle.height, new Rect(0, 0, 1, 1), renderList.material);
if (_outlineMaterial != null)
{
DrawWireframe(rectangle, _outlineMaterial);
}
}
}
}
}
internal void render(RenderList list, RenderObject obj, ref Transform parent, byte drawLayers = 255)
{
Transform trs = Local * parent;
uint pos;
if (this.forceBillboard)
{
list.Camera.MakeBillboard(ref trs);
}
if (0 != (drawLayers & ChildrenDrawLayerMask))
{
GeoNode node;
for (pos = NumImmediate, node = FirstChild; 0 != pos; node = node.Sibling, --pos)
{
if (0 != (drawLayers & node.DrawLayerMask))
{
node.render(list, obj, ref trs, drawLayers);
}
}
}
if (0 != (drawLayers & SelfDrawLayerMask))
{
OpenTK.Vector4 viewProj = list.Camera.ViewProj * new OpenTK.Vector4(trs.translation, 1f);
GeoModel model;
for (pos = ModelCount, model = FirstModel; 0 != pos; model = model.Next, --pos)
{
if (0 != (drawLayers & model.DrawLayerMask))
{
RenderLayer.Insert(list, obj, model, ref trs, ref viewProj, (byte)(drawLayers & model.DrawLayerMask));
}
}
}
}
internal void BuildRenderList(RenderList renderList, CameraComponent camera)
{
if (ShowTerrain)
{
Terrain?.BuildRenderList(renderList);
}
if (ShowRoads)
{
foreach (var road in Roads)
{
road.BuildRenderList(renderList);
}
}
if (ShowObjects)
{
foreach (var gameObject in GameObjects.Items)
{
gameObject.BuildRenderList(renderList, camera);
}
}
_particleSystemManager.BuildRenderList(renderList);
}
internal void BuildRenderList(RenderList renderList, RenderInstanceData instanceData, MeshEffect effect)
{
var uniquePipelineStates = MaterialPasses
.SelectMany(x => x.MeshParts.Select(y => y.PipelineStateHandle))
.Distinct()
.ToList();
foreach (var pipelineStateHandle in uniquePipelineStates)
{
var filteredMaterialPasses = MaterialPasses
.Where(x => x.MeshParts.Any(y => y.PipelineStateHandle == pipelineStateHandle))
.ToList();
if (filteredMaterialPasses.Count > 0)
{
renderList.AddRenderItem(new InstancedRenderItem(
instanceData,
effect,
pipelineStateHandle,
(commandEncoder, e, h, _) =>
{
Draw(
commandEncoder,
effect,
h,
filteredMaterialPasses,
instanceData);
}));
}
}
}
protected virtual void RenderDiagramElementsLayer(Graphics graphics, RenderList renderlist, Layer layer)
{
foreach (Element element in renderlist)
{
if (element.Layer == layer && element.Visible)
{
//Draw shapes
graphics.TranslateTransform(element.Rectangle.X, element.Rectangle.Y);
RenderElement(graphics, element);
//Render any elements in the container
if (element is IContainer)
{
IContainer container = (IContainer)element;
Region region = new Region(element.GetPathInternal());
Region current = graphics.Clip;
graphics.SetClip(region, CombineMode.Intersect);
RenderDiagramElementsLayer(graphics, container.RenderList, layer);
//reset clip
graphics.Clip = current;
}
graphics.TranslateTransform(-element.Rectangle.X, -element.Rectangle.Y);
}
}
}
public void RenderShadowmap(Shader effect,
GraphicsDevice graphicsDevice,
ShadowRenderer shadowRenderer,
Matrix worldMatrix,
Texture2D tilemap)
{
Vector3[] corners = new Vector3[8];
Camera tempCamera = new Camera(World, camera.Target, camera.Position, camera.FOV, camera.AspectRatio, camera.NearPlane, 30);
tempCamera.GetFrustrum().GetCorners(corners);
BoundingBox cameraBox = MathFunctions.GetBoundingBox(corners);
cameraBox = cameraBox.Expand(1.0f);
effect.World = worldMatrix;
effect.MainTexture = tilemap;
shadowRenderer.SetupViewProj(cameraBox);
shadowRenderer.PrepareEffect(effect, false);
shadowRenderer.BindShadowmapEffect(effect);
shadowRenderer.BindShadowmap(graphicsDevice);
List <VoxelChunk> renderListCopy = RenderList.ToArray().ToList();
foreach (VoxelChunk chunk in renderListCopy)
{
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
chunk.Render(Graphics);
}
}
shadowRenderer.UnbindShadowmap(graphicsDevice);
effect.CurrentTechnique = effect.Techniques[Shader.Technique.Textured];
effect.SelfIlluminationEnabled = false;
}
internal override void BuildRenderList(RenderList renderList)
{
foreach (var renderable in _meshes)
{
renderable.BuildRenderList(renderList);
}
}
public void UpdateRenderList(Camera camera)
{
while (RenderList.Count > 0)
{
VoxelChunk result;
if (!RenderList.TryDequeue(out result))
{
break;
}
}
foreach (VoxelChunk chunk in visibleSet)
{
BoundingBox box = chunk.GetBoundingBox();
if ((camera.Position - (box.Min + box.Max) * 0.5f).Length() < DrawDistance)
{
chunk.IsVisible = true;
RenderList.Enqueue(chunk);
}
else
{
chunk.IsVisible = false;
}
}
}
internal void BuildRenderList(RenderList renderList)
{
foreach (var waterArea in _waterAreas)
{
waterArea.BuildRenderList(renderList);
}
}
internal void BuildRenderList(RenderList renderList, CameraComponent camera)
{
foreach (var drawModule in DrawModules)
{
drawModule.BuildRenderList(renderList, camera);
}
}
public void RenderLightmaps(Camera renderCamera, DwarfTime gameTime, GraphicsDevice graphicsDevice,
Shader effect, Matrix worldMatrix)
{
RasterizerState state = RasterizerState.CullNone;
RasterizerState origState = graphicsDevice.RasterizerState;
effect.CurrentTechnique = effect.Techniques[Shader.Technique.Lightmap];
effect.SelfIlluminationTexture = ChunkData.IllumMap;
effect.MainTexture = ChunkData.Tilemap;
effect.SunlightGradient = ChunkData.SunMap;
effect.AmbientOcclusionGradient = ChunkData.AmbientMap;
effect.TorchlightGradient = ChunkData.TorchMap;
effect.LightRampTint = Color.White;
effect.VertexColorTint = Color.White;
effect.SelfIlluminationEnabled = true;
effect.EnableShadows = GameSettings.Default.UseDynamicShadows;
graphicsDevice.RasterizerState = state;
Graphics.BlendState = BlendState.NonPremultiplied;
List <VoxelChunk> renderListCopy = RenderList.ToArray().ToList();
foreach (EffectPass pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
foreach (VoxelChunk chunk in renderListCopy)
{
Graphics.SetRenderTarget(chunk.Primitive.Lightmap);
Graphics.Clear(ClearOptions.Target, Color.Black, 0.0f, 0);
chunk.Render(Graphics);
}
}
Graphics.SetRenderTarget(null);
effect.SelfIlluminationEnabled = false;
effect.CurrentTechnique = effect.Techniques[Shader.Technique.Textured];
graphicsDevice.RasterizerState = origState;
}
internal abstract void BuildRenderList(
RenderList renderList,
Camera camera,
ModelInstance modelInstance,
ModelMeshInstance modelMeshInstance,
ModelBone parentBone,
in Matrix4x4 modelTransform,
internal void BuildRenderList(RenderList renderList)
{
foreach (var patch in Patches)
{
patch.BuildRenderList(renderList);
}
}
internal override void BuildRenderList(RenderList renderList)
{
foreach (var particleSystem in _particleSystems)
{
particleSystem.BuildRenderList(renderList);
}
}
internal void BuildRenderList(RenderList renderList)
{
foreach (var road in _roads)
{
road.BuildRenderList(renderList);
}
}
private void CalculateGuides(RenderList actions)
{
ArrayList list = new ArrayList();
//Loop through actions and add rectangles
foreach (Element element in actions)
{
if (element is Shape && element.Visible)
{
ArrayList newList = new ArrayList();
//Get the rectangle from element
RectangleF newRect = element.Rectangle;
//If a solid element, get transform rectangle
if (element is SolidElement)
{
SolidElement solid = (SolidElement)element;
newRect = solid.TransformRectangle;
}
//Offset rectangle according to container
newRect.X += element.Container.Offset.X;
newRect.Y += element.Container.Offset.Y;
bool combine = false;
//Loop through the existing rectangles and see if they intersect
foreach (RectangleF rect in list)
{
//Determine if rectangles can be combined
if (Orientation == RulerOrientation.Top)
{
combine = rect.Contains(new PointF(newRect.X, rect.Y)) || rect.Contains(new PointF(newRect.Right, rect.Y));
}
else
{
combine = rect.Contains(new PointF(rect.X, newRect.Y)) || rect.Contains(new PointF(rect.X, newRect.Bottom));
}
//Add combined rectangle rectangle together, or add to new list if no intersection
if (combine)
{
newRect = CombineRectangle(newRect, rect);
}
else
{
newList.Add(rect);
}
}
//Add to new list if not combined
newList.Add(newRect);
list = newList;
}
}
SetGuides((RectangleF[])list.ToArray(typeof(RectangleF)));
}
internal override void BuildRenderList(
RenderList renderList,
Camera camera,
ModelInstance modelInstance,
BeforeRenderDelegate[] beforeRender,
BeforeRenderDelegate[] beforeRenderDepth,
ModelBone parentBone,
in Matrix4x4 modelTransform,
internal override void BuildRenderList(RenderList renderList, Camera camera, bool castsShadow, MeshShaderResources.RenderItemConstantsPS renderItemConstantsPS)
{
_modelInstance.BuildRenderList(
renderList,
camera,
castsShadow,
renderItemConstantsPS);
}
public GraphicsSystem(Game game)
: base(game)
{
RegisterComponentList(_models = new List <ModelComponent>());
RenderList = new RenderList();
_renderContext = new RenderContext();
}
internal override void BuildRenderList(
RenderList renderList,
Camera camera,
bool castsShadow,
MeshShaderResources.RenderItemConstantsPS renderItemConstantsPS,
Dictionary <string, bool> shownSubObjects = null, Dictionary <string, bool> hiddenSubObjects = null)
{
// Nothing.
}
internal void BuildRenderList(RenderList renderList)
{
foreach (var patch in Patches)
{
patch.BuildRenderList(
renderList,
EnableMacroTexture ? _macroTexture : _whiteTexture);
}
}
internal void BuildRenderList(RenderList renderList)
{
foreach (var patch in Patches)
{
patch.BuildRenderList(
renderList,
_shaderSet,
_pipeline);
}
}
internal override void BuildRenderList(RenderList renderList)
{
foreach (var shape in _guiComponents)
{
renderList.Gui.AddRenderItemDraw(
shape.Material,
shape.VertexBuffer,
null,
CullFlags.AlwaysVisible,
null,
internal void BuildRenderList(RenderList renderList, CameraComponent camera)
{
Terrain?.BuildRenderList(renderList);
foreach (var gameObject in GameObjects.Items)
{
gameObject.BuildRenderList(renderList, camera);
}
_particleSystemManager.BuildRenderList(renderList);
}
internal void BuildRenderList(RenderList renderList)
{
renderList.Water.RenderItems.Add(new RenderItem(
_shaderSet,
_pipeline,
_boundingBox,
_world,
0,
_numIndices,
_indexBuffer,
_beforeRender));
}
internal void BuildRenderList(RenderList renderList)
{
renderList.Opaque.RenderItems.Add(new RenderItem(
_shaderSet,
_pipeline,
_boundingBox,
Matrix4x4.Identity,
0,
_numIndices,
_indexBuffer,
_beforeRender));
}
internal void BuildRenderList(RenderList renderList)
{
renderList.Terrain.RenderItems.Add(new RenderItem(
$"Terrain-{Bounds}",
_material,
BoundingBox,
Matrix4x4.Identity,
0,
_numIndices,
_indexBuffer,
_beforeRender));
}
internal void BuildRenderList(RenderList renderList)
{
renderList.Water.RenderItems.Add(new RenderItem(
_debugName,
_material,
_boundingBox,
_world,
0,
_numIndices,
_indexBuffer,
_beforeRender));
}
internal void BuildRenderList(RenderList renderList)
{
renderList.Opaque.AddRenderItemDrawIndexed(
_material,
_vertexBuffer,
null,
CullFlags.None,
_boundingBox,
Matrix4x4.Identity,
0,
_numIndices,
_indexBuffer);
}
public RendererControl()
{
InitializeComponent();
lapWatch = new Stopwatch();
globalWatch = new Stopwatch();
camera = new Camera();
frameNumber = 0;
Renderables = new RenderList();
objects = new ObjectDisplay();
objects.Color = ForeColor;
objects.Location = new PointF(0, 50);
Renderables.Add(objects);
}
public RendererWindow()
: base(800, 600, GraphicsMode.Default, "EZ Terrain")
{
Context.ErrorChecking = true;
VSync = VSyncMode.Off;
ClearColor = Color.LightBlue;
lapWatch = new Stopwatch();
globalWatch = new Stopwatch();
camera = new Camera();
frameNumber = 0;
Renderables = new RenderList();
objects = new ObjectDisplay();
objects.Color = Color.Black;
objects.Location = new PointF(0, 50);
Renderables.Add(objects);
}
//Adds a model lines and shapes to an svg document
private void AddContainerImplementation(IContainer container)
{
RenderList list = new RenderList();
//Add each sorted shape to the svg document
foreach (Element element in container.Lines.Values)
{
list.Add(element);
}
//Add each sorted line to the svg document
foreach (Element element in container.Shapes.Values)
{
list.Add(element);
}
list.Sort();
//Go through the diagram and add the element
foreach (Element element in list)
{
AddElement(element);
}
}
//Adds a model lines and shapes to an svg document
private void AddDiagramImplementation(IDiagram diagram)
{
RenderList list = new RenderList();
//Add each sorted shape to the svg document
foreach (Element element in diagram.Lines.Values)
{
if (element.Visible) list.Add(element);
}
//Add each sorted line to the svg document
foreach (Element element in diagram.Shapes.Values)
{
if (element.Visible) list.Add(element);
}
list.Sort();
//Go through the diagram and add the element by layer;
foreach (Layer layer in diagram.Layers)
{
if (layer.Visible)
{
foreach (Element element in list)
{
if (element.Layer == layer) AddElement(element);
}
}
}
}
private void CalculateGuides(RenderList actions)
{
ArrayList list = new ArrayList();
//Loop through actions and add rectangles
foreach (Element element in actions)
{
if (element is Shape && element.Visible)
{
ArrayList newList = new ArrayList();
//Get the rectangle from element
RectangleF newRect = element.Rectangle;
//If a solid element, get transform rectangle
if (element is SolidElement)
{
SolidElement solid = (SolidElement) element;
newRect = solid.TransformRectangle;
}
//Offset rectangle according to container
newRect.X += element.Container.Offset.X;
newRect.Y += element.Container.Offset.Y;
bool combine = false;
//Loop through the existing rectangles and see if they intersect
foreach (RectangleF rect in list)
{
//Determine if rectangles can be combined
if (Orientation == RulerOrientation.Top)
{
combine = rect.Contains(new PointF(newRect.X, rect.Y )) || rect.Contains(new PointF(newRect.Right, rect.Y ));
}
else
{
combine = rect.Contains(new PointF(rect.X, newRect.Y)) || rect.Contains(new PointF(rect.X, newRect.Bottom));
}
//Add combined rectangle rectangle together, or add to new list if no intersection
if (combine)
{
newRect = CombineRectangle(newRect, rect);
}
else
{
newList.Add(rect);
}
}
//Add to new list if not combined
newList.Add(newRect);
list = newList;
}
}
SetGuides((RectangleF[]) list.ToArray(typeof(RectangleF)));
}
