/*

  -----------------------------------------------------------------------------

  This source file is part of OGRE

  (Object-oriented Graphics Rendering Engine)

  For the latest info, see http://www.ogre3d.org

Copyright (c) 2000-2014 Torus Knot Software Ltd

  Permission is hereby granted, free of charge, to any person obtaining a copy

  of this software and associated documentation files (the "Software"), to deal

  in the Software without restriction, including without limitation the rights

  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  copies of the Software, and to permit persons to whom the Software is

  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in

  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  THE SOFTWARE.

  -----------------------------------------------------------------------------

*/

#include "OgreStableHeaders.h"

#include "OgreGpuProgramParams.h"

#include "OgreGpuProgramManager.h"

#include "OgreDualQuaternion.h"

namespace Ogre

{

    //---------------------------------------------------------------------

    GpuProgramParameters::AutoConstantDefinition GpuProgramParameters::AutoConstantDictionary[] = {

        AutoConstantDefinition(ACT_WORLD_MATRIX,                  "world_matrix",                16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_WORLD_MATRIX,          "inverse_world_matrix",        16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_TRANSPOSE_WORLD_MATRIX,             "transpose_world_matrix",            16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_WORLD_MATRIX, "inverse_transpose_world_matrix", 16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_BONE_MATRIX_ARRAY_3x4,        "bone_matrix_array_3x4",      12, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_BONE_MATRIX_ARRAY,            "bone_matrix_array",          16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_BONE_DUALQUATERNION_ARRAY_2x4, "bone_dualquaternion_array_2x4",      8, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_BONE_SCALE_SHEAR_MATRIX_ARRAY_3x4, "bone_scale_shear_matrix_array_3x4", 12, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VIEW_MATRIX,                   "view_matrix",                 16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_VIEW_MATRIX,           "inverse_view_matrix",         16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_TRANSPOSE_VIEW_MATRIX,              "transpose_view_matrix",             16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_VIEW_MATRIX,       "inverse_transpose_view_matrix",     16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_PROJECTION_MATRIX,             "projection_matrix",           16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_PROJECTION_MATRIX,          "inverse_projection_matrix",         16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_TRANSPOSE_PROJECTION_MATRIX,        "transpose_projection_matrix",       16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX, "inverse_transpose_projection_matrix", 16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VIEWPROJ_MATRIX,               "viewproj_matrix",             16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_VIEWPROJ_MATRIX,       "inverse_viewproj_matrix",     16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_TRANSPOSE_VIEWPROJ_MATRIX,          "transpose_viewproj_matrix",         16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX,   "inverse_transpose_viewproj_matrix", 16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_WORLDVIEW_MATRIX,              "worldview_matrix",            16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_WORLDVIEW_MATRIX,      "inverse_worldview_matrix",    16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_TRANSPOSE_WORLDVIEW_MATRIX,         "transpose_worldview_matrix",        16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX, "inverse_transpose_worldview_matrix", 16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_NORMAL_MATRIX,                  "normal_matrix",     9, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_WORLDVIEWPROJ_MATRIX,          "worldviewproj_matrix",        16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_WORLDVIEWPROJ_MATRIX,       "inverse_worldviewproj_matrix",      16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX,     "transpose_worldviewproj_matrix",    16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX, "inverse_transpose_worldviewproj_matrix", 16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_WORLDVIEWPROJ_MATRIX_ARRAY,          "worldviewproj_matrix_array",        16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_RENDER_TARGET_FLIPPING,          "render_target_flipping",         1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VERTEX_WINDING,          "vertex_winding",         1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_FOG_COLOUR,                    "fog_colour",                   4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_FOG_PARAMS,                    "fog_params",                   4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_SURFACE_AMBIENT_COLOUR,          "surface_ambient_colour",           4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_SURFACE_DIFFUSE_COLOUR,          "surface_diffuse_colour",           4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_SURFACE_SPECULAR_COLOUR,         "surface_specular_colour",          4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_SURFACE_EMISSIVE_COLOUR,         "surface_emissive_colour",          4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_SURFACE_SHININESS,               "surface_shininess",                1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_SURFACE_ALPHA_REJECTION_VALUE,   "surface_alpha_rejection_value",    1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_LIGHT_COUNT,                   "light_count",                  1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_AMBIENT_LIGHT_COLOUR,          "ambient_light_colour",         4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_LIGHT_DIFFUSE_COLOUR,          "light_diffuse_colour",         4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_SPECULAR_COLOUR,         "light_specular_colour",        4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_ATTENUATION,             "light_attenuation",            4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SPOTLIGHT_PARAMS,              "spotlight_params",             4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_POSITION,                "light_position",               4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_POSITION_OBJECT_SPACE,   "light_position_object_space",  4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_POSITION_VIEW_SPACE,          "light_position_view_space",    4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIRECTION,               "light_direction",              4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIRECTION_OBJECT_SPACE,  "light_direction_object_space", 4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIRECTION_VIEW_SPACE,         "light_direction_view_space",   4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DISTANCE_OBJECT_SPACE,   "light_distance_object_space",  1, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_POWER_SCALE,                     "light_power",  1, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED, "light_diffuse_colour_power_scaled",         4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED, "light_specular_colour_power_scaled",        4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIFFUSE_COLOUR_ARRAY,          "light_diffuse_colour_array",         4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_SPECULAR_COLOUR_ARRAY,         "light_specular_colour_array",        4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY, "light_diffuse_colour_power_scaled_array",         4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY, "light_specular_colour_power_scaled_array",        4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_ATTENUATION_ARRAY,             "light_attenuation_array",            4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_POSITION_ARRAY,                "light_position_array",               4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY,   "light_position_object_space_array",  4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY,          "light_position_view_space_array",    4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIRECTION_ARRAY,               "light_direction_array",              4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY,  "light_direction_object_space_array", 4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY,         "light_direction_view_space_array",   4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY,   "light_distance_object_space_array",  1, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_POWER_SCALE_ARRAY,               "light_power_array",  1, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SPOTLIGHT_PARAMS_ARRAY,              "spotlight_params_array",             4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_DERIVED_AMBIENT_LIGHT_COLOUR,    "derived_ambient_light_colour",     4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_DERIVED_SCENE_COLOUR,            "derived_scene_colour",             4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_DERIVED_LIGHT_DIFFUSE_COLOUR,    "derived_light_diffuse_colour",     4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_DERIVED_LIGHT_SPECULAR_COLOUR,   "derived_light_specular_colour",    4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY,  "derived_light_diffuse_colour_array",   4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY, "derived_light_specular_colour_array",  4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_NUMBER,                                          "light_number",  1, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_CASTS_SHADOWS,                           "light_casts_shadows",  1, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LIGHT_CASTS_SHADOWS_ARRAY,     "light_casts_shadows_array",  1, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SHADOW_EXTRUSION_DISTANCE,     "shadow_extrusion_distance",    1, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_CAMERA_POSITION,               "camera_position",              3, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_CAMERA_POSITION_OBJECT_SPACE,  "camera_position_object_space", 3, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_CAMERA_RELATIVE_POSITION,      "camera_relative_position",     3, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_TEXTURE_VIEWPROJ_MATRIX,       "texture_viewproj_matrix",     16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY, "texture_viewproj_matrix_array", 16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_TEXTURE_WORLDVIEWPROJ_MATRIX,  "texture_worldviewproj_matrix",16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY, "texture_worldviewproj_matrix_array",16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SPOTLIGHT_VIEWPROJ_MATRIX,       "spotlight_viewproj_matrix",     16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY, "spotlight_viewproj_matrix_array", 16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX,  "spotlight_worldviewproj_matrix",16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX_ARRAY,  "spotlight_worldviewproj_matrix_array",16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_CUSTOM,                        "custom",                       4, ET_REAL, ACDT_INT),  // *** needs to be tested

        AutoConstantDefinition(ACT_TIME,                               "time",                               1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TIME_0_X,                      "time_0_x",                     1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_COSTIME_0_X,                   "costime_0_x",                  1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_SINTIME_0_X,                   "sintime_0_x",                  1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TANTIME_0_X,                   "tantime_0_x",                  1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TIME_0_X_PACKED,               "time_0_x_packed",              4, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TIME_0_1,                      "time_0_1",                     1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_COSTIME_0_1,                   "costime_0_1",                  1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_SINTIME_0_1,                   "sintime_0_1",                  1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TANTIME_0_1,                   "tantime_0_1",                  1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TIME_0_1_PACKED,               "time_0_1_packed",              4, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TIME_0_2PI,                    "time_0_2pi",                   1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_COSTIME_0_2PI,                 "costime_0_2pi",                1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_SINTIME_0_2PI,                 "sintime_0_2pi",                1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TANTIME_0_2PI,                 "tantime_0_2pi",                1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_TIME_0_2PI_PACKED,             "time_0_2pi_packed",            4, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_FRAME_TIME,                    "frame_time",                   1, ET_REAL, ACDT_REAL),

        AutoConstantDefinition(ACT_FPS,                           "fps",                          1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VIEWPORT_WIDTH,                "viewport_width",               1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VIEWPORT_HEIGHT,               "viewport_height",              1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_VIEWPORT_WIDTH,        "inverse_viewport_width",       1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_INVERSE_VIEWPORT_HEIGHT,       "inverse_viewport_height",      1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VIEWPORT_SIZE,                 "viewport_size",                4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VIEW_DIRECTION,                "view_direction",               3, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VIEW_SIDE_VECTOR,              "view_side_vector",             3, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_VIEW_UP_VECTOR,                "view_up_vector",               3, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_FOV,                           "fov",                          1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_NEAR_CLIP_DISTANCE,            "near_clip_distance",           1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_FAR_CLIP_DISTANCE,             "far_clip_distance",            1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_PASS_NUMBER,                        "pass_number",                        1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_PASS_ITERATION_NUMBER,              "pass_iteration_number",              1, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_ANIMATION_PARAMETRIC,               "animation_parametric",               4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_TEXEL_OFFSETS,               "texel_offsets",                                  4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_SCENE_DEPTH_RANGE,           "scene_depth_range",                      4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_SHADOW_SCENE_DEPTH_RANGE,    "shadow_scene_depth_range",               4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SHADOW_SCENE_DEPTH_RANGE_ARRAY,    "shadow_scene_depth_range_array",           4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_SHADOW_COLOUR,                               "shadow_colour",                                  4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_TEXTURE_SIZE,                "texture_size",                   4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_INVERSE_TEXTURE_SIZE,        "inverse_texture_size",           4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_PACKED_TEXTURE_SIZE,         "packed_texture_size",            4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_TEXTURE_MATRIX,  "texture_matrix", 16, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_LOD_CAMERA_POSITION,               "lod_camera_position",              3, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_LOD_CAMERA_POSITION_OBJECT_SPACE,  "lod_camera_position_object_space", 3, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_LIGHT_CUSTOM,        "light_custom", 4, ET_REAL, ACDT_INT),

        AutoConstantDefinition(ACT_POINT_PARAMS,                    "point_params",                   4, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_MATERIAL_LOD_INDEX,       "material_lod_index",             1, ET_INT, ACDT_NONE),

        // NOTE: new auto constants must be added before this line, as the following are merely aliases

        // to allow legacy world_ names in scripts

        AutoConstantDefinition(ACT_BONE_MATRIX_ARRAY_3x4,        "world_matrix_array_3x4",      12, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_BONE_MATRIX_ARRAY,            "world_matrix_array",          16, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_BONE_DUALQUATERNION_ARRAY_2x4, "world_dualquaternion_array_2x4",      8, ET_REAL, ACDT_NONE),

        AutoConstantDefinition(ACT_BONE_SCALE_SHEAR_MATRIX_ARRAY_3x4, "world_scale_shear_matrix_array_3x4", 12, ET_REAL, ACDT_NONE),

    };

