Changeset 936 for GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/src

Timestamp:

05/09/06 17:13:42 (19 years ago)

Author:

igarcia

Message:

 

Location:

GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/src

Files:

• BBCEntity.cpp (modified) (7 diffs)
• BBCSubEntity.cpp (modified) (1 diff)

GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/src/BBCEntity.cpp

@@ -82 +82 @@
    getMeshVertexColours(mergeSubMeshes);
    getMeshTexCoords(mergeSubMeshes);
-   getMeshFacesVerticesID(mergeSubMeshes);
+   //getMeshFacesVerticesID(mergeSubMeshes);
 }
 
@@ -110 +110 @@
         size_t shared_offset = 0;
         size_t next_offset = 0;
+        size_t index_offset = 0;
+        size_t vertex_count, index_count;
+
+        vertex_count = index_count = 0;
 
         unsigned int numSubMeshes = mMesh->get()->getNumSubMeshes();
         sincronizeNumSubEntities();
         
+    // Calculate how many vertices and indices we're going to need
+    for(int i = 0; i < mMesh->get()->getNumSubMeshes(); i++)
+    {
+                Ogre::SubMesh* submesh = mMesh->get()->getSubMesh(i);
+
+        // We only need to add the shared vertices once
+        if(submesh->useSharedVertices)
+        {
+            if(!added_shared)
+            {
+                                Ogre::VertexData* vertex_data = mMesh->get()->sharedVertexData;
+                vertex_count += vertex_data->vertexCount;
+                added_shared = true;
+            }
+        }
+        else
+        {
+                        Ogre::VertexData* vertex_data = submesh->vertexData;
+            vertex_count += vertex_data->vertexCount;
+        }
+
+        // Add the indices
+        Ogre::IndexData* index_data = submesh->indexData;
+        index_count += index_data->indexCount;
+    }
+
+        unsigned int* indices = NULL;
+        if (mergeSubMeshes)
+        {
+                indices = new unsigned[index_count];
+        }
+
         added_shared = false;
         for (unsigned short i = 0; i < mMesh->get()->getNumSubMeshes(); i++)
@@ -119 +155 @@
                 Ogre::SubMesh* subMesh = mMesh->get()->getSubMesh(i);
                 Ogre::VertexData* vertexData = subMesh->useSharedVertices ? mMesh->get()->sharedVertexData : subMesh->vertexData;
+
+                if (!mergeSubMeshes)
+                {
+                        // Add the indices
+                        Ogre::IndexData* index_data = subMesh->indexData;
+                        index_count = index_data->indexCount;
+
+                        if (indices != NULL)
+                        {
+                                delete [] indices;
+                        }
+
+                        indices = new unsigned[index_count];
+                }
 
                 if ((!subMesh->useSharedVertices) || (subMesh->useSharedVertices && !added_shared))
@@ -154 +204 @@
                         vbuf->unlock();
                         next_offset += vertexData->vertexCount;
-                }      
-        }
-    current_offset = next_offset;
+   
+
+                        Ogre::IndexData* index_data = subMesh->indexData;
+
+                        size_t numTris = index_data->indexCount / 3;
+                        unsigned short* pShort;
+                        unsigned int* pInt;
+                        Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
+                        bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
+                        if (use32bitindexes) pInt = static_cast<unsigned int*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
+                        else pShort = static_cast<unsigned short*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
+
+                        index_offset = 0;
+                        for(size_t k = 0; k < numTris; ++k)
+                        {
+                                size_t offset;
+                                if (!mergeSubMeshes)
+                                {
+                                        offset = (subMesh->useSharedVertices)?shared_offset:0;
+                                }
+                                else
+                                {
+                                        offset = (subMesh->useSharedVertices)?shared_offset:current_offset;
+                                }
+
+                                unsigned int vindex = use32bitindexes? *pInt++ : *pShort++;
+                                indices[index_offset + 0] = vindex + offset;
+                                
+                                vindex = use32bitindexes? *pInt++ : *pShort++;
+                                indices[index_offset + 1] = vindex + offset;
+                                
+                                vindex = use32bitindexes? *pInt++ : *pShort++;
+                                indices[index_offset + 2] = vindex + offset;                    
+                                                        
+                                index_offset += 3;
+                        }
+                
+                        for(size_t k = 0; k < index_count; k = k + 3)
+                        {
+                                if (!mergeSubMeshes)
+                                {
+                                        this->getSubEntity(i)->addFaceVerticesIDs(Ogre::Vector3(indices[k], indices[k+1], indices[k+2]));       
+                                }
+                                else
+                                {
+                                        this->getSubEntity(0)->addFaceVerticesIDs(Ogre::Vector3(indices[k], indices[k+1], indices[k+2]));       
+                                }
+                        }
+                        ibuf->unlock();
+                        current_offset = next_offset;
+                }
+        }
+
+        delete [] indices;
 }
 
