Changeset 154 for trunk/VUT/Ogre

Timestamp:

07/04/05 17:57:51 (19 years ago)

Author:

mattausch

Message:

added item buffer queries.

Location:

trunk/VUT/Ogre

Files:

• include/OgreBspHierarchyInterface.h (modified) (1 diff)
• include/OgreItemBufferQueryManager.h (modified) (2 diffs)
• include/OgreOcclusionQueriesQueryManager.h (added)
• include/OgreOctreeHierarchyInterface.h (modified) (3 diffs)
• include/OgrePlatformQueryManager.h (modified) (2 diffs)
• include/OgreSceneNodeHierarchyInterface.h (modified) (1 diff)
• scripts/Plugin_VisibilitySceneManager.vcproj (modified) (2 diffs)
• src/OgreItemBufferQueryManager.cpp (modified) (6 diffs)
• src/OgreOcclusionQueriesQueryManager.cpp (added)
• src/OgreOctreeHierarchyInterface.cpp (modified) (2 diffs)
• src/OgrePlatformQueryManager.cpp (modified) (4 diffs)
• src/OgreSceneNodeHierarchyInterface.cpp (modified) (2 diffs)
• src/OgreVisibilityOctreeSceneManager.cpp (modified) (1 diff)
• src/OgreVisibilityTerrainSceneManager.cpp (modified) (6 diffs)

trunk/VUT/Ogre/include/OgreBspHierarchyInterface.h

@@ -43 +43 @@
         */
         AxisAlignedBox *GetBoundingBox(GtpVisibility::HierarchyNode *node);
-        
-        unsigned int mNumOctreeNodes;
 };
 } // namespace Ogre

trunk/VUT/Ogre/include/OgreItemBufferQueryManager.h

@@ -22 +22 @@
                             bool relativeVisibility = false);
     
-    /** 
-        Uses the specified point to execute the visibility query in all directions. 
-        @sa ComputeCameraVisibility()
-    */
-    void ComputeFromPointVisibility(const Vector3 &point,
-                               InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
-                               InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                               bool relativeVisibility = false);
-    
         bool ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine = false);  
         
@@ -36 +27 @@
         void InitItemBuffer( InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry);
-        bool mWasInitialised;
+        
 };
 

trunk/VUT/Ogre/include/OgreOctreeHierarchyInterface.h

@@ -25 +25 @@
                 See setOption
         */
-        //bool getOption( const String &, void * );
-        //bool getOptionKeys( StringVector &refKeys );
         void PullUpVisibility(GtpVisibility::HierarchyNode *node);
+        
         /** Traverses given node.
                 @param node current node
@@ -50 +49 @@
                                                         InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
                                                         bool includeChildren = false);*/
+
         void GetGeometry(GtpVisibility::HierarchyNode *node,
                                          GtpVisibility::GeometryList *geometryList, 
                                          bool includeChildren);
+
+        void SetNodeId(GtpVisibility::HierarchyNode *node, int id);
+        
+        int GetNodeId(GtpVisibility::HierarchyNode *node);
 
 protected:
@@ -65 +69 @@
         */
         Real GetSquaredViewDepth(const Camera* cam, const AxisAlignedBox* box) const;
-        /** number of octree hierarchy nodes */
-        unsigned int mNumOctreeNodes;
 };
 } // namespace Ogre

trunk/VUT/Ogre/include/OgrePlatformQueryManager.h

@@ -20 +20 @@
     
     /** 
-        Computes restricted visibility from point by using an explicit camera to execute
-        the visibility query.
-        @param camera The camera to be used
-
-        @param visibleNodes Pointer to the container where visible nodes should be added.
-        This set is formed of visible leafs or fully visible interior nodes.
-        If NULL no visible nodes are not evaluated.
-
-        @param visibleGeometry Pointer to the container where visible meshes should be added.
-        If NULL no visible meshes are not evaluated.
-
-        @param projectedPixels If true the visibility member for
-        NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible
-        pixels divided by the the number of projected pixels.
-
-        @return true if the corresponding PVS exists.
-    */
-    virtual void
-    ComputeCameraVisibility(const Camera &camera,
-                            InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
-                            InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                            bool relativeVisibility = false
-                            );
-    
-    /** 
         Uses the specified point to execute the visibility query in all directions. 
         @sa ComputeCameraVisibility()
     */
