Changeset 751 for GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/src/LBBCBillboardCloudTextureViewMode.cpp

Timestamp:

04/19/06 00:27:14 (18 years ago)

Author:

igarcia

Message:

 

File:

• GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/src/LBBCBillboardCloudTextureViewMode.cpp (modified) (6 diffs)

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

@@ -10 +10 @@
 {       
         mFrame = 0;
-        mDebugOverlay->setScale(0.0, 0.0);
+        mCurrentBillboardGroup = 0;
+        mCurrentBillboard = 0;
+        showDebugOverlay(false);
+        mDebugBillboardGeneration = false;
+        mDebugTextureAtlasGeneration = false;
 }
 
@@ -18 +22 @@
 }
 
+
+void BillboardCloudTextureViewMode::setBillboardCloudGroupedTextureAtlasDebug(bool debugTextureAtlasGeneration)
+{
+        mDebugTextureAtlasGeneration = debugTextureAtlasGeneration;
+}
+
+void BillboardCloudTextureViewMode::configureBillboardOrthogonalAlignedCamera(unsigned int iBillboard)
+{
+        BBC::BillboardPtr billboardPtr = ((LBBC::LBBCManager*)LBBC::LBBCManager::getSingletonPtr())->getLeaves()->getBillboardCloud()->getBillboard(iBillboard);
+        Ogre::Vector3 vTopLeft = billboardPtr->getBillboardClusterData()->getQuadTopLeftCorner();
+        Ogre::Vector3 vTopRight = billboardPtr->getBillboardClusterData()->getQuadTopRightCorner();
+        Ogre::Vector3 vBottomLeft = billboardPtr->getBillboardClusterData()->getQuadBottomLeftCorner();
+        Ogre::Vector3 vBottomRight = billboardPtr->getBillboardClusterData()->getQuadBottomRightCorner();
+
+        Ogre::Vector3 vMidPoint = vTopLeft.midPoint(vBottomRight);
+        Ogre::Vector3 vWidth(vTopRight - vTopLeft);
+        Ogre::Vector3 vHeight(vBottomLeft - vTopLeft);
+
+        Ogre::Real w = vWidth.length();
+        Ogre::Real h = vHeight.length();
+        Ogre::Real aspect = w / h;
+        Ogre::Radian fovy = Ogre::Radian(Ogre::Degree(90.0));
+        Ogre::Real nearPlane =  h / Ogre::Math::Tan(fovy/2.0,false);
+        Ogre::Real farPlane = 100000;
+
+        Ogre::Vector3 vUp = vTopLeft - vBottomLeft;
+        vUp.normalise();
+
+        Ogre::Vector3 vI(vTopRight-vTopLeft);
+        vI.normalise();
+
+        Ogre::Vector3 vJ(vBottomLeft-vTopLeft);
+        vJ.normalise();
+
+        Ogre::Vector3 vDir = -vI.crossProduct(vJ);
+        vDir.normalise();
+
+        Ogre::Vector3 vRight = vDir.crossProduct(vUp);
+        vRight.normalise();     
+
+        Ogre::Quaternion qOrientation(vRight, vUp, -vDir);
+        
+        mCamera->setNearClipDistance(nearPlane);
+        mCamera->setOrientation(qOrientation);
+        mCamera->setPosition(vMidPoint - (vDir * (nearPlane*nearPlane)));
+
+        Ogre::Radian thetaY (fovy / 2.0f);
+        Ogre::Real tanThetaY = Ogre::Math::Tan(thetaY);
+
+        Ogre::Real tanThetaX = tanThetaY * aspect;
+
+        Ogre::Real half_w,half_h;
+        half_w = w / 2.0;
+        half_h = h / 2.0;
+
+        Ogre::Real iw = 1.0 / half_w;
+        Ogre::Real ih = 1.0 / half_h;
+        Ogre::Real q;
+        if (farPlane == 0)
+        {
+                q = 0;
+        }
+        else
+        {
+                q = 2.0 / (farPlane - nearPlane);
+        }
+        mCustomProjMatrix = Ogre::Matrix4::ZERO;
+        mCustomProjMatrix[0][0] = iw;
+        mCustomProjMatrix[1][1] = ih;
+        mCustomProjMatrix[2][2] = -q;
+        mCustomProjMatrix[2][3] = - (farPlane + nearPlane)/(farPlane - nearPlane);
+        mCustomProjMatrix[3][3] = 1;    
+}
+
+void BillboardCloudTextureViewMode::saveTextureAtlas()
+{
+        if (mBitRange == 32)
+        {
+                mDestPixelFormat = Ogre::PF_FLOAT32_RGBA;
+        }
+        else if (mBitRange == 16)
+        {
+                mDestPixelFormat = Ogre::PF_FLOAT16_RGBA;
+        }
+        else  // mBitRange == 8
+        {
+                mDestPixelFormat = Ogre::PF_BYTE_RGBA;
+        }
+
+        Ogre::String textureAtlasFileName = BBC::Util::getBaseName(mTextureAtlasName) + Ogre::StringConverter::toString(mCurrentBillboardGroup) + "." + BBC::Util::getExtensionName(mTextureAtlasName);
+        mTextureAtlas->save(mTextureAtlasFolder, textureAtlasFileName, mDestPixelFormat);
+}
+
+void BillboardCloudTextureViewMode::disableEntityClusterCustomOrthogonalCameraMaterial(unsigned int iEntityClusterGrouped)
+{
+        mEntityClustersGrouped->getSubEntity(iEntityClusterGrouped)->getMaterial()->getTechnique(0)->getPass(0)->setVertexProgram("");
+        mEntityClustersGrouped->getSubEntity(iEntityClusterGrouped)->getMaterial()->getTechnique(0)->getPass(0)->setFragmentProgram("");
+        mEntityClustersGrouped->getSubEntity(iEntityClusterGrouped)->getMaterial()->reload();
+}
+
+void BillboardCloudTextureViewMode::enableEntityClusterCustomOrthogonalCameraMaterial(unsigned int iEntityClusterGrouped)
+{
+        mEntityClustersGrouped->getSubEntity(iEntityClusterGrouped)->getMaterial()->getTechnique(0)->getPass(0)->setVertexProgram("diffuseTextureVP");
+        mEntityClustersGrouped->getSubEntity(iEntityClusterGrouped)->getMaterial()->getTechnique(0)->getPass(0)->setFragmentProgram("diffuseTextureFP");
+
+        Ogre::GpuProgramParametersSharedPtr vertParams;
+        Ogre::GpuProgramParametersSharedPtr fragParams;
+        vertParams = mEntityClustersGrouped->getSubEntity(iEntityClusterGrouped)->getMaterial()->getTechnique(0)->getPass(0)->getVertexProgramParameters();
+        fragParams = mEntityClustersGrouped->getSubEntity(iEntityClusterGrouped)->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
+
+        vertParams->setNamedConstant("projectionmatrix", mCamera->getProjectionMatrixWithRSDepth());
+        vertParams->setNamedAutoConstant("worldmatrix", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX);
+        vertParams->setNamedAutoConstant("viewmatrix", Ogre::GpuProgramParameters::ACT_VIEW_MATRIX);
+        mEntityClustersGrouped->getSubEntity(iEntityClusterGrouped)->getMaterial()->reload();
+}
+
+void BillboardCloudTextureViewMode::configureTexture()
+{
+        mTextureAtlas->getRectangle2D()->setVisible(false);
+        mEntityClustersGrouped->getSubEntity((mCurrentTexture-1) % mEntityClustersGrouped->getNumSubEntities())->setVisible(false);
+        mEntityClustersGrouped->getSubEntity(mCurrentTexture % mEntityClustersGrouped->getNumSubEntities())->setVisible(true);
+
+        configureBillboardOrthogonalAlignedCamera(mCurrentTexture % mBillboardCloudSplitted->getNumSubEntities());
+        mCamera->setCustomProjectionMatrix(true,mCustomProjMatrix);
+
+        if (mDebugTextureAtlasGeneration)
+        {
+                mClusterTexture->getMaterial()->getTechnique(0)->getPass(0)->setAmbient(Ogre::Math::RangeRandom(0.0,1.0), Ogre::Math::RangeRandom(0.0,1.0), Ogre::Math::RangeRandom(0.0,1.0));
+                mClusterTexture->getMaterial()->getTechnique(0)->getPass(0)->setDiffuse(Ogre::Math::RangeRandom(0.0,1.0), Ogre::Math::RangeRandom(0.0,1.0), Ogre::Math::RangeRandom(0.0,1.0), 1.0);
+        }
+}
+
+void BillboardCloudTextureViewMode::generateTexture()
+{
+        configureTexture();
+
+        enableEntityClusterCustomOrthogonalCameraMaterial(mCurrentTexture % mEntityClustersGrouped->getNumSubEntities());
+        
+        mClusterTexture->update();              
+
+        disableEntityClusterCustomOrthogonalCameraMaterial(mCurrentTexture % mEntityClustersGrouped->getNumSubEntities());
+}
+
+void BillboardCloudTextureViewMode::initializeEntityClustersGrouped()
+{
+        if (mFrame == 1)
+        {
+                for (unsigned int iSubEntity = 0; iSubEntity < mEntityClustersGrouped->getNumSubEntities(); iSubEntity++)
+                {
+                        mEntityClustersGrouped->getSubEntity(iSubEntity)->setVisible(false);
+                }
+        }
+}
+
+void BillboardCloudTextureViewMode::initializeBillboardCloudSplitted()
+{
+        if (mFrame == 1)
+        {
+                for (unsigned int iSubEntity = 0; iSubEntity < mBillboardCloudSplitted->getNumSubEntities(); iSubEntity++)
+                {
+                        mBillboardCloudSplitted->getSubEntity(iSubEntity)->setVisible(false);
+                }
+        }
+}
+
+bool BillboardCloudTextureViewMode::processUnbufferedKeyInput(const Ogre::FrameEvent& evt)
+{
+        if (mInputDevice->isKeyDown(Ogre::KC_SPACE))
+    {
+        mCurrentTexture++;
+    }
+
+        return OgreFrameListenerMode::processUnbufferedKeyInput(evt);
+}
+
+void BillboardCloudTextureViewMode::configureTextureAtlas()
+{
+        mEntityClustersGrouped->getSubEntity(mCurrentTexture % mEntityClustersGrouped->getNumSubEntities())->setVisible(false);
+
+        mClusterTexture->getRectangle2D()->setVisible(true);
+        mTextureAtlas->getRectangle2D()->setVisible(true);
+
+        Ogre::Vector2 uvMapMax = ((LBBC::LBBCManager*)LBBC::LBBCManager::getSingletonPtr())->getLeaves()->getBillboardCloud()->getBillboard(mCurrentTexture % mEntityClustersGrouped->getNumSubEntities())->getBillboardClusterData()->getBillboardUVMapMax(0);
+        Ogre::Vector2 uvMapMin = ((LBBC::LBBCManager*)LBBC::LBBCManager::getSingletonPtr())->getLeaves()->getBillboardCloud()->getBillboard(mCurrentTexture % mEntityClustersGrouped->getNumSubEntities())->getBillboardClusterData()->getBillboardUVMapMin(0);
+
+        mClusterTexture->setCorners(uvMapMin[0], uvMapMax[1], uvMapMax[0], uvMapMin[1]);
+}
+
+void BillboardCloudTextureViewMode::generateTextureAtlas()
+{       
+        configureTextureAtlas();
+
+        mTextureAtlas->update();                
+        //mTextureAtlas->debug();
+        
+        mClusterTexture->getRectangle2D()->setVisible(false);
+}
+
 bool BillboardCloudTextureViewMode::frameStarted(const Ogre::FrameEvent& evt, Ogre::InputReader *inputReader)
 {
-        if (mFrame == 1)
-        {
-                for (unsigned int iSubEntity = 0; iSubEntity < mClusterizedEntities->getNumSubEntities(); iSubEntity++)
+        initializeEntityClustersGrouped();
+    initializeBillboardCloudSplitted();
+
+        if (mFrame > 1)
+        {               
+                if (!mDebugBillboardGeneration)
                 {
-                        mClusterizedEntities->getSubEntity(iSubEntity)->setVisible(false);
+                        mWindow->getViewport(0)->setBackgroundColour(Ogre::ColourValue(1.0, 1.0, 1.0, 1.0));
+
+                        if (mCurrentTexture < mNumTextures)
+                        {
+                                generateTexture();
+
+                                generateTextureAtlas();
+
+                                mCurrentTexture++;
+                                mCurrentBillboard++;
+
+                                unsigned int numBillboardsCurrentGroups = ((LBBC::LBBCManager*)LBBC::LBBCManager::getSingletonPtr())->getLeaves()->getBillboardCloud()->getBillboardGroup(mCurrentBillboardGroup)->getNumBillboards();
+
+                                if (mCurrentBillboard == numBillboardsCurrentGroups)
+                                {
+                                        saveTextureAtlas();
+                                        
+                                        unsigned int numBillboardGroups = ((LBBC::LBBCManager*)LBBC::LBBCManager::getSingletonPtr())->getLeaves()->getBillboardCloud()->getNumBillboardGroups();
+
+                                        if (mCurrentBillboardGroup < numBillboardGroups)
+                                        {
+                                                mCurrentBillboard = 0;
+                                                mCurrentBillboardGroup++;                                               
+
+                                                mTextureAtlas->getRectangle2D()->setVisible(false);
+                                                mTextureAtlas->update();
+                                                //mTextureAtlas->debug();
+                                        }
+                                }
+                        }
+
+                        if (mCurrentTexture == mNumTextures)
+                        {                               
+                                mDebugBillboardGeneration = true;
+
+                                mWindow->getViewport(0)->setBackgroundColour(Ogre::ColourValue(0.0, 0.0, 0.0, 1.0)); 
+
+                                mTextureAtlas->getRectangle2D()->setVisible(false);
+
+                                mCurrentTexture = 0;
+                        }
                 }
-        }
-        
-        if (mFrame > 1)
-        {
-                mClusterizedEntities->getSubEntity((mCurrentTexture-1) % mClusterizedEntities->getNumSubEntities())->setVisible(false);
-        }
-
-        if (mFrame == 1)
-        {
-                mTextureAtlas->update();
-        }
-
-        if (mFrame > 1)
-        {
-                mClusterizedEntities->getSubEntity(mCurrentTexture % mClusterizedEntities->getNumSubEntities())->setVisible(true);
-                mClusterTextureListener.setSubEntityVisible(mCurrentTexture% mClusterizedEntities->getNumSubEntities());
-                mClusterTexture->update();
-
-                //if (mCurrentTexture <= mNumTextures)
+                else
                 {
-                        mClusterizedEntities->getSubEntity(mCurrentTexture)->setVisible(false);
-                        mClusterTexture->getMaterial()->getTechnique(0)->getPass(0)->setAmbient( Ogre::Math::RangeRandom(0.0,1.0), Ogre::Math::RangeRandom(0.0,1.0), Ogre::Math::RangeRandom(0.0,1.0) );
-                        mClusterTexture->getRectangle2D()->setVisible(true);
-                        mTextureAtlas->getRectangle2D()->setVisible(true);
-                        Ogre::Vector2 uvMapMax = ((LBBC::LBBCManager*)LBBC::LBBCManager::getSingletonPtr())->getLeaves()->getBillboardCloud()->getBillboard(mCurrentTexture)->getBillboardClusterData()->getBillboardUVMapMax(0);
-                        Ogre::Vector2 uvMapMin = ((LBBC::LBBCManager*)LBBC::LBBCManager::getSingletonPtr())->getLeaves()->getBillboardCloud()->getBillboard(mCurrentTexture)->getBillboardClusterData()->getBillboardUVMapMin(0);
-                        mClusterTexture->setCorners(uvMapMin[0], uvMapMax[1], uvMapMax[0], uvMapMin[1]);
-                        mClusterTexture->getMaterial()->getTechnique(0)->getPass(0)->setAmbient(uvMapMax[0], uvMapMax[1], 0.0);
-                        mTextureAtlas->update();                
-                        //mTextureAtlas->debug();
-                        mClusterTexture->getRectangle2D()->setVisible(false);
-                        
-                        Ogre::LogManager::getSingleton().logMessage("Billboard(" + Ogre::StringConverter::toString(mCurrentTexture) + ") uvMapMin(" + Ogre::StringConverter::toString(uvMapMin[0]) + "," +
-                                Ogre::StringConverter::toString(uvMapMin[1]) + ") uvMapMax(" + Ogre::StringConverter::toString(uvMapMax[0]) + "," +
-                                Ogre::StringConverter::toString(uvMapMax[1]) + ")");
-                        Ogre::LogManager::getSingleton().logMessage(
-                                "USize(" + Ogre::StringConverter::toString(Ogre::Math::Abs(uvMapMax[0]-uvMapMin[0])) +
-                                "," + Ogre::StringConverter::toString(Ogre::Math::Abs(uvMapMax[1]-uvMapMin[1])) + ")");
-
-                        mCurrentTexture++;
-
-                        if (mCurrentTexture == mNumTextures)
-                        {
-                                if (mBitRange == 32)
-                                {
-                                        mDestPixelFormat = Ogre::PF_FLOAT32_RGBA;
-                                }
-                                else if (mBitRange == 16)
-                                {
-                                        mDestPixelFormat = Ogre::PF_FLOAT16_RGBA;
-                                }
-                                else  // mBitRange == 8
-                                {
-                                        mDestPixelFormat = Ogre::PF_BYTE_RGBA;
-                                }
-                                mTextureAtlas->save(mTextureAtlasFolder, mTextureAtlasName, mDestPixelFormat);
-                        }
+                        mWindow->getViewport(0)->setBackgroundColour(Ogre::ColourValue(0.0, 0.0, 0.0, 1.0)); 
+
+                        configureBillboard();
+
+                        configureTexture();
 
                         mCurrentTexture = mCurrentTexture % mNumTextures;
-                }               
+                }
         }
 
@@ -93 +288 @@
 }
 