@@ -240 +341 @@
                                 Ogre::HardwareVertexBufferSharedPtr vbuf = vertexData->vertexBufferBinding->getBuffer(colourElem->getSource());
                                 unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
-                                Ogre::RGBA *pSrcRGBA;
+                                Ogre::ARGB *pSrcARGB;
 
                                 for(size_t j = 0; j < vertexData->vertexCount; ++j, vertex += vbuf->getVertexSize())
@@ -246 +347 @@
                                         if (colourElem)
                                         {
-                                                colourElem->baseVertexPointerToElement(vertex, &pSrcRGBA);
-                                        }
+                                                colourElem->baseVertexPointerToElement(vertex, &pSrcARGB);
                                         
-                                        Ogre::ColourValue colour((Ogre::RGBA)(*pSrcRGBA));
-
-                                        if (!mergeSubMeshes)
-                                        {
-                                                this->getSubEntity(i)->setVertexColour(j,colour.getAsRGBA());   
-                                        }
-                                        else
-                                        {                               
-                                                this->getSubEntity(0)->setVertexColour(j,colour.getAsRGBA());
+                                                Ogre::ColourValue colour;
+                                                colour.setAsARGB((Ogre::ARGB)(*pSrcARGB));
+
+                                                if (!mergeSubMeshes)
+                                                {
+                                                        this->getSubEntity(i)->setVertexColour(j,colour.getAsARGB());   
+                                                }
+                                                else
+                                                {                               
+                                                        this->getSubEntity(0)->setVertexColour(j,colour.getAsARGB());
+                                                }
                                         }
                                 }
@@ -301 +403 @@
                         }
 