-    virtual void
-    ComputeFromPointVisibility(const Vector3 &point,
+    void ComputeFromPointVisibility(const Vector3 &point,
                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                               bool relativeVisibility = false
-                               );
+                               bool relativeVisibility = false);
     
   /** 
@@ -79 +52 @@
 protected:
         Viewport *mViewport;
+        bool mWasInitialised;
 };
 

trunk/VUT/Ogre/include/OgreSceneNodeHierarchyInterface.h

@@ -49 +49 @@
                                          GtpVisibility::GeometryList *geometryList, 
                                          bool includeChildren);
+
+        void SetNodeId(GtpVisibility::HierarchyNode *node, int id);
+        
+        int GetNodeId(GtpVisibility::HierarchyNode *node);
 };
 

trunk/VUT/Ogre/scripts/Plugin_VisibilitySceneManager.vcproj

@@ -195 +195 @@
                                 </File>
                                 <File
+                                        RelativePath="..\include\OgreOcclusionQueriesQueryManager.h">
+                                </File>
+                                <File
                                         RelativePath="..\include\OgrePlatformHierarchyInterface.h">
                                 </File>
@@ -227 +230 @@
                                 <File
                                         RelativePath="..\src\OgreItemBufferQueryManager.cpp">
+                                </File>
+                                <File
+                                        RelativePath="..\src\OgreOcclusionQueriesQueryManager.cpp">
                                 </File>
                                 <File

trunk/VUT/Ogre/src/OgreItemBufferQueryManager.cpp

@@ -8 +8 @@
 //----------------------------------------------------------------------- 
 ItemBufferQueryManager::ItemBufferQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp):
-PlatformQueryManager(hierarchyInterface, vp), mWasInitialised(false)
+PlatformQueryManager(hierarchyInterface, vp)
 {
 }
@@ -23 +23 @@
                             bool relativeVisibility)
 {
-        // initialise item buffer if necessary
+        // initialise item buffer (if not already initialised)
         InitItemBuffer(visibleNodes, visibleGeometry);
 
@@ -45 +45 @@
         sm->setOption("UseItemBuffer", &useItemBuffer);
         
-        // clear background with black
+        // clear background with black (i.e., not a valid item id)
         ColourValue bg = mViewport->getBackgroundColour();
         mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0));
@@ -70 +70 @@
         uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy);
 
+        
         // loop through frame buffer & collect visible pixels
         for (int idx = 0; idx < dimy * dimx * 3; idx += 3)
         {
+                // -- decode color code to receive id
                 int id = buf[idx] << 16;
                 id += buf[idx + 1] << 8;
                 id += buf[idx + 2];
 
-                // if valid id <= add visibility
-                if ((id >= 0) && (id < (int)visibleGeometry->size()))
+                // if valid id <= add visibility (id values start at 1
+                if ((id > 0) && (id < (int)visibleGeometry->size()))
                 {
                         ((*visibleGeometry)[id]).AddVisibility(1, 1);
                 }
-        /*      else
-                { 
-                        std::stringstream d; 
-                        d << "id: " << id << ", buf 1: " << (int)buf[idx] << ", buf 2: " << (int)buf[idx + 1] << ", buf 3: " << (int)buf[idx + 2];
-                        LogManager::getSingleton().logMessage(d.str());
-                }*/
+                /*else {        std::stringstream d; 
+                        d << "adding pixel to geometry with id: " << id << ", buf 1: " << (int)buf[idx] << ", buf 2: " << (int)buf[idx + 1] << ", buf 3: " << (int)buf[idx + 2];
+                        LogManager::getSingleton().logMessage(d.str()); }*/
         }
 
@@ -104 +103 @@
         mWasInitialised = true;
 
-        SceneManager::EntityIterator it = dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->
+        SceneManager::EntityIterator it = 
+                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->
                 GetSceneManager()->getEntityIterator();
 
         // TODO: make this more efficient
         visibleGeometry->clear();
+        visibleNodes->clear();
 
         while (it.hasMoreElements())
@@ -115 +116 @@
         }
 }
