public IShaderStage <T> GetShaderStage <T>()
        {
            IShaderStage stage = null;

            shaderStages.TryGetValue(typeof(T), out stage);
            return((IShaderStage <T>)stage);
        }
        public IShaderStage GetShaderStage(Type type)
        {
            IShaderStage stage = null;

            shaderStages.TryGetValue(type, out stage);
            return(stage);
        }
示例#3
0
        public void Main(
            [ShaderInput(typeof(AppData))] void *inputPtr,
            [ShaderOutput(typeof(VOutdata))] void *outputPtr, IShaderStage <IVertexShader> _)
        {
            AppData * appPtr  = (AppData *)inputPtr;
            VOutdata *vOutPtr = (VOutdata *)outputPtr;

            vOutPtr->Vertex = ObjectToView * appPtr->Vertex * (SinTime * .3f + 1);
        }
示例#4
0
        public unsafe void Main(
            [ShaderInput(typeof(App))] void *inputPtr,
            [ShaderOutput(typeof(VOut))] void *outputPtr, IShaderStage <IVertexShader> _)
        {
            App * appPtr  = (App *)inputPtr;
            VOut *vOutPtr = (VOut *)outputPtr;

            Mul(ObjectToScreen, &appPtr->Vertex, &vOutPtr->Vertex);
        }
示例#5
0
        /// <summary>
        /// Outputs <paramref name="inputPtr"/>'s pointing value with every channel added 1
        /// </summary>
        public unsafe void Main(
            [ShaderInput(typeof(FragmentInputTest))] void *inputPtr,
            [ShaderOutput(typeof(FragmentOutputTest))] void *outputPtr, IShaderStage <IFragmentShader> _)
        {
            FragmentInputTest * fin  = (FragmentInputTest *)inputPtr;
            FragmentOutputTest *fout = (FragmentOutputTest *)outputPtr;

            fout->Vertex = fin->Vertex + 1;
        }
示例#6
0
        /// <summary>
        /// Outputs 2.5 times the <paramref name="inputPtr"/>'s pointing value
        /// </summary>
        public unsafe void Main(
            [ShaderInput(typeof(VertexInputTest))] void *inputPtr,
            [ShaderOutput(typeof(FragmentInputTest))] void *outputPtr, IShaderStage <IVertexShader> _)
        {
            VertexInputTest *  vin  = (VertexInputTest *)inputPtr;
            FragmentInputTest *vout = (FragmentInputTest *)outputPtr;

            vout->Vertex = vin->Vertex * 2.5f;
        }
示例#7
0
        public void Main(
            [ShaderInput(typeof(AppData))] void *inputPtr,
            [ShaderOutput(typeof(VOutData))] void *outputPtr, IShaderStage <IVertexShader> _)
        {
            AppData * appPtr  = (AppData *)inputPtr;
            VOutData *vOutPtr = (VOutData *)outputPtr;

            Vector4 vertex = appPtr->Vertex * (SinTime * .3f + 1);

            Mul(ObjectToScreen, &vertex, &vOutPtr->Vertex);
        }
示例#8
0
        public unsafe void Main(
            [ShaderInput(typeof(FIn))] void *inputPtr,
            [ShaderOutput(typeof(FOut))] void *outputPtr, IShaderStage <IFragmentShader> _)
        {
            FIn * fInPtr  = (FIn *)inputPtr;
            FOut *fOutPtr = (FOut *)outputPtr;

            float absSinTime = MathF.Abs(CosTime);

            fOutPtr->Color = new Vector4(absSinTime, absSinTime, absSinTime, 1f);
        }
示例#9
0
        public unsafe void Main(
            [ShaderInput(typeof(AppData))] void *inputPtr,
            [ShaderOutput(typeof(VOutData))] void *outputPtr, IShaderStage <IVertexShader> _)
        {
            AppData * appPtr  = (AppData *)inputPtr;
            VOutData *vOutPtr = (VOutData *)outputPtr;

            Vector4 pos = appPtr->Vertex;

            pos.Z *= MathF.Sin(pos.X + pos.Y + Time * .5f);
            Mul(ObjectToScreen, &pos, &vOutPtr->Vertex);
        }
示例#10
0
        private void MensureLuminance(GraphicDevice device, IShaderStage stage)
        {
            effect.Technique = HdrEffect.SampleAvgLum;

            RenderTexture2D dest   = _rtToneMap[Tonemaptextures - 1];
            RenderTexture2D source = _rtHdrScene;

            dest.SetTarget(device);
            source.SetTexture(0, device);

            stage.SetSampler(0, _linearSampler);

            device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
            _quadRender.DrawQuad(effect);

            effect.Technique = HdrEffect.ResampleAvgLum;
            stage.SetSampler(0, _pointSampler);

            for (int i = Tonemaptextures - 2; i > 0; i--)
            {
                dest   = _rtToneMap[i];
                source = _rtToneMap[i + 1];

                dest.SetTarget(device);
                source.SetTexture(0, device);
                device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
                _quadRender.DrawQuad(effect);
            }

            effect.Technique = HdrEffect.ResampleAvgLumExp;
            source           = _rtToneMap[1];
            dest             = _rtToneMap[0];

            dest.SetTarget(device);
            source.SetTexture(0, device);

            device.Clear(ClearFlags.Target, Color4.Black, 1, 0);
            _quadRender.DrawQuad(effect);
        }
示例#11
0
 public SamplerStateStack(int index, IShaderStage stage)
 {
     this.index = index;
     this.stage = stage;
 }
 public static void SetResources(this IShaderStage stage, int index, IShaderResource[] resources)
 {
     stage.SetResources(index, resources.Length, resources);
 }
 public static void SetSamplers(this IShaderStage stage, int index, SamplerState[] states)
 {
     stage.SetSamplers(index, states.Length, states);
 }