Logo Search packages:      
Sourcecode: ogre version File versions

OgreGpuProgram.h

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org

Copyright (c) 2000-2006 Torus Knot Software Ltd
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.

You may alternatively use this source under the terms of a specific version of
the OGRE Unrestricted License provided you have obtained such a license from
Torus Knot Software Ltd.
-----------------------------------------------------------------------------
*/
#ifndef __GpuProgram_H_
#define __GpuProgram_H_

// Precompiler options
#include "OgrePrerequisites.h"
#include "OgreResource.h"
#include "OgreSharedPtr.h"
#include "OgreIteratorWrappers.h"

namespace Ogre {

      /** Enumerates the types of programs which can run on the GPU. */
00041       enum GpuProgramType
      {
            GPT_VERTEX_PROGRAM,
            GPT_FRAGMENT_PROGRAM
      };

      /** Enumeration of the types of constant we may encounter in programs. 
      @note Low-level programs, by definition, will always use either
      float4 or int4 constant types since that is the fundamental underlying
      type in assembler.
      */
00052       enum GpuConstantType
      {
            GCT_FLOAT1,
            GCT_FLOAT2,
            GCT_FLOAT3,
            GCT_FLOAT4,
            GCT_SAMPLER1D,
            GCT_SAMPLER2D,
            GCT_SAMPLER3D,
            GCT_SAMPLERCUBE,
            GCT_SAMPLER1DSHADOW,
            GCT_SAMPLER2DSHADOW,
            GCT_MATRIX_2X2,
            GCT_MATRIX_2X3,
            GCT_MATRIX_2X4,
            GCT_MATRIX_3X2,
            GCT_MATRIX_3X3,
            GCT_MATRIX_3X4,
            GCT_MATRIX_4X2,
            GCT_MATRIX_4X3,
            GCT_MATRIX_4X4,
            GCT_INT1,
            GCT_INT2,
            GCT_INT3,
            GCT_INT4,
            GCT_UNKNOWN
      };

      /** Information about predefined program constants. 
      @note Only available for high-level programs but is referenced generically
            by GpuProgramParameters.
      */
00084       struct _OgreExport GpuConstantDefinition
      {
            /// Data type
00087             GpuConstantType constType;
            /// Physical start index in buffer (either float or int buffer)
00089             size_t physicalIndex;
            /** Number of raw buffer slots per element 
            (some programs pack each array element to float4, some do not) */
00092             size_t elementSize;
            /// Length of array
00094             size_t arraySize;

            bool isFloat() const
            {
                  switch(constType)
                  {
                  case GCT_INT1:
                  case GCT_INT2:
                  case GCT_INT3:
                  case GCT_INT4:
                  case GCT_SAMPLER1D:
                  case GCT_SAMPLER2D:
                  case GCT_SAMPLER3D:
                  case GCT_SAMPLERCUBE:
                  case GCT_SAMPLER1DSHADOW:
                  case GCT_SAMPLER2DSHADOW:
                        return false;
                  default:
                        return true;
                  };

            }

            bool isSampler() const
            {
                  switch(constType)
                  {
                  case GCT_SAMPLER1D:
                  case GCT_SAMPLER2D:
                  case GCT_SAMPLER3D:
                  case GCT_SAMPLERCUBE:
                  case GCT_SAMPLER1DSHADOW:
                  case GCT_SAMPLER2DSHADOW:
                        return true;
                  default:
                        return false;
                  };

            }

            GpuConstantDefinition()
                  : constType(GCT_UNKNOWN)
                  , physicalIndex((std::numeric_limits<size_t>::max)())
                  , elementSize(0)
                  , arraySize(1) {}
      };
      typedef std::map<String, GpuConstantDefinition> GpuConstantDefinitionMap;
      typedef ConstMapIterator<GpuConstantDefinitionMap> GpuConstantDefinitionIterator;

      /// Struct collecting together the information for named constants.
00144       struct _OgreExport GpuNamedConstants
      {
            /// Total size of the float buffer required
00147             size_t floatBufferSize;
            /// Total size of the int buffer required
00149             size_t intBufferSize;
            /// Map of parameter names to GpuConstantDefinition
00151             GpuConstantDefinitionMap map;

            /** Generate additional constant entries for arrays based on a base definition.
            @remarks
                  Array uniforms will be added just with their base name with no array
                  suffix. This method will add named entries for array suffixes too
                  so individual array entries can be addressed. Note that we only 
                  individually index array elements if the array size is up to 16
                  entries in size. Anything larger than that only gets a [0] entry
                  as well as the main entry, to save cluttering up the name map. After
                  all, you can address the larger arrays in a bulk fashion much more
                  easily anyway. 
            */
            void generateConstantDefinitionArrayEntries(const String& paramName, 
                  const GpuConstantDefinition& baseDef);

      };

      /** Structure recording the use of a physical buffer by a logical parameter
            index. Only used for low-level programs.
      */
00172       struct _OgreExport GpuLogicalIndexUse
      {
            /// Physical buffer index
00175             size_t physicalIndex;
            /// Current physical size allocation
00177             size_t currentSize;

            GpuLogicalIndexUse(size_t bufIdx, size_t curSz) 
                  : physicalIndex(bufIdx), currentSize(curSz) {}
      };
      typedef std::map<size_t, GpuLogicalIndexUse> GpuLogicalIndexUseMap;
      /// Container struct to allow params to safely & update shared list of logical buffer assignments
00184       struct _OgreExport GpuLogicalBufferStruct
      {
            OGRE_MUTEX(mutex)
            /// Map from logical index to physical buffer location
00188             GpuLogicalIndexUseMap map;
            /// Shortcut to know the buffer size needs
00190             size_t bufferSize;
            GpuLogicalBufferStruct() : bufferSize(0) {}
      };

