示例#1
0
		public override void LoadResources()
		{
			if (m_Disposed == true)
			{
				m_TextFont.LoadResources();

				//SlimDX.D3DCompiler.ShaderBytecode blob = SlimDX.D3DCompiler.ShaderBytecode.CompileFromFile(Helper.ResolvePath(m_ShaderLocation), "fx_4_0", SlimDX.D3DCompiler.ShaderFlags.EnableStrictness, SlimDX.D3DCompiler.EffectFlags.None);

				m_Effect = new Effect(GameEnvironment.Device, Bytecode);

				m_Technique = m_Effect.GetTechniqueByName("LinesAndBoxes");
				m_Pass_BoxesAndText = m_Technique.GetPassByName("BoxesAndText");
				m_Pass_Lines = m_Technique.GetPassByName("Lines");
				
				m_Layout = new InputLayout(GameEnvironment.Device, m_Pass_Lines.Description.Signature, new[] {
					new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
					new InputElement("TEXCOORD", 0, Format.R32G32_Float, 12, 0),
					new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 20, 0),				
				});

				m_UiElementsTexture = m_Effect.GetVariableByName("UiElementsTexture").AsResource();
				m_UiElementsTexture.SetResource(m_TextFont.TexureView); 

				m_Disposed = false;
			}
		}
示例#2
0
        public void Render(DeviceContext dc, EffectPass pass, Matrix view, Matrix proj)
        {
            var position = Particle.Position;
            Model.World = Matrix.Translation(position);

            Model.Draw(dc, pass, view, proj);
        }
示例#3
0
		public override void LoadResources()
		{
			if (m_Disposed == true)
			{
				m_Effect = m_Effect = new Effect(GameEnvironment.Device, Bytecode); // Effect.FromFile(GameEnvironment.Device, Helper.ResolvePath(m_ShaderLocation), "fx_4_0", ShaderFlags.None, EffectFlags.None, null, null);
				m_Technique = m_Effect.GetTechniqueByName("RenderParticles");
				m_ParticlePass_Add = m_Technique.GetPassByName("Add");

				m_Layout = new InputLayout(GameEnvironment.Device, m_ParticlePass_Add.Description.Signature, new[] {
					new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
					new InputElement("TEXCOORD", 0, Format.R32G32_Float, 16, 0),				
					new InputElement("INST_POSITION", 0, Format.R32G32B32_Float, 0, 1, InputClassification.PerInstanceData, 1),
					new InputElement("INST_COLOR", 0, Format.R32G32B32A32_Float, 12, 1, InputClassification.PerInstanceData, 1), 					
				});

				m_WorldViewProj = m_Effect.GetVariableByName("worldViewProj").AsMatrix();
				m_ParticleTexture = m_Effect.GetVariableByName("particle_texture").AsResource();
				m_AmpScale = m_Effect.GetVariableByName("ampScale").AsScalar();
				m_PartScaleX = m_Effect.GetVariableByName("partScaleX").AsScalar();
				m_PartScaleY = m_Effect.GetVariableByName("partScaleY").AsScalar(); 
				m_MaxDistance = m_Effect.GetVariableByName("maxDistance").AsScalar();
				m_MinDistance = m_Effect.GetVariableByName("minDistance").AsScalar();
				m_ScaleDistance = m_Effect.GetVariableByName("scaleDistance").AsScalar();

				m_Disposed = false;
			}
		}
示例#4
0
        public void Render(DeviceContext dc, EffectPass pass, Matrix view, Matrix proj) {
            var position = Particle.Position;
            Model.World = Matrix.Scaling(new Vector3(1 + Particle.Mass / 100)) * Matrix.Translation(position);

            Model.Draw(dc, pass, view, proj);

        }
示例#5
0
        public MeshMaterialBinding(Device device, Material material, Mesh mesh)
        {
            mDevice = device;
            mMesh = mesh;
            mPass = material.GetFirstPass();

            mInputLayout = new InputLayout(device, mPass.Description.Signature, mesh.GetInputElements());
        }
 public ShaderData(Effect shader, string passName)
 {
     _passName = passName;
     _shader   = shader;
     if (shader != null && passName != null)
     {
         _effectPass = shader.CurrentTechnique.Passes[passName];
     }
 }
示例#7
0
        /// <summary>
        /// Lazily computes derived parameter values immediately before applying the effect.
        /// </summary>
        protected internal override EffectPass OnApply(EffectPass pass)
        {
            // Recompute the world+view+projection matrix or fog vector?
            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);

            // Recompute the world inverse transpose and eye position?
            dirtyFlags = EffectHelpers.SetLightingMatrices(dirtyFlags, ref world, ref view, worldParam, worldInverseTransposeParam, eyePositionParam);

            // Recompute the diffuse/emissive/alpha material color parameters?
            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
            {
                EffectHelpers.SetMaterialColor(true, alpha, ref diffuseColor, ref emissiveColor, ref ambientLightColor, diffuseColorParam, emissiveColorParam);

                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
            }

            // Check if we can use the only-bother-with-the-first-light shader optimization.
            bool newOneLight = !light1.Enabled && !light2.Enabled;

            if (oneLight != newOneLight)
            {
                oneLight    = newOneLight;
                dirtyFlags |= EffectDirtyFlags.ShaderIndex;
            }

            // Recompute the shader index?
            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
            {
                int shaderIndex = 0;

                if (!fogEnabled)
                {
                    shaderIndex += 1;
                }

                if (fresnelEnabled)
                {
                    shaderIndex += 2;
                }

                if (specularEnabled)
                {
                    shaderIndex += 4;
                }

                if (oneLight)
                {
                    shaderIndex += 8;
                }

                shaderPass = pass.SubPasses[shaderIndex];

                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
            }

            return(base.OnApply(shaderPass));
        }
示例#8
0
 public void SwapProgram(string passName)
 {
     this._passName = passName;
     if (passName == null)
     {
         return;
     }
     this._effectPass = this.Shader.CurrentTechnique.Passes[passName];
 }
示例#9
0
        public void Initialize()
        {
            _worldViewProjParam = _shader.Parameters["WorldViewProj"];
            _globalColorParam   = _shader.Parameters["GlobalColor"];

            //Passes
            _vertexColorPass = _shader.Techniques["VertexColor"].Passes[0];
            _globalColorPass = _shader.Techniques["GlobalColor"].Passes[0];
        }
        /// <summary>
        /// Show shadows with help of our blur map shader
        /// </summary>
        public void RenderShadows()
        {
            // Only apply post screen blur if texture is valid and effect are valid
            if (sceneMapTexture == null ||
                Valid == false ||
                // If the shadow scene map is not yet filled, there is no point
                // continuing here ...
                sceneMapTexture.XnaTexture == null)
            {
                return;
            }

            // Don't use or write to the z buffer
            BaseGame.Device.DepthStencilState = DepthStencilState.None;
            // Disable alpha for the first pass
            BaseGame.Device.BlendState = BlendState.Opaque;

            if (windowSize != null)
            {
                windowSize.SetValue(
                    new float[] { sceneMapTexture.Width, sceneMapTexture.Height });
            }
            if (sceneMap != null)
            {
                sceneMap.SetValue(sceneMapTexture.XnaTexture);
            }

            effect.CurrentTechnique = effect.Techniques["ScreenAdvancedBlur20"];

            // We must have exactly 2 passes!
            if (effect.CurrentTechnique.Passes.Count != 2)
            {
                throw new InvalidOperationException(
                          "This shader should have exactly 2 passes!");
            }

            // Just start pass 0

            blurMapTexture.SetRenderTarget();

            EffectPass effectPass = effect.CurrentTechnique.Passes[0];

            effectPass.Apply();
            VBScreenHelper.Render();


            blurMapTexture.Resolve();
            BaseGame.ResetRenderTarget(false);

            // Restore z buffer state
            BaseGame.Device.DepthStencilState = DepthStencilState.Default;
            // Set u/v addressing back to wrap
            BaseGame.Device.SamplerStates[0] = SamplerState.LinearWrap;
            // Restore normal alpha blending
            //BaseGame.Device.RenderState.BlendFunction = BlendFunction.Add;
            BaseGame.SetCurrentAlphaMode(BaseGame.AlphaMode.Default);
        }
