/// <summary>
/// <see cref="IEffectMaterialVariables.BindMaterialTextures(DeviceContext, IShaderPass)"/>
/// </summary>
/// <param name="context"></param>
/// <param name="shaderPass"></param>
/// <returns></returns>
public bool BindMaterialTextures(DeviceContext context, IShaderPass shaderPass)
{
if (material == null)
{
return(false);
}
UpdateMappings(shaderPass);
if (HasTextures)
{
for (int i = 0; i < shaderPass.Shaders.Count; ++i)
{
var shader = shaderPass.Shaders[i];
if (shader.IsNULL || !EnumHelper.HasFlag(Constants.CanBindTextureStages, shader.ShaderType))
{
continue;
}
OnBindMaterialTextures(context, shader);
}
}
if (RenderShadowMap)
{
shaderPass.GetShader(ShaderStage.Pixel).BindSampler(context, SamplerBindingMap[ShaderStage.Pixel.ToIndex()][NUMSAMPLERS - 1], SamplerResources[NUMSAMPLERS - 1]);
}
return(true);
}
/// <summary>
/// Called when [attach].
/// </summary>
/// <param name="technique">The technique.</param>
/// <returns></returns>
protected override bool OnAttach(IRenderTechnique technique)
{
if (base.OnAttach(technique))
{
VertexLayout = technique.Layout;
updatePass = technique[DefaultParticlePassNames.Update];
insertPass = technique[DefaultParticlePassNames.Insert];
renderPass = technique[DefaultParticlePassNames.Default];
#region Get binding slots
currentStateSlot = updatePass.GetShader(ShaderStage.Compute).UnorderedAccessViewMapping.TryGetBindSlot(CurrentSimStateUAVBufferName);
newStateSlot = updatePass.GetShader(ShaderStage.Compute).UnorderedAccessViewMapping.TryGetBindSlot(NewSimStateUAVBufferName);
renderStateSlot = renderPass.GetShader(ShaderStage.Vertex).ShaderResourceViewMapping.TryGetBindSlot(SimStateBufferName);
textureSlot = renderPass.GetShader(ShaderStage.Pixel).ShaderResourceViewMapping.TryGetBindSlot(ShaderTextureBufferName);
samplerSlot = renderPass.GetShader(ShaderStage.Pixel).SamplerMapping.TryGetBindSlot(ShaderTextureSamplerName);
#endregion
perFrameCB = technique.ConstantBufferPool.Register(DefaultBufferNames.ParticleFrameCB, ParticlePerFrame.SizeInBytes);
insertCB = technique.ConstantBufferPool.Register(DefaultBufferNames.ParticleCreateParameters, ParticleInsertParameters.SizeInBytes);
isBlendChanged = true;
if (isInitialParticleChanged)
{
OnInitialParticleChanged(ParticleCount);
}
textureSampler = Collect(technique.EffectsManager.StateManager.Register(SamplerDescription));
return(true);
}
else
{
return(false);
}
}
private void UpdateMappings(IShaderPass shaderPass)
{
if (currentPass == shaderPass)
{
return;
}
currentPass = shaderPass;
for (int i = 0; i < shaderPass.Shaders.Count; ++i)
{
var shader = shaderPass.Shaders[i];
if (shader.IsNULL || !EnumHelper.HasFlag(Constants.CanBindTextureStages, shader.ShaderType))
{
continue;
}
int idx = shaderPass.Shaders[i].ShaderType.ToIndex();
TextureBindingMap[idx][DiffuseIdx] = shader.ShaderResourceViewMapping.TryGetBindSlot(ShaderDiffuseTexName);
TextureBindingMap[idx][AlphaIdx] = shader.ShaderResourceViewMapping.TryGetBindSlot(ShaderAlphaTexName);
TextureBindingMap[idx][NormalIdx] = shader.ShaderResourceViewMapping.TryGetBindSlot(ShaderNormalTexName);
TextureBindingMap[idx][DisplaceIdx] = shader.ShaderResourceViewMapping.TryGetBindSlot(ShaderDisplaceTexName);
SamplerBindingMap[idx][DiffuseIdx] = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerDiffuseTexName);
SamplerBindingMap[idx][AlphaIdx] = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerAlphaTexName);
SamplerBindingMap[idx][NormalIdx] = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerNormalTexName);
SamplerBindingMap[idx][DisplaceIdx] = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerDisplaceTexName);
SamplerBindingMap[idx][ShadowIdx] = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerShadowMapName);
}
}
/// <summary>
///
/// </summary>
/// <param name="disposeManagedResources"></param>
protected override void OnDispose(bool disposeManagedResources)
{
this.Material = null;
TextureResources = null;
SamplerResources = null;
TextureBindingMap = null;
SamplerBindingMap = null;
OnInvalidateRenderer = null;
currentPass = null;
base.OnDispose(disposeManagedResources);
}
/// <summary>
/// Initializes a new instance of the <see cref="PostEffectMeshOutlineBlurCore"/> class.
/// </summary>
public PostEffectBlurCore(global::SharpDX.DXGI.Format textureFormat,
IShaderPass blurVerticalPass, IShaderPass blurHorizontalPass, int textureSlot, int samplerSlot,
SamplerStateDescription sampler, IEffectsManager manager)
{
screenBlurPassVertical = blurVerticalPass;
screenBlurPassHorizontal = blurHorizontalPass;
this.textureSlot = textureSlot;
this.samplerSlot = samplerSlot;
this.sampler = Collect(manager.StateManager.Register(sampler));
texture2DDesc.Format = targetResourceViewDesc.Format = renderTargetViewDesc.Format = textureFormat;
}
/// <summary>
///
/// </summary>
/// <param name="technique"></param>
/// <returns></returns>
protected override bool OnAttach(IRenderTechnique technique)
{
if (base.OnAttach(technique))
{
DefaultShaderPass = technique[DefaultShaderPassName];
ShadowPass = technique[DefaultShadowPassName];
this.VertexLayout = technique.Layout;
CreateRasterState(rasterDescription, true);
return(true);
}
return(false);
}
protected override bool OnAttach(IRenderTechnique technique)
{
if (base.OnAttach(technique))
{
clipParamCB = technique.ConstantBufferPool.Register(GetClipParamsCBDescription());
drawBackfacePass = technique[DefaultPassNames.Backface];
drawScreenQuadPass = technique[DefaultPassNames.ScreenQuad];
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Called when [attach].
/// </summary>
/// <param name="technique">The technique.</param>
/// <returns></returns>
protected override bool OnAttach(IRenderTechnique technique)
{
if (base.OnAttach(technique))
{
DefaultShaderPass = technique.EffectsManager[DefaultRenderTechniqueNames.ScreenDuplication][DefaultPassNames.Default];
CursorShaderPass = technique.EffectsManager[DefaultRenderTechniqueNames.ScreenDuplication][DefaultPassNames.ScreenQuad];
textureBindSlot = DefaultShaderPass.GetShader(ShaderStage.Pixel).ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
samplerBindSlot = DefaultShaderPass.GetShader(ShaderStage.Pixel).SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.DiffuseMapSampler);
textureSampler = Collect(technique.EffectsManager.StateManager.Register(DefaultSamplers.ScreenDupSampler));
return(Initialize(technique.EffectsManager));
}
else
{
return(false);
}
}
protected override bool OnAttach(IRenderTechnique technique)
{
if (base.OnAttach(technique))
{
screenQuadPass = technique.GetPass(DefaultPassNames.ScreenQuad);
screenQuadCopy = technique.GetPass(DefaultPassNames.ScreenQuadCopy);
blurPassVertical = technique.GetPass(DefaultPassNames.EffectBlurVertical);
blurPassHorizontal = technique.GetPass(DefaultPassNames.EffectBlurHorizontal);
screenOutlinePass = technique.GetPass(DefaultPassNames.MeshOutline);
textureSlot = screenOutlinePass.GetShader(ShaderStage.Pixel).ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
samplerSlot = screenOutlinePass.GetShader(ShaderStage.Pixel).SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.DiffuseMapSampler);
sampler = Collect(technique.EffectsManager.StateManager.Register(DefaultSamplers.LinearSamplerClampAni4));
return(true);
}
else
{
return(false);
}
}
protected override void OnDefaultPassChanged(IShaderPass pass)
{
base.OnDefaultPassChanged(pass);
shadowMapSlot = pass.GetShader(ShaderStage.Pixel).ShaderResourceViewMapping.TryGetBindSlot(ShaderShadowMapTextureName);
}
/// <summary>
/// Called when [attach].
/// </summary>
/// <param name="technique">The technique.</param>
/// <returns></returns>
protected override bool OnAttach(IRenderTechnique technique)
{
outlineShaderPass = technique[OutlinePassName];
return(base.OnAttach(technique));
}
protected override void OnDefaultPassChanged(IShaderPass pass)
{
base.OnDefaultPassChanged(pass);
ColorTextureSlot = pass.GetShader(ShaderStage.Pixel).ShaderResourceViewMapping.TryGetBindSlot(CustomShaderNames.TexData);
ColorTextureSamplerSlot = pass.GetShader(ShaderStage.Pixel).SamplerMapping.TryGetBindSlot(CustomShaderNames.TexDataSampler);
}
/// <summary>
/// Render function for custom shader pass. Used to do special effects
/// </summary>
protected virtual void OnRenderCustom(IRenderContext context, DeviceContextProxy deviceContext, IShaderPass shaderPass)
{
}
/// <summary>
/// Called when [default pass changed].
/// </summary>
/// <param name="pass">The pass.</param>
protected override void OnDefaultPassChanged(IShaderPass pass)
{
cubeTextureSlot = pass.GetShader(ShaderStage.Pixel).ShaderResourceViewMapping.TryGetBindSlot(ShaderCubeTextureName);
textureSamplerSlot = pass.GetShader(ShaderStage.Pixel).SamplerMapping.TryGetBindSlot(ShaderCubeTextureSamplerName);
}
/// <summary>
///
/// </summary>
/// <param name="pass"></param>
protected virtual void OnDefaultPassChanged(IShaderPass pass)
{
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="shader"></param>
/// <returns></returns>
public bool BindMaterialTextures(DeviceContext context, IShaderPass shader)
{
return(MaterialVariables.BindMaterialTextures(context, shader));
}
protected override void OnRenderCustom(IRenderContext context, DeviceContextProxy deviceContext, IShaderPass shaderPass)
{
OnDraw(deviceContext, InstanceBuffer);
}
/// <summary>
///
/// </summary>
/// <param name="pass"></param>
protected virtual void OnShadowPassChanged(IShaderPass pass)
{
}