    /** Collects together the program parameters used for a GpuProgram.
    @remarks
        Gpu program state includes constant parameters used by the program, and
        bindings to render system state which is propagated into the constants 
        by the engine automatically if requested.
    @par
        GpuProgramParameters objects should be created through the GpuProgram and
        may be shared between multiple Pass instances. For this reason they
        are managed using a shared pointer, which will ensure they are automatically
        deleted when no Pass is using them anymore. 
      @par
            High-level programs use named parameters (uniforms), low-level programs 
            use indexed constants. This class supports both, but you can tell whether 
            named constants are supported by calling hasNamedParameters(). There are
            references in the documentation below to 'logical' and 'physical' indexes;
            logical indexes are the indexes used by low-level programs and represent 
            indexes into an array of float4's, some of which may be settable, some of
            which may be predefined constants in the program. We only store those
            constants which have actually been set, therefore our buffer could have 
            gaps if we used the logical indexes in our own buffers. So instead we map
            these logical indexes to physical indexes in our buffer. When using 
            high-level programs, logical indexes don't necessarily exist, although they
            might if the high-level program has a direct, exposed mapping from parameter
            names to logical indexes. In addition, high-level languages may or may not pack
            arrays of elements that are smaller than float4 (e.g. float2/vec2) contiguously.
            This kind of information is held in the ConstantDefinition structure which 
            is only populated for high-level programs. You don't have to worry about
            any of this unless you intend to read parameters back from this structure
            rather than just setting them.
    */
00224     class _OgreExport GpuProgramParameters
    {
    public:
        /** Defines the types of automatically updated values that may be bound to GpuProgram
        parameters, or used to modify parameters on a per-object basis.
        */
00230         enum AutoConstantType
        {
            /// The current world matrix
00233             ACT_WORLD_MATRIX,
            /// The current world matrix, inverted
00235             ACT_INVERSE_WORLD_MATRIX,
                  /** Provides transpose of world matrix.
                  Equivalent to RenderMonkey's "WorldTranspose".
                  */
00239                   ACT_TRANSPOSE_WORLD_MATRIX,
            /// The current world matrix, inverted & transposed
00241             ACT_INVERSE_TRANSPOSE_WORLD_MATRIX,


            /// The current array of world matrices, as a 3x4 matrix, used for blending
00245             ACT_WORLD_MATRIX_ARRAY_3x4,
            /// The current array of world matrices, used for blending
00247             ACT_WORLD_MATRIX_ARRAY,

            /// The current view matrix
00250             ACT_VIEW_MATRIX,
                  /// The current view matrix, inverted
00252                   ACT_INVERSE_VIEW_MATRIX,
                  /** Provides transpose of view matrix.
                  Equivalent to RenderMonkey's "ViewTranspose".
                  */
00256                   ACT_TRANSPOSE_VIEW_MATRIX,
                  /** Provides inverse transpose of view matrix.
                  Equivalent to RenderMonkey's "ViewInverseTranspose".
                  */
00260                   ACT_INVERSE_TRANSPOSE_VIEW_MATRIX,


            /// The current projection matrix
00264             ACT_PROJECTION_MATRIX,
                  /** Provides inverse of projection matrix.
                  Equivalent to RenderMonkey's "ProjectionInverse".
                  */
00268                   ACT_INVERSE_PROJECTION_MATRIX,
                  /** Provides transpose of projection matrix.
                  Equivalent to RenderMonkey's "ProjectionTranspose".
                  */
00272                   ACT_TRANSPOSE_PROJECTION_MATRIX,
                  /** Provides inverse transpose of projection matrix.
                  Equivalent to RenderMonkey's "ProjectionInverseTranspose".
                  */
00276                   ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX,


            /// The current view & projection matrices concatenated
00280             ACT_VIEWPROJ_MATRIX,
                  /** Provides inverse of concatenated view and projection matrices.
                  Equivalent to RenderMonkey's "ViewProjectionInverse".
                  */
00284                   ACT_INVERSE_VIEWPROJ_MATRIX,
                  /** Provides transpose of concatenated view and projection matrices.
                  Equivalent to RenderMonkey's "ViewProjectionTranspose".
                  */
00288                   ACT_TRANSPOSE_VIEWPROJ_MATRIX,
                  /** Provides inverse transpose of concatenated view and projection matrices.
                  Equivalent to RenderMonkey's "ViewProjectionInverseTranspose".
                  */
00292                   ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX,


            /// The current world & view matrices concatenated
00296             ACT_WORLDVIEW_MATRIX,
            /// The current world & view matrices concatenated, then inverted
00298             ACT_INVERSE_WORLDVIEW_MATRIX,
                  /** Provides transpose of concatenated world and view matrices.
                        Equivalent to RenderMonkey's "WorldViewTranspose".
                  */
00302                   ACT_TRANSPOSE_WORLDVIEW_MATRIX,
            /// The current world & view matrices concatenated, then inverted & tranposed
00304             ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX,
                  /// view matrices.


            /// The current world, view & projection matrices concatenated
00309             ACT_WORLDVIEWPROJ_MATRIX,
                  /** Provides inverse of concatenated world, view and projection matrices.
                  Equivalent to RenderMonkey's "WorldViewProjectionInverse".
                  */
00313                   ACT_INVERSE_WORLDVIEWPROJ_MATRIX,
                  /** Provides transpose of concatenated world, view and projection matrices.
                  Equivalent to RenderMonkey's "WorldViewProjectionTranspose".
                  */
00317                   ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX,
                  /** Provides inverse transpose of concatenated world, view and projection
                  matrices. Equivalent to RenderMonkey's "WorldViewProjectionInverseTranspose".
                  */
00321                   ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX,


            /// render target related values
            /** -1 if requires texture flipping, +1 otherwise. It's useful when you bypassed
            projection matrix transform, still able use this value to adjust transformed y position.
            */
00328             ACT_RENDER_TARGET_FLIPPING,


            /// Fog colour
00332             ACT_FOG_COLOUR,
            /// Fog params: density, linear start, linear end, 1/(end-start)
00334             ACT_FOG_PARAMS,


            /// Surface ambient colour, as set in Pass::setAmbient
00338             ACT_SURFACE_AMBIENT_COLOUR,
            /// Surface diffuse colour, as set in Pass::setDiffuse
00340             ACT_SURFACE_DIFFUSE_COLOUR,
            /// Surface specular colour, as set in Pass::setSpecular
00342             ACT_SURFACE_SPECULAR_COLOUR,
            /// Surface emissive colour, as set in Pass::setSelfIllumination
00344             ACT_SURFACE_EMISSIVE_COLOUR,
            /// Surface shininess, as set in Pass::setShininess
00346             ACT_SURFACE_SHININESS,


                  /// The ambient light colour set in the scene
00350                   ACT_AMBIENT_LIGHT_COLOUR, 

            /// Light diffuse colour (index determined by setAutoConstant call)
00353             ACT_LIGHT_DIFFUSE_COLOUR,
            /// Light specular colour (index determined by setAutoConstant call)
00355             ACT_LIGHT_SPECULAR_COLOUR,
            /// Light attenuation parameters, Vector4(range, constant, linear, quadric)
00357             ACT_LIGHT_ATTENUATION,
                  /** Spotlight parameters, Vector4(innerFactor, outerFactor, falloff, isSpot)
                        innerFactor and outerFactor are cos(angle/2)
                        The isSpot parameter is 0.0f for non-spotlights, 1.0f for spotlights.
                        Also for non-spotlights the inner and outer factors are 1 and nearly 1 respectively
                  */ 
00363                   ACT_SPOTLIGHT_PARAMS,
            /// A light position in world space (index determined by setAutoConstant call)
00365             ACT_LIGHT_POSITION,
            /// A light position in object space (index determined by setAutoConstant call)
00367             ACT_LIGHT_POSITION_OBJECT_SPACE,
                  /// A light position in view space (index determined by setAutoConstant call)
00369             ACT_LIGHT_POSITION_VIEW_SPACE,
            /// A light direction in world space (index determined by setAutoConstant call)
00371             ACT_LIGHT_DIRECTION,
            /// A light direction in object space (index determined by setAutoConstant call)
00373             ACT_LIGHT_DIRECTION_OBJECT_SPACE,
                  /// A light direction in view space (index determined by setAutoConstant call)
00375                   ACT_LIGHT_DIRECTION_VIEW_SPACE,
                  /** The distance of the light from the center of the object
                        a useful approximation as an alternative to per-vertex distance
                        calculations.
                  */
00380                   ACT_LIGHT_DISTANCE_OBJECT_SPACE,
                  /** Light power level, a single scalar as set in Light::setPowerScale  (index determined by setAutoConstant call) */
00382                   ACT_LIGHT_POWER_SCALE,
                  /// Array of light diffuse colours (count set by extra param)
00384                   ACT_LIGHT_DIFFUSE_COLOUR_ARRAY,
                  /// Array of light specular colours (count set by extra param)
00386                   ACT_LIGHT_SPECULAR_COLOUR_ARRAY,
                  /// Array of light attenuation parameters, Vector4(range, constant, linear, quadric) (count set by extra param)
00388                   ACT_LIGHT_ATTENUATION_ARRAY,
                  /// Array of light positions in world space (count set by extra param)
00390                   ACT_LIGHT_POSITION_ARRAY,
                  /// Array of light positions in object space (count set by extra param)
00392                   ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY,
                  /// Array of light positions in view space (count set by extra param)
00394                   ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY,
                  /// Array of light directions in world space (count set by extra param)
00396                   ACT_LIGHT_DIRECTION_ARRAY,
                  /// Array of light directions in object space (count set by extra param)
00398                   ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY,
                  /// Array of light directions in view space (count set by extra param)
00400                   ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY,
                  /** Array of distances of the lights from the center of the object
                  a useful approximation as an alternative to per-vertex distance
                  calculations. (count set by extra param)
                  */
00405                   ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY,
                  /** Array of light power levels, a single scalar as set in Light::setPowerScale 
                   (count set by extra param)
                  */
00409                   ACT_LIGHT_POWER_SCALE_ARRAY,
                  /** Spotlight parameters array of Vector4(innerFactor, outerFactor, falloff, isSpot)
                  innerFactor and outerFactor are cos(angle/2)
                  The isSpot parameter is 0.0f for non-spotlights, 1.0f for spotlights.
                  Also for non-spotlights the inner and outer factors are 1 and nearly 1 respectively.
                  (count set by extra param)
                  */ 
00416                   ACT_SPOTLIGHT_PARAMS_ARRAY,

            /** The derived ambient light colour, with 'r', 'g', 'b' components filled with
                product of surface ambient colour and ambient light colour, respectively,
                and 'a' component filled with surface ambient alpha component.
            */
00422             ACT_DERIVED_AMBIENT_LIGHT_COLOUR,
            /** The derived scene colour, with 'r', 'g' and 'b' components filled with sum
                of derived ambient light colour and surface emissive colour, respectively,
                and 'a' component filled with surface diffuse alpha component.
            */
00427             ACT_DERIVED_SCENE_COLOUR,

            /** The derived light diffuse colour (index determined by setAutoConstant call),
                with 'r', 'g' and 'b' components filled with product of surface diffuse colour
                and light diffuse colour, respectively, and 'a' component filled with surface
                diffuse alpha component.
            */
00434             ACT_DERIVED_LIGHT_DIFFUSE_COLOUR,
            /** The derived light specular colour (index determined by setAutoConstant call),
                with 'r', 'g' and 'b' components filled with product of surface specular colour
                and light specular colour, respectively, and 'a' component filled with surface
                specular alpha component.
            */
00440             ACT_DERIVED_LIGHT_SPECULAR_COLOUR,

                  /// Array of derived light diffuse colours (count set by extra param)
00443             ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY,
                  /// Array of derived light specular colours (count set by extra param)
00445             ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY,


                  /** The distance a shadow volume should be extruded when using
                      finite extrusion programs.
                  */
00451                   ACT_SHADOW_EXTRUSION_DISTANCE,
            /// The current camera's position in world space
00453             ACT_CAMERA_POSITION,
            /// The current camera's position in object space 
00455             ACT_CAMERA_POSITION_OBJECT_SPACE,
            /// The view/projection matrix of the assigned texture projection frustum
00457             ACT_TEXTURE_VIEWPROJ_MATRIX,
            /// A custom parameter which will come from the renderable, using 'data' as the identifier
00459             ACT_CUSTOM,
            /** provides current elapsed time
            */
00462             ACT_TIME,
                  /** Single float value, which repeats itself based on given as
                  parameter "cycle time". Equivalent to RenderMonkey's "Time0_X".
                  */
00466                   ACT_TIME_0_X,
                  /// Cosine of "Time0_X". Equivalent to RenderMonkey's "CosTime0_X".
00468                   ACT_COSTIME_0_X,
                  /// Sine of "Time0_X". Equivalent to RenderMonkey's "SinTime0_X".
00470                   ACT_SINTIME_0_X,
                  /// Tangent of "Time0_X". Equivalent to RenderMonkey's "TanTime0_X".
00472                   ACT_TANTIME_0_X,
                  /** Vector of "Time0_X", "SinTime0_X", "CosTime0_X", 
                  "TanTime0_X". Equivalent to RenderMonkey's "Time0_X_Packed".
                  */
00476                   ACT_TIME_0_X_PACKED,
                  /** Single float value, which represents scaled time value [0..1],
                  which repeats itself based on given as parameter "cycle time".
                  Equivalent to RenderMonkey's "Time0_1".
                  */
00481                   ACT_TIME_0_1,
                  /// Cosine of "Time0_1". Equivalent to RenderMonkey's "CosTime0_1".
00483                   ACT_COSTIME_0_1,
                  /// Sine of "Time0_1". Equivalent to RenderMonkey's "SinTime0_1".
00485                   ACT_SINTIME_0_1,
                  /// Tangent of "Time0_1". Equivalent to RenderMonkey's "TanTime0_1".
00487                   ACT_TANTIME_0_1,
                  /** Vector of "Time0_1", "SinTime0_1", "CosTime0_1",
                  "TanTime0_1". Equivalent to RenderMonkey's "Time0_1_Packed".
                  */
00491                   ACT_TIME_0_1_PACKED,
                  /**   Single float value, which represents scaled time value [0..2*Pi],
                  which repeats itself based on given as parameter "cycle time".
                  Equivalent to RenderMonkey's "Time0_2PI".
                  */
00496                   ACT_TIME_0_2PI,
                  /// Cosine of "Time0_2PI". Equivalent to RenderMonkey's "CosTime0_2PI".
00498                   ACT_COSTIME_0_2PI,
                  /// Sine of "Time0_2PI". Equivalent to RenderMonkey's "SinTime0_2PI".
00500                   ACT_SINTIME_0_2PI,
                  /// Tangent of "Time0_2PI". Equivalent to RenderMonkey's "TanTime0_2PI".
00502                   ACT_TANTIME_0_2PI,
                  /** Vector of "Time0_2PI", "SinTime0_2PI", "CosTime0_2PI",
                  "TanTime0_2PI". Equivalent to RenderMonkey's "Time0_2PI_Packed".
                  */
00506                   ACT_TIME_0_2PI_PACKED,
                  /// provides the scaled frame time, returned as a floating point value.
00508             ACT_FRAME_TIME,
                  /// provides the calculated frames per second, returned as a floating point value.
00510                   ACT_FPS,
                  /// viewport-related values
                  /** Current viewport width (in pixels) as floating point value.
                  Equivalent to RenderMonkey's "ViewportWidth".
                  */
00515                   ACT_VIEWPORT_WIDTH,
                  /** Current viewport height (in pixels) as floating point value.
                  Equivalent to RenderMonkey's "ViewportHeight".
                  */
00519                   ACT_VIEWPORT_HEIGHT,
                  /** This variable represents 1.0/ViewportWidth. 
                  Equivalent to RenderMonkey's "ViewportWidthInverse".
                  */
00523                   ACT_INVERSE_VIEWPORT_WIDTH,
                  /** This variable represents 1.0/ViewportHeight.
                  Equivalent to RenderMonkey's "ViewportHeightInverse".
                  */
00527                   ACT_INVERSE_VIEWPORT_HEIGHT,
            /** Packed of "ViewportWidth", "ViewportHeight", "ViewportWidthInverse",
            "ViewportHeightInverse".
            */
00531             ACT_VIEWPORT_SIZE,

                  /// view parameters
                  /** This variable provides the view direction vector (world space).
                  Equivalent to RenderMonkey's "ViewDirection".
                  */
00537                   ACT_VIEW_DIRECTION,
                  /** This variable provides the view side vector (world space).
                  Equivalent to RenderMonkey's "ViewSideVector".
                  */
00541                   ACT_VIEW_SIDE_VECTOR,
                  /** This variable provides the view up vector (world space).
                  Equivalent to RenderMonkey's "ViewUpVector".
                  */
00545                   ACT_VIEW_UP_VECTOR,
                  /** This variable provides the field of view as a floating point value.
                  Equivalent to RenderMonkey's "FOV".
                  */
00549                   ACT_FOV,
                  /**   This variable provides the near clip distance as a floating point value.
                  Equivalent to RenderMonkey's "NearClipPlane".
                  */
00553                   ACT_NEAR_CLIP_DISTANCE,
                  /**   This variable provides the far clip distance as a floating point value.
                  Equivalent to RenderMonkey's "FarClipPlane".
                  */
00557                   ACT_FAR_CLIP_DISTANCE,

            /** provides the pass index number within the technique
                of the active materil.
            */
00562             ACT_PASS_NUMBER,

            /** provides the current iteration number of the pass. The iteration
                number is the number of times the current render operation has
                been drawn for the acitve pass.
            */
00568             ACT_PASS_ITERATION_NUMBER,


                  /** Provides a parametric animation value [0..1], only available
                        where the renderable specifically implements it.
                  */
00574                   ACT_ANIMATION_PARAMETRIC,

                  /** Provides the texel offsets required by this rendersystem to map
                        texels to pixels. Packed as 
                        float4(absoluteHorizontalOffset, absoluteVerticalOffset, 
                              horizontalOffset / viewportWidth, verticalOffset / viewportHeight)
                  */
00581                   ACT_TEXEL_OFFSETS,

                  /** Provides information about the depth range of the scene as viewed
                        from the current camera. 
                        Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)
                  */
00587                   ACT_SCENE_DEPTH_RANGE,

                  /** Provides information about the depth range of the scene as viewed
                  from a given shadow camera. Requires an index parameter which maps
                  to a light index relative to the current light list.
                  Passed as float4(minDepth, maxDepth, depthRange, 1 / depthRange)
                  */
00594                   ACT_SHADOW_SCENE_DEPTH_RANGE,

            /** Provides texture size of the texture unit (index determined by setAutoConstant
                call). Packed as float4(width, height, depth, 1)
            */
00599             ACT_TEXTURE_SIZE,
            /** Provides inverse texture size of the texture unit (index determined by setAutoConstant
                call). Packed as float4(1 / width, 1 / height, 1 / depth, 1)
            */
00603             ACT_INVERSE_TEXTURE_SIZE,
            /** Provides packed texture size of the texture unit (index determined by setAutoConstant
                call). Packed as float4(width, height, 1 / width, 1 / height)
            */
00607             ACT_PACKED_TEXTURE_SIZE,


        };

        /** Defines the type of the extra data item used by the auto constant.

        */
00615         enum ACDataType {
            /// no data is required
00617             ACDT_NONE,
            /// the auto constant requires data of type int
00619             ACDT_INT,
            /// the auto constant requires data of type real
00621             ACDT_REAL
        };

        /** Defines the base element type of the auto constant
        */
00626         enum ElementType {
            ET_INT,
            ET_REAL
        };

        /** Structure defining an auto constant that's available for use in 
                  a parameters object.
            */
00634             struct AutoConstantDefinition
        {
            AutoConstantType acType;
            String name;
            size_t elementCount;
                  /// The type of the constant in the program
00640             ElementType elementType;
                  /// The type of any extra data
00642             ACDataType dataType;

                  AutoConstantDefinition(AutoConstantType _acType, const String& _name, 
                        size_t _elementCount, ElementType _elementType, 
                        ACDataType _dataType)
                        :acType(_acType), name(_name), elementCount(_elementCount), 
                        elementType(_elementType), dataType(_dataType)
                  {
                        
                  }
        };

        /** Structure recording the use of an automatic parameter. */
00655         class AutoConstantEntry
        {
        public:
            /// The type of parameter
00659             AutoConstantType paramType;
                  /// The target (physical) constant index
00661             size_t physicalIndex;
                  /** The number of elements per individual entry in this constant
                        Used in case people used packed elements smaller than 4 (e.g. GLSL)
                        and bind an auto which is 4-element packed to it */
00665                   size_t elementCount;
            /// Additional information to go with the parameter
                  union{
                        size_t data;
                        Real fData;
                  };

            AutoConstantEntry(AutoConstantType theType, size_t theIndex, size_t theData, 
                        size_t theElemCount = 4)
                : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), data(theData) {}

                  AutoConstantEntry(AutoConstantType theType, size_t theIndex, Real theData, 
                        size_t theElemCount = 4)
                        : paramType(theType), physicalIndex(theIndex), elementCount(theElemCount), fData(theData) {}

        };
            // Auto parameter storage
            typedef std::vector<AutoConstantEntry> AutoConstantList;