    GpuNamedConstants::GpuNamedConstants() : bufferSize(0), registerCount(0) {}

    GpuNamedConstants::~GpuNamedConstants() {}

    GpuLogicalBufferStruct::GpuLogicalBufferStruct() : bufferSize(0) {}

    GpuLogicalBufferStruct::~GpuLogicalBufferStruct() {}

    //---------------------------------------------------------------------

    //  GpuNamedConstants methods

    //---------------------------------------------------------------------

    void GpuNamedConstants::save(const String& filename) const

    {

        GpuNamedConstantsSerializer ser;

        ser.exportNamedConstants(this, filename);

    }

    //---------------------------------------------------------------------

    void GpuNamedConstants::load(DataStreamPtr& stream)

    {

        GpuNamedConstantsSerializer ser;

        ser.importNamedConstants(stream, this);

    }

    //-----------------------------------------------------------------------------

    size_t GpuNamedConstants::calculateSize(void) const

    {

        size_t memSize = sizeof(*this);

        // Tally up constant defs

        memSize += sizeof(GpuConstantDefinition) * map.size();

        return memSize;

    }

    //---------------------------------------------------------------------

    //  GpuNamedConstantsSerializer methods

    //---------------------------------------------------------------------

    GpuNamedConstantsSerializer::GpuNamedConstantsSerializer()