示例#11
0
        /// <summary>
        /// Read and create a SilverlightEffect
        /// </summary>
        protected override SilverlightEffect Read(ContentReader input, SilverlightEffect existingInstance)
        {
            int techniquesCount = input.ReadInt32();

            EffectTechnique[] techniques = new EffectTechnique[techniquesCount];

            for (int techniqueIndex = 0; techniqueIndex < techniquesCount; techniqueIndex++)
            {
                int          passesCount = input.ReadInt32();
                EffectPass[] passes      = new EffectPass[passesCount];

                for (int passIndex = 0; passIndex < passesCount; passIndex++)
                {
                    string passName = input.ReadString();

                    // Vertex shader
                    int    vertexShaderByteCodeLength   = input.ReadInt32();
                    byte[] vertexShaderByteCode         = input.ReadBytes(vertexShaderByteCodeLength);
                    int    vertexShaderParametersLength = input.ReadInt32();
                    byte[] vertexShaderParameters       = input.ReadBytes(vertexShaderParametersLength);

                    // Pixel shader
                    int    pixelShaderByteCodeLength   = input.ReadInt32();
                    byte[] pixelShaderByteCode         = input.ReadBytes(pixelShaderByteCodeLength);
                    int    pixelShaderParametersLength = input.ReadInt32();
                    byte[] pixelShaderParameters       = input.ReadBytes(pixelShaderParametersLength);

                    MemoryStream vertexShaderCodeStream       = new MemoryStream(vertexShaderByteCode);
                    MemoryStream pixelShaderCodeStream        = new MemoryStream(pixelShaderByteCode);
                    MemoryStream vertexShaderParametersStream = new MemoryStream(vertexShaderParameters);
                    MemoryStream pixelShaderParametersStream  = new MemoryStream(pixelShaderParameters);

                    // Instanciate pass
                    SilverlightEffectPass currentPass = new SilverlightEffectPass(passName, GraphicsDeviceManager.Current.GraphicsDevice, vertexShaderCodeStream, pixelShaderCodeStream, vertexShaderParametersStream, pixelShaderParametersStream);
                    passes[passIndex] = currentPass;

                    vertexShaderCodeStream.Dispose();
                    pixelShaderCodeStream.Dispose();
                    vertexShaderParametersStream.Dispose();
                    pixelShaderParametersStream.Dispose();

                    // Render states
                    int renderStatesCount = input.ReadInt32();

                    for (int renderStateIndex = 0; renderStateIndex < renderStatesCount; renderStateIndex++)
                    {
                        currentPass.AppendState(input.ReadString(), input.ReadString());
                    }
                }

                // Instanciate technique
                techniques[techniqueIndex] = new EffectTechnique(passes);
            }

            return(new SilverlightEffect(techniques));
        }
示例#12
0
		public override void LoadResources()
		{
			if (m_Disposed == true)
			{
				m_Effect = m_Effect = new Effect(GameEnvironment.Device, Bytecode); // Effect.FromFile(GameEnvironment.Device, Helper.ResolvePath(m_ShaderLocation), "fx_4_0", ShaderFlags.None, EffectFlags.None, null, null);
				m_Technique = m_Effect.GetTechniqueByName("Imposter");

				m_Pass_NoBlend = m_Technique.GetPassByName("NoBlend");
				m_Pass_OverlayAdd = m_Technique.GetPassByName("OverlayAdd");
				m_Pass_OverlaySubtract = m_Technique.GetPassByName("OverlaySubtract");
				m_Pass_OverlayInvert = m_Technique.GetPassByName("OverlayInvert");
				m_Pass_OverlayAlpha = m_Technique.GetPassByName("OverlayAlpha");

				m_Technique_BrightPass = m_Effect.GetTechniqueByName("Imposter_BrightPass");

				m_Pass_NoBlend_BrightPass = m_Technique_BrightPass.GetPassByName("NoBlend");
				m_Pass_OverlayAdd_BrightPass = m_Technique_BrightPass.GetPassByName("OverlayAdd");
				m_Pass_OverlaySubtract_BrightPass = m_Technique_BrightPass.GetPassByName("OverlaySubtract");
				m_Pass_OverlayAlpha_BrightPass = m_Technique_BrightPass.GetPassByName("OverlayAlpha");

				m_ImposterTextureResource = m_Effect.GetVariableByName("imposter").AsResource();

				m_BrightPassThreshold = m_Effect.GetVariableByName("brightPassThreshold").AsScalar();

				m_Layout = new InputLayout(GameEnvironment.Device, m_Pass_NoBlend.Description.Signature, new[] {
					new InputElement("POSITION", 0, Format.R32G32_Float, 0, 0),
					new InputElement("TEXCOORD", 0, Format.R32G32_Float, 8, 0)		
				});

				float minX = -1f, miny = -1f, maxX = 1f, maxY = 1f;

				using (DataStream stream = new DataStream(4 * Marshal.SizeOf(typeof(Vertex2D)), true, true))
				{
					stream.WriteRange(new Vertex2D[] {					
						new Vertex2D() { Position = new Vector2(maxX, miny), TextureCoords =  new Vector2(1.0f, 1.0f) }, 
						new Vertex2D() { Position = new Vector2(minX, miny), TextureCoords =  new Vector2(0.0f, 1.0f) }, 
						new Vertex2D() { Position = new Vector2(maxX, maxY), TextureCoords = new Vector2(1.0f, 0.0f) },  
						new Vertex2D() { Position = new Vector2(minX, maxY), TextureCoords =  new Vector2(0.0f, 0.0f) } 
					});
					stream.Position = 0;

					m_Vertices = new SlimDX.Direct3D11.Buffer(GameEnvironment.Device, stream, new BufferDescription()
					{
						BindFlags = BindFlags.VertexBuffer,
						CpuAccessFlags = CpuAccessFlags.None,
						OptionFlags = ResourceOptionFlags.None,
						SizeInBytes = 4 * Marshal.SizeOf(typeof(Vertex2D)),
						Usage = ResourceUsage.Default
					});
				}

				m_VerticesBindings = new VertexBufferBinding(m_Vertices, Marshal.SizeOf(typeof(Vertex2D)), 0);

				m_Disposed = false;
			}
		}
示例#13
0
        /// <summary>
        /// 描画時に呼び出されるスプライト処理
        /// </summary>
        /// <param name="totalTime"></param>
        /// <param name="elapsedTime"></param>
        /// <param name="render"></param>
        /// <param name="cbd"></param>
        /// <returns></returns>
        internal override int CallDrawingSprite(
            double totalTime,
            float elapsedTime,
            IMCSpriteRender render,
            MCCallBatchDrawing cbd
            )
        {
            MCVector3   pos          = new MCVector3();
            MCMatrix4x4 mWVP         = MCMatrix4x4.Identity;
            var         spriteRender = (MCRenderAlphanumericSprite)render;

            // 頂点値を更新
            spriteRender.VertexUpdate(this, out pos);

            // 位置の計算
            if (IsBillbord)
            {
                // ビルボードである(使用できない
                Debug.Assert(false);
            }
            else
            {
                MCMatrix4x4 mTmp = MCMatrix4x4.Identity;
                // 通常スプライト
                mTmp.MakeRotationYawPitchRoll(m_angle.Y, m_angle.X, m_angle.Z);


                // 位置
                mTmp.M41 += m_position.X;
                mTmp.M42 += m_position.Y;
                mTmp.M43 += m_position.Z;
                // スケール値
                mTmp.M11 *= m_scale.X; mTmp.M21 *= m_scale.Y;
                mTmp.M12 *= m_scale.X; mTmp.M22 *= m_scale.Y;
                mTmp.M13 *= m_scale.X; mTmp.M23 *= m_scale.Y;
                mTmp.M14 *= m_scale.X; mTmp.M24 *= m_scale.Y;

                mWVP = mTmp * cbd.GetCurrentCamera().ViewProjMatrix;
            }

            cbd.SetWVP(ref mWVP);
            cbd.SetUniqueValue(m_uniquetValue);
            Sprite.Texture00.SetResource(cbd.GetDiffuseTexture());

            EffectPass pass = cbd.GetEffect().GetCurrentEffectPass();

            App.LayoutMgr.IASetInputLayout(pass, (int)spriteRender.GetLayoutKind());
            pass.Apply(App.ImmediateContext);
            if (BlendState != (uint)BLENDSTATE.UNDEFINED)
            {
                App.BlendStateMgr.OMSetBlendState(BlendState);
            }
            spriteRender.Render(App.ImmediateContext, pass, this);

            return(0);
        }
示例#14
0
        /// <summary>
        /// Initializes a new instance of the <see cref="PrimitiveQuad" /> class.
        /// </summary>
        /// <param name="graphicsDevice">The graphics device.</param>
        public PrimitiveQuad(GraphicsDevice graphicsDevice)
        {
            GraphicsDevice = graphicsDevice;
            quadEffect = ToDispose(new Effect(GraphicsDevice, effectBytecode));
            quadPass = quadEffect.CurrentTechnique.Passes[0];
            matrixParameter = quadEffect.Parameters["MatrixTransform"];
            Transform = Matrix.Identity;

            sharedData = GraphicsDevice.GetOrCreateSharedData(SharedDataType.PerDevice, "Toolkit::PrimitiveQuad::VertexBuffer", () => new SharedData(GraphicsDevice));
        }
