private void UpdateSampler()
{
var newSampler = EffectTechnique.EffectsManager.StateManager.Register(samplerDescription);
RemoveAndDispose(ref sampler);
sampler = newSampler;
}
private void CreateSamplers()
{
var newSampler = material == null ? null : statePoolManager.Register(material.DiffuseMapSampler);
RemoveAndDispose(ref SamplerResource);
SamplerResource = newSampler;
}
protected override void OnDetach()
{
MipMapLevels = 0;
textureSampler = null;
cubeTextureRes = null;
base.OnDetach();
}
protected override void OnInitialPropertyBindings()
{
AddPropertyBinding(nameof(ColorStripeMaterialCore.DiffuseColor), () =>
{
WriteValue(PhongPBRMaterialStruct.DiffuseStr, material.DiffuseColor);
});
AddPropertyBinding(nameof(ColorStripeMaterialCore.ColorStripeX), () =>
{
CreateTextureView(material.ColorStripeX, 0);
WriteValue(PhongPBRMaterialStruct.HasDiffuseMapStr, material.ColorStripeXEnabled && (textureIndex & 1u) != 0 ? 1 : 0);
});
AddPropertyBinding(nameof(ColorStripeMaterialCore.ColorStripeY), () =>
{
CreateTextureView(material.ColorStripeY, 1);
WriteValue(PhongPBRMaterialStruct.HasDiffuseAlphaMapStr, material.ColorStripeYEnabled && (textureIndex & 1u << 1) != 0 ? 1 : 0);
});
AddPropertyBinding(nameof(ColorStripeMaterialCore.ColorStripeSampler), () =>
{
RemoveAndDispose(ref sampler);
sampler = Collect(statePoolManager.Register(material.ColorStripeSampler));
});
AddPropertyBinding(nameof(ColorStripeMaterialCore.ColorStripeXEnabled), () =>
{
WriteValue(PhongPBRMaterialStruct.HasDiffuseMapStr, material.ColorStripeXEnabled && (textureIndex & 1u) != 0 ? 1 : 0);
});
AddPropertyBinding(nameof(ColorStripeMaterialCore.ColorStripeYEnabled), () =>
{
WriteValue(PhongPBRMaterialStruct.HasDiffuseAlphaMapStr, material.ColorStripeYEnabled && (textureIndex & 1u << 1) != 0 ? 1 : 0);
});
WriteValue(PhongPBRMaterialStruct.UVTransformR1Str, new Vector4(1, 0, 0, 0));
WriteValue(PhongPBRMaterialStruct.UVTransformR2Str, new Vector4(0, 1, 0, 0));
}
/// <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);
}
}
protected override void OnDetach()
{
depthdesc.Width = depthdesc.Height = 0;
blurCore = null;
sampler = null;
base.OnDetach();
}
protected override void OnDetach()
{
sampler = null;
width = height = 0;
offScreenRenderTargets.Clear();
base.OnDetach();
}
protected override void OnInitialPropertyBindings()
{
base.OnInitialPropertyBindings();
AddPropertyBinding(nameof(DiffuseMaterialCore.DiffuseColor), () =>
{ WriteValue(PhongPBRMaterialStruct.DiffuseStr, material.DiffuseColor); });
AddPropertyBinding(nameof(DiffuseMaterialCore.UVTransform), () =>
{
Matrix m = material.UVTransform;
WriteValue(PhongPBRMaterialStruct.UVTransformR1Str, m.Column1);
WriteValue(PhongPBRMaterialStruct.UVTransformR2Str, m.Column2);
});
AddPropertyBinding(nameof(DiffuseMaterialCore.DiffuseMap), () =>
{
CreateTextureView(material.DiffuseMap, DiffuseIdx);
WriteValue(PhongPBRMaterialStruct.HasDiffuseMapStr, material.RenderDiffuseMap && TextureResource != null ? 1 : 0);
});
AddPropertyBinding(nameof(DiffuseMaterialCore.DiffuseMapSampler), () =>
{
RemoveAndDispose(ref SamplerResource);
SamplerResource = Collect(statePoolManager.Register(material.DiffuseMapSampler));
});
AddPropertyBinding(nameof(DiffuseMaterialCore.EnableUnLit), () =>
{ WriteValue(PhongPBRMaterialStruct.HasNormalMapStr, material.EnableUnLit); });
AddPropertyBinding(nameof(DiffuseMaterialCore.EnableFlatShading), () => { WriteValue(PhongPBRMaterialStruct.RenderFlat, material.EnableFlatShading); });
}
protected override void OnInitialPropertyBindings()
{
base.OnInitialPropertyBindings();
AddPropertyBinding(nameof(VolumeTextureMaterialCoreBase <T> .VolumeTexture), () => { UpdateTexture(material); });
AddPropertyBinding(nameof(IVolumeTextureMaterial.Sampler), () =>
{
var newSampler = EffectsManager.StateManager.Register(material.Sampler);
RemoveAndDispose(ref sampler);
sampler = Collect(newSampler);
});
AddPropertyBinding(nameof(IVolumeTextureMaterial.SampleDistance),
() => UpdateStepSize());
AddPropertyBinding(nameof(IVolumeTextureMaterial.MaxIterations),
() => WriteValue(VolumeParamsStruct.MaxIterations, material.MaxIterations));
AddPropertyBinding(nameof(IVolumeTextureMaterial.IterationOffset),
() => WriteValue(VolumeParamsStruct.IterationOffset, material.IterationOffset));
AddPropertyBinding(nameof(IVolumeTextureMaterial.IsoValue),
() => WriteValue(VolumeParamsStruct.IsoValue, (float)material.IsoValue));
AddPropertyBinding(nameof(IVolumeTextureMaterial.Color),
() => WriteValue(VolumeParamsStruct.Color, material.Color));
AddPropertyBinding(nameof(IVolumeTextureMaterial.TransferMap),
() => UpdateGradientMap());
AddPropertyBinding(nameof(IVolumeTextureMaterial.EnablePlaneAlignment),
() => WriteValue(VolumeParamsStruct.EnablePlaneAlignment, material.EnablePlaneAlignment));
}
private void CreateSamplers()
{
RemoveAndDispose(ref sampler);
if (material != null)
{
sampler = Collect(statePoolManager.Register(material.ColorStripeSampler));
}
}
protected override bool OnAttach(IRenderTechnique technique)
{
DefaultShaderPass = technique[DefaultShaderPassName];
contextPool = technique.EffectsManager.DeviceContextPool;
textureSampler = Collect(technique.EffectsManager.StateManager.Register(SamplerDescription));
CreateCubeMapResources();
return true;
}
protected override bool OnAttach(IRenderTechnique technique)
{
spritePass = technique[DefaultPassNames.Default];
texSlot = spritePass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.SpriteTB);
samplerSlot = spritePass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SpriteSampler);
sampler = Collect(EffectTechnique.EffectsManager.StateManager.Register(DefaultSamplers.PointSamplerWrap));
return(true);
}
/// <summary>
/// Called when [detach].
/// </summary>
protected override void OnDetach()
{
clearTarget = true;
invalidRender = true;
pointer = new PointerInfo();
textureSampler = null;
base.OnDetach();
}
private void CreateSamplers()
{
RemoveAndDispose(ref SamplerResource);
if (material != null)
{
SamplerResource = Collect(statePoolManager.Register(material.DiffuseMapSampler));
}
}
/// <summary>
/// Called when [detach].
/// </summary>
protected override void OnDetach()
{
DisposeBuffers();
textureSampler = null;
blendState = null;
textureView = null;
base.OnDetach();
}
protected override bool OnAttach(IRenderTechnique technique)
{
DefaultShaderPass = technique[DefaultPassNames.Default];
samplerSlot = DefaultShaderPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.ShadowMapSampler);
shadowMapSlot = DefaultShaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.ShadowMapTB);
shadowSampler = Collect(technique.EffectsManager.StateManager.Register(DefaultSamplers.ShadowSampler));
return(true);
}
/// <summary>
/// Called when [detach].
/// </summary>
protected override void OnDetach()
{
DisposeBuffers();
isInitialParticleChanged = true;
textureSampler = null;
blendState = null;
textureView = null;
base.OnDetach();
}
/// <summary>
/// Called when [attach].
/// </summary>
/// <param name="technique">The technique.</param>
/// <returns></returns>
protected override bool OnAttach(IRenderTechnique technique)
{
DefaultShaderPass = technique.EffectsManager[DefaultRenderTechniqueNames.ScreenDuplication][DefaultPassNames.Default];
CursorShaderPass = technique.EffectsManager[DefaultRenderTechniqueNames.ScreenDuplication][DefaultPassNames.ScreenQuad];
textureBindSlot = DefaultShaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
samplerBindSlot = DefaultShaderPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SurfaceSampler);
textureSampler = technique.EffectsManager.StateManager.Register(DefaultSamplers.ScreenDupSampler);
return(Initialize(technique.EffectsManager));
}
protected override bool OnAttach(IRenderTechnique technique)
{
FXAAPass = technique[DefaultPassNames.FXAAPass];
LUMAPass = technique[DefaultPassNames.LumaPass];
textureSlot = FXAAPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
samplerSlot = FXAAPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SurfaceSampler);
sampler = Collect(technique.EffectsManager.StateManager.Register(DefaultSamplers.LinearSamplerClampAni1));
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="disposeManagedResources"></param>
protected override void OnDispose(bool disposeManagedResources)
{
if (disposeManagedResources)
{
TextureResource = null;
SamplerResource = null;
}
base.OnDispose(disposeManagedResources);
}
private void CreateSamplers()
{
var newSampler = statePoolManager.Register(material.ColorStripeSampler);
RemoveAndDispose(ref sampler);
if (material != null)
{
sampler = newSampler;
}
}
protected override void OnInitialPropertyBindings()
{
base.OnInitialPropertyBindings();
AddPropertyBinding(nameof(BillboardMaterialCore.FixedSize), () => { WriteValue(PointLineMaterialStruct.FixedSize, materialCore.FixedSize); });
AddPropertyBinding(nameof(BillboardMaterialCore.Type), () => { WriteValue(PointLineMaterialStruct.ParamsStr, new Vector4((int)materialCore.Type, 0, 0, 0)); });
AddPropertyBinding(nameof(BillboardMaterialCore.SamplerDescription), () => {
RemoveAndDispose(ref textureSampler);
textureSampler = Collect(EffectsManager.StateManager.Register(materialCore.SamplerDescription));
});
}
/// <summary>
/// Initializes a new instance of the <see cref="PostEffectMeshOutlineBlurCore"/> class.
/// </summary>
public PostEffectBlurCore(ShaderPass blurVerticalPass, ShaderPass blurHorizontalPass, int textureSlot, int samplerSlot,
SamplerStateDescription sampler, IEffectsManager manager)
{
screenBlurPassVertical = blurVerticalPass;
screenBlurPassHorizontal = blurHorizontalPass;
this.textureSlot = textureSlot;
this.samplerSlot = samplerSlot;
this.sampler = manager.StateManager.Register(sampler);
modelCB = new ConstantBufferComponent(new ConstantBufferDescription(DefaultBufferNames.BorderEffectCB, BorderEffectStruct.SizeInBytes));
}
protected override bool OnAttach(IRenderTechnique technique)
{
screenQuadPass = technique[DefaultPassNames.Default];
colorTexIndex = screenQuadPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.OITColorTB);
alphaTexIndex = screenQuadPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.OITAlphaTB);
samplerIndex = screenQuadPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SurfaceSampler);
targetSampler = technique.EffectsManager.StateManager.Register(DefaultSamplers.LinearSamplerWrapAni1);
RenderCount = 0;
return(true);
}
protected override void OnDetach()
{
targetSampler = null;
width = height = 0;
colorTarget = null;
alphaTarget = null;
colorTargetNoMSAA = null;
alphaTargetNoMSAA = null;
base.OnDetach();
}
/// <summary>
/// Initializes a new instance of the <see cref="PostEffectMeshOutlineBlurCore"/> class.
/// </summary>
public PostEffectBlurCore(global::SharpDX.DXGI.Format textureFormat,
ShaderPass blurVerticalPass, ShaderPass 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>
/// Initializes a new instance of the <see cref="BillboardMaterialVariable"/> class.
/// </summary>
/// <param name="manager">The manager.</param>
/// <param name="technique">The technique.</param>
/// <param name="materialCore">The core.</param>
/// <param name="billboardPassName">Name of the billboard pass.</param>
/// <param name="billboardOITPassName">Name of the billboard oit pass.</param>
public BillboardMaterialVariable(IEffectsManager manager, IRenderTechnique technique, BillboardMaterialCore materialCore,
string billboardPassName = DefaultPassNames.Default, string billboardOITPassName = DefaultPassNames.OITPass)
: base(manager, technique, DefaultPointLineConstantBufferDesc, materialCore)
{
BillboardPass = technique[billboardPassName];
BillboardOITPass = technique[billboardOITPassName];
this.materialCore = materialCore;
shaderTextureSlot = BillboardPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(ShaderTextureName);
textureSamplerSlot = BillboardPass.PixelShader.SamplerMapping.TryGetBindSlot(ShaderTextureSamplerName);
textureSampler = Collect(EffectsManager.StateManager.Register(materialCore.SamplerDescription));
}
protected override bool OnAttach(IRenderTechnique 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.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
samplerSlot = screenOutlinePass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.DiffuseMapSampler);
sampler = Collect(technique.EffectsManager.StateManager.Register(DefaultSamplers.LinearSamplerClampAni1));
return(true);
}
protected override bool OnAttach(IRenderTechnique technique)
{
if (base.OnAttach(technique))
{
textureSampler = Collect(technique.EffectsManager.StateManager.Register(SamplerDescription));
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LineMaterialVariable"/> class.
/// </summary>
/// <param name="manager">The manager.</param>
/// <param name="technique">The technique.</param>
/// <param name="materialCore">The material core.</param>
/// <param name="defaultPassName">Default pass name</param>
public LineMaterialVariable(IEffectsManager manager, IRenderTechnique technique, LineMaterialCore materialCore,
string defaultPassName = DefaultPassNames.Default)
: base(manager, technique, DefaultPointLineConstantBufferDesc, materialCore)
{
textureManager = manager.MaterialTextureManager;
LinePass = technique[defaultPassName];
ShadowPass = technique[DefaultPassNames.ShadowPass];
DepthPass = technique[DefaultPassNames.DepthPrepass];
this.material = materialCore;
shaderTextureSlot = LinePass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(ShaderTextureName);
textureSamplerSlot = LinePass.PixelShader.SamplerMapping.TryGetBindSlot(ShaderTextureSamplerName);
textureSampler = EffectsManager.StateManager.Register(materialCore.SamplerDescription);
}