            /** Definition of container that holds the current float constants.
            @note Not necessarily in direct index order to constant indexes, logical
                  to physical index map is derived from GpuProgram
            */
00688             typedef std::vector<float> FloatConstantList;
            /** Definition of container that holds the current float constants.
            @note Not necessarily in direct index order to constant indexes, logical
                  to physical index map is derived from GpuProgram
            */
00693             typedef std::vector<int> IntConstantList;

      protected:
        static AutoConstantDefinition AutoConstantDictionary[];
            /// Packed list of floating-point constants (physical indexing)
00698         FloatConstantList mFloatConstants;
        /// Packed list of integer constants (physical indexing)
00700         IntConstantList mIntConstants;
            /** Logical index to physical index map - for low-level programs
                  or high-level programs which pass params this way. */
00703             GpuLogicalBufferStruct* mFloatLogicalToPhysical;
            /** Logical index to physical index map - for low-level programs
            or high-level programs which pass params this way. */
00706             GpuLogicalBufferStruct* mIntLogicalToPhysical;
            /// Mapping from parameter names to def - high-level programs are expected to populate this
00708             const GpuNamedConstants* mNamedConstants;
        /// List of automatically updated parameters
00710         AutoConstantList mAutoConstants;
        /// Do we need to transpose matrices?
00712         bool mTransposeMatrices;
            /// flag to indicate if names not found will be ignored
00714             bool mIgnoreMissingParams;
        /// physical index for active pass iteration parameter real constant entry;
00716         size_t mActivePassIterationIndex;