-//-----------------------------------------------------------------------
-void ItemBufferQueryManager::ComputeFromPointVisibility(const Vector3 &point,
-                               InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
-                               InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                               bool relativeVisibility)
-{
-        SceneManager *sm = dynamic_cast<PlatformHierarchyInterface *>
-                (mHierarchyInterface)->GetSceneManager();
-
-        Camera *cam = sm->createCamera("PointQueryCam");        
-
-        //save old camera
-        Camera *savedCam = mViewport->getCamera();
-        
-        // --- initialise new camera
-        mViewport->setCamera(cam);
-        cam->setPosition(point);
-
-        cam->setNearClipDistance(savedCam->getNearClipDistance());
-        cam->setFarClipDistance(savedCam->getFarClipDistance());
-
-        // set frustum to 45 degrees so all the scene can be captured with 6 shots
-        cam->setAspectRatio(1.0);
-        cam->setFOVy(Radian(Math::HALF_PI));
-
-        int sign = -1;
-        
-        // ---- capture visibility from all 6 directions
-        for (int i=0; i < 6; i++)       
-        {
-                sign *= -1;
-                
-                // Print camera details
-        std::stringstream d;
-                d << "Point query camera: " + StringConverter::toString(cam->getDerivedPosition()) + 
-                        " " + "O: " + StringConverter::toString(cam->getDerivedOrientation());
-                LogManager::getSingleton().logMessage(d.str());
-
-                // prevent from initialising array again
-                if (i > 0)
-                        mWasInitialised = true;
-                
-                // compute camera visibility for this direction
-                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility);
-
-                //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait"); // HACK: DISPLAY CAMERA VIEW
-
-                // --- permute directions
-                Vector3 dir(0,0,0);
-                dir[i/2] = sign;
-
-                cam->setDirection(dir);
-        }
-        
-        // reset camera
-        mViewport->setCamera(savedCam);
-}
-
 } // namespace Ogre

trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

@@ -55 +55 @@
 }
 //-----------------------------------------------------------------------
-void OctreeHierarchyInterface::SetNumOctreeNodes(unsigned int num)
-{
-        mNumOctreeNodes = num;
-}
-//-----------------------------------------------------------------------
 float OctreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
 {
@@ -173 +168 @@
                 SceneNodeHierarchyInterface::GetGeometry(*nodeIt, geometryList, includeChildren);
         }
+}
+//-----------------------------------------------------------------------
+void OctreeHierarchyInterface::SetNodeId(GtpVisibility::HierarchyNode *node, int id)
+{
+        static_cast<Octree *>(node)->setId(id);
+}
+//-----------------------------------------------------------------------
+int OctreeHierarchyInterface::GetNodeId(GtpVisibility::HierarchyNode *node)
+{
+        return static_cast<Octree *>(node)->getId();
 }
 //-----------------------------------------------------------------------

trunk/VUT/Ogre/src/OgrePlatformQueryManager.cpp

@@ -10 +10 @@
 //----------------------------------------------------------------------- 
 PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp):
-QueryManager(hierarchyInterface), mViewport(vp)
+QueryManager(hierarchyInterface), mViewport(vp), mWasInitialised(false)
 {
 }
@@ -18 +18 @@
     // run OGRE ray shooting query
     return false;