示例#15
0
 private void InitializeHiDef(IGraphicsService graphicsService)
 {
     _submesh = MeshHelper.GetBox(graphicsService);
     _effect  = graphicsService.Content.Load <Effect>("DigitalRune/Sky/Skybox");
     _parameterWorldViewProjection = _effect.Parameters["WorldViewProjection"];
     _parameterExposure            = _effect.Parameters["Color"];
     _textureParameter             = _effect.Parameters["Texture"];
     _passLinear = _effect.CurrentTechnique.Passes["SRgbToRgb"];
     _passGamma  = _effect.CurrentTechnique.Passes["SRgbToSRgb"];
 }
示例#16
0
        /// <summary>
        /// Draw a list of Lines.
        /// </summary>
        public void Draw(List <XnaLine2d> roundLines, Matrix viewProjMatrix,
                         float time, string techniqueName)
        {
            device.SetVertexBuffer(vb);
            device.Indices = ib;

            viewProjMatrixParameter.SetValue(viewProjMatrix);
            timeParameter.SetValue(time);

            blurThresholdParameter.SetValue(BlurThreshold);

            if (techniqueName == null)
            {
                effect.CurrentTechnique = effect.Techniques[0];
            }
            else
            {
                effect.CurrentTechnique = effect.Techniques[techniqueName];
            }
            EffectPass pass = effect.CurrentTechnique.Passes[0];

            pass.Apply();

            int iData = 0;
            int numInstancesThisDraw = 0;

            foreach (XnaLine2d roundLine in roundLines)
            {
                lineColorParameter.SetValue(roundLine.Color.ToVector4());
                lineRadiusParameter.SetValue(roundLine.Radius);

                translationData[iData++] = roundLine.StartPoint.X;
                translationData[iData++] = roundLine.StartPoint.Y;
                translationData[iData++] = roundLine.Length;
                translationData[iData++] = roundLine.Angle;
                numInstancesThisDraw++;

                if (numInstancesThisDraw == numInstances)
                {
                    instanceDataParameter.SetValue(translationData);
                    pass.Apply();
                    device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, numVertices, 0, numPrimitivesPerInstance * numInstancesThisDraw);
                    NumLinesDrawn       += numInstancesThisDraw;
                    numInstancesThisDraw = 0;
                    iData = 0;
                }
            }
            if (numInstancesThisDraw > 0)
            {
                instanceDataParameter.SetValue(translationData);
                pass.Apply();
                device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, numVertices, 0, numPrimitivesPerInstance * numInstancesThisDraw);
                NumLinesDrawn += numInstancesThisDraw;
            }
        }
示例#17
0
文件: EffectPass.cs 项目: Zeludon/FEZ
 internal EffectPass(Effect effect, EffectPass cloneSource)
 {
   this._effect = effect;
   this.Name = cloneSource.Name;
   this._blendState = cloneSource._blendState;
   this._depthStencilState = cloneSource._depthStencilState;
   this._rasterizerState = cloneSource._rasterizerState;
   this.Annotations = cloneSource.Annotations;
   this._vertexShader = cloneSource._vertexShader;
   this._pixelShader = cloneSource._pixelShader;
 }
示例#18
0
 protected virtual void SetupParamaters()
 {
     m_PassColor        = _effect.CurrentTechnique.Passes["UnlitColor"];
     m_PassTexture      = _effect.CurrentTechnique.Passes["UnlitTexture"];
     m_EPView           = _effect.Parameters["View"];
     m_EPProjection     = _effect.Parameters["Projection"];
     m_EPWorld          = _effect.Parameters["World"];
     m_EPTextureTilling = _effect.Parameters["TextureTilling"];
     m_EPDiffuseColor   = _effect.Parameters["DiffuseColor"];
     m_EPMainTexture    = _effect.Parameters["MainTexture"];
 }
示例#19
0
 //============================================================
 public void LoadFile(string fileName)
 {
     try{
         var bytecode = ShaderBytecode.CompileFromFile(fileName, "fx_5_0", ShaderFlags.None, EffectFlags.None);
         _nativeEffect = new Effect(_device.NativeAdapter, bytecode);
     }catch (System.Exception ex) {
         throw new FFatalException(ex);
     }
     _nativeTechnique = _nativeEffect.GetTechniqueByIndex(0);
     _nativePass      = _nativeTechnique.GetPassByIndex(0);
 }
示例#20
0
        public ShaderData(Effect shader, string passName)
        {
            _passName = passName;
            _shader   = shader;
            if (shader == null || passName == null)
            {
                return;
            }

            _effectPass = shader.CurrentTechnique.Passes[passName];
        }
示例#21
0
        private void DrawAllMeshes(EffectPass pass, bool passRenderOpaque)
        {
            _graphics.GraphicsDevice.DepthStencilState = passRenderOpaque ? DepthStencilState.Default : DepthStencilState.DepthRead;

            _shader.SetProjectionView(_camera.Projection);
            _shader.SetWorldView(_camera.World);
            _shader.SetModelViewIdentity();
            pass.Apply();

            Field.Render(_camera, _shader, pass, passRenderOpaque);
        }
示例#22
0
        }   // end of Sphere Render()

        /// <summary>
        /// Call drawprimitive for each pass on the effect. Doesn't set any effect parameters
        /// or technique.
        /// </summary>
        /// <param name="effect"></param>
        public void DrawPrim(Effect effect)
        {
            GraphicsDevice device = BokuGame.bokuGame.GraphicsDevice;

            for (int indexEffectPass = 0; indexEffectPass < effect.CurrentTechnique.Passes.Count; indexEffectPass++)
            {
                EffectPass pass = effect.CurrentTechnique.Passes[indexEffectPass];
                pass.Apply();
                device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, numVertices, 0, numTriangles);
            } // end loop over each pass.
        }     // end of DrawPrim()
示例#23
0
        public DeferredLightEffect() : base(Core.graphicsDevice, EffectResource.deferredLightBytes)
        {
            clearGBufferPass     = Techniques["ClearGBuffer"].Passes[0];
            pointLightPass       = Techniques["DeferredPointLight"].Passes[0];
            spotLightPass        = Techniques["DeferredSpotLight"].Passes[0];
            areaLightPass        = Techniques["DeferredAreaLight"].Passes[0];
            directionalLightPass = Techniques["DeferredDirectionalLight"].Passes[0];
            finalCombinePass     = Techniques["FinalCombine"].Passes[0];

            cacheEffectParameters();
        }
示例#24
0
 internal EffectPass(Effect effect, EffectPass cloneSource)
 {
     this._effect            = effect;
     this.Name               = cloneSource.Name;
     this._blendState        = cloneSource._blendState;
     this._depthStencilState = cloneSource._depthStencilState;
     this._rasterizerState   = cloneSource._rasterizerState;
     this.Annotations        = cloneSource.Annotations;
     this._vertexShader      = cloneSource._vertexShader;
     this._pixelShader       = cloneSource._pixelShader;
 }
示例#25
0
        protected internal virtual EffectPass OnApply(EffectPass pass)
        {
            var handler = OnApplyCallback;

            if (handler != null)
            {
                pass = handler(pass);
            }

            return(pass);
        }
示例#26
0
        /// <summary>
        /// Draws the specified effect pass onto the quad. The effect pass must have a pixel shader with the signature float2:TEXCOORD.
        /// </summary>
        /// <param name="effectPass">The effect pass.</param>
        public void Draw(EffectPass effectPass)
        {
            ResetShaderStages();

            // Apply the Effect pass
            effectPass.Apply();
            Draw();

            // Unapply this effect
            effectPass.UnApply();
        }
示例#27
0
        /// <summary>
        /// A filter that allows color grading by using Look up tables
        /// </summary>
        /// <param name="graphics"></param>
        /// <param name="content"></param>
        /// <param name="shaderPath">the relative shader path needed for the content manager to load. For example "Shaders/ColorGrading/Colorgrading"</param>
        public ColorGradingFilter(ContentManager content, string shaderPath)
        {
            _shaderEffect      = content.Load <Effect>(shaderPath);
            _sizeParam         = _shaderEffect.Parameters["Size"];
            _sizeRootParam     = _shaderEffect.Parameters["SizeRoot"];
            _inputTextureParam = _shaderEffect.Parameters["InputTexture"];
            _lutParam          = _shaderEffect.Parameters["LUT"];

            _applyLUTPass  = _shaderEffect.Techniques["ApplyLUT"].Passes[0];
            _createLUTPass = _shaderEffect.Techniques["CreateLUT"].Passes[0];
        }
        /// <summary>
        /// Draws the specified effect pass onto the quad. The effect pass must have a pixel shader with the signature float2:TEXCOORD.
        /// </summary>
        /// <param name="effectPass">The effect pass.</param>
        /// <param name="fullScreenTriangle">if set to <c>true</c> to draw an optimized full screen triangle as a full screen quad.</param>
        public void Draw(EffectPass effectPass, bool fullScreenTriangle = false)
        {
            ResetShaderStages();

            // Apply the Effect pass
            effectPass.Apply();
            Draw(fullScreenTriangle);

            // Unapply this effect
            effectPass.UnApply();
        }
