Changeset 11080

Timestamp:

Jan 19, 2016, 11:27:40 PM (9 years ago)

Author:

landauf

Message:

merged shaders back to trunk (pps project from HS 2012)

Location:

code/trunk

Files:

• . (modified) (1 prop)
• data/levels/shadertest.oxw (copied) (copied from code/branches/shaders_merge/data/levels/shadertest.oxw)
• src/libraries/tools/Mesh.cc (modified) (2 diffs)
• src/libraries/tools/Mesh.h (modified) (1 diff)
• src/orxonox/CMakeLists.txt (modified) (1 diff)
• src/orxonox/OrxonoxPrereqs.h (modified) (1 diff)
• src/orxonox/RenderQueueListener.cc (copied) (copied from code/branches/shaders_merge/src/orxonox/RenderQueueListener.cc)
• src/orxonox/RenderQueueListener.h (copied) (copied from code/branches/shaders_merge/src/orxonox/RenderQueueListener.h)
• src/orxonox/Scene.cc (modified) (5 diffs)
• src/orxonox/Scene.h (modified) (4 diffs)
• src/orxonox/graphics/Billboard.cc (modified) (1 diff)
• src/orxonox/graphics/Billboard.h (modified) (1 diff)
• src/orxonox/graphics/CMakeLists.txt (modified) (1 diff)
• src/orxonox/graphics/LensFlare.cc (copied) (copied from code/branches/shaders_merge/src/orxonox/graphics/LensFlare.cc)
• src/orxonox/graphics/LensFlare.h (copied) (copied from code/branches/shaders_merge/src/orxonox/graphics/LensFlare.h)
• src/orxonox/graphics/Model.cc (modified) (5 diffs)
• src/orxonox/graphics/Model.h (modified) (6 diffs)

code/trunk/src/libraries/tools/Mesh.cc

@@ -33 +33 @@
 #include <string>
 #include <OgreEntity.h>
+#include <OgreSubEntity.h>
 #include <OgreSceneManager.h>
 
@@ -93 +94 @@
     }
 
+    void Mesh::setMaterial(const std::string& name)
+    {
+        if (this->entity_)
+            this->entity_->setMaterialName(name);
+    }
+
+    const std::string& Mesh::getMaterial() const
+    {
+        if (this->entity_)
+        {
+            if(this->entity_->getSubEntity(0))
+                return this->entity_->getSubEntity(0)->getMaterialName(); //return the Material of the first SubEntity, should be enough for now
+            else
+                return BLANKSTRING;
+        }
+        else
+            return BLANKSTRING;
+    }
+
     void Mesh::setVisible(bool bVisible)
     {

code/trunk/src/libraries/tools/Mesh.h

@@ -48 +48 @@
             const std::string& getName() const;
 
+            void setMaterial(const std::string& name);
+            const std::string& getMaterial() const;
+
             void setVisible(bool bVisible);
             bool isVisible() const;

code/trunk/src/orxonox/CMakeLists.txt

@@ -36 +36 @@
   CameraManager.cc
   Scene.cc
+  RenderQueueListener.cc
 END_BUILD_UNIT
 )

code/trunk/src/orxonox/OrxonoxPrereqs.h

@@ -75 +75 @@
     class PlayerManager;
     class Radar;
+    class RenderQueueListener;
     class Scene;
     class GSLevelMemento;

code/trunk/src/orxonox/Scene.cc

@@ -27 +27 @@
  *
  */
+
+/**
+@file Scene.cc
+@brief Implementation of Scene Class
+*/
+
 
 #include "Scene.h"
@@ -51 +57 @@
 #include "worldentities/WorldEntity.h"
 #include "Level.h"
+#include "RenderQueueListener.h"
 
 namespace orxonox
 {
     RegisterClass(Scene);
-
+    
+    /**
+    @brief 
+        Constructor, it sets common standard paramters for a scene depending on whether it will be rendered or not.
+        It also makes sure we user our own render queue listener for rendering instead of the standard listener provided by Ogre
+    */
     SetConsoleCommand("Scene", "debugDrawPhysics", &Scene::consoleCommand_debugDrawPhysics).addShortcut().defaultValue(1, true).defaultValue(2, 0.5f);
 
@@ -75 +87 @@
             this->sceneManager_ = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC);
             this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
+            this->renderQueueListener_ = new RenderQueueListener();
+            this->sceneManager_->addRenderQueueListener(this->renderQueueListener_);//add our own renderQueueListener
 
             this->radar_ = new Radar();
@@ -84 +98 @@
             this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
 
+            this->renderQueueListener_ = nullptr;
             this->radar_ = nullptr;
         }
@@ -111 +126 @@
 
             if (GameMode::showsGraphics())
+            {
+                this->sceneManager_->removeRenderQueueListener(this->renderQueueListener_);
+                delete this->renderQueueListener_;
                 Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
+            }
             else
                 delete this->sceneManager_;

code/trunk/src/orxonox/Scene.h

@@ -28 +28 @@
  */
 
