static IShader compilePixelShader(iShaderFactory compiler, iStorageFolder assets) { // return compiler.compileHlslFile( assets, "Nv12PS.hlsl", ShaderType.Pixel ); ShaderSourceInfo sourceInfo = new ShaderSourceInfo(ShaderType.Pixel, ShaderSourceLanguage.Glsl); sourceInfo.combinedTextureSamplers = true; return(compiler.compileFromFile(assets, "Nv12PS.glsl", sourceInfo)); }
protected override IShader compilePixelShader(iShaderFactory compiler, iStorageFolder assets, string uvMin, string uvMax, string colorString) { ShaderSourceInfo ssi = new ShaderSourceInfo(ShaderType.Pixel, ShaderSourceLanguage.Hlsl) { combinedTextureSamplers = true }; return(compiler.compileFromFile(assets, "VideoPS.hlsl", ssi, "RenderVideoPS", makeMacros(uvMin, uvMax, colorString))); }
public Blender(Context context, IRenderDevice device, byte samplesCount) { PipelineStateDesc desc = new PipelineStateDesc(false); desc.setBufferFormats(context); desc.premultipliedAlphaBlending(); desc.GraphicsPipeline.PrimitiveTopology = PrimitiveTopology.TriangleList; desc.GraphicsPipeline.RasterizerDesc.CullMode = CullMode.None; desc.GraphicsPipeline.DepthStencilDesc.DepthEnable = false; iShaderFactory shaderFactory = device.GetShaderFactory(); iStorageFolder assets = StorageFolder.embeddedResources(Assembly.GetExecutingAssembly(), resourceSubfolder); using (iPipelineStateFactory stateFactory = device.CreatePipelineStateFactory()) { stateFactory.layoutVariable(ShaderType.Pixel, ShaderResourceVariableType.Mutable, textureVarName); stateFactory.graphicsVertexShader(shaderFactory.compileShader(assets, "Blend", ShaderType.Vertex)); ShaderSourceInfo ssi; string src; if (RuntimeEnvironment.operatingSystem == eOperatingSystem.Windows) { ssi = new ShaderSourceInfo(ShaderType.Pixel, ShaderSourceLanguage.Hlsl); src = "BlendPS.hlsl"; } else { ssi = new ShaderSourceInfo(ShaderType.Pixel, ShaderSourceLanguage.Glsl); ssi.combinedTextureSamplers = true; src = "BlendPS.glsl"; } string name = $"BlendPS { samplesCount }x"; var ps = shaderFactory.compileFromFile(assets, src, ssi, name, shaderMacros(samplesCount)); stateFactory.graphicsPixelShader(ps); stateFactory.apply(ref desc); pipelineState = device.CreatePipelineState(ref desc); } this.samplesCount = samplesCount; }
void createPipelineState(IRenderDevice device, iStorageFolder assets) { PipelineStateDesc PSODesc = new PipelineStateDesc(false); PSODesc.setBufferFormats(context); // Primitive topology defines what kind of primitives will be rendered by this pipeline state PSODesc.GraphicsPipeline.PrimitiveTopology = PrimitiveTopology.TriangleList; // Cull back faces PSODesc.GraphicsPipeline.RasterizerDesc.CullMode = CullMode.Back; // Enable depth testing PSODesc.GraphicsPipeline.DepthStencilDesc.DepthEnable = true; iShaderFactory shaderFactory = device.GetShaderFactory(); // We won't be using the factory object after this, `using` to release the COM interface once finished using (iPipelineStateFactory stateFactory = device.CreatePipelineStateFactory()) { stateFactory.setName("Cube PSO"); // Compile the two shaders ShaderSourceInfo sourceInfo = new ShaderSourceInfo(ShaderType.Vertex, ShaderSourceLanguage.Hlsl); sourceInfo.combinedTextureSamplers = true; // This appears to be the requirement of OpenGL backend. // In this tutorial, we will load shaders from resources embedded into this .NET DLL. var vs = shaderFactory.compileFromFile(assets, "cube.vsh", sourceInfo, "Cube VS"); stateFactory.graphicsVertexShader(vs); // Create dynamic uniform buffer that will store our transformation matrix. Dynamic buffers can be frequently updated by the CPU. BufferDesc CBDesc = new BufferDesc(false); CBDesc.uiSizeInBytes = Marshal.SizeOf <Matrix4x4>(); CBDesc.Usage = Usage.Dynamic; CBDesc.BindFlags = BindFlags.UniformBuffer; CBDesc.CPUAccessFlags = CpuAccessFlags.Write; vsConstants = device.CreateBuffer(CBDesc, "VS constants CB"); // Create a pixel shader sourceInfo.shaderType = ShaderType.Pixel; var ps = shaderFactory.compileFromFile(assets, "cube.psh", sourceInfo, "Cube PS"); stateFactory.graphicsPixelShader(ps); // Define vertex shader input layout // Attribute 0 - vertex position LayoutElement elt = new LayoutElement(false) { InputIndex = 0, BufferSlot = 0, NumComponents = 3, ValueType = GpuValueType.Float32, IsNormalized = false }; stateFactory.graphicsLayoutElement(elt); // Attribute 1 - texture coordinates elt.InputIndex = 1; elt.NumComponents = 2; stateFactory.graphicsLayoutElement(elt); // Define variable type that will be used by default PSODesc.ResourceLayout.DefaultVariableType = ShaderResourceVariableType.Static; // Shader variables should typically be mutable, which means they are expected to change on a per-instance basis stateFactory.layoutVariable(ShaderType.Pixel, ShaderResourceVariableType.Mutable, "g_Texture"); // Define static sampler for g_Texture. Static samplers should be used whenever possible. // The default constructor is good enough, it sets FilterType.Linear and TextureAddressMode.Clamp for all 3 coordinates. SamplerDesc samplerDesc = new SamplerDesc(false); stateFactory.layoutStaticSampler(ShaderType.Pixel, ref samplerDesc, "g_Texture"); stateFactory.apply(ref PSODesc); pipelineState = device.CreatePipelineState(ref PSODesc); } // Since we did not explicitly specify the type for 'Constants' variable, default // type (SHADER_RESOURCE_VARIABLE_TYPE_STATIC) will be used. Static variables never // change and are bound directly through the pipeline state object. pipelineState.GetStaticVariableByName(ShaderType.Vertex, "Constants").Set(vsConstants); // Since we are using mutable variable, we must create a shader resource binding object // http://diligentgraphics.com/2016/03/23/resource-binding-model-in-diligent-engine-2-0/ resourceBinding = pipelineState.CreateShaderResourceBinding(true); }
public TeapotResources(Context context, IRenderDevice device) { PipelineStateDesc PSODesc = new PipelineStateDesc(false); PSODesc.setBufferFormats(context); // Primitive topology defines what kind of primitives will be rendered by this pipeline state PSODesc.GraphicsPipeline.PrimitiveTopology = PrimitiveTopology.TriangleList; // Cull back faces PSODesc.GraphicsPipeline.RasterizerDesc.CullMode = CullMode.Back; // Enable depth testing PSODesc.GraphicsPipeline.DepthStencilDesc.DepthEnable = true; iShaderFactory shaderFactory = device.GetShaderFactory(); // We won't be using the device object after this, `using` is to release the COM interface once finished using (iPipelineStateFactory stateFactory = device.CreatePipelineStateFactory()) { stateFactory.setName("Teapot PSO"); // Compile the two shaders ShaderSourceInfo sourceInfo = new ShaderSourceInfo(ShaderType.Vertex, ShaderSourceLanguage.Hlsl); sourceInfo.combinedTextureSamplers = true; // This appears to be the requirement of OpenGL backend. // In this tutorial, we will load shaders from resources embedded into this .NET DLL. iStorageFolder resources = StorageFolder.embeddedResources(Assembly.GetExecutingAssembly(), resourcesFolder); var vs = shaderFactory.compileFromFile(resources, "TeapotVS.hlsl", sourceInfo, "Teapot VS"); stateFactory.graphicsVertexShader(vs); // Create dynamic uniform buffer that will store our transformation matrix. Dynamic buffers can be frequently updated by the CPU. vsConstants = device.CreateDynamicUniformBuffer <VsConstants>("VS constants CB"); // Create a pixel shader sourceInfo.shaderType = ShaderType.Pixel; var ps = shaderFactory.compileFromFile(resources, "TeapotPS.hlsl", sourceInfo, "Teapot PS"); stateFactory.graphicsPixelShader(ps); // Define vertex shader input layout // Attribute 0 - vertex position LayoutElement elt = new LayoutElement(false) { InputIndex = 0, BufferSlot = 0, NumComponents = 3, ValueType = GpuValueType.Float32, IsNormalized = false }; stateFactory.graphicsLayoutElement(elt); // Attribute 1 - normals, they are generated by STL loader because we ask for them. elt.InputIndex = 1; elt.NumComponents = 3; stateFactory.graphicsLayoutElement(elt); // Define variable type that will be used by default PSODesc.ResourceLayout.DefaultVariableType = ShaderResourceVariableType.Static; stateFactory.apply(ref PSODesc); pipelineState = device.CreatePipelineState(ref PSODesc); } // Since we did not explicitly specify the type for 'Constants' variable, default // type (SHADER_RESOURCE_VARIABLE_TYPE_STATIC) will be used. Static variables never // change and are bound directly through the pipeline state object. pipelineState.GetStaticVariableByName(ShaderType.Vertex, "Constants").Set(vsConstants); // Create a shader resource binding object and bind all static resources in it resourceBinding = pipelineState.CreateShaderResourceBinding(true); }