public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyEffectAtmosphere effectAtmosphere = shader as MyEffectAtmosphere;
effectAtmosphere.SetWorldMatrix((Matrix)renderElement.WorldMatrixForDraw);
effectAtmosphere.SetDiffuseColor(renderElement.Color);
var atmosphere = renderElement.RenderObject as MyRenderAtmosphere;
float depthScale = 0.2f;
effectAtmosphere.SetInnerRadius(atmosphere.PlanetRadius);
effectAtmosphere.SetOutherRadius(atmosphere.AtmosphereRadius);
float scaleAtmosphere = 1.0f / (atmosphere.AtmosphereRadius - atmosphere.PlanetRadius);
effectAtmosphere.SetScaleAtmosphere(scaleAtmosphere);
effectAtmosphere.SetScaleAtmosphereOverScaleDepth(scaleAtmosphere / depthScale);
Vector3 cameraToCenter = atmosphere.GetRelativeCameraPos(MyRenderCamera.Position);
effectAtmosphere.SetRelativeCameraPos(cameraToCenter);
effectAtmosphere.SetLightPos(-MySunGlare.GetSunDirection());
effectAtmosphere.SetIsInside(atmosphere.IsInside(MyRenderCamera.Position));
effectAtmosphere.SetScaleDepth(depthScale);
effectAtmosphere.SetWavelength(atmosphere.AtmosphereWavelengths);
}
public static void SetupVoxelEntity(MyLodTypeEnum lod, MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyEffectVoxels effectVoxels = shader as MyEffectVoxels;
{
MatrixD worldMatrixD = renderElement.WorldMatrix;
worldMatrixD.Translation -= MyRenderCamera.Position;
var worldMatrix = (Matrix)worldMatrixD;
effectVoxels.SetWorldMatrix(ref worldMatrix);
}
//effectVoxels.SetVoxelMapPosition((Vector3)(renderElement.WorldMatrix.Translation - MyRenderCamera.Position));
//effectVoxels.SetPositionLocalOffset((Vector3)(renderElement.WorldMatrix.Right));
//effectVoxels.SetPositionLocalScale((Vector3)(renderElement.WorldMatrix.Up));
//effectVoxels.SetLodBounds(new Vector2((float)renderElement.WorldMatrix.M14, (float)renderElement.WorldMatrix.M24));
effectVoxels.SetDiffuseColor(Vector3.One);
if (MyRenderSettings.DebugClipmapLodColor && renderElement.VoxelBatch.Lod < MyRenderVoxelCell.LOD_COLORS.Length)
{
effectVoxels.SetDiffuseColor(MyRenderVoxelCell.LOD_COLORS[renderElement.VoxelBatch.Lod].ToVector3());
}
effectVoxels.EnablePerVertexAmbient(MyRender.Settings.EnablePerVertexVoxelAmbient);
if (lod == MyLodTypeEnum.LOD_BACKGROUND && renderElement.RenderObject is MyRenderVoxelCellBackground)
{
SetupAtmosphere(effectVoxels, renderElement.RenderObject as MyRenderVoxelCellBackground);
}
}
private void setupRenderElement(MyModel model, Matrix worldMatrix)
{
model.LoadInDraw();
foreach (MyMesh mesh in model.GetMeshList())
{
MyRender.MyRenderElement renderElement =
mesh.GetMaterial().DrawTechnique == MyMeshDrawTechnique.HOLO ?
MyRender.AddTransparentRenderElement(m_setup.TransparentRenderElementsToDraw) :
MyRender.AddRenderElement(m_setup.RenderElementsToDraw);
if (renderElement == null)
{
return;
}
renderElement.Entity = null;
renderElement.DebugName = "";
renderElement.VertexBuffer = model.VertexBuffer;
renderElement.IndexBuffer = mesh.IndexBuffer;
renderElement.WorldMatrixForDraw = worldMatrix;
renderElement.WorldMatrix = worldMatrix;
renderElement.BoundingBox = model.BoundingBox.Transform(renderElement.WorldMatrix);
renderElement.Material = mesh.GetMaterial();
}
}
public static void SetupVoxelEntity(MyLodTypeEnum lod, MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyEffectVoxels effectVoxels = shader as MyEffectVoxels;
{
MatrixD worldMatrixD = renderElement.WorldMatrix;
worldMatrixD.Translation -= MyRenderCamera.Position;
var worldMatrix = (Matrix)worldMatrixD;
effectVoxels.SetWorldMatrix(ref worldMatrix);
}
var voxelCell = renderElement.RenderObject as MyRenderVoxelCell;
if (voxelCell != null)
{
MyRenderVoxelCell.EffectArgs args;
voxelCell.GetEffectArgs(out args);
effectVoxels.VoxelVertex.SetArgs(ref args);
}
effectVoxels.SetDiffuseColor(Vector3.One);
if (MyRenderSettings.DebugClipmapLodColor && renderElement.VoxelBatch.Lod < MyRenderVoxelCell.LOD_COLORS.Length)
{
effectVoxels.SetDiffuseColor(MyRenderVoxelCell.LOD_COLORS[renderElement.VoxelBatch.Lod].ToVector3());
}
effectVoxels.EnablePerVertexAmbient(
MyRenderSettings.EnableVoxelAo,
MyRenderSettings.VoxelAoMin,
MyRenderSettings.VoxelAoMax,
MyRenderSettings.VoxelAoOffset);
}
public sealed override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
base.SetupEntity(shader, renderElement);
MyEffectModelsDNS effectDNS = shader as MyEffectModelsDNS;
MyRenderCharacter character = renderElement.RenderObject as MyRenderCharacter;
var bonesUsed = renderElement.BonesUsed;
if (character.SkinMatrices != null)
{
if (bonesUsed == null)
{
for (int i = 0; i < Math.Min(character.SkinMatrices.Length, MyRenderConstants.MAX_SHADER_BONES); i++)
{
m_bonesBuffer[i] = character.SkinMatrices[i];
}
}
else
{
for (int i = 0; i < bonesUsed.Length; i++)
{
m_bonesBuffer[i] = character.SkinMatrices[bonesUsed[i]];
}
}
effectDNS.SetBones(m_bonesBuffer);
}
}
private void SetupRenderElements(MyModel model, Matrix worldMatrix, int materialIndex = 0, bool staticAsteroid = false)
{
model.LoadInDraw();
var meshList = model.GetMeshList();
foreach (MyMesh mesh in meshList)
{
if (materialIndex > mesh.Materials.Length - 1)
{
materialIndex = 0;
}
var material = staticAsteroid ? MyVoxelMaterials.GetMaterialForMesh(FakeEntity.VoxelMaterial) : mesh.Materials[materialIndex];
material.PreloadTexture(Managers.LoadingMode.Immediate);
if (material.DrawTechnique == MyMeshDrawTechnique.DECAL)
{
continue;
}
if (staticAsteroid && material.DrawTechnique == MyMeshDrawTechnique.MESH)
{
material.DrawTechnique = MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID;
}
//Do not use render alocator, it will reuse elements
MyRender.MyRenderElement renderElement = new MyRender.MyRenderElement();
//MyRender.AllocateRenderElement(out renderElement);
renderElement.Entity = FakeEntity;
renderElement.VertexBuffer = model.VertexBuffer;
renderElement.IndexBuffer = model.IndexBuffer;
renderElement.IndexStart = mesh.IndexStart;
renderElement.TriCount = mesh.TriCount;
//renderElement.UseChannels = false;
renderElement.WorldMatrixForDraw = worldMatrix;
renderElement.WorldMatrix = worldMatrix;
renderElement.Material = material;
renderElement.DrawTechnique = material.DrawTechnique;
renderElement.VoxelBatch = null;
if (material.DrawTechnique == MyMeshDrawTechnique.HOLO)
{
m_setup.TransparentRenderElementsToDraw.Add(renderElement);
}
else
{
m_setup.RenderElementsToDraw.Add(renderElement);
}
}
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
base.SetupEntity(shader, renderElement);
if (renderElement.Dithering > 0)
{
// renderElement.Dithering = 0;
}
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyEffectModelsDNS effectDNS = shader as MyEffectModelsDNS;
effectDNS.SetWorldMatrix((Matrix)renderElement.WorldMatrixForDraw);
effectDNS.SetDiffuseColor(renderElement.Color);
effectDNS.Dithering = renderElement.Dithering;
effectDNS.Time = (float)MyRender.InterpolationTime.Miliseconds;
effectDNS.SetColorMaskHSV(renderElement.ColorMaskHSV);
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyEffectModelsDNS effectDNS = shader as MyEffectModelsDNS;
// This is required, it's position of whole group
effectDNS.SetWorldMatrix((Matrix)renderElement.WorldMatrixForDraw);
// This should be in instance buffer when required
effectDNS.SetDiffuseColor(renderElement.Color);
effectDNS.Dithering = renderElement.Dithering;
effectDNS.SetColorMaskHSV(renderElement.ColorMaskHSV);
effectDNS.SetEmissivity(0);
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
base.SetupEntity(shader, renderElement);
var atmosphere = renderElement.RenderObject as MyRenderAtmosphere;
if (atmosphere.IsInside(MyRenderCamera.Position))
{
MyEffectAtmosphere effectAtmosphere = shader as MyEffectAtmosphere;
Matrix optProjection = Matrix.CreatePerspectiveFieldOfView(MyRenderCamera.FieldOfView, MyRenderCamera.AspectRatio, MyRenderCamera.NEAR_PLANE_DISTANCE, atmosphere.AtmosphereRadius * 2.0f / MyRenderAtmosphere.ATMOSPHERE_SCALE);
effectAtmosphere.SetProjectionMatrix(ref optProjection);
}
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyEffectVoxelsDebris effectVoxelsDebris = (MyEffectVoxelsDebris)shader;
MyRenderVoxelDebris voxelDebris = renderElement.RenderObject as MyRenderVoxelDebris;
// Random texture coord scale and per-object random texture coord offset
effectVoxelsDebris.SetTextureCoordRandomPositionOffset(voxelDebris.TextureCoordOffset);
effectVoxelsDebris.SetTextureCoordScale(voxelDebris.TextureCoordScale);
effectVoxelsDebris.SetDiffuseTextureColorMultiplier(voxelDebris.TextureColorMultiplier);
Matrix m = (Matrix)renderElement.WorldMatrixForDraw;
effectVoxelsDebris.SetViewWorldScaleMatrix(m * MyRenderCamera.ViewMatrixAtZero);
effectVoxelsDebris.SetWorldMatrix(ref m);
effectVoxelsDebris.SetDiffuseColor(Vector3.One);
effectVoxelsDebris.SetEmissivity(0);
effectVoxelsDebris.UpdateVoxelTextures(voxelDebris.VoxelMaterialIndex);
}
private void SetupRenderElements(MyModel model, Matrix worldMatrix, int materialIndex = 0, bool staticAsteroid = false)
{
model.LoadInDraw();
var meshList = model.GetMeshList();
foreach (MyMesh mesh in meshList)
{
if (materialIndex > mesh.Materials.Length - 1)
materialIndex = 0;
var material = staticAsteroid ? MyVoxelMaterials.GetMaterialForMesh(FakeEntity.VoxelMaterial) : mesh.Materials[materialIndex];
material.PreloadTexture(Managers.LoadingMode.Immediate);
if (material.DrawTechnique == MyMeshDrawTechnique.DECAL)
continue;
if (staticAsteroid && material.DrawTechnique == MyMeshDrawTechnique.MESH)
{
material.DrawTechnique = MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID;
}
//Do not use render alocator, it will reuse elements
MyRender.MyRenderElement renderElement = new MyRender.MyRenderElement();
//MyRender.AllocateRenderElement(out renderElement);
renderElement.Entity = FakeEntity;
renderElement.VertexBuffer = model.VertexBuffer;
renderElement.IndexBuffer = model.IndexBuffer;
renderElement.IndexStart = mesh.IndexStart;
renderElement.TriCount = mesh.TriCount;
//renderElement.UseChannels = false;
renderElement.WorldMatrixForDraw = worldMatrix;
renderElement.WorldMatrix = worldMatrix;
renderElement.Material = material;
renderElement.DrawTechnique = material.DrawTechnique;
renderElement.VoxelBatch = null;
if (material.DrawTechnique == MyMeshDrawTechnique.HOLO)
m_setup.TransparentRenderElementsToDraw.Add(renderElement);
else
m_setup.RenderElementsToDraw.Add(renderElement);
}
}
private static void DrawShadowsForElements(MyEffectShadowMap effect, bool relativeCamera, Vector3D cameraPos, List <MyRender.MyRenderElement> elements, bool voxelShadows, bool skinnedShadows, bool instancedShadows, bool genericInstancedShadows, int perfCounterIndex, bool ditheredShadows)
{
effect.Begin();
long lastVertexBuffer = 0;
for (int i = 0; i < elements.Count; i++)
{
MyRender.MyRenderElement renderElement = elements[i];
if ((renderElement.RenderObject is MyRenderVoxelCell) != voxelShadows ||
renderElement.VertexBuffer.IsDisposed ||
renderElement.IndexBuffer.IsDisposed)
{
continue;
}
if ((renderElement.RenderObject is MyRenderCharacter) != skinnedShadows)
{
continue;
}
//if ((renderElement.InstanceBuffer != null) != instancedShadows)
// continue;
if ((renderElement.InstanceBuffer != null && renderElement.InstanceStride == 64) != instancedShadows)
{
continue;
}
if ((renderElement.InstanceBuffer != null && renderElement.InstanceStride == 32) != genericInstancedShadows)
{
continue;
}
long currentVertexBuffer = renderElement.VertexBuffer.GetHashCode();
if ((lastVertexBuffer != currentVertexBuffer) || instancedShadows || genericInstancedShadows)
{
lastVertexBuffer = currentVertexBuffer;
MyRender.GraphicsDevice.Indices = renderElement.IndexBuffer;
MyRender.GraphicsDevice.VertexDeclaration = renderElement.VertexDeclaration;
if (renderElement.InstanceBuffer == null)
{
MyRender.GraphicsDevice.ResetStreamSourceFrequency(0);
MyRender.GraphicsDevice.ResetStreamSourceFrequency(1);
MyRender.GraphicsDevice.SetStreamSource(1, null, 0, 0);
}
else
{
MyRender.GraphicsDevice.SetStreamSourceFrequency(0, renderElement.InstanceCount, StreamSource.IndexedData);
MyRender.GraphicsDevice.SetStreamSourceFrequency(1, 1, StreamSource.InstanceData);
MyRender.GraphicsDevice.SetStreamSource(1, renderElement.InstanceBuffer, renderElement.InstanceStart * renderElement.InstanceStride, renderElement.InstanceStride);
}
MyRender.GraphicsDevice.SetStreamSource(0, renderElement.VertexBuffer, 0, renderElement.VertexStride);
System.Diagnostics.Debug.Assert(renderElement.IndexBuffer != null);
}
if (relativeCamera)
{
MatrixD m = renderElement.WorldMatrix;
m.Translation -= cameraPos;
effect.SetWorldMatrix((Matrix)m);
}
else
{
effect.SetWorldMatrix((Matrix)renderElement.WorldMatrix);
}
if (voxelShadows)
{
var voxelCell = renderElement.RenderObject as MyRenderVoxelCell;
if (voxelCell != null)
{
MyRenderVoxelCell.EffectArgs args;
voxelCell.GetEffectArgs(out args);
effect.VoxelVertex.SetArgs(ref args);
}
}
var skinMatrices = skinnedShadows ? ((MyRenderCharacter)renderElement.RenderObject).SkinMatrices : null;
if (skinMatrices != null)
{
var bonesUsed = renderElement.BonesUsed;
if (bonesUsed == null)
{
for (int b = 0; b < Math.Min(skinMatrices.Length, MyRenderConstants.MAX_SHADER_BONES); b++)
{
m_bonesBuffer[b] = skinMatrices[b];
}
}
else
{
for (int b = 0; b < bonesUsed.Length; b++)
{
m_bonesBuffer[b] = skinMatrices[bonesUsed[b]];
}
}
effect.SetBones(m_bonesBuffer);
}
effect.SetDithering(ditheredShadows ? renderElement.Dithering : 0);
MyPerformanceCounter.PerCameraDrawWrite.ShadowDrawCalls[perfCounterIndex]++;
effect.D3DEffect.CommitChanges();
MyRender.GraphicsDevice.DrawIndexedPrimitive(SharpDX.Direct3D9.PrimitiveType.TriangleList, 0, 0, renderElement.VertexCount, renderElement.IndexStart, renderElement.TriCount);
MyPerformanceCounter.PerCameraDrawWrite.TotalDrawCalls++;
}
MyRender.GraphicsDevice.ResetStreamSourceFrequency(0);
MyRender.GraphicsDevice.ResetStreamSourceFrequency(1);
effect.End();
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyDrawTechniqueVoxelSingle.SetupVoxelEntity(m_currentLod, shader, renderElement);
}
public abstract void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement);
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
SetupVoxelEntity(m_currentLod, shader, renderElement);
}