    {

        mVersion = "[v1.0]";

    }

    //---------------------------------------------------------------------

    GpuNamedConstantsSerializer::~GpuNamedConstantsSerializer()

    {

    }

    //---------------------------------------------------------------------

    void GpuNamedConstantsSerializer::exportNamedConstants(

        const GpuNamedConstants* pConsts, const String& filename, Endian endianMode)

    {

        DataStreamPtr stream = _openFileStream(filename, std::ios::binary | std::ios::out);

        exportNamedConstants(pConsts, stream, endianMode);

        stream->close();

    }

    //---------------------------------------------------------------------

    void GpuNamedConstantsSerializer::exportNamedConstants(

        const GpuNamedConstants* pConsts, DataStreamPtr stream, Endian endianMode)

    {

        // Decide on endian mode

        determineEndianness(endianMode);

        mStream =stream;

        if (!stream->isWriteable())

        {

            OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE,

                        "Unable to write to stream " + stream->getName(),

                        "GpuNamedConstantsSerializer::exportNamedConstants");

        }

        writeFileHeader();

        writeInts(((const uint32*)&pConsts->bufferSize), 1);

        writeInts(((const uint32*)&pConsts->bufferSize), 1);

        writeInts(((const uint32*)&pConsts->bufferSize), 1);

