public static async Task <Material> GenerateAsync(MaterialDescriptor descriptor, MaterialGeneratorContext context)
{
context.PushMaterialDescriptor(descriptor);
for (int passIndex = 0; passIndex < context.PassCount; passIndex++)
{
MaterialPass materialPass = context.PushPass();
context.Visit(descriptor.Attributes);
InputElementDescription[] inputElements = new[]
{
new InputElementDescription("Position", 0, PixelFormat.R32G32B32Float, 0),
new InputElementDescription("Normal", 0, PixelFormat.R32G32B32Float, 1),
new InputElementDescription("Tangent", 0, PixelFormat.R32G32B32A32Float, 2),
new InputElementDescription("TexCoord", 0, PixelFormat.R32G32Float, 3)
};
materialPass.PipelineState = await context.CreateGraphicsPipelineStateAsync(inputElements);
materialPass.ShaderResourceViewDescriptorSet = context.CreateShaderResourceViewDescriptorSet();
materialPass.SamplerDescriptorSet = context.CreateSamplerDescriptorSet();
context.PopPass();
}
context.PopMaterialDescriptor();
return(context.Material);
}
internal TerrainPatch(
HeightMap heightMap,
Rectangle patchBounds,
GraphicsDevice graphicsDevice,
TerrainPatchIndexBufferCache indexBufferCache,
Material material)
{
DebugName = $"Terrain_{Bounds}";
Bounds = patchBounds;
_indexBuffer = indexBufferCache.GetIndexBuffer(
patchBounds.Width,
patchBounds.Height,
out var indices);
_numIndices = (uint)indices.Length;
_vertexBuffer = AddDisposable(CreateVertexBuffer(
graphicsDevice,
heightMap,
patchBounds,
indices,
out var boundingBox,
out var triangles));
BoundingBox = boundingBox;
Triangles = triangles;
MaterialPass = new MaterialPass(material, null);
}
public static async Task <Material> GenerateAsync(MaterialDescriptor descriptor, MaterialGeneratorContext context)
{
context.PushMaterialDescriptor(descriptor);
for (int passIndex = 0; passIndex < context.PassCount; passIndex++)
{
MaterialPass materialPass = context.PushPass();
descriptor.Visit(context);
materialPass.PipelineState = await context.CreateGraphicsPipelineStateAsync();
var shaderResources = context.ConstantBufferViews.Concat(context.ShaderResourceViews).Concat(context.UnorderedAccessViews);
if (shaderResources.Count() > 0)
{
materialPass.ShaderResourceViewDescriptorSet = new DescriptorSet(context.GraphicsDevice, shaderResources.Count());
materialPass.ShaderResourceViewDescriptorSet.AddConstantBufferViews(context.ConstantBufferViews);
materialPass.ShaderResourceViewDescriptorSet.AddShaderResourceViews(context.ShaderResourceViews);
materialPass.ShaderResourceViewDescriptorSet.AddUnorderedAccessViews(context.UnorderedAccessViews);
}
if (context.Samplers.Count > 0)
{
materialPass.SamplerDescriptorSet = new DescriptorSet(context.GraphicsDevice, context.Samplers.Count, DescriptorHeapType.Sampler);
materialPass.SamplerDescriptorSet.AddSamplers(context.Samplers);
}
context.PopPass();
}
context.PopMaterialDescriptor();
return(context.Material);
}
public StencilShadowRenderer(Game game)
{
this.game = game;
var desc = new MaterialPassDesc();
desc.ManualConstantBuffers = true;
desc.ShaderFile = "StencilShadow.hlsl";
desc.BlendStates.RenderTarget[0].IsBlendEnabled = true;
desc.BlendStates.RenderTarget[0].SourceBlend = BlendOption.SourceAlpha;
desc.BlendStates.RenderTarget[0].DestinationBlend = BlendOption.InverseSourceAlpha;
desc.BlendStates.RenderTarget[0].BlendOperation = BlendOperation.Add;
desc.BlendStates.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
desc.BlendStates.RenderTarget[0].DestinationAlphaBlend = BlendOption.Zero;
desc.BlendStates.RenderTarget[0].AlphaBlendOperation = BlendOperation.Add;
desc.BlendStates.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
desc.DepthStencilStates.IsDepthEnabled = true;
desc.DepthStencilStates.DepthWriteMask = DepthWriteMask.Zero;
desc.DepthStencilStates.DepthComparison = Comparison.LessEqual;
desc.DepthStencilStates.IsStencilEnabled = true;
desc.DepthStencilStates.StencilReadMask = 1;
desc.DepthStencilStates.StencilWriteMask = 1;
desc.DepthStencilStates.FrontFace.FailOperation = StencilOperation.Keep;
desc.DepthStencilStates.FrontFace.DepthFailOperation = StencilOperation.Keep;
desc.DepthStencilStates.FrontFace.PassOperation = StencilOperation.Replace;
desc.DepthStencilStates.FrontFace.Comparison = Comparison.NotEqual;
desc.StencilRef = 1;
pass = new MaterialPass(game.Device, desc, "StencilShadow");
buffer = Material.CreateBuffer<ShaderData>();
}
public PassTextureSlot(MaterialPass pass, int textureIndex)
{
InitializeComponent();
this.pass = pass;
this.textureIndex = textureIndex;
this.labelTitle.Text = "Texture " + textureIndex;
this.label1.Text = pass.Desc.Textures[textureIndex].TextureFile;
UpdateThumb();
}
private void UpdateMaterial(RenderMesh renderMesh, MaterialPass materialPass, MaterialInstance modelMaterialInstance, DecalComponent decalComponent)
{
renderMesh.MaterialPass = materialPass;
renderMesh.IsShadowCaster = false;
if (modelMaterialInstance != null)
{
renderMesh.IsShadowCaster = renderMesh.IsShadowCaster && modelMaterialInstance.IsShadowCaster;
}
}
public MaterialPass PushPass()
{
MaterialPass materialPass = new MaterialPass {
PassIndex = PassIndex
};
Material.Passes.Add(materialPass);
MaterialPass = materialPass;
return(materialPass);
}
public SkyBox(Game game, ShaderResourceView cubeMap, string debugName = null)
{
this.game = game;
this.cubeMap = cubeMap;
cube = game.ResourceManager.Mesh.Load(InternalResources.MESH_CUBE);
MaterialPassDesc desc = new MaterialPassDesc();
desc.ManualConstantBuffers = true;
desc.ShaderFile = "Skybox.hlsl";
desc.RasteriazerStates.CullMode = CullMode.Front;
desc.DepthStencilStates.DepthWriteMask = DepthWriteMask.Zero;
pass = new MaterialPass(game.Device, desc, debugName ?? "Skybox" + Debug.NextObjectId);
buffer = Material.CreateBuffer<Data>();
}
public TexturePreviewQuad(Game game, Texture2DDescription textureDesc)
{
this.game = game;
var passDesc = new MaterialPassDesc();
passDesc.ManualConstantBuffers = true;
passDesc.ShaderFile = "TexturePreview.hlsl";
passDesc.InputElements = new InputElement[]{
new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0),
new InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float, 12, 0),
};
pass = new MaterialPass(Game.Instance.Device, passDesc, "Preview");
BuildVertexBuffer(textureDesc);
}
public Skydome(Device device)
{
this.device = device;
sphere = Mesh.CreateSphere();
MaterialPassDesc desc = new MaterialPassDesc();
desc.ManualConstantBuffers = true;
desc.ShaderFile = "Skydome.hlsl";
desc.RasteriazerStates.CullMode = CullMode.None;
desc.DepthStencilStates.IsDepthEnabled = false;
pass = new MaterialPass(device, desc, "Skydome");
buffer = Material.CreateBuffer<Data>();
//Game.Instance.AddControl(new Lilium.Controls.ColorPicker("Bottom", () => data.bottomColor, val => data.bottomColor = val));
//Game.Instance.AddControl(new Lilium.Controls.ColorPicker("Top", () => data.topColor, val => data.topColor = val));
}
public ScatteringParameters(MaterialPass material)
{
// Extract all required parameters from the material:
ScatteringWidth = material.Parameters.Get(MaterialSurfaceSubsurfaceScatteringShadingKeys.ScatteringWidth); // TODO: Instead of saving this shit, how about just generating a hash of the kernel inside the material??
ScatteringKernel = material.Parameters.Get(MaterialSurfaceSubsurfaceScatteringShadingKeys.ScatteringKernel);
scatteringKernelHashCode = 0;
// TODO: Use a better hash function (and maybe a higher bit depth for the hash).
if (ScatteringKernel.Length > 0)
{
scatteringKernelHashCode = GetVector4Hash(ScatteringKernel[0]);
for (int i = 1; i < ScatteringKernel.Length; ++i)
{
scatteringKernelHashCode = (scatteringKernelHashCode * 397) ^ GetVector4Hash(ScatteringKernel[i]);
}
}
}
internal ModelMeshPart(
ModelMesh modelMesh,
DeviceBuffer texCoordVertexBuffer,
uint startIndex,
uint indexCount,
bool blendEnabled,
MaterialPass material,
MaterialPass materialBlend)
{
ModelMesh = modelMesh;
TexCoordVertexBuffer = texCoordVertexBuffer;
StartIndex = startIndex;
IndexCount = indexCount;
BlendEnabled = blendEnabled;
Material = material;
MaterialBlend = materialBlend;
}
public override void Start()
{
//Input.AddListener(new Test());
effectRenderPass = EffectMaterial?.Passes?.First();
PlayerRaycaster.OnRaycast.Subscribe(hitResult =>
{
var entity = hitResult.Collider?.Entity;
if (entity == null)
{
GunBeam?.UpdateBeam(false);
return;
}
if (Input.MouseWheelDelta != 0)
{
var timeComponent = entity.Get <TimeControllerComponent>() ?? entity.GetParent()?.Get <TimeControllerComponent>();
if (timeComponent != null)
{
GunBeam?.UpdateBeam(true, hitResult.Point);
if (Input.MouseWheelDelta < 0)
{
timeComponent.Time = timeComponent.Time.GetPrevious();
}
else
{
timeComponent.Time = timeComponent.Time.GetNext();
}
}
}
else
{
GunBeam?.UpdateBeam(false);
}
})
.DisposeLater(this);
}
private ModelMeshPart CreateModelMeshPartShaderMaterial(
AssetLoadContext context,
W3dMesh w3dMesh,
W3dMaterialPass w3dMaterialPass,
W3dShaderMaterial w3dShaderMaterial,
ShaderMaterialShaderResources shaderResources)
{
var texCoords = new MeshShaderResources.MeshVertex.TexCoords[w3dMesh.Header.NumVertices];
if (w3dMaterialPass.TexCoords != null)
{
for (var i = 0; i < texCoords.Length; i++)
{
texCoords[i].UV0 = w3dMaterialPass.TexCoords.Items[i];
}
}
var blendEnabled = false;
var texCoordsVertexBuffer = AddDisposable(context.GraphicsDevice.CreateStaticBuffer(
texCoords,
BufferUsage.VertexBuffer));
var material = shaderResources.GetCachedMaterial(w3dShaderMaterial, context);
var materialPass = new MaterialPass(material, context.ShaderResources.MeshDepth.Material);
return(new ModelMeshPart(
this,
texCoordsVertexBuffer,
0,
(uint)w3dMesh.Triangles.Items.Length * 3,
blendEnabled,
materialPass,
materialPass)); // TODO
}
private bool HasScatteringKernel(MaterialPass material)
{
return(material.Parameters.ContainsKey(MaterialSurfaceSubsurfaceScatteringShadingKeys.ScatteringKernel));
}
void LoadShader()
{
var passDesc = new MaterialPassDesc();
passDesc.ManualConstantBuffers = true;
passDesc.ShaderFile = shaderFile;
passDesc.InputElements = new InputElement[]{
new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0),
new InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float, 12, 0),
};
Pass = new MaterialPass(Game.Instance.Device, passDesc, debugName);
}
public TangentSpaceBasisRenderer(List<MeshVertex> vertices)
{
hasTangent = vertices[0].Tangent.LengthSquared() > 0;
{
var lineVerticesList = new List<LineVertex>();
Action<Color> _addLine = (c) =>
{
lineVerticesList.Add(new LineVertex(Vector3.Zero, c));
lineVerticesList.Add(new LineVertex(Vector3.Zero, c));
};
for (int i = 0; i < vertices.Count; ++i)
{
var v = vertices[i];
if (hasTangent)
{
_addLine(Color.Red);
_addLine(Color.Green);
}
_addLine(Color.Blue);
}
lineVertices = lineVerticesList.ToArray();
updateLineVertices = delegate
{
int i = 0;
int j = 0;
for (i = 0; i < vertices.Count; ++i)
{
var v = vertices[i];
var origin = v.Position + Config.TBNOffset * v.Normal;
if (hasTangent)
{
lineVertices[j++].Position = origin;
lineVertices[j++].Position = origin + v.Tangent;
lineVertices[j++].Position = origin;
lineVertices[j++].Position = origin + Vector3.Cross(v.Normal, v.Tangent);
}
lineVertices[j++].Position = origin;
lineVertices[j++].Position = origin + v.Normal;
}
};
}
{
var desc = new BufferDescription();
desc.BindFlags = BindFlags.VertexBuffer;
desc.Usage = ResourceUsage.Dynamic;
desc.CpuAccessFlags = CpuAccessFlags.Write;
desc.OptionFlags = ResourceOptionFlags.None;
desc.SizeInBytes = Utilities.SizeOf<LineVertex>() * lineVertices.Length;
desc.StructureByteStride = 0;
vertexBuffer = new Buffer(Game.Instance.Device, desc);
}
{
var passDesc = new MaterialPassDesc();
passDesc.ManualConstantBuffers = true;
passDesc.ShaderFile = InternalResources.SHADER_DEBUG_LINE;
passDesc.InputElements = new InputElement[]{
new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0),
new InputElement("COLOR", 0, SharpDX.DXGI.Format.R32G32B32A32_Float, 12, 0),
};
pass = new MaterialPass(Game.Instance.Device, passDesc, "TangentSpaceBasisRenderer");
matrixBuffer = Material.CreateBuffer<Matrix>();
}
}
public MeshPreview(Mesh mesh)
{
this.mesh = mesh;
var game = Game.Instance;
{
var desc = new MaterialPassDesc();
desc.ManualConstantBuffers = true;
desc.ShaderFile = "MeshPreview.hlsl";
passFill = new MaterialPass(game.Device, desc, "Preview(Fill)");
}
{
var desc = new MaterialPassDesc();
desc.ManualConstantBuffers = true;
desc.ShaderFile = "MeshPreview.hlsl";
desc.RasteriazerStates.FillMode = FillMode.Wireframe;
passWireframe = new MaterialPass(game.Device, desc, "Preview(Wireframe)");
}
shaderBuffer = Material.CreateBuffer<ShaderData>();
shaderBuffer.DebugName = "Preview";
tangentRenderer = new TangentSpaceBasisRenderer(mesh.vertices);
}
public void Create3D()
{
Dispose3D();
{
var desc = new BufferDescription();
desc.BindFlags = BindFlags.VertexBuffer;
desc.Usage = ResourceUsage.Dynamic;
desc.CpuAccessFlags = CpuAccessFlags.Write;
desc.OptionFlags = ResourceOptionFlags.None;
desc.SizeInBytes = Utilities.SizeOf<LineVertex>() * vertices.Length;
desc.StructureByteStride = 0;
vertexBuffer = new Buffer(game.Device, desc);
vertexBuffer.DebugName = debugName;
vertexBufferBinding = new VertexBufferBinding(vertexBuffer, Utilities.SizeOf<LineVertex>(), 0);
}
{
pass = new MaterialPass(game.Device, Desc, debugName);
matrixBuffer = Material.CreateBuffer<Matrix>();
matrixBuffer.DebugName = debugName;
}
}
public MaterialInfo(MaterialPass materialPass)
{
MaterialPass = materialPass;
CullMode = materialPass.CullMode;
}
public MaterialInfo(MaterialPass materialPass)
{
MaterialPass = materialPass;
}
public void Init()
{
{
BuildVertices();
var desc = new BufferDescription();
desc.BindFlags = BindFlags.VertexBuffer;
desc.Usage = ResourceUsage.Default;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.OptionFlags = ResourceOptionFlags.None;
desc.SizeInBytes = Utilities.SizeOf<LineVertex>() * vertices.Length;
desc.StructureByteStride = 0;
vertexBuffer = Buffer.Create(Device, vertices, desc);//new Buffer(Device, desc);
}
{
var passDesc = new MaterialPassDesc();
passDesc.ManualConstantBuffers = true;
passDesc.ShaderFile = InternalResources.SHADER_DEBUG_LINE;
passDesc.InputElements = new InputElement[]{
new InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0),
new InputElement("COLOR", 0, SharpDX.DXGI.Format.R32G32B32A32_Float, 12, 0),
};
passDesc.RasteriazerStates.CullMode = CullMode.None;
passDesc.DepthStencilStates.DepthWriteMask = DepthWriteMask.Zero;
pass = new MaterialPass(Game.Instance.Device, passDesc, "Grid");
matrixBuffer = Material.CreateBuffer<Matrix>();
}
}
// One ModelMeshPart for each unique shader in a W3D_CHUNK_MATERIAL_PASS.
private ModelMeshPart CreateModelMeshPart(
AssetLoadContext context,
DeviceBuffer texCoordsVertexBuffer,
uint startIndex,
uint indexCount,
W3dMesh w3dMesh,
FixedFunctionShaderResources.VertexMaterial[] vertexMaterials,
FixedFunctionShaderResources.ShadingConfiguration[] shadingConfigurations,
uint vertexMaterialID,
uint shaderID,
uint numTextureStages,
uint?textureIndex0,
uint?textureIndex1)
{
var w3dShader = w3dMesh.Shaders.Items[(int)shaderID];
var cullMode = w3dMesh.Header.Attributes.HasFlag(W3dMeshFlags.TwoSided)
? FaceCullMode.None
: FaceCullMode.Back;
var depthWriteEnabled = w3dShader.DepthMask == W3dShaderDepthMask.WriteEnable;
var depthComparison = w3dShader.DepthCompare.ToComparison();
var blendEnabled = w3dShader.SrcBlend != W3dShaderSrcBlendFunc.One || w3dShader.DestBlend != W3dShaderDestBlendFunc.Zero;
var sourceFactor = w3dShader.SrcBlend.ToBlend();
var destinationColorFactor = w3dShader.DestBlend.ToBlend(false);
var destinationAlphaFactor = w3dShader.DestBlend.ToBlend(true);
var materialConstants = new FixedFunctionShaderResources.MaterialConstantsType
{
Material = vertexMaterials[vertexMaterialID],
Shading = shadingConfigurations[shaderID],
NumTextureStages = (int)numTextureStages
};
var texture0 = CreateTexture(context, w3dMesh, textureIndex0) ?? context.StandardGraphicsResources.NullTexture;
var texture1 = CreateTexture(context, w3dMesh, textureIndex1) ?? context.StandardGraphicsResources.NullTexture;
var material = context.ShaderResources.FixedFunction.GetCachedMaterial(
cullMode,
depthWriteEnabled,
depthComparison,
blendEnabled,
sourceFactor,
destinationColorFactor,
destinationAlphaFactor,
materialConstants,
texture0,
texture1);
var materialBlend = context.ShaderResources.FixedFunction.GetCachedMaterial(
cullMode,
depthWriteEnabled,
depthComparison,
true,
BlendFactor.SourceAlpha,
BlendFactor.InverseSourceAlpha,
BlendFactor.InverseSourceAlpha,
materialConstants,
texture0,
texture1);
var materialPass = new MaterialPass(material, context.ShaderResources.MeshDepth.Material);
var materialPassBlend = new MaterialPass(materialBlend, context.ShaderResources.MeshDepth.Material);
return(new ModelMeshPart(
this,
texCoordsVertexBuffer,
startIndex,
indexCount,
blendEnabled,
materialPass,
materialPassBlend));
}
public void PreviewActive()
{
var desc = new ShaderResourceViewDescription();
desc.Format = tex.Description.Format;
desc.Dimension = ShaderResourceViewDimension.TextureCube;
desc.Texture2D.MipLevels = tex.Description.MipLevels;
desc.Texture2D.MostDetailedMip = 0;
shaderResourceView = new ShaderResourceView(mGame.Device, tex, desc);
shaderResourceView.DebugName = "Preview";
if (shaderResourceView == null) return;
desc.Dimension = ShaderResourceViewDimension.Texture2DArray;
desc.Texture2DArray.ArraySize = 1;
desc.Texture2DArray.MipLevels = tex.Description.MipLevels;
desc.Texture2DArray.MostDetailedMip = 0;
mFaces = new ShaderResourceView[6];
for (int i = 0; i < 6; ++i)
{
desc.Texture2DArray.FirstArraySlice = i;
mFaces[i] = new ShaderResourceView(mGame.Device, tex, desc);
}
cube = mGame.ResourceManager.Mesh.Load(InternalResources.MESH_CUBE);
sphere = mGame.ResourceManager.Mesh.Load(InternalResources.MESH_SPHERE);
var passDesc = new MaterialPassDesc();
passDesc.ManualConstantBuffers = true;
passDesc.ShaderFile = "CubemapPreview.hlsl";
passCube = new MaterialPass(Game.Instance.Device, passDesc, "Preview(Cube)");
passDesc.PixelShaderFunction = "PS_Sphere";
passSphere = new MaterialPass(mGame.Device, passDesc, "Preview(Sphere)");
skybox = new SkyBox(mGame, shaderResourceView, "Preview");
mQuad = new TexturePreviewQuad(mGame, tex.Description);
Light.IsPreviewingTexture = true;
}
