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 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 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 override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectModelsDNS)MyRender.GetEffect(MyEffects.ModelDNS);
SetupBaseEffect(shader, setup, lodType);
MyEffectModelsDNS dnsShader = shader as MyEffectModelsDNS;
dnsShader.SetHalfPixel(MyRenderCamera.Viewport.Width, MyRenderCamera.Viewport.Height);
dnsShader.SetScale(MyRender.GetScaleForViewport(MyRender.GetRenderTarget(MyRenderTargets.Depth)));
bool useDepth = lodType != MyLodTypeEnum.LOD_NEAR;
if (useDepth)
{
// DepthStencilState.DepthRead;
MyStateObjects.DepthStencil_TestFarObject_DepthReadOnly.Apply();
}
else
{
DepthStencilState.DepthRead.Apply();
}
MyStateObjects.Holo_BlendState.Apply();
shader.ApplyHolo(!useDepth);
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return shader;
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectModelsDNS)MyRender.GetEffect(MyEffects.ModelDNS);
SetupBaseEffect(shader, setup, lodType);
shader.SetTechnique(MyRenderConstants.RenderQualityProfile.ModelsInstancedSkinnedTechnique);
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return shader;
}
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 MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectAtmosphere)MyRender.GetEffect(MyEffects.Atmosphere);
SetupBaseEffect(shader, setup, lodType);
shader.SetSurfaceTechnique();
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return shader;
}
public override void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement)
{
base.SetupEntity(shader, renderElement);
if (renderElement.Dithering > 0)
{
// renderElement.Dithering = 0;
}
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectModelsDNS)MyRender.GetEffect(MyEffects.ModelDNS);
SetupBaseEffect(shader, setup, lodType);
shader.ApplyMasked();
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return shader;
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
MyEffectVoxelsDebris shader = (MyEffectVoxelsDebris)MyRender.GetEffect(MyEffects.VoxelDebrisMRT);
SetupBaseEffect(shader, setup, lodType);
shader.SetTechnique(MyRenderConstants.RenderQualityProfile.VoxelsRenderTechnique);
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return shader;
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
MyEffectVoxelsDebris shader = (MyEffectVoxelsDebris)MyRender.GetEffect(MyEffects.VoxelDebrisMRT);
SetupBaseEffect(shader, setup, lodType);
shader.SetTechnique(MyRenderConstants.RenderQualityProfile.VoxelsRenderTechnique);
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return(shader);
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectAtmosphere)MyRender.GetEffect(MyEffects.Atmosphere);
SetupBaseEffect(shader, setup, lodType);
shader.SetSurfaceTechnique();
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return(shader);
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectModelsDNS)MyRender.GetEffect(MyEffects.ModelDNS);
SetupBaseEffect(shader, setup, lodType);
shader.ApplyMasked();
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return(shader);
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectAtmosphere)MyRender.GetEffect(MyEffects.Atmosphere);
SetupBaseEffect(shader, setup, lodType);
shader.SetTechnique(MyRenderConstants.RenderQualityProfile.ModelsRenderTechnique);
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return(shader);
}
public static void LoadData()
{
MyRender.GetRenderProfiler().StartProfilingBlock("MyLights.LoadData");
MyRender.Log.WriteLine("MyLights.LoadData() - START");
MyRender.Log.IncreaseIndent();
MyRender.Log.DecreaseIndent();
MyRender.Log.WriteLine("MyLights.LoadData() - END");
MyRender.GetRenderProfiler().EndProfilingBlock();
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectModelsDNS)MyRender.GetEffect(MyEffects.ModelDNS);
SetupBaseEffect(shader, setup, lodType);
shader.SetTechnique(MyRenderConstants.RenderQualityProfile.ModelsInstancedTechnique);
//shader.SetTechnique(MyEffectModelsDNS.MyEffectModelsDNSTechniqueEnum.HighInstanced);
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return(shader);
}
public void PrepareForDraw(MyEffectDistantImpostors effect)
{
RasterizerState.CullClockwise.Apply();
BlendState.Opaque.Apply();
MyMinerGame.SetRenderTarget(MyRender.GetRenderTarget(MyRenderTargets.AuxiliaryHalf0), null);
foreach (MyVoxelMapImpostorGroup group in m_voxelMapImpostorGroups)
{
group.PrepareForDraw(effect);
}
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectModelsDNS)MyRender.GetEffect(MyEffects.ModelDNS);
SetupBaseEffect(shader, setup, lodType);
MyStateObjects.Static_Decals_BlendState.Apply();
MyStateObjects.DepthStencil_TestFarObject_DepthReadOnly.Apply();
shader.BeginBlended();
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return shader;
}
public static void LoadData()
{
MyRender.GetRenderProfiler().StartProfilingBlock("MyParticlesDustField.LoadData");
MyMwcLog.WriteLine("MyParticlesDustField.LoadContent() - START");
MyMwcLog.IncreaseIndent();
MyMwcLog.DecreaseIndent();
MyMwcLog.WriteLine("MyParticlesDustField.LoadContent() - END");
MyRender.GetRenderProfiler().EndProfilingBlock();
}
protected void RenderShadowMap(Matrix lightViewProjectionAtZero)
{
// Set up the effect
MyEffectShadowMap shadowMapEffect = MyRender.GetEffect(MyEffects.ShadowMap) as MyEffectShadowMap;
shadowMapEffect.SetViewProjMatrix(lightViewProjectionAtZero);
shadowMapEffect.SetDitheringTexture((SharpDX.Direct3D9.Texture)MyTextureManager.GetTexture <MyTexture2D>(@"Textures\Models\Dither.png"));
shadowMapEffect.SetHalfPixel(MySpotShadowRenderer.SpotShadowMapSize, MySpotShadowRenderer.SpotShadowMapSize);
// Draw the models
DrawElements(m_renderElementsForShadows, shadowMapEffect, true, MyRenderCamera.Position, MyShadowRenderer.NumSplits, false);
}
private void BlitToThumbnail(GraphicsDevice device, RenderTarget2D renderTarget)
{
device.SetRenderTarget(renderTarget);
var screenEffect = MyRender.GetEffect(MyEffects.Scale) as MyEffectScale;
Debug.Assert(screenEffect != null);
screenEffect.SetTechnique(MyEffectScale.Technique.HWScalePrefabPreviews);
screenEffect.SetSourceTextureMod(m_fullSizeRT);
screenEffect.SetScale(2f * new Vector2(renderTarget.Width / (float)m_fullSizeRT.Width, renderTarget.Height / (float)m_fullSizeRT.Height));
MyGuiManager.GetFullscreenQuad().Draw(screenEffect);
device.SetRenderTarget(null);
}
public static void Draw()
{
if (MyRender.GetCurrentLodDrawPass() == Utils.MyLodTypeEnum.LOD_NEAR && CanDrawCockpitWeapons() && MyFakes.DRAW_WEAPONS)
{
var old = MySession.PlayerShip.Weapons.Visible;
MySession.PlayerShip.Weapons.Visible = true;
MySession.PlayerShip.Weapons.Draw();
MySession.PlayerShip.Weapons.Visible = old;
MySession.PlayerShip.CubeBuilder.Draw();
}
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = MyRender.GetEffect(MyEffects.VoxelsMRT) as MyEffectVoxels;
SetupBaseEffect(shader, setup, lodType);
{
shader.Apply();
}
m_currentLod = lodType;
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return shader;
}
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 MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = (MyEffectModelsDNS)MyRender.GetEffect(MyEffects.ModelDNS);
SetupBaseEffect(shader, setup, lodType);
MyStateObjects.Static_Decals_BlendState.Apply();
MyStateObjects.DepthStencil_TestFarObject_DepthReadOnly.Apply();
shader.BeginBlended();
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return(shader);
}
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 MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = MyRender.GetEffect(MyEffects.VoxelsMRT) as MyEffectVoxels;
SetupBaseEffect(shader, setup, lodType);
{
shader.ApplyMultimaterial();
}
shader.Begin(0, SharpDX.Direct3D9.FX.None);
m_currentLod = lodType;
return(shader);
}
private void BlitToThumbnail(Device device, Texture renderTarget)
{
MyMinerGame.SetRenderTarget(renderTarget, null);
var screenEffect = MyRender.GetEffect(MyEffects.Scale) as MyEffectScale;
Debug.Assert(screenEffect != null);
screenEffect.SetTechnique(MyEffectScale.Technique.HWScalePrefabPreviews);
screenEffect.SetSourceTextureMod(m_fullSizeRT);
//screenEffect.SetScale(2f * new Vector2(renderTarget.Width / (float)m_fullSizeRT.Width, renderTarget.Height / (float)m_fullSizeRT.Height));
screenEffect.SetScale(2f * new Vector2((renderTarget.GetLevelDescription(0).Width - 1) / (float)m_fullSizeRT.GetLevelDescription(0).Width, (renderTarget.GetLevelDescription(0).Height - 1) / (float)m_fullSizeRT.GetLevelDescription(0).Height));
MyGuiManager.GetFullscreenQuad().Draw(screenEffect);
MyMinerGame.SetRenderTarget(null, null);
}
public override void RecreateControls(bool contructor)
{
Controls.Clear();
m_scale = 0.7f;
AddCaption(new System.Text.StringBuilder("Render Lights debug"), Color.Yellow.ToVector4());
MyGuiControlLabel label = new MyGuiControlLabel(this, new Vector2(0.01f, -m_size.Value.Y / 2.0f + 0.07f), null, new System.Text.StringBuilder("(press ALT to share focus)"), Color.Yellow.ToVector4(), MyGuiConstants.LABEL_TEXT_SCALE * 0.7f,
MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_TOP);
Controls.Add(label);
m_currentPosition = -m_size.Value / 2.0f + new Vector2(0.02f, 0.10f);
m_currentPosition.Y += 0.01f;
AddLabel(new StringBuilder("Lights"), Color.Yellow.ToVector4(), 1.2f);
AddCheckBox(new StringBuilder("Enable lights"), null, MemberHelper.GetMember(() => EnableRenderLights));
AddCheckBox(new StringBuilder("Enable light glares"), null, MemberHelper.GetMember(() => MyLightGlare.EnableLightGlares));
AddCheckBox(new StringBuilder("Enable spot shadows"), null, MemberHelper.GetMember(() => MyRender.EnableSpotShadows));
AddCheckBox(new StringBuilder("Enable spectator light"), null, MemberHelper.GetMember(() => MyRender.EnableSpectatorReflector));
AddCheckBox(new StringBuilder("Only specular intensity"), null, MemberHelper.GetMember(() => MyRender.ShowSpecularIntensity));
AddCheckBox(new StringBuilder("Only specular power"), null, MemberHelper.GetMember(() => MyRender.ShowSpecularPower));
AddCheckBox(new StringBuilder("Only emissivity"), null, MemberHelper.GetMember(() => MyRender.ShowEmissivity));
AddCheckBox(new StringBuilder("Only reflectivity"), null, MemberHelper.GetMember(() => MyRender.ShowReflectivity));
MyEffectShadowMap shadowMapEffect = MyRender.GetEffect(MyEffects.ShadowMap) as MyEffectShadowMap;
if (shadowMapEffect != null)
{
m_currentPosition.Y += 0.01f;
AddLabel(new StringBuilder("Sun"), Color.Yellow.ToVector4(), 1.2f);
AddCheckBox(new StringBuilder("Enable sun"), null, MemberHelper.GetMember(() => MyRender.EnableSun));
AddCheckBox(new StringBuilder("Enable shadows"), null, MemberHelper.GetMember(() => MyRender.EnableShadows));
AddCheckBox(new StringBuilder("Enable asteroid shadows"), null, MemberHelper.GetMember(() => MyRender.EnableAsteroidShadows));
AddCheckBox(new StringBuilder("Enable ambient map"), MyRender.EnableEnvironmentMapAmbient, OnAmbientMapChecked);
AddCheckBox(new StringBuilder("Enable reflection map"), MyRender.EnableEnvironmentMapReflection, OnReflectionMapChecked);
AddCheckBox(new StringBuilder("Enable voxel ambient"), null, MemberHelper.GetMember(() => MyRender.EnablePerVertexVoxelAmbient));
AddSlider(new StringBuilder("Intensity"), 0, 10.0f, MySector.SunProperties, MemberHelper.GetMember(() => MySector.SunProperties.SunIntensity));
AddCheckBox(new StringBuilder("Show cascade splits"), null, MemberHelper.GetMember(() => MyRender.ShowCascadeSplits));
//nefunguje po obfuskaci
// AddSlider(new StringBuilder("ShadowBias"), 0, 0.01f, shadowMapEffect, MemberHelper.GetMember(() => shadowMapEffect.ShadowBias));
AddCheckBox(new StringBuilder("Enable shadow interleaving"), null, MemberHelper.GetMember(() => MyRender.ShadowInterleaving));
AddCheckBox(new StringBuilder("Freeze cascade 0"), null, MemberHelper.GetMember(() => MyRender.FreezeCascade0));
AddCheckBox(new StringBuilder("Freeze cascade 1"), null, MemberHelper.GetMember(() => MyRender.FreezeCascade1));
AddCheckBox(new StringBuilder("Freeze cascade 2"), null, MemberHelper.GetMember(() => MyRender.FreezeCascade2));
AddCheckBox(new StringBuilder("Freeze cascade 3"), null, MemberHelper.GetMember(() => MyRender.FreezeCascade3));
}
}
void PrepareViewportForCascade(int splitIndex)
{
// Set the viewport for the current split
Viewport splitViewport = new Viewport();
splitViewport.MinDepth = 0;
splitViewport.MaxDepth = 1;
splitViewport.Width = ShadowMapCascadeSize;
splitViewport.Height = ShadowMapCascadeSize;
splitViewport.X = splitIndex * ShadowMapCascadeSize;
splitViewport.Y = 0;
//Must be here because otherwise it crasher after resolution change
MyRender.SetDeviceViewport(splitViewport);
}
public static void DrawModel(MyModel model, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, Vector3 diffuseColor, float alpha)
{
var effect = (MyEffectModelsDiffuse)MyRender.GetEffect(MyEffects.ModelDiffuse);
effect.SetWorldMatrix(worldMatrix);
effect.SetViewMatrix(ref viewMatrix);
effect.SetProjectionMatrix(ref projectionMatrix);
effect.SetDiffuseColor(new Vector4(diffuseColor, alpha));
effect.SetTechnique(MyEffectModelsDiffuse.Technique.Position);
effect.Begin();
model.Render();
effect.End();
}
public override void RecreateControls(bool contructor)
{
Controls.Clear();
AddCaption(new StringBuilder("Volumetric SSAO Debug"), Color.Yellow.ToVector4());
MyGuiControlLabel label = new MyGuiControlLabel(this, new Vector2(0.01f, -m_size.Value.Y / 2.0f + 0.07f), null, new System.Text.StringBuilder("(press ALT to share focus)"), Color.Yellow.ToVector4(), MyGuiConstants.LABEL_TEXT_SCALE * 0.7f,
MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_TOP);
Controls.Add(label);
m_currentPosition = -m_size.Value / 2.0f + new Vector2(0.02f, 0.10f);
MyPostProcessVolumetricSSAO2 volumetricSsaoPP = MyRender.GetPostProcess(MyPostProcessEnum.VolumetricSSAO2) as MyPostProcessVolumetricSSAO2;
if (volumetricSsaoPP == null)
{
label = new MyGuiControlLabel(this, new Vector2(0.01f, -m_size.Value.Y / 2.0f + 0.1f), null, new System.Text.StringBuilder("Sorry SSAO post process is not available"), Color.Red.ToVector4(), MyGuiConstants.LABEL_TEXT_SCALE * 0.7f,
MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_TOP);
Controls.Add(label);
return;
}
MyEffectVolumetricSSAO2 volumetricSsaoEffect = MyRender.GetEffect(MyEffects.VolumetricSSAO) as MyEffectVolumetricSSAO2;
AddCheckBox(new StringBuilder("Use SSAO"), volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.Enabled));
AddCheckBox(new StringBuilder("Use blur"), volumetricSsaoEffect, MemberHelper.GetMember(() => volumetricSsaoEffect.UseBlur));
AddCheckBox(new StringBuilder("Show only SSAO"), volumetricSsaoEffect, MemberHelper.GetMember(() => volumetricSsaoEffect.ShowOnlySSAO));
m_currentPosition.Y += 0.01f;
// AddSlider(new StringBuilder("Offset"), 0, 10, volumetricSsaoEffect, MemberHelper.GetMember(() => volumetricSsaoEffect.Offset));
// AddSlider(new StringBuilder("SiluetteDist"), 0, 10, volumetricSsaoEffect, MemberHelper.GetMember(() => volumetricSsaoEffect.SiluetteDist));
// AddSlider(new StringBuilder("R"), 0, 10, volumetricSsaoEffect, MemberHelper.GetMember(() => volumetricSsaoEffect.R));
AddSlider(new StringBuilder("MinRadius"), 0, 10, volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.MinRadius));
AddSlider(new StringBuilder("MaxRadius"), 0, 1000, volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.MaxRadius));
AddSlider(new StringBuilder("RadiusGrowZScale"), 0, 10, volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.RadiusGrowZScale));
AddSlider(new StringBuilder("CameraZFar"), 0, 100000, volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.CameraZFar));
AddSlider(new StringBuilder("Bias"), 0, 10, volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.Bias));
AddSlider(new StringBuilder("Falloff"), 0, 10, volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.Falloff));
AddSlider(new StringBuilder("NormValue"), 0, 10, volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.NormValue));
//AddSlider(new StringBuilder("ColorScale"), 0, 10, volumetricSsaoEffect, MemberHelper.GetMember(() => volumetricSsaoEffect.ColorScale));
AddSlider(new StringBuilder("Contrast"), 0, 10, volumetricSsaoPP, MemberHelper.GetMember(() => volumetricSsaoPP.Contrast));
m_currentPosition.Y += 0.01f;
}
/// <summary>
/// Load graphics resources content.
/// </summary>
public override void LoadContent()
{
int block1 = -1;
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("MyMinerGame::LoadContent", ref block1);
base.LoadContent();
DefaultSurface = MyMinerGame.Static.GraphicsDevice.GetRenderTarget(0);
DefaultSurface.DebugName = "DefaultSurface";
DefaultDepth = MyMinerGame.Static.GraphicsDevice.DepthStencilSurface;
DefaultDepth.DebugName = "DefaultDepth";
MyMwcLog.WriteLine("MyMinerGame.LoadContent() - START");
MyMwcLog.IncreaseIndent();
MyVideoModeManager.UpdateScreenSize();
System.Drawing.Font systemfont = new System.Drawing.Font("Tahoma", 12f, FontStyle.Regular);
m_debugFont = new SharpDX.Direct3D9.Font(GraphicsDevice, systemfont);
// GUI
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("MyGuiManager.LoadContent()");
MyGuiManager.LoadContent();
// Models
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyModels.LoadContent()");
MyModels.LoadContent();
// Render
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyRender.LoadContent();");
MyRender.LoadContent();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyDebugDraw.LoadContent();");
MyDebugDraw.LoadContent();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MyDebugDrawCachedLines.LoadContent()");
MyDebugDrawCachedLines.LoadContent();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("MySunGlare.LoadContent()");
MySunGlare.LoadContent();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();
MyMwcLog.DecreaseIndent();
MyMwcLog.WriteLine("MyMinerGame.LoadContent() - END");
GC.Collect();
MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock(block1);
}
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);
* }
* } */
}
/// <summary>
/// Only to be called with FastOcclusionBoundingBoxDraw
/// </summary>
public static void PrepareFastOcclusionBoundingBoxDraw()
{
MyEffectOcclusionQueryDraw effectOQ = MyRender.GetEffect(MyEffects.OcclusionQueryDrawMRT) as MyEffectOcclusionQueryDraw;
effectOQ.SetTechnique(MyEffectOcclusionQueryDraw.Technique.DepthTestEnabled);
effectOQ.SetViewMatrix(MyCamera.ViewMatrixAtZero);
effectOQ.SetProjectionMatrix(MyCamera.ProjectionMatrix);
if (!MyRenderConstants.RenderQualityProfile.ForwardRender)
{
var depthRenderTarget = MyRender.GetRenderTarget(MyRenderTargets.Depth);
effectOQ.SetDepthRT(depthRenderTarget);
effectOQ.SetScale(MyRender.GetScaleForViewport(depthRenderTarget));
}
}
public override void RecreateControls(bool contructor)
{
Controls.Clear();
AddCaption(new System.Text.StringBuilder("Render modules"), Color.Yellow.ToVector4());
MyGuiControlLabel label = new MyGuiControlLabel(this, new Vector2(0.01f, -m_size.Value.Y / 2.0f + 0.07f), null, new System.Text.StringBuilder("(press ALT to share focus)"), Color.Yellow.ToVector4(), MyGuiConstants.LABEL_TEXT_SCALE * 0.7f,
MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_TOP);
Controls.Add(label);
m_scale = 0.7f;
m_currentPosition = -m_size.Value / 2.0f + new Vector2(0.02f, 0.10f);
m_currentPosition.Y += 0.01f;
AddLabel(new StringBuilder("Prepare for draw"), Color.Yellow.ToVector4(), 1.2f);
foreach (MyRender.MyRenderModuleItem renderModule in MyRender.GetRenderModules(MyRenderStage.PrepareForDraw))
{
AddCheckBox(new StringBuilder(renderModule.DisplayName), renderModule, MemberHelper.GetMember(() => renderModule.Enabled));
}
AddLabel(new StringBuilder("Background"), Color.Yellow.ToVector4(), 1.2f);
foreach (MyRender.MyRenderModuleItem renderModule in MyRender.GetRenderModules(MyRenderStage.Background))
{
AddCheckBox(new StringBuilder(renderModule.DisplayName), renderModule, MemberHelper.GetMember(() => renderModule.Enabled));
}
AddLabel(new StringBuilder("Pre-HDR Alpha blend"), Color.Yellow.ToVector4(), 1.2f);
foreach (MyRender.MyRenderModuleItem renderModule in MyRender.GetRenderModules(MyRenderStage.AlphaBlendPreHDR))
{
AddCheckBox(new StringBuilder(renderModule.DisplayName), renderModule, MemberHelper.GetMember(() => renderModule.Enabled));
}
AddLabel(new StringBuilder("Alpha blend"), Color.Yellow.ToVector4(), 1.2f);
foreach (MyRender.MyRenderModuleItem renderModule in MyRender.GetRenderModules(MyRenderStage.AlphaBlend))
{
AddCheckBox(new StringBuilder(renderModule.DisplayName), renderModule, MemberHelper.GetMember(() => renderModule.Enabled));
}
AddLabel(new StringBuilder("Debug draw"), Color.Yellow.ToVector4(), 1.2f);
foreach (MyRender.MyRenderModuleItem renderModule in MyRender.GetRenderModules(MyRenderStage.DebugDraw))
{
AddCheckBox(new StringBuilder(renderModule.DisplayName), renderModule, MemberHelper.GetMember(() => renderModule.Enabled));
}
}
public static void Draw()
{
if (MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD0)
{
MyStateObjects.DepthStencil_TestFarObject_DepthReadOnly.Apply();
MyStateObjects.Dynamic_Decals_BlendState.Apply();
MyStateObjects.BiasedRasterizer_Decals.Apply();
Effects.MyEffectDecals effect = (Effects.MyEffectDecals)MyRender.GetEffect(MyEffects.Decals);
// Draw voxel decals
m_decalsForVoxels.Draw(m_vertices, effect, m_texturesDiffuse, m_texturesNormalMap);
// Draw model decals
m_decalsForModels.Draw(m_vertices, effect, m_texturesDiffuse, m_texturesNormalMap);
}
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = MyRender.GetEffect(MyEffects.VoxelsMRT) as MyEffectVoxels;
SetupBaseEffect(shader, setup, lodType);
if (lodType == MyLodTypeEnum.LOD_BACKGROUND)
{
shader.ApplyMultimaterialFar();
}
else
{
shader.ApplyMultimaterial();
}
shader.Begin(0, SharpDX.Direct3D9.FX.None);
m_currentLod = lodType;
return shader;
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = MyRender.GetEffect(MyEffects.VoxelsMRT) as MyEffectVoxels;
SetupBaseEffect(shader, setup, lodType);
if (lodType == MyLodTypeEnum.LOD_BACKGROUND)
{
shader.ApplyFar(MyRenderConstants.RenderQualityProfile.VoxelsRenderTechnique);
}
else
{
shader.Apply();
}
m_currentLod = lodType;
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return shader;
}
protected void RenderShadowMap(Matrix lightViewProjection)
{
// Set up the effect
MyEffectShadowMap shadowMapEffect = MyRender.GetEffect(MyEffects.ShadowMap) as MinerWars.AppCode.Game.Effects.MyEffectShadowMap;
shadowMapEffect.SetViewProjMatrix(lightViewProjection);
/*
* m_culledElements.Clear();
* foreach (MyRender.MyRenderElement element in m_renderElementsForShadows)
* {
* m_culledElements.Add(element);
* }
*/
// Draw the models
DrawElements(m_renderElementsForShadows, shadowMapEffect, false, MyPerformanceCounter.NoSplit);
}
public void RenderForLight(Matrix lightViewProjection, ref BoundingBox lightBoundingBox, Texture shadowRenderTarget, Texture shadowDepth, int spotIndex)
{
m_renderElementsForShadows.Clear();
m_castingRenderObjectsUnique.Clear();
m_spotFrustum.Matrix = lightViewProjection;
//MyRender.GetEntitiesFromPrunningStructure(ref lightBoundingBox, m_castingRenderObjects);
MyRender.GetEntitiesFromShadowStructure(ref lightBoundingBox, m_castingRenderObjects);
foreach (MyElement element in m_castingRenderObjects)
{
MyRenderObject renderObject = (MyRenderObject)element;
MyEntity entity = ((MyRenderObject)element).Entity;
if (entity != null)
{
if (entity is MyVoxelMap)
{
// Changed m_castersBox to lightBoundingBox, should work
//(entity as MyVoxelMap).GetRenderElementsForShadowmap(m_renderElementsForShadows, ref lightBoundingBox, m_spotFrustum, MyLodTypeEnum.LOD0, false);
(entity as MyVoxelMap).GetRenderElementsForShadowmap(m_renderElementsForShadows, renderObject.RenderCellCoord.Value, MyLodTypeEnum.LOD0, false);
}
else
{
if (entity.ModelLod0 != null)
{
MyRender.CollectRenderElementsForShadowmap(m_renderElementsForShadows, m_transparentRenderElementsForShadows, entity, entity.ModelLod0);
}
}
}
}
// Set our targets
MyMinerGame.SetRenderTarget(shadowRenderTarget, shadowDepth);
MyMinerGame.Static.GraphicsDevice.Clear(ClearFlags.All, new ColorBGRA(1.0f), 1.0f, 0);
DepthStencilState.Default.Apply();
RasterizerState.CullNone.Apply();
BlendState.Opaque.Apply();
RenderShadowMap(lightViewProjection);
MyRender.TakeScreenshot("ShadowMapSpot", shadowRenderTarget, MyEffectScreenshot.ScreenshotTechniqueEnum.Color);
}
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 MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = MyRender.GetEffect(MyEffects.VoxelsMRT) as MyEffectVoxels;
SetupBaseEffect(shader, setup, lodType);
if (lodType == MyLodTypeEnum.LOD_BACKGROUND)
{
shader.ApplyMultimaterialFar(MyRenderConstants.RenderQualityProfile.VoxelsRenderTechnique);
}
else
{
shader.ApplyMultimaterial();
}
shader.Begin(0, SharpDX.Direct3D9.FX.None);
m_currentLod = lodType;
return(shader);
}
private void DisableContainedDummyParticles(ref MyExplosionInfo explosionInfo)
{
BoundingBox aabb = BoundingBox.CreateFromSphere(explosionInfo.ExplosionSphere);
MyRender.GetEntitiesFromPrunningStructure(ref aabb, m_destroyHelper);
foreach (var elem in m_destroyHelper)
{
var entity = ((MyRenderObject)elem).Entity;
var dummyPoint = entity as MyDummyPoint;
if (dummyPoint != null && !dummyPoint.CanSurvivePrefabDestruction())
{
var position = dummyPoint.GetPosition();
dummyPoint.DisableParticleEffect();
}
}
}
public override MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType)
{
var shader = MyRender.GetEffect(MyEffects.VoxelsMRT) as MyEffectVoxels;
SetupBaseEffect(shader, setup, lodType);
if (lodType == MyLodTypeEnum.LOD_BACKGROUND)
{
shader.ApplyFar();
}
else
{
shader.Apply();
}
m_currentLod = lodType;
shader.Begin(0, SharpDX.Direct3D9.FX.None);
return(shader);
}
/// <summary>
/// Draw occlusion bounding box method with our premade effect and box.
/// </summary>
/// <param name="bbox"></param>
/// <param name="scale"></param>
/// <param name="enableDepthTesting"></param>
/// <param name="billboardLike">Indicates whether the occlusion object (box) is rotated to face the camera or not.</param>
public static void DrawOcclusionBoundingBox(BoundingBox bbox, float scale, bool enableDepthTesting, bool billboardLike = false, bool useDepthTarget = true)
{
useDepthTarget &= !MyRenderConstants.RenderQualityProfile.ForwardRender;
var cameraToBBox = bbox.GetCenter() - MyCamera.Position;
Matrix worldMatrix = billboardLike ? Matrix.CreateWorld(Vector3.Zero, MyMwcUtils.Normalize(cameraToBBox), MyMwcUtils.Normalize(MyCamera.UpVector + MyCamera.LeftVector)) : Matrix.Identity;
Vector3 scaleV = (bbox.Max - bbox.Min) * scale;
worldMatrix *= Matrix.CreateScale(scaleV);
worldMatrix.Translation = cameraToBBox;
MyEffectOcclusionQueryDraw effectOQ = MyRender.GetEffect(MyEffects.OcclusionQueryDrawMRT) as MyEffectOcclusionQueryDraw;
if (enableDepthTesting && !MyRenderConstants.RenderQualityProfile.ForwardRender)
{
effectOQ.SetTechnique(MyEffectOcclusionQueryDraw.Technique.DepthTestEnabled);
}
else
{
effectOQ.SetTechnique(MyEffectOcclusionQueryDraw.Technique.DepthTestDisabled);
}
effectOQ.SetWorldMatrix(worldMatrix);
effectOQ.SetViewMatrix(MyCamera.ViewMatrixAtZero);
effectOQ.SetProjectionMatrix(MyCamera.ProjectionMatrix);
if (useDepthTarget)
{
var depthRenderTarget = MyRender.GetRenderTarget(MyRenderTargets.Depth);
effectOQ.SetDepthRT(depthRenderTarget);
effectOQ.SetScale(MyRender.GetScaleForViewport(depthRenderTarget));
}
effectOQ.Begin();
//draw
m_modelBoxLowRes.Render();
effectOQ.End();
}
//////////////////////////////////////////////////////////////////////////
private MyPrefabContainerManager()
{
short modifier = (short)MyShortcut.ModifierValue.Control + (short)MyShortcut.ModifierValue.Shift;
string category = "MyPrefabContainerManager";
//@ debug draw Container
MyShortcut shortcut = new MyShortcut(Keys.P, modifier);
MyDebugConsole.GetInstance().RegisterShortcut(MyDebugSystem.Editor, category, "Debug draw container", shortcut, OnToggleDebugDraw);
//@ invalidate nodes
shortcut = new MyShortcut(Keys.L, modifier);
MyDebugConsole.GetInstance().RegisterShortcut(MyDebugSystem.Editor, category, "ShowPhysicsAABBUnderCursor", shortcut, OnShowPhysAABB);
MyRender.RegisterRenderModule(MyRenderModuleEnum.PrefabContainerManager, "Prefab container manager", DebugDraw, MyRenderStage.DebugDraw);
//@ check res if duplicity registration
}
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 abstract void SetupEntity(MyEffectBase shader, MyRender.MyRenderElement renderElement);
/// <summary> /// Caller is responsible to call End when done with shader. /// </summary> public abstract MyEffectBase PrepareAndBeginShader(MyRender.MyRenderSetup setup, MyLodTypeEnum lodType);
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);
}
