public void MarkOneCascade(int numCascade, IDepthStencil depthStencil, Matrix worldToProjection,
ICascadeShadowMapSlice slice)
{
MyRenderContext RC = MyRender11.RC;
RC.SetVertexBuffer(0, m_vertexBuffer);
RC.SetIndexBuffer(m_indexBuffer);
RC.SetInputLayout(m_inputLayout);
RC.SetViewport(0, 0, MyRender11.ResolutionI.X, MyRender11.ResolutionI.Y);
RC.SetDepthStencilState(MyDepthStencilStateManager.MarkIfInsideCascadeOld[numCascade], 0xf - numCascade);
RC.SetRasterizerState(MyRasterizerStateManager.NocullRasterizerState);
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
MyMapping mapping = MyMapping.MapDiscard(m_markerConstantBuffer);
Matrix shadowToProjection = slice.MatrixShadowToWorldAt0Space * worldToProjection;
shadowToProjection = Matrix.Transpose(shadowToProjection);
mapping.WriteAndPosition(ref shadowToProjection);
mapping.Unmap();
RC.VertexShader.SetConstantBuffer(6, m_markerConstantBuffer);
RC.VertexShader.Set(m_vsMarker);
RC.PixelShader.SetSrv(0, depthStencil.SrvDepth);
//RC.PixelShader.SetSrv(1, depthStencil.SrvStencil);
RC.PixelShader.Set(m_psMarker);
RC.SetRtv(depthStencil, MyDepthStencilAccess.DepthReadOnly);
RC.DrawIndexed(36, 0, 0);
}
// the method returns the same constant buffer as the parameter
protected void FillConstantBuffer <T>(MyRenderContext RC, IConstantBuffer cb, T data) where T : struct
{
var mapping = MyMapping.MapDiscard(RC, MyCommon.ProjectionConstants);
mapping.WriteAndPosition(ref data);
mapping.Unmap();
}
unsafe IConstantBuffer GetShadowConstants(ICascadeShadowMap csm, ref MyShadowsSettings settings)
{
const int MAX_SLICES_COUNT = 8;
MyRenderProxy.Assert(csm.SlicesCount <= MAX_SLICES_COUNT, "It is not supported more than 8 slices per cascade shadow map");
int size = sizeof(Matrix) * MAX_SLICES_COUNT + sizeof(Vector4) * MAX_SLICES_COUNT;
IConstantBuffer cb = MyCommon.GetObjectCB(size);
var mapping = MyMapping.MapDiscard(cb);
for (int i = 0; i < csm.SlicesCount; i++)
{
// Set matrices:
Matrix matrix = csm.GetSlice(i).MatrixWorldAt0ToShadowSpace;
matrix = matrix * Matrix.CreateTranslation(1, -1, 0);
Vector2 scalingFactor = new Vector2(0.5f, -0.5f);
matrix = matrix * Matrix.CreateScale(scalingFactor.X, scalingFactor.Y, 1);
matrix = Matrix.Transpose(matrix);
mapping.WriteAndPosition(ref matrix);
// Set normal offsets:
mapping.WriteAndPosition(ref settings.Cascades[i].ShadowNormalOffset);
float zero = 0;
for (int j = 1; j < 4; j++)
{
mapping.WriteAndPosition(ref zero);
}
}
mapping.Unmap();
return(cb);
}
unsafe IConstantBuffer GetGlassCB(MyRenderContext RC, MyGlassMaterial material)
{
StaticGlassConstants glassConstants = new StaticGlassConstants();
glassConstants.Color = material.Color;
glassConstants.Reflective = material.Refraction;
var glassCB = MyCommon.GetMaterialCB(sizeof(StaticGlassConstants));
var mapping = MyMapping.MapDiscard(RC, glassCB);
mapping.WriteAndPosition(ref glassConstants);
mapping.Unmap();
return(glassCB);
}
// returned value - is there anything to draw?
public bool Finalize(MyRenderContext RC, out IVertexBuffer vbInstances)
{
vbInstances = m_vbInstances;
if (m_validElements == 0)
{
return(false);
}
MyMapping mappingVb = MyMapping.MapDiscard(RC, vbInstances);
mappingVb.WriteAndPosition(m_vbData, m_validElements);
mappingVb.Unmap();
return(true);
}
public void UpdateEntry(int voxelMaterialId, ref MyVoxelMaterialEntry entry)
{
MyRenderProxy.Assert(voxelMaterialId < MAX_ENTRIES);
MyRenderProxy.Assert(Cb != null);
MyRenderProxy.Assert(MyRenderProxy.RenderThread.SystemThread == System.Threading.Thread.CurrentThread);
if (m_needsUpdate[voxelMaterialId])
{
m_entries[voxelMaterialId] = entry;
MyMapping mapping = MyMapping.MapDiscard(Cb);
for (int i = 0; i < MAX_ENTRIES; i++)
{
mapping.WriteAndPosition(ref m_entries[i]);
}
mapping.Unmap();
m_needsUpdate[voxelMaterialId] = false;
}
}
protected static unsafe IConstantBuffer GetPlaceholderObjectCB(MyRenderContext RC, uint lod)
{
int cbSize = sizeof(MyObjectDataCommon);
cbSize += sizeof(MyObjectDataNonVoxel);
IConstantBuffer cb = MyCommon.GetObjectCB(cbSize);
var mapping = MyMapping.MapDiscard(RC, cb);
MyObjectDataNonVoxel nonVoxelData = new MyObjectDataNonVoxel();
mapping.WriteAndPosition(ref nonVoxelData);
MyObjectDataCommon commonData = new MyObjectDataCommon();
commonData.LocalMatrix = Matrix.Identity;
commonData.ColorMul = Vector3.One;
commonData.KeyColor = new Vector3(0, 0f, 0f);
commonData.LOD = lod;
mapping.WriteAndPosition(ref commonData);
mapping.Unmap();
return(cb);
}
private static void PreparePointLights()
{
bool visiblePointlights = VisiblePointlights.Count != 0;
if (!visiblePointlights && !m_lastFrameVisiblePointlights)
{
return;
}
m_lastFrameVisiblePointlights = visiblePointlights;
if (VisiblePointlights.Count > MyRender11Constants.MAX_POINT_LIGHTS)
{
VisiblePointlights.Sort((x, y) => x.ViewerDistanceSquared.CompareTo(y.ViewerDistanceSquared));
while (VisiblePointlights.Count > MyRender11Constants.MAX_POINT_LIGHTS)
{
VisiblePointlights.RemoveAtFast(VisiblePointlights.Count - 1);
}
}
var activePointlights = 0;
foreach (var light in VisiblePointlights)
{
MyLights.WritePointlightConstants(light, ref m_pointlightsCullBuffer[activePointlights]);
activePointlights++;
Debug.Assert(activePointlights <= MyRender11Constants.MAX_POINT_LIGHTS);
}
for (int lightIndex = activePointlights; lightIndex < MyRender11Constants.MAX_POINT_LIGHTS; ++lightIndex)
{
MyLights.WritePointlightConstants(LightId.NULL, ref m_pointlightsCullBuffer[lightIndex]);
}
var mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(16));
mapping.WriteAndPosition(ref activePointlights);
mapping.Unmap();
mapping = MyMapping.MapDiscard(m_pointlightCullHwBuffer);
mapping.WriteAndPosition(m_pointlightsCullBuffer, MyRender11Constants.MAX_POINT_LIGHTS);
mapping.Unmap();
if (!MyStereoRender.Enable)
{
RC.ComputeShader.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
}
else
{
MyStereoRender.CSBindRawCB_FrameConstants(RC);
}
RC.ComputeShader.SetConstantBuffer(1, MyCommon.GetObjectCB(16));
RC.ComputeShader.SetUav(0, m_tileIndices);
RC.ComputeShader.SetSrvs(0, MyGBuffer.Main);
RC.ComputeShader.SetSrv(MyCommon.POINTLIGHT_SLOT, m_pointlightCullHwBuffer);
RC.ComputeShader.Set(m_preparePointLights);
Vector2I tiles = new Vector2I(m_tilesX, m_tilesY);
if (MyStereoRender.Enable && MyStereoRender.RenderRegion != MyStereoRegion.FULLSCREEN)
{
tiles.X /= 2;
}
RC.Dispatch(tiles.X, tiles.Y, 1);
RC.ComputeShader.Set(null);
RC.ComputeShader.SetUav(0, null);
RC.ComputeShader.ResetSrvs(0, MyGBufferSrvFilter.ALL);
}
private static unsafe void RenderSpotlights()
{
RC.SetRtv(MyGBuffer.Main.DepthStencil, MyDepthStencilAccess.ReadOnly, MyGBuffer.Main.LBuffer);
RC.SetViewport(0, 0, MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y);
RC.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
if (MyStereoRender.Enable)
{
MyStereoRender.PSBindRawCB_FrameConstants(RC);
MyStereoRender.SetViewport(RC);
}
var coneMesh = MyMeshes.GetMeshId(X.TEXT_("Models/Debug/Cone.mwm"), 1.0f);
var buffers = MyMeshes.GetLodMesh(coneMesh, 0).Buffers;
RC.SetVertexBuffer(0, buffers.VB0);
RC.SetIndexBuffer(buffers.IB);
RC.VertexShader.Set(m_spotlightProxyVs);
RC.SetInputLayout(m_spotlightProxyIl);
RC.PixelShader.Set(m_spotlightPsPixel);
RC.SetRasterizerState(MyRasterizerStateManager.InvTriRasterizerState);
var cb = MyCommon.GetObjectCB(sizeof(SpotlightConstants));
RC.AllShaderStages.SetConstantBuffer(1, cb);
RC.PixelShader.SetSampler(13, MySamplerStateManager.Alphamask);
RC.PixelShader.SetSampler(14, MySamplerStateManager.Shadowmap);
RC.PixelShader.SetSampler(15, MySamplerStateManager.Shadowmap);
int index = 0;
int casterIndex = 0;
foreach (var id in VisibleSpotlights)
{
SpotlightConstants spotlight = new SpotlightConstants();
var reflectorTexture = MyLights.WriteSpotlightConstants(id, ref spotlight);
var mapping = MyMapping.MapDiscard(cb);
mapping.WriteAndPosition(ref spotlight);
mapping.Unmap();
RC.PixelShader.SetSrv(13, reflectorTexture);
if (id.CastsShadowsThisFrame)
{
RC.PixelShader.SetSrv(14, MyRender11.DynamicShadows.ShadowmapsPool[casterIndex]);
casterIndex++;
}
if (MyRender11.MultisamplingEnabled)
{
RC.SetDepthStencilState(MyDepthStencilStateManager.TestEdgeStencil, 0);
RC.PixelShader.Set(m_spotlightPsPixel);
}
RC.DrawIndexed(MyMeshes.GetLodMesh(coneMesh, 0).Info.IndicesNum, 0, 0);
if (MyRender11.MultisamplingEnabled)
{
RC.PixelShader.Set(m_spotlightPsSample);
RC.SetDepthStencilState(MyDepthStencilStateManager.TestEdgeStencil, 0x80);
RC.DrawIndexed(MyMeshes.GetLodMesh(coneMesh, 0).Info.IndicesNum, 0, 0);
}
index++;
if (index >= SPOTLIGHTS_MAX)
{
break;
}
}
if (MyRender11.MultisamplingEnabled)
{
RC.SetDepthStencilState(MyDepthStencilStateManager.DefaultDepthState);
}
RC.SetRasterizerState(null);
RC.SetRtv(null);
}
internal static void RenderColoredTextures(List <renderColoredTextureProperties> texturesToRender)
{
if (texturesToRender.Count == 0)
{
return;
}
if (!m_initialized)
{
Init();
}
const int RENDER_TEXTURE_RESOLUTION = 512;
RC.SetBlendState(null);
RC.SetInputLayout(null);
RC.PixelShader.Set(m_ps);
RC.AllShaderStages.SetConstantBuffer(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
RC.AllShaderStages.SetConstantBuffer(1, m_cb);
MyBorrowedRwTextureManager rwTexManager = MyManagers.RwTexturesPool;
MyFileTextureManager fileTexManager = MyManagers.FileTextures;
foreach (var texture in texturesToRender)
{
ISrvBindable tex = fileTexManager.GetTexture(texture.TextureName, MyFileTextureEnum.COLOR_METAL, true);
if (tex == null)
{
continue;
}
Vector2 texSize = tex.Size;
Vector2I renderTargetResolution = new Vector2I(RENDER_TEXTURE_RESOLUTION, RENDER_TEXTURE_RESOLUTION);
if (texSize.Y > 0)
{
if (texSize.Y < RENDER_TEXTURE_RESOLUTION)
{
renderTargetResolution.X = (int)texSize.X;
renderTargetResolution.Y = (int)texSize.Y;
}
else
{
renderTargetResolution.X *= (int)(texSize.X / texSize.Y);
}
}
MyViewport viewport = new MyViewport(renderTargetResolution.X, renderTargetResolution.Y);
IBorrowedRtvTexture renderTexture = rwTexManager.BorrowRtv("MySaveExportedTextures.RenderColoredTextures",
renderTargetResolution.X, renderTargetResolution.Y, SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, 1, 0);
RC.SetRtv(renderTexture);
// Set color
var mapping = MyMapping.MapDiscard(m_cb);
Vector4 color = new Vector4(texture.ColorMaskHSV, 1);
mapping.WriteAndPosition(ref color);
mapping.Unmap();
// Set texture
RC.PixelShader.SetSrv(0, tex);
// Draw
MyScreenPass.DrawFullscreenQuad(viewport);
// Save to file
MyTextureData.ToFile(renderTexture, texture.PathToSave, ImageFileFormat.Png);
renderTexture.Release();
}
texturesToRender.Clear();
RC.SetRtv(null);
RC.PixelShader.SetSrvs(0, MyGBuffer.Main);
}
internal static void RenderColoredTextures(List <renderColoredTextureProperties> texturesToRender)
{
if (texturesToRender.Count == 0)
{
return;
}
if (!m_initialized)
{
Init();
}
const int RENDER_TEXTURE_RESOLUTION = 512;
RC.DeviceContext.OutputMerger.BlendState = null;
RC.SetIL(null);
RC.SetPS(m_ps);
RC.SetCB(0, MyCommon.FrameConstants);
RC.SetCB(1, m_cb);
Dictionary <Vector2I, MyRenderTarget> createdRenderTextureTargets = new Dictionary <Vector2I, MyRenderTarget>();
foreach (var texture in texturesToRender)
{
TexId texId = MyTextures.GetTexture(texture.TextureName, MyTextureEnum.COLOR_METAL, true);
if (texId == TexId.NULL)
{
continue;
}
Vector2 texSize = MyTextures.GetSize(texId);
Vector2I renderTargetResolution = new Vector2I(RENDER_TEXTURE_RESOLUTION, RENDER_TEXTURE_RESOLUTION);
if (texSize.Y > 0)
{
if (texSize.Y < RENDER_TEXTURE_RESOLUTION)
{
renderTargetResolution.X = (int)texSize.X;
renderTargetResolution.Y = (int)texSize.Y;
}
else
{
renderTargetResolution.X *= (int)(texSize.X / texSize.Y);
}
}
MyViewport viewport = new MyViewport(renderTargetResolution.X, renderTargetResolution.Y);
MyRenderTarget renderTexture = null;
if (!createdRenderTextureTargets.TryGetValue(renderTargetResolution, out renderTexture))
{
renderTexture = new MyRenderTarget(renderTargetResolution.X, renderTargetResolution.Y, SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, 1, 0);
createdRenderTextureTargets[renderTargetResolution] = renderTexture;
}
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, renderTexture);
// Set color
var mapping = MyMapping.MapDiscard(m_cb);
Vector4 color = new Vector4(texture.ColorMaskHSV, 1);
mapping.WriteAndPosition(ref color);
mapping.Unmap();
// Set texture
RC.DeviceContext.PixelShader.SetShaderResource(0, MyTextures.GetView(texId));
// Draw
MyScreenPass.DrawFullscreenQuad(viewport);
// Save to file
MyTextureData.ToFile(renderTexture.GetHWResource(), texture.PathToSave, ImageFileFormat.Png);
}
texturesToRender.Clear();
foreach (var texture in createdRenderTextureTargets)
{
texture.Value.Release();
}
createdRenderTextureTargets.Clear();
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, null);
RC.BindGBufferForRead(0, MyGBuffer.Main);
}