        // simple export of all the named constants, no chunks

        // name, physical index

        for (const auto& i : pConsts->map)

        {

            const String& name = i.first;

            const GpuConstantDefinition& def = i.second;

            writeString(name);

            writeInts(((const uint32*)&def.physicalIndex), 1);

            writeInts(((const uint32*)&def.logicalIndex), 1);

            uint32 constType = static_cast<uint32>(def.constType);

            writeInts(&constType, 1);

            writeInts(((const uint32*)&def.elementSize), 1);

            writeInts(((const uint32*)&def.arraySize), 1);

        }

    }

    //---------------------------------------------------------------------

    void GpuNamedConstantsSerializer::importNamedConstants(

        DataStreamPtr& stream, GpuNamedConstants* pDest)

    {

        // Determine endianness (must be the first thing we do!)

        determineEndianness(stream);

        // Check header

        readFileHeader(stream);

        // simple file structure, no chunks

        pDest->map.clear();

        readInts(stream, ((uint32*)&pDest->bufferSize), 1);

        readInts(stream, ((uint32*)&pDest->bufferSize), 1);

        readInts(stream, ((uint32*)&pDest->bufferSize), 1);

        while (!stream->eof())

        {

            GpuConstantDefinition def;

            String name = readString(stream);

            // Hmm, deal with trailing information

            if (name.empty())

                continue;

            readInts(stream, ((uint32*)&def.physicalIndex), 1);

            readInts(stream, ((uint32*)&def.logicalIndex), 1);

            uint constType;

            readInts(stream, &constType, 1);

            def.constType = static_cast<GpuConstantType>(constType);

            readInts(stream, ((uint32*)&def.elementSize), 1);

            readInts(stream, ((uint32*)&def.arraySize), 1);

            pDest->map[name] = def;

        }

    }

    //-----------------------------------------------------------------------------

    //      GpuSharedParameters Methods

    //-----------------------------------------------------------------------------

    GpuSharedParameters::GpuSharedParameters(const String& name)

        :mName(name)

        , mVersion(0), mOffset(0), mDirty(false)

    {

    }

    //-----------------------------------------------------------------------------

    size_t GpuSharedParameters::calculateSize(void) const

    {

        size_t memSize = sizeof(*this);

        memSize += mConstants.size();

        memSize += mName.size() * sizeof(char);

        return memSize;

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::addConstantDefinition(const String& name, GpuConstantType constType, uint32 arraySize)

    {

        if (mNamedConstants.map.find(name) != mNamedConstants.map.end())

        {

            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,

                        "Constant entry with name '" + name + "' already exists. ",

                        "GpuSharedParameters::addConstantDefinition");

        }

        GpuConstantDefinition def;

        def.arraySize = arraySize;

        def.constType = constType;

    // here, we do not consider padding, but rather alignment

        def.elementSize = GpuConstantDefinition::getElementSize(constType, false);

    // we try to adhere to GLSL std140 packing rules

    // handle alignment requirements

        size_t align_size = std::min<size_t>(def.elementSize == 3 ? 4 : def.elementSize, 4); // vec3 is 16 byte aligned, which is max

        align_size *= 4; // bytes

        size_t nextAlignedOffset = ((mOffset + align_size - 1) / align_size) * align_size;

        // abuse logical index to store offset

        if (mOffset + align_size > nextAlignedOffset)

        {

            def.logicalIndex = nextAlignedOffset;

        }

        else

        {

            def.logicalIndex = mOffset;

        }

        mOffset = def.logicalIndex + (def.constType == GCT_MATRIX_4X3 ? 16 : def.elementSize) * 4; // mat4x3 have a size of 64 bytes

        def.variability = (uint16)GPV_GLOBAL;

        if (def.isFloat())

        {

            def.physicalIndex = mConstants.size();

            mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*4);

        }

        else if (def.isDouble())

        {

            def.physicalIndex = mConstants.size();

            mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*8);

        }

        else if (def.isInt() || def.isUnsignedInt() || def.isBool())

        {

            def.physicalIndex = mConstants.size();

            mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*4);

        }

        else 

        {

            //FIXME Is this the right exception type?

            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,

                        "Constant entry with name '" + name + "' is not a known type.",

                        "GpuSharedParameters::addConstantDefinition");

        }

        mNamedConstants.map[name] = def;

        ++mVersion;

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::removeConstantDefinition(const String& name)

    {

        GpuConstantDefinitionMap::iterator i = mNamedConstants.map.find(name);

        if (i != mNamedConstants.map.end())

        {

            GpuConstantDefinition& def = i->second;

            size_t numElems = def.elementSize * def.arraySize;

            for (auto& j : mNamedConstants.map)

            {

                GpuConstantDefinition& otherDef = j.second;

                // comes after in the buffer

                if (otherDef.physicalIndex > def.physicalIndex)

                {

                    // adjust index

                    otherDef.logicalIndex -= numElems;

                    otherDef.physicalIndex -= numElems;

                }

            }

            // remove and reduce buffer

            if (def.isFloat() || def.isInt() || def.isUnsignedInt() || def.isBool())

            {

                mNamedConstants.bufferSize -= numElems;

                ConstantList::iterator beg = mConstants.begin();

                std::advance(beg, def.physicalIndex);

                ConstantList::iterator en = beg;

                std::advance(en, numElems*4);

                mConstants.erase(beg, en);

            }

            else {

                //TODO exception handling

            }

            ++mVersion;

        }

    }

    void GpuSharedParameters::_upload() const

    {

        OgreAssert(mHardwareBuffer, "not backed by a HardwareBuffer");

        if (!mDirty)

            return;

        mHardwareBuffer->writeData(0, mConstants.size(), mConstants.data());

    }

    void GpuSharedParameters::download()

    {

        OgreAssert(mHardwareBuffer, "not backed by a HardwareBuffer");

        mHardwareBuffer->readData(0, mConstants.size(), mConstants.data());

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::removeAllConstantDefinitions()

    {

    mOffset = 0;

        mNamedConstants.map.clear();

        mNamedConstants.bufferSize = 0;

        mConstants.clear();

    }

    //---------------------------------------------------------------------

    GpuConstantDefinitionIterator GpuSharedParameters::getConstantDefinitionIterator(void) const

    {

        return GpuConstantDefinitionIterator(mNamedConstants.map.begin(), mNamedConstants.map.end());

    }

    //---------------------------------------------------------------------

    const GpuConstantDefinition& GpuSharedParameters::getConstantDefinition(const String& name) const

    {

        GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name);

        if (i == mNamedConstants.map.end())

        {

            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,

                        "Constant entry with name '" + name + "' does not exist. ",

                        "GpuSharedParameters::getConstantDefinition");

        }

        return i->second;

    }

    //---------------------------------------------------------------------

    const GpuNamedConstants& GpuSharedParameters::getConstantDefinitions() const

    {

        return mNamedConstants;

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::setNamedConstant(const String& name, const Matrix4& m)

    {

        _setNamedConstant(name, m[0], 16);

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::setNamedConstant(const String& name, const Matrix4* m, uint32 numEntries)

    {

        _setNamedConstant(name, m[0][0], 16 * numEntries);

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::setNamedConstant(const String& name, const ColourValue& colour)

    {

        _setNamedConstant(name, colour.ptr(), 4);

    }

    //---------------------------------------------------------------------

    template <typename T> void GpuSharedParameters::_setNamedConstant(const String& name, const T* val, uint32 count)

    {

        GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name);

        if (i == mNamedConstants.map.end())

            return; // ignore

        const GpuConstantDefinition& def = i->second;

        memcpy(&mConstants[def.physicalIndex], val, sizeof(float) * std::min(count, def.elementSize * def.arraySize));

        _markDirty();

    }

Unexecuted instantiation: void Ogre::GpuSharedParameters::_setNamedConstant<float>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, float const*, unsigned int)

Unexecuted instantiation: void Ogre::GpuSharedParameters::_setNamedConstant<double>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, double const*, unsigned int)

