C# GpuProgramParameters.MapParamNameToIndex方法代码示例

		public GpuProgramParameters Clone()
		{
			GpuProgramParameters p = new GpuProgramParameters();

			// copy int constants
			for ( int i = 0; i < intConstants.Count; i++ )
			{
				IntConstantEntry e = intConstants[ i ] as IntConstantEntry;
				if ( e.isSet )
				{
					p.SetConstant( i, e.val );
				}
			}

			// copy float constants
			for ( int i = 0; i < floatConstants.Count; i++ )
			{
				FloatConstantEntry e = floatConstants[ i ] as FloatConstantEntry;
				if ( e.isSet )
				{
					p.SetConstant( i, e.val );
				}
			}

			// copy auto constants
			for ( int i = 0; i < autoConstantList.Count; i++ )
			{
				AutoConstantEntry entry = autoConstantList[ i ] as AutoConstantEntry;
				p.SetAutoConstant( entry.Clone() );
			}

			// copy named params
			foreach ( string key in namedParams.Keys )
			{
				p.MapParamNameToIndex( key, namedParams[ key ] );
			}

			for ( int i = 0; i < paramTypeList.Count; i++ )
			{
			}
			foreach ( ParameterEntry pEntry in paramTypeList )
			{
				p.AddParameterToDefaultsList( pEntry.ParameterType, pEntry.ParameterName );
			}

			// copy value members
			p.transposeMatrices = transposeMatrices;
			p.autoAddParamName = autoAddParamName;

			return p;
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="prefix"></param>
        /// <param name="index"></param>
        /// <param name="parms"></param>
        protected void ProcessParamElement(D3D.EffectHandle parent, string prefix, int index, GpuProgramParameters parms)
        {
            D3D.EffectHandle constant = constantTable.GetConstant(parent, index);

            // Since D3D HLSL doesn't deal with naming of array and struct parameters
            // automatically, we have to do it by hand
            D3D.ConstantDescription[] descs = constantTable.GetConstantDescription(constant, 1);
            D3D.ConstantDescription desc = descs[0];

            string paramName = desc.Name;

            // trim the odd '$' which appears at the start of the names in HLSL
            if(paramName.StartsWith("$")) {
                paramName = paramName.Remove(0, 1);
            }

            // If it's an array, elements will be > 1
            for(int e = 0; e < desc.Elements; e++) {
                if(desc.Class == ParameterClass.Struct) {
                    // work out a new prefix for the nextest members
                    // if its an array, we need the index
                    if(desc.Elements > 1) {
                        prefix += string.Format("{0}[{1}].", paramName, e);
                    }
                    else {
                        prefix += ".";
                    }

                    // cascade into the struct members
                    for(int i = 0; i < desc.StructMembers; i++) {
                        ProcessParamElement(constant, prefix, i, parms);
                    }
                }
                else {
                    // process params
                    if(desc.ParameterType == ParameterType.Float ||
                        desc.ParameterType == ParameterType.Integer ||
                        desc.ParameterType == ParameterType.Boolean) {

                        int paramIndex = desc.RegisterIndex;
                        string newName = prefix + paramName;

                        // if this is an array, we need to appent the element index
                        if(desc.Elements > 1) {
                            newName += string.Format("[{0}]", e);
                        }

                        // map the named param to the index
                        parms.MapParamNameToIndex(newName, paramIndex+e);
                    }
                }
            }
        }

		/// <summary>
		///
		/// </summary>
		/// <param name="parms"></param>
		protected override void PopulateParameterNames( GpuProgramParameters parms )
		{
			Debug.Assert( cgProgram != IntPtr.Zero );

			// Note use of 'leaf' format so we only get bottom-level params, not structs
			IntPtr param = Cg.cgGetFirstLeafParameter( cgProgram, Cg.CG_PROGRAM );

			int index = 0;

			// loop through the rest of the params
			while ( param != IntPtr.Zero )
			{

				// get the type of this param up front
				int paramType = Cg.cgGetParameterType( param );

				// Look for uniform parameters only
				// Don't bother enumerating unused parameters, especially since they will
				// be optimized out and therefore not in the indexed versions
				if ( Cg.cgIsParameterReferenced( param ) != 0
					&& Cg.cgGetParameterVariability( param ) == Cg.CG_UNIFORM
					&& Cg.cgGetParameterDirection( param ) != Cg.CG_OUT
					&& paramType != Cg.CG_SAMPLER1D
					&& paramType != Cg.CG_SAMPLER2D
					&& paramType != Cg.CG_SAMPLER3D
					&& paramType != Cg.CG_SAMPLERCUBE
					&& paramType != Cg.CG_SAMPLERRECT )
				{

					// get the name and index of the program param
					string name = Cg.cgGetParameterName( param );

					// fp30 uses named rather than indexed params, so Cg returns
					// 0 for the index. However, we need the index to be unique here
					// Resource type 3256 doesn't have a define in the Cg header, so I assume
					// it means an unused or non-indexed params, since it is also returned
					// for programs that have a param that is not referenced in the program
					// and ends up getting pruned by the Cg compiler
					if ( selectedCgProfile == Cg.CG_PROFILE_FP30 )
					{
						// use a fake index just to order the named fp30 params
						index++;
					}
					else
					{
						// get the param constant index the normal way
						index = Cg.cgGetParameterResourceIndex( param );
					}

					// get the underlying resource type of this param
					// we need a special case for the register combiner
					// stage constants.
					int resource = Cg.cgGetParameterResource( param );

					// Get the parameter resource, so we know what type we're dealing with
					switch ( resource )
					{
						case Cg.CG_COMBINER_STAGE_CONST0:
							// register combiner, const 0
							// the index relates to the texture stage; store this as (stage * 2) + 0
							index = index * 2;
							break;

						case Cg.CG_COMBINER_STAGE_CONST1:
							// register combiner, const 1
							// the index relates to the texture stage; store this as (stage * 2) + 1
							index = ( index * 2 ) + 1;
							break;
					}

					// map the param to the index
					parms.MapParamNameToIndex( name, index );
				}

				// get the next param
				param = Cg.cgGetNextLeafParameter( param );
			}
		}

        public GpuProgramParameters Clone()
        {
            GpuProgramParameters p = new GpuProgramParameters();

            // copy int constants
            for ( int i = 0; i < intConstants.Count; i++ )
            {
                IntConstantEntry e = intConstants[i];
                if ( e.isSet )
                {
                    p.SetConstant(i, e.val);
                }
            }

            // copy float constants
            p.floatConstantsArray = new float[floatConstantsArray.Length];
            Array.Copy(floatConstantsArray, p.floatConstantsArray, floatConstantsArray.Length);
            p.floatIsSet = new bool[floatIsSet.Length];
            Array.Copy(floatIsSet, p.floatIsSet, floatIsSet.Length);
            p.float4VecConstantsCount = float4VecConstantsCount;
            p.maxSetCount = maxSetCount;

            // copy auto constants
            for(int i = 0; i < autoConstantList.Count; i++)
            {
                AutoConstantEntry entry = autoConstantList[i];
                p.SetAutoConstant(entry.Clone());
            }

            // copy named params
            foreach ( DictionaryEntry e in namedParams )
            {
                p.MapParamNameToIndex(e.Key as string, (int)e.Value);
            }

            for ( int i = 0; i < paramTypeList.Count; i++ )
            {

            }
            foreach ( ParameterEntry pEntry in paramTypeList )
            {
                p.AddParameterToDefaultsList(pEntry.ParameterType, pEntry.ParameterName);
            }

            // copy value members
            p.transposeMatrices = transposeMatrices;
            p.autoAddParamName = autoAddParamName;

            return p;
        }