+/**
+@file Scene.h
+@brief Definition of Scene Class
+*/
+
 #ifndef _Scene_H__
 #define _Scene_H__
@@ -49 +54 @@
     {
         public:
+            /**
+            @brief 
+                This class holds a Scene which is a collection of all kinds of objects to be rendered in the same space,
+                with the same physics and the same light properties. Objects can be anything from a light source, over non physical objects
+                like Billboards to just plain Models with an attached Mesh
+            */
             Scene(Context* context);
             virtual ~Scene();
@@ -59 +70 @@
             inline Ogre::SceneNode* getRootSceneNode() const
                 { return this->rootSceneNode_; }
+            inline RenderQueueListener* getRenderQueueListener() const
+                { return this->renderQueueListener_; }
 
             void setSkybox(const std::string& skybox);
@@ -95 +108 @@
                 { this->setShadow(this->bShadows_); }
 
-            Ogre::SceneManager*      sceneManager_;
-            Ogre::SceneNode*         rootSceneNode_;
+            Ogre::SceneManager*      sceneManager_; //!< This is a pointer to the Ogre SceneManager we're using to render the Scene
+            Ogre::SceneNode*         rootSceneNode_; //!< This is a pointer to the root node of the Scene tree
+            RenderQueueListener*     renderQueueListener_; //!< this is a pointer to the RenderQueueListener we're using for this Scene
 
-            std::string              skybox_;
-            ColourValue              ambientLight_;
-            std::list<BaseObject*>   objects_;
-            bool                     bShadows_;
-            float                    soundReferenceDistance_;
-            Radar*                   radar_;
+            std::string              skybox_; //!< This string holds information about the skybox we're using
+            ColourValue              ambientLight_; //!< This variable holds the color value for the ambient light in our scene, usually black in space
+            std::list<BaseObject*>   objects_; //!< This list holds all the objects created in our scene
+            bool                     bShadows_; //!< Do we want shadows in our scene?
+            float                    soundReferenceDistance_; //!< This holds a reference distance, which represents the distance between our scene and the listener
+            Radar*                   radar_; //!< This is a pointer to a Radar object assigned with this scene
 
 

code/trunk/src/orxonox/graphics/Billboard.cc

@@ -171 +171 @@
         }
     }
+    
+    void Billboard::setRenderQueueGroup(unsigned char groupID)
+    {
+        Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
+        if( bSet != nullptr )
+        {
+            bSet->setRenderQueueGroup(groupID);
+        }
+    }
+    
+    void Billboard::disableFrustumCulling()
+    {
+        Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
+        if( bSet != nullptr )
+        {
+            bSet->setBounds(Ogre::AxisAlignedBox(Ogre::AxisAlignedBox::EXTENT_INFINITE),0);
+        }
+    }
 }

code/trunk/src/orxonox/graphics/Billboard.h

@@ -81 +81 @@
             
             void setDefaultDimensions(float width, float height);
+            
+            void setRenderQueueGroup(unsigned char groupID);
+            
+            void disableFrustumCulling();
 
 

code/trunk/src/orxonox/graphics/CMakeLists.txt

@@ -13 +13 @@
   Backlight.cc
   Camera.cc
+  LensFlare.cc
   Light.cc
 END_BUILD_UNIT

code/trunk/src/orxonox/graphics/Model.cc

@@ -37 +37 @@
 #include "core/XMLPort.h"
 #include "Scene.h"
+#include "RenderQueueListener.h"
 #include "graphics/MeshLodInformation.h"
 #include "Level.h"
@@ -45 +46 @@
 
     Model::Model(Context* context) :
-        StaticEntity(context), bCastShadows_(true), lodLevel_(5), bLodEnabled_(true), numLodLevels_(10), lodReductionRate_(.15f)
+        StaticEntity(context), bCastShadows_(true), renderQueueGroup_(RENDER_QUEUE_MAIN), lodLevel_(5), bLodEnabled_(true), numLodLevels_(10), lodReductionRate_(.15f)
     {
         RegisterObject(Model);
@@ -72 +73 @@
 
         XMLPortParam(Model, "mesh", setMeshSource, getMeshSource, xmlelement, mode);
+        XMLPortParam(Model, "renderQueueGroup", setRenderQueueGroup, getRenderQueueGroup, xmlelement, mode);
+        XMLPortParam(Model, "material", setMaterial, getMaterial, xmlelement, mode);
         XMLPortParam(Model, "shadow", setCastShadows, getCastShadows, xmlelement, mode).defaultValues(true);
     }
