OgreManualObject.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://www.ogre3d.org/

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 __OgreManualObject_H__
#define __OgreManualObject_H__

#include "OgrePrerequisites.h"
#include "OgreMovableObject.h"
#include "OgreRenderable.h"
#include "OgreResourceGroupManager.h"


namespace Ogre
{
    class _OgreExport ManualObject : public MovableObject
    {
    public:
        ManualObject(const String& name);
        virtual ~ManualObject();

        virtual void clear(void);
        
        virtual void estimateVertexCount(size_t vcount);

        virtual void estimateIndexCount(size_t icount);

        virtual void begin(const String& materialName, 
            RenderOperation::OperationType opType = RenderOperation::OT_TRIANGLE_LIST);
        virtual void position(const Vector3& pos);
        virtual void position(Real x, Real y, Real z);

        virtual void normal(const Vector3& norm);
        virtual void normal(Real x, Real y, Real z);

        virtual void textureCoord(Real u);
        virtual void textureCoord(Real u, Real v);
        virtual void textureCoord(Real u, Real v, Real w);
        virtual void textureCoord(const Vector2& uv);
        virtual void textureCoord(const Vector3& uvw);

        virtual void colour(const ColourValue& col);
        virtual void colour(Real r, Real g, Real b, Real a = 1.0f);

        virtual void index(uint16 idx);
        virtual void triangle(uint16 i1, uint16 i2, uint16 i3);
        virtual void quad(uint16 i1, uint16 i2, uint16 i3, uint16 i4);

        virtual void end(void);

        virtual MeshPtr convertToMesh(const String& meshName, 
            const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

        // MovableObject overrides

        const String& getMovableType(void) const;
        const AxisAlignedBox& getBoundingBox(void) const;
        Real getBoundingRadius(void) const;
        void _updateRenderQueue(RenderQueue* queue);
        EdgeData* getEdgeList(void);
        ShadowRenderableListIterator getShadowVolumeRenderableIterator(
            ShadowTechnique shadowTechnique, const Light* light, 
            HardwareIndexBufferSharedPtr* indexBuffer, 
            bool extrudeVertices, Real extrusionDist, unsigned long flags = 0);


        class _OgreExport ManualObjectSection : public Renderable
        {
        protected:
            ManualObject* mParent;
            String mMaterialName;
            mutable MaterialPtr mMaterial;
            RenderOperation mRenderOperation;
            
        public:
            ManualObjectSection(ManualObject* parent, const String& materialName,
                RenderOperation::OperationType opType);
            virtual ~ManualObjectSection();
            
            RenderOperation* getRenderOperation(void);
            const String& getMaterialName(void) const { return mMaterialName; }
            
            // Renderable overrides
            const MaterialPtr& getMaterial(void) const;
            void getRenderOperation(RenderOperation& op);
            void getWorldTransforms(Matrix4* xform) const;
            const Quaternion& getWorldOrientation(void) const;
            const Vector3& getWorldPosition(void) const;
            Real getSquaredViewDepth(const Ogre::Camera *) const;
            const LightList &getLights(void) const;
                    
        };
        class _OgreExport ManualObjectSectionShadowRenderable : public ShadowRenderable
        {
        protected:
            ManualObject* mParent;
            // Shared link to position buffer
            HardwareVertexBufferSharedPtr mPositionBuffer;
            // Shared link to w-coord buffer (optional)
            HardwareVertexBufferSharedPtr mWBuffer;

        public:
            ManualObjectSectionShadowRenderable(ManualObject* parent, 
                HardwareIndexBufferSharedPtr* indexBuffer, const VertexData* vertexData, 
                bool createSeparateLightCap, bool isLightCap = false);
            ~ManualObjectSectionShadowRenderable();
            void getWorldTransforms(Matrix4* xform) const;
            const Quaternion& getWorldOrientation(void) const;
            const Vector3& getWorldPosition(void) const;
            HardwareVertexBufferSharedPtr getPositionBuffer(void) { return mPositionBuffer; }
            HardwareVertexBufferSharedPtr getWBuffer(void) { return mWBuffer; }

        };

        typedef std::vector<ManualObjectSection*> SectionList;
        
    protected:
        SectionList mSectionList;
        ManualObjectSection* mCurrentSection;
        struct TempVertex
        {
            Vector3 position;
            Vector3 normal;
            Vector3 texCoord[OGRE_MAX_TEXTURE_COORD_SETS];
            ushort texCoordDims[OGRE_MAX_TEXTURE_COORD_SETS];
            ColourValue colour;
        };
        TempVertex mTempVertex;
        bool mFirstVertex;
        bool mTempVertexPending;
        char* mTempVertexBuffer;
        size_t mTempVertexSize;
        uint16* mTempIndexBuffer;
        size_t mTempIndexSize;
        size_t mDeclSize;
        ushort mTexCoordIndex;
        AxisAlignedBox mAABB;
        Real mRadius;
        bool mAnyIndexed;
        EdgeData* mEdgeList;
        ShadowRenderableList mShadowRenderables;


        virtual void resetTempAreas(void);
        virtual void resizeTempVertexBufferIfNeeded(size_t numVerts);
        virtual void resizeTempIndexBufferIfNeeded(size_t numInds);

        virtual void copyTempVertexToBuffer(void);

    };


    class _OgreExport ManualObjectFactory : public MovableObjectFactory
    {
    protected:
        MovableObject* createInstanceImpl( const String& name, const NameValuePairList* params);
    public:
        ManualObjectFactory() {}
        ~ManualObjectFactory() {}

        static String FACTORY_TYPE_NAME;

        const String& getType(void) const;
        void destroyInstance( MovableObject* obj);  

    };
}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:43 2006