Unexecuted instantiation: void Ogre::GpuSharedParameters::_setNamedConstant<int>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, int const*, unsigned int)

Unexecuted instantiation: void Ogre::GpuSharedParameters::_setNamedConstant<unsigned int>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, unsigned int const*, unsigned int)

    void GpuSharedParameters::setNamedConstant(const String& name, const float* val, uint32 count)

    {

        _setNamedConstant(name, val, count);

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::setNamedConstant(const String& name, const double* val, uint32 count)

    {

        _setNamedConstant(name, val, count);

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::setNamedConstant(const String& name, const int* val, uint32 count)

    {

        _setNamedConstant(name, val, count);

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::setNamedConstant(const String& name, const uint* val, uint32 count)

    {

        _setNamedConstant(name, val, count);

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::_markClean()

    {

        mDirty = false;

    }

    //---------------------------------------------------------------------

    void GpuSharedParameters::_markDirty()

    {

        mDirty = true;

    }

    //-----------------------------------------------------------------------------

    //      GpuSharedParametersUsage Methods

    //-----------------------------------------------------------------------------

    GpuSharedParametersUsage::GpuSharedParametersUsage(GpuSharedParametersPtr sharedParams,

                                                       GpuProgramParameters* params)

        : mSharedParams(sharedParams)

        , mParams(params)

    {

        initCopyData();

    }

    //---------------------------------------------------------------------

    void GpuSharedParametersUsage::initCopyData()

    {

        mCopyDataList.clear();

        const GpuConstantDefinitionMap& sharedmap = mSharedParams->getConstantDefinitions().map;

        for (const auto& i : sharedmap)

        {

            const String& pName = i.first;

            const GpuConstantDefinition& shareddef = i.second;

            const GpuConstantDefinition* instdef = mParams->_findNamedConstantDefinition(pName, false);

            if (instdef)

            {

                // Check that the definitions are the same

                if (instdef->constType == shareddef.constType &&

                    instdef->arraySize <= shareddef.arraySize)

                {

                    CopyDataEntry e;

                    e.srcDefinition = &shareddef;

                    e.dstDefinition = instdef;

                    mCopyDataList.push_back(e);

                }

                else

                    LogManager::getSingleton().logWarning("cannot copy shared parameter '" + pName +

                                                          "' - type or variability mismatch");

            }

        }

        mCopyDataVersion = mSharedParams->getVersion();

    }

    //---------------------------------------------------------------------

    void GpuSharedParametersUsage::_copySharedParamsToTargetParams() const

    {

        // check copy data version

        if (mCopyDataVersion != mSharedParams->getVersion())

            const_cast<GpuSharedParametersUsage*>(this)->initCopyData();

        // force const call to get*Pointer

        const GpuSharedParameters* sharedParams = mSharedParams.get();

        for (const CopyDataEntry& e : mCopyDataList)

        {

            // dst type cannot be double, so src will never be double either

            if (mParams->getTransposeMatrices() && (e.dstDefinition->constType == GCT_MATRIX_4X4))

            {

                const float* pSrc = sharedParams->getFloatPointer(e.srcDefinition->physicalIndex);

                float* pDst = mParams->getFloatPointer(e.dstDefinition->physicalIndex);

                // for each matrix that needs to be transposed and copied,

                for (size_t iMat = 0; iMat < e.dstDefinition->arraySize; ++iMat)

                {

                    for (int row = 0; row < 4; ++row)

                        for (int col = 0; col < 4; ++col)

                            pDst[row * 4 + col] = pSrc[col * 4 + row];

                    pSrc += 16;

                    pDst += 16;

                }

            }

            else

            {

                OgreAssertDbg(!e.dstDefinition->isSampler() && !e.dstDefinition->isDouble() &&

                                  !e.dstDefinition->isSpecialization(),

                              "expected 4 byte type");

                const int* pSrc = sharedParams->getIntPointer(e.srcDefinition->physicalIndex);

                int* pDst = mParams->getIntPointer(e.dstDefinition->physicalIndex);

                if (e.dstDefinition->elementSize == e.srcDefinition->elementSize)

                {

                    // simple copy

                    memcpy(pDst, pSrc, sizeof(int) * e.dstDefinition->elementSize * e.dstDefinition->arraySize);

                }

                else

                {

                    // element wise copy

                    for (uint32 l = 0; l < e.dstDefinition->arraySize; ++l)

                    {

                        memcpy(pDst, pSrc, sizeof(int) * e.dstDefinition->elementSize);

                        pSrc += e.srcDefinition->elementSize;

                        pDst += e.dstDefinition->elementSize;

                    }

                }

            }

        }

    }

    //-----------------------------------------------------------------------------

    //      GpuProgramParameters Methods

    //-----------------------------------------------------------------------------

    GpuProgramParameters::GpuProgramParameters() :

        mCombinedVariability(GPV_GLOBAL)

        , mTransposeMatrices(false)

        , mIgnoreMissingParams(false)

        , mActivePassIterationIndex(std::numeric_limits<size_t>::max())

        , mUseLinearColours(false)

    {

        static_assert((sizeof(AutoConstantDictionary) / sizeof(AutoConstantDefinition) - 5) == ACT_MATERIAL_LOD_INDEX,

                      "AutoConstantDictionary out of sync");

    }

    GpuProgramParameters::~GpuProgramParameters() {}

    //-----------------------------------------------------------------------------

    GpuProgramParameters::GpuProgramParameters(const GpuProgramParameters& oth)

    {

        *this = oth;

    }

    //-----------------------------------------------------------------------------

    GpuProgramParameters& GpuProgramParameters::operator=(const GpuProgramParameters& oth)

    {

        // let compiler perform shallow copies of structures

        // AutoConstantEntry, RealConstantEntry, IntConstantEntry

        mConstants = oth.mConstants;

        mRegisters = oth.mRegisters;

        mAutoConstants = oth.mAutoConstants;

        mLogicalToPhysical = oth.mLogicalToPhysical;

        mNamedConstants = oth.mNamedConstants;

        copySharedParamSetUsage(oth.mSharedParamSets);

        mCombinedVariability = oth.mCombinedVariability;

        mTransposeMatrices = oth.mTransposeMatrices;

        mIgnoreMissingParams  = oth.mIgnoreMissingParams;

        mActivePassIterationIndex = oth.mActivePassIterationIndex;

        mUseLinearColours = oth.mUseLinearColours;

        return *this;

    }

    //---------------------------------------------------------------------

    void GpuProgramParameters::copySharedParamSetUsage(const GpuSharedParamUsageList& srcList)

    {

        mSharedParamSets.clear();

        for (const auto& i : srcList)

        {

            mSharedParamSets.push_back(GpuSharedParametersUsage(i.getSharedParams(), this));

        }

    }

    //-----------------------------------------------------------------------------

    size_t GpuProgramParameters::calculateSize(void) const

    {

        size_t memSize = sizeof(*this);

        memSize += mConstants.size();

        memSize += mRegisters.size()*4;

        for (const auto& ac : mAutoConstants)

        {

            memSize += sizeof(ac);

        }

        return memSize;

    }

    //---------------------------------------------------------------------

    void GpuProgramParameters::_setNamedConstants(

        const GpuNamedConstantsPtr& namedConstants)

    {

        mNamedConstants = namedConstants;

        // Determine any extension to local buffers

        // Size and reset buffer (fill with zero to make comparison later ok)

        if (namedConstants->bufferSize*4 > mConstants.size())

        {

            mConstants.insert(mConstants.end(), namedConstants->bufferSize * 4 - mConstants.size(), 0);

        }

        if(namedConstants->registerCount > mRegisters.size())

            mRegisters.insert(mRegisters.end(), namedConstants->registerCount - mRegisters.size(), 0);

    }

    //---------------------------------------------------------------------

    void GpuProgramParameters::_setLogicalIndexes(const GpuLogicalBufferStructPtr& indexMap)

    {

        mLogicalToPhysical = indexMap;

        // resize the internal buffers

        // Note that these will only contain something after the first parameter

        // set has set some parameters

        // Size and reset buffer (fill with zero to make comparison later ok)

        if (indexMap && indexMap->bufferSize*4 > mConstants.size())

        {

            mConstants.insert(mConstants.end(), indexMap->bufferSize * 4 - mConstants.size(), 0);

        }

    }

    //---------------------------------------------------------------------()

    void GpuProgramParameters::setConstant(size_t index, const Vector4& vec)

    {

        setConstant(index, vec.ptr(), 1);

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, Real val)

    {

        setConstant(index, Vector4(val, 0.0f, 0.0f, 0.0f));

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const Vector3& vec)

    {

        setConstant(index, Vector4(vec.x, vec.y, vec.z, 1.0f));

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const Vector2& vec)

    {

        setConstant(index, Vector4(vec.x, vec.y, 1.0f, 1.0f));

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const Matrix4& m)

    {

        // set as 4x 4-element floats

        if (mTransposeMatrices)

        {

            Matrix4 t = m.transpose();

            GpuProgramParameters::setConstant(index, t[0], 4);

        }

        else

        {

            GpuProgramParameters::setConstant(index, m[0], 4);

        }

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const Matrix4* pMatrix,

                                           size_t numEntries)

    {

        if (mTransposeMatrices)

        {

            for (size_t i = 0; i < numEntries; ++i)

            {

                Matrix4 t = pMatrix[i].transpose();

                GpuProgramParameters::setConstant(index, t[0], 4);

                index += 4;

            }

        }

        else

        {

            GpuProgramParameters::setConstant(index, pMatrix[0][0], 4 * numEntries);

        }

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const ColourValue& colour)

    {

        setConstant(index, colour.ptr(), 1);

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const float *val, size_t count)

    {

        // Raw buffer size is 4x count

        size_t rawCount = count * 4;

        // get physical index

        assert(mLogicalToPhysical && "GpuProgram hasn't set up the logical -> physical map!");

        size_t physicalIndex = _getConstantPhysicalIndex(index, rawCount, GPV_GLOBAL, BCT_FLOAT);

        // Copy

        _writeRawConstants(physicalIndex, val, rawCount);

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const double *val, size_t count)

    {

        // Raw buffer size is 4x count

        size_t rawCount = count * 4;

        // get physical index

        assert(mLogicalToPhysical && "GpuProgram hasn't set up the logical -> physical map!");

        size_t physicalIndex = _getConstantPhysicalIndex(index, rawCount, GPV_GLOBAL, BCT_DOUBLE);

        // Copy

        _writeRawConstants(physicalIndex, val, rawCount);

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const int *val, size_t count)

    {

        // Raw buffer size is 4x count

        size_t rawCount = count * 4;

        // get physical index

        assert(mLogicalToPhysical && "GpuProgram hasn't set up the logical -> physical map!");

        size_t physicalIndex = _getConstantPhysicalIndex(index, rawCount, GPV_GLOBAL, BCT_INT);

        // Copy

        _writeRawConstants(physicalIndex, val, rawCount);

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::setConstant(size_t index, const uint *val, size_t count)

    {

        // Raw buffer size is 4x count

        size_t rawCount = count * 4;

        // get physical index

        assert(mLogicalToPhysical && "GpuProgram hasn't set up the logical -> physical map!");

        size_t physicalIndex = _getConstantPhysicalIndex(index, rawCount, GPV_GLOBAL, BCT_INT);

        // Copy

        _writeRawConstants(physicalIndex, val, rawCount);

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::_writeRawConstant(size_t physicalIndex, const Matrix4& m, size_t elementCount)

    {

        // remember, raw content access uses raw float count rather than float4

        if (mTransposeMatrices)

        {

            Matrix4 t = m.transpose();

            _writeRawConstants(physicalIndex, t[0], elementCount > 16 ? 16 : elementCount);

        }

        else

        {

            _writeRawConstants(physicalIndex, m[0], elementCount > 16 ? 16 : elementCount);

        }

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::_writeRawConstant(size_t physicalIndex, const Matrix3& m, size_t elementCount)

    {

        // remember, raw content access uses raw float count rather than float4

        if (mTransposeMatrices)

        {

            Matrix3 t = m.transpose();

            _writeRawConstants(physicalIndex, t[0], elementCount > 9 ? 9 : elementCount);

        }

        else

        {

            _writeRawConstants(physicalIndex, m[0], elementCount > 9 ? 9 : elementCount);

        }

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::_writeRawConstant(size_t physicalIndex, const TransformBaseReal* pMatrix, size_t numEntries)

    {

        // remember, raw content access uses raw float count rather than float4

        if (mTransposeMatrices)

        {

            for (size_t i = 0; i < numEntries; ++i)

            {

                Matrix4 t = pMatrix[i].transpose();

                _writeRawConstants(physicalIndex, t[0], 16);

                physicalIndex += 16*sizeof(Real);

            }

        }

        else

        {

            _writeRawConstants(physicalIndex, pMatrix[0][0], 16 * numEntries);

        }

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::_writeRawConstant(size_t physicalIndex,

                                                 const ColourValue& colour, size_t count)

    {

        if(mUseLinearColours)

            return _writeRawConstants(physicalIndex, colour.gammaToLinear().ptr(), std::min(count, (size_t)4));

        // write either the number requested (for packed types) or up to 4

        _writeRawConstants(physicalIndex, colour.ptr(), std::min(count, (size_t)4));

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::_writeRawConstants(size_t physicalIndex, const double* val, size_t count)

    {

        assert(physicalIndex + sizeof(float) * count <= mConstants.size());

        for (size_t i = 0; i < count; ++i)

        {

            float tmp = val[i];

            memcpy(&mConstants[physicalIndex + i * sizeof(float)], &tmp, sizeof(float));

        }

    }

    void GpuProgramParameters::_writeRegisters(size_t index, const int* val, size_t count)

    {

        assert(index + count <= mRegisters.size());

        memcpy(&mRegisters[index], val, sizeof(int) * count);

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::_readRawConstants(size_t physicalIndex, size_t count, float* dest)

    {

        assert(physicalIndex + count <= mConstants.size());

        memcpy(dest, &mConstants[physicalIndex], sizeof(float) * count);

    }

    //-----------------------------------------------------------------------------

    void GpuProgramParameters::_readRawConstants(size_t physicalIndex, size_t count, int* dest)

    {

        assert(physicalIndex + count <= mConstants.size());

        memcpy(dest, &mConstants[physicalIndex], sizeof(int) * count);

    }

    //---------------------------------------------------------------------

    uint16 GpuProgramParameters::deriveVariability(GpuProgramParameters::AutoConstantType act)

    {

        switch(act)

        {

        case ACT_VIEW_MATRIX:

        case ACT_INVERSE_VIEW_MATRIX:

        case ACT_TRANSPOSE_VIEW_MATRIX:

        case ACT_INVERSE_TRANSPOSE_VIEW_MATRIX: