public override void BindParameters(GpuProgramParameters parameters)
        {
            // activate the link program object
            GLSLLinkProgram linkProgram = GLSLLinkProgramManager.Instance.ActiveLinkProgram;

            // pass on parameters from params to program object uniforms
            linkProgram.UpdateUniforms(parameters);
        }
예제 #2
0
        /// <summary>
        ///		Set the active vertex shader for the next rendering state.
        /// </summary>
        /// <remarks>
        ///		The active program object will be cleared.
        ///		Normally called from the GLSLGpuProgram.BindProgram and UnbindProgram methods
        /// </remarks>
        /// <param name="vertexProgram"></param>
        public void SetActiveVertexShader(GLSLGpuProgram vertexProgram)
        {
            if (vertexProgram != this.activeVertexProgram)
            {
                this.activeVertexProgram = vertexProgram;

                // active link program is no longer valid
                this.activeLinkProgram = null;

                // change back to fixed pipeline
                Gl.glUseProgramObjectARB(0);
            }
        }
예제 #3
0
        /// <summary>
        ///		Set the active geometry shader for the next rendering state.
        /// </summary>
        /// <remarks>
        ///		The active program object will be cleared.
        ///		Normally called from the GLSLGpuProgram.BindProgram and UnbindProgram methods
        /// </remarks>
        /// <param name="vertexProgram"></param>
        public void SetActiveGeometryShader(GLSLGpuProgram geometryProgram)
        {
            if (geometryProgram != this.activeGeometryProgram)
            {
                this.activeGeometryProgram = geometryProgram;

                // active link program is no longer valid
                this.activeLinkProgram = null;

                // change back to fixed pipeline
                Gl.glUseProgramObjectARB(0);
            }
        }
예제 #4
0
        /// <summary>
        ///		Set the active fragment shader for the next rendering state.
        /// </summary>
        /// <remarks>
        ///		The active program object will be cleared.
        ///		Normally called from the GLSLGpuProgram.BindProgram and UnbindProgram methods
        /// </remarks>
        /// <param name="fragmentProgram"></param>
        public void SetActiveFragmentShader(GLSLGpuProgram fragmentProgram)
        {
            if (fragmentProgram != this.activeFragmentProgram)
            {
                this.activeFragmentProgram = fragmentProgram;

                // active link program is no longer valid
                this.activeLinkProgram = null;

                // change back to fixed pipeline
                Gl.glUseProgramObjectARB(0);
            }
        }
예제 #5
0
        public override void BindProgramParameters(GpuProgramParameters parms, GpuProgramParameters.GpuParamVariability mask)
        {
            try
            {
                // activate the link program object
                GLSLLinkProgram linkProgram = GLSLLinkProgramManager.Instance.ActiveLinkProgram;

                // pass on parameters from params to program object uniforms
                linkProgram.UpdateUniforms(parms, mask, Type);
            }
            catch (Exception e)
            {
                LogManager.Instance.Write("Remove this when validated");
                Debugger.Break();
            }
        }
        /// <summary>
        ///		Set the active vertex shader for the next rendering state.
        /// </summary>
        /// <remarks>
        ///		The active program object will be cleared.
        ///		Normally called from the GLSLGpuProgram.BindProgram and UnbindProgram methods
        /// </remarks>
        /// <param name="vertexProgram"></param>
        public void SetActiveVertexShader(GLSLGpuProgram vertexProgram)
        {
            if(vertexProgram != activeVertexProgram) {
                activeVertexProgram = vertexProgram;

                // active link program is no longer valid
                activeLinkProgram = null;

                // change back to fixed pipeline
                Gl.glUseProgramObjectARB(0);
            }
        }
        /// <summary>
        ///		Set the active fragment shader for the next rendering state.
        /// </summary>
        /// <remarks>
        ///		The active program object will be cleared.
        ///		Normally called from the GLSLGpuProgram.BindProgram and UnbindProgram methods
        /// </remarks>
        /// <param name="fragmentProgram"></param>
        public void SetActiveFragmentShader(GLSLGpuProgram fragmentProgram)
        {
            if(fragmentProgram != activeFragmentProgram) {
                activeFragmentProgram = fragmentProgram;

                // active link program is no longer valid
                activeLinkProgram = null;

                // change back to fixed pipeline
                Gl.glUseProgramObjectARB(0);
            }
        }
