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);
}
}
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);
}
}
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 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 sealed override void SetupMaterial(MyEffectBase shader, MyRenderMeshMaterial material)
{
System.Diagnostics.Debug.Assert(material != null);
shader.SetEmissivity(0);
MyRender.CheckTextures(shader, material.NormalTexture, material.DrawTechnique == MyMeshDrawTechnique.HOLO);
}
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);
}
static void UnloadEffects()
{
for (int i = 0; i < Enum.GetValues(typeof(MyEffects)).GetLength(0); i++)
{
MyEffectBase effect = m_effects[i];
if (effect != null)
{
effect.Dispose();
m_effects[i] = null;
}
}
}
static void SetupShaderForMaterialAlternative(MyEffectBase shader, MyVoxelCacheCellRenderBatchType batchType, MyMwcVoxelMaterialsEnum m0, MyMwcVoxelMaterialsEnum?m1, MyMwcVoxelMaterialsEnum?m2)
{
MyEffectVoxels effectVoxels = shader as MyEffectVoxels;
if (batchType == MyVoxelCacheCellRenderBatchType.SINGLE_MATERIAL)
{
effectVoxels.UpdateVoxelTextures(OverrideVoxelMaterial ?? m0);
}
else if (batchType == MyVoxelCacheCellRenderBatchType.MULTI_MATERIAL)
{
effectVoxels.UpdateVoxelMultiTextures(OverrideVoxelMaterial ?? m0, OverrideVoxelMaterial ?? m1, OverrideVoxelMaterial ?? m2);
}
}
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)
{
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);
}
/// <summary>
/// Draws the full screen quad
/// </summary>
/// <param name="graphicsDevice">The GraphicsDevice to use for rendering</param>
public void Draw(MyEffectBase effect)
{
// Set the vertex buffer and declaration
MyMinerGame.Static.GraphicsDevice.VertexDeclaration = MyVertexFormatFullScreenQuad.VertexDeclaration;
MyMinerGame.Static.GraphicsDevice.SetStreamSource(0, m_vertexBuffer, 0, MyVertexFormatFullScreenQuad.Stride);
effect.Begin();
// Draw primitives
MyMinerGame.Static.GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.End();
MyPerformanceCounter.PerCameraDraw.TotalDrawCalls++;
}
public static void SetupBaseEffect(MyEffectBase effect, float fogMultiplierMult = 1.0f)
{
if (MyRender.EnableFog)
{
effect.SetFogDistanceFar(MySector.FogProperties.FogFar);
effect.SetFogDistanceNear(MySector.FogProperties.FogNear);
effect.SetFogColor(MySector.FogProperties.FogColor);
effect.SetFogMultiplier(MySector.FogProperties.FogMultiplier * fogMultiplierMult);
effect.SetFogBacklightMultiplier(MySector.FogProperties.FogBacklightMultiplier);
}
else
{
effect.SetFogMultiplier(0);
}
//if (MyRenderConstants.RenderQualityProfile.ForwardRender || !MyRender.EnableLODBlending)
{
if (MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD0)
{
effect.SetLodCut((GetLodTransitionDistanceFar() + GetLodTransitionDistanceNear()) / 2.0f);
}
else
if (MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD1)
{
effect.SetLodCut(-(GetLodTransitionDistanceFar() + GetLodTransitionDistanceNear()) / 2.0f);
}
else
{
effect.SetLodCut(0);
}
effect.SetLodBackgroundCut(GetLodTransitionDistanceBackgroundEnd());
}
/*
* if (!MyRenderConstants.RenderQualityProfile.ForwardRender && MyRender.EnableLODBlending)
* {
* if (MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD1)
* {
* //effect.SetLodCut(-(GetLodTransitionDistanceFar() + GetLodTransitionDistanceNear()) / 2.0f);
* //effect.SetLodCut(-(GetLodTransitionDistanceFar() + GetLodTransitionDistanceNear()) / 2.0f);
* effect.SetLodCut(0);
* }
* else
* {
* effect.SetLodCut(0);
* }
* } */
}
public static void SetupBaseEffect(MyEffectBase effect, MyLodTypeEnum lodType, float fogMultiplierMult = 1.0f)
{
if (MyRender.Settings.EnableFog)
{
effect.SetFogDistanceFar(MyRender.FogProperties.FogFar);
effect.SetFogDistanceNear(MyRender.FogProperties.FogNear);
effect.SetFogColor(MyRender.FogProperties.FogColor);
effect.SetFogMultiplier(MyRender.FogProperties.FogMultiplier * fogMultiplierMult);
effect.SetFogBacklightMultiplier(MyRender.FogProperties.FogBacklightMultiplier);
}
else
{
effect.SetFogMultiplier(0);
}
}
static void UnloadEffects()
{
MyMwcLog.WriteLine("MyRender.UnloadEffects - START");
for (int i = 0; i < Enum.GetValues(typeof(MyEffects)).GetLength(0); i++)
{
MyEffectBase effect = m_effects[i];
if (effect != null)
{
effect.Dispose();
m_effects[i] = null;
}
}
MyMwcLog.WriteLine("MyRender.UnloadEffects - END");
}
/// <summary>
/// Draws the full screen quad
/// </summary>
/// <param name="graphicsDevice">The GraphicsDevice to use for rendering</param>
public void Draw(MyEffectBase effect)
{
// Set the vertex buffer and declaration
MyMinerGame.Static.GraphicsDevice.VertexDeclaration = MyVertexFormatFullScreenQuad.VertexDeclaration;
MyMinerGame.Static.GraphicsDevice.SetStreamSource(0, m_vertexBuffer, 0, MyVertexFormatFullScreenQuad.Stride);
effect.Begin();
// Draw primitives
MyMinerGame.Static.GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.End();
MyPerformanceCounter.PerCameraDraw.TotalDrawCalls++;
}
protected void SetupBaseEffect(MyEffectBase shader, MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
MyRenderCamera.SetupBaseEffect(shader, lodType, setup.FogMultiplierMult);
if (lodType == MyLodTypeEnum.LOD_NEAR)
{
shader.SetProjectionMatrix(ref MyRenderCamera.ProjectionMatrixForNearObjects);
}
else
{
shader.SetProjectionMatrix(ref MyRenderCamera.ProjectionMatrix);
}
shader.SetViewMatrix(ref MyRenderCamera.ViewMatrixAtZero);
var rasterizerState = MyRender.Settings.Wireframe ? WireframeRasterizerState : SolidRasterizerState;
rasterizerState.Apply();
}
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);
}
public sealed override void SetupMaterial(MyEffectBase shader, MyRenderMeshMaterial material)
{
System.Diagnostics.Debug.Assert(material != null);
shader.SetTextureDiffuse(material.DiffuseTexture);
shader.SetTextureNormal(material.NormalTexture);
shader.SetSpecularIntensity(material.SpecularIntensity);
shader.SetSpecularPower(material.SpecularPower);
shader.SetDiffuseUVAnim(material.DiffuseUVAnim);
shader.SetEmissivityUVAnim(material.EmissiveUVAnim);
shader.SetEmissivityOffset(material.EmissivityOffset);
((MyEffectModelsDNS)shader).EnableColorMaskHsv(material.DiffuseTexture != null ? material.EnableColorMask : false);
((MyEffectModelsDNS)shader).SetDitheringTexture((SharpDX.Direct3D9.Texture)MyTextureManager.GetTexture <MyTexture2D>(@"Textures\Models\Dither.png"));
((MyEffectModelsDNS)shader).SetHalfPixel(MyRenderCamera.Viewport.Width, MyRenderCamera.Viewport.Height);
// TODO: Petrzilka - Get rid of this branching
if (material.DrawTechnique == MyMeshDrawTechnique.HOLO)
{
shader.SetEmissivity(material.HoloEmissivity);
}
if (material.Emissivity.HasValue)
{
shader.SetEmissivity(material.Emissivity.Value);
}
else
{
shader.SetEmissivity(0);
}
MyRender.CheckTextures(shader, material.NormalTexture, material.DrawTechnique == MyMeshDrawTechnique.HOLO);
}
public override void SetupMaterial(MyEffectBase shader, MyRenderMeshMaterial material)
{
// nothing to do
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
SetupVoxelEntity(m_currentLod, shader, renderElement);
}
static void SetupShaderForMaterialAlternative(MyEffectBase shader, MyMeshMaterial material)
{
switch (material.DrawTechnique)
{
case MyMeshDrawTechnique.MESH:
case MyMeshDrawTechnique.DECAL:
case MyMeshDrawTechnique.HOLO:
case MyMeshDrawTechnique.ALPHA_MASKED:
{
if (material != null)
{
shader.SetTextureDiffuse(material.DiffuseTexture);
shader.SetTextureNormal(material.NormalTexture);
//Do we need this? Graphicians dont use this
//shader.SetDiffuseColor(material.DiffuseColor);
shader.SetSpecularIntensity(material.SpecularIntensity);
shader.SetSpecularPower(material.SpecularPower);
shader.SetDiffuseUVAnim(material.DiffuseUVAnim);
shader.SetEmissivityUVAnim(material.EmissiveUVAnim);
shader.SetEmissivityOffset(material.EmissivityOffset);
if (material.DrawTechnique == MyMeshDrawTechnique.HOLO)
{
shader.SetEmissivity(material.HoloEmissivity);
}
// Commented due 856 - graphicians have to reexport white diffuse colors from MAX
//shader.SetDiffuseColor(material.DiffuseColor);
}
else
{
shader.SetTextureDiffuse(null);
shader.SetTextureNormal(null);
shader.SetSpecularPower(1);
shader.SetSpecularIntensity(1);
//this value is set from object if not from material
//shader.SetDiffuseColor(material.DiffuseColor);
}
if (CheckDiffuseTextures)
{
if (!shader.IsTextureDiffuseSet())
{
LazyLoadDebugTextures();
shader.SetTextureDiffuse(m_debugTexture);
shader.SetDiffuseColor(Vector3.One);
shader.SetEmissivity(1);
}
else
{
if (material.DrawTechnique != MyMeshDrawTechnique.HOLO)
{
shader.SetEmissivity(0);
}
}
}
if (CheckNormalTextures)
{
if (!shader.IsTextureNormalSet())
{
LazyLoadDebugTextures();
shader.SetTextureDiffuse(m_debugTexture);
shader.SetEmissivity(1);
}
else
{
shader.SetTextureDiffuse(material.NormalTexture);
//shader.SetTextureDiffuse(m_debugNormalTexture);
shader.SetEmissivity(0);
}
}
if (!shader.IsTextureNormalSet())
{
LazyLoadDebugTextures();
shader.SetTextureNormal(m_debugTexture);
}
}
break;
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
case MyMeshDrawTechnique.VOXELS_DEBRIS:
break;
default:
{
throw new MyMwcExceptionApplicationShouldNotGetHere();
}
}
}
static void BeginShaderAlternative(MyEffectBase shader, MyMeshDrawTechnique technique, MyVoxelCacheCellRenderBatchType batchType)
{
switch (technique)
{
case MyMeshDrawTechnique.DECAL:
{
if (shader is MyEffectModelsDNS)
{
(shader as MyEffectModelsDNS).BeginBlended();
}
}
break;
case MyMeshDrawTechnique.HOLO:
{
if (m_currentLodDrawPass != MyLodTypeEnum.LOD_NEAR && !MyRenderConstants.RenderQualityProfile.ForwardRender)
{
(shader as MyEffectModelsDNS).ApplyHolo(false);
}
else
{
(shader as MyEffectModelsDNS).ApplyHolo(true);
}
}
break;
case MyMeshDrawTechnique.ALPHA_MASKED:
{
(shader as MyEffectModelsDNS).ApplyMasked();
}
break;
case MyMeshDrawTechnique.VOXEL_MAP:
{
MyEffectVoxels effectVoxels = shader as MyEffectVoxels;
if (batchType == MyVoxelCacheCellRenderBatchType.SINGLE_MATERIAL)
{
effectVoxels.Apply();
}
else if (batchType == MyVoxelCacheCellRenderBatchType.MULTI_MATERIAL)
{
effectVoxels.ApplyMultimaterial();
}
break;
}
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
{
((MyEffectVoxelsStaticAsteroid)shader).Apply();
}
break;
case MyMeshDrawTechnique.MESH:
{
((MyEffectModelsDNS)shader).SetTechnique(MyRenderConstants.RenderQualityProfile.ModelsRenderTechnique);
}
break;
case MyMeshDrawTechnique.VOXELS_DEBRIS:
{
((MyEffectVoxelsDebris)shader).SetTechnique(MyRenderConstants.RenderQualityProfile.VoxelsRenderTechnique);
}
break;
default:
{
System.Diagnostics.Debug.Assert(false);
}
break;
}
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyDrawTechniqueVoxelSingle.SetupVoxelEntity(m_currentLod, shader, renderElement);
}
public override void SetupMaterial(MyEffectBase shader, MyRenderMeshMaterial material)
{
throw new InvalidOperationException();
}
public abstract void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement);
public abstract void SetupMaterial(MyEffectBase shader, MyRenderMeshMaterial material);
private static void SetupShaderForEntity(MyEffectBase shader, MyRenderElement renderElement)
{
// m_renderProfiler.StartProfilingBlock("SetupShaderForEntity");
MyEffectBase currRenderEffect = null;
Vector3 diffuseColor = Vector3.One;
Vector3 highlightColor = Vector3.Zero;
float emisivity = 0;
MyEntity entity = renderElement.Entity;
if (entity.GetDiffuseColor().HasValue)
diffuseColor = entity.GetDiffuseColor().Value;
highlightColor = entity.GetHighlightColor();
switch (renderElement.DrawTechnique)
{
case MyMeshDrawTechnique.MESH:
case MyMeshDrawTechnique.DECAL:
case MyMeshDrawTechnique.HOLO:
case MyMeshDrawTechnique.ALPHA_MASKED:
{
MyEffectModelsDNS effectDNS = shader as MyEffectModelsDNS;
effectDNS.SetWorldMatrix(renderElement.WorldMatrixForDraw);
effectDNS.SetDiffuseColor(diffuseColor);
effectDNS.SetEmissivity(emisivity);
effectDNS.SetHighlightColor(highlightColor);
}
break;
case MyMeshDrawTechnique.VOXELS_DEBRIS:
{
//m_renderProfiler.StartProfilingBlock("VOXELD");
MyEffectVoxelsDebris effectVoxelsDebris = shader as MyEffectVoxelsDebris;
MyExplosionDebrisVoxel explosionDebrisVoxel = entity as MyExplosionDebrisVoxel;
// Random texture coord scale and per-object random texture coord offset
effectVoxelsDebris.SetTextureCoordRandomPositionOffset(explosionDebrisVoxel.GetRandomizedTextureCoordRandomPositionOffset());
effectVoxelsDebris.SetTextureCoordScale(explosionDebrisVoxel.GetRandomizedTextureCoordScale());
effectVoxelsDebris.SetDiffuseTextureColorMultiplier(explosionDebrisVoxel.GetRandomizedDiffuseTextureColorMultiplier());
effectVoxelsDebris.SetViewWorldScaleMatrix(renderElement.WorldMatrixForDraw * MyCamera.ViewMatrixAtZero);
effectVoxelsDebris.SetWorldMatrix(ref renderElement.WorldMatrixForDraw);
effectVoxelsDebris.SetDiffuseColor(diffuseColor);
effectVoxelsDebris.SetHighlightColor(highlightColor);
effectVoxelsDebris.SetEmissivity(0);
effectVoxelsDebris.UpdateVoxelTextures(explosionDebrisVoxel.VoxelMaterial);
currRenderEffect = effectVoxelsDebris;
//m_renderProfiler.EndProfilingBlock();
}
break;
case MyMeshDrawTechnique.VOXEL_MAP:
{
//m_renderProfiler.StartProfilingBlock("VOXMAP");
MyVoxelMap voxelMap = entity as MyVoxelMap;
MyEffectVoxels effectVoxels = shader as MyEffectVoxels;
effectVoxels.SetVoxelMapPosition(voxelMap.PositionLeftBottomCorner - MyCamera.Position);
effectVoxels.SetDiffuseColor(diffuseColor);
effectVoxels.SetHighlightColor(highlightColor);
effectVoxels.EnablePerVertexAmbient(EnablePerVertexVoxelAmbient);
//m_renderProfiler.EndProfilingBlock();
}
break;
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
{
// m_renderProfiler.StartProfilingBlock("STATA");
MyEffectVoxelsStaticAsteroid effectVoxelsStaticAsteroid = shader as MyEffectVoxelsStaticAsteroid;
var asteroid = ((MyStaticAsteroid)entity);
//effectVoxelsStaticAsteroid.UpdateVoxelTextures(((MyStaticAsteroid)entity).VoxelMaterial);
//effectVoxelsStaticAsteroid.UpdateVoxelMultiTextures(((MyStaticAsteroid)entity).VoxelMaterial, ((MyStaticAsteroid)entity).VoxelMaterial1, null);
if (asteroid.VoxelMaterial1 == null || MyRenderConstants.RenderQualityProfile.ForwardRender)
{
effectVoxelsStaticAsteroid.UpdateVoxelTextures(asteroid.VoxelMaterial);
}
else
{
Debug.Assert(asteroid.FieldDir != null);
effectVoxelsStaticAsteroid.SetEmissivityPower1(3f);
effectVoxelsStaticAsteroid.SetTime(MyMinerGame.TotalGamePlayTimeInMilliseconds);
effectVoxelsStaticAsteroid.SetFieldDir(asteroid.FieldDir.Value);
effectVoxelsStaticAsteroid.UpdateVoxelMultiTextures(asteroid.VoxelMaterial, asteroid.VoxelMaterial1, null);
}
effectVoxelsStaticAsteroid.SetWorldMatrix(ref renderElement.WorldMatrixForDraw);
effectVoxelsStaticAsteroid.SetDiffuseColor(diffuseColor);
effectVoxelsStaticAsteroid.SetHighlightColor(highlightColor);
effectVoxelsStaticAsteroid.SetEmissivity(0);
//m_renderProfiler.EndProfilingBlock();
}
break;
default:
{
throw new MyMwcExceptionApplicationShouldNotGetHere();
}
}
// m_renderProfiler.EndProfilingBlock();
}
static void BeginShaderAlternative(MyEffectBase shader, MyMeshDrawTechnique technique, MyVoxelCacheCellRenderBatchType batchType)
{
switch (technique)
{
case MyMeshDrawTechnique.DECAL:
{
if (shader is MyEffectModelsDNS)
{
(shader as MyEffectModelsDNS).BeginBlended();
}
}
break;
case MyMeshDrawTechnique.HOLO:
{
if (m_currentLodDrawPass != MyLodTypeEnum.LOD_NEAR && !MyRenderConstants.RenderQualityProfile.ForwardRender)
{
(shader as MyEffectModelsDNS).ApplyHolo(false);
}
else
{
(shader as MyEffectModelsDNS).ApplyHolo(true);
}
}
break;
case MyMeshDrawTechnique.ALPHA_MASKED:
{
(shader as MyEffectModelsDNS).ApplyMasked();
}
break;
case MyMeshDrawTechnique.VOXEL_MAP:
{
MyEffectVoxels effectVoxels = shader as MyEffectVoxels;
if (batchType == MyVoxelCacheCellRenderBatchType.SINGLE_MATERIAL)
{
effectVoxels.Apply();
}
else if (batchType == MyVoxelCacheCellRenderBatchType.MULTI_MATERIAL)
{
effectVoxels.ApplyMultimaterial();
}
break;
}
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
{
((MyEffectVoxelsStaticAsteroid)shader).Apply();
}
break;
case MyMeshDrawTechnique.MESH:
{
((MyEffectModelsDNS)shader).SetTechnique(MyRenderConstants.RenderQualityProfile.ModelsRenderTechnique);
}
break;
case MyMeshDrawTechnique.VOXELS_DEBRIS:
{
((MyEffectVoxelsDebris)shader).SetTechnique(MyRenderConstants.RenderQualityProfile.VoxelsRenderTechnique);
}
break;
default:
{
System.Diagnostics.Debug.Assert(false);
}
break;
}
}
static void SetupShaderForMaterialAlternative(MyEffectBase shader, MyMeshMaterial material)
{
switch (material.DrawTechnique)
{
case MyMeshDrawTechnique.MESH:
case MyMeshDrawTechnique.DECAL:
case MyMeshDrawTechnique.HOLO:
case MyMeshDrawTechnique.ALPHA_MASKED:
{
if (material != null)
{
shader.SetTextureDiffuse(material.DiffuseTexture);
shader.SetTextureNormal(material.NormalTexture);
//Do we need this? Graphicians dont use this
//shader.SetDiffuseColor(material.DiffuseColor);
shader.SetSpecularIntensity(material.SpecularIntensity);
shader.SetSpecularPower(material.SpecularPower);
shader.SetDiffuseUVAnim(material.DiffuseUVAnim);
shader.SetEmissivityUVAnim(material.EmissiveUVAnim);
shader.SetEmissivityOffset(material.EmissivityOffset);
if (material.DrawTechnique == MyMeshDrawTechnique.HOLO)
{
shader.SetEmissivity(material.HoloEmissivity);
}
// Commented due 856 - graphicians have to reexport white diffuse colors from MAX
//shader.SetDiffuseColor(material.DiffuseColor);
}
else
{
shader.SetTextureDiffuse(null);
shader.SetTextureNormal(null);
shader.SetSpecularPower(1);
shader.SetSpecularIntensity(1);
//this value is set from object if not from material
//shader.SetDiffuseColor(material.DiffuseColor);
}
if (CheckDiffuseTextures)
{
if (!shader.IsTextureDiffuseSet())
{
LazyLoadDebugTextures();
shader.SetTextureDiffuse(m_debugTexture);
shader.SetDiffuseColor(Vector3.One);
shader.SetEmissivity(1);
}
else
{
if (material.DrawTechnique != MyMeshDrawTechnique.HOLO)
{
shader.SetEmissivity(0);
}
}
}
if (CheckNormalTextures)
{
if (!shader.IsTextureNormalSet())
{
LazyLoadDebugTextures();
shader.SetTextureDiffuse(m_debugTexture);
shader.SetEmissivity(1);
}
else
{
shader.SetTextureDiffuse(material.NormalTexture);
//shader.SetTextureDiffuse(m_debugNormalTexture);
shader.SetEmissivity(0);
}
}
if (!shader.IsTextureNormalSet())
{
LazyLoadDebugTextures();
shader.SetTextureNormal(m_debugTexture);
}
}
break;
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
case MyMeshDrawTechnique.VOXELS_DEBRIS:
break;
default:
{
throw new MyMwcExceptionApplicationShouldNotGetHere();
}
}
}
static void SetupShaderForMaterialAlternative(MyEffectBase shader, MyVoxelCacheCellRenderBatchType batchType, MyMwcVoxelMaterialsEnum m0, MyMwcVoxelMaterialsEnum? m1, MyMwcVoxelMaterialsEnum? m2)
{
MyEffectVoxels effectVoxels = shader as MyEffectVoxels;
if (batchType == MyVoxelCacheCellRenderBatchType.SINGLE_MATERIAL)
{
effectVoxels.UpdateVoxelTextures(OverrideVoxelMaterial ?? m0);
}
else if (batchType == MyVoxelCacheCellRenderBatchType.MULTI_MATERIAL)
{
effectVoxels.UpdateVoxelMultiTextures(OverrideVoxelMaterial ?? m0, OverrideVoxelMaterial ?? m1, OverrideVoxelMaterial ?? m2);
}
}
private static void SetupShaderPerDraw(MyEffectBase shader, MyMeshDrawTechnique technique)
{
// m_renderProfiler.StartProfilingBlock("SetupShaderPerDraw");
MyCamera.SetupBaseEffect(shader, m_currentSetup.FogMultiplierMult);
if (m_currentLodDrawPass == MyLodTypeEnum.LOD_NEAR)
shader.SetProjectionMatrix(ref MyCamera.ProjectionMatrixForNearObjects);
else
shader.SetProjectionMatrix(ref MyCamera.ProjectionMatrix);
shader.SetViewMatrix(ref MyCamera.ViewMatrixAtZero);
switch (technique)
{
case MyMeshDrawTechnique.DECAL:
{
MyStateObjects.Static_Decals_BlendState.Apply();
MyStateObjects.BiasedRasterizer_StaticDecals.Apply();
MyStateObjects.DepthStencil_TestFarObject_DepthReadOnly.Apply();
}
break;
case MyMeshDrawTechnique.HOLO:
{
RasterizerState.CullNone.Apply();
MyStateObjects.Holo_BlendState.Apply();
MyEffectModelsDNS dnsShader = shader as MyEffectModelsDNS;
dnsShader.SetHalfPixel(MyCamera.ForwardViewport.Width, MyCamera.ForwardViewport.Height);
dnsShader.SetScale(GetScaleForViewport(GetRenderTarget(MyRenderTargets.Depth)));
if (m_currentLodDrawPass != MyLodTypeEnum.LOD_NEAR && !MyRenderConstants.RenderQualityProfile.ForwardRender)
{
//m_device.DepthStencilState = DepthStencilState.DepthRead;
MyStateObjects.DepthStencil_TestFarObject_DepthReadOnly.Apply();
MyStateObjects.HoloRasterizerState.Apply();
/*dnsShader.SetDepthTextureNear(GetRenderTarget(MyRenderTargets.Lod0Depth));
dnsShader.SetDepthTextureFar(GetRenderTarget(MyRenderTargets.Lod1Depth));
*/
}
else
{
DepthStencilState.DepthRead.Apply();
}
}
break;
case MyMeshDrawTechnique.ALPHA_MASKED:
{
if (!Wireframe)
RasterizerState.CullCounterClockwise.Apply();
else
MyStateObjects.WireframeRasterizerState.Apply();
BlendState.Opaque.Apply();
}
break;
case MyMeshDrawTechnique.VOXEL_MAP:
{
if (!Wireframe)
RasterizerState.CullCounterClockwise.Apply();
else
MyStateObjects.WireframeRasterizerState.Apply();
break;
}
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
{
if (!Wireframe)
RasterizerState.CullNone.Apply();
else
MyStateObjects.WireframeRasterizerState.Apply();
break;
}
default:
{
if (!Wireframe)
RasterizerState.CullCounterClockwise.Apply();
else
MyStateObjects.WireframeRasterizerState.Apply();
}
break;
}
// m_renderProfiler.EndProfilingBlock();
}