-}
-//-----------------------------------------------------------------------
-void PlatformQueryManager::ComputeCameraVisibility(const Camera &camera,
-                            InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
-                            InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                            bool relativeVisibility)
-{
-        // we need access to the scene manager and the rendersystem
-        PlatformHierarchyInterface *pfHierarchyInterface = 
-                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface);
-
-        //-- Render scene to get conservative visibility and fill depth buffer 
-
-        // const_cast allowed because camera is not changed in renderScene
-        Camera *pCam = const_cast<Camera *>(&camera); 
-
-        // disable overlays, reset them later
-        bool overlayEnabled = mViewport->getOverlaysEnabled();
-        mViewport->setOverlaysEnabled(false);
-
-        //-- render the scene once to update depth buffer
-        pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false);
-
-        /* 
-                Two query lists for projected pixels and for visibile pixels:
-                We test queries after a rendering pass 
-                to get exact visibility with regard to the current camera.
-                We issue all queries at once to avoid starvation & stalls.
-        */
-        GtpVisibility::QueryList queryList[2];
-        
-        // get rendered hierarchy nodes
-        GtpVisibility::HierarchyNodeList *nodeList = mHierarchyInterface->GetRenderedNodes();
-        // vector for storing entities of meshes
-        GtpVisibility::GeometryList geometryList;
-        
-        GtpVisibility::HierarchyNodeList::iterator nodeIt, nodeIt_end = nodeList->end();
-        // geometry list has still do be built
-        GtpVisibility::GeometryList::iterator geometryIt, geometryIt_end;
-
-        // to obtain the correct number of projected pixels, depth write must be disabled
-        bool enableDepthWrite = false;
-
-        // this option must be provided by the scene manager
-        pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite);
-
-        /* relative visiblity:
-                1) get visible pixels count of objects
-                2) clear frame buffer
-                3) get projected visible pixels count:
-                   test all objects again without depth write (set as option in scene manager)
-                4) calculate ratio between visible vs. projected pixels
-        */
-        // for relative visibility we need 2 rendering passes
-        int n = relativeVisibility ? 2 : 1;
-        
-        for (int i=0; i<n; ++i)
-        {
-                //-- queries for hierarchy nodes
-                for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)                
-                {
-                        // TODO: DELETE QUERIES FROM PREVIOUS RENDER
-                        queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*nodeIt, false));
-                        
-                        // store geometry of the hierarchy node in a geometry list (only once!)
-                        if (i == 0)
-                        {
-                                mHierarchyInterface->GetGeometry(*nodeIt, &geometryList, false);
-                        }
-                }
-
-                geometryIt_end = geometryList.end();
-
-                //-- add queries for geometry
-                for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt)
-                {
-                        queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt));
-                }
-
-        
-                pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_DEPTH);
-        }
-
-        enableDepthWrite = true;
-        // this option must be provided by the scene manager
-        pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite);
-        // reset old overlay status
-        mViewport->setOverlaysEnabled(overlayEnabled);
-
-        //---- collect results
-        GtpVisibility::QueryList::iterator visQueryIt, projQueryIt;
-
-        visQueryIt = queryList[0].begin();
-        projQueryIt = queryList[1].begin();
-
-        
-        for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)
-        {
-                unsigned int visiblePixels = 0;
-                (*visQueryIt)->GetQueryResult(visiblePixels, true);
-        
-                unsigned int projectedPixels = 0;
-
-                if (relativeVisibility)
-                {
-                        (*projQueryIt)->GetQueryResult(projectedPixels, true);
-                
-                        ++projQueryIt;
-                }
-
-                ++visQueryIt;
-                
-                // node with visibilty 0 in queue (e.g., if node is intersected by near plane)
-                if (visiblePixels > 0)
-                {
-                        visibleNodes->push_back(GtpVisibility::NodeInfo(*nodeIt, visiblePixels, projectedPixels));
-                }
-        }
-
-        //---- queries for geometry
-        geometryIt_end = geometryList.end();
-        
-        for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt)
-        {
-                unsigned int visiblePixels = 0;
-                (*visQueryIt)->GetQueryResult(visiblePixels, true);
-                
-                unsigned int projectedPixels = 0;
-
-                if (relativeVisibility)
-                {
-                        (*projQueryIt)->GetQueryResult(projectedPixels, true);
-
-                        ++projQueryIt;
-                }
-
-                ++visQueryIt;
-
-                // approximate depth ordering during rendering => 
-                // geometry maybe occluded
-                if (visiblePixels > 0)
-                {                        
-                        visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt, visiblePixels, 
-                                projectedPixels));
-                }
-        }
-
-}
-//-----------------------------------------------------------------------
-inline bool nodeinfo_eq(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2) 
-{ 
-        return info1.GetNode() == info2.GetNode(); 
-}
-//-----------------------------------------------------------------------
-inline bool meshinfo_eq(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2) 
-{ 
-        return info1.GetMesh() == info2.GetMesh(); 
-}
-//-----------------------------------------------------------------------
-inline bool nodeinfo_lower(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2) 
-{ 
-        return info1.GetNode() < info2.GetNode(); 
-}
-//-----------------------------------------------------------------------
-inline bool meshinfo_lower(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2) 
-{ 
-        return info1.GetMesh() < info2.GetMesh(); 
 }
 //-----------------------------------------------------------------------
@@ -222 +55 @@
                 LogManager::getSingleton().logMessage(d.str());
 
+                // prevent from initialising geometry / node array again
+                if (i > 0)
+                        mWasInitialised = true;
+
                 ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility);
                 
@@ -235 +72 @@
         // reset camera
         mViewport->setCamera(savedCam);