示例#29
0
        //--------------------------------------------------------------
        #region Creation & Cleanup
        //--------------------------------------------------------------

        /// <summary>
        /// Initializes a new instance of the <see cref="FxaaFilter"/> class.
        /// </summary>
        /// <param name="graphicsService">The graphics service.</param>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="graphicsService"/> is <see langword="null"/>.
        /// </exception>
        public FxaaFilter(IGraphicsService graphicsService)
            : base(graphicsService)
        {
            _effect = GraphicsService.Content.Load <Effect>("DigitalRune/PostProcessing/FxaaFilter");
            _viewportSizeParameter  = _effect.Parameters["ViewportSize"];
            _sourceTextureParameter = _effect.Parameters["SourceTexture"];
            _luminanceToAlphaPass   = _effect.CurrentTechnique.Passes["LuminanceToAlpha"];
            _fxaaPass = _effect.CurrentTechnique.Passes["Fxaa"];

            ComputeLuminance = true;
        }
示例#30
0
        public DeferredLightEffect() : base(EffectResource.DeferredLightEffect)
        {
            clearGBufferPass     = Techniques["ClearGBuffer"].Passes[0];
            pointLightPass       = Techniques["DeferredPointLight"].Passes[0];
            spotLightPass        = Techniques["DeferredSpotLight"].Passes[0];
            areaLightPass        = Techniques["DeferredAreaLight"].Passes[0];
            directionalLightPass = Techniques["DeferredDirectionalLight"].Passes[0];
            finalCombinePass     = Techniques["FinalCombine"].Passes[0];

            CacheEffectParameters();
        }
示例#31
0
        public ColorGradingFilter(IRenderer renderer, SpriteBatch spriteBatch, Effect effect)
        {
            _renderer    = renderer;
            _spriteBatch = spriteBatch;

            _effect                = effect;
            _lutTextureParam       = _effect.Parameters["LutTexture"];
            _lutTextureWidthParam  = _effect.Parameters["LutWidth"];
            _lutTextureHeightParam = _effect.Parameters["LutHeight"];
            _effectPass            = _effect.CurrentTechnique.Passes[0];
        }
示例#32
0
        /// <summary>
        /// A filter that allows color grading by using Look up tables
        /// </summary>
        /// <param name="graphics"></param>
        /// <param name="content"></param>
        /// <param name="shaderPath">the relative shader path needed for the content manager to load. For example "Shaders/ColorGrading/Colorgrading"</param>
        public ColorGradingFilter(GraphicsDevice graphics, ContentManager content, string shaderPath)
        {
            _shaderEffect      = content.Load <Effect>(shaderPath);
            _sizeParam         = _shaderEffect.Parameters["Size"];
            _sizeRootParam     = _shaderEffect.Parameters["SizeRoot"];
            _inputTextureParam = _shaderEffect.Parameters["InputTexture"];
            _lutParam          = _shaderEffect.Parameters["LUT"];

            _applyLUTPass  = _shaderEffect.Techniques["ApplyLUT"].Passes[0];
            _createLUTPass = _shaderEffect.Techniques["CreateLUT"].Passes[0];
            _fsq           = new FullScreenQuadRenderer(graphics);
        }
示例#33
0
        public static void SetRenderTexture(this KingdomShader shader, EffectPass pass, IKingdomTexture texture)
        {
            if (shader.Texture0 != texture.Texture2D)
            {
                shader.Texture0 = texture.Texture2D;
                switch (texture.AddressU)
                {
                case ModelTexture.TextureWrapMode.Clamp:
                    shader.TextureRegionU   = KingdomShader.DefaultTextureRegion;
                    shader.TextureWrapModeU = TextureWrapMode.Clamp;
                    break;

                case ModelTexture.TextureWrapMode.Repeat:
                    shader.TextureRegionU   = KingdomShader.DefaultTextureRegion;
                    shader.TextureWrapModeU = TextureWrapMode.Repeat;
                    break;

                case ModelTexture.TextureWrapMode.RegionClamp:
                    shader.TextureRegionU   = texture.RegionU;
                    shader.TextureWrapModeU = TextureWrapMode.Clamp;
                    break;

                case ModelTexture.TextureWrapMode.RegionRepeat:
                    shader.TextureRegionU   = texture.RegionU;
                    shader.TextureWrapModeU = TextureWrapMode.Repeat;
                    break;
                }
                switch (texture.AddressV)
                {
                case ModelTexture.TextureWrapMode.Clamp:
                    shader.TextureRegionV   = KingdomShader.DefaultTextureRegion;
                    shader.TextureWrapModeV = TextureWrapMode.Clamp;
                    break;

                case ModelTexture.TextureWrapMode.Repeat:
                    shader.TextureRegionV   = KingdomShader.DefaultTextureRegion;
                    shader.TextureWrapModeV = TextureWrapMode.Repeat;
                    break;

                case ModelTexture.TextureWrapMode.RegionClamp:
                    shader.TextureRegionV   = texture.RegionV;
                    shader.TextureWrapModeV = TextureWrapMode.Clamp;
                    break;

                case ModelTexture.TextureWrapMode.RegionRepeat:
                    shader.TextureRegionV   = texture.RegionV;
                    shader.TextureWrapModeV = TextureWrapMode.Repeat;
                    break;
                }

                pass.Apply();
            }
        }
示例#34
0
        private void SetRenderTexture(EffectPass pass, KingdomTexture texture)
        {
            if (_shader.Texture0 != texture.Texture2D)
            {
                _shader.Texture0 = texture.Texture2D;
                switch (texture.ModelTexture.TextureAddressMode.AddressU)
                {
                case ModelTexture.TextureWrapMode.Clamp:
                    _shader.TextureRegionU   = KingdomShader.DefaultTextureRegion;
                    _shader.TextureWrapModeU = TextureWrapMode.Clamp;
                    break;

                case ModelTexture.TextureWrapMode.Repeat:
                    _shader.TextureRegionU   = KingdomShader.DefaultTextureRegion;
                    _shader.TextureWrapModeU = TextureWrapMode.Repeat;
                    break;

                case ModelTexture.TextureWrapMode.RegionClamp:
                    _shader.TextureRegionU   = texture.RegionU;
                    _shader.TextureWrapModeU = TextureWrapMode.Clamp;
                    break;

                case ModelTexture.TextureWrapMode.RegionRepeat:
                    _shader.TextureRegionU   = texture.RegionU;
                    _shader.TextureWrapModeU = TextureWrapMode.Repeat;
                    break;
                }
                switch (texture.ModelTexture.TextureAddressMode.AddressV)
                {
                case ModelTexture.TextureWrapMode.Clamp:
                    _shader.TextureRegionV   = KingdomShader.DefaultTextureRegion;
                    _shader.TextureWrapModeV = TextureWrapMode.Clamp;
                    break;

                case ModelTexture.TextureWrapMode.Repeat:
                    _shader.TextureRegionV   = KingdomShader.DefaultTextureRegion;
                    _shader.TextureWrapModeV = TextureWrapMode.Repeat;
                    break;

                case ModelTexture.TextureWrapMode.RegionClamp:
                    _shader.TextureRegionV   = texture.RegionV;
                    _shader.TextureWrapModeV = TextureWrapMode.Clamp;
                    break;

                case ModelTexture.TextureWrapMode.RegionRepeat:
                    _shader.TextureRegionV   = texture.RegionV;
                    _shader.TextureWrapModeV = TextureWrapMode.Repeat;
                    break;
                }

                pass.Apply();
            }
        }
        /// <summary>
        /// スプライトを描画する
        /// </summary>
        /// <param name="immediateContext">DeviceContextポインタ。</param>
        /// <param name="pass">EffectPassポインタ。</param>
        /// <param name="drawSprite">基本描画スプライト</param>
        /// <return>通常、エラーが発生しなかった場合は MC_S_OK を返す。</return>
        public int Render(DeviceContext immediateContext, EffectPass pass, MCDrawSpriteBase drawSprite)
        {
            int[] strides = new int[] { System.Runtime.InteropServices.Marshal.SizeOf(new MC_VERTEX_PCTx()) };
            int[] offsets = new int[] { 0 };
            SharpDX.Direct3D11.Buffer[] vertexBuffers = new SharpDX.Direct3D11.Buffer[] { m_vertexBuffer };

            immediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
            immediateContext.InputAssembler.SetVertexBuffers(0, vertexBuffers, strides, offsets);
            immediateContext.InputAssembler.SetIndexBuffer(m_indexBuffer, SharpDX.DXGI.Format.R16_UInt, 0);
            immediateContext.DrawIndexed(m_drawTriangleNum * 3, 0, 0);
            return(0);
        }
        public void Initialize()
        {
            _worldParam         = _shader.Parameters["World"];
            _worldViewProjParam = _shader.Parameters["WorldViewProj"];
            _worldViewITParam   = _shader.Parameters["WorldViewIT"];

            _albedoMapParameter      = _shader.Parameters["AlbedoMap"];
            _normalMapParameter      = _shader.Parameters["NormalMap"];
            _frustumCornersParameter = _shader.Parameters["FrustumCorners"];

            _pass1 = _shader.Techniques["Default"].Passes[0];
        }