예제 #8
0
        ///<summary>
        /// Populate a list of uniforms based on a program object.
        ///</summary>
        ///<param name="programObject">Handle to the program object to query</param>
        ///<param name="vertexConstantDefs">Definition of the constants extracted from the
        /// vertex program, used to match up physical buffer indexes with program
        /// uniforms. May be null if there is no vertex program.</param>
        ///<param name="geometryConstantDefs">Definition of the constants extracted from the
        /// geometry program, used to match up physical buffer indexes with program
        /// uniforms. May be null if there is no geometry program.</param>
        ///<param name="fragmentConstantDefs">Definition of the constants extracted from the
        /// fragment program, used to match up physical buffer indexes with program
        /// uniforms. May be null if there is no fragment program.</param>
        ///<param name="list">The list to populate (will not be cleared before adding, clear
        /// it yourself before calling this if that's what you want).</param>
        public void ExtractUniforms(int programObject,
                   GpuProgramParameters.GpuConstantDefinitionMap vertexConstantDefs,
                   GpuProgramParameters.GpuConstantDefinitionMap geometryConstantDefs,
                   GpuProgramParameters.GpuConstantDefinitionMap fragmentConstantDefs,
                   GLSLLinkProgram.UniformReferenceList list)
        {

            // scan through the active uniforms and add them to the reference list

            // get the number of active uniforms
            int uniformCount;
            const int BUFFERSIZE = 200;

            Gl.glGetObjectParameterivARB(programObject, Gl.GL_OBJECT_ACTIVE_UNIFORMS_ARB,
                        out uniformCount);

            // Loop over each of the active uniforms, and add them to the reference container
            // only do this for user defined uniforms, ignore built in gl state uniforms
            for (var index = 0; index < uniformCount; index++)
            {
                // important for Axiom: dont pull this var to the outer scope
                // because UniformReference is by value (class)
                // if we'd share the instance we would push the same instance
                // to the result list each iteration
                var newGLUniformReference = new GLSLLinkProgram.UniformReference();

                var uniformName = new StringBuilder();
                int arraySize;
                int glType;
                Gl.glGetActiveUniformARB(programObject, index, BUFFERSIZE, null,
                                out arraySize, out glType, uniformName);

                newGLUniformReference.Location = Gl.glGetUniformLocationARB(programObject, uniformName.ToString());
                if (newGLUniformReference.Location >= 0)
                {
                    // user defined uniform found, add it to the reference list
                    var paramName = uniformName.ToString();

                    // currant ATI drivers (Catalyst 7.2 and earlier) and older NVidia drivers will include all array elements as uniforms but we only want the root array name and location
                    // Also note that ATI Catalyst 6.8 to 7.2 there is a bug with glUniform that does not allow you to update a uniform array past the first uniform array element
                    // ie you can't start updating an array starting at element 1, must always be element 0.

                    // if the uniform name has a "[" in it then its an array element uniform.
                    var arrayStart = paramName.IndexOf( '[' );
                    if (arrayStart != -1)
                    {
                        // if not the first array element then skip it and continue to the next uniform

                        if (paramName.Substring(arrayStart, paramName.Length - 1) != "[0]") 
                            continue;
                        paramName = paramName.Substring(0, arrayStart);
                    }

                    // find out which params object this comes from
                    var foundSource = CompleteParamSource( paramName, vertexConstantDefs, geometryConstantDefs,
                                                           fragmentConstantDefs, newGLUniformReference );

                    // only add this parameter if we found the source
                    if (foundSource)
                    {
                        Debug.Assert( arraySize == newGLUniformReference.ConstantDef.ArraySize,
                                      "GL doesn't agree with our array size!" );
                        list.Add(newGLUniformReference);
                    }

                    // Don't bother adding individual array params, they will be
                    // picked up in the 'parent' parameter can copied all at once
                    // anyway, individual indexes are only needed for lookup from
                    // user params
                } // end if
            } // end for
        }
예제 #9
0
        private bool CompleteParamSource(String paramName,
                GpuProgramParameters.GpuConstantDefinitionMap vertexConstantDefs, 
                GpuProgramParameters.GpuConstantDefinitionMap geometryConstantDefs,
                GpuProgramParameters.GpuConstantDefinitionMap fragmentConstantDefs,
                GLSLLinkProgram.UniformReference refToUpdate)
        {
            GpuProgramParameters.GpuConstantDefinition parami;
            if (vertexConstantDefs != null)
            {

                if ( vertexConstantDefs.TryGetValue( paramName, out parami ) )
                {
                    refToUpdate.SourceProgType = GpuProgramType.Vertex;
                    refToUpdate.ConstantDef = parami;
                    return true;
                }
            }

            if (geometryConstantDefs != null)
            {

                if (geometryConstantDefs.TryGetValue(paramName, out parami))
                {
                    refToUpdate.SourceProgType = GpuProgramType.Geometry;
                    refToUpdate.ConstantDef = parami;
                    return true;
                }
            }

            if (fragmentConstantDefs != null)
            {

                if (fragmentConstantDefs.TryGetValue(paramName, out parami))
                {
                    refToUpdate.SourceProgType = GpuProgramType.Fragment;
                    refToUpdate.ConstantDef = parami;
                    return true;
                }
            }

            return false;
        }
예제 #10
0
		/// <summary>
		///		Set the active geometry shader for the next rendering state.
		/// </summary>
		/// <remarks>
		///		The active program object will be cleared.
		///		Normally called from the GLSLGpuProgram.BindProgram and UnbindProgram methods
		/// </remarks>
		/// <param name="vertexProgram"></param>
		public void SetActiveGeometryShader( GLSLGpuProgram geometryProgram )
		{
            if (geometryProgram != activeGeometryProgram)
			{
                activeGeometryProgram = geometryProgram;

				// active link program is no longer valid
				activeLinkProgram = null;

				// change back to fixed pipeline
				Gl.glUseProgramObjectARB( 0 );
			}
		}