Example #1
0
        private void SubroutineUniformIndexChanged(SubroutineUniform uniform)
        {
            switch (uniform.ShaderType)
            {
            case ShaderType.VertexShader:
                _subroutineVertexStage[uniform.Location] = uniform.SubroutineIndex;
                break;

            case ShaderType.FragmentShader:
                _subroutineFragmentStage[uniform.Location] = uniform.SubroutineIndex;
                break;

            case ShaderType.GeometryShader:
                _subroutineGeometryStage[uniform.Location] = uniform.SubroutineIndex;
                break;

            default:
                throw new NotSupportedException(uniform.ShaderType.ToString());
            }
        }
Example #2
0
        private void InitSubroutines(uint handle, ShaderType shaderType)
        {
            if (shaderType == ShaderType.ComputeShader)
            {
                throw new NotSupportedException(ShaderType.ComputeShader.ToString());
            }

            var activeSubroutineUniformLocations = Context.GetProgramStage(handle, shaderType, ShaderSubroutine.ActiveSubroutineUniformLocations);
            var activeSubroutineUniformsCount    = Context.GetProgramStage(handle, shaderType, ShaderSubroutine.ActiveSubroutineUniforms);

            Assert.True(activeSubroutineUniformLocations == activeSubroutineUniformsCount);

            if (activeSubroutineUniformsCount == 0)
            {
                return;
            }

            switch (shaderType)
            {
            case ShaderType.VertexShader:
                Assert.Null(_subroutineVertexStage);
                _subroutineVertexStage = new uint[activeSubroutineUniformLocations];
                break;

            case ShaderType.FragmentShader:
                Assert.Null(_subroutineFragmentStage);
                _subroutineFragmentStage = new uint[activeSubroutineUniformLocations];
                break;

            case ShaderType.GeometryShader:
                Assert.Null(_subroutineGeometryStage);
                _subroutineGeometryStage = new uint[activeSubroutineUniformLocations];
                break;

            default:
                throw new NotSupportedException(shaderType.ToString());
            }

            for (uint i = 0; i < activeSubroutineUniformsCount; i++)
            {
                var uniformName     = Context.GetActiveSubroutineUniformName(handle, shaderType, i);
                var uniformLocation = Context.GetSubroutineUniformLocation(handle, shaderType, uniformName);

                var uniform = new SubroutineUniform(uniformName, uniformLocation, shaderType);
                uniform.SubroutineUniformIndexChanged += SubroutineUniformIndexChanged;
                _subroutineUniforms.Add(uniform);

                var compatibleCount = Context.GetActiveSubroutineUniform(handle, shaderType, i, ShaderSubroutine.NumCompatibleSubroutines);

                var indexes = new int[compatibleCount];
                Context.GetActiveSubroutineUniform(handle, shaderType, i, ShaderSubroutine.CompatibleSubroutines, indexes);

                for (uint j = 0; j < compatibleCount; j++)
                {
                    var subroutineName  = Context.GetActiveSubroutineName(handle, shaderType, j);
                    var subroutineIndex = Context.GetSubroutineIndex(handle, shaderType, subroutineName);
                    Assert.True(subroutineIndex == j);

                    uniform.AddSubroutine(subroutineName, subroutineIndex);
                }
            }
        }