+void BillboardCloudTextureViewMode::configureBillboard()
+{
+        mBillboardCloudSplitted->getSubEntity((mCurrentTexture-1) % mEntityClustersGrouped->getNumSubEntities())->setVisible(false);
+        mBillboardCloudSplitted->getSubEntity(mCurrentTexture % mEntityClustersGrouped->getNumSubEntities())->setVisible(true);
+}
+
 void BillboardCloudTextureViewMode::setTextureAtlasSize(unsigned int size)
 {
@@ -98 +299 @@
 }
 
-void BillboardCloudTextureViewMode::setEntityName(Ogre::String entityName)
-{
-        mEntityName = entityName;
+void BillboardCloudTextureViewMode::setEntityClustersGroupedName(Ogre::String entityClustersGroupedName)
+{
+        mEntityClustersGroupedName = entityClustersGroupedName;
+}
+
+void BillboardCloudTextureViewMode::setBillboardCloudSplittedName(Ogre::String billboardCloudSplittedName)
+{
+        mBillboardCloudSplittedName = billboardCloudSplittedName;
 }
 
@@ -123 +329 @@
 }
 
+void BillboardCloudTextureViewMode::setTextureName(Ogre::String textureName)
+{
+        mTextureName = textureName;
+}
+
 void BillboardCloudTextureViewMode::createScene()
 {
@@ -139 +350 @@
 
         LBBC::Leaves *mLeaves = ((LBBC::LBBCManager*)LBBC::LBBCManager::getSingletonPtr())->getLeaves();
-        Ogre::LogManager::getSingleton().logMessage("Num.Billboards:" + Ogre::StringConverter::toString(mLeaves->getBillboardCloud()->getNumBillboards()));
-        Ogre::LogManager::getSingleton().logMessage("Num.BillboardGroups:" + Ogre::StringConverter::toString(mLeaves->getBillboardCloud()->getNumBillboardGroups()));
         Ogre::Vector2 uvMapMax = mLeaves->getBillboardCloud()->getBillboard(0)->getBillboardClusterData()->getBillboardUVMapMax(0);
         Ogre::Vector2 uvMapMin = mLeaves->getBillboardCloud()->getBillboard(0)->getBillboardClusterData()->getBillboardUVMapMin(0);
-        Ogre::LogManager::getSingleton().logMessage("BillboardUVMapMax:" + Ogre::StringConverter::toString( Ogre::Vector3(uvMapMax[0], uvMapMax[1], 0.0) ));
-        Ogre::LogManager::getSingleton().logMessage("BillboardUVMapMin:" + Ogre::StringConverter::toString( Ogre::Vector3(uvMapMin[0], uvMapMin[1], 0.0) ));
-
-        mClusterizedEntitiesMergedSceneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
-        Ogre::LogManager::getSingleton().logMessage("Mesh:" + mEntityName);
-        std::cin.get();
-
-        mClusterizedEntities = mSceneMgr->createEntity(mEntityName, mEntityName);
-        //mClusterizedEntities = mSceneMgr->createEntity("mapleLeavesClusterizedEntitiesMerged.mesh", "mapleLeavesClusterizedEntitiesMerged.mesh");
-    mClusterizedEntitiesMergedSceneNode->attachObject(mClusterizedEntities);
+
+        IMG::TexturePtr texturePtr ( new IMG::Texture() );
+        texturePtr->bind(mTextureName);
+        Ogre::ColourValue avgColour = texturePtr->getAvgColour();
+        mWindow->getViewport(0)->setBackgroundColour(Ogre::ColourValue(1.0, 1.0, 1.0, 1.0)); 
+
+        mEntityClustersGroupedSceneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
+        mBillboardCloudSplittedSceneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
+
+        mEntityClustersGrouped = mSceneMgr->createEntity(mEntityClustersGroupedName, mEntityClustersGroupedName);
+    mEntityClustersGroupedSceneNode->attachObject(mEntityClustersGrouped);
+
+        mBillboardCloudSplitted = mSceneMgr->createEntity(mBillboardCloudSplittedName, mBillboardCloudSplittedName);
+    mBillboardCloudSplittedSceneNode->attachObject(mBillboardCloudSplitted);
 
         mTextureAtlas = IMG::TextureAtlasPtr( new IMG::TextureAtlas() );
-        mTextureAtlas->create("TextureAtlas", mTextureAtlasSize, mTextureAtlasSize, mSrcPixelFormat, mCamera);
+        mTextureAtlas->create("TextureAtlas", mTextureAtlasSize, mTextureAtlasSize, mSrcPixelFormat, mCamera, avgColour);
         mTextureAtlas->setRenderTargetListener(&mTextureAtlasListener);
-        mTextureAtlas->setTextureAtlasSceneNode(mClusterizedEntitiesMergedSceneNode);
+        mTextureAtlas->setTextureAtlasSceneNode(mEntityClustersGroupedSceneNode);
         Ogre::MaterialPtr materialPtr1 = Ogre::MaterialManager::getSingleton().create("textureAtlasMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);         
-        materialPtr1->getTechnique(0)->getPass(0)->setDiffuse( 1.0, 1.0, 1.0, 1.0);
         materialPtr1->getTechnique(0)->getPass(0)->setAlphaRejectSettings(Ogre::CMPF_GREATER_EQUAL, 10);
         materialPtr1->getTechnique(0)->getPass(0)->createTextureUnitState("transparent.png");
         materialPtr1->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureFiltering(Ogre::FO_NONE, Ogre::FO_NONE, Ogre::FO_NONE);                    
         materialPtr1->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
+        materialPtr1->getTechnique(0)->getPass(0)->setLightingEnabled(false);
         mTextureAtlas->setMaterial(materialPtr1.getPointer());
         mTextureAtlas->setCorners(-1.0, 1.0, 1.0, -1.0);        
 
         mClusterTexture = IMG::TexturePtr( new IMG::Texture() );
-        mClusterTexture->create("clusterTexture", mTextureSize, mTextureSize, mSrcPixelFormat, mCamera);
+        mClusterTexture->create("clusterTexture", mTextureSize, mTextureSize, mSrcPixelFormat, mCamera, avgColour);
         mClusterTexture->setRenderTargetListener(&mClusterTextureListener);
-        Ogre::MaterialPtr materialPtr = Ogre::MaterialManager::getSingleton().create("textureMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);               
-        materialPtr->getTechnique(0)->getPass(0)->setAmbient( 1.0, Ogre::Math::RangeRandom(0.5,1.0), 1.0 );
-        materialPtr->getTechnique(0)->getPass(0)->setDiffuse( 1.0, 1.0, 1.0, 1.0 );
-        //materialPtr->getTechnique(0)->getPass(0)->setAlphaRejectSettings(Ogre::CMPF_GREATER_EQUAL, 10);
-        //materialPtr->getTechnique(0)->getPass(0)->createTextureUnitState("clusterTexture", 0);
+        Ogre::MaterialPtr materialPtr = Ogre::MaterialManager::getSingleton().create("textureMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);                       
+        if (!mDebugTextureAtlasGeneration)
+        {
+                materialPtr->getTechnique(0)->getPass(0)->setAlphaRejectSettings(Ogre::CMPF_GREATER_EQUAL, 10);
+                materialPtr->getTechnique(0)->getPass(0)->createTextureUnitState("clusterTexture", 0);
+                materialPtr->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureFiltering(Ogre::FO_NONE, Ogre::FO_NONE, Ogre::FO_NONE);                     
+                materialPtr->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);          
+                materialPtr->getTechnique(0)->getPass(0)->setLightingEnabled(false);
+        }
         mClusterTexture->setMaterial(materialPtr.getPointer());
 
         mTextureAtlas->addTexture(mClusterTexture);
         
-        mClusterTextureListener.setNumTextures(mClusterizedEntities->getNumSubEntities());
+        mClusterTextureListener.setNumTextures(mEntityClustersGrouped->getNumSubEntities());
         mClusterTextureListener.setTextureAtlas(mTextureAtlas);
         mClusterTextureListener.setTexture(mClusterTexture);
-        mClusterTextureListener.setEntity(mClusterizedEntities);
-
-        mNumTextures = mClusterizedEntities->getNumSubEntities();
+        mClusterTextureListener.setEntityClusters(mEntityClustersGrouped);
+
+        mNumTextures = mEntityClustersGrouped->getNumSubEntities();
         mCurrentTexture = 0;
 }