+    
+    /**
+    @brief
+        This function turns a string from XML Port into a usable ID for the rendering system
+        It defaults to the main queue if the group isn't recognized.
+        
+    @param renderQueueGroup
+        This is a string representing the render queue group. Accepted values:
+        'main', 'stencil glow', 'stencil object'
+    */
+    const unsigned int Model::getRenderQueueGroupID(const std::string& renderQueueGroup) const
+    {
+        if(renderQueueGroup.compare("stencil glow")==0)
+        {
+            return RENDER_QUEUE_STENCIL_GLOW;
+        }
+        if(renderQueueGroup.compare("stencil object")==0)
+        {
+            return RENDER_QUEUE_STENCIL_OBJECTS;
+        }
+        return RENDER_QUEUE_MAIN;
+    }
 
     void Model::registerVariables()
     {
         registerVariable(this->meshSrc_,    VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedMesh));
+        registerVariable(this->renderQueueGroup_,    VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedRenderQueueGroup));
+        registerVariable(this->materialName_,    VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedMaterial));
         registerVariable(this->bCastShadows_, VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedShadows));
     }
@@ -104 +131 @@
                 this->attachOgreObject(this->mesh_.getEntity());
                 this->mesh_.getEntity()->setCastShadows(this->bCastShadows_);
+                this->mesh_.getEntity()->setRenderQueueGroup(this->renderQueueGroup_);
                 this->mesh_.setVisible(this->isVisible());
 
@@ -110 +138 @@
             }
         }
+    }
+
+    void Model::changedRenderQueueGroup()
+    {
+        if (GameMode::showsGraphics())
+        {
+            if (this->mesh_.getEntity())
+            {
+                this->mesh_.getEntity()->setRenderQueueGroup(this->renderQueueGroup_);
+            }
+        }
+    }
+
+    void Model::changedMaterial()
+    {
+        this->mesh_.setMaterial(this->materialName_);
     }
 

code/trunk/src/orxonox/graphics/Model.h

@@ -27 +27 @@
  */
 
+/**
+  @file Model.h
+  @brief Definition of Model Class
+*/
+
 #ifndef _Model_H__
 #define _Model_H__
@@ -34 +39 @@
 #include <string>
 #include "tools/Mesh.h"
+#include "RenderQueueListener.h"
 #include "worldentities/StaticEntity.h"
 
@@ -40 +46 @@
     class _OrxonoxExport Model : public StaticEntity
     {
+        /**
+        @brief
+            The class Model stores a Mesh and some additional properties, so you can easily render any Model and apply different effects to it.
+            
+            You can assign any Material to any Mesh to completely change the way it looks, to further add versatility you can also assign the Model
+            to a render queue group, to enable proper rendering of fancy effect like glowing edges around objects with alpha blending.
+        */
         public:
             Model(Context* context);
@@ -58 +71 @@
                 { return this->meshSrc_; }
 
+            inline void setRenderQueueGroup(const std::string& renderQueueGroup)
+                { this->renderQueueGroup_ = getRenderQueueGroupID(renderQueueGroup); this->changedRenderQueueGroup(); }
+            inline const int getRenderQueueGroup() const
+                { return this->renderQueueGroup_; }
+
             inline void setCastShadows(bool bCastShadows)
                 { this->bCastShadows_ = bCastShadows; this->changedShadows(); }
@@ -63 +81 @@
                 { return this->bCastShadows_; }
 
+            inline void setMaterial(const std::string& materialname)
+                { this->materialName_ = materialname; this->changedMaterial(); }
+            inline const std::string& getMaterial() const
+                { return this->materialName_; }
+
         protected:
+            /**
+            @brief
+                This function turns a string from XML Port into a usable ID for the rendering system
+                It defaults to the main queue if the group isn't recognized.
+                
+            @param renderQueueGroup
+                This is a string representing the render queue group. Accepted values:
+                main, stencil glow, stencil object
+            */
+            const unsigned int getRenderQueueGroupID(const std::string& renderQueueGroup) const;
+
             void registerVariables();
             void changedMesh();
+            void changedRenderQueueGroup();
+            void changedMaterial();
             void changedShadows();
 
@@ -77 +113 @@
             float getBiggestScale(Vector3 scale3d);
 
-            std::string meshSrc_;
-            Mesh mesh_;
-            bool bCastShadows_;
+            std::string meshSrc_; //!< This string stores the path where the mesh is stored
+            Mesh mesh_; //!< This is the mesh object linked to this Object, it stores the data from the mesh file in a usable format for the Ogre engine
+            bool bCastShadows_; //!< This value determines whether a Model is casting a shadow or not, turn it off to save performance, when not needed
+            unsigned int renderQueueGroup_; //!< This variable stores which render queue group this object is assigned to
+            std::string materialName_; //!< This string stores the name of the material to be applied to the mesh/model
 
             //LoD
-            bool bGlobalEnableLod_;
-            float lodLevel_;
-            bool bLodEnabled_;
-            unsigned int numLodLevels_;
-            float lodReductionRate_;
+            bool bGlobalEnableLod_; //!< Has LoD been turned on in the graphics configuration?
+            float lodLevel_; //!< Standard LoD Level
+            bool bLodEnabled_; //!< Is LoD to be used on this model?
+            unsigned int numLodLevels_; //!< How many LoD does this model feature
+            float lodReductionRate_; //!< How fast should be switched to lower LoDs
 
     };