Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 11080


Ignore:
Timestamp:
Jan 19, 2016, 11:27:40 PM (4 years ago)
Author:
landauf
Message:

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

Location:
code/trunk
Files:
12 edited
5 copied

Legend:

Unmodified
Added
Removed
  • code/trunk

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

    r11071 r11080  
    3333#include <string>
    3434#include <OgreEntity.h>
     35#include <OgreSubEntity.h>
    3536#include <OgreSceneManager.h>
    3637
     
    9394    }
    9495
     96    void Mesh::setMaterial(const std::string& name)
     97    {
     98        if (this->entity_)
     99            this->entity_->setMaterialName(name);
     100    }
     101
     102    const std::string& Mesh::getMaterial() const
     103    {
     104        if (this->entity_)
     105        {
     106            if(this->entity_->getSubEntity(0))
     107                return this->entity_->getSubEntity(0)->getMaterialName(); //return the Material of the first SubEntity, should be enough for now
     108            else
     109                return BLANKSTRING;
     110        }
     111        else
     112            return BLANKSTRING;
     113    }
     114
    95115    void Mesh::setVisible(bool bVisible)
    96116    {
  • code/trunk/src/libraries/tools/Mesh.h

    r5781 r11080  
    4848            const std::string& getName() const;
    4949
     50            void setMaterial(const std::string& name);
     51            const std::string& getMaterial() const;
     52
    5053            void setVisible(bool bVisible);
    5154            bool isVisible() const;
  • code/trunk/src/orxonox/CMakeLists.txt

    r10624 r11080  
    3636  CameraManager.cc
    3737  Scene.cc
     38  RenderQueueListener.cc
    3839END_BUILD_UNIT
    3940)
  • code/trunk/src/orxonox/OrxonoxPrereqs.h

    r11052 r11080  
    7575    class PlayerManager;
    7676    class Radar;
     77    class RenderQueueListener;
    7778    class Scene;
    7879    class GSLevelMemento;
  • code/trunk/src/orxonox/Scene.cc

    r11071 r11080  
    2727 *
    2828 */
     29
     30/**
     31@file Scene.cc
     32@brief Implementation of Scene Class
     33*/
     34
    2935
    3036#include "Scene.h"
     
    5157#include "worldentities/WorldEntity.h"
    5258#include "Level.h"
     59#include "RenderQueueListener.h"
    5360
    5461namespace orxonox
    5562{
    5663    RegisterClass(Scene);
    57 
     64   
     65    /**
     66    @brief
     67        Constructor, it sets common standard paramters for a scene depending on whether it will be rendered or not.
     68        It also makes sure we user our own render queue listener for rendering instead of the standard listener provided by Ogre
     69    */
    5870    SetConsoleCommand("Scene", "debugDrawPhysics", &Scene::consoleCommand_debugDrawPhysics).addShortcut().defaultValue(1, true).defaultValue(2, 0.5f);
    5971
     
    7587            this->sceneManager_ = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC);
    7688            this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
     89            this->renderQueueListener_ = new RenderQueueListener();
     90            this->sceneManager_->addRenderQueueListener(this->renderQueueListener_);//add our own renderQueueListener
    7791
    7892            this->radar_ = new Radar();
     
    8498            this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
    8599
     100            this->renderQueueListener_ = nullptr;
    86101            this->radar_ = nullptr;
    87102        }
     
    111126
    112127            if (GameMode::showsGraphics())
     128            {
     129                this->sceneManager_->removeRenderQueueListener(this->renderQueueListener_);
     130                delete this->renderQueueListener_;
    113131                Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
     132            }
    114133            else
    115134                delete this->sceneManager_;
  • code/trunk/src/orxonox/Scene.h

    r11071 r11080  
    2828 */
    2929
     30/**
     31@file Scene.h
     32@brief Definition of Scene Class
     33*/
     34
    3035#ifndef _Scene_H__
    3136#define _Scene_H__
     
    4954    {
    5055        public:
     56            /**
     57            @brief
     58                This class holds a Scene which is a collection of all kinds of objects to be rendered in the same space,
     59                with the same physics and the same light properties. Objects can be anything from a light source, over non physical objects
     60                like Billboards to just plain Models with an attached Mesh
     61            */
    5162            Scene(Context* context);
    5263            virtual ~Scene();
     
    5970            inline Ogre::SceneNode* getRootSceneNode() const
    6071                { return this->rootSceneNode_; }
     72            inline RenderQueueListener* getRenderQueueListener() const
     73                { return this->renderQueueListener_; }
    6174
    6275            void setSkybox(const std::string& skybox);
     
    95108                { this->setShadow(this->bShadows_); }
    96109
    97             Ogre::SceneManager*      sceneManager_;
    98             Ogre::SceneNode*         rootSceneNode_;
     110            Ogre::SceneManager*      sceneManager_; //!< This is a pointer to the Ogre SceneManager we're using to render the Scene
     111            Ogre::SceneNode*         rootSceneNode_; //!< This is a pointer to the root node of the Scene tree
     112            RenderQueueListener*     renderQueueListener_; //!< this is a pointer to the RenderQueueListener we're using for this Scene
    99113
    100             std::string              skybox_;
    101             ColourValue              ambientLight_;
    102             std::list<BaseObject*>   objects_;
    103             bool                     bShadows_;
    104             float                    soundReferenceDistance_;
    105             Radar*                   radar_;
     114            std::string              skybox_; //!< This string holds information about the skybox we're using
     115            ColourValue              ambientLight_; //!< This variable holds the color value for the ambient light in our scene, usually black in space
     116            std::list<BaseObject*>   objects_; //!< This list holds all the objects created in our scene
     117            bool                     bShadows_; //!< Do we want shadows in our scene?
     118            float                    soundReferenceDistance_; //!< This holds a reference distance, which represents the distance between our scene and the listener
     119            Radar*                   radar_; //!< This is a pointer to a Radar object assigned with this scene
    106120
    107121
  • code/trunk/src/orxonox/graphics/Billboard.cc

    r11071 r11080  
    171171        }
    172172    }
     173   
     174    void Billboard::setRenderQueueGroup(unsigned char groupID)
     175    {
     176        Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
     177        if( bSet != nullptr )
     178        {
     179            bSet->setRenderQueueGroup(groupID);
     180        }
     181    }
     182   
     183    void Billboard::disableFrustumCulling()
     184    {
     185        Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
     186        if( bSet != nullptr )
     187        {
     188            bSet->setBounds(Ogre::AxisAlignedBox(Ogre::AxisAlignedBox::EXTENT_INFINITE),0);
     189        }
     190    }
    173191}
  • code/trunk/src/orxonox/graphics/Billboard.h

    r11071 r11080  
    8181           
    8282            void setDefaultDimensions(float width, float height);
     83           
     84            void setRenderQueueGroup(unsigned char groupID);
     85           
     86            void disableFrustumCulling();
    8387
    8488
  • code/trunk/src/orxonox/graphics/CMakeLists.txt

    r8729 r11080  
    1313  Backlight.cc
    1414  Camera.cc
     15  LensFlare.cc
    1516  Light.cc
    1617END_BUILD_UNIT
  • code/trunk/src/orxonox/graphics/Model.cc

    r11071 r11080  
    3737#include "core/XMLPort.h"
    3838#include "Scene.h"
     39#include "RenderQueueListener.h"
    3940#include "graphics/MeshLodInformation.h"
    4041#include "Level.h"
     
    4546
    4647    Model::Model(Context* context) :
    47         StaticEntity(context), bCastShadows_(true), lodLevel_(5), bLodEnabled_(true), numLodLevels_(10), lodReductionRate_(.15f)
     48        StaticEntity(context), bCastShadows_(true), renderQueueGroup_(RENDER_QUEUE_MAIN), lodLevel_(5), bLodEnabled_(true), numLodLevels_(10), lodReductionRate_(.15f)
    4849    {
    4950        RegisterObject(Model);
     
    7273
    7374        XMLPortParam(Model, "mesh", setMeshSource, getMeshSource, xmlelement, mode);
     75        XMLPortParam(Model, "renderQueueGroup", setRenderQueueGroup, getRenderQueueGroup, xmlelement, mode);
     76        XMLPortParam(Model, "material", setMaterial, getMaterial, xmlelement, mode);
    7477        XMLPortParam(Model, "shadow", setCastShadows, getCastShadows, xmlelement, mode).defaultValues(true);
    7578    }
     79   
     80    /**
     81    @brief
     82        This function turns a string from XML Port into a usable ID for the rendering system
     83        It defaults to the main queue if the group isn't recognized.
     84       
     85    @param renderQueueGroup
     86        This is a string representing the render queue group. Accepted values:
     87        'main', 'stencil glow', 'stencil object'
     88    */
     89    const unsigned int Model::getRenderQueueGroupID(const std::string& renderQueueGroup) const
     90    {
     91        if(renderQueueGroup.compare("stencil glow")==0)
     92        {
     93            return RENDER_QUEUE_STENCIL_GLOW;
     94        }
     95        if(renderQueueGroup.compare("stencil object")==0)
     96        {
     97            return RENDER_QUEUE_STENCIL_OBJECTS;
     98        }
     99        return RENDER_QUEUE_MAIN;
     100    }
    76101
    77102    void Model::registerVariables()
    78103    {
    79104        registerVariable(this->meshSrc_,    VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedMesh));
     105        registerVariable(this->renderQueueGroup_,    VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedRenderQueueGroup));
     106        registerVariable(this->materialName_,    VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedMaterial));
    80107        registerVariable(this->bCastShadows_, VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedShadows));
    81108    }
     
    104131                this->attachOgreObject(this->mesh_.getEntity());
    105132                this->mesh_.getEntity()->setCastShadows(this->bCastShadows_);
     133                this->mesh_.getEntity()->setRenderQueueGroup(this->renderQueueGroup_);
    106134                this->mesh_.setVisible(this->isVisible());
    107135
     
    110138            }
    111139        }
     140    }
     141
     142    void Model::changedRenderQueueGroup()
     143    {
     144        if (GameMode::showsGraphics())
     145        {
     146            if (this->mesh_.getEntity())
     147            {
     148                this->mesh_.getEntity()->setRenderQueueGroup(this->renderQueueGroup_);
     149            }
     150        }
     151    }
     152
     153    void Model::changedMaterial()
     154    {
     155        this->mesh_.setMaterial(this->materialName_);
    112156    }
    113157
  • code/trunk/src/orxonox/graphics/Model.h

    r11071 r11080  
    2727 */
    2828
     29/**
     30  @file Model.h
     31  @brief Definition of Model Class
     32*/
     33
    2934#ifndef _Model_H__
    3035#define _Model_H__
     
    3439#include <string>
    3540#include "tools/Mesh.h"
     41#include "RenderQueueListener.h"
    3642#include "worldentities/StaticEntity.h"
    3743
     
    4046    class _OrxonoxExport Model : public StaticEntity
    4147    {
     48        /**
     49        @brief
     50            The class Model stores a Mesh and some additional properties, so you can easily render any Model and apply different effects to it.
     51           
     52            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
     53            to a render queue group, to enable proper rendering of fancy effect like glowing edges around objects with alpha blending.
     54        */
    4255        public:
    4356            Model(Context* context);
     
    5871                { return this->meshSrc_; }
    5972
     73            inline void setRenderQueueGroup(const std::string& renderQueueGroup)
     74                { this->renderQueueGroup_ = getRenderQueueGroupID(renderQueueGroup); this->changedRenderQueueGroup(); }
     75            inline const int getRenderQueueGroup() const
     76                { return this->renderQueueGroup_; }
     77
    6078            inline void setCastShadows(bool bCastShadows)
    6179                { this->bCastShadows_ = bCastShadows; this->changedShadows(); }
     
    6381                { return this->bCastShadows_; }
    6482
     83            inline void setMaterial(const std::string& materialname)
     84                { this->materialName_ = materialname; this->changedMaterial(); }
     85            inline const std::string& getMaterial() const
     86                { return this->materialName_; }
     87
    6588        protected:
     89            /**
     90            @brief
     91                This function turns a string from XML Port into a usable ID for the rendering system
     92                It defaults to the main queue if the group isn't recognized.
     93               
     94            @param renderQueueGroup
     95                This is a string representing the render queue group. Accepted values:
     96                main, stencil glow, stencil object
     97            */
     98            const unsigned int getRenderQueueGroupID(const std::string& renderQueueGroup) const;
     99
    66100            void registerVariables();
    67101            void changedMesh();
     102            void changedRenderQueueGroup();
     103            void changedMaterial();
    68104            void changedShadows();
    69105
     
    77113            float getBiggestScale(Vector3 scale3d);
    78114
    79             std::string meshSrc_;
    80             Mesh mesh_;
    81             bool bCastShadows_;
     115            std::string meshSrc_; //!< This string stores the path where the mesh is stored
     116            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
     117            bool bCastShadows_; //!< This value determines whether a Model is casting a shadow or not, turn it off to save performance, when not needed
     118            unsigned int renderQueueGroup_; //!< This variable stores which render queue group this object is assigned to
     119            std::string materialName_; //!< This string stores the name of the material to be applied to the mesh/model
    82120
    83121            //LoD
    84             bool bGlobalEnableLod_;
    85             float lodLevel_;
    86             bool bLodEnabled_;
    87             unsigned int numLodLevels_;
    88             float lodReductionRate_;
     122            bool bGlobalEnableLod_; //!< Has LoD been turned on in the graphics configuration?
     123            float lodLevel_; //!< Standard LoD Level
     124            bool bLodEnabled_; //!< Is LoD to be used on this model?
     125            unsigned int numLodLevels_; //!< How many LoD does this model feature
     126            float lodReductionRate_; //!< How fast should be switched to lower LoDs
    89127
    90128    };
Note: See TracChangeset for help on using the changeset viewer.