示例#37
0
 public static void SetRenderTexture(this KingdomShader shader, EffectPass pass, Texture2D texture)
 {
     if (shader.Texture0 != texture)
     {
         shader.Texture0         = texture;
         shader.TextureRegionU   = KingdomShader.DefaultTextureRegion;
         shader.TextureRegionV   = KingdomShader.DefaultTextureRegion;
         shader.TextureWrapModeU = TextureWrapMode.Clamp;
         shader.TextureWrapModeV = TextureWrapMode.Clamp;
         pass.Apply();
     }
 }
示例#38
0
        public void Initialize()
        {
            _frustumCornersParam    = _shader.Parameters["FrustumCorners"];
            _cameraPositonParam     = _shader.Parameters["CameraPosition"];
            _depthMapParam          = _shader.Parameters["DepthMap"];
            _volumeTexParam         = _shader.Parameters["VolumeTex"];
            _volumeTexPositionParam = _shader.Parameters["VolumeTexPositionWS"];
            _volumeTexSizeParam     = _shader.Parameters["VolumeTexSize"];
            _volumeTexResolution    = _shader.Parameters["VolumeTexResolution"];

            _basicPass = _shader.Techniques["Basic"].Passes[0];
        }
示例#39
0
        public DebugRenderer( SlimDX.Direct3D11.Device device )
        {
            mEffect = EffectUtil.CompileEffect( device, @"Shaders\DebugRenderer.fx" );

            var positionInputElements = new[]
                                        {
                                            new InputElement( "POSITION", 0, POSITION_FORMAT, POSITION_SLOT )
                                        };

            var positionTexcoordInputElements = new[]
                                                {
                                                    new InputElement( "POSITION", 0, POSITION_FORMAT, POSITION_SLOT ),
                                                    new InputElement( "TEXCOORD", 0, TEXCOORD_FORMAT, TEXCOORD_SLOT )
                                                };

            EffectTechnique effectTechnique;

            effectTechnique = mEffect.GetTechniqueByName( "RenderWireframe" );
            mRenderWireframePass = effectTechnique.GetPassByName( "RenderWireframe" );

            effectTechnique = mEffect.GetTechniqueByName( "RenderSolid" );
            mRenderSolidPass = effectTechnique.GetPassByName( "RenderSolid" );

            effectTechnique = mEffect.GetTechniqueByName( "RenderTexture3D" );
            mRenderTexture3DPass = effectTechnique.GetPassByName( "RenderTexture3D" );

            effectTechnique = mEffect.GetTechniqueByName( "RenderGreyScaleTexture3D" );
            mRenderGreyScaleTexture3DPass = effectTechnique.GetPassByName( "RenderGreyScaleTexture3D" );

            mRenderWireframeInputLayout = new InputLayout( device, mRenderWireframePass.Description.Signature, positionInputElements );
            mRenderSolidInputLayout = new InputLayout( device, mRenderSolidPass.Description.Signature, positionInputElements );
            mRenderTexture3DInputLayout = new InputLayout( device, mRenderTexture3DPass.Description.Signature, positionTexcoordInputElements );
            mRenderGreyScaleTexture3DInputLayout = new InputLayout( device, mRenderGreyScaleTexture3DPass.Description.Signature, positionTexcoordInputElements );

            mPositionVertexBuffer = new SlimDX.Direct3D11.Buffer( device,
                                                                  null,
                                                                  NUM_VERTICES * POSITION_NUM_COMPONENTS_PER_VERTEX * POSITION_NUM_BYTES_PER_COMPONENT,
                                                                  ResourceUsage.Dynamic,
                                                                  BindFlags.VertexBuffer,
                                                                  CpuAccessFlags.Write,
                                                                  ResourceOptionFlags.None,
                                                                  0 );

            mTexCoordVertexBuffer = new SlimDX.Direct3D11.Buffer( device,
                                                                  null,
                                                                  NUM_VERTICES * TEXCOORD_NUM_COMPONENTS_PER_VERTEX * TEXCOORD_NUM_BYTES_PER_COMPONENT,
                                                                  ResourceUsage.Dynamic,
                                                                  BindFlags.VertexBuffer,
                                                                  CpuAccessFlags.Write,
                                                                  ResourceOptionFlags.None,
                                                                  0 );
        }
示例#40
0
 public bool ValidateLayout(EffectPass pass, out InputLayout layout)
 {
     layout = null;
     try
     {
         layout = new InputLayout(context.Device, pass.Description.Signature, this.InputLayout);
         return true;
     }
     catch
     {
         return false;
     }
 }
示例#41
0
		public override void LoadResources()
		{
			if (m_Disposed == true)
			{
				m_Effect = new Effect(GameEnvironment.Device, Bytecode); // Helper.ResolvePath(m_ShaderLocation), "fx_4_0", ShaderFlags.None, EffectFlags.None, null, null);
				m_Technique = m_Effect.GetTechniqueByName("BlurBilinear");

				m_Pass_Gaussian = m_Technique.GetPassByName("Gaussian");

				m_SourceTex = m_Effect.GetVariableByName("g_SourceTex").AsResource();
				m_GWeights = m_Effect.GetVariableByName("g_GWeights").AsScalar();

				//m_ElementCount = 1 + GAUSSIAN_MAX_SAMPLES;
				m_DataStride = Marshal.SizeOf(typeof(Vector2)) * (1 + GAUSSIAN_MAX_SAMPLES);

				InputElement[] IADesc = new InputElement[1 + (GAUSSIAN_MAX_SAMPLES / 2)];

				IADesc[0] = new InputElement()
				{
					SemanticName = "POSITION",
					SemanticIndex = 0,
					AlignedByteOffset = 0,
					Slot = 0,
					Classification = InputClassification.PerVertexData,
					Format = Format.R32G32_Float
				};


				for (int i = 1; i < 1 + (GAUSSIAN_MAX_SAMPLES / 2); i++)
				{
					IADesc[i] = new InputElement()
					{
						SemanticName = "TEXCOORD",
						SemanticIndex = i - 1,
						AlignedByteOffset = 8 + (i - 1) * 16,
						Slot = 0,
						Classification = InputClassification.PerVertexData,
						Format = Format.R32G32B32A32_Float
					};
				}

				// Real number of "sematinc based" elements
				//m_ElementCount = 1 + GAUSSIAN_MAX_SAMPLES / 2;

				EffectPassDescription PassDesc = m_Pass_Gaussian.Description;
				m_Layout = new InputLayout(GameEnvironment.Device, PassDesc.Signature, IADesc);

				m_Disposed = false;
			}
		}
 public UserInterfaceRenderCommand(Renderer renderer, Hud hud, RenderableNode rNode)
     : base(renderer, new UIMaterial(),
         new RenderableCollection(UIMaterial.ItemsDescription, new [] {rNode}))
 {
     CommandType = CommandType.UserInterfaceRenderCommand;
     CommandAttributes |= Graphics.CommandAttributes.MonoRendering;
     this.hud = hud;
     textMaterial = new TextMaterial();
     this.rNode = rNode;
     this.rNode.RenderableObject.Material = Material;
     tNode = (TransformNode)rNode.Parent;
     UpdateSprites(hud.SpriteControls);
     textTechnique = textMaterial.EffectDescription.Technique;
     textPass = textTechnique.GetPassByIndex(textMaterial.EffectDescription.Pass);
     textLayout = new InputLayout(Game.Context.Device, textPass.Description.Signature,
         TextItems.Description.InputElements);
 }
