private UniformCollection FindUniforms(ShaderProgramNameGL3x program)
        {
            int programHandle = program.Value;

            int numberOfUniforms;

            GL.GetProgram(programHandle, ProgramParameter.ActiveUniforms, out numberOfUniforms);

            int uniformNameMaxLength;

            GL.GetProgram(programHandle, ProgramParameter.ActiveUniformMaxLength, out uniformNameMaxLength);

            UniformCollection uniforms = new UniformCollection();

            for (int i = 0; i < numberOfUniforms; ++i)
            {
                int uniformNameLength;
                int uniformSize;
                ActiveUniformType uniformType;
                StringBuilder     uniformNameBuilder = new StringBuilder(uniformNameMaxLength);

                GL.GetActiveUniform(programHandle, i, uniformNameMaxLength,
                                    out uniformNameLength, out uniformSize, out uniformType, uniformNameBuilder);

                string uniformName = CorrectUniformName(uniformNameBuilder.ToString());

                if (uniformName.StartsWith("gl_", StringComparison.InvariantCulture))
                {
                    //
                    // Names starting with the reserved prefix of "gl_" have a location of -1.
                    //
                    continue;
                }

                //
                // Skip uniforms in a named block
                //
                int uniformBlockIndex;
                GL.GetActiveUniforms(programHandle, 1, ref i, ActiveUniformParameter.UniformBlockIndex, out uniformBlockIndex);
                if (uniformBlockIndex != -1)
                {
                    continue;
                }

                if (uniformSize != 1)
                {
                    // TODO:  Support arrays
                    throw new NotSupportedException("Uniform arrays are not supported.");
                }

                int uniformLocation = GL.GetUniformLocation(programHandle, uniformName);
                uniforms.Add(CreateUniform(uniformName, uniformLocation, uniformType));
            }

            return(uniforms);
        }
Example #2
0
        private static void BasicSetUniforms(UniformCollection uniforms, DrawContext context)
        {
            // Vertex Uniforms
            uniforms["MVP"]
            .SetMatrix4(context.Instances[0].ModelMatrix * context.ModelMatrix * context.View * context.World);
            uniforms["MasterTextureMatrix"].SetMatrix3(context.Instances[0].TextureMatrix * context.TextureMatrix);
            uniforms["HasVColor"]
            .SetBool(context.Mesh.Attributes.Has("color"));

            DrawObject(context.ForcedType.GetValueOrDefault(context.Mesh.PrimitiveType), context.Mesh);
        }
Example #3
0
 protected void InitializeAutomaticUniforms(UniformCollection uniforms)
 {
     foreach (Uniform uniform in uniforms)
     {
         if (Device.LinkAutomaticUniforms.Contains(uniform.Name))
         {
             Device.LinkAutomaticUniforms[uniform.Name].Set(uniform);
         }
         else if (Device.DrawAutomaticUniformFactories.Contains(uniform.Name))
         {
             _drawAutomaticUniforms.Add(Device.DrawAutomaticUniformFactories[uniform.Name].Create(uniform));
         }
     }
 }
Example #4
0
        private static void InstancedSetUniforms(UniformCollection uniforms, DrawContext context)
        {
            if (context.Instances == null || context.Instances.Count < 1)
            {
                return;
            }

            uniforms["MVP"].SetMatrix4(context.ModelMatrix * context.View * context.World);
            uniforms["MasterTextureMatrix"].SetMatrix3(context.TextureMatrix);
            uniforms["HasVColor"]
            .SetBool(context.Mesh.Attributes.Has("color"));

            UniformArray instances = uniforms.GetArray("Instances");

            int shaderInstanceI = 0;

            for (int i = 0; i < context.Instances.Count; i++)
            {
                if (shaderInstanceI > instances.Length - 1)
                {
                    DrawObject(context.Mesh, instances.Length);
                    shaderInstanceI = 0;
                }

                var shaderInstance = instances[shaderInstanceI];
                var instance       = context.Instances[i];
                if (instance == null)
                {
                    continue;
                }
                shaderInstance["ModelMatrix"].SetMatrix4(instance.ModelMatrix);
                shaderInstance["TextureMatrix"].SetMatrix3(instance.TextureMatrix);

                shaderInstanceI++;
            }

            DrawObject(context.ForcedType.GetValueOrDefault(context.Mesh.PrimitiveType), context.Mesh, shaderInstanceI);
        }
 static void SetUniforms(UniformCollection uniforms, DrawContext context)
 {
     uniforms["Tint"].SetColor(context.Material.Tint);
     uniforms["Texture"].SetTexture(context.Material.Texture, uniforms["UseTexture"]);
 }
        private UniformCollection FindUniforms(ShaderProgramNameGL3x program)
        {
            int programHandle = program.Value;

            int numberOfUniforms;
            GL.GetProgram(programHandle, ProgramParameter.ActiveUniforms, out numberOfUniforms);

            int uniformNameMaxLength;
            GL.GetProgram(programHandle, ProgramParameter.ActiveUniformMaxLength, out uniformNameMaxLength);

            UniformCollection uniforms = new UniformCollection();
            for (int i = 0; i < numberOfUniforms; ++i)
            {
                int uniformNameLength;
                int uniformSize;
                ActiveUniformType uniformType;
                StringBuilder uniformNameBuilder = new StringBuilder(uniformNameMaxLength);

                GL.GetActiveUniform(programHandle, i, uniformNameMaxLength,
                    out uniformNameLength, out uniformSize, out uniformType, uniformNameBuilder);

                string uniformName = CorrectUniformName(uniformNameBuilder.ToString());

                if (uniformName.StartsWith("gl_", StringComparison.InvariantCulture))
                {
                    //
                    // Names starting with the reserved prefix of "gl_" have a location of -1.
                    //
                    continue;
                }

                //
                // Skip uniforms in a named block
                //
                int uniformBlockIndex;
                GL.GetActiveUniforms(programHandle, 1, ref i, ActiveUniformParameter.UniformBlockIndex, out uniformBlockIndex);
                if (uniformBlockIndex != -1)
                {
                    continue;
                }

                if (uniformSize != 1)
                {
                    // TODO:  Support arrays
                    throw new NotSupportedException("Uniform arrays are not supported.");
                }

                int uniformLocation = GL.GetUniformLocation(programHandle, uniformName);
                uniforms.Add(CreateUniform(uniformName, uniformLocation, uniformType));
            }

            return uniforms;
        }