    public:
            GpuProgramParameters();
            ~GpuProgramParameters() {}

        /// Copy constructor
        GpuProgramParameters(const GpuProgramParameters& oth);
        /// Operator = overload
        GpuProgramParameters& operator=(const GpuProgramParameters& oth);

            /** Internal method for providing a link to a name->definition map for parameters. */
            void _setNamedConstants(const GpuNamedConstants* constantmap);

            /** Internal method for providing a link to a logical index->physical index map for parameters. */
            void _setLogicalIndexes(GpuLogicalBufferStruct* floatIndexMap, 
                  GpuLogicalBufferStruct* intIndexMap);


            /// Does this parameter set include named parameters?
00736             bool hasNamedParameters() const { return mNamedConstants != 0;}
            /** Does this parameter set include logically indexed parameters?
            @note Not mutually exclusive with hasNamedParameters since some high-level
                  programs still use logical indexes to set the parameters on the 
                  rendersystem.
            */
00742             bool hasLogicalIndexedParameters() const { return mFloatLogicalToPhysical != 0;}

            /** Sets a 4-element floating-point parameter to the program.
            @param index The logical constant index at which to place the parameter 
                  (each constant is a 4D float)
            @param vec The value to set
            */
            void setConstant(size_t index, const Vector4& vec);
            /** Sets a single floating-point parameter to the program.
            @note This is actually equivalent to calling 
            setConstant(index Vector4(val, 0, 0, 0)) since all constants are 4D.
            @param index The logical constant index at which to place the parameter (each constant is
            a 4D float)
            @param val The value to set
            */
            void setConstant(size_t index, Real val);
            /** Sets a 4-element floating-point parameter to the program via Vector3.
            @param index The logical constant index at which to place the parameter (each constant is
            a 4D float).
            Note that since you're passing a Vector3, the last element of the 4-element
            value will be set to 1 (a homogenous vector)
            @param vec The value to set
            */
            void setConstant(size_t index, const Vector3& vec);
            /** Sets a Matrix4 parameter to the program.
            @param index The logical constant index at which to place the parameter (each constant is
            a 4D float).
            NB since a Matrix4 is 16 floats long, this parameter will take up 4 indexes.
            @param m The value to set
            */
            void setConstant(size_t index, const Matrix4& m);
        /** Sets a list of Matrix4 parameters to the program.
        @param index The logical constant index at which to start placing the parameter (each constant is
        a 4D float).
        NB since a Matrix4 is 16 floats long, so each entry will take up 4 indexes.
        @param m Pointer to an array of matrices to set
        @param numEntries Number of Matrix4 entries
        */
        void setConstant(size_t index, const Matrix4* m, size_t numEntries);
            /** Sets a multiple value constant floating-point parameter to the program.
            @param index The logical constant index at which to start placing parameters (each constant is
            a 4D float)
            @param val Pointer to the values to write, must contain 4*count floats
            @param count The number of groups of 4 floats to write
            */
            void setConstant(size_t index, const float *val, size_t count);
            /** Sets a multiple value constant floating-point parameter to the program.
            @param index The logical constant index at which to start placing parameters (each constant is
            a 4D float)
            @param val Pointer to the values to write, must contain 4*count floats
            @param count The number of groups of 4 floats to write
            */
            void setConstant(size_t index, const double *val, size_t count);
            /** Sets a ColourValue parameter to the program.
            @param index The logical constant index at which to place the parameter (each constant is
            a 4D float)
            @param colour The value to set
            */
        void setConstant(size_t index, const ColourValue& colour);
            
            /** Sets a multiple value constant integer parameter to the program.
        @remarks
            Different types of GPU programs support different types of constant parameters.
            For example, it's relatively common to find that vertex programs only support
            floating point constants, and that fragment programs only support integer (fixed point)
            parameters. This can vary depending on the program version supported by the
            graphics card being used. You should consult the documentation for the type of
            low level program you are using, or alternatively use the methods
            provided on RenderSystemCapabilities to determine the options.
            @param index The logical constant index at which to place the parameter (each constant is
            a 4D integer)
            @param val Pointer to the values to write, must contain 4*count ints
            @param count The number of groups of 4 ints to write
            */
            void setConstant(size_t index, const int *val, size_t count);

