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; }