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 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 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(MyRender.Settings.EnablePerVertexVoxelAmbient);
if (lod == MyLodTypeEnum.LOD_BACKGROUND && renderElement.RenderObject is MyRenderVoxelCellBackground)
{
SetupAtmosphere(effectVoxels, renderElement.RenderObject as MyRenderVoxelCellBackground);
}
}
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);
}
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);
}
}
/// <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
MyRender.GraphicsDevice.VertexDeclaration = MyVertexFormatFullScreenQuad.VertexDeclaration;
MyRender.GraphicsDevice.SetStreamSource(0, m_vertexBuffer, 0, MyVertexFormatFullScreenQuad.Stride);
effect.Begin();
// Draw primitives
MyRender.GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
effect.End();
MyPerformanceCounter.PerCameraDrawWrite["Quad draw calls"]++;
MyPerformanceCounter.PerCameraDrawWrite.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 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 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);
}
}
public abstract void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement);
public abstract void SetupMaterial(MyEffectBase shader, MyRenderMeshMaterial material);
public override void SetupMaterial(MyEffectBase shader, MyRenderMeshMaterial material)
{
throw new InvalidOperationException();
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
SetupVoxelEntity(m_currentLod,shader, renderElement);
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
MyDrawTechniqueVoxelSingle.SetupVoxelEntity(m_currentLod,shader, renderElement);
}
public override void SetupMaterial(MyEffectBase shader, MyRenderMeshMaterial material)
{
// nothing to do
}
public static void CheckTextures(MyEffectBase shader, Texture normalTexture, bool isHolo)
{
if (Settings.CheckDiffuseTextures)
{
if (!shader.IsTextureDiffuseSet())
{
LazyLoadDebugTextures();
shader.SetTextureDiffuse(m_debugTexture);
shader.SetDiffuseColor(Vector3.One);
shader.SetEmissivity(1);
}
else
{
if (!isHolo)
{
shader.SetEmissivity(0);
}
}
}
if (Settings.CheckNormalTextures)
{
if (!shader.IsTextureNormalSet())
{
LazyLoadDebugTextures();
shader.SetTextureDiffuse(m_debugTexture);
shader.SetEmissivity(1);
}
else
{
shader.SetTextureDiffuse(normalTexture);
//shader.SetTextureDiffuse(m_debugNormalTexture);
shader.SetEmissivity(0);
}
}
if (!shader.IsTextureNormalSet())
{
LazyLoadDebugTextures();
shader.SetTextureNormal(m_debugTexture);
}
}
