internal override void Cleanup()
{
base.Cleanup();
Dsv = null;
DefaultRasterizer = null;
}
public void SetRasterizer(IRasterizerState rasterizerState)
{
graphicsDevice.Cast <RasterizerState>(rasterizerState, "rasterizerState"); // State überprüfen
currentState.Rasterizer = rasterizerState;
stateDirty = true;
}
internal override void Cleanup()
{
base.Cleanup();
Dsv = null;
DefaultRasterizer = null;
IsCascade = false;
}
public void SetRasterizerState(IRasterizerState rasterizerState)
{
var command = new D3D11Command
{
Type = CommandType.SetRasterizerState,
RasterizerState = (D3D11RasterizerState)rasterizerState
};
_commandList.Add(command);
}
internal void SetRasterizerState(IRasterizerState rs)
{
RasterizerState dxstate = null;
if (rs != null)
{
IRasterizerStateInternal rsInternal = (IRasterizerStateInternal)rs;
dxstate = rsInternal.Resource;
}
m_state.SetRasterizerState(dxstate);
CheckErrors();
}
public void InitStandard(string cmFilepath, string ngFilepath, string extFilepath)
{
m_srvs = new ISrvBindable[]
{
MyManagers.FileTextures.GetTexture(cmFilepath, MyFileTextureEnum.COLOR_METAL),
MyManagers.FileTextures.GetTexture(ngFilepath, MyFileTextureEnum.NORMALMAP_GLOSS),
MyManagers.FileTextures.GetTexture(extFilepath, MyFileTextureEnum.EXTENSIONS)
};
m_depthStencilState = MyDepthStencilStateManager.DefaultDepthState;
m_blendState = null;
m_rasterizerState = null;
m_isFaceCullingEnabled = true;
}
public D3D11Pipeline(Shader vertexShader, Shader pixelShader, IInputLayout inputLayout,
IBlendState blendState, IDepthStencilState depthStencilState, IRasterizerState rasterizerState,
Viewport viewport, PrimitiveTopology primitiveTopology)
{
VertexShader = vertexShader;
PixelShader = pixelShader;
InputLayout = inputLayout;
BlendState = blendState;
DepthStencilState = depthStencilState;
RasterizerState = rasterizerState;
Viewport = viewport;
PrimitiveTopology = primitiveTopology;
}
public static IRasterizerState New(VideoTypes videoType, IDisposableResource parent, IRasterizerStateDesc desc)
{
IRasterizerState api = null;
#if WIN32
if (videoType == VideoTypes.D3D9)
{
api = new D3D9.RasterizerState(parent, desc);
}
#endif
#if WIN32 || WINRT || WP8
if (videoType == VideoTypes.D3D11)
{
api = new D3D11.RasterizerState(parent, desc);
}
#endif
#if WIN32 || OSX || LINUX || iOS || ANDROID || NaCl
if (videoType == VideoTypes.OpenGL)
{
api = new OpenGL.RasterizerState(parent, desc);
}
#endif
#if XNA
if (videoType == VideoTypes.XNA)
{
api = new XNA.RasterizerState(parent, desc);
}
#endif
#if VITA
if (videoType == VideoTypes.Vita)
{
api = new Vita.RasterizerState(parent, desc);
}
#endif
if (api == null)
{
Debug.ThrowError("RasterizerStateAPI", "Unsuported InputType: " + videoType);
}
return(api);
}
public GBufferShader(Engine engine) : base(engine, @"Rendering\Passes\Shaders\gbuffer")
{
sampler = engine.GraphicsDevice.Factory.CreateSampler(new SamplerInfo(TextureFilter.Linear));
constantBuffer = shader.CreateConstantBuffer(ResourceUsage.Dynamic);
rasterizerState = engine.GraphicsDevice.Factory.CreateRasterizerState(new RasterizerStateInfo()
{
CullMode = CullMode.None,
FillMode = FillMode.Solid,
IsFrontCounterClockwise = false,
});
depthStencil = engine.GraphicsDevice.Factory.CreateDepthStencilState(new DepthStencilStateInfo()
{
IsDepthEnabled = true,
DepthComparsion = Comparison.LessEqual,
DepthWriteMask = DepthWriteMask.All
});
}
public void InitDecal(string cmFilepath, string ngFilepath, string extFilepath, string alphamaskFilepath, bool isPremultipliedAlpha, bool isCutout)
{
m_srvs = new ISrvBindable[]
{
MyManagers.FileTextures.GetTexture(cmFilepath, MyFileTextureEnum.COLOR_METAL),
MyManagers.FileTextures.GetTexture(ngFilepath, MyFileTextureEnum.NORMALMAP_GLOSS),
MyManagers.FileTextures.GetTexture(extFilepath, MyFileTextureEnum.EXTENSIONS),
MyManagers.FileTextures.GetTexture(alphamaskFilepath, MyFileTextureEnum.ALPHAMASK)
};
m_depthStencilState = MyDepthStencilStateManager.DepthTestReadOnly;
if (isCutout)
{
m_blendState = null;
}
else
{
m_blendState = GetAlphamaskBlendState(cmFilepath, ngFilepath, extFilepath, isPremultipliedAlpha);
}
m_rasterizerState = MyRasterizerStateManager.DecalRasterizerState;
m_isFaceCullingEnabled = true;
}
protected override void Initialize()
{
base.Initialize();
Window.Title = "Xacor.Demo";
_viewMatrix = Matrix.LookAtRH(new Vector3(0, 0, 10f), Vector3.Zero, Vector3.UnitY);
_projectionMatrix = Matrix.PerspectiveFovRH(MathF.PI / 3.0f, _renderResolution.Width / (float)_renderResolution.Height, 0.1f, 4096f);
_leftMvp = new InputBuffer
{
ModelViewProjectionMatrix = Matrix.Translation(-1.5f, 1, -0.5f) * _viewMatrix * _projectionMatrix
};
_rightMvp = new InputBuffer
{
ModelViewProjectionMatrix = Matrix.Translation(1.5f, -1, 0.5f) * _viewMatrix * _projectionMatrix
};
_viewport = new Viewport(0, 0, _renderResolution.Width, _renderResolution.Height, 0.1f, 4096f);
_defaultBlendState = GraphicsFactory.CreateBlendState(true, Blend.SourceAlpha, Blend.InverseSourceAlpha, BlendOperation.Add, Blend.One, Blend.Zero, BlendOperation.Add);
_defaultDepthStencilState = GraphicsFactory.CreateDepthStencilState();
_defaultRasterizerState = GraphicsFactory.CreateRasterizerState(CullMode.None, FillMode.Solid, true, false, false, false);
var macros = new[] { ("TEST", "0") };
public IPipeline CreatePipeline(Shader vertexShader, Shader pixelShader, IInputLayout inputLayout, IBlendState blendState,
IDepthStencilState depthStencilState, IRasterizerState rasterizerState, Viewport viewport,
PrimitiveTopology primitiveTopology)
{
throw new System.NotImplementedException();
}
public IPipeline CreatePipeline(Shader vertexShader, Shader pixelShader, IInputLayout inputLayout,
IBlendState blendState, IDepthStencilState depthStencilState, IRasterizerState rasterizerState,
Viewport viewport, PrimitiveTopology primitiveTopology)
{
return(new D3D11Pipeline(vertexShader, pixelShader, inputLayout, blendState, depthStencilState, rasterizerState, viewport, primitiveTopology));
}
internal void Apply(IRasterizerState compareTo)
{
if (compareTo != null)
{
if (compareTo.Info.FillMode != Info.FillMode)
{
GL.PolygonMode(MaterialFace.FrontAndBack, EnumConverter.Convert(Info.FillMode));
}
if (compareTo.Info.CullMode != Info.CullMode)
{
if (Info.CullMode != CullMode.None)
{
GL.Enable(EnableCap.CullFace);
GL.CullFace(EnumConverter.Convert(Info.CullMode));
}
else
{
GL.Disable(EnableCap.CullFace);
}
}
if (compareTo.Info.IsFrontCounterClockwise != Info.IsFrontCounterClockwise)
{
GL.FrontFace(Info.IsFrontCounterClockwise ? FrontFaceDirection.Ccw : FrontFaceDirection.Cw);
}
if (compareTo.Info.IsMultisampleEnabled != Info.IsMultisampleEnabled)
{
if (Info.IsMultisampleEnabled)
{
GL.Enable(EnableCap.Multisample);
GL.Enable(EnableCap.PolygonSmooth);
}
else
{
GL.Disable(EnableCap.Multisample);
GL.Disable(EnableCap.PolygonSmooth);
}
}
if (compareTo.Info.IsScissorEnabled != Info.IsScissorEnabled)
{
if (Info.IsScissorEnabled)
{
GL.Enable(EnableCap.ScissorTest);
}
else
{
GL.Disable(EnableCap.ScissorTest);
}
}
if (compareTo.Info.IsAntialiasedLineEnabled != Info.IsAntialiasedLineEnabled)
{
if (Info.IsAntialiasedLineEnabled)
{
GL.Enable(EnableCap.LineSmooth);
}
else
{
GL.Disable(EnableCap.LineSmooth);
}
}
if (compareTo.Info.DepthBias != Info.DepthBias || compareTo.Info.SlopeScaledDepthBias != Info.SlopeScaledDepthBias)
{
GL.PolygonMode(MaterialFace.FrontAndBack, EnumConverter.Convert(Info.FillMode));
GL.PolygonOffset(Info.DepthBias, Info.SlopeScaledDepthBias);
}
}
else
{
//Nothing to compare to
//Set all states
GL.PolygonMode(MaterialFace.FrontAndBack, EnumConverter.Convert(Info.FillMode));
if (Info.CullMode != CullMode.None)
{
GL.Enable(EnableCap.CullFace);
GL.CullFace(EnumConverter.Convert(Info.CullMode));
}
else
{
GL.Disable(EnableCap.CullFace);
}
GL.FrontFace(Info.IsFrontCounterClockwise ? FrontFaceDirection.Ccw : FrontFaceDirection.Cw);
if (Info.IsMultisampleEnabled)
{
GL.Enable(EnableCap.Multisample);
GL.Enable(EnableCap.PolygonSmooth);
}
else
{
GL.Disable(EnableCap.Multisample);
GL.Disable(EnableCap.PolygonSmooth);
}
if (Info.IsScissorEnabled)
{
GL.Enable(EnableCap.ScissorTest);
}
else
{
GL.Disable(EnableCap.ScissorTest);
}
if (Info.IsAntialiasedLineEnabled)
{
GL.Enable(EnableCap.LineSmooth);
}
else
{
GL.Disable(EnableCap.LineSmooth);
}
GL.PolygonMode(MaterialFace.FrontAndBack, EnumConverter.Convert(Info.FillMode));
GL.PolygonOffset(Info.DepthBias, Info.SlopeScaledDepthBias);
}
}
public MyRasterizerStateManager()
{
RasterizerStateDescription desc = new RasterizerStateDescription();
desc.FillMode = FillMode.Wireframe;
desc.CullMode = CullMode.Back;
MyRasterizerStateManager.WireframeRasterizerState = CreateResource("WireframeRasterizerState", ref desc);
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.Front;
MyRasterizerStateManager.InvTriRasterizerState = CreateResource("InvTriRasterizerState", ref desc);
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.None;
MyRasterizerStateManager.NocullRasterizerState = CreateResource("NocullRasterizerState", ref desc);
desc.FillMode = FillMode.Wireframe;
desc.CullMode = CullMode.None;
MyRasterizerStateManager.NocullWireframeRasterizerState = CreateResource("NocullWireframeRasterizerState", ref desc);
desc = new RasterizerStateDescription();
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.Back;
MyRasterizerStateManager.LinesRasterizerState = CreateResource("LinesRasterizerState", ref desc);
desc = new RasterizerStateDescription();
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.Back;
desc.DepthBias = 25000;
desc.DepthBiasClamp = 2;
desc.SlopeScaledDepthBias = 0;
MyRasterizerStateManager.DecalRasterizerState = CreateResource("DecalRasterizerState", ref desc);
desc = new RasterizerStateDescription();
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.None;
desc.DepthBias = 25000;
desc.DepthBiasClamp = 2;
desc.SlopeScaledDepthBias = 0;
MyRasterizerStateManager.NocullDecalRasterizerState = CreateResource("NocullDecalRasterizerState", ref desc);
desc = new RasterizerStateDescription();
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.None;
desc.IsFrontCounterClockwise = true;
desc.DepthBias = 0;
desc.DepthBiasClamp = 0;
desc.SlopeScaledDepthBias = 0;
MyRasterizerStateManager.CascadesRasterizerState = CreateResource("CascadesRasterizerState", ref desc);
desc = new RasterizerStateDescription();
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.None;
desc.IsFrontCounterClockwise = true;
desc.DepthBias = 20;
desc.DepthBiasClamp = 2;
desc.SlopeScaledDepthBias = 4;
MyRasterizerStateManager.CascadesRasterizerStateOld = CreateResource("CascadesRasterizerStateOld", ref desc);
desc = new RasterizerStateDescription();
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.None;
desc.IsFrontCounterClockwise = true;
desc.DepthBias = 2500;
desc.DepthBiasClamp = 10000;
desc.SlopeScaledDepthBias = 4;
MyRasterizerStateManager.ShadowRasterizerState = CreateResource("ShadowRasterizerState", ref desc);
desc.FillMode = FillMode.Solid;
desc.CullMode = CullMode.Back;
desc.IsFrontCounterClockwise = false;
desc.IsScissorEnabled = true;
MyRasterizerStateManager.ScissorTestRasterizerState = CreateResource("ScissorTestRasterizerState", ref desc);
}
public Stars(IDevice device, int starCount)
{
this.starCount = starCount;
shaders = CreateShaders(device);
timeUbuffer = CreateTimeUbuffer(device);
vertexLayout = CreateVertexLayout(device, shaders.VertexShader);
vertexBuffer = CreateVertexBuffer(device, starCount);
indexBuffer = CreateIndexBuffer(device, starCount);
rasterizerState = CreateRasterizerState(device);
depthStencilState = CreateDepthStencilState(device);
blendState = CreateBlendState(device);
}
public void SetRasterizerState(IRasterizerState rasterizerState)
{
throw new NotImplementedException();
}
internal override void Cleanup()
{
base.Cleanup();
Dsv = null;
DefaultRasterizer = null;
}
/// <summary>
/// OpenGL States auf DirectX11 default Werte setzen
/// </summary>
private void CreateDefaultState()
{
IBlendState defaultBlend = graphicsDevice.Factory.CreateBlendState(new BlendStateInfo()
{
AlphaToCoverageEnable = false,
IndependentBlendEnable = false,
RenderTargets = new RTBlendInfo[] {
new RTBlendInfo()
{
IsBlendEnabled = false,
SrcBlend = Blend.One,
DestBlend = Blend.Zero,
BlendOp = Graphics.BlendOp.Add,
SrcBlendAlpha = Blend.One,
DestBlendAlpha = Blend.Zero,
BlendOpAlpha = BlendOp.Add,
RenderTargetWriteMask = ColorWriteMaskFlags.All,
}
},
});
IRasterizerState defaultRasterizer = graphicsDevice.Factory.CreateRasterizerState(new RasterizerStateInfo()
{
FillMode = FillMode.Solid,
CullMode = CullMode.None,
IsFrontCounterClockwise = false,
DepthBias = 0,
SlopeScaledDepthBias = 0.0f,
DepthBiasClamp = 0.0f,
IsDepthClipEnabled = true,
IsScissorEnabled = true,
IsMultisampleEnabled = false,
IsAntialiasedLineEnabled = false,
});
IDepthStencilState defaultDepthStencil = graphicsDevice.Factory.CreateDepthStencilState(new DepthStencilStateInfo()
{
IsDepthEnabled = true,
DepthWriteMask = DepthWriteMask.All,
DepthComparsion = Comparison.Less,
IsStencilEnabled = false,
StencilReadMask = 0x0,
StencilWriteMask = 0x0,
FrontFace = new DepthStencilOperator()
{
Comparsion = Comparison.Always,
DepthFailOperation = StencilOperation.Keep,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
},
BackFace = new DepthStencilOperator()
{
Comparsion = Comparison.Always,
DepthFailOperation = StencilOperation.Keep,
PassOperation = StencilOperation.Keep,
FailOperation = StencilOperation.Keep,
},
});
graphicsDevice.Cast <BlendState>(defaultBlend, "defaultBlend").Apply();
graphicsDevice.Cast <RasterizerState>(defaultRasterizer, "defaultRasterizer").Apply();
graphicsDevice.Cast <DepthStencilState>(defaultDepthStencil, "depthStencil").Apply(currentStencilReference);
}
internal override void Cleanup()
{
base.Cleanup();
Dsv = null;
DefaultRasterizer = null;
IsCascade = false;
}
