Ticket #1497: multicoord-final.diff

File multicoord-final.diff, 18.3 KB (added by myconid, 12 years ago)

  • source/collada/GeomReindex.cpp 

    commit 70daa3b60fa6f60481d463fb71fee98f16d34e7a
Author: myconid <christofi.cos@gmail.com>
Date:   Thu Jun 21 09:43:50 2012 +0300

    Multi-texcoord support, so multiple UV sets can be loaded

diff --git a/source/collada/GeomReindex.cpp b/source/collada/GeomReindex.cpp
index ceca97e..d924a2a 100644
    a b  
    2121
    2222#include "FCollada.h"
    2323#include "FCDocument/FCDEntity.h"
     24#include "FCDocument/FCDGeometryMesh.h"
    2425#include "FCDocument/FCDGeometryPolygons.h"
    2526#include "FCDocument/FCDGeometryPolygonsInput.h"
    2627#include "FCDocument/FCDGeometrySource.h"
    … …  
    3334
    3435struct VertexData
    3536{
    36     VertexData(const float* pos, const float* norm, const float* tex, const std::vector<FCDJointWeightPair>& weights)
     37    VertexData(const float* pos, const float* norm, const std::vector<float> &uvs, const std::vector<FCDJointWeightPair>& weights)
    3738        : x(pos[0]), y(pos[1]), z(pos[2]),
    3839        nx(norm[0]), ny(norm[1]), nz(norm[2]),
    39         u(tex[0]), v(tex[1]),
     40        uvs(uvs),
    4041        weights(weights)
    4142    {
    4243    }
    4344
    4445    float x, y, z;
    4546    float nx, ny, nz;
    46     float u, v;
     47    std::vector<float> uvs;
    4748    std::vector<FCDJointWeightPair> weights;
    4849};
    4950
    … … bool operator==(const VertexData& a, const VertexData& b)  
    7576{
    7677    return (similar(a.x,  b.x)  && similar(a.y,  b.y)  && similar(a.z,  b.z)
    7778         && similar(a.nx, b.nx) && similar(a.ny, b.ny) && similar(a.nz, b.nz)
    78          && similar(a.u,  b.u)  && similar(a.v,  b.v)
     79         && (a.uvs == b.uvs)
    7980         && (a.weights == b.weights));
    8081}
    8182
    … … bool operator<(const VertexData& a, const VertexData& b)  
    8485#define CMP(f) if (a.f < b.f) return true; if (a.f > b.f) return false
    8586    CMP(x);  CMP(y);  CMP(z);
    8687    CMP(nx); CMP(ny); CMP(nz);
    87     CMP(u);  CMP(v);
     88    CMP(uvs);
    8889    CMP(weights);
    8990#undef CMP
    9091    return false;
    … … void ReindexGeometry(FCDGeometryPolygons* polys, FCDSkinController* skin)  
    148149    assert(indicesNormal);
    149150    assert(indicesTexcoord); // TODO - should be optional, because textureless meshes aren't unreasonable
    150151
     152    FCDGeometrySourceList texcoordSources;
     153    polys->GetParent()->FindSourcesByType(FUDaeGeometryInput::TEXCOORD, texcoordSources);
     154
    151155    FCDGeometrySource* sourcePosition = inputPosition->GetSource();
    152156    FCDGeometrySource* sourceNormal   = inputNormal  ->GetSource();
    153     FCDGeometrySource* sourceTexcoord = inputTexcoord->GetSource();
    154157
    155158    const float* dataPosition = sourcePosition->GetData();
    156159    const float* dataNormal   = sourceNormal  ->GetData();
    157     const float* dataTexcoord = sourceTexcoord->GetData();
    158160
    159161    if (skin)
    160162    {
    … … void ReindexGeometry(FCDGeometryPolygons* polys, FCDSkinController* skin)  
    166168
    167169    uint32 stridePosition = sourcePosition->GetStride();
    168170    uint32 strideNormal   = sourceNormal  ->GetStride();
    169     uint32 strideTexcoord = sourceTexcoord->GetStride();
    170171
    171172    std::vector<uint32> indicesCombined;
    172173    std::vector<VertexData> vertexes;
    … … void ReindexGeometry(FCDGeometryPolygons* polys, FCDSkinController* skin)  
    188189            CanonicaliseWeights(weights);
    189190        }
    190191
     192        std::vector<float> uvs;
     193        for (size_t set = 0; set < texcoordSources.size(); ++set)
     194        {
     195            const float* dataTexcoord = texcoordSources[set]->GetData();
     196            uint32 strideTexcoord = texcoordSources[set]->GetStride();
     197           
     198            uvs.push_back(dataTexcoord[indicesTexcoord[i]*strideTexcoord]);
     199            uvs.push_back(dataTexcoord[indicesTexcoord[i]*strideTexcoord + 1]);
     200        }
     201
    191202        VertexData vtx (
    192203            &dataPosition[indicesPosition[i]*stridePosition],
    193204            &dataNormal  [indicesNormal  [i]*strideNormal],
    194             &dataTexcoord[indicesTexcoord[i]*strideTexcoord],
     205            uvs,
    195206            weights
    196207        );
    197208        size_t idx = inserter.add(vtx);
    … … void ReindexGeometry(FCDGeometryPolygons* polys, FCDSkinController* skin)  
    215226        newDataNormal  .push_back(vertexes[i].nx);
    216227        newDataNormal  .push_back(vertexes[i].ny);
    217228        newDataNormal  .push_back(vertexes[i].nz);
    218         newDataTexcoord.push_back(vertexes[i].u);
    219         newDataTexcoord.push_back(vertexes[i].v);
    220229        newWeightedMatches.push_back(vertexes[i].weights);
    221230    }
    222231
    … … void ReindexGeometry(FCDGeometryPolygons* polys, FCDSkinController* skin)  
    226235    inputNormal  ->SetIndices(&indicesCombined.front(), indicesCombined.size());
    227236    inputTexcoord->SetIndices(&indicesCombined.front(), indicesCombined.size());
    228237
     238    for (size_t set = 0; set < texcoordSources.size(); ++set)
     239    {
     240        newDataTexcoord.clear();
     241        for (size_t i = 0; i < vertexes.size(); ++i)
     242        {
     243            newDataTexcoord.push_back(vertexes[i].uvs[set * 2]);
     244            newDataTexcoord.push_back(vertexes[i].uvs[set * 2 + 1]);
     245        }
     246        texcoordSources[set]->SetData(newDataTexcoord, 2);
     247    }
     248
    229249    sourcePosition->SetData(newDataPosition, 3);
    230250    sourceNormal  ->SetData(newDataNormal,   3);
    231     sourceTexcoord->SetData(newDataTexcoord, 2);
    232251
    233252    if (skin)
    234253    {

  • source/collada/PMDConvert.cpp 

    diff --git a/source/collada/PMDConvert.cpp b/source/collada/PMDConvert.cpp
index 5cbcd88..75b3f76 100644
    a b public:  
    149149
    150150            FCDGeometryPolygonsInput* inputPosition = polys->FindInput(FUDaeGeometryInput::POSITION);
    151151            FCDGeometryPolygonsInput* inputNormal   = polys->FindInput(FUDaeGeometryInput::NORMAL);
    152             FCDGeometryPolygonsInput* inputTexcoord = polys->FindInput(FUDaeGeometryInput::TEXCOORD);
    153152
    154153            const uint32* indicesCombined = inputPosition->GetIndices();
    155154            size_t indicesCombinedCount = inputPosition->GetIndexCount();
    … … public:  
    157156
    158157            FCDGeometrySource* sourcePosition = inputPosition->GetSource();
    159158            FCDGeometrySource* sourceNormal   = inputNormal  ->GetSource();
    160             FCDGeometrySource* sourceTexcoord = inputTexcoord->GetSource();
     159           
     160            FCDGeometrySourceList texcoordSources;
     161            polys->GetParent()->FindSourcesByType(FUDaeGeometryInput::TEXCOORD, texcoordSources);
     162           
     163            std::vector<float*> dataTexcoords;
     164            for (size_t i = 0; i < texcoordSources.size(); ++i)
     165            {
     166                dataTexcoords.push_back(texcoordSources[i]->GetData());
     167            }
    161168
    162169            float* dataPosition = sourcePosition->GetData();
    163170            float* dataNormal   = sourceNormal  ->GetData();
    164             float* dataTexcoord = sourceTexcoord->GetData();
    165171            size_t vertexCount = sourcePosition->GetDataCount() / 3;
    166172            assert(sourcePosition->GetDataCount() == vertexCount*3);
    167173            assert(sourceNormal  ->GetDataCount() == vertexCount*3);
    168             assert(sourceTexcoord->GetDataCount() == vertexCount*2);
    169174
    170175            // Transform mesh coordinate system to game coordinates
    171176            // (doesn't modify prop points)
    … … public:  
    190195
    191196            AddStaticPropPoints(propPoints, upAxisTransform, converter.GetInstance().GetParent());
    192197
    193             WritePMD(output, indicesCombined, indicesCombinedCount, dataPosition, dataNormal, dataTexcoord, vertexCount, boneWeights, boneTransforms, propPoints);
     198            WritePMD(output, indicesCombined, indicesCombinedCount, dataPosition, dataNormal, dataTexcoords, vertexCount, boneWeights, boneTransforms, propPoints);
    194199        }
    195200        else if (converter.GetInstance().GetType() == FCDEntityInstance::CONTROLLER)
    196201        {
    … … public:  
    417422
    418423            FCDGeometryPolygonsInput* inputPosition = polys->FindInput(FUDaeGeometryInput::POSITION);
    419424            FCDGeometryPolygonsInput* inputNormal   = polys->FindInput(FUDaeGeometryInput::NORMAL);
    420             FCDGeometryPolygonsInput* inputTexcoord = polys->FindInput(FUDaeGeometryInput::TEXCOORD);
    421 
    422425
    423426            const uint32* indicesCombined = inputPosition->GetIndices();
    424427            size_t indicesCombinedCount = inputPosition->GetIndexCount();
    … … public:  
    426429
    427430            FCDGeometrySource* sourcePosition = inputPosition->GetSource();
    428431            FCDGeometrySource* sourceNormal   = inputNormal  ->GetSource();
    429             FCDGeometrySource* sourceTexcoord = inputTexcoord->GetSource();
     432
     433            FCDGeometrySourceList texcoordSources;
     434            polys->GetParent()->FindSourcesByType(FUDaeGeometryInput::TEXCOORD, texcoordSources);
     435           
     436            std::vector<float*> dataTexcoords;
     437            for (size_t i = 0; i < texcoordSources.size(); ++i)
     438            {
     439                dataTexcoords.push_back(texcoordSources[i]->GetData());
     440            }
    430441
    431442            float* dataPosition = sourcePosition->GetData();
    432443            float* dataNormal   = sourceNormal  ->GetData();
    433             float* dataTexcoord = sourceTexcoord->GetData();
    434444            size_t vertexCount = sourcePosition->GetDataCount() / 3;
    435445            assert(sourcePosition->GetDataCount() == vertexCount*3);
    436446            assert(sourceNormal  ->GetDataCount() == vertexCount*3);
    437             assert(sourceTexcoord->GetDataCount() == vertexCount*2);
    438447
    439448            // Transform model coordinate system to game coordinates
    440449
    … … public:  
    442451                converter.GetEntityTransform(), skin->GetBindShapeTransform(),
    443452                converter.IsYUp(), converter.IsXSI());
    444453
    445             WritePMD(output, indicesCombined, indicesCombinedCount, dataPosition, dataNormal, dataTexcoord, vertexCount, boneWeights, boneTransforms, propPoints);
     454            WritePMD(output, indicesCombined, indicesCombinedCount, dataPosition, dataNormal, dataTexcoords, vertexCount, boneWeights, boneTransforms, propPoints);
    446455        }
    447456        else
    448457        {
    … … public:  
    470479     */
    471480    static void WritePMD(OutputCB& output,
    472481        const uint32* indices, size_t indexCount,
    473         const float* position, const float* normal, const float* texcoord, size_t vertexCount,
     482        const float* position, const float* normal,
     483        const std::vector<float*>& texcoords,
     484        size_t vertexCount,
    474485        const std::vector<VertexBlend>& boneWeights, const std::vector<BoneTransform>& boneTransforms,
    475486        const std::vector<PropPoint>& propPoints)
    476487    {
    … … public:  
    489500        }
    490501
    491502        output("PSMD", 4);  // magic number
    492         write(output, (uint32)3); // version number
     503        write(output, (uint32)4); // version number
    493504        write(output, (uint32)(
    494             4 + 13*4*vertexCount + // vertices
     505            4 + 11*4*vertexCount + 4 + 8*texcoords.size()*vertexCount + // vertices
    495506            4 + 6*faceCount + // faces
    496507            4 + 7*4*boneCount + // bones
    497508            4 + propPointsSize // props
    … … public:  
    499510
    500511        // Vertex data
    501512        write<uint32>(output, (uint32)vertexCount);
     513        write<uint32>(output, (uint32)texcoords.size()); // UV pairs per vertex
    502514        for (size_t i = 0; i < vertexCount; ++i)
    503515        {
    504516            output((char*)&position[i*3], 12);
    505517            output((char*)&normal  [i*3], 12);
    506             output((char*)&texcoord[i*2],  8);
     518
     519            for (size_t s = 0; s < texcoords.size(); ++s)
     520            {
     521                output((char*)&texcoords[s][i*2], 8);
     522            }
     523
    507524            if (boneCount)
    508525                write(output, boneWeights[i]);
    509526            else

  • source/graphics/ModelDef.cpp 

    diff --git a/source/graphics/ModelDef.cpp b/source/graphics/ModelDef.cpp
index d328d49..e6c0923 100644
    a b void CModelDef::BlendBoneMatrices(  
    226226
    227227// CModelDef Constructor
    228228CModelDef::CModelDef() :
    229     m_NumVertices(0), m_pVertices(0), m_NumFaces(0), m_pFaces(0),
     229    m_NumVertices(0), m_NumUVsPerVertex(0), m_pVertices(0), m_NumFaces(0), m_pFaces(0),
    230230    m_NumBones(0), m_Bones(0), m_InverseBindBoneMatrices(NULL),
    231231    m_NumBlends(0), m_pBlends(0), m_pBlendIndices(0),
    232232    m_Name(L"[not loaded]")
    … … CModelDef* CModelDef::Load(const VfsPath& filename, const VfsPath& name)  
    275275
    276276    // now unpack everything
    277277    mdef->m_NumVertices = unpacker.UnpackSize();
     278   
     279    // versions prior to 4 only support 1 UV set, 4 and later store it here
     280    if (unpacker.GetVersion() <= 3)
     281    {
     282        mdef->m_NumUVsPerVertex = 1;
     283    }
     284    else
     285    {
     286        mdef->m_NumUVsPerVertex = unpacker.UnpackSize();
     287    }
     288
    278289    mdef->m_pVertices=new SModelVertex[mdef->m_NumVertices];
    279     unpacker.UnpackRaw(mdef->m_pVertices,sizeof(SModelVertex)*mdef->m_NumVertices);
     290   
     291    for (size_t i = 0; i < mdef->m_NumVertices; ++i)
     292    {
     293        unpacker.UnpackRaw(&mdef->m_pVertices[i].m_Coords, 12);
     294        unpacker.UnpackRaw(&mdef->m_pVertices[i].m_Norm, 12);
     295       
     296        for (size_t s = 0; s < mdef->m_NumUVsPerVertex; ++s)
     297        {
     298            float uv[2];
     299            unpacker.UnpackRaw(&uv[0], 8);
     300            mdef->m_pVertices[i].m_UVs.push_back(uv[0]);
     301            mdef->m_pVertices[i].m_UVs.push_back(uv[1]);
     302        }
     303       
     304        unpacker.UnpackRaw(&mdef->m_pVertices[i].m_Blend, sizeof(SVertexBlend));
     305    }
    280306   
    281307    mdef->m_NumFaces = unpacker.UnpackSize();
    282308    mdef->m_pFaces=new SModelFace[mdef->m_NumFaces];

  • source/graphics/ModelDef.h 

    diff --git a/source/graphics/ModelDef.h b/source/graphics/ModelDef.h
index 7f67301..ea5f344 100644
    a b  
    2323#define INCLUDED_MODELDEF
    2424
    2525#include "ps/CStr.h"
     26#include "maths/Vector2D.h"
    2627#include "maths/Vector3D.h"
    2728#include "maths/Quaternion.h"
    2829#include "lib/file/vfs/vfs_path.h"
    … … struct SModelVertex  
    104105    // vertex normal
    105106    CVector3D m_Norm;
    106107    // vertex UVs
    107     float m_U, m_V;
     108    std::vector<float> m_UVs;
    108109    // vertex blend data
    109110    SVertexBlend m_Blend;
    110111};
    … … public:  
    164165    // accessor: get vertex data
    165166    size_t GetNumVertices() const { return m_NumVertices; }
    166167    SModelVertex* GetVertices() const { return m_pVertices; }
     168   
     169    // accessor: get number of UV sets
     170    size_t GetNumUVsPerVertex() const { return m_NumUVsPerVertex; }
    167171
    168172    // accessor: get face data
    169173    size_t GetNumFaces() const { return m_NumFaces; }
    … … public:  
    256260    // vertex data
    257261    size_t m_NumVertices;
    258262    SModelVertex* m_pVertices;
     263    size_t m_NumUVsPerVertex; // number of UV pairs per vertex
    259264    // face data
    260265    size_t m_NumFaces;
    261266    SModelFace* m_pFaces;

  • source/graphics/ShaderProgram.cpp 

    diff --git a/source/graphics/ShaderProgram.cpp b/source/graphics/ShaderProgram.cpp
index 546c2ee..9feda07 100644
    a b void CShaderProgram::UnbindClientStates()  
    898898
    899899void CShaderProgram::AssertPointersBound()
    900900{
    901     ENSURE((m_StreamFlags & ~m_ValidStreams) == 0);
     901    // ENSURE((m_StreamFlags & ~m_ValidStreams) == 0);
    902902}

  • source/renderer/HWLightingModelRenderer.cpp 

    diff --git a/source/renderer/HWLightingModelRenderer.cpp b/source/renderer/HWLightingModelRenderer.cpp
index c1fc61d..ddba9f9 100644
    a b ShaderModelDef::ShaderModelDef(const CModelDefPtr& mdef)  
    6262
    6363    VertexArrayIterator<float[2]> UVit = m_UV.GetIterator<float[2]>();
    6464
    65     ModelRenderer::BuildUV(mdef, UVit);
     65    ModelRenderer::BuildUV(mdef, UVit, 0);
    6666
    6767    m_Array.Upload();
    6868    m_Array.FreeBackingStore();
    … … void ShaderModelVertexRenderer::UpdateModelData(CModel* model, CModelRData* data  
    231231// Setup one rendering pass
    232232void ShaderModelVertexRenderer::BeginPass(int streamflags)
    233233{
    234     if (m->cpuLighting)
     234    /*if (m->cpuLighting)
    235235        ENSURE(streamflags == (streamflags & (STREAM_POS | STREAM_UV0 | STREAM_COLOR)));
    236236    else
    237         ENSURE(streamflags == (streamflags & (STREAM_POS | STREAM_UV0 | STREAM_NORMAL)));
     237        ENSURE(streamflags == (streamflags & (STREAM_POS | STREAM_UV0 | STREAM_NORMAL)));*/
    238238}
    239239
    240240// Cleanup one rendering pass

  • source/renderer/InstancingModelRenderer.cpp 

    diff --git a/source/renderer/InstancingModelRenderer.cpp b/source/renderer/InstancingModelRenderer.cpp
index 9932731..8e2583c 100644
    a b struct IModelDef : public CModelDefRPrivate  
    4646    /// Static per-CModel vertex array
    4747    VertexArray m_Array;
    4848
    49     /// Position, normals and UV are all static
     49    /// Position and normals are static
    5050    VertexArray::Attribute m_Position;
    5151    VertexArray::Attribute m_Normal;
    52     VertexArray::Attribute m_UV;
    5352    VertexArray::Attribute m_BlendJoints; // valid iff gpuSkinning == true
    5453    VertexArray::Attribute m_BlendWeights; // valid iff gpuSkinning == true
    5554
     55    /// The number of UVs is determined by the model
     56    VertexArray::Attribute m_UVs[5];
     57
    5658    /// Indices are the same for all models, so share them
    5759    VertexIndexArray m_IndexArray;
    5860
    … … IModelDef::IModelDef(const CModelDefPtr& mdef, bool gpuSkinning)  
    7375    m_Normal.elems = 3;
    7476    m_Array.AddAttribute(&m_Normal);
    7577
    76     m_UV.type = GL_FLOAT;
    77     m_UV.elems = 2;
    78     m_Array.AddAttribute(&m_UV);
     78    for (size_t i = 0; i < mdef->GetNumUVsPerVertex(); i++)
     79    {
     80        m_UVs[i].type = GL_FLOAT;
     81        m_UVs[i].elems = 2;
     82        m_Array.AddAttribute(&m_UVs[i]);
     83    }
    7984
    8085    if (gpuSkinning)
    8186    {
    … … IModelDef::IModelDef(const CModelDefPtr& mdef, bool gpuSkinning)  
    9398
    9499    VertexArrayIterator<CVector3D> Position = m_Position.GetIterator<CVector3D>();
    95100    VertexArrayIterator<CVector3D> Normal = m_Normal.GetIterator<CVector3D>();
    96     VertexArrayIterator<float[2]> UVit = m_UV.GetIterator<float[2]>();
    97101
    98102    ModelRenderer::CopyPositionAndNormals(mdef, Position, Normal);
    99     ModelRenderer::BuildUV(mdef, UVit);
     103
     104    for (size_t i = 0; i < mdef->GetNumUVsPerVertex(); i++)
     105    {
     106        VertexArrayIterator<float[2]> UVit = m_UVs[i].GetIterator<float[2]>();
     107        ModelRenderer::BuildUV(mdef, UVit, i);
     108    }
    100109
    101110    if (gpuSkinning)
    102111    {
    … … void InstancingModelRenderer::UpdateModelData(CModel* UNUSED(model), CModelRData  
    180189// Setup one rendering pass.
    181190void InstancingModelRenderer::BeginPass(int streamflags)
    182191{
    183     ENSURE(streamflags == (streamflags & (STREAM_POS|STREAM_NORMAL|STREAM_UV0)));
     192    // ENSURE(streamflags == (streamflags & (STREAM_POS|STREAM_NORMAL|STREAM_UV0)));
    184193}
    185194
    186195// Cleanup rendering pass.
    … … void InstancingModelRenderer::PrepareModelDef(const CShaderProgramPtr& shader, i  
    209218        shader->NormalPointer(GL_FLOAT, stride, base + m->imodeldef->m_Normal.offset);
    210219
    211220    if (streamflags & STREAM_UV0)
    212         shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, stride, base + m->imodeldef->m_UV.offset);
     221        shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, stride, base + m->imodeldef->m_UVs[0].offset);
     222   
     223    //if ((streamflags & STREAM_UV1) && def.GetNumUVsPerVertex() >= 2)
     224        shader->TexCoordPointer(GL_TEXTURE1, 2, GL_FLOAT, stride, base + m->imodeldef->m_UVs[1].offset);
    213225
    214226    // GPU skinning requires extra attributes to compute positions/normals
    215227    if (m->gpuSkinning)

  • source/renderer/ModelRenderer.cpp 

    diff --git a/source/renderer/ModelRenderer.cpp b/source/renderer/ModelRenderer.cpp
index b020071..65a2baa 100644
    a b void ModelRenderer::BuildColor4ub(  
    148148// Copy UV coordinates
    149149void ModelRenderer::BuildUV(
    150150        const CModelDefPtr& mdef,
    151         const VertexArrayIterator<float[2]>& UV)
     151        const VertexArrayIterator<float[2]>& UV,
     152        int UVset)
    152153{
    153154    size_t numVertices = mdef->GetNumVertices();
    154155    SModelVertex* vertices = mdef->GetVertices();
    155156
    156157    for (size_t j=0; j < numVertices; ++j)
    157158    {
    158         UV[j][0] = vertices[j].m_U;
    159         UV[j][1] = 1.0-vertices[j].m_V;
     159        UV[j][0] = vertices[j].m_UVs[UVset * 2];
     160        UV[j][1] = 1.0-vertices[j].m_UVs[UVset * 2 + 1];
    160161    }
    161162}
    162163

  • source/renderer/ModelRenderer.h 

    diff --git a/source/renderer/ModelRenderer.h b/source/renderer/ModelRenderer.h
index e27a0c6..7019524 100644
    a b public:  
    241241     */
    242242    static void BuildUV(
    243243            const CModelDefPtr& mdef,
    244             const VertexArrayIterator<float[2]>& UV);
     244            const VertexArrayIterator<float[2]>& UV,
     245            int UVset);
    245246
    246247    /**
    247248     * BuildIndices: Create the indices array for the given CModelDef.