OgreRenderable.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://ogre.sourceforge.net/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef __Renderable_H__
#define __Renderable_H__

#include "OgrePrerequisites.h"
#include "OgreCommon.h"

#include "OgreRenderOperation.h"
#include "OgreMatrix4.h"
#include "OgreMaterial.h"
#include "OgrePlane.h"
#include "OgreGpuProgram.h"
#include "OgreVector4.h"
#include "OgreException.h"

namespace Ogre {

    class _OgreExport Renderable
    {
    public:
        Renderable() : mRenderDetailOverrideable(true) {}
        virtual ~Renderable() { }
        virtual const MaterialPtr& getMaterial(void) const = 0;
        virtual Technique* getTechnique(void) const { return getMaterial()->getBestTechnique(); }
        virtual void getRenderOperation(RenderOperation& op) = 0;
        virtual void getWorldTransforms(Matrix4* xform) const = 0;
        virtual const Quaternion& getWorldOrientation(void) const = 0;
        virtual const Vector3& getWorldPosition(void) const = 0;

        virtual unsigned short getNumWorldTransforms(void) const { return 1; }

        virtual bool useIdentityProjection(void) const { return false; }

        virtual bool useIdentityView(void) const { return false; }

        virtual Real getSquaredViewDepth(const Camera* cam) const = 0;

        virtual SceneDetailLevel getRenderDetail() const {return SDL_SOLID;} 

        virtual bool getNormaliseNormals(void) const { return false; }

        virtual const LightList& getLights(void) const = 0;

        virtual const PlaneList& getClipPlanes() const { return msDummyPlaneList; };

        virtual bool getCastsShadows(void) const { return false; }

        void setCustomParameter(size_t index, const Vector4& value) 
        {
            mCustomParameters[index] = value;
        }

        const Vector4& getCustomParameter(size_t index) const
        {
            CustomParameterMap::const_iterator i = mCustomParameters.find(index);
            if (i != mCustomParameters.end())
            {
                return i->second;
            }
            else
            {
                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, 
                    "Parameter at the given index was not found.",
                    "Renderable::getCustomParameter");
            }
        }

        virtual void _updateCustomGpuParameter(
            const GpuProgramParameters::AutoConstantEntry& constantEntry,
            GpuProgramParameters* params) const
        {
            CustomParameterMap::const_iterator i = mCustomParameters.find(constantEntry.data);
            if (i != mCustomParameters.end())
            {
                params->setConstant(constantEntry.index, i->second);
            }
        }

        virtual void setRenderDetailOverrideable(bool override)
        {
            mRenderDetailOverrideable = override;
        }

        virtual bool getRenderDetailOverrideable(void) const
        {
            return mRenderDetailOverrideable;
        }


    protected:
        static const PlaneList msDummyPlaneList;
        typedef std::map<size_t, Vector4> CustomParameterMap;
        CustomParameterMap mCustomParameters;
        bool mRenderDetailOverrideable;
    };



}

#endif //__Renderable_H__

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:50 2006