Exemplo n.º 1
0
        /// <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);
                    }
                }
            }
        }
Exemplo n.º 2
0
        /// <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);
            }
        }