-
-        // --- remove duplicates (duplicates occur if an object is on the edge of the viewport)
-
-        // before duplicates can be deleted we have to add up their visibility
-
-        // --- visible nodes
-        sort(visibleNodes->begin(), visibleNodes->end(), nodeinfo_lower);
-        InfoContainer<GtpVisibility::NodeInfo>::iterator visibleNodesIt,
-                visibleNodesIt_end = visibleNodes->end();
-        
-        GtpVisibility::NodeInfo *nodeInfo = NULL;
-
-        for (visibleNodesIt = visibleNodes->begin(); visibleNodesIt != visibleNodesIt_end; 
-                ++visibleNodesIt)
-        {
-                if (!nodeInfo || (nodeInfo->GetNode() != (*visibleNodesIt).GetNode()))
-                {
-                        nodeInfo = &(*visibleNodesIt);
-                }
-                else // add visibility
-                {                       
-                        nodeInfo->AddVisibility(*visibleNodesIt);
-                }
-
-        }
-        
-        // physically delete duplicates
-        visibleNodes->erase( std::unique(visibleNodes->begin(), 
-                visibleNodes->end(), nodeinfo_eq), visibleNodes->end());
-
-        // --- visible geometry
-        sort(visibleGeometry->begin(), visibleGeometry->end(), meshinfo_lower);
-        InfoContainer<GtpVisibility::MeshInfo>::iterator visibleGeomIt,
-                visibleGeomIt_end = visibleGeometry->end();
-
-        GtpVisibility::MeshInfo *geomInfo = NULL;
-
-        int i=0;
-        for (visibleGeomIt = visibleGeometry->begin(); visibleGeomIt != visibleGeomIt_end; 
-                ++visibleGeomIt)
-        {
-                if (!geomInfo || (geomInfo->GetMesh() != (*visibleGeomIt).GetMesh()))
-                {
-                        geomInfo = &(*visibleGeomIt);
-                }
-                else // info points to same mesh, just add visibility
-                {
-                        geomInfo->AddVisibility(*visibleGeomIt);
-                }
-        }
-
-        // physically delete duplicates
-        visibleGeometry->erase(std::unique(visibleGeometry->begin(), visibleGeometry->end(), 
-                meshinfo_eq), visibleGeometry->end());
-        
 }
 //-----------------------------------------------------------------------

trunk/VUT/Ogre/src/OgreSceneNodeHierarchyInterface.cpp

@@ -147 +147 @@
                 MovableObject *movable = objIt.getNext();
                 
-                // we are interested only in the entities, i.e., intances of geometry
+                // we are interested only in the entities, i.e., instances of geometry
                 if (movable->getMovableType() == "Entity")
                 {
@@ -156 +156 @@
     }
 }
+//-----------------------------------------------------------------------
+void SceneNodeHierarchyInterface::SetNodeId(GtpVisibility::HierarchyNode *node, int id)
+{
+        static_cast<SceneNode *>(node)->setId(id);
+}
+//-----------------------------------------------------------------------
+int SceneNodeHierarchyInterface::GetNodeId(GtpVisibility::HierarchyNode *node)
+{
+        return static_cast<SceneNode *>(node)->getId();
+}
 } // namespace Ogre     

trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

@@ -259 +259 @@
         mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
 
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-    mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes);
-#endif
         OctreeSceneManager::_updateSceneGraph(cam);
 }

trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

@@ -24 +24 @@
 mUseDepthPass(false),
 mRenderDepthPass(false),
-//mUseItemBuffer(false),
-mUseItemBuffer(true),
+mUseItemBuffer(false),
+//mUseItemBuffer(true),
 mRenderItemBuffer(false),
-mCurrentEntityId(0),
+mCurrentEntityId(1),
 mEnableDepthWrite(true),
 mSkipTransparents(false),
@@ -327 +327 @@
                 
         // set the new render level index afterwards => new level in the next frame 
-        int levelIdx = (TerrainRenderable::getCurrentRenderLevelIndex() + 1) % 10;
+        int levelIdx = TerrainRenderable::getCurrentRenderLevelIndex() + 1;
         TerrainRenderable::setCurrentRenderLevelIndex(levelIdx);
 
@@ -343 +343 @@
         mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
 
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-    mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes);
-#endif
         TerrainSceneManager::_updateSceneGraph(cam);
 }
@@ -567 +564 @@
         int col[4];
         
+        // -- create color code out of object id
         col[0] = (rend->getId() >> 16) & 255;
         col[1] = (rend->getId() >> 8) & 255;
@@ -599 +597 @@
 
         Pass *usedPass = setPass(mItemBufferPass); 
-        //Pass *usedPass = setPass(pass);
-        
-        if (rend->getId() > 0)
+        
+        /*if (rend->getId() > 0)
         {
                 std::stringstream d; d << "item buffer id: " << rend->getId() << ", col: " << col[0] <<
                         " " << col[1] << " " << col[2] << " " << col[3];
                 LogManager::getSingleton().logMessage(d.str());
-        }
+        }*/
 
         // Render a single object, this will set up auto params if required
         renderSingleObject(rend, usedPass, false, &nullLightList);
-
-        // reset colour
-        //mDestRenderSystem->setColour(255, 255, 255, 255);
 }
 //-----------------------------------------------------------------------
@@ -630 +624 @@
         }
 
+        // increase counter of entity id values
         ++ mCurrentEntityId;