OgrePatchSurface.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 __PatchSurface_H__
#define __PatchSurface_H__

#include "OgrePrerequisites.h"

#include "OgreVector3.h"
#include "OgreString.h"
#include "OgreRenderOperation.h"
#include "OgreAxisAlignedBox.h"

namespace Ogre {

    class _OgreExport PatchSurface
    {
    public:
        PatchSurface();
        ~PatchSurface();

        enum PatchSurfaceType
        {
            PST_BEZIER
        };

        enum
        {
            AUTO_LEVEL = -1
        };

        enum VisibleSide {
            VS_FRONT,
            VS_BACK,
            VS_BOTH
        };
        void defineSurface(void* controlPointBuffer, 
            VertexDeclaration *declaration, size_t width, size_t height,
            PatchSurfaceType pType = PST_BEZIER, 
            size_t uMaxSubdivisionLevel = AUTO_LEVEL, size_t vMaxSubdivisionLevel = AUTO_LEVEL,
            VisibleSide visibleSide = VS_FRONT);

        size_t getRequiredVertexCount(void) const;
        size_t getRequiredIndexCount(void) const;

        size_t getCurrentIndexCount(void) const;
        size_t getIndexOffset(void) const { return mIndexOffset; }
        size_t getVertexOffset(void) const { return mVertexOffset; }


        const AxisAlignedBox& getBounds(void) const;
        Real getBoundingSphereRadius(void) const;
        void build(HardwareVertexBufferSharedPtr destVertexBuffer, size_t vertexStart,
            HardwareIndexBufferSharedPtr destIndexBuffer, size_t indexStart);

        void setSubdivisionFactor(Real factor);

        Real getSubdivisionFactor(void) const;

        void* getControlPointBuffer(void) const
        {
            return mControlPointBuffer;
        }
        void notifyControlPointBufferDeallocated(void) { 
            mControlPointBuffer = 0;
        }
    protected:
        VertexDeclaration* mDeclaration;
        void* mControlPointBuffer;
        PatchSurfaceType mType;
        size_t mCtlWidth;
        size_t mCtlHeight;
        size_t mCtlCount;
        size_t mULevel;
        size_t mVLevel;
        size_t mMaxULevel;
        size_t mMaxVLevel;
        size_t mMeshWidth;
        size_t mMeshHeight;
        VisibleSide mVSide;

        Real mSubdivisionFactor;

        std::vector<Vector3> mVecCtlPoints;

        size_t findLevel( Vector3& a, Vector3& b, Vector3& c);

        void distributeControlPoints(void* lockedBuffer);
        void subdivideCurve(void* lockedBuffer, size_t startIdx, size_t stepSize, size_t numSteps, size_t iterations);
        void interpolateVertexData(void* lockedBuffer, size_t leftIndex, size_t rightIndex, size_t destIndex);
        void makeTriangles(void);

        size_t getAutoULevel(bool forMax = false);
        size_t getAutoVLevel(bool forMax = false);

        HardwareVertexBufferSharedPtr mVertexBuffer;
        HardwareIndexBufferSharedPtr mIndexBuffer;
        size_t mVertexOffset;
        size_t mIndexOffset;
        size_t mRequiredVertexCount;
        size_t mRequiredIndexCount;
        size_t mCurrIndexCount;

        AxisAlignedBox mAABB;
        Real mBoundingSphere;



    };


} // namespace

#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:46 2006