            /** Write a series of floating point values into the underlying float 
                  constant buffer at the given physical index.
            @param physicalIndex The buffer position to start writing
            @param val Pointer to a list of values to write
            @param count The number of floats to write
            */
            void _writeRawConstants(size_t physicalIndex, const float* val, size_t count);
            /** Write a series of floating point values into the underlying float 
            constant buffer at the given physical index.
            @param physicalIndex The buffer position to start writing
            @param val Pointer to a list of values to write
            @param count The number of floats to write
            */
            void _writeRawConstants(size_t physicalIndex, const double* val, size_t count);
            /** Write a series of integer values into the underlying integer
                  constant buffer at the given physical index.
            @param physicalIndex The buffer position to start writing
            @param val Pointer to a list of values to write
            @param count The number of ints to write
            */
            void _writeRawConstants(size_t physicalIndex, const int* val, size_t count);
            /** Read a series of floating point values from the underlying float 
                  constant buffer at the given physical index.
            @param physicalIndex The buffer position to start reading
            @param count The number of floats to read
            @param dest Pointer to a buffer to receive the values
            */
            void _readRawConstants(size_t physicalIndex, size_t count, float* dest);
            /** Read a series of integer values from the underlying integer 
            constant buffer at the given physical index.
            @param physicalIndex The buffer position to start reading
            @param count The number of ints to read
            @param dest Pointer to a buffer to receive the values
            */
            void _readRawConstants(size_t physicalIndex, size_t count, int* dest);

            /** Write a 4-element floating-point parameter to the program directly to 
                  the underlying constants buffer.
            @note You can use these methods if you have already derived the physical
                  constant buffer location, for a slight speed improvement over using
                  the named / logical index versions.
            @param physicalIndex The physical buffer index at which to place the parameter 
            @param vec The value to set
            @param count The number of floats to write; if for example
                  the uniform constant 'slot' is smaller than a Vector4
            */
            void _writeRawConstant(size_t physicalIndex, const Vector4& vec, 
                  size_t count = 4);
            /** Write a single floating-point parameter to the program.
            @note You can use these methods if you have already derived the physical
            constant buffer location, for a slight speed improvement over using
            the named / logical index versions.
            @param physicalIndex The physical buffer index at which to place the parameter 
            @param val The value to set
            */
            void _writeRawConstant(size_t physicalIndex, Real val);
            /** Write a single integer parameter to the program.
            @note You can use these methods if you have already derived the physical
            constant buffer location, for a slight speed improvement over using
            the named / logical index versions.
            @param physicalIndex The physical buffer index at which to place the parameter 
            @param val The value to set
            */
            void _writeRawConstant(size_t physicalIndex, int val);
            /** Write a 3-element floating-point parameter to the program via Vector3.
            @note You can use these methods if you have already derived the physical
            constant buffer location, for a slight speed improvement over using
            the named / logical index versions.
            @param physicalIndex The physical buffer index at which to place the parameter 
            @param vec The value to set
            */
            void _writeRawConstant(size_t physicalIndex, const Vector3& vec);
            /** Write a Matrix4 parameter to the program.
            @note You can use these methods if you have already derived the physical
            constant buffer location, for a slight speed improvement over using
            the named / logical index versions.
            @param physicalIndex The physical buffer index at which to place the parameter 
            @param m The value to set
            */
            void _writeRawConstant(size_t physicalIndex, const Matrix4& m);
        /** Write a list of Matrix4 parameters to the program.
            @note You can use these methods if you have already derived the physical
            constant buffer location, for a slight speed improvement over using
            the named / logical index versions.
            @param physicalIndex The physical buffer index at which to place the parameter 
        @param numEntries Number of Matrix4 entries
        */
        void _writeRawConstant(size_t physicalIndex, const Matrix4* m, size_t numEntries);
            /** Write a ColourValue parameter to the program.
            @note You can use these methods if you have already derived the physical
            constant buffer location, for a slight speed improvement over using
            the named / logical index versions.
            @param physicalIndex The physical buffer index at which to place the parameter 
            @param colour The value to set
            @param count The number of floats to write; if for example
                  the uniform constant 'slot' is smaller than a Vector4
            */
        void _writeRawConstant(size_t physicalIndex, const ColourValue& colour, 
                  size_t count = 4);
            

        /** Gets an iterator over the named GpuConstantDefinition instances as defined
                  by the program for which these parameters exist.
            @note
                  Only available if this parameters object has named parameters.
            */
        GpuConstantDefinitionIterator getConstantDefinitionIterator(void) const;

            /** Get a specific GpuConstantDefinition for a named parameter.
            @note
                  Only available if this parameters object has named parameters.
            */
            const GpuConstantDefinition& getConstantDefinition(const String& name) const;

            /** Get the full list of GpuConstantDefinition instances.
            @note
            Only available if this parameters object has named parameters.
            */
            const GpuNamedConstants& getConstantDefinitions() const;

            /** Get the current list of mappings from low-level logical param indexes
                  to physical buffer locations in the float buffer.
            @note
                  Only applicable to low-level programs.
            */
00943             const GpuLogicalBufferStruct* getFloatLogicalBufferStruct() const { return mFloatLogicalToPhysical; }

            /** Retrieves the logical index relating to a physical index in the float
                  buffer, for programs which support that (low-level programs and 
                  high-level programs which use logical parameter indexes).
                  @returns std::numeric_limits<size_t>::max() if not found
            */
            size_t getFloatLogicalIndexForPhysicalIndex(size_t physicalIndex);
            /** Retrieves the logical index relating to a physical index in the int
            buffer, for programs which support that (low-level programs and 
            high-level programs which use logical parameter indexes).
            @returns std::numeric_limits<size_t>::max() if not found
            */
            size_t getIntLogicalIndexForPhysicalIndex(size_t physicalIndex);

            /** Get the current list of mappings from low-level logical param indexes
                  to physical buffer locations in the integer buffer.
            @note
                  Only applicable to low-level programs.
            */
00963             const GpuLogicalBufferStruct* getIntLogicalBufferStruct() const { return mIntLogicalToPhysical; }
            /// Get a reference to the list of float constants
00965             const FloatConstantList& getFloatConstantList() const { return mFloatConstants; }
            /// Get a pointer to the 'nth' item in the float buffer
00967             float* getFloatPointer(size_t pos) { return &mFloatConstants[pos]; }
            /// Get a pointer to the 'nth' item in the float buffer
00969             const float* getFloatPointer(size_t pos) const { return &mFloatConstants[pos]; }
            /// Get a reference to the list of int constants
00971             const IntConstantList& getIntConstantList() const { return mIntConstants; }
            /// Get a pointer to the 'nth' item in the int buffer
00973             int* getIntPointer(size_t pos) { return &mIntConstants[pos]; }
            /// Get a pointer to the 'nth' item in the int buffer
00975             const int* getIntPointer(size_t pos) const { return &mIntConstants[pos]; }
            /// Get a reference to the list of auto constant bindings
00977             const AutoConstantList& getAutoConstantList() const { return mAutoConstants; }

        /** Sets up a constant which will automatically be updated by the system.
        @remarks
            Vertex and fragment programs often need parameters which are to do with the
            current render state, or particular values which may very well change over time,
            and often between objects which are being rendered. This feature allows you 
            to set up a certain number of predefined parameter mappings that are kept up to 
            date for you.
        @param index The location in the constant list to place this updated constant every time
            it is changed. Note that because of the nature of the types, we know how big the 
            parameter details will be so you don't need to set that like you do for manual constants.
        @param acType The type of automatic constant to set
        @param extraInfo If the constant type needs more information (like a light index) put it here.
        */
        void setAutoConstant(size_t index, AutoConstantType acType, size_t extraInfo = 0);
            void setAutoConstantReal(size_t index, AutoConstantType acType, Real rData);

            /** As setAutoConstant, but sets up the auto constant directly against a
                  physical buffer index.
            */
            void _setRawAutoConstant(size_t physicalIndex, AutoConstantType acType, size_t extraInfo, 
                  size_t elementSize = 4);
            /** As setAutoConstantReal, but sets up the auto constant directly against a
            physical buffer index.
            */
            void _setRawAutoConstantReal(size_t physicalIndex, AutoConstantType acType, Real rData, 
                  size_t elementSize = 4);


