OgreInstanceBatch.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-2013 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __InstanceBatch_H__
#define __InstanceBatch_H__

#include "OgrePrerequisites.h"
#include "OgreRenderOperation.h"
#include "OgreRenderable.h"
#include "OgreMovableObject.h"
#include "OgreMesh.h"
#include "OgreHeaderPrefix.h"

namespace Ogre
{
    class _OgreExport InstanceBatch : public Renderable, public MovableObject
    {
    public:
        typedef vector<InstancedEntity*>::type  InstancedEntityVec;
        typedef vector<Vector4>::type           CustomParamsVec;
    protected:
        RenderOperation     mRenderOperation;
        size_t              mInstancesPerBatch;

        InstanceManager     *mCreator;

        MaterialPtr         mMaterial;

        MeshPtr             mMeshReference;
        Mesh::IndexMap const *mIndexToBoneMap;

        //InstancedEntities are all allocated at build time and kept as "unused"
        //when they're requested, they're removed from there when requested,
        //and put back again when they're no longer needed
        //Note each InstancedEntity has a unique ID ranging from [0; mInstancesPerBatch)
        InstancedEntityVec  mInstancedEntities;
        InstancedEntityVec  mUnusedEntities;

        CustomParamsVec     mCustomParams;

        AxisAlignedBox      mFullBoundingBox;
        Real                mBoundingRadius;
        bool                mBoundsDirty;
        bool                mBoundsUpdated; //Set to false by derived classes that need it
        Camera              *mCurrentCamera;

        unsigned short      mMaterialLodIndex;

        bool                mDirtyAnimation; //Set to false at start of each _updateRenderQueue

        bool                mTechnSupportsSkeletal;

        mutable Real mCachedCameraDist;
        mutable const Camera *mCachedCamera;

        bool mTransformSharingDirty;

        bool mRemoveOwnVertexData;
        bool mRemoveOwnIndexData;

        virtual void setupVertices( const SubMesh* baseSubMesh ) = 0;
        virtual void setupIndices( const SubMesh* baseSubMesh ) = 0;
        virtual void createAllInstancedEntities(void);
        virtual void deleteAllInstancedEntities(void);
        virtual void deleteUnusedInstancedEntities(void);
        virtual InstancedEntity* generateInstancedEntity(size_t num);

        void makeMatrixCameraRelative3x4( float *mat3x4, size_t numFloats );

        virtual bool checkSubMeshCompatibility( const SubMesh* baseSubMesh );

        void updateVisibility(void);

        void defragmentBatchNoCull( InstancedEntityVec &usedEntities, CustomParamsVec &usedParams );

        void defragmentBatchDoCull( InstancedEntityVec &usedEntities, CustomParamsVec &usedParams );

    public:
        InstanceBatch( InstanceManager *creator, MeshPtr &meshReference, const MaterialPtr &material,
                       size_t instancesPerBatch, const Mesh::IndexMap *indexToBoneMap,
                       const String &batchName );
        virtual ~InstanceBatch();

        MeshPtr& _getMeshRef() { return mMeshReference; }

        void _setInstancesPerBatch( size_t instancesPerBatch );

        const Mesh::IndexMap* _getIndexToBoneMap() const { return mIndexToBoneMap; }

        bool _supportsSkeletalAnimation() const { return mTechnSupportsSkeletal; }

        void _updateBounds(void);

        virtual size_t calculateMaxNumInstances( const SubMesh *baseSubMesh, uint16 flags ) const = 0;

        virtual RenderOperation build( const SubMesh* baseSubMesh );

        virtual void buildFrom( const SubMesh *baseSubMesh, const RenderOperation &renderOperation );

        const Ogre::MeshPtr& _getMeshReference(void) const { return mMeshReference; }

        bool isBatchFull(void) const { return mUnusedEntities.empty(); }

        bool isBatchUnused(void) const { return mUnusedEntities.size() == mInstancedEntities.size(); }

        void getInstancedEntitiesInUse( InstancedEntityVec &outEntities, CustomParamsVec &outParams );

        void _defragmentBatch( bool optimizeCulling, InstancedEntityVec &usedEntities,
                                CustomParamsVec &usedParams );

        void _defragmentBatchDiscard(void);

        virtual void _boundsDirty(void);

        virtual void setStaticAndUpdate( bool bStatic )     {}

        virtual bool isStatic() const                       { return false; }

        InstancedEntity* createInstancedEntity();

        void removeInstancedEntity( InstancedEntity *instancedEntity );

        virtual bool useBoneWorldMatrices() const { return true; }

        void _markTransformSharingDirty() { mTransformSharingDirty = true; }

        void _setCustomParam( InstancedEntity *instancedEntity, unsigned char idx, const Vector4 &newParam );

        const Vector4& _getCustomParam( InstancedEntity *instancedEntity, unsigned char idx );

        //Renderable overloads
        const MaterialPtr& getMaterial(void) const      { return mMaterial; }
        void getRenderOperation( RenderOperation& op )  { op = mRenderOperation; }

        Real getSquaredViewDepth( const Camera* cam ) const;
        const LightList& getLights( void ) const;
        Technique* getTechnique(void) const;

        const String& getMovableType(void) const;
        void _notifyCurrentCamera( Camera* cam );
        const AxisAlignedBox& getBoundingBox(void) const;
        Real getBoundingRadius(void) const;

        virtual void _updateRenderQueue(RenderQueue* queue);
        void visitRenderables( Renderable::Visitor* visitor, bool debugRenderables = false );

        // resolve ambiguity of get/setUserAny due to inheriting from Renderable and MovableObject
        using Renderable::getUserAny;
        using Renderable::setUserAny;
    };
} // namespace Ogre

#include "OgreHeaderSuffix.h"

#endif // __InstanceBatch_H__