示例#43
0
        /// <summary>
        /// Initializes a new instance of the <see cref="PrimitiveQuad" /> class.
        /// </summary>
        /// <param name="graphicsDevice">The graphics device.</param>
        public PrimitiveQuad(GraphicsDevice graphicsDevice)
        {
            GraphicsDevice = graphicsDevice;
            quadEffect = ToDispose(new Effect(GraphicsDevice, effectBytecode));
            quadPass = quadEffect.CurrentTechnique.Passes[0];
            matrixParameter = quadEffect.Parameters["MatrixTransform"];

            textureCopyPass = quadEffect.CurrentTechnique.Passes[1];
            textureParameter = quadEffect.Parameters["Texture"];
            textureSamplerParameter = quadEffect.Parameters["TextureSampler"];

            // Default LinearClamp
            textureSamplerParameter.SetResource(GraphicsDevice.SamplerStates.LinearClamp);

            Transform = Matrix.Identity;

            sharedData = GraphicsDevice.GetOrCreateSharedData(SharedDataType.PerDevice, "Toolkit::PrimitiveQuad::VertexBuffer", () => new SharedData(GraphicsDevice));
        }
        public AdjustSegmentationRenderingStrategy( SlimDX.Direct3D11.Device device, DeviceContext deviceContext, TileManager tileManager )
        {
            mTileManager = tileManager;
            mDebugRenderer = new DebugRenderer( device );

            mEffect = EffectUtil.CompileEffect( device, @"Shaders\AdjustRenderer2D.fx" );

            var positionTexcoordInputElements = new[]
                                                {
                                                    new InputElement( "POSITION", 0, POSITION_FORMAT, POSITION_SLOT ),
                                                    new InputElement( "TEXCOORD", 0, TEXCOORD_FORMAT, TEXCOORD_SLOT )
                                                };

            EffectTechnique effectTechnique = mEffect.GetTechniqueByName( "TileManager2D" );
            mPass = effectTechnique.GetPassByName( "TileManager2D" );

            mInputLayout = new InputLayout( device, mPass.Description.Signature, positionTexcoordInputElements );

            mPositionVertexBuffer = new Buffer( device,
                                                null,
                                                QUAD_NUM_VERTICES * POSITION_NUM_COMPONENTS_PER_VERTEX * POSITION_NUM_BYTES_PER_COMPONENT,
                                                ResourceUsage.Dynamic,
                                                BindFlags.VertexBuffer,
                                                CpuAccessFlags.Write,
                                                ResourceOptionFlags.None,
                                                0 );

            mTexCoordVertexBuffer = new Buffer( device,
                                                null,
                                                QUAD_NUM_VERTICES * TEXCOORD_NUM_COMPONENTS_PER_VERTEX * TEXCOORD_NUM_BYTES_PER_COMPONENT,
                                                ResourceUsage.Dynamic,
                                                BindFlags.VertexBuffer,
                                                CpuAccessFlags.Write,
                                                ResourceOptionFlags.None,
                                                0 );

            //bool result;
            //mTinyTextContext = new Context( device, deviceContext, Constants.MAX_NUM_TINY_TEXT_CHARACTERS, out result );
            //Release.Assert( result );

            mStopwatch.Start();
        }
示例#45
0
        public Visualizer( D3D10Wrapper d3d, EffectManager effectManager )
        {
            rootItemTree = new ItemTree( "root" );

            this.d3d = d3d;
            
            streamState = new VisualizerStreamState();
            textureVertexBuffer = new DynamicVertexBuffer( VertexPosition4fColor4f.SizeInBytes, 6 );
            var stream = textureVertexBuffer.MapForWriteDiscard();
            stream.Write( new Vector4f( 0, 0, 0, 1 ) );
            stream.Write( new Vector4f( 0, 1, 0, 1 ) );
            stream.Write( new Vector4f( 1, 0, 0, 1 ) );
            stream.Write( new Vector4f( 1, 1, 0, 1 ) );
            stream.Write( new Vector4f( 0, 1, 0, 1 ) );
            stream.Write( new Vector4f( 0, 0, 0, 1 ) );

            stream.Write( new Vector4f( 0, 1, 0, 1 ) );
            stream.Write( new Vector4f( 0, 0, 0, 1 ) );
            stream.Write( new Vector4f( 1, 0, 0, 1 ) );
            stream.Write( new Vector4f( 1, 1, 0, 1 ) );
            stream.Write( new Vector4f( 1, 1, 0, 1 ) );
            stream.Write( new Vector4f( 1, 0, 0, 1 ) );
            textureVertexBuffer.Unmap();

            effect = effectManager[ "visualizer.fx" ];

            opaquePass = effectManager[ "visualizer.fx", "renderOpaque", "p0" ];
            opaquePassLayout = new InputLayout( d3d.Device, opaquePass.Description.Signature, VertexPosition4fColor4f.InputElements );

            alphaPass = effectManager[ "visualizer.fx", "renderAlpha", "p0" ];
            alphaPassLayout = new InputLayout( d3d.Device, alphaPass.Description.Signature, VertexPosition4fColor4f.InputElements );

            additivePass = effectManager[ "visualizer.fx", "renderAdditive", "p0" ];
            additivePassLayout = new InputLayout( d3d.Device, additivePass.Description.Signature, VertexPosition4fColor4f.InputElements );
            
            opaqueTexturePass = effect.GetTechniqueByName( "renderTexOpaque" ).GetPassByName( "p0" );
            opaqueTexturePassLayout = new InputLayout( d3d.Device, opaqueTexturePass.Description.Signature, VertexPosition4fTexture4f.InputElements );

            alphaTexturePass = effect.GetTechniqueByName( "renderTexAlpha" ).GetPassByName( "p0" );
            alphaTexturePassLayout = new InputLayout( d3d.Device, alphaTexturePass.Description.Signature, VertexPosition4fTexture4f.InputElements );
        }
示例#46
0
        public void DrawBasic(DeviceContext dc, EffectPass effectPass, Matrix viewProj)
        {
            var world = World;
            var wit = MathF.InverseTranspose(world);
            var wvp = world * viewProj;

            Effects.BasicFX.SetWorld(world);
            Effects.BasicFX.SetWorldInvTranspose(wit);
            Effects.BasicFX.SetWorldViewProj(wvp);
            Effects.BasicFX.SetWorldViewProjTex(wvp * ToTexSpace);
            Effects.BasicFX.SetTexTransform(TexTransform);
            Effects.BasicFX.SetShadowTransform(world*ShadowTransform);

            for (int i = 0; i < Model.SubsetCount; i++) {
                Effects.BasicFX.SetMaterial(Model.Materials[i]);
                Effects.BasicFX.SetDiffuseMap(Model.DiffuseMapSRV[i]);

                effectPass.Apply(dc);
                Model.ModelMesh.Draw(dc, i);
            }
        }
示例#47
0
		public override void LoadResources()
		{
			if (m_Disposed == true)
			{
				m_Effect = m_Effect = new Effect(GameEnvironment.Device, Bytecode); // Effect.FromFile(GameEnvironment.Device, Helper.ResolvePath(m_ShaderLocation), "fx_4_0", ShaderFlags.Debug | ShaderFlags.EnableStrictness, EffectFlags.None, null, null);
				m_Technique = m_Effect.GetTechniqueByName("Render");
				m_Pass0 = m_Technique.GetPassByName("P0");

				/*m_Layout = new InputLayout(GameEnvironment.Device, m_Pass0.Description.Signature, new[] {
					new InputElement( "POSITION", 0, Format.R32G32B32_Float, 0, 0, InputClassification.PerVertexData, 0),
					new InputElement( "NORMAL", 0, Format.R32G32B32_Float, 0, 12, InputClassification.PerVertexData, 0),
					new InputElement( "TEXCOORD", 0, Format.R32G32_Float, 0, 24, InputClassification.PerVertexData, 0),
				});*/

				m_Layout = new InputLayout(GameEnvironment.Device, m_Pass0.Description.Signature, new[] {
					new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
					new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0),
					new InputElement("TEXCOORD", 0, Format.R32G32_Float, 24, 0)
				});

				//texColorMap
				//texNormalMap
				//texDiffuseMap
				//texSpecularMap

				//m_DiffuseVariable = m_Effect.GetVariableByName("g_txDiffuse").AsResource();
				m_DiffuseVariable = m_Effect.GetVariableByName("texColorMap").AsResource();
				m_NormalMapVariable = m_Effect.GetVariableByName("texNormalMap").AsResource();
				m_WorldVariable = m_Effect.GetVariableByName("World").AsMatrix();
				m_ViewVariable = m_Effect.GetVariableByName("View").AsMatrix();
				m_InvViewVariable = m_Effect.GetVariableByName("InvView").AsMatrix();
				m_ProjectionVariable = m_Effect.GetVariableByName("Projection").AsMatrix();
				//m_SpecularMapVariable = m_Effect.GetVariableByName("g_txEnvMap").AsResource();
				m_SpecularMapVariable = m_Effect.GetVariableByName("texSpecularMap").AsResource();
				m_DiffuseMapVariable = m_Effect.GetVariableByName("texDiffuseMap").AsResource();
				m_EyeVariable = m_Effect.GetVariableByName("Eye").AsVector();

				m_Disposed = false;
			}
		}
