private static void OnDeviceReset()
{
MyManagers.OnDeviceReset();
MyShaders.OnDeviceReset();
MyMaterialShaders.OnDeviceReset();
MyTransparentRendering.OnDeviceReset();
ResetShadows(MyShadowCascades.Settings.NewData.CascadesCount, Settings.User.ShadowQuality.ShadowCascadeResolution());
MyBillboardRenderer.OnDeviceReset();
MyScreenDecals.OnDeviceReset();
MyMeshMaterials1.OnDeviceReset();
MyVoxelMaterials1.OnDeviceReset();
MyRenderableComponent.MarkAllDirty();
foreach (var f in MyComponentFactory <MyFoliageComponent> .GetAll())
{
f.Dispose();
}
foreach (var c in MyComponentFactory <MyGroupRootComponent> .GetAll())
{
c.OnDeviceReset();
}
MyBigMeshTable.Table.OnDeviceReset();
MySceneMaterials.OnDeviceReset();
MyMeshes.OnDeviceReset();
MyInstancing.OnDeviceReset();
MyScreenDecals.OnDeviceReset();
}
internal static void OnDeviceReset()
{
MyHwBuffers.OnDeviceReset();
MyShaders.OnDeviceReset();
MyMaterialShaders.OnDeviceReset();
MyPipelineStates.OnDeviceReset();
MyTextures.OnDeviceReset();
MyRwTextures.OnDeviceReset();
ResetShadows(Settings.ShadowCascadeCount, RenderSettings.ShadowQuality.ShadowCascadeResolution());
MyBillboardRenderer.OnDeviceRestart();
MyScreenDecals.OnDeviceReset();
MyMeshMaterials1.InvalidateMaterials();
MyVoxelMaterials1.InvalidateMaterials();
MyRenderableComponent.MarkAllDirty();
foreach (var f in MyComponentFactory <MyFoliageComponent> .GetAll())
{
f.Dispose();
}
foreach (var c in MyComponentFactory <MyGroupRootComponent> .GetAll())
{
c.OnDeviceReset();
}
MyBigMeshTable.Table.OnDeviceReset();
MySceneMaterials.OnDeviceReset();
MyMeshes.OnDeviceReset();
MyInstancing.OnDeviceReset();
MyScreenDecals.OnDeviceReset();
}
internal static void UnloadData()
{
MyActorFactory.RemoveAll();
// many-to-one relation, can live withput owners, deallocated separately
// MyComponentFactory<MyInstancingComponent>.RemoveAll();
//MyVoxelMesh.RemoveAll();
//MyDynamicMesh.RemoveAll();
MyRender11.Log.WriteLine("Unloading session data");
MyScene.RenderablesDBVH.Clear();
MyScene.GroupsDBVH.Clear();
MyClipmapFactory.RemoveAll();
MyInstancing.OnSessionEnd();
MyMeshes.OnSessionEnd();
MyLights.OnSessionEnd();
MyMaterials1.OnSessionEnd();
MyVoxelMaterials1.OnSessionEnd();
MyMeshMaterials1.OnSessionEnd();
MyScreenDecals.OnSessionEnd();
MyTextures.OnSessionEnd();
MyBigMeshTable.Table.OnSessionEnd();
//MyAssetsLoader.ClearMeshes();
}
private static void OnDeviceEnd()
{
// Reversed order of calling End -- Managers last
MyScreenDecals.OnDeviceEnd();
MyShaders.OnDeviceEnd();
MyMaterialShaders.OnDeviceEnd();
MyVoxelMaterials1.OnDeviceEnd();
MyTransparentRendering.OnDeviceEnd();
MyManagers.OnDeviceEnd();
}
internal static unsafe void InitSubsystems()
{
InitializeBlendStates();
InitializeRasterizerStates();
InitilizeSamplerStates();
MyCommon.Init();
MyPipelineStates.Init();
MyTextures.Init();
MyVertexLayouts.Init();
MyShaders.Init();
MyRwTextures.Init();
MyHwBuffers.Init();
MyMeshes.Init();
MyMeshTableSRV.Init();
MyMergeInstancing.Init();
MyGeometryRenderer.Init();
MyLightRendering.Init();
MyShadows.Init();
MyLinesRenderer.Init();
MySpritesRenderer.Init();
MyPrimitivesRenderer.Init();
MyFoliageRenderer.Init();
MyOutline.Init();
MyComponents.Init();
MyBillboardRenderer.Init(); // hardcoded limits
MyDebugRenderer.Init();
MyGPUFoliageGenerating.Init();
MyScreenDecals.Init();
MyEnvProbeProcessing.Init();
MyShadowsResolve.Init();
MyAtmosphereRenderer.Init();
MyAAEdgeMarking.Init();
MyScreenPass.Init();
MyCopyToRT.Init();
MyBlendTargets.Init();
MyFXAA.Init();
MyDepthResolve.Init();
MyBloom.Init();
MyLuminanceAverage.Init();
MyToneMapping.Init();
MySSAO.Init();
MyHdrDebugTools.Init();
MySceneMaterials.Init();
MyMaterials1.Init();
MyVoxelMaterials1.Init();
MyMeshMaterials1.Init();
//MyShaderFactory.RunCompilation(); // rebuild
}
internal static void OnDeviceEnd()
{
MyScreenDecals.OnDeviceEnd();
MyShaders.OnDeviceEnd();
MyMaterialShaders.OnDeviceEnd();
MyVoxelMaterials1.OnDeviceEnd();
MyTextures.OnDeviceEnd();
MyRwTextures.OnDeviceEnd();
MyHwBuffers.OnDeviceEnd();
MyPipelineStates.OnDeviceEnd();
}
/// <returns>True if window has decals and is not too far</returns>
static bool HandleWindow(MyBillboard billboard)
{
uint parentID = (uint)billboard.ParentID;
if (MyScreenDecals.HasEntityDecals(parentID) && billboard.DistanceSquared < MyScreenDecals.VISIBLE_DECALS_SQ_TH)
{
m_windowsWithDecals.Add(parentID);
return(true);
}
return(false);
}
/// <returns>True if window glass decals and is not too far</returns>
static bool HandleGlass(MyRenderCullResultFlat result, double viewDistanceSquared)
{
uint id = result.RenderProxy.Parent.Owner.ID;
if (MyScreenDecals.HasEntityDecals(id) && viewDistanceSquared < MyScreenDecals.VISIBLE_DECALS_SQ_TH)
{
m_glassWithDecals.Add(id);
return(true);
}
return(false);
}
internal static void OnDeviceEnd()
{
MyManagers.OnDeviceEnd();
MyScreenDecals.OnDeviceEnd();
MyShaders.OnDeviceEnd();
MyMaterialShaders.OnDeviceEnd();
MyVoxelMaterials1.OnDeviceEnd();
//MyRwTextures.OnDeviceEnd();
MyHwBuffers.OnDeviceEnd();
MyTransparentRendering.OnDeviceEnd();
}
internal static unsafe void InitSubsystems()
{
MyRwTextures.Init();
MyHwBuffers.Init();
MyPipelineStates.Init();
ResetShadows(MyRenderProxy.Settings.ShadowCascadeCount, RenderSettings.ShadowQuality.ShadowCascadeResolution());
MyRender11.Init();
MyCommon.Init();
SamplerStates.Init();
MyDepthStencilState.Init();
MyTextures.Init();
MyVertexLayouts.Init();
MyShaders.Init();
MyMeshes.Init();
MyMeshTableSRV.Init();
MyLightRendering.Init();
MyLinesRenderer.Init();
MySpritesRenderer.Init();
MyPrimitivesRenderer.Init();
MyOutline.Init();
MyBlur.Init();
MyTransparentRendering.Init();
MyFoliageComponents.Init();
MyBillboardRenderer.Init(); // hardcoded limits
MyDebugRenderer.Init();
MyScreenDecals.Init();
MyEnvProbeProcessing.Init();
MyAtmosphereRenderer.Init();
MyCloudRenderer.Init();
MyAAEdgeMarking.Init();
MyScreenPass.Init();
MyCopyToRT.Init();
MyBlendTargets.Init();
MyFXAA.Init();
MyDepthResolve.Init();
MyBloom.Init();
MyLuminanceAverage.Init();
MyToneMapping.Init();
MySSAO.Init();
MyPlanetBlur.Init();
MyHdrDebugTools.Init();
MySceneMaterials.Init();
MyMaterials1.Init();
MyVoxelMaterials1.Init();
MyMeshMaterials1.Init();
}
internal static void UnloadData()
{
MyManagers.OnUnloadData();
MyActorFactory.RemoveAll();
// many-to-one relation, can live withput owners, deallocated separately
// MyComponentFactory<MyInstancingComponent>.RemoveAll();
//MyVoxelMesh.RemoveAll();
//MyDynamicMesh.RemoveAll();
MyRender11.Log.WriteLine("Unloading session data");
// Remove leftover persistent debug draw messages
m_debugDrawMessages.Clear();
MyScene.DynamicRenderablesDBVH.Clear();
if (MyScene.SeparateGeometry)
{
MyScene.StaticRenderablesDBVH.Clear();
}
MyScene.GroupsDBVH.Clear();
MyScene.FoliageDBVH.Clear();
MyClipmapFactory.RemoveAll();
MyClipmap.UnloadCache();
MyInstancing.OnSessionEnd();
MyFoliageComponents.OnSessionEnd();
MyMeshes.OnSessionEnd();
MyLights.OnSessionEnd();
MyMaterials1.OnSessionEnd();
MyVoxelMaterials1.OnSessionEnd();
MyMeshMaterials1.OnSessionEnd();
MyScreenDecals.OnSessionEnd();
MyBigMeshTable.Table.OnSessionEnd();
MyPrimitivesRenderer.Unload();
MyTransparentRendering.OnSessionEnd();
//MyAssetsLoader.ClearMeshes();
}
static void PreGatherBillboard(MyBillboard billboard)
{
var material = MyTransparentMaterials.GetMaterial(billboard.Material);
if (material.NeedSort)
{
m_sortedCount++;
}
else
{
m_unsortedCount++;
}
if (billboard.Window && MyScreenDecals.HasEntityDecals((uint)billboard.ParentID))
{
m_windowCount++;
}
}
internal void SetAnimationBones(Matrix[] boneAbsoluteTransforms, IReadOnlyList <MyBoneDecalUpdate> boneDecals)
{
if (m_skeletonHierarchy == null)
{
return;
}
var skeletonCount = m_skeletonHierarchy.Length;
for (int i = 0; i < skeletonCount; i++)
{
m_absoluteTransforms[i] = boneAbsoluteTransforms[i];
}
int bonesCount = m_skeletonIndices.Length;
for (int i = 0; i < bonesCount; i++)
{
m_skinTransforms[i] = Matrix.Transpose(m_skeletonHierarchy[m_skeletonIndices[i]].SkinTransform * m_absoluteTransforms[m_skeletonIndices[i]]);
}
m_decalUpdateCache.Clear();
for (int it = 0; it < boneDecals.Count; it++)
{
MyBoneDecalUpdate pair = boneDecals[it];
MyDecalTopoData data;
bool found = MyScreenDecals.GetDecalTopoData(pair.DecalID, out data);
if (!found)
{
continue;
}
Matrix skinningTrans = ComputeSkinning(data.BoneIndices, ref data.BoneWeights);
Matrix transform = data.MatrixBinding * skinningTrans;
m_decalUpdateCache.Add(new MyDecalPositionUpdate()
{
ID = pair.DecalID, Transform = transform
});
}
MyScreenDecals.UpdateDecals(m_decalUpdateCache);
}
private static void UpdateDecalPositions(InstancingId id, List <MyCubeInstanceData> instanceData, List <MyCubeInstanceDecalData> decals)
{
m_tmpDecalsUpdate.Clear();
for (int it1 = 0; it1 < decals.Count; it1++)
{
MyCubeInstanceDecalData decal = decals[it1];
MyCubeInstanceData cubeData = instanceData[decal.InstanceIndex];
if (!cubeData.EnableSkinning)
{
break;
}
MyDecalTopoData decalTopo;
bool found = MyScreenDecals.GetDecalTopoData(decal.DecalId, out decalTopo);
if (!found)
{
continue;
}
Matrix localCubeMatrix;
Matrix skinningMatrix = cubeData.ConstructDeformedCubeInstanceMatrix(ref decalTopo.BoneIndices, ref decalTopo.BoneWeights, out localCubeMatrix);
Matrix localCubeMatrixInv;
Matrix.Invert(ref localCubeMatrix, out localCubeMatrixInv);
// TODO: Optimization: it would be cool if we keep original cube coordiates local intersection
// and avoid matrix inversion here. Refer to MyCubeGrid.GetIntersectionWithLine(), MyCubeGridHitInfo
Matrix invBinding = decalTopo.MatrixBinding * localCubeMatrixInv;
Matrix transform = invBinding * skinningMatrix;
m_tmpDecalsUpdate.Add(new MyDecalPositionUpdate()
{
ID = decal.DecalId, Transform = transform
});
}
MyScreenDecals.UpdateDecals(m_tmpDecalsUpdate);
}
private static void ProcessMessageInternal(IMyRenderMessage message)
{
switch (message.MessageType)
{
case MyRenderMessageEnum.SetCameraViewMatrix:
{
var rMessage = (MyRenderMessageSetCameraViewMatrix)message;
SetupCameraMatrices(rMessage);
break;
}
case MyRenderMessageEnum.DrawScene:
{
var rMessage = (IMyRenderMessage)message;
m_drawQueue.Enqueue(rMessage);
m_messageTracker.Clear();
break;
}
case MyRenderMessageEnum.RebuildCullingStructure:
{
break;
}
#region Profiler
case MyRenderMessageEnum.RenderProfiler:
{
var profMessage = (MyRenderMessageRenderProfiler)message;
MyRenderProfiler.HandleInput(profMessage.Command, profMessage.Index);
break;
}
#endregion
#region Characters
case MyRenderMessageEnum.CreateRenderCharacter:
{
var rMessage = (MyRenderMessageCreateRenderCharacter)message;
var actor = MyActorFactory.CreateCharacter();
Matrix worldMatrixF = rMessage.WorldMatrix;
//actor.GetRenderable().SetModel(MyAssetsLoader.GetModel(rMessage.Model));
actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(rMessage.Model)));
actor.SetMatrix(ref worldMatrixF);
if (rMessage.ColorMaskHSV.HasValue)
{
var color = ColorFromMask(rMessage.ColorMaskHSV.Value);
actor.GetRenderable().SetKeyColor(new Vector4(color, 1));
}
actor.SetID(rMessage.ID);
//var entity = MyComponents.CreateEntity(rMessage.ID);
//MyComponents.CreateRenderable(
// entity,
// MyMeshes.GetMeshId(X.TEXT(rMessage.Model)),
// rMessage.ColorMaskHSV.HasValue ? rMessage.ColorMaskHSV.Value : Vector3.One);
//MyComponents.SetMatrix(entity, ref rMessage.WorldMatrix);
break;
}
case MyRenderMessageEnum.SetCharacterSkeleton:
{
var rMessage = (MyRenderMessageSetCharacterSkeleton)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.CharacterID);
if (actor != null)
{
actor.GetSkinning().SetSkeleton(rMessage.SkeletonBones, rMessage.SkeletonIndices);
}
//var entity = MyComponents.GetEntity(rMessage.CharacterID);
//MyComponents.SetSkeleton(entity, rMessage.SkeletonBones, rMessage.SkeletonIndices);
break;
};
case MyRenderMessageEnum.SetCharacterTransforms:
{
var rMessage = (MyRenderMessageSetCharacterTransforms)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.CharacterID);
if (actor != null)
{
actor.GetSkinning().SetAnimationBones(rMessage.RelativeBoneTransforms);
}
//var entity = MyComponents.GetEntity(rMessage.CharacterID);
//MyComponents.SetAnimation(entity, rMessage.RelativeBoneTransforms);
break;
}
case MyRenderMessageEnum.UpdateRenderEntity:
{
var rMessage = (MyRenderMessageUpdateRenderEntity)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);
if (actor != null && actor.GetRenderable() != null)
{
if (rMessage.ColorMaskHSV.HasValue)
{
actor.GetRenderable().SetKeyColor(new Vector4(ColorFromMask(rMessage.ColorMaskHSV.Value), 0));
}
actor.GetRenderable().SetDithering(rMessage.Dithering);
}
break;
}
case MyRenderMessageEnum.ChangeModelMaterial:
{
var rMessage = (MyRenderMessageChangeModelMaterial)message;
//var matId = MyMeshMaterialId.NULL;
//if (rMessage.Material.ToLower().Contains("debug"))
//{
// matId = MyMeshMaterials1.DebugMaterialId;
//}
//else
//{
// matId = MyMeshMaterials1.GetMaterialId(rMessage.Material);
//}
//MyAssetsLoader.GetModel(rMessage.Model).SetMaterial_SLOW(MyMeshMaterials1.GetProxyId(matId));
break;
}
#endregion
#region Render objects
case MyRenderMessageEnum.CreateRenderEntity:
{
var rMessage = (MyRenderMessageCreateRenderEntity)message;
Matrix m = (Matrix)rMessage.WorldMatrix;
var actor = MyActorFactory.CreateSceneObject();
if (rMessage.Model != null)
{
var model = MyAssetsLoader.ModelRemap.Get(rMessage.Model, rMessage.Model);
actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
//if (MyDestructionMesh.ModelsDictionary.ContainsKey(model))
//{
// //actor.GetRenderable().SetModel(MyDestructionMesh.ModelsDictionary.Get(model));
// actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
//}
//else
//{
// //actor.GetRenderable().SetModel(MyAssetsLoader.GetModel(model));
// actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
//}
}
actor.SetID(rMessage.ID);
actor.SetMatrix(ref m);
break;
}
case MyRenderMessageEnum.CreateRenderVoxelDebris:
{
var rMessage = (MyRenderMessageCreateRenderVoxelDebris)message;
Matrix m = (Matrix)rMessage.WorldMatrix;
var actor = MyActorFactory.CreateSceneObject();
if (rMessage.Model != null)
{
actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(rMessage.Model)));
}
actor.SetID(rMessage.ID);
actor.SetMatrix(ref m);
MyRenderableComponent.DebrisEntityVoxelMaterial[rMessage.ID] = rMessage.VoxelMaterialIndex;
break;
}
case MyRenderMessageEnum.CreateScreenDecal:
{
var rMessage = (MyRenderMessageCreateScreenDecal)message;
//rMessage.ParentID
MyScreenDecals.AddDecal(rMessage.ID, rMessage.ParentID, rMessage.LocalOBB);
break;
}
case MyRenderMessageEnum.RemoveDecal:
{
var rMessage = (MyRenderMessageRemoveDecal)message;
MyScreenDecals.RemoveDecal(rMessage.ID);
break;
}
case MyRenderMessageEnum.UpdateRenderObject:
{
var rMessage = (MyRenderMessageUpdateRenderObject)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);
if (actor != null)
{
Matrix m = (Matrix)rMessage.WorldMatrix;
actor.SetMatrix(ref m);
if (rMessage.AABB.HasValue)
{
actor.SetAabb((BoundingBox)rMessage.AABB.Value);
}
}
var entity = MyComponents.GetEntity(rMessage.ID);
if (entity != EntityId.NULL)
{
MyComponents.SetMatrix(entity, ref rMessage.WorldMatrix);
if (rMessage.AABB.HasValue)
{
var aabb = rMessage.AABB.Value;
MyComponents.SetAabb(entity, ref aabb);
}
}
break;
}
case MyRenderMessageEnum.RemoveRenderObject:
{
var rMessage = (MyRenderMessageRemoveRenderObject)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);
if (actor != null)
{
if (actor.GetRenderable() != null && actor.GetRenderable().GetModel().Info.Dynamic)
{
MyMeshes.RemoveMesh(actor.GetRenderable().GetModel());
}
actor.Destruct();
MyScreenDecals.RemoveEntityDecals(rMessage.ID);
}
var instancing = MyInstancing.Get(rMessage.ID);
if (instancing != InstancingId.NULL)
{
MyInstancing.Remove(rMessage.ID, instancing);
}
var light = MyLights.Get(rMessage.ID);
if (light != LightId.NULL)
{
MyLights.Remove(rMessage.ID, light);
}
var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ID);
if (clipmap != null)
{
clipmap.RemoveFromUpdate();
}
break;
}
case MyRenderMessageEnum.UpdateRenderObjectVisibility:
{
var rMessage = (MyRenderMessageUpdateRenderObjectVisibility)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);
if (actor != null)
{
actor.SetVisibility(rMessage.Visible);
}
break;
}
case MyRenderMessageEnum.CreateRenderInstanceBuffer:
{
var rMessage = (MyRenderMessageCreateRenderInstanceBuffer)message;
//var instancing = MyComponentFactory<MyInstancingComponent>.Create();
//instancing.SetID(rMessage.ID);
//instancing.Init(rMessage.Type);
//instancing.SetDebugName(rMessage.DebugName);
MyInstancing.Create(rMessage.ID, rMessage.Type, rMessage.DebugName);
break;
}
case MyRenderMessageEnum.UpdateRenderInstanceBuffer:
{
var rMessage = (MyRenderMessageUpdateRenderInstanceBuffer)message;
//var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
//if(instancing != null)
//{
// instancing.UpdateGeneric(rMessage.InstanceData, rMessage.Capacity);
//}
MyInstancing.UpdateGeneric(MyInstancing.Get(rMessage.ID), rMessage.InstanceData, rMessage.Capacity);
rMessage.InstanceData.Clear();
break;
}
case MyRenderMessageEnum.UpdateRenderCubeInstanceBuffer:
{
var rMessage = (MyRenderMessageUpdateRenderCubeInstanceBuffer)message;
//var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
//if (instancing != null)
//{
// instancing.UpdateCube(rMessage.InstanceData, rMessage.Capacity);
//}
MyInstancing.UpdateCube(MyInstancing.Get(rMessage.ID), rMessage.InstanceData, rMessage.Capacity);
rMessage.InstanceData.Clear();
break;
}
case MyRenderMessageEnum.SetInstanceBuffer:
{
var rMessage = (MyRenderMessageSetInstanceBuffer)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);
//var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.InstanceBufferId);
if (actor != null)
{
//if (actor.GetComponent(MyActorComponentEnum.Instancing) != instancing)
//{
// actor.AddComponent(instancing);
//}
//actor.SetLocalAabb(rMessage.LocalAabb);
//actor.GetRenderable().SetInstancingCounters(rMessage.InstanceCount, rMessage.InstanceStart);
actor.GetRenderable().SetInstancing(MyInstancing.Get(rMessage.InstanceBufferId));
actor.SetLocalAabb(rMessage.LocalAabb);
actor.GetRenderable().SetInstancingCounters(rMessage.InstanceCount, rMessage.InstanceStart);
}
break;
}
case MyRenderMessageEnum.CreateManualCullObject:
{
var rMessage = (MyRenderMessageCreateManualCullObject)message;
var actor = MyActorFactory.CreateGroup();
actor.SetID(rMessage.ID);
Matrix m = (Matrix)rMessage.WorldMatrix;
actor.SetMatrix(ref m);
break;
}
case MyRenderMessageEnum.SetParentCullObject:
{
var rMessage = (MyRenderMessageSetParentCullObject)message;
var child = MyIDTracker <MyActor> .FindByID(rMessage.ID);
var parent = MyIDTracker <MyActor> .FindByID(rMessage.CullObjectID);
if (child != null && parent != null && parent.GetGroupRoot() != null && child.GetGroupLeaf() == null)
{
child.SetRelativeTransform(rMessage.ChildToParent);
parent.GetGroupRoot().Add(child);
}
break;
}
case MyRenderMessageEnum.CreateLineBasedObject:
{
var rMessage = (MyRenderMessageCreateLineBasedObject)message;
var actor = MyActorFactory.CreateSceneObject();
//actor.GetRenderable().SetModel(new MyDynamicMesh());
actor.SetID(rMessage.ID);
actor.SetMatrix(ref Matrix.Identity);
MyMeshMaterials1.GetMaterialId("__ROPE_MATERIAL", null, rMessage.ColorMetalTexture, rMessage.NormalGlossTexture, rMessage.ExtensionTexture, MyMesh.DEFAULT_MESH_TECHNIQUE);
actor.GetRenderable().SetModel(MyMeshes.CreateRuntimeMesh(X.TEXT("LINE" + rMessage.ID), 1, true));
break;
}
case MyRenderMessageEnum.UpdateLineBasedObject:
{
var rMessage = (MyRenderMessageUpdateLineBasedObject)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);
if (actor != null)
{
//var mesh = actor.GetRenderable().GetMesh() as MyDynamicMesh;
MyVertexFormatPositionH4 [] stream0;
MyVertexFormatTexcoordNormalTangent [] stream1;
MyLineHelpers.GenerateVertexData(ref rMessage.WorldPointA, ref rMessage.WorldPointB,
out stream0, out stream1);
var indices = MyLineHelpers.GenerateIndices(stream0.Length);
var sections = new MySectionInfo[]
{
new MySectionInfo {
TriCount = indices.Length / 3, IndexStart = 0, MaterialName = "__ROPE_MATERIAL"
}
};
MyMeshes.UpdateRuntimeMesh(MyMeshes.GetMeshId(X.TEXT("LINE" + rMessage.ID)),
indices,
stream0,
stream1,
sections,
(BoundingBox)MyLineHelpers.GetBoundingBox(ref rMessage.WorldPointA, ref rMessage.WorldPointB));
//actor.SetAabb((BoundingBox)MyLineHelpers.GetBoundingBox(ref rMessage.WorldPointA, ref rMessage.WorldPointB));
actor.MarkRenderDirty();
var matrix = Matrix.CreateTranslation((Vector3)(rMessage.WorldPointA + rMessage.WorldPointB) * 0.5f);
actor.SetMatrix(ref matrix);
}
break;
}
case MyRenderMessageEnum.SetRenderEntityData:
{
var rMessage = (MyRenderMessageSetRenderEntityData)message;
Debug.Assert(false, "MyRenderMessageSetRenderEntityData is deprecated!");
break;
}
case MyRenderMessageEnum.AddRuntimeModel:
{
var rMessage = (MyRenderMessageAddRuntimeModel)message;
//MyDestructionMesh mesh = MyDestructionMesh.ModelsDictionary.Get(rMessage.Name);
//if (mesh == null)
//{
//mesh = new MyDestructionMesh(rMessage.Name);
//ProfilerShort.Begin("LoadBuffers");
//mesh.Fill(rMessage.ModelData.Indices, rMessage.ModelData.Positions, rMessage.ModelData.Normals, rMessage.ModelData.Tangents, rMessage.ModelData.TexCoords, rMessage.ModelData.Sections, rMessage.ModelData.AABB);
//ProfilerShort.End();
if (!MyMeshes.Exists(rMessage.Name))
{
{
ushort[] indices = new ushort[rMessage.ModelData.Indices.Count];
for (int i = 0; i < rMessage.ModelData.Indices.Count; i++)
{
indices[i] = (ushort)rMessage.ModelData.Indices[i];
}
var verticesNum = rMessage.ModelData.Positions.Count;
MyVertexFormatPositionH4[] stream0 = new MyVertexFormatPositionH4[verticesNum];
MyVertexFormatTexcoordNormalTangent[] stream1 = new MyVertexFormatTexcoordNormalTangent[verticesNum];
for (int i = 0; i < verticesNum; i++)
{
stream0[i] = new MyVertexFormatPositionH4(rMessage.ModelData.Positions[i]);
stream1[i] = new MyVertexFormatTexcoordNormalTangent(
rMessage.ModelData.TexCoords[i], rMessage.ModelData.Normals[i], rMessage.ModelData.Tangents[i]);
}
var id = MyMeshes.CreateRuntimeMesh(X.TEXT(rMessage.Name), rMessage.ModelData.Sections.Count, false);
MyMeshes.UpdateRuntimeMesh(id, indices, stream0, stream1, rMessage.ModelData.Sections.ToArray(), rMessage.ModelData.AABB);
}
if (rMessage.ReplacedModel != null)
{
//MyAssetsLoader.ModelRemap[rMessage.ReplacedModel] = rMessage.Name;
MyAssetsLoader.ModelRemap[rMessage.Name] = rMessage.ReplacedModel;
}
//if (MyAssetsLoader.LOG_MESH_STATISTICS)
//{
// mesh.DebugWriteInfo();
//}
}
break;
}
case MyRenderMessageEnum.UpdateModelProperties:
{
var rMessage = (MyRenderMessageUpdateModelProperties)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);
if (actor != null)
{
var key = new MyEntityMaterialKey {
LOD = rMessage.LOD, Material = X.TEXT(rMessage.MaterialName)
};
if (rMessage.Enabled.HasValue)
{
if (!MyScene.EntityDisabledMaterials.ContainsKey(rMessage.ID))
{
MyScene.EntityDisabledMaterials.Add(rMessage.ID, new HashSet <MyEntityMaterialKey>());
}
if (!rMessage.Enabled.Value)
{
MyScene.EntityDisabledMaterials[rMessage.ID].Add(key);
}
else
{
MyScene.EntityDisabledMaterials[rMessage.ID].Remove(key);
}
}
var r = actor.GetRenderable();
if ((rMessage.Emissivity.HasValue || rMessage.DiffuseColor.HasValue) && !r.ModelProperties.ContainsKey(key))
{
r.ModelProperties[key] = new MyModelProperties();
}
if (rMessage.Emissivity.HasValue)
{
r.ModelProperties[key].Emissivity = rMessage.Emissivity.Value;
}
if (rMessage.DiffuseColor.HasValue)
{
r.ModelProperties[key].ColorMul = rMessage.DiffuseColor.Value;
}
actor.MarkRenderDirty();
}
break;
}
case MyRenderMessageEnum.PreloadModel:
{
var rMessage = (MyRenderMessagePreloadModel)message;
//MyAssetsLoader.GetModel(rMessage.Name);
MyMeshes.GetMeshId(X.TEXT(rMessage.Name));
break;
}
case MyRenderMessageEnum.ChangeMaterialTexture:
{
var rMessage = (MyRenderMessageChangeMaterialTexture)message;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.RenderObjectID);
if (actor != null)
{
var r = actor.GetRenderable();
var key = new MyEntityMaterialKey {
LOD = 0, Material = X.TEXT(rMessage.MaterialName)
};
if (!r.ModelProperties.ContainsKey(key))
{
r.ModelProperties[key] = new MyModelProperties();
}
if (r.ModelProperties[key].TextureSwaps == null)
{
r.ModelProperties[key].TextureSwaps = new List <MyMaterialTextureSwap>();
foreach (var s in rMessage.Changes)
{
r.ModelProperties[key].TextureSwaps.Add(new MyMaterialTextureSwap {
TextureName = X.TEXT(s.TextureName),
MaterialSlot = s.MaterialSlot
});
}
}
else
{
foreach (var s in rMessage.Changes)
{
bool swapped = false;
for (int i = 0; i < r.ModelProperties[key].TextureSwaps.Count; ++i)
{
if (r.ModelProperties[key].TextureSwaps[i].MaterialSlot == s.MaterialSlot)
{
r.ModelProperties[key].TextureSwaps[i] = new MyMaterialTextureSwap
{
TextureName = X.TEXT(s.TextureName),
MaterialSlot = s.MaterialSlot
};
swapped = true;
break;
}
}
if (!swapped)
{
r.ModelProperties[key].TextureSwaps.Add(new MyMaterialTextureSwap
{
TextureName = X.TEXT(s.TextureName),
MaterialSlot = s.MaterialSlot
});
}
}
}
r.FreeCustomRenderTextures(key);
actor.MarkRenderDirty();
}
rMessage.Changes.Clear();
break;
}
case MyRenderMessageEnum.DrawTextToMaterial:
{
var rMessage = (MyRenderMessageDrawTextToMaterial)message;
//rMessage.EntityId
//rMessage.FontColor
//rMessage.MaterialName
//rMessage.Text;
//rMessage.TextScale;
var actor = MyIDTracker <MyActor> .FindByID(rMessage.RenderObjectID);
if (actor != null)
{
var r = actor.GetRenderable();
var key = new MyEntityMaterialKey {
LOD = 0, Material = X.TEXT(rMessage.MaterialName)
};
if (!r.ModelProperties.ContainsKey(key))
{
r.ModelProperties[key] = new MyModelProperties();
}
else
{
r.ModelProperties[key].TextureSwaps = null;
}
RwTexId handle = r.ModelProperties[key].CustomRenderedTexture;
if (handle == RwTexId.NULL && MyModelProperties.CustomTextures < MyModelProperties.MaxCustomTextures)
{
handle = MyRwTextures.CreateRenderTarget(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution, SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, true);
r.ModelProperties[key].CustomRenderedTexture = handle;
++MyModelProperties.CustomTextures;
}
if (handle != RwTexId.NULL)
{
var clearColor = new SharpDX.Color4(rMessage.BackgroundColor.PackedValue);
clearColor.Alpha = 0;
MyRender11.ImmediateContext.ClearRenderTargetView(handle.Rtv, clearColor);
// my sprites renderer -> push state
MySpritesRenderer.PushState(new Vector2(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution));
MySpritesRenderer.DrawText(Vector2.Zero, new StringBuilder(rMessage.Text), rMessage.FontColor, rMessage.TextScale);
// render text with fonts to rt
// update texture of proxy
MySpritesRenderer.Draw(handle.Rtv, new MyViewport(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution));
// render to rt
// my sprites renderer -> pop state
MySpritesRenderer.PopState();
MyRender11.ImmediateContext.GenerateMips(handle.ShaderView);
actor.MarkRenderDirty();
}
else
{
MyRenderProxy.TextNotDrawnToTexture(rMessage.EntityId);
}
}
else
{
MyRenderProxy.TextNotDrawnToTexture(rMessage.EntityId);
}
break;
}
case MyRenderMessageEnum.PreloadMaterials:
{
var rMessage = (MyRenderMessagePreloadMaterials)message;
//MyAssetsLoader.GetMaterials(rMessage.Name);
MyMeshes.GetMeshId(X.TEXT(rMessage.Name));
break;
}
#endregion
#region Voxels
case MyRenderMessageEnum.CreateClipmap:
{
var rMessage = (MyRenderMessageCreateClipmap)message;
var clipmap = new MyClipmapHandler(rMessage.ClipmapId, rMessage.ScaleGroup, rMessage.WorldMatrix, rMessage.SizeLod0);
MyClipmapFactory.ClipmapByID[rMessage.ClipmapId] = clipmap;
clipmap.Base.LoadContent();
break;
}
case MyRenderMessageEnum.UpdateClipmapCell:
{
var rMessage = (MyRenderMessageUpdateClipmapCell)message;
var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);
if (clipmap != null)
{
clipmap.Base.UpdateCell(rMessage);
}
rMessage.Batches.Clear();
break;
}
case MyRenderMessageEnum.InvalidateClipmapRange:
{
var rMessage = (MyRenderMessageInvalidateClipmapRange)message;
var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);
if (clipmap != null)
{
clipmap.Base.InvalidateRange(rMessage.MinCellLod0, rMessage.MaxCellLod0);
}
break;
}
case MyRenderMessageEnum.CreateRenderVoxelMaterials:
{
var rMessage = (MyRenderMessageCreateRenderVoxelMaterials)message;
Debug.Assert(MyVoxelMaterials1.CheckIndices(rMessage.Materials));
MyVoxelMaterials1.Set(rMessage.Materials);
rMessage.Materials = null;
break;
}
#endregion
#region Lights
case MyRenderMessageEnum.CreateRenderLight:
{
var rMessage = (MyRenderMessageCreateRenderLight)message;
//MyLight.Create(rMessage.ID);
MyLights.Create(rMessage.ID);
break;
}
case MyRenderMessageEnum.UpdateRenderLight:
{
var rMessage = (MyRenderMessageUpdateRenderLight)message;
var light = MyLights.Get(rMessage.ID);
if (light != LightId.NULL)
{
var lightInfo = new MyLightInfo
{
Position = rMessage.Position,
PositionWithOffset = rMessage.Position + rMessage.Offset * rMessage.Range * rMessage.ReflectorDirection,
CastsShadows = rMessage.CastShadows,
ShadowsDistance = rMessage.ShadowDistance,
ParentGID = rMessage.ParentID,
UsedInForward = rMessage.UseInForwardRender
};
MyLights.UpdateEntity(light, ref lightInfo);
if ((rMessage.Type & LightTypeEnum.PointLight) > 0)
{
MyLights.UpdatePointlight(light, rMessage.LightOn, rMessage.Range, new Vector3(rMessage.Color.R, rMessage.Color.G, rMessage.Color.B) / 255.0f * rMessage.Intensity, rMessage.Falloff);
}
if ((rMessage.Type & LightTypeEnum.Hemisphere) > 0)
{
//rMessage.Color;
//rMessage.Falloff;
//rMessage.Intensity;
//rMessage.LightOn;
//rMessage.ReflectorDirection;
//rMessage.ReflectorUp;
}
if ((rMessage.Type & LightTypeEnum.Spotlight) > 0)
{
// because it's so in dx9...
float coneMaxAngleCos = 1 - rMessage.ReflectorConeMaxAngleCos;
coneMaxAngleCos = (float)Math.Min(Math.Max(coneMaxAngleCos, 0.01), 0.99f);
MyLights.UpdateSpotlight(light, rMessage.ReflectorOn,
rMessage.ReflectorDirection, rMessage.ReflectorRange, coneMaxAngleCos, rMessage.ReflectorUp,
new Vector3(rMessage.ReflectorColor.R, rMessage.ReflectorColor.G, rMessage.ReflectorColor.B) / 255.0f * rMessage.Intensity, rMessage.ReflectorFalloff,
MyTextures.GetTexture(rMessage.ReflectorTexture, MyTextureEnum.CUSTOM));
}
if (rMessage.GlareOn)
{
MyLights.UpdateGlare(light, new MyGlareDesc
{
Enabled = rMessage.GlareOn,
Material = X.TEXT(rMessage.GlareMaterial),
Intensity = rMessage.GlareIntensity,
QuerySize = rMessage.GlareQuerySize,
Type = rMessage.GlareType,
Size = rMessage.GlareSize,
MaxDistance = rMessage.GlareMaxDistance,
Color = rMessage.Color,
Direction = rMessage.ReflectorDirection,
Range = rMessage.Range
});
}
}
break;
}
case MyRenderMessageEnum.SetLightShadowIgnore:
{
var rMessage = (MyRenderMessageSetLightShadowIgnore)message;
var light = MyLights.Get(rMessage.ID);
var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID2);
if (light != LightId.NULL && actor != null)
{
if (!MyLights.IgnoredEntitites.ContainsKey(light))
{
MyLights.IgnoredEntitites[light] = new HashSet <uint>();
}
MyLights.IgnoredEntitites[light].Add(rMessage.ID2);
}
break;
}
case MyRenderMessageEnum.ClearLightShadowIgnore:
{
var rMessage = (MyRenderMessageClearLightShadowIgnore)message;
var light = MyLights.Get(rMessage.ID);
if (light != LightId.NULL)
{
MyLights.IgnoredEntitites.Remove(light);
}
break;
}
case MyRenderMessageEnum.UpdateFogSettings:
{
var rMessage = (MyRenderMessageUpdateFogSettings)message;
MyEnvironment.FogSettings = rMessage.Settings;
break;
}
case MyRenderMessageEnum.UpdateRenderEnvironment:
{
var rMessage = (MyRenderMessageUpdateRenderEnvironment)message;
MyEnvironment.DirectionalLightDir = VRageMath.Vector3.Normalize(rMessage.SunDirection);
MyEnvironment.DirectionalLightIntensity = rMessage.SunIntensity * rMessage.SunColor.ToVector3();
MyEnvironment.DirectionalLightEnabled = rMessage.SunLightOn;
MyEnvironment.DayTime = (float)(rMessage.DayTime - Math.Truncate(rMessage.DayTime));
MyEnvironment.SunDistance = rMessage.DistanceToSun;
MyEnvironment.SunColor = rMessage.SunColor;
MyEnvironment.SunMaterial = rMessage.SunMaterial;
MyEnvironment.SunSizeMultiplier = rMessage.SunSizeMultiplier;
var skybox = rMessage.BackgroundTexture;
m_resetEyeAdaptation = m_resetEyeAdaptation || rMessage.ResetEyeAdaptation;
break;
}
case MyRenderMessageEnum.UpdateEnvironmentMap:
{
break;
}
case MyRenderMessageEnum.UpdatePostprocessSettings:
{
var rMessage = (MyRenderMessageUpdatePostprocessSettings)message;
m_postprocessSettings = rMessage.Settings;
break;
}
case MyRenderMessageEnum.UpdateSSAOSettings:
{
var rMessage = (MyRenderMessageUpdateSSAOSettings)message;
MySSAO.Params.MinRadius = rMessage.MinRadius;
MySSAO.Params.MaxRadius = rMessage.MaxRadius;
MySSAO.Params.RadiusGrow = rMessage.RadiusGrowZScale;
MySSAO.Params.RadiusBias = rMessage.Bias;
MySSAO.Params.Falloff = rMessage.Falloff;
MySSAO.Params.Normalization = rMessage.NormValue;
MySSAO.Params.Contrast = rMessage.Contrast;
break;
}
#endregion
#region Sprites
case MyRenderMessageEnum.DrawSprite:
case MyRenderMessageEnum.DrawSpriteNormalized:
case MyRenderMessageEnum.DrawSpriteAtlas:
case MyRenderMessageEnum.SpriteScissorPush:
case MyRenderMessageEnum.SpriteScissorPop:
{
m_drawQueue.Enqueue(message);
break;
}
#endregion
#region Fonts and text
case MyRenderMessageEnum.CreateFont:
{
var createFontMessage = message as MyRenderMessageCreateFont;
Debug.Assert(createFontMessage != null);
var renderFont = new MyRenderFont(createFontMessage.FontPath);
renderFont.LoadContent();
AddFont(createFontMessage.FontId, renderFont, createFontMessage.IsDebugFont);
break;
}
case MyRenderMessageEnum.DrawString:
{
m_drawQueue.Enqueue(message);
break;
}
#endregion
#region Textures
case MyRenderMessageEnum.PreloadTextures:
{
var preloadMsg = message as MyRenderMessagePreloadTextures;
//MyTextureManager.PreloadTextures(preloadMsg.InDirectory, preloadMsg.Recursive);
//MyTextures.UnloadTexture(texMessage.Texture);
break;
}
case MyRenderMessageEnum.UnloadTexture:
{
var texMessage = (MyRenderMessageUnloadTexture)message;
//MyTextureManager.UnloadTexture(texMessage.Texture);
MyTextures.UnloadTexture(texMessage.Texture);
break;
}
case MyRenderMessageEnum.ReloadTextures:
{
var reloadMsg = (MyRenderMessageReloadTextures)message;
MyVoxelMaterials1.InvalidateMaterials();
MyMeshMaterials1.InvalidateMaterials();
MyTextures.ReloadAssetTextures();
//MyTextureManager.UnloadTextures();
//MyMaterialProxyFactory.ReloadTextures();
break;
}
case MyRenderMessageEnum.ReloadModels:
{
var reloadMsg = (MyRenderMessageReloadModels)message;
//MyMaterials.Clear();
MyAssetsLoader.ReloadMeshes();
MyRenderableComponent.MarkAllDirty();
break;
}
#endregion
case MyRenderMessageEnum.TakeScreenshot:
{
var rMessage = (MyRenderMessageTakeScreenshot)message;
m_screenshot = new MyScreenshot(rMessage.PathToSave, rMessage.SizeMultiplier, rMessage.IgnoreSprites);
break;
}
case MyRenderMessageEnum.ReloadEffects:
{
m_reloadShaders = true;
//MyShaderBundleFactory.ClearCache();
//MyShaderMaterial.ClearCache();
//MyShaderPass.ClearCache();
MyShaders.Recompile();
MyMaterialShaders.Recompile();
MyRenderableComponent.MarkAllDirty();
foreach (var f in MyComponentFactory <MyFoliageComponent> .GetAll())
{
f.Dispose();
}
break;
}
case MyRenderMessageEnum.PlayVideo:
{
var rMessage = (MyRenderMessagePlayVideo)message;
MyVideoFactory.Create(rMessage.ID, rMessage.VideoFile);
var video = MyVideoFactory.Videos.Get(rMessage.ID);
if (video != null)
{
video.Volume = rMessage.Volume;
}
break;
}
case MyRenderMessageEnum.CloseVideo:
{
var rMessage = (MyRenderMessageCloseVideo)message;
var video = MyVideoFactory.Videos.Get(rMessage.ID);
if (video != null)
{
video.Stop();
video.Dispose();
MyVideoFactory.Videos.Remove(rMessage.ID);
}
break;
}
case MyRenderMessageEnum.DrawVideo:
{
var rMessage = (MyRenderMessageDrawVideo)message;
var video = MyVideoFactory.Videos.Get(rMessage.ID);
if (video != null)
{
video.Draw(rMessage.Rectangle, rMessage.Color, rMessage.FitMode);
}
break;
}
case MyRenderMessageEnum.UpdateVideo:
{
var rMessage = (MyRenderMessageUpdateVideo)message;
var video = MyVideoFactory.Videos.Get(rMessage.ID);
if (video != null)
{
video.Update();
}
break;
}
case MyRenderMessageEnum.SetVideoVolume:
{
var rMessage = (MyRenderMessageSetVideoVolume)message;
var video = MyVideoFactory.Videos.Get(rMessage.ID);
if (video != null)
{
video.Volume = rMessage.Volume;
}
break;
}
case MyRenderMessageEnum.VideoAdaptersRequest:
{
MyRenderProxy.SendVideoAdapters(GetAdaptersList());
break;
}
case MyRenderMessageEnum.SwitchDeviceSettings:
{
MyRenderProxy.RenderThread.SwitchSettings((message as MyRenderMessageSwitchDeviceSettings).Settings);
break;
}
case MyRenderMessageEnum.SwitchRenderSettings:
break; // Can be ignored as we're handling newer version of the message.
case MyRenderMessageEnum.SwitchRenderSettings1:
{
UpdateRenderSettings((message as MyRenderMessageSwitchRenderSettings1).Settings);
break;
}
case MyRenderMessageEnum.UnloadData:
{
MyRender11.UnloadData();
break;
}
case MyRenderMessageEnum.CollectGarbage:
{
GC.Collect();
break;
}
#region Debug draw
case MyRenderMessageEnum.DebugDrawPoint:
case MyRenderMessageEnum.DebugDrawLine3D:
case MyRenderMessageEnum.DebugDrawLine2D:
case MyRenderMessageEnum.DebugDrawSphere:
case MyRenderMessageEnum.DebugDrawAABB:
case MyRenderMessageEnum.DebugDrawAxis:
case MyRenderMessageEnum.DebugDrawOBB:
case MyRenderMessageEnum.DebugDrawCone:
case MyRenderMessageEnum.DebugDrawTriangle:
case MyRenderMessageEnum.DebugDrawCapsule:
case MyRenderMessageEnum.DebugDrawText2D:
case MyRenderMessageEnum.DebugDrawText3D:
case MyRenderMessageEnum.DebugDrawModel:
case MyRenderMessageEnum.DebugDrawTriangles:
case MyRenderMessageEnum.DebugDrawPlane:
case MyRenderMessageEnum.DebugDrawCylinder:
{
m_debugDrawMessages.Enqueue(message);
}
break;
case MyRenderMessageEnum.DebugCrashRenderThread:
{
throw new InvalidOperationException("Forced exception");
}
#endregion
}
}
internal static unsafe void InitSubsystems()
{
MyManagers.OnDeviceInit();
//MyRwTextures.Init();
MyHwBuffers.Init();
ResetShadows(MyShadowCascades.Settings.NewData.CascadesCount, RenderSettings.ShadowQuality.ShadowCascadeResolution());
MyRender11.Init();
MyCommon.Init();
MyVertexLayouts.Init();
MyShaders.Init();
MyMeshes.Init();
MyMeshTableSrv.Init();
MyLightRendering.Init();
MyLinesRenderer.Init();
MySpritesRenderer.Init();
MyPrimitivesRenderer.Init();
MyOutline.Init();
MyBlur.Init();
MyTransparentRendering.Init();
MyFoliageComponents.Init();
MyBillboardRenderer.Init(); // hardcoded limits
MyDebugRenderer.Init();
MyScreenDecals.Init();
MyEnvProbeProcessing.Init();
MyAtmosphereRenderer.Init();
MyCloudRenderer.Init();
MyAAEdgeMarking.Init();
MyScreenPass.Init();
MyCopyToRT.Init();
MyBlendTargets.Init();
MyFXAA.Init();
MyDepthResolve.Init();
MyBloom.Init();
MyLuminanceAverage.Init();
MyToneMapping.Init();
MySSAO.Init();
MyHdrDebugTools.Init();
MySceneMaterials.Init();
MyMaterials1.Init();
MyVoxelMaterials1.Init();
MyMeshMaterials1.Init();
MyHBAO.Init();
try
{
if (m_settings.UseStereoRendering)
{
var openVR = new MyOpenVR();
MyStereoStencilMask.InitUsingOpenVR();
}
}
catch (System.Exception e)
{
if (!VRage.MyCompilationSymbols.DX11ForceStereo)
{
throw;
}
MyStereoStencilMask.InitUsingUndefinedMask();
}
}
// Returns the final image and copies it to renderTarget if non-null
private static IRtvTexture DrawGameScene(IRtvBindable renderTarget, out IBorrowedRtvTexture debugAmbientOcclusion)
{
MyGpuProfiler.IC_BeginBlockAlways("ClearAndGeometryRender");
PrepareGameScene();
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear");
MyRender11.RC.ClearState();
ProfilerShort.End();
}
if (MyStereoRender.Enable && MyStereoRender.EnableUsingStencilMask)
{
ProfilerShort.Begin("MyStereoStencilMask.Draw");
MyGpuProfiler.IC_BeginBlock("MyStereoStencilMask.Draw");
MyStereoStencilMask.Draw();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
}
ProfilerShort.Begin("MyLights.Update");
MyLights.Update();
ProfilerShort.End();
ProfilerShort.Begin("DynamicGeometryRenderer");
MyCullQuery cullQuery = m_dynamicGeometryRenderer.PrepareCullQuery(true); // it is used to share rendering settings between the old and the new pipeline
ProfilerShort.End();
MyGpuProfiler.IC_BeginBlock("NewGeometryRenderer");
ProfilerShort.Begin("NewGeometryRenderer");
IGeometrySrvStrategy geometrySrvStrategy = MyManagers.GeometrySrvResolver.GetGeometrySrvStrategy();
if (MyDebugGeometryStage2.EnableNewGeometryPipeline)
{
MyManagers.GeometryRenderer.Render(cullQuery, geometrySrvStrategy);
}
ProfilerShort.End();
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("MyGeometryRenderer.Render");
Debug.Assert(m_commandLists.Count == 0, "Not all command lists executed last frame!");
ProfilerShort.Begin("DynamicGeometryRenderer");
m_dynamicGeometryRenderer.Render(m_commandLists);
ProfilerShort.End(); // End function block
if (MyScene.SeparateGeometry)
{
ProfilerShort.Begin("StaticGeometryRenderer");
m_staticGeometryRenderer.Render(m_commandLists); // , false);
ProfilerShort.End(); // End function block
}
SendGlobalOutputMessages();
ExecuteCommandLists(m_commandLists);
MyGpuProfiler.IC_EndBlock();
#if !UNSHARPER_TMP
MyManagers.EnvironmentProbe.FinalizeEnvProbes();
#endif
// cleanup context atfer deferred lists
if (true)
{
ProfilerShort.Begin("Clear3");
MyRender11.RC.ClearState();
ProfilerShort.End();
}
MyGpuProfiler.IC_EndBlockAlways();
IBorrowedRtvTexture gbuffer1Copy = MyGBuffer.Main.GetGbuffer1CopyRtv();
ProfilerShort.Begin("Render decals - Opaque");
MyGpuProfiler.IC_BeginBlock("Render decals - Opaque");
MyScreenDecals.Draw(gbuffer1Copy, false);
MyGpuProfiler.IC_EndBlock();
IBorrowedDepthStencilTexture depthStencilCopy = null; // Highlights need the depth state before foliage
if (MyHighlight.HasHighlights)
{
depthStencilCopy = MyGBuffer.Main.GetDepthStencilCopyRtv();
}
ProfilerShort.BeginNextBlock("Render foliage");
MyGpuProfiler.IC_BeginBlockAlways("RenderFoliage");
m_foliageRenderer.Render();
MyGpuProfiler.IC_EndBlockAlways();
MyGpuProfiler.IC_BeginBlock("GBuffer Resolve");
ProfilerShort.BeginNextBlock("MySceneMaterials.MoveToGPU");
MySceneMaterials.MoveToGPU();
MyRender11.RC.ResetTargets();
IBorrowedRtvTexture ambientOcclusionRtv = MyManagers.RwTexturesPool.BorrowRtv("MyScreenDependants.AmbientOcclusion",
ResolutionI.X, ResolutionI.Y, SharpDX.DXGI.Format.R8_UNorm);
debugAmbientOcclusion = ambientOcclusionRtv; // Pass the texture to the outside
int nPasses = MyStereoRender.Enable ? 2 : 1;
for (int i = 0; i < nPasses; i++)
{
if (MyStereoRender.Enable)
{
MyStereoRender.RenderRegion = i == 0 ? MyStereoRegion.LEFT : MyStereoRegion.RIGHT;
}
MyGBuffer.Main.ResolveMultisample();
ProfilerShort.BeginNextBlock("Shadows");
MyGpuProfiler.IC_BeginBlockAlways("Shadows");
IBorrowedUavTexture postProcessedShadows;
if (MyScene.SeparateGeometry)
{
MyShadowCascadesPostProcess.Combine(MyShadowCascades.CombineShadowmapArray, DynamicShadows.ShadowCascades, StaticShadows.ShadowCascades);
postProcessedShadows = DynamicShadows.ShadowCascades.PostProcess(MyShadowCascades.CombineShadowmapArray);
//MyShadowCascadesPostProcess.Combine(MyShadowCascades.CombineShadowmapArray,
// DynamicShadows.ShadowCascades, StaticShadows.ShadowCascades);
//postProcessedShadows =
// DynamicShadows.ShadowCascades.PostProcess(MyShadowCascades.CombineShadowmapArray);
}
else
{
postProcessedShadows = DynamicShadows.ShadowCascades.PostProcess(DynamicShadows.ShadowCascades.CascadeShadowmapArray);
//postProcessedShadows = MyManagers.Shadow.Evaluate();
}
MyGpuProfiler.IC_EndBlockAlways();
if (MySSAO.Params.Enabled && Settings.User.AmbientOcclusionEnabled &&
m_debugOverrides.Postprocessing && m_debugOverrides.SSAO)
{
ProfilerShort.BeginNextBlock("SSAO");
MyGpuProfiler.IC_BeginBlockAlways("SSAO");
MySSAO.Run(ambientOcclusionRtv, MyGBuffer.Main);
if (MySSAO.Params.UseBlur)
{
IBorrowedRtvTexture ambientOcclusionHelper = MyManagers.RwTexturesPool.BorrowRtv("MyScreenDependants.AmbientOcclusionHelper",
ResolutionI.X, ResolutionI.Y, SharpDX.DXGI.Format.R8_UNorm);
MyBlur.Run(ambientOcclusionRtv, ambientOcclusionHelper, ambientOcclusionRtv, clearColor: Color4.White);
ambientOcclusionHelper.Release();
}
MyGpuProfiler.IC_EndBlockAlways();
}
else if (MyHBAO.Params.Enabled && Settings.User.AmbientOcclusionEnabled &&
m_debugOverrides.Postprocessing && m_debugOverrides.SSAO)
{
ProfilerShort.BeginNextBlock("HBAO");
MyGpuProfiler.IC_BeginBlock("HBAO");
MyHBAO.Run(ambientOcclusionRtv, MyGBuffer.Main);
MyGpuProfiler.IC_EndBlock();
}
else
{
MyRender11.RC.ClearRtv(ambientOcclusionRtv, Color4.White);
}
ProfilerShort.BeginNextBlock("Lights");
MyGpuProfiler.IC_BeginBlockAlways("Lights");
if (m_debugOverrides.Lighting)
{
MyLightsRendering.Render(postProcessedShadows, ambientOcclusionRtv);
}
MyGpuProfiler.IC_EndBlockAlways();
postProcessedShadows.Release();
if (MyRender11.DebugOverrides.Flares)
{
MyLightsRendering.DrawFlares();
}
}
MyStereoRender.RenderRegion = MyStereoRegion.FULLSCREEN;
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Occlusion Queries");
MyGpuProfiler.IC_BeginBlock("Occlusion Queries");
MyOcclusionQueryRenderer.Render(RC, MyGBuffer.Main.ResolvedDepthStencil, MyGBuffer.Main.LBuffer);
MyGpuProfiler.IC_EndBlock();
// Rendering for VR is solved inside of Transparent rendering
ProfilerShort.BeginNextBlock("Transparent Pass");
MyGpuProfiler.IC_BeginBlockAlways("TransparentPass");
if (m_debugOverrides.Transparent)
{
MyTransparentRendering.Render(gbuffer1Copy);
}
MyGpuProfiler.IC_EndBlockAlways();
gbuffer1Copy.Release();
ProfilerShort.BeginNextBlock("PostProcess");
MyGpuProfiler.IC_BeginBlockAlways("PostProcess");
MyGpuProfiler.IC_BeginBlock("Luminance reduction");
IBorrowedUavTexture avgLum = null;
if (MyRender11.Postprocess.EnableEyeAdaptation)
{
if (m_resetEyeAdaptation)
{
MyLuminanceAverage.Reset();
m_resetEyeAdaptation = false;
}
avgLum = MyLuminanceAverage.Run(MyGBuffer.Main.LBuffer);
}
else
{
avgLum = MyLuminanceAverage.Skip();
}
MyGpuProfiler.IC_EndBlock();
IBorrowedUavTexture histogram = null;
if (MyRender11.Settings.DisplayHistogram)
{
histogram = MyHdrDebugTools.CreateHistogram(MyGBuffer.Main.LBuffer, MyGBuffer.Main.SamplesCount);
}
if (MyRender11.Settings.DisplayHdrIntensity)
{
MyHdrDebugTools.DisplayHdrIntensity(MyGBuffer.Main.LBuffer);
}
MyGpuProfiler.IC_BeginBlock("Bloom");
IBorrowedUavTexture bloom;
if (m_debugOverrides.Postprocessing && m_debugOverrides.Bloom)
{
bloom = MyBloom.Run(MyGBuffer.Main.LBuffer, MyGBuffer.Main.GBuffer2, MyGBuffer.Main.ResolvedDepthStencil.SrvDepth);
}
else
{
bloom = MyManagers.RwTexturesPool.BorrowUav("bloom_EightScreenUavHDR", MyRender11.ResolutionI.X / 8, MyRender11.ResolutionI.Y / 8, MyGBuffer.LBufferFormat);
MyRender11.RC.ClearRtv(bloom, Color4.Black);
}
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("Tone mapping");
IBorrowedUavTexture tonemapped = MyToneMapping.Run(MyGBuffer.Main.LBuffer, avgLum, bloom, Postprocess.EnableTonemapping && m_debugOverrides.Postprocessing && m_debugOverrides.Tonemapping);
bloom.Release();
MyGpuProfiler.IC_EndBlock();
IRtvTexture renderedImage;
IBorrowedCustomTexture fxaaTarget = null;
bool fxaa = MyRender11.FxaaEnabled;
if (fxaa)
{
fxaaTarget = MyManagers.RwTexturesPool.BorrowCustom("MyRender11.FXAA.Rgb8");
MyGpuProfiler.IC_BeginBlock("FXAA");
MyFXAA.Run(fxaaTarget.Linear, tonemapped);
MyGpuProfiler.IC_EndBlock();
renderedImage = fxaaTarget.SRgb;
}
else
{
renderedImage = tonemapped;
}
ProfilerShort.Begin("MyHighlight.Run");
MyHighlight.Run(renderedImage, fxaaTarget, depthStencilCopy);
ProfilerShort.End();
if (depthStencilCopy != null)
{
depthStencilCopy.Release();
}
if (renderTarget != null)
{
MyCopyToRT.Run(renderTarget, renderedImage);
}
if (MyRender11.Settings.DisplayHistogram)
{
if (renderTarget != null && avgLum != null)
{
MyHdrDebugTools.DisplayHistogram(renderTarget, avgLum, histogram);
}
}
MyGpuProfiler.IC_EndBlockAlways();
ProfilerShort.End();
if (fxaaTarget != null)
{
fxaaTarget.Release();
}
if (histogram != null)
{
histogram.Release();
}
avgLum.Release();
tonemapped.Release();
// HOTFIX: MyDebugTextureDisplay uses borrowed textures. If we place MyDebugTextureDisplay to the different location, we will have problem with borrowed textures (comment by Michal)
ProfilerShort.Begin("MyDebugTextureDisplay.Draw");
MyGpuProfiler.IC_BeginBlock("MyDebugTextureDisplay.Draw");
MyDebugTextureDisplay.Draw(MyRender11.Backbuffer);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
return(renderedImage);
}
// Returns the final image and copies it to renderTarget if non-null
private static MyBindableResource DrawGameScene(MyBindableResource renderTarget)
{
ProfilerShort.Begin("DrawGameScene");
PrepareGameScene();
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear");
MyRenderContext.Immediate.Clear();
MyRenderContext.Immediate.DeviceContext.ClearState();
ProfilerShort.End();
}
Debug.Assert(m_commandLists.Count == 0, "Not all command lists executed last frame!");
DynamicGeometryRenderer.Render(m_commandLists, true);
if (MyScene.SeparateGeometry)
{
StaticGeometryRenderer.Render(m_commandLists, false);
}
SendGlobalOutputMessages();
ExecuteCommandLists(m_commandLists);
MyEnvironmentProbe.FinalizeEnvProbes();
// cleanup context atfer deferred lists
if (MyRender11.DeferredContextsEnabled)
{
ProfilerShort.Begin("Clear2");
MyRenderContext.Immediate.Clear();
ProfilerShort.End();
}
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear3");
MyRenderContext.Immediate.Clear();
MyRenderContext.Immediate.DeviceContext.ClearState();
ProfilerShort.End();
}
ProfilerShort.Begin("Render decals");
MyGpuProfiler.IC_BeginBlock("Render decals");
MyRender11.CopyGbufferToScratch();
MyScreenDecals.Draw();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Render foliage");
MyGpuProfiler.IC_BeginBlock("Render foliage");
m_foliageRenderer.Render();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("MySceneMaterials.MoveToGPU");
MySceneMaterials.MoveToGPU();
ProfilerShort.BeginNextBlock("Postprocessing");
MyGpuProfiler.IC_BeginBlock("Postprocessing");
if (MultisamplingEnabled)
{
MyRender11.DeviceContext.ClearDepthStencilView(MyScreenDependants.m_resolvedDepth.m_DSV, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1, 0);
MyGpuProfiler.IC_BeginBlock("MarkAAEdges");
MyAAEdgeMarking.Run();
MyGpuProfiler.IC_EndBlock();
MyDepthResolve.Run(MyScreenDependants.m_resolvedDepth, MyGBuffer.Main.DepthStencil.Depth);
}
if (MyScene.SeparateGeometry)
{
MyShadowCascadesPostProcess.Combine(MyShadowCascades.CombineShadowmapArray, DynamicShadows.ShadowCascades, StaticShadows.ShadowCascades);
DynamicShadows.ShadowCascades.PostProcess(MyRender11.PostProcessedShadows, MyShadowCascades.CombineShadowmapArray);
}
else
{
DynamicShadows.ShadowCascades.PostProcess(MyRender11.PostProcessedShadows, DynamicShadows.ShadowCascades.CascadeShadowmapArray);
}
MyGpuProfiler.IC_BeginBlock("SSAO");
if (Postprocess.EnableSsao)
{
MySSAO.Run(MyScreenDependants.m_ambientOcclusion, MyGBuffer.Main, MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.Depth : MyGBuffer.Main.DepthStencil.Depth);
if (MySSAO.UseBlur)
{
MyBlur.Run(MyScreenDependants.m_ambientOcclusion, MyScreenDependants.m_ambientOcclusionHelper, MyScreenDependants.m_ambientOcclusion);
}
}
else
{
MyRender11.DeviceContext.ClearRenderTargetView(MyScreenDependants.m_ambientOcclusion.m_RTV, Color4.White);
}
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("Lights");
MyLightRendering.Render();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginBlock("Billboards");
if (MyRender11.MultisamplingEnabled)
{
MyBillboardRenderer.Render(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyScreenDependants.m_resolvedDepth, MyScreenDependants.m_resolvedDepth.Depth);
}
else
{
MyBillboardRenderer.Render(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyGBuffer.Main.DepthStencil, MyGBuffer.Main.DepthStencil.Depth);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Atmosphere");
MyGpuProfiler.IC_BeginBlock("Atmosphere");
MyAtmosphereRenderer.Render();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Clouds");
MyGpuProfiler.IC_BeginBlock("Clouds");
MyCloudRenderer.Render();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
MyGpuProfiler.IC_BeginBlock("Luminance reduction");
MyBindableResource avgLum = null;
if (MyRender11.MultisamplingEnabled)
{
MyRenderContext.Immediate.DeviceContext.ResolveSubresource(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer).m_resource, 0, MyGBuffer.Main.Get(MyGbufferSlot.LBufferResolved).m_resource, 0, SharpDX.DXGI.Format.R11G11B10_Float);
}
if (m_resetEyeAdaptation)
{
MyRenderContext.Immediate.DeviceContext.ClearUnorderedAccessView(m_prevLum.m_UAV, Int4.Zero);
m_resetEyeAdaptation = false;
}
avgLum = MyLuminanceAverage.Run(m_reduce0, m_reduce1, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), m_prevLum);
MyGpuProfiler.IC_EndBlock();
if (MyRender11.Settings.DisplayHdrDebug)
{
var src = MyGBuffer.Main.Get(MyGbufferSlot.LBuffer) as MyRenderTarget;
MyHdrDebugTools.CreateHistogram(src.m_SRV, src.m_resolution, src.m_samples.X);
}
MyGpuProfiler.IC_BeginBlock("Bloom");
var bloom = MyBloom.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum);
MyGpuProfiler.IC_EndBlock();
MyBindableResource tonemapped;
if (MyRender11.FxaaEnabled)
{
tonemapped = m_rgba8_linear;
}
else
{
tonemapped = m_uav3;
}
MyGpuProfiler.IC_BeginBlock("Tone mapping");
MyToneMapping.Run(tonemapped, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum, bloom, Postprocess.EnableTonemapping);
MyGpuProfiler.IC_EndBlock();
MyBindableResource renderedImage;
if (MyRender11.FxaaEnabled)
{
MyGpuProfiler.IC_BeginBlock("FXAA");
MyFXAA.Run(m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm, View = MyViewEnum.RtvView
}), tonemapped);
MyGpuProfiler.IC_EndBlock();
renderedImage = m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView
});
}
else
{
//renderedImage = (tonemapped as MyCustomTexture).GetView(new MyViewKey { Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView });
renderedImage = tonemapped;
}
ProfilerShort.Begin("Outline");
if (MyOutline.AnyOutline())
{
MyOutline.Run();
MyGpuProfiler.IC_BeginBlock("Outline Blending");
ProfilerShort.Begin("Outline Blending");
if (MyRender11.FxaaEnabled)
{
MyBlendTargets.RunWithStencil(
m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}),
MyRender11.m_rgba8_1,
MyRender11.BlendAdditive,
MyDepthStencilState.TestOutlineMeshStencil,
0x40);
MyBlendTargets.RunWithStencil(
m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}),
MyRender11.m_rgba8_1,
MyRender11.BlendTransparent,
MyDepthStencilState.TestHighlightMeshStencil,
0x40);
}
else
{
if (MyRender11.MultisamplingEnabled)
{
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_ms, MyRender11.BlendAdditive);
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_ms, MyRender11.BlendTransparent, true);
}
else
{
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendAdditive, MyDepthStencilState.TestOutlineMeshStencil, 0x40);
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendTransparent, MyDepthStencilState.TestHighlightMeshStencil, 0x40);
}
}
ProfilerShort.End();
MyGpuProfiler.IC_EndBlock();
}
ProfilerShort.End();
if (renderTarget != null)
{
MyCopyToRT.Run(renderTarget, renderedImage);
}
if (MyRender11.Settings.DisplayHdrDebug)
{
MyHdrDebugTools.DisplayHistogram((renderTarget as IRenderTargetBindable).RTV, (avgLum as IShaderResourceBindable).SRV);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
return(renderedImage);
}
private static void DrawGameScene(bool blitToBackbuffer)
{
ResetStats();
MyCommon.UpdateFrameConstants();
// todo: shouldn't be necessary
if (true)
{
MyImmediateRC.RC.Clear();
MyImmediateRC.RC.Context.ClearState();
}
MyRender11.GetRenderProfiler().StartProfilingBlock("MyGeometryRenderer.Render");
MyGpuProfiler.IC_BeginBlock("MyGeometryRenderer.Render");
MyGeometryRenderer.Render();
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
// cleanup context atfer deferred lists
if (MyRender11.DeferredContextsEnabled)
{
MyImmediateRC.RC.Clear();
}
// todo: shouldn't be necessary
if (true)
{
MyImmediateRC.RC.Clear();
MyImmediateRC.RC.Context.ClearState();
}
MyRender11.GetRenderProfiler().StartProfilingBlock("Render decals");
MyGpuProfiler.IC_BeginBlock("Render decals");
MyRender11.CopyGbufferToScratch();
MyScreenDecals.Draw();
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MyRender11.GetRenderProfiler().StartProfilingBlock("Render foliage");
MyGpuProfiler.IC_BeginBlock("Render foliage");
MyFoliageRenderer.Render();
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MySceneMaterials.MoveToGPU();
MyRender11.GetRenderProfiler().StartProfilingBlock("Postprocessing");
MyGpuProfiler.IC_BeginBlock("Postprocessing");
if (MultisamplingEnabled)
{
MyRender11.Context.ClearDepthStencilView(MyScreenDependants.m_resolvedDepth.m_DSV, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1, 0);
MyGpuProfiler.IC_BeginBlock("MarkAAEdges");
MyAAEdgeMarking.Run();
MyGpuProfiler.IC_EndBlock();
MyDepthResolve.Run(MyScreenDependants.m_resolvedDepth, MyGBuffer.Main.DepthStencil.Depth);
}
MyGpuProfiler.IC_BeginBlock("MarkCascades");
MyShadows.MarkCascadesInStencil();
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("Shadows resolve");
MyShadowsResolve.Run();
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("SSAO");
if (Postprocess.EnableSsao)
{
MySSAO.Run(MyScreenDependants.m_ambientOcclusion, MyGBuffer.Main, MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.Depth : MyGBuffer.Main.DepthStencil.Depth);
}
else
{
MyRender11.Context.ClearRenderTargetView(MyScreenDependants.m_ambientOcclusion.m_RTV, Color4.White);
}
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("Lights");
MyLightRendering.Render();
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().StartProfilingBlock("Billboards");
MyGpuProfiler.IC_BeginBlock("Billboards");
MyRender11.Context.ClearRenderTargetView((MyScreenDependants.m_particlesRT as IRenderTargetBindable).RTV, new Color4(0, 0, 0, 0));
if (MyRender11.MultisamplingEnabled)
{
MyBillboardRenderer.Render(MyScreenDependants.m_particlesRT, MyScreenDependants.m_resolvedDepth, MyScreenDependants.m_resolvedDepth.Depth);
}
else
{
MyBillboardRenderer.Render(MyScreenDependants.m_particlesRT, MyGBuffer.Main.DepthStencil, MyGBuffer.Main.DepthStencil.Depth);
}
MyBlendTargets.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyScreenDependants.m_particlesRT, MyRender11.BlendAlphaPremult);
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
MyAtmosphereRenderer.Render();
MyGpuProfiler.IC_BeginBlock("Luminance reduction");
MyBindableResource avgLum = null;
if (MyRender11.MultisamplingEnabled)
{
//MyLBufferResolve.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBufferResolved), MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), MyGBuffer.Main.DepthStencil.Stencil);
MyImmediateRC.RC.Context.ResolveSubresource(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer).m_resource, 0, MyGBuffer.Main.Get(MyGbufferSlot.LBufferResolved).m_resource, 0, SharpDX.DXGI.Format.R11G11B10_Float);
}
if (m_resetEyeAdaptation)
{
MyImmediateRC.RC.Context.ClearUnorderedAccessView(m_prevLum.m_UAV, Int4.Zero);
m_resetEyeAdaptation = false;
}
avgLum = MyLuminanceAverage.Run(m_reduce0, m_reduce1, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), m_prevLum, m_localLum);
MyGpuProfiler.IC_EndBlock();
if (MyRender11.Settings.DispalyHdrDebug)
{
var src = MyGBuffer.Main.Get(MyGbufferSlot.LBuffer) as MyRenderTarget;
MyHdrDebugTools.CreateHistogram(src.m_SRV, src.m_resolution, src.m_samples.X);
}
MyGpuProfiler.IC_BeginBlock("Bloom");
var bloom = MyBloom.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum);
MyGpuProfiler.IC_EndBlock();
MyBindableResource tonemapped;
if (MyRender11.FxaaEnabled)
{
tonemapped = m_rgba8_linear;
}
else
{
tonemapped = m_uav3;
}
MyGpuProfiler.IC_BeginBlock("Tone mapping");
MyToneMapping.Run(tonemapped, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum, bloom, MyRender11.Settings.EnableTonemapping && Postprocess.EnableTonemapping && MyRender11.RenderSettings.TonemappingEnabled);
MyGpuProfiler.IC_EndBlock();
MyBindableResource renderedImage;
if (MyRender11.FxaaEnabled)
{
MyGpuProfiler.IC_BeginBlock("FXAA");
MyFXAA.Run(m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm, View = MyViewEnum.RtvView
}), tonemapped);
MyGpuProfiler.IC_EndBlock();
renderedImage = m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView
});
}
else
{
//renderedImage = (tonemapped as MyCustomTexture).GetView(new MyViewKey { Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView });
renderedImage = tonemapped;
}
if (MyOutline.AnyOutline())
{
MyOutline.Run();
if (MyRender11.FxaaEnabled)
{
MyBlendTargets.RunWithStencil(m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}), MyRender11.m_rgba8_1, MyRender11.BlendAdditive);
}
else
{
if (MyRender11.MultisamplingEnabled)
{
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendAdditive);
}
else
{
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendAdditive);
}
}
}
m_finalImage = renderedImage;
if (blitToBackbuffer)
{
MyCopyToRT.Run(Backbuffer, renderedImage);
}
if (MyRender11.Settings.DispalyHdrDebug)
{
MyHdrDebugTools.DisplayHistogram(Backbuffer.m_RTV, (avgLum as IShaderResourceBindable).SRV);
}
MyGpuProfiler.IC_EndBlock();
MyRender11.GetRenderProfiler().EndProfilingBlock();
}
internal static void Render(MyUnorderedAccessTexture accumTarget, MyUnorderedAccessTexture coverageTarget)
{
ProfilerShort.Begin("Atmosphere");
MyGpuProfiler.IC_BeginBlock("Atmosphere");
if (MyRender11.DebugOverrides.Atmosphere)
{
MyAtmosphereRenderer.Render();
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Clouds");
MyGpuProfiler.IC_BeginBlock("Clouds");
if (MyRender11.DebugOverrides.Clouds)
{
MyCloudRenderer.Render();
}
MyGpuProfiler.IC_EndBlock();
// setup weighted blended OIT targets + blend states
if (MyRender11.DebugOverrides.OIT)
{
SetupOIT(accumTarget, coverageTarget, true);
}
else
{
SetupStandard();
}
MyDepthStencil depthResource;
if (MyRender11.MultisamplingEnabled)
{
depthResource = MyScreenDependants.m_resolvedDepth;
}
else
{
depthResource = MyGBuffer.Main.DepthStencil;
}
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginBlock("Billboards");
MyBillboardRenderer.Render(depthResource.Depth);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("GPU Particles");
MyGpuProfiler.IC_BeginBlock("GPU Particles");
if (MyRender11.DebugOverrides.GPUParticles)
{
MyGPUParticleRenderer.Run(depthResource.Depth);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Billboards - Depth Only");
MyGpuProfiler.IC_BeginBlock("Billboards - Depth Only");
bool windowsFound = MyBillboardRenderer.RenderWindowsDepthOnly(depthResource, MyRender11.Gbuffer1Copy);
MyGpuProfiler.IC_EndBlock();
if (MyRender11.DebugOverrides.OIT && windowsFound)
{
SetupOIT(accumTarget, coverageTarget, false);
}
ProfilerShort.BeginNextBlock("Render decals - Transparent");
MyGpuProfiler.IC_BeginBlock("Render decals - Transparent");
MyScreenDecals.Draw(true);
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("OIT Resolve");
// resolve weighted blended OIT in accum / coverage to LBuffer
if (MyRender11.DebugOverrides.OIT)
{
ResolveOIT(accumTarget, coverageTarget);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
}
internal static void Render(IRtvTexture gbuffer1Copy)
{
IBorrowedUavTexture accumTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.AccumTarget", Format.R16G16B16A16_Float);
IBorrowedUavTexture coverageTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.CoverageTarget", Format.R16_UNorm);
ProfilerShort.Begin("Atmosphere");
MyGpuProfiler.IC_BeginBlock("Atmosphere");
if (MyRender11.DebugOverrides.Atmosphere)
{
MyAtmosphereRenderer.RenderGBuffer();
}
ProfilerShort.BeginNextBlock("Clouds");
MyGpuProfiler.IC_BeginNextBlock("Clouds");
if (MyRender11.DebugOverrides.Clouds)
{
MyCloudRenderer.Render();
}
var depthResource = MyGBuffer.Main.ResolvedDepthStencil;
// setup weighted blended OIT targets + blend states
if (MyRender11.Settings.DrawBillboards)
{
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginNextBlock("Billboards");
MyBillboardRenderer.Gather();
MyBillboardRenderer.RenderAdditveBottom(depthResource.SrvDepth);
SetupTargets(accumTarget, coverageTarget, true);
MyBillboardRenderer.RenderStandard(depthResource.SrvDepth);
}
else
{
SetupTargets(accumTarget, coverageTarget, true);
}
ProfilerShort.BeginNextBlock("GPU Particles");
MyGpuProfiler.IC_BeginNextBlock("GPU Particles");
if (MyRender11.DebugOverrides.GPUParticles)
{
MyGPUParticleRenderer.Run(depthResource.SrvDepth, MyGBuffer.Main.GBuffer1);
}
// Render decals on transparent surfaces in 2 steps: first far, second proximity
if (MyRender11.Settings.DrawGlass)
{
ProfilerShort.BeginNextBlock("Static glass");
MyGpuProfiler.IC_BeginNextBlock("Static glass");
m_glassWithDecals.Clear();
MyStaticGlassRenderer.Render(HandleGlass);
float intervalMax = MyScreenDecals.VISIBLE_DECALS_SQ_TH;
for (int it = 0; it < m_distances.Length; it++)
{
float intervalMin = m_distances[it];
ProfilerShort.BeginNextBlock("Glass - Depth Only");
MyGpuProfiler.IC_BeginNextBlock("Glass - Depth Only");
//TODO: This code should properly render glass decals, that they are visible when looking through window on another window
// Anyway, it is italian code and it doesnt work. Solve after Beta
bool glassFound = MyStaticGlassRenderer.RenderGlassDepthOnly(depthResource, gbuffer1Copy, intervalMin, intervalMax);
// if (glassFound)
{
SetupTargets(accumTarget, coverageTarget, false);
ProfilerShort.BeginNextBlock("Render decals - Transparent");
MyGpuProfiler.IC_BeginNextBlock("Render decals - Transparent");
MyScreenDecals.Draw(gbuffer1Copy, true /*, m_glassWithDecals*/);
}
intervalMax = intervalMin;
}
}
if (IsUsedOverlappingHeatMap())
{
DisplayOverlappingHeatMap(accumTarget, coverageTarget, MyRender11.Settings.DisplayTransparencyHeatMapInGrayscale);
}
MyGpuProfiler.IC_BeginNextBlock("OIT Resolve");
// resolve weighted blended OIT in accum / coverage to LBuffer
if (MyRender11.DebugOverrides.OIT)
{
ResolveOIT(accumTarget, coverageTarget);
}
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginNextBlock("Billboards");
if (MyRender11.Settings.DrawBillboards)
{
MyBillboardRenderer.RenderAdditveTop(depthResource.SrvDepth);
}
RC.SetRtv(null);
MyGpuProfiler.IC_EndBlock();
coverageTarget.Release();
accumTarget.Release();
ProfilerShort.End();
}
internal static void Render()
{
IBorrowedUavTexture accumTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.AccumTarget", Format.R16G16B16A16_Float);
IBorrowedUavTexture coverageTarget = MyManagers.RwTexturesPool.BorrowUav("MyTransparentRendering.CoverageTarget", Format.R16_UNorm);
ProfilerShort.Begin("Atmosphere");
MyGpuProfiler.IC_BeginBlock("Atmosphere");
if (MyRender11.DebugOverrides.Atmosphere)
{
MyAtmosphereRenderer.Render();
}
ProfilerShort.BeginNextBlock("Clouds");
MyGpuProfiler.IC_BeginNextBlock("Clouds");
if (MyRender11.DebugOverrides.Clouds)
{
MyCloudRenderer.Render();
}
MyGpuProfiler.IC_EndBlock();
// setup weighted blended OIT targets + blend states
SetupTargets(accumTarget, coverageTarget, true);
IDepthStencil depthResource;
if (MyRender11.MultisamplingEnabled)
{
depthResource = MyScreenDependants.m_resolvedDepth;
}
else
{
depthResource = MyGBuffer.Main.DepthStencil;
}
m_windowsWithDecals.Clear();
ProfilerShort.BeginNextBlock("Billboards");
MyGpuProfiler.IC_BeginBlock("Billboards");
bool resetBindings = MyBillboardRenderer.Gather(HandleWindow);
if (resetBindings)
{
SetupTargets(accumTarget, coverageTarget, false);
}
MyBillboardRenderer.Render(depthResource.SrvDepth);
ProfilerShort.BeginNextBlock("GPU Particles");
MyGpuProfiler.IC_BeginNextBlock("GPU Particles");
if (MyRender11.DebugOverrides.GPUParticles)
{
MyGPUParticleRenderer.Run(depthResource.SrvDepth);
}
MyGpuProfiler.IC_EndBlock();
// Render decals on transparent surfaces in 2 steps: first far, second proximity
float intervalMax = MyScreenDecals.VISIBLE_DECALS_SQ_TH;
for (int it = 0; it < m_distances.Length; it++)
{
float intervalMin = m_distances[it];
ProfilerShort.BeginNextBlock("Billboards - Depth Only");
MyGpuProfiler.IC_BeginBlock("Billboards - Depth Only");
bool windowsFound = MyBillboardRenderer.RenderWindowsDepthOnly(depthResource, MyGlobalResources.Gbuffer1Copy, intervalMin, intervalMax);
MyGpuProfiler.IC_EndBlock();
if (windowsFound)
{
SetupTargets(accumTarget, coverageTarget, false);
ProfilerShort.BeginNextBlock("Render decals - Transparent");
MyGpuProfiler.IC_BeginBlock("Render decals - Transparent");
MyScreenDecals.Draw(true, m_windowsWithDecals);
MyGpuProfiler.IC_EndBlock();
}
intervalMax = intervalMin;
}
if (IsUsedOverlappingHeatMap())
{
DisplayOverlappingHeatMap(accumTarget, coverageTarget, MyRender11.Settings.DisplayTransparencyHeatMapInGrayscale);
}
MyGpuProfiler.IC_BeginBlock("OIT Resolve");
// resolve weighted blended OIT in accum / coverage to LBuffer
if (MyRender11.DebugOverrides.OIT)
{
ResolveOIT(accumTarget, coverageTarget);
}
else
{
RC.SetRtv(null);
}
MyGpuProfiler.IC_EndBlock();
coverageTarget.Release();
accumTarget.Release();
ProfilerShort.End();
}
// Returns the final image and copies it to renderTarget if non-null
private static MyBindableResource DrawGameScene(MyBindableResource renderTarget)
{
MyGpuProfiler.IC_BeginBlock("Clear & Geometry Render");
PrepareGameScene();
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear");
MyRenderContext.Immediate.Clear();
MyRenderContext.Immediate.DeviceContext.ClearState();
ProfilerShort.End();
}
if (MyStereoRender.Enable && MyStereoRender.EnableUsingStencilMask)
{
ProfilerShort.Begin("MyStereoStencilMask.Draw");
MyGpuProfiler.IC_BeginBlock("MyStereoStencilMask.Draw");
MyStereoStencilMask.Draw();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
}
MyGpuProfiler.IC_BeginBlock("MyGeometryRenderer.Render");
Debug.Assert(m_commandLists.Count == 0, "Not all command lists executed last frame!");
ProfilerShort.Begin("DynamicGeometryRenderer");
DynamicGeometryRenderer.Render(m_commandLists, true);
ProfilerShort.End(); // End function block
if (MyScene.SeparateGeometry)
{
ProfilerShort.Begin("StaticGeometryRenderer");
StaticGeometryRenderer.Render(m_commandLists, false);
ProfilerShort.End(); // End function block
}
SendGlobalOutputMessages();
ExecuteCommandLists(m_commandLists);
MyGpuProfiler.IC_EndBlock();
#if !UNSHARPER_TMP
MyEnvironmentProbe.FinalizeEnvProbes();
#endif
// cleanup context atfer deferred lists
if (MyRender11.DeferredContextsEnabled)
{
ProfilerShort.Begin("Clear2");
MyRenderContext.Immediate.Clear();
ProfilerShort.End();
}
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear3");
MyRenderContext.Immediate.Clear();
MyRenderContext.Immediate.DeviceContext.ClearState();
ProfilerShort.End();
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.Begin("Render decals - Opaque");
MyGpuProfiler.IC_BeginBlock("Render decals - Opaque");
MyRender11.CopyGbufferToScratch();
MyScreenDecals.Draw(false);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Render foliage");
MyGpuProfiler.IC_BeginBlock("Render foliage");
m_foliageRenderer.Render();
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("GBuffer Resolve");
ProfilerShort.BeginNextBlock("MySceneMaterials.MoveToGPU");
MySceneMaterials.MoveToGPU();
int nPasses = MyStereoRender.Enable ? 2 : 1;
for (int i = 0; i < nPasses; i++)
{
if (MyStereoRender.Enable)
{
MyStereoRender.RenderRegion = i == 0 ? MyStereoRegion.LEFT : MyStereoRegion.RIGHT;
}
if (MultisamplingEnabled)
{
MyRender11.DeviceContext.ClearDepthStencilView(MyScreenDependants.m_resolvedDepth.m_DSV, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1, 0);
MyGpuProfiler.IC_BeginBlock("MarkAAEdges");
MyAAEdgeMarking.Run();
MyGpuProfiler.IC_EndBlock();
MyDepthResolve.Run(MyScreenDependants.m_resolvedDepth, MyGBuffer.Main.DepthStencil.Depth);
}
ProfilerShort.BeginNextBlock("Shadows");
MyGpuProfiler.IC_BeginBlock("Shadows");
if (MyScene.SeparateGeometry)
{
MyShadowCascadesPostProcess.Combine(MyShadowCascades.CombineShadowmapArray, DynamicShadows.ShadowCascades, StaticShadows.ShadowCascades);
DynamicShadows.ShadowCascades.PostProcess(MyRender11.PostProcessedShadows, MyShadowCascades.CombineShadowmapArray);
}
else
{
DynamicShadows.ShadowCascades.PostProcess(MyRender11.PostProcessedShadows, DynamicShadows.ShadowCascades.CascadeShadowmapArray);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("SSAO");
MyGpuProfiler.IC_BeginBlock("SSAO");
if (Postprocess.EnableSsao && m_debugOverrides.Postprocessing && m_debugOverrides.SSAO)
{
MySSAO.Run(MyScreenDependants.m_ambientOcclusion, MyGBuffer.Main, MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.Depth : MyGBuffer.Main.DepthStencil.Depth);
if (MySSAO.UseBlur)
{
MyBlur.Run(MyScreenDependants.m_ambientOcclusion, MyScreenDependants.m_ambientOcclusionHelper, MyScreenDependants.m_ambientOcclusion);
}
}
else
{
MyRender11.DeviceContext.ClearRenderTargetView(MyScreenDependants.m_ambientOcclusion.m_RTV, Color4.White);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Lights");
MyGpuProfiler.IC_BeginBlock("Lights");
if (m_debugOverrides.Lighting)
{
MyLightRendering.Render();
}
MyGpuProfiler.IC_EndBlock();
if (MyRender11.DebugOverrides.Flares)
{
MyLightRendering.DrawFlares();
}
}
MyStereoRender.RenderRegion = MyStereoRegion.FULLSCREEN;
MyGpuProfiler.IC_EndBlock();
// Rendering for VR is solved inside of Transparent rendering
ProfilerShort.BeginNextBlock("Transparent Pass");
MyGpuProfiler.IC_BeginBlock("Transparent Pass");
if (m_debugOverrides.Transparent)
{
MyTransparentRendering.Render(m_transparencyAccum, m_transparencyCoverage);
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("PostProcess");
MyGpuProfiler.IC_BeginBlock("PostProcess");
MyGpuProfiler.IC_BeginBlock("Luminance reduction");
MyBindableResource avgLum = null;
if (m_resetEyeAdaptation)
{
MyRenderContext.Immediate.DeviceContext.ClearUnorderedAccessView(m_prevLum.m_UAV, Int4.Zero);
m_resetEyeAdaptation = false;
}
avgLum = MyLuminanceAverage.Run(m_reduce0, m_reduce1, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), m_prevLum);
MyGpuProfiler.IC_EndBlock();
if (MyRender11.Settings.DisplayHdrDebug)
{
var src = MyGBuffer.Main.Get(MyGbufferSlot.LBuffer) as MyRenderTarget;
MyHdrDebugTools.CreateHistogram(src.m_SRV, src.m_resolution, src.m_samples.X);
}
MyGpuProfiler.IC_BeginBlock("Bloom");
MyBindableResource bloom;
if (m_debugOverrides.Postprocessing && m_debugOverrides.Bloom)
{
bloom = MyBloom.Run(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum);
}
else
{
MyRender11.DeviceContext.ClearRenderTargetView(MyRender11.EighthScreenUavHDR.m_RTV, Color4.Black);
bloom = MyRender11.EighthScreenUavHDR;
}
MyGpuProfiler.IC_EndBlock();
MyBindableResource tonemapped;
bool fxaa = MyRender11.FxaaEnabled;
if (fxaa)
{
tonemapped = m_rgba8_linear;
}
else
{
tonemapped = m_uav3;
}
MyGpuProfiler.IC_BeginBlock("Tone mapping");
if (m_debugOverrides.Postprocessing && m_debugOverrides.Tonemapping)
{
MyToneMapping.Run(tonemapped, MyGBuffer.Main.Get(MyGbufferSlot.LBuffer), avgLum, bloom, Postprocess.EnableTonemapping);
}
else
{
tonemapped = MyGBuffer.Main.Get(MyGbufferSlot.LBuffer);
//MyRender11.DeviceContext.CopyResource(MyGBuffer.Main.Get(MyGbufferSlot.LBuffer).m_resource, tonemapped.m_resource);
}
MyGpuProfiler.IC_EndBlock();
MyBindableResource renderedImage;
if (fxaa)
{
MyGpuProfiler.IC_BeginBlock("FXAA");
MyFXAA.Run(m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm, View = MyViewEnum.RtvView
}), tonemapped);
MyGpuProfiler.IC_EndBlock();
renderedImage = m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView
});
}
else
{
//renderedImage = (tonemapped as MyCustomTexture).GetView(new MyViewKey { Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.SrvView });
renderedImage = tonemapped;
}
ProfilerShort.Begin("Outline");
if (MyOutline.AnyOutline())
{
MyOutline.Run();
MyGpuProfiler.IC_BeginBlock("Outline Blending");
ProfilerShort.Begin("Outline Blending");
if (fxaa)
{
MyBlendTargets.RunWithStencil(
m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}),
MyRender11.m_rgba8_1,
MyRender11.BlendAdditive,
MyDepthStencilState.TestOutlineMeshStencil,
0x40);
MyBlendTargets.RunWithStencil(
m_rgba8_0.GetView(new MyViewKey {
Fmt = SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, View = MyViewEnum.RtvView
}),
MyRender11.m_rgba8_1,
MyRender11.BlendTransparent,
MyDepthStencilState.TestHighlightMeshStencil,
0x40);
}
else
{
if (MyRender11.MultisamplingEnabled)
{
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_ms, MyRender11.BlendAdditive);
MyBlendTargets.RunWithPixelStencilTest(tonemapped, MyRender11.m_rgba8_ms, MyRender11.BlendTransparent, true);
}
else
{
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendAdditive, MyDepthStencilState.TestOutlineMeshStencil, 0x40);
MyBlendTargets.RunWithStencil(tonemapped, MyRender11.m_rgba8_1, MyRender11.BlendTransparent, MyDepthStencilState.TestHighlightMeshStencil, 0x40);
}
}
ProfilerShort.End();
MyGpuProfiler.IC_EndBlock();
}
ProfilerShort.End();
if (renderTarget != null)
{
MyCopyToRT.Run(renderTarget, renderedImage);
}
if (MyRender11.Settings.DisplayHdrDebug)
{
var target = renderTarget as IRenderTargetBindable;
var lum = avgLum as IShaderResourceBindable;
if (target != null && lum != null)
{
MyHdrDebugTools.DisplayHistogram(target.RTV, lum.SRV);
}
}
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
return(renderedImage);
}
// Returns the final image and copies it to renderTarget if non-null
private static IRtvTexture DrawGameScene(IRtvBindable renderTarget)
{
MyGpuProfiler.IC_BeginBlockAlways("ClearAndGeometryRender");
PrepareGameScene();
// todo: shouldn't be necessary
if (true)
{
ProfilerShort.Begin("Clear");
MyRender11.RC.ClearState();
ProfilerShort.End();
}
if (MyStereoRender.Enable && MyStereoRender.EnableUsingStencilMask)
{
ProfilerShort.Begin("MyStereoStencilMask.Draw");
MyGpuProfiler.IC_BeginBlock("MyStereoStencilMask.Draw");
MyStereoStencilMask.Draw();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
}
MyGpuProfiler.IC_BeginBlock("MyGeometryRenderer.Render");
Debug.Assert(m_commandLists.Count == 0, "Not all command lists executed last frame!");
ProfilerShort.Begin("DynamicGeometryRenderer");
DynamicGeometryRenderer.Render(m_commandLists, true);
ProfilerShort.End(); // End function block
if (MyScene.SeparateGeometry)
{
ProfilerShort.Begin("StaticGeometryRenderer");
StaticGeometryRenderer.Render(m_commandLists, false);
ProfilerShort.End(); // End function block
}
SendGlobalOutputMessages();
ExecuteCommandLists(m_commandLists);
MyGpuProfiler.IC_EndBlock();
#if !UNSHARPER_TMP
MyManagers.EnvironmentProbe.FinalizeEnvProbes();
#endif
// cleanup context atfer deferred lists
if (true)
{
ProfilerShort.Begin("Clear3");
MyRender11.RC.ClearState();
ProfilerShort.End();
}
MyGpuProfiler.IC_EndBlockAlways();
ProfilerShort.Begin("Render decals - Opaque");
MyGpuProfiler.IC_BeginBlock("Render decals - Opaque");
MyImmediateRC.RC.CopyResource(MyGBuffer.Main.GBuffer1.Resource, MyGlobalResources.Gbuffer1Copy.Resource); // copy gbuffer1
MyScreenDecals.Draw(false);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.BeginNextBlock("Render foliage");
MyGpuProfiler.IC_BeginBlockAlways("RenderFoliage");
m_foliageRenderer.Render();
MyGpuProfiler.IC_EndBlockAlways();
MyGpuProfiler.IC_BeginBlock("GBuffer Resolve");
ProfilerShort.BeginNextBlock("MySceneMaterials.MoveToGPU");
MySceneMaterials.MoveToGPU();
MyRender11.RC.ResetTargets();
int nPasses = MyStereoRender.Enable ? 2 : 1;
for (int i = 0; i < nPasses; i++)
{
if (MyStereoRender.Enable)
{
MyStereoRender.RenderRegion = i == 0 ? MyStereoRegion.LEFT : MyStereoRegion.RIGHT;
}
if (MultisamplingEnabled)
{
MyRender11.RC.ClearDsv(MyScreenDependants.m_resolvedDepth, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1, 0);
MyGpuProfiler.IC_BeginBlock("MarkAAEdges");
MyAAEdgeMarking.Run();
MyGpuProfiler.IC_EndBlock();
MyDepthResolve.Run(MyScreenDependants.m_resolvedDepth, MyGBuffer.Main.DepthStencil);
}
ProfilerShort.BeginNextBlock("Shadows");
MyGpuProfiler.IC_BeginBlockAlways("Shadows");
IBorrowedUavTexture postProcessedShadows;
if (MyScene.SeparateGeometry)
{
MyShadowCascadesPostProcess.Combine(MyShadowCascades.CombineShadowmapArray, DynamicShadows.ShadowCascades, StaticShadows.ShadowCascades);
postProcessedShadows = DynamicShadows.ShadowCascades.PostProcess(MyShadowCascades.CombineShadowmapArray);
//MyShadowCascadesPostProcess.Combine(MyShadowCascades.CombineShadowmapArray,
// DynamicShadows.ShadowCascades, StaticShadows.ShadowCascades);
//postProcessedShadows =
// DynamicShadows.ShadowCascades.PostProcess(MyShadowCascades.CombineShadowmapArray);
}
else
{
postProcessedShadows = DynamicShadows.ShadowCascades.PostProcess(DynamicShadows.ShadowCascades.CascadeShadowmapArray);
//postProcessedShadows = MyManagers.Shadow.Evaluate();
}
MyGpuProfiler.IC_EndBlockAlways();
if (MySSAO.Params.Enabled && m_debugOverrides.Postprocessing && m_debugOverrides.SSAO)
{
ProfilerShort.BeginNextBlock("SSAO");
MyGpuProfiler.IC_BeginBlockAlways("SSAO");
MySSAO.Run(MyScreenDependants.m_ambientOcclusion, MyGBuffer.Main, MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.SrvDepth : MyGBuffer.Main.DepthStencil.SrvDepth);
if (MySSAO.Params.UseBlur)
{
MyBlur.Run(MyScreenDependants.m_ambientOcclusion, MyScreenDependants.m_ambientOcclusionHelper, MyScreenDependants.m_ambientOcclusion, clearColor: Color4.White);
}
MyGpuProfiler.IC_EndBlockAlways();
}
else if (MyHBAO.Params.Enabled && m_debugOverrides.Postprocessing && m_debugOverrides.SSAO)
{
ProfilerShort.BeginNextBlock("HBAO");
MyGpuProfiler.IC_BeginBlock("HBAO");
MyHBAO.Run(MyScreenDependants.m_ambientOcclusion, MyGBuffer.Main,
MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.SrvDepth : MyGBuffer.Main.DepthStencil.SrvDepth);
MyGpuProfiler.IC_EndBlock();
}
else
{
MyRender11.RC.ClearRtv(MyScreenDependants.m_ambientOcclusion, Color4.White);
}
ProfilerShort.BeginNextBlock("Lights");
MyGpuProfiler.IC_BeginBlockAlways("Lights");
if (m_debugOverrides.Lighting)
{
MyLightRendering.Render(postProcessedShadows);
}
MyGpuProfiler.IC_EndBlockAlways();
postProcessedShadows.Release();
if (MyRender11.DebugOverrides.Flares)
{
MyLightRendering.DrawFlares();
}
}
MyStereoRender.RenderRegion = MyStereoRegion.FULLSCREEN;
MyGpuProfiler.IC_EndBlock();
// Rendering for VR is solved inside of Transparent rendering
ProfilerShort.BeginNextBlock("Transparent Pass");
MyGpuProfiler.IC_BeginBlockAlways("TransparentPass");
if (m_debugOverrides.Transparent)
{
MyTransparentRendering.Render();
}
MyGpuProfiler.IC_EndBlockAlways();
ProfilerShort.BeginNextBlock("PostProcess");
MyGpuProfiler.IC_BeginBlockAlways("PostProcess");
MyGpuProfiler.IC_BeginBlock("Luminance reduction");
IBorrowedUavTexture avgLum = null;
if (MyRender11.Postprocess.EnableEyeAdaptation)
{
if (m_resetEyeAdaptation)
{
MyLuminanceAverage.Reset();
m_resetEyeAdaptation = false;
}
avgLum = MyLuminanceAverage.Run(MyGBuffer.Main.LBuffer);
}
else
{
avgLum = MyLuminanceAverage.Skip();
}
MyGpuProfiler.IC_EndBlock();
IBorrowedUavTexture histogram = null;
if (MyRender11.Settings.DisplayHistogram)
{
histogram = MyHdrDebugTools.CreateHistogram(MyGBuffer.Main.LBuffer, MyGBuffer.Main.SamplesCount);
}
if (MyRender11.Settings.DisplayHdrIntensity)
{
MyHdrDebugTools.DisplayHdrIntensity(MyGBuffer.Main.LBuffer);
}
MyGpuProfiler.IC_BeginBlock("Bloom");
IBorrowedUavTexture bloom;
if (m_debugOverrides.Postprocessing && m_debugOverrides.Bloom)
{
bloom = MyBloom.Run(MyGBuffer.Main.LBuffer, MyGBuffer.Main.GBuffer2,
MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth.SrvDepth : MyGBuffer.Main.DepthStencil.SrvDepth);
}
else
{
bloom = MyManagers.RwTexturesPool.BorrowUav("bloom_EightScreenUavHDR", MyRender11.ResolutionI.X / 8, MyRender11.ResolutionI.Y / 8, MyGBuffer.LBufferFormat);
MyRender11.RC.ClearRtv(bloom, Color4.Black);
}
MyGpuProfiler.IC_EndBlock();
MyGpuProfiler.IC_BeginBlock("Tone mapping");
IBorrowedUavTexture tonemapped = MyToneMapping.Run(MyGBuffer.Main.LBuffer, avgLum, bloom, Postprocess.EnableTonemapping && m_debugOverrides.Postprocessing && m_debugOverrides.Tonemapping);
bloom.Release();
MyGpuProfiler.IC_EndBlock();
IRtvTexture renderedImage;
IBorrowedCustomTexture rgba8_0 = null;
bool fxaa = MyRender11.FxaaEnabled;
if (fxaa)
{
rgba8_0 = MyManagers.RwTexturesPool.BorrowCustom("MyRender11.Rgb8_0");
MyGpuProfiler.IC_BeginBlock("FXAA");
MyFXAA.Run(rgba8_0.Linear, tonemapped);
MyGpuProfiler.IC_EndBlock();
renderedImage = rgba8_0.SRgb;
}
else
{
renderedImage = tonemapped;
}
ProfilerShort.Begin("Outline");
if (MyOutline.AnyOutline())
{
IBorrowedRtvTexture outlined = MyOutline.Run();
MyGpuProfiler.IC_BeginBlock("Outline Blending");
ProfilerShort.Begin("Outline Blending");
if (fxaa)
{
MyBlendTargets.RunWithStencil(
rgba8_0.SRgb,
outlined,
MyBlendStateManager.BlendAdditive,
MyDepthStencilStateManager.TestOutlineMeshStencil,
0x40);
MyBlendTargets.RunWithStencil(
rgba8_0.SRgb,
outlined,
MyBlendStateManager.BlendTransparent,
MyDepthStencilStateManager.TestHighlightMeshStencil,
0x40);
}
else
{
if (MyRender11.MultisamplingEnabled)
{
MyBlendTargets.RunWithPixelStencilTest(tonemapped, outlined, MyBlendStateManager.BlendAdditive);
MyBlendTargets.RunWithPixelStencilTest(tonemapped, outlined, MyBlendStateManager.BlendTransparent, true);
}
else
{
MyBlendTargets.RunWithStencil(tonemapped, outlined, MyBlendStateManager.BlendAdditive, MyDepthStencilStateManager.TestOutlineMeshStencil, 0x40);
MyBlendTargets.RunWithStencil(tonemapped, outlined, MyBlendStateManager.BlendTransparent, MyDepthStencilStateManager.TestHighlightMeshStencil, 0x40);
}
}
ProfilerShort.End();
MyGpuProfiler.IC_EndBlock();
outlined.Release();
}
ProfilerShort.End();
if (renderTarget != null)
{
MyCopyToRT.Run(renderTarget, renderedImage);
}
if (MyRender11.Settings.DisplayHistogram)
{
if (renderTarget != null && avgLum != null)
{
MyHdrDebugTools.DisplayHistogram(renderTarget, avgLum, histogram);
}
}
MyGpuProfiler.IC_EndBlockAlways();
ProfilerShort.End();
if (rgba8_0 != null)
{
rgba8_0.Release();
}
if (histogram != null)
{
histogram.Release();
}
avgLum.Release();
tonemapped.Release();
// HOTFIX: MyDebugTextureDisplay uses borrowed textures. If we place MyDebugTextureDisplay to the different location, we will have problem with borrowed textures (comment by Michal)
ProfilerShort.Begin("MyDebugTextureDisplay.Draw");
MyGpuProfiler.IC_BeginBlock("MyDebugTextureDisplay.Draw");
MyDebugTextureDisplay.Draw(MyRender11.Backbuffer);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
return(renderedImage);
}
static void Gather()
{
m_batches.Clear();
// counting sorted billboards
m_sortedCount = 0;
m_unsortedCount = 0;
m_windowCount = 0;
PreGatherList(MyRenderProxy.BillboardsRead);
PreGatherList(m_billboardsOnce);
if (BillboardCount == 0)
{
return;
}
ResizeStorage();
int sortedIndex = 0;
int unsortedIndex = 0;
GatherList(MyRenderProxy.BillboardsRead, ref sortedIndex, ref unsortedIndex);
GatherList(m_billboardsOnce, ref sortedIndex, ref unsortedIndex);
Array.Sort(m_sortedBuffer, 0, m_sortedCount);
int i = 0;
int windowidx = 0;
var N = BillboardCountSafe;
int currentOffset = 0;
TexId prevTexId = TexId.NULL;
TexId batchTexId = TexId.NULL;
MyTransparentMaterial prevMaterial = null;
while (true)
{
if (i == N)
{
AddBatch(N, currentOffset, prevTexId, prevMaterial);
break;
}
MyBillboard billboard = m_sortedBuffer[i];
MyTransparentMaterial material = MyTransparentMaterials.GetMaterial(billboard.Material);
if (material.UseAtlas)
{
var atlasItem = m_atlas.FindElement(material.Texture);
batchTexId = atlasItem.TextureId;
}
else
{
batchTexId = MyTextures.GetTexture(material.Texture, MyTextureEnum.GUI, true);
}
bool closeBatch = i > 0 && (batchTexId != prevTexId || i == m_sortedCount);
if (closeBatch)
{
AddBatch(i, currentOffset, prevTexId, prevMaterial);
currentOffset = i;
}
var billboardData = new MyBillboardData();
var billboardVertices = new MyBillboardVertexData();
billboardData.CustomProjectionID = billboard.CustomViewProjection;
billboardData.Color = billboard.Color;
billboardData.Color.X *= billboard.ColorIntensity;
billboardData.Color.Y *= billboard.ColorIntensity;
billboardData.Color.Z *= billboard.ColorIntensity;
billboardData.AlphaCutout = billboard.AlphaCutout;
billboardData.AlphaSaturation = material.AlphaSaturation;
billboardData.SoftParticleDistanceScale = billboard.SoftParticleDistanceScale * material.SoftParticleDistanceScale;
billboardData.Reflective = billboard.Reflectivity;
Vector3D pos0 = billboard.Position0;
Vector3D pos1 = billboard.Position1;
Vector3D pos2 = billboard.Position2;
Vector3D pos3 = billboard.Position3;
if (billboard.ParentID != -1)
{
if (MyIDTracker <MyActor> .FindByID((uint)billboard.ParentID) != null)
{
var matrix = MyIDTracker <MyActor> .FindByID((uint)billboard.ParentID).WorldMatrix;
Vector3D.Transform(ref pos0, ref matrix, out pos0);
Vector3D.Transform(ref pos1, ref matrix, out pos1);
Vector3D.Transform(ref pos2, ref matrix, out pos2);
Vector3D.Transform(ref pos3, ref matrix, out pos3);
}
}
MyEnvironmentMatrices envMatrices = MyRender11.Environment;
if (MyStereoRender.Enable)
{
if (MyStereoRender.RenderRegion == MyStereoRegion.LEFT)
{
envMatrices = MyStereoRender.EnvMatricesLeftEye;
}
else if (MyStereoRender.RenderRegion == MyStereoRegion.RIGHT)
{
envMatrices = MyStereoRender.EnvMatricesRightEye;
}
}
if (billboard.CustomViewProjection != -1)
{
var billboardViewProjection = MyRenderProxy.BillboardsViewProjectionRead[billboard.CustomViewProjection];
//pos0 -= envMatrices.CameraPosition;
//pos1 -= envMatrices.CameraPosition;
//pos2 -= envMatrices.CameraPosition;
//pos3 -= envMatrices.CameraPosition;
}
else
{
pos0 -= envMatrices.CameraPosition;
pos1 -= envMatrices.CameraPosition;
pos2 -= envMatrices.CameraPosition;
pos3 -= envMatrices.CameraPosition;
}
var normal = Vector3.Cross(pos1 - pos0, pos2 - pos0);
normal.Normalize();
billboardData.Normal = normal;
billboardVertices.V0.Position = pos0;
billboardVertices.V1.Position = pos1;
billboardVertices.V2.Position = pos2;
billboardVertices.V3.Position = pos3;
var uv0 = new Vector2(material.UVOffset.X + billboard.UVOffset.X, material.UVOffset.Y + billboard.UVOffset.Y);
var uv1 = new Vector2(material.UVOffset.X + material.UVSize.X * billboard.UVSize.X + billboard.UVOffset.X, material.UVOffset.Y + billboard.UVOffset.Y);
var uv2 = new Vector2(material.UVOffset.X + material.UVSize.X * billboard.UVSize.X + billboard.UVOffset.X, material.UVOffset.Y + billboard.UVOffset.Y + material.UVSize.Y * billboard.UVSize.Y);
var uv3 = new Vector2(material.UVOffset.X + billboard.UVOffset.X, material.UVOffset.Y + billboard.UVOffset.Y + material.UVSize.Y * billboard.UVSize.Y);
if (material.UseAtlas)
{
var atlasItem = m_atlas.FindElement(material.Texture);
uv0 = uv0 * new Vector2(atlasItem.UvOffsetScale.Z, atlasItem.UvOffsetScale.W) + new Vector2(atlasItem.UvOffsetScale.X, atlasItem.UvOffsetScale.Y);
uv1 = uv1 * new Vector2(atlasItem.UvOffsetScale.Z, atlasItem.UvOffsetScale.W) + new Vector2(atlasItem.UvOffsetScale.X, atlasItem.UvOffsetScale.Y);
uv2 = uv2 * new Vector2(atlasItem.UvOffsetScale.Z, atlasItem.UvOffsetScale.W) + new Vector2(atlasItem.UvOffsetScale.X, atlasItem.UvOffsetScale.Y);
uv3 = uv3 * new Vector2(atlasItem.UvOffsetScale.Z, atlasItem.UvOffsetScale.W) + new Vector2(atlasItem.UvOffsetScale.X, atlasItem.UvOffsetScale.Y);
}
billboardVertices.V0.Texcoord = new HalfVector2(uv0);
billboardVertices.V1.Texcoord = new HalfVector2(uv1);
billboardVertices.V2.Texcoord = new HalfVector2(uv2);
billboardVertices.V3.Texcoord = new HalfVector2(uv3);
pos0.AssertIsValid();
pos1.AssertIsValid();
pos2.AssertIsValid();
pos3.AssertIsValid();
MyTriangleBillboard triBillboard = billboard as MyTriangleBillboard;
if (triBillboard != null)
{
billboardVertices.V3.Position = pos2; // second triangle will die in rasterizer
billboardVertices.V0.Texcoord = new HalfVector2(triBillboard.UV0);
billboardVertices.V1.Texcoord = new HalfVector2(triBillboard.UV1);
billboardVertices.V2.Texcoord = new HalfVector2(triBillboard.UV2);
billboardData.Normal = triBillboard.Normal0;
}
m_arrayDataBillboards.Data[i] = billboardData;
m_arrayDataBillboards.Vertex[i] = billboardVertices;
if (billboard.Window && MyScreenDecals.HasEntityDecals((uint)billboard.ParentID))
{
m_arrayDataWindows.Data[windowidx] = billboardData;
m_arrayDataWindows.Vertex[windowidx] = billboardVertices;
windowidx++;
}
prevTexId = batchTexId;
prevMaterial = material;
i++;
}
}
internal static void QueryTexturesFromEntities()
{
MyMeshMaterials1.OnResourcesRequesting();
MyVoxelMaterials1.OnResourcesRequesting();
MyScreenDecals.OnResourcesRequesting();
}