-                        const Ogre::VertexElement* texcoordElem = vertexData->vertexDeclaration->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES);
-                        Ogre::HardwareVertexBufferSharedPtr vbuf = vertexData->vertexBufferBinding->getBuffer(texcoordElem->getSource());
-                        unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
-
-                        Ogre::VertexDeclaration* decl = vertexData->vertexDeclaration;
-                        Ogre::VertexBufferBinding* bind = vertexData->vertexBufferBinding;
-                        Ogre::VertexBufferBinding::VertexBufferBindingMap::const_iterator b, bend;
-                        bend = bind->getBindings().end();
-                        // Iterate over buffers
-                        for (b = bind->getBindings().begin(); b != bend; ++b)
-                        {
-                                const Ogre::HardwareVertexBufferSharedPtr vbuf = b->second;
-                                unsigned short bufferIdx = b->first;
-                                // Get all the elements that relate to this buffer
-                                Ogre::VertexDeclaration::VertexElementList elems = decl->findElementsBySource(bufferIdx);
-                                Ogre::VertexDeclaration::VertexElementList::iterator it, itend;
-                                itend = elems.end();
-
-                                // Skim over the elements to set up the general data
-                                unsigned short numTextureCoords = 0;
-                                std::vector<unsigned int> baseTexCoordSetIndex;
-                                for (it = elems.begin(); it != itend; ++it)
-                                {
-                                        Ogre::VertexElement& elem = *it;
-                                        if (elem.getSemantic() == Ogre::VES_TEXTURE_COORDINATES)
+                        const Ogre::VertexElement* texcoordElem = NULL;
+                        texcoordElem = vertexData->vertexDeclaration->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES);
+                        if (texcoordElem != NULL)
+                        {
+                                Ogre::HardwareVertexBufferSharedPtr vbuf = vertexData->vertexBufferBinding->getBuffer(texcoordElem->getSource());
+                                unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
+
+                                Ogre::VertexDeclaration* decl = vertexData->vertexDeclaration;
+                                Ogre::VertexBufferBinding* bind = vertexData->vertexBufferBinding;
+                                Ogre::VertexBufferBinding::VertexBufferBindingMap::const_iterator b, bend;
+                                bend = bind->getBindings().end();
+                                // Iterate over buffers
+                                for (b = bind->getBindings().begin(); b != bend; ++b)
+                                {
+                                        const Ogre::HardwareVertexBufferSharedPtr vbuf = b->second;
+                                        unsigned short bufferIdx = b->first;
+                                        // Get all the elements that relate to this buffer
+                                        Ogre::VertexDeclaration::VertexElementList elems = decl->findElementsBySource(bufferIdx);
+                                        Ogre::VertexDeclaration::VertexElementList::iterator it, itend;
+                                        itend = elems.end();
+
+                                        // Skim over the elements to set up the general data
+                                        unsigned short numTextureCoords = 0;
+                                        std::vector<unsigned int> baseTexCoordSetIndex;
+                                        for (it = elems.begin(); it != itend; ++it)
                                         {
-                                                if (numTextureCoords == 0)
+                                                Ogre::VertexElement& elem = *it;
+                                                if (elem.getSemantic() == Ogre::VES_TEXTURE_COORDINATES)
                                                 {
-                                                        baseTexCoordSetIndex.push_back(0);
-                                                        baseTexCoordSetIndex.push_back(Ogre::VertexElement::getTypeCount(elem.getType()));
+                                                        if (numTextureCoords == 0)
+                                                        {
+                                                                baseTexCoordSetIndex.push_back(0);
+                                                                baseTexCoordSetIndex.push_back(Ogre::VertexElement::getTypeCount(elem.getType()));
+                                                        }
+                                                        ++numTextureCoords;
                                                 }
-                                                ++numTextureCoords;
                                         }
-                                }
-
-                                // There is _no_ baseVertexPointerToElement() which takes an Ogre::Real or a double
-                                // as a second argument. So make it float, to avoid trouble when Ogre::Real will be
-                                // compiled/typedefed as double:
-                                // Ogre::Real* pReal;
-                                float* pReal;
-
-                                unsigned int baseTexCoord = 0;
-                                unsigned int texCoordSet = 0;
-                                unsigned int dimBaseTexCoord = 0;
-                                for (unsigned int texCoordSet = 0; texCoordSet < numTextureCoords; texCoordSet++)
-                                {
-                                        for (unsigned int iTexCoordSet = 0; iTexCoordSet <= texCoordSet; iTexCoordSet++)
+
+                                        // There is _no_ baseVertexPointerToElement() which takes an Ogre::Real or a double
+                                        // as a second argument. So make it float, to avoid trouble when Ogre::Real will be
+                                        // compiled/typedefed as double:
+                                        // Ogre::Real* pReal;
+                                        float* pReal;
+
+                                        unsigned int baseTexCoord = 0;
+                                        unsigned int texCoordSet = 0;
+                                        unsigned int dimBaseTexCoord = 0;
+                                        for (unsigned int texCoordSet = 0; texCoordSet < numTextureCoords; texCoordSet++)
                                         {
-                                                baseTexCoord = baseTexCoord + baseTexCoordSetIndex[iTexCoordSet];
-                                        }
-                                        unsigned short dimTexCoord = (unsigned short)baseTexCoordSetIndex[texCoordSet+1];
-                                        for (size_t j = 0; j < vertexData->vertexCount; j++, vertex += vbuf->getVertexSize())
-                                        {
-                                                texcoordElem->baseVertexPointerToElement(vertex, &pReal);
-                                                Ogre::Vector3 texcoord;
-                                                if (baseTexCoordSetIndex[texCoordSet+1] == 2)
+                                                for (unsigned int iTexCoordSet = 0; iTexCoordSet <= texCoordSet; iTexCoordSet++)
                                                 {
-                                                        texcoord = Ogre::Vector3(pReal[baseTexCoord + 0], pReal[baseTexCoord + 1], 0.0);
-                                                        dimBaseTexCoord = 2;
+                                                        baseTexCoord = baseTexCoord + baseTexCoordSetIndex[iTexCoordSet];
                                                 }
-                                                else if (baseTexCoordSetIndex[texCoordSet + 1] == 3)
+                                                unsigned short dimTexCoord = (unsigned short)baseTexCoordSetIndex[texCoordSet+1];
+                                                for (size_t j = 0; j < vertexData->vertexCount; j++, vertex += vbuf->getVertexSize())
                                                 {
-                                                        texcoord = Ogre::Vector3(pReal[baseTexCoord + 0], pReal[baseTexCoord + 1], pReal[baseTexCoord + 2]);
-                                                        dimBaseTexCoord = 3;
-                                                }
-                                        
+                                                        texcoordElem->baseVertexPointerToElement(vertex, &pReal);
+                                                        Ogre::Vector3 texcoord;
+                                                        if (baseTexCoordSetIndex[texCoordSet+1] == 2)
+                                                        {
+                                                                texcoord = Ogre::Vector3(pReal[baseTexCoord + 0], pReal[baseTexCoord + 1], 0.0);
+                                                                dimBaseTexCoord = 2;
+                                                        }
+                                                        else if (baseTexCoordSetIndex[texCoordSet + 1] == 3)
+                                                        {
+                                                                texcoord = Ogre::Vector3(pReal[baseTexCoord + 0], pReal[baseTexCoord + 1], pReal[baseTexCoord + 2]);
+                                                                dimBaseTexCoord = 3;
+                                                        }
+                                                
+                                                        if (!mergeSubMeshes)
+                                                        {
+                                                                this->getSubEntity(i)->setTexCoord(j,texCoordSet,texcoord);
+                                                        }
+                                                        else
+                                                        {
+                                                                this->getSubEntity(0)->setTexCoord(j,texCoordSet,texcoord);                             
+                                                        }
+                                                }                       
+                                
                                                 if (!mergeSubMeshes)
                                                 {
-                                                        this->getSubEntity(i)->setTexCoord(j,texCoordSet,texcoord);
+                                                        this->getSubEntity(i)->addTextureCoordSet(dimBaseTexCoord);
                                                 }
                                                 else
                                                 {
-                                                        this->getSubEntity(0)->setTexCoord(j,texCoordSet,texcoord);                             
+                                                        if (i == 0)
+                                                        {
+                                                                this->getSubEntity(0)->addTextureCoordSet(dimBaseTexCoord);
+                                                        }
                                                 }
-                                        }                       
-                        
-                                        if (!mergeSubMeshes)
-                                        {
-                                                this->getSubEntity(i)->addTextureCoordSet(dimBaseTexCoord);
-                                        }
-                                        else
-                                        {
-                                                if (i == 0)
-                                                {
-                                                        this->getSubEntity(0)->addTextureCoordSet(dimBaseTexCoord);
-                                                }
-                                        }
-                                }       
-                        }                       
-                        vbuf->unlock();
-                        next_offset += vertexData->vertexCount;
+                                        }       
+                                }                       
+                                vbuf->unlock();
+                                next_offset += vertexData->vertexCount;
+                        }
                 }      
         }

GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/src/BBCSubEntity.cpp

@@ -45 +45 @@
 }
 
-Ogre::Vector3 SubEntity::getTexCoord(unsigned int index, unsigned int set, unsigned int value)
+Ogre::Vector3 SubEntity::getTexCoord(unsigned int index, unsigned int set)
 {
         return mUniqueVertexList[index].uv[set];