示例#48
0
        public void Draw(DeviceContext dc, Matrix viewProj, EffectPass pass)
        {
            var world = World;
            var wit = MathF.InverseTranspose(world);
            var wvp = world * viewProj;

            Effects.NormalMapFX.SetWorld(world);
            Effects.NormalMapFX.SetWorldInvTranspose(wit);
            Effects.NormalMapFX.SetWorldViewProj(wvp);
            Effects.NormalMapFX.SetTexTransform(Matrix.Identity);

            Effects.NormalMapFX.SetBoneTransforms(FinalTransforms);

            for (int i = 0; i < _model.SubsetCount; i++) {
                Effects.NormalMapFX.SetMaterial(_model.Materials[i]);
                Effects.NormalMapFX.SetDiffuseMap(_model.DiffuseMapSRV[i]);
                Effects.NormalMapFX.SetNormalMap(_model.NormalMapSRV[i]);

                pass.Apply(dc);
                _model.ModelMesh.Draw(dc, i);
            }
        }
示例#49
0
 public void ApplyPass(EffectPass pass)
 {
     pass.Apply(this.context.CurrentDeviceContext);
     this.ApplyCounterUAVS();
 }
示例#50
0
        /// <summary>
        /// Lazily computes derived parameter values immediately before applying the effect.
        /// </summary>
        protected internal override EffectPass OnApply(EffectPass pass)
        {
            // Recompute the world+view+projection matrix or fog vector?
            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);
            
            // Recompute the diffuse/emissive/alpha material color parameters?
            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
            {
                EffectHelpers.SetMaterialColor(lightingEnabled, alpha, ref diffuseColor, ref emissiveColor, ref ambientLightColor, diffuseColorParam, emissiveColorParam);

                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
            }

            if (lightingEnabled)
            {
                // Recompute the world inverse transpose and eye position?
                dirtyFlags = EffectHelpers.SetLightingMatrices(dirtyFlags, ref world, ref view, worldParam, worldInverseTransposeParam, eyePositionParam);
                
                // Check if we can use the only-bother-with-the-first-light shader optimization.
                bool newOneLight = !light1.Enabled && !light2.Enabled;
                
                if (oneLight != newOneLight)
                {
                    oneLight = newOneLight;
                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
                }
            }

            // Recompute the shader index?
            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
            {
                int shaderIndex = 0;
                
                if (!fogEnabled)
                    shaderIndex += 1;
                
                if (vertexColorEnabled)
                    shaderIndex += 2;
                
                if (textureEnabled)
                    shaderIndex += 4;

                if (lightingEnabled)
                {
                    if (preferPerPixelLighting)
                        shaderIndex += 24;
                    else if (oneLight)
                        shaderIndex += 16;
                    else
                        shaderIndex += 8;
                }

                shaderPass = pass.SubPasses[shaderIndex];

                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
            }

            // Call the base class to process callbacks
            pass = base.OnApply(shaderPass);

            return pass;
        }
示例#51
0
        /// <summary>
        /// Lazily computes derived parameter values immediately before applying the effect.
        /// </summary>
        protected internal override EffectPass OnApply(EffectPass pass)
        {
            // Recompute the world+view+projection matrix or fog vector?
            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);

            // Recompute the diffuse/alpha material color parameter?
            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
            {
                diffuseColorParam.SetValue(new Vector4(diffuseColor * alpha, alpha));

                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
            }

            // Recompute the shader index?
            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
            {
                int shaderIndex = 0;
                
                if (!fogEnabled)
                    shaderIndex += 1;
                
                if (vertexColorEnabled)
                    shaderIndex += 2;

                shaderPass = pass.SubPasses[shaderIndex];

                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
            }

            return base.OnApply(shaderPass);
        }
示例#52
0
        /// <summary>
        /// Draws the specified effect pass onto the quad. The effect pass must have a pixel shader with the signature float2:TEXCOORD.
        /// </summary>
        /// <param name="effectPass">The effect pass.</param>
        /// <param name="fullScreenTriangle">if set to <c>true</c> to draw an optimized full screen triangle as a full screen quad.</param>
        public void Draw(EffectPass effectPass, bool fullScreenTriangle = false)
        {
            ResetShaderStages();

            // Apply the Effect pass
            effectPass.Apply();
            Draw(fullScreenTriangle);

            // Unapply this effect
            effectPass.UnApply();
        }
示例#53
0
        public void SetSourceCode(string extendedSourceCode)
        {
            string shaderCode = File.ReadAllText(renderer.Directory + "\\Resources\\Teapot.fx");

            try
            {
                using (ShaderBytecode bytecode = ShaderBytecode.Compile(extendedSourceCode + shaderCode, null, "fx_5_0", ShaderFlags.None, EffectFlags.None))
                {
                    effect = new Effect(renderingDevice, bytecode);
                }
            }
            catch (CompilationException ex)
            {
                System.Diagnostics.Debug.Write(ex.Message);
                return;
            }

            effectViewProjection = effect.GetVariableByName("matViewProjection").AsMatrix();
            effectCameraPositionWorld = effect.GetVariableByName("cameraPositionWorld").AsVector();

            technique = effect.GetTechniqueByIndex(0);
            pass = technique.GetPassByIndex(0);

            ShaderSignature signature = pass.Description.Signature;

            inputLayout = new InputLayout(renderingDevice, signature, new[] {
				new InputElement("POSITION", 0, SlimDX.DXGI.Format.R32G32B32_Float, 0, 0),
				new InputElement("NORMAL", 0, SlimDX.DXGI.Format.R32G32B32_Float, 12, 0) 
			});
        }
示例#54
0
        ///// <summary>
        ///// Creates a new AlphaTestEffect by cloning parameter settings from an existing instance.
        ///// </summary>
        //protected AlphaTestEffect(AlphaTestEffect cloneSource)
        //    : base(cloneSource)
        //{
        //    fogEnabled = cloneSource.fogEnabled;
        //    vertexColorEnabled = cloneSource.vertexColorEnabled;

        //    world = cloneSource.world;
        //    view = cloneSource.view;
        //    projection = cloneSource.projection;

        //    diffuseColor = cloneSource.diffuseColor;

        //    alpha = cloneSource.alpha;

        //    fogStart = cloneSource.fogStart;
        //    fogEnd = cloneSource.fogEnd;
            
        //    alphaFunction = cloneSource.alphaFunction;
        //    referenceAlpha = cloneSource.referenceAlpha;
        //}


        ///// <summary>
        ///// Creates a clone of the current AlphaTestEffect instance.
        ///// </summary>
        //public override Effect Clone()
        //{
        //    return new AlphaTestEffect(this);
        //}

        /// <summary>
        /// Lazily computes derived parameter values immediately before applying the effect.
        /// </summary>
        protected internal override EffectPass OnApply(EffectPass pass)
        {
            // Recompute the world+view+projection matrix or fog vector?
            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);

            // Recompute the diffuse/alpha material color parameter?
            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
            {
                diffuseColorParam.SetValue(new Vector4(diffuseColor * alpha, alpha));

                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
            }

            // Recompute the alpha test settings?
            if ((dirtyFlags & EffectDirtyFlags.AlphaTest) != 0)
            {
                var alphaTest = new Vector4();
                bool eqNe = false;
                
                // Convert reference alpha from 8 bit integer to 0-1 float format.
                float reference = (float)referenceAlpha / 255f;
                
                // Comparison tolerance of half the 8 bit integer precision.
                const float threshold = 0.5f / 255f;
                
                switch (alphaFunction)
                {
                    case Direct3D11.Comparison.Less:
                        // Shader will evaluate: clip((a < x) ? z : w)
                        alphaTest.X = reference - threshold;
                        alphaTest.Z = 1;
                        alphaTest.W = -1;
                        break;

                    case Direct3D11.Comparison.LessEqual:
                        // Shader will evaluate: clip((a < x) ? z : w)
                        alphaTest.X = reference + threshold;
                        alphaTest.Z = 1;
                        alphaTest.W = -1;
                        break;

                    case Direct3D11.Comparison.GreaterEqual:
                        // Shader will evaluate: clip((a < x) ? z : w)
                        alphaTest.X = reference - threshold;
                        alphaTest.Z = -1;
                        alphaTest.W = 1;
                        break;

                    case Direct3D11.Comparison.Greater:
                        // Shader will evaluate: clip((a < x) ? z : w)
                        alphaTest.X = reference + threshold;
                        alphaTest.Z = -1;
                        alphaTest.W = 1;
                        break;

                    case Direct3D11.Comparison.Equal:
                        // Shader will evaluate: clip((abs(a - x) < Y) ? z : w)
                        alphaTest.X = reference;
                        alphaTest.Y = threshold;
                        alphaTest.Z = 1;
                        alphaTest.W = -1;
                        eqNe = true;
                        break;

                    case Direct3D11.Comparison.NotEqual:
                        // Shader will evaluate: clip((abs(a - x) < Y) ? z : w)
                        alphaTest.X = reference;
                        alphaTest.Y = threshold;
                        alphaTest.Z = -1;
                        alphaTest.W = 1;
                        eqNe = true;
                        break;

                    case Direct3D11.Comparison.Never:
                        // Shader will evaluate: clip((a < x) ? z : w)
                        alphaTest.Z = -1;
                        alphaTest.W = -1;
                        break;

                    case Direct3D11.Comparison.Always:
                    default:
                        // Shader will evaluate: clip((a < x) ? z : w)
                        alphaTest.Z = 1;
                        alphaTest.W = 1;
                        break;
                }
                
                alphaTestParam.SetValue(alphaTest);

                dirtyFlags &= ~EffectDirtyFlags.AlphaTest;
                
                // If we changed between less/greater vs. equal/notequal
                // compare modes, we must also update the shader index.
                if (isEqNe != eqNe)
                {
                    isEqNe = eqNe;
                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
                }
            }

            // Recompute the shader index?
            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
            {
                int shaderIndex = 0;
                
                if (!fogEnabled)
                    shaderIndex += 1;
                
                if (vertexColorEnabled)
                    shaderIndex += 2;
                
                if (isEqNe)
                    shaderIndex += 4;

                shaderPass = pass.SubPasses[shaderIndex];

                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
            }

            return base.OnApply(shaderPass);
        }
示例#55
0
        private void LoadEffect(string shaderFileName = @"Assets\light.fx")
        {
            _effect = Effect.FromFile(_dxDevice, shaderFileName, "fx_4_0", ShaderFlags.None, EffectFlags.None, null, null);
            _technique = _effect.GetTechniqueByName("Render"); //C++ Comparaison// technique = effect->GetTechniqueByName( "Render" );
            _effectPass = _technique.GetPassByIndex(0);

            ShaderSignature signature = _effectPass.Description.Signature;
            _inputLayout = new InputLayout(_dxDevice, signature,
                new[] {
                    new InputElement("POSITION", 0, SlimDX.DXGI.Format.R32G32B32A32_Float, 0, 0),
                    new InputElement("NORMAL", 0, SlimDX.DXGI.Format.R32G32B32A32_Float, 16, 0),
                    new InputElement("TEXCOORD", 0, SlimDX.DXGI.Format.R32G32_Float, 32, 0)
                });
        }
示例#56
0
 private void UpdateTechnique()
 {
     this.technique = this.shaderinstance.Effect.GetTechniqueByIndex(this.techid);
     this.pass = this.technique.GetPassByIndex(this.passid);
 }
示例#57
0
        /// <summary>
        /// Draws the specified effect pass onto the quad. The effect pass must have a pixel shader with the signature float2:TEXCOORD.
        /// </summary>
        /// <param name="effectPass">The effect pass.</param>
        public void Draw(EffectPass effectPass)
        {
            ResetShaderStages();

            // Apply the Effect pass
            effectPass.Apply();
            Draw();

            // Unapply this effect
            effectPass.UnApply();
        }
示例#58
0
        public ImageShaderPass(EffectPass pd)
        {
            this.Mips = false;
            this.CustomFormat = false;
            this.Scale = 1.0f;
            this.DoScale = false;
            this.Reference = eImageScaleReference.Previous;

            this.ComputeData = new ImageComputeData(pd);

            EffectVariable var = pd.GetAnnotationByName("format");
            if (var.IsValid)
            {
                string fmt = var.AsString().GetString();
                this.CustomFormat = true;
                this.Format = (SlimDX.DXGI.Format)Enum.Parse(typeof(SlimDX.DXGI.Format), fmt, true);
            }

            var = pd.GetAnnotationByName("mips");
            if (var.IsValid)
            {
                bool b = var.AsScalar().GetFloat() > 0.5f;
                this.Mips = b;
            }

            var = pd.GetAnnotationByName("scale");
            if (var.IsValid)
            {
                this.Scale = var.AsScalar().GetFloat();
                this.DoScale = true;
            }

            var = pd.GetAnnotationByName("initial");
            if (var.IsValid)
            {
                bool b = var.AsScalar().GetFloat() > 0.5f;
                this.Reference = b ? eImageScaleReference.Initial : eImageScaleReference.Previous;
            }
        }
 public ImageComputeData(EffectPass pass)
 {
     this.Enabled = pass.ComputeShaderDescription.Variable.IsValid;
     this.tX = pass.GetIntAnnotation("tx", 1);
     this.tY = pass.GetIntAnnotation("ty", 1);
     this.tZ = pass.GetIntAnnotation("tz", 1);
 }
        public ImageShaderPass(EffectPass pd)
        {
            this.Mips = false;
            this.CustomFormat = false;
            this.ScaleVector = new Vector2(1, 1);
            this.DoScale = false;
            this.Reference = eImageScaleReference.Previous;
            this.BlendPreset = "";
            this.DepthPreset = "";
            this.UseDepth = false;
            this.HasState = false;
            this.KeepTarget = false;
            this.Absolute = false;

            this.ComputeData = new ImageComputeData(pd);

            EffectVariable var = pd.GetAnnotationByName("format");
            if (var.IsValid)
            {
                string fmt = var.AsString().GetString();
                this.CustomFormat = true;
                this.Format = (SlimDX.DXGI.Format)Enum.Parse(typeof(SlimDX.DXGI.Format), fmt, true);
            }

            var = pd.GetAnnotationByName("mips");
            if (var.IsValid)
            {
                bool b = var.AsScalar().GetFloat() > 0.5f;
                this.Mips = b;
            }

            var = pd.GetAnnotationByName("scale");
            if (var.IsValid)
            {
                if (var.GetVariableType().Description.Class == ShaderVariableClass.Scalar)
                {
                    float s = var.AsScalar().GetFloat();
                    this.ScaleVector = new Vector2(s, s);
                    this.DoScale = true;
                }
                if (var.GetVariableType().Description.Class == ShaderVariableClass.Vector)
                {
                    Vector4 s = var.AsVector().GetVector();
                    this.ScaleVector = new Vector2(s.X, s.Y);
                    this.DoScale = true;
                }
                var = pd.GetAnnotationByName("absolute");
                if (var.IsValid && var.GetVariableType().Description.Class == ShaderVariableClass.Scalar)
                {
                    this.Absolute = var.AsScalar().GetFloat() > 0.5f;
                }

            }

            var = pd.GetAnnotationByName("initial");
            if (var.IsValid)
            {
                bool b = var.AsScalar().GetFloat() > 0.5f;
                this.Reference = b ? eImageScaleReference.Initial : eImageScaleReference.Previous;
            }

            var = pd.GetAnnotationByName("clear");
            if (var.IsValid)
            {
                bool b = var.AsScalar().GetFloat() > 0.5f;
                this.Clear = b;
            }

            var = pd.GetAnnotationByName("usedepth");
            if (var.IsValid)
            {
                bool b = var.AsScalar().GetFloat() > 0.5f;
                this.UseDepth = b;
            }

            var = pd.GetAnnotationByName("keeptarget");
            if (var.IsValid)
            {
                bool b = var.AsScalar().GetFloat() > 0.5f;
                this.KeepTarget = b;
            }

            var = pd.GetAnnotationByName("hasstate");
            if (var.IsValid)
            {
                bool b = var.AsScalar().GetFloat() > 0.5f;
                this.HasState = b;
            }

            var = pd.GetAnnotationByName("blendpreset");
            if (var.IsValid)
            {
                string blend = var.AsString().GetString();
                this.BlendPreset = blend;
            }

            var = pd.GetAnnotationByName("depthpreset");
            if (var.IsValid)
            {
                string depth = var.AsString().GetString();
                this.DepthPreset = depth;
            }
        }