            /** Unbind an auto constant so that the constant is manually controlled again. */
            void clearAutoConstant(size_t index);

        /** Sets a named parameter up to track a derivation of the current time.
        @param index The index of the parameter
        @param factor The amount by which to scale the time value
        */  
        void setConstantFromTime(size_t index, Real factor);

        /** Clears all the existing automatic constants. */
        void clearAutoConstants(void);
        typedef ConstVectorIterator<AutoConstantList> AutoConstantIterator;
        /** Gets an iterator over the automatic constant bindings currently in place. */
        AutoConstantIterator getAutoConstantIterator(void) const;
        /// Gets the number of int constants that have been set
01022         size_t getAutoConstantCount(void) const { return mAutoConstants.size(); }
            /** Gets a specific Auto Constant entry if index is in valid range
                  otherwise returns a NULL
            @parem index which entry is to be retrieved
            */
            AutoConstantEntry* getAutoConstantEntry(const size_t index);
        /** Returns true if this instance has any automatic constants. */
01029         bool hasAutoConstants(void) const { return !(mAutoConstants.empty()); }
            /** Finds an auto constant that's affecting a given logical parameter 
                  index for floating-point values.
            @note Only applicable for low-level programs.
            */
            const AutoConstantEntry* findFloatAutoConstantEntry(size_t logicalIndex);
            /** Finds an auto constant that's affecting a given logical parameter 
            index for integer values.
            @note Only applicable for low-level programs.
            */
            const AutoConstantEntry* findIntAutoConstantEntry(size_t logicalIndex);
            /** Finds an auto constant that's affecting a given named parameter index.
            @note Only applicable to high-level programs.
            */
            const AutoConstantEntry* findAutoConstantEntry(const String& paramName);
            /** Finds an auto constant that's affecting a given physical position in 
                  the floating-point buffer
            */
            const AutoConstantEntry* _findRawAutoConstantEntryFloat(size_t physicalIndex);
            /** Finds an auto constant that's affecting a given physical position in 
            the integer buffer
            */
            const AutoConstantEntry* _findRawAutoConstantEntryInt(size_t physicalIndex);

        /** Updates the automatic parameters (except lights) based on the details provided. */
        void _updateAutoParamsNoLights(const AutoParamDataSource& source);
        /** Updates the automatic parameters for lights based on the details provided. */
        void _updateAutoParamsLightsOnly(const AutoParamDataSource& source);

            /** Tells the program whether to ignore missing parameters or not.
            */
01060             void setIgnoreMissingParams(bool state) { mIgnoreMissingParams = state; }

            /** Sets a single value constant floating-point parameter to the program.
        @remarks
            Different types of GPU programs support different types of constant parameters.
            For example, it's relatively common to find that vertex programs only support
            floating point constants, and that fragment programs only support integer (fixed point)
            parameters. This can vary depending on the program version supported by the
            graphics card being used. You should consult the documentation for the type of
            low level program you are using, or alternatively use the methods
            provided on RenderSystemCapabilities to determine the options.
        @par
            Another possible limitation is that some systems only allow constants to be set
            on certain boundaries, e.g. in sets of 4 values for example. Again, see
            RenderSystemCapabilities for full details.
        @note
            This named option will only work if you are using a parameters object created
            from a high-level program (HighLevelGpuProgram).
            @param name The name of the parameter
            @param val The value to set
            */
            void setNamedConstant(const String& name, Real val);
            /** Sets a single value constant integer parameter to the program.
        @remarks
            Different types of GPU programs support different types of constant parameters.
            For example, it's relatively common to find that vertex programs only support
            floating point constants, and that fragment programs only support integer (fixed point)
            parameters. This can vary depending on the program version supported by the
            graphics card being used. You should consult the documentation for the type of
            low level program you are using, or alternatively use the methods
            provided on RenderSystemCapabilities to determine the options.
        @par
            Another possible limitation is that some systems only allow constants to be set
            on certain boundaries, e.g. in sets of 4 values for example. Again, see
            RenderSystemCapabilities for full details.
        @note
            This named option will only work if you are using a parameters object created
            from a high-level program (HighLevelGpuProgram).
        @param name The name of the parameter
            @param val The value to set
            */
            void setNamedConstant(const String& name, int val);
            /** Sets a Vector4 parameter to the program.
        @param name The name of the parameter
            @param vec The value to set
            */
            void setNamedConstant(const String& name, const Vector4& vec);
            /** Sets a Vector3 parameter to the program.
        @note
            This named option will only work if you are using a parameters object created
            from a high-level program (HighLevelGpuProgram).
            @param index The index at which to place the parameter
                  NB this index refers to the number of floats, so a Vector3 is 3. Note that many 
            rendersystems & programs assume that every floating point parameter is passed in
            as a vector of 4 items, so you are strongly advised to check with 
            RenderSystemCapabilities before using this version - if in doubt use Vector4
            or ColourValue instead (both are 4D).
            @param vec The value to set
            */
            void setNamedConstant(const String& name, const Vector3& vec);
            /** Sets a Matrix4 parameter to the program.
        @param name The name of the parameter
            @param m The value to set
            */
            void setNamedConstant(const String& name, const Matrix4& m);
        /** Sets a list of Matrix4 parameters to the program.
        @param name The name of the parameter; this must be the first index of an array,
            for examples 'matrices[0]'
        NB since a Matrix4 is 16 floats long, so each entry will take up 4 indexes.
        @param m Pointer to an array of matrices to set
        @param numEntries Number of Matrix4 entries
        */
        void setNamedConstant(const String& name, const Matrix4* m, size_t numEntries);
            /** Sets a multiple value constant floating-point parameter to the program.
        @par
            Some systems only allow constants to be set on certain boundaries, 
                  e.g. in sets of 4 values for example. The 'multiple' parameter allows
                  you to control that although you should only change it if you know
                  your chosen language supports that (at the time of writing, only
                  GLSL allows constants which are not a multiple of 4).
        @note
            This named option will only work if you are using a parameters object created
            from a high-level program (HighLevelGpuProgram).
        @param name The name of the parameter
            @param val Pointer to the values to write
            @param count The number of 'multiples' of floats to write
            @param multiple The number of raw entries in each element to write, 
                  the default is 4 so count = 1 would write 4 floats.
            */
            void setNamedConstant(const String& name, const float *val, size_t count, 
                  size_t multiple = 4);
            /** Sets a multiple value constant floating-point parameter to the program.
        @par
            Some systems only allow constants to be set on certain boundaries, 
                  e.g. in sets of 4 values for example. The 'multiple' parameter allows
                  you to control that although you should only change it if you know
                  your chosen language supports that (at the time of writing, only
                  GLSL allows constants which are not a multiple of 4).
        @note
            This named option will only work if you are using a parameters object created
            from a high-level program (HighLevelGpuProgram).
        @param name The name of the parameter
            @param val Pointer to the values to write
            @param count The number of 'multiples' of floats to write
            @param multiple The number of raw entries in each element to write, 
                  the default is 4 so count = 1 would write 4 floats.
            */
            void setNamedConstant(const String& name, const double *val, size_t count, 
                  size_t multiple = 4);
            /** Sets a ColourValue parameter to the program.
        @param name The name of the parameter
            @param colour The value to set
            */
        void setNamedConstant(const String& name, const ColourValue& colour);
            
            /** Sets a multiple value constant floating-point parameter to the program.
        @par
            Some systems only allow constants to be set on certain boundaries, 
                  e.g. in sets of 4 values for example. The 'multiple' parameter allows
                  you to control that although you should only change it if you know
                  your chosen language supports that (at the time of writing, only
                  GLSL allows constants which are not a multiple of 4).
        @note
            This named option will only work if you are using a parameters object created
            from a high-level program (HighLevelGpuProgram).
        @param name The name of the parameter
            @param val Pointer to the values to write
            @param count The number of 'multiples' of floats to write
            @param multiple The number of raw entries in each element to write, 
                  the default is 4 so count = 1 would write 4 floats.
            */
            void setNamedConstant(const String& name, const int *val, size_t count, 
                  size_t multiple = 4);

        /** Sets up a constant which will automatically be updated by the system.
        @remarks
            Vertex and fragment programs often need parameters which are to do with the
            current render state, or particular values which may very well change over time,
            and often between objects which are being rendered. This feature allows you 
            to set up a certain number of predefined parameter mappings that are kept up to 
            date for you.
        @note
            This named option will only work if you are using a parameters object created
            from a high-level program (HighLevelGpuProgram).
        @param name The name of the parameter
        @param acType The type of automatic constant to set
        @param extraInfo If the constant type needs more information (like a light index) put it here.
        */
        void setNamedAutoConstant(const String& name, AutoConstantType acType, size_t extraInfo = 0);
            void setNamedAutoConstantReal(const String& name, AutoConstantType acType, Real rData);

        /** Sets a named parameter up to track a derivation of the current time.
        @note
            This named option will only work if you are using a parameters object created
            from a high-level program (HighLevelGpuProgram).
        @param name The name of the parameter
        @param factor The amount by which to scale the time value
        */  
        void setNamedConstantFromTime(const String& name, Real factor);

            /** Unbind an auto constant so that the constant is manually controlled again. */
            void clearNamedAutoConstant(const String& name);

        /** Find a constant definition for a named parameter.
            @remarks
                  This method returns null if the named parameter did not exist, unlike
                  getConstantDefinition which is more strict; unless you set the 
                  last parameter to true.
            @param name The name to look up
            @param throwExceptionIfMissing If set to true, failure to find an entry
                  will throw an exception.
            */
        const GpuConstantDefinition* _findNamedConstantDefinition(
                  const String& name, bool throwExceptionIfMissing = false) const;
            /** Gets the physical buffer index associated with a logical float constant index. 
            @note Only applicable to low-level programs.
            @param logicalIndex The logical parameter index
            @param requestedSize The requested size - pass 0 to ignore missing entries
                  and return std::numeric_limits<size_t>::max() 
            */
            size_t _getFloatConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize);
            /** Gets the physical buffer index associated with a logical int constant index. 
            @note Only applicable to low-level programs.
            @param logicalIndex The logical parameter index
            @param requestedSize The requested size - pass 0 to ignore missing entries
                  and return std::numeric_limits<size_t>::max() 
            */
            size_t _getIntConstantPhysicalIndex(size_t logicalIndex, size_t requestedSize);


        /** Sets whether or not we need to transpose the matrices passed in from the rest of OGRE.
        @remarks
            D3D uses transposed matrices compared to GL and OGRE; this is not important when you
            use programs which are written to process row-major matrices, such as those generated
            by Cg, but if you use a program written to D3D's matrix layout you will need to enable
            this flag.
        */
01257         void setTransposeMatrices(bool val) { mTransposeMatrices = val; } 
        /// Gets whether or not matrices are to be transposed when set
01259         bool getTransposeMatrices(void) const { return mTransposeMatrices; } 

            /** Copies the values of all constants (including auto constants) from another
                  GpuProgramParameters object.
            */
            void copyConstantsFrom(const GpuProgramParameters& source);

        /** gets the auto constant definition associated with name if found else returns NULL
        @param name The name of the auto constant
        */
        static const AutoConstantDefinition* getAutoConstantDefinition(const String& name);
        /** gets the auto constant definition using an index into the auto constant definition array.
            If the index is out of bounds then NULL is returned;
        @param idx The auto constant index
        */
        static const AutoConstantDefinition* getAutoConstantDefinition(const size_t idx);
        /** Returns the number of auto constant definitions
        */
        static size_t getNumAutoConstantDefinitions(void);


        /** increments the multipass number entry by 1 if it exists
        */
        void incPassIterationNumber(void);
            /** Does this parameters object have a pass iteration number constant? */
01284             bool hasPassIterationNumber() const 
            { return mActivePassIterationIndex != (std::numeric_limits<size_t>::max)(); }
            /** Get the physical buffer index of the pass iteration number constant */
01287             size_t getPassIterationNumberIndex() const 
            { return mActivePassIterationIndex; }


    };

    /// Shared pointer used to hold references to GpuProgramParameters instances
01294     typedef SharedPtr<GpuProgramParameters> GpuProgramParametersSharedPtr;

    // Forward declaration 
    class GpuProgramPtr;

      /** Defines a program which runs on the GPU such as a vertex or fragment program. 
      @remarks
            This class defines the low-level program in assembler code, the sort used to
            directly assemble into machine instructions for the GPU to execute. By nature,
            this means that the assembler source is rendersystem specific, which is why this
            is an abstract class - real instances are created through the RenderSystem. 
            If you wish to use higher level shading languages like HLSL and Cg, you need to 
            use the HighLevelGpuProgram class instead.
      */
01308       class _OgreExport GpuProgram : public Resource
      {
      protected:
            /// Command object - see ParamCommand 
01312             class _OgreExport CmdType : public ParamCommand
            {
            public:
                  String doGet(const void* target) const;
                  void doSet(void* target, const String& val);
            };
            class _OgreExport CmdSyntax : public ParamCommand
            {
            public:
                  String doGet(const void* target) const;
                  void doSet(void* target, const String& val);
            };
            class _OgreExport CmdSkeletal : public ParamCommand
            {
            public:
                  String doGet(const void* target) const;
                  void doSet(void* target, const String& val);
            };
            class _OgreExport CmdMorph : public ParamCommand
            {
            public:
                  String doGet(const void* target) const;
                  void doSet(void* target, const String& val);
            };
            class _OgreExport CmdPose : public ParamCommand
            {
            public:
                  String doGet(const void* target) const;
                  void doSet(void* target, const String& val);
            };
            class _OgreExport CmdVTF : public ParamCommand
            {
            public:
                  String doGet(const void* target) const;
                  void doSet(void* target, const String& val);
            };
            // Command object for setting / getting parameters
            static CmdType msTypeCmd;
            static CmdSyntax msSyntaxCmd;
            static CmdSkeletal msSkeletalCmd;
            static CmdMorph msMorphCmd;
            static CmdPose msPoseCmd;
            static CmdVTF msVTFCmd;
      
            /// The type of the program
01357             GpuProgramType mType;
            /// The name of the file to load source from (may be blank)
01359             String mFilename;
        /// The assembler source of the program (may be blank until file loaded)
01361         String mSource;
        /// Whether we need to load source from file or not
01363         bool mLoadFromFile;
        /// Syntax code eg arbvp1, vs_2_0 etc
01365         String mSyntaxCode;
        /// Does this (vertex) program include skeletal animation?
01367         bool mSkeletalAnimation;
            /// Does this (vertex) program include morph animation?
01369             bool mMorphAnimation;
            /// Does this (vertex) program include pose animation (count of number of poses supported)
01371             ushort mPoseAnimation;
            /// Does this (vertex) program require support for vertex texture fetch?
01373             bool mVertexTextureFetch;
            /// The default parameters for use with this object
01375             GpuProgramParametersSharedPtr mDefaultParams;
            /// Does this program want light states passed through fixed pipeline
01377             bool mPassSurfaceAndLightStates;
            /// Did we encounter a compilation error?
01379             bool mCompileError;
            /** Record of logical to physical buffer maps. Mandatory for low-level
                  programs or high-level programs which set their params the same way. */
01382             mutable GpuLogicalBufferStruct mFloatLogicalToPhysical;
            /** Record of logical to physical buffer maps. Mandatory for low-level
                  programs or high-level programs which set their params the same way. */
01385             mutable GpuLogicalBufferStruct mIntLogicalToPhysical;

            /** Internal method for setting up the basic parameter definitions for a subclass. 
            @remarks
            Because StringInterface holds a dictionary of parameters per class, subclasses need to
            call this to ask the base class to add it's parameters to their dictionary as well.
            Can't do this in the constructor because that runs in a non-virtual context.
            @par
            The subclass must have called it's own createParamDictionary before calling this method.
            */
            void setupBaseParamDictionary(void);

        /** Internal method returns whether required capabilities for this program is supported.
        */
        bool isRequiredCapabilitiesSupported(void) const;

            /// @copydoc Resource::calculateSize
01402             size_t calculateSize(void) const { return 0; } // TODO 

            /// @copydoc Resource::loadImpl
            void loadImpl(void);
      public:

            GpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle,
                  const String& group, bool isManual = false, ManualResourceLoader* loader = 0);

            virtual ~GpuProgram() {}

        /** Sets the filename of the source assembly for this program.
        @remarks
            Setting this will have no effect until you (re)load the program.
        */
        virtual void setSourceFile(const String& filename);

            /** Sets the source assembly for this program from an in-memory string.
        @remarks
            Setting this will have no effect until you (re)load the program.
        */
        virtual void setSource(const String& source);

        /** Gets the syntax code for this program e.g. arbvp1, fp20, vs_1_1 etc */
01426         virtual const String& getSyntaxCode(void) const { return mSyntaxCode; }

            /** Sets the syntax code for this program e.g. arbvp1, fp20, vs_1_1 etc */
            virtual void setSyntaxCode(const String& syntax);

            /** Gets the name of the file used as source for this program. */
01432             virtual const String& getSourceFile(void) const { return mFilename; }
        /** Gets the assembler source for this program. */
01434         virtual const String& getSource(void) const { return mSource; }
            /// Set the program type (only valid before load)
            virtual void setType(GpuProgramType t);
        /// Get the program type
01438         virtual GpuProgramType getType(void) const { return mType; }

        /** Returns the GpuProgram which should be bound to the pipeline.
        @remarks
            This method is simply to allow some subclasses of GpuProgram to delegate
            the program which is bound to the pipeline to a delegate, if required. */
01444         virtual GpuProgram* _getBindingDelegate(void) { return this; }

        /** Returns whether this program can be supported on the current renderer and hardware. */
        virtual bool isSupported(void) const;

        /** Creates a new parameters object compatible with this program definition. 
        @remarks
            It is recommended that you use this method of creating parameters objects
            rather than going direct to GpuProgramManager, because this method will
            populate any implementation-specific extras (like named parameters) where
            they are appropriate.
        */
        virtual GpuProgramParametersSharedPtr createParameters(void);

        /** Sets whether a vertex program includes the required instructions
        to perform skeletal animation. 
        @remarks
        If this is set to true, OGRE will not blend the geometry according to 
        skeletal animation, it will expect the vertex program to do it.
        */
01464         virtual void setSkeletalAnimationIncluded(bool included) 
        { mSkeletalAnimation = included; }

        /** Returns whether a vertex program includes the required instructions
            to perform skeletal animation. 
        @remarks
            If this returns true, OGRE will not blend the geometry according to 
            skeletal animation, it will expect the vertex program to do it.
        */
01473         virtual bool isSkeletalAnimationIncluded(void) const { return mSkeletalAnimation; }

        /** Sets whether a vertex program includes the required instructions
        to perform morph animation. 
        @remarks
        If this is set to true, OGRE will not blend the geometry according to 
        morph animation, it will expect the vertex program to do it.
        */
01481         virtual void setMorphAnimationIncluded(bool included) 
            { mMorphAnimation = included; }

        /** Sets whether a vertex program includes the required instructions
        to perform pose animation. 
        @remarks
        If this is set to true, OGRE will not blend the geometry according to 
        pose animation, it will expect the vertex program to do it.
            @param poseCount The number of simultaneous poses the program can blend
        */
01491         virtual void setPoseAnimationIncluded(ushort poseCount) 
            { mPoseAnimation = poseCount; }

            /** Returns whether a vertex program includes the required instructions
            to perform morph animation. 
        @remarks
            If this returns true, OGRE will not blend the geometry according to 
            morph animation, it will expect the vertex program to do it.
        */
01500         virtual bool isMorphAnimationIncluded(void) const { return mMorphAnimation; }

            /** Returns whether a vertex program includes the required instructions
            to perform pose animation. 
        @remarks
            If this returns true, OGRE will not blend the geometry according to 
            pose animation, it will expect the vertex program to do it.
        */
01508         virtual bool isPoseAnimationIncluded(void) const { return mPoseAnimation > 0; }
            /** Returns the number of simultaneous poses the vertex program can 
                  blend, for use in pose animation.
        */
01512         virtual ushort getNumberOfPosesIncluded(void) const { return mPoseAnimation; }
            /** Sets whether this vertex program requires support for vertex 
                  texture fetch from the hardware.
            */
01516             virtual void setVertexTextureFetchRequired(bool r) { mVertexTextureFetch = r; }
            /** Returns whether this vertex program requires support for vertex 
                  texture fetch from the hardware.
            */
01520             virtual bool isVertexTextureFetchRequired(void) const { return mVertexTextureFetch; }

            /** Get a reference to the default parameters which are to be used for all
                  uses of this program.
            @remarks
                  A program can be set up with a list of default parameters, which can save time when 
                  using a program many times in a material with roughly the same settings. By 
                  retrieving the default parameters and populating it with the most used options, 
                  any new parameter objects created from this program afterwards will automatically include
                  the default parameters; thus users of the program need only change the parameters
                  which are unique to their own usage of the program.
            */
            virtual GpuProgramParametersSharedPtr getDefaultParameters(void);

        /** Returns true if default parameters have been set up.  
        */
01536         virtual bool hasDefaultParameters(void) const { return !mDefaultParams.isNull(); }

            /** Sets whether a vertex program requires light and material states to be passed
            to through fixed pipeline low level API rendering calls.
            @remarks
            If this is set to true, OGRE will pass all active light states to the fixed function
            pipeline.  This is useful for high level shaders like GLSL that can read the OpenGL
            light and material states.  This way the user does not have to use autoparameters to 
            pass light position, color etc.
            */
01546             virtual void setSurfaceAndPassLightStates(bool state)
                  { mPassSurfaceAndLightStates = state; }

            /** Returns whether a vertex program wants light and material states to be passed
            through fixed pipeline low level API rendering calls
            */
01552             virtual bool getPassSurfaceAndLightStates(void) const { return mPassSurfaceAndLightStates; }

        /** Returns a string that specifies the language of the gpu programs as specified
        in a material script. ie: asm, cg, hlsl, glsl
        */
        virtual const String& getLanguage(void) const;

            /** Did this program encounter a compile error when loading?
            */
01561             virtual bool hasCompileError(void) const { return mCompileError; }

            /** Reset a compile error if it occurred, allowing the load to be retried
            */
01565             virtual void resetCompileError(void) { mCompileError = false; }
    protected:
        /// Virtual method which must be implemented by subclasses, load from mSource
        virtual void loadFromSource(void) = 0;

      };


      /** Specialisation of SharedPtr to allow SharedPtr to be assigned to GpuProgramPtr 
      @note Has to be a subclass since we need operator=.
      We could templatise this instead of repeating per Resource subclass, 
      except to do so requires a form VC6 does not support i.e.
      ResourceSubclassPtr<T> : public SharedPtr<T>
      */
01579       class _OgreExport GpuProgramPtr : public SharedPtr<GpuProgram> 
      {
      public:
            GpuProgramPtr() : SharedPtr<GpuProgram>() {}
            explicit GpuProgramPtr(GpuProgram* rep) : SharedPtr<GpuProgram>(rep) {}
            GpuProgramPtr(const GpuProgramPtr& r) : SharedPtr<GpuProgram>(r) {} 
            GpuProgramPtr(const ResourcePtr& r) : SharedPtr<GpuProgram>()
            {
                  // lock & copy other mutex pointer
            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
            {
                      OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
                      OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
                      pRep = static_cast<GpuProgram*>(r.getPointer());
                      pUseCount = r.useCountPointer();
                      if (pUseCount)
                      {
                            ++(*pUseCount);
                      }
            }
            }

            /// Operator used to convert a ResourcePtr to a GpuProgramPtr
01602             GpuProgramPtr& operator=(const ResourcePtr& r)
            {
                  if (pRep == static_cast<GpuProgram*>(r.getPointer()))
                        return *this;
                  release();
                  // lock & copy other mutex pointer
            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
            {
                OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
                      OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
                      pRep = static_cast<GpuProgram*>(r.getPointer());
                      pUseCount = r.useCountPointer();
                      if (pUseCount)
                      {
                            ++(*pUseCount);
                      }
            }
                  else
                  {
                        // RHS must be a null pointer
                        assert(r.isNull() && "RHS must be null if it has no mutex!");
                        setNull();
                  }
                  return *this;
            }
        /// Operator used to convert a HighLevelGpuProgramPtr to a GpuProgramPtr
        GpuProgramPtr& operator=(const HighLevelGpuProgramPtr& r);
      };
}

#endif

Generated by  Doxygen 1.6.0   Back to index