Ejemplo n.º 1
0
 private void FinishMaterial(BatchInfo material)
 {
     //DrawTechnique tech = material.Technique.Res;
     this.SetupBlendType(BlendMode.Reset);
     NativeShaderProgram.Bind(null);
     NativeTexture.ResetBinding(this.sharedSamplerBindings);
 }
Ejemplo n.º 2
0
        /// <summary>
        /// Applies the specified parameter values to all currently active shaders.
        /// </summary>
        /// <param name="sharedParams"></param>
        /// <seealso cref="RetrieveActiveShaders"/>
        private void SetupSharedParameters(ShaderParameterCollection sharedParams)
        {
            this.sharedSamplerBindings = 0;
            this.sharedShaderParameters.Clear();
            if (sharedParams == null)
            {
                return;
            }

            foreach (NativeShaderProgram shader in this.activeShaders)
            {
                NativeShaderProgram.Bind(shader);

                ShaderFieldInfo[] varInfo   = shader.Fields;
                int[]             locations = shader.FieldLocations;

                // Setup shared sampler bindings and uniform data
                for (int i = 0; i < varInfo.Length; i++)
                {
                    ref ShaderFieldInfo field = ref varInfo[i];

                    if (field.Scope == ShaderFieldScope.Attribute)
                    {
                        continue;
                    }
                    if (field.Type == ShaderFieldType.Sampler2D)
                    {
                        ContentRef <Texture> texRef;
                        if (!sharedParams.TryGetInternal(field.Name, out texRef))
                        {
                            continue;
                        }

                        NativeTexture.Bind(texRef, this.sharedSamplerBindings);
                        GL.Uniform1(locations[i], this.sharedSamplerBindings);

                        this.sharedSamplerBindings++;
                    }
                    else
                    {
                        float[] data;
                        if (!sharedParams.TryGetInternal(field.Name, out data))
                        {
                            continue;
                        }

                        NativeShaderProgram.SetUniform(ref field, locations[i], data);
                    }

                    this.sharedShaderParameters.Add(field.Name);
                }
            }
Ejemplo n.º 3
0
        private void SetupMaterial(BatchInfo material, BatchInfo lastMaterial)
        {
            if (material == lastMaterial)
            {
                return;
            }
            DrawTechnique tech     = material.Technique.Res ?? DrawTechnique.Solid.Res;
            DrawTechnique lastTech = lastMaterial != null ? lastMaterial.Technique.Res : null;

            // Setup BlendType
            if (lastTech == null || tech.Blending != lastTech.Blending)
            {
                this.SetupBlendType(tech.Blending, this.currentDevice.DepthWrite);
            }

            // Bind Shader
            ShaderProgram       shader       = tech.Shader.Res ?? ShaderProgram.Minimal.Res;
            NativeShaderProgram nativeShader = shader.Native as NativeShaderProgram;

            NativeShaderProgram.Bind(nativeShader);

            // Setup shader data
            ShaderFieldInfo[] varInfo   = nativeShader.Fields;
            int[]             locations = nativeShader.FieldLocations;

            // Setup sampler bindings automatically
            int curSamplerIndex = this.sharedSamplerBindings;

            for (int i = 0; i < varInfo.Length; i++)
            {
                if (locations[i] == -1)
                {
                    continue;
                }
                if (varInfo[i].Type != ShaderFieldType.Sampler2D)
                {
                    continue;
                }
                if (this.sharedShaderParameters.Contains(varInfo[i].Name))
                {
                    continue;
                }

                ContentRef <Texture> texRef = material.GetInternalTexture(varInfo[i].Name);
                NativeTexture.Bind(texRef, curSamplerIndex);

                GL.Uniform1(locations[i], curSamplerIndex);

                curSamplerIndex++;
            }
            NativeTexture.ResetBinding(curSamplerIndex);

            // Setup uniform data
            for (int i = 0; i < varInfo.Length; i++)
            {
                if (locations[i] == -1)
                {
                    continue;
                }
                if (varInfo[i].Type == ShaderFieldType.Sampler2D)
                {
                    continue;
                }
                if (this.sharedShaderParameters.Contains(varInfo[i].Name))
                {
                    continue;
                }

                float[] data;
                if (varInfo[i].Name == "ModelView")
                {
                    data = modelViewData;
                }
                else if (varInfo[i].Name == "Projection")
                {
                    data = projectionData;
                }
                else
                {
                    data = material.GetInternalData(varInfo[i].Name);
                    if (data == null)
                    {
                        continue;
                    }
                }

                NativeShaderProgram.SetUniform(ref varInfo[i], locations[i], data);
            }
        }