source: downloads/ColladaPlugin/include/OgreColladaDocument.h @ 50

/**
 * This source file is part of OgreColladaPlugin
 * an addon for OGRE (Object-oriented Graphics Rendering Engine)
 * For the latest info, see http://www.ogre3d.org/
 *
 * 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.
 *
 * @author      Philipp Hartl
 * @see         README
 */

#ifndef __COLLADA_DOCUMENT_H__
#define __COLLADA_DOCUMENT_H__

#include "OgreColladaPrerequisites.h"

#include "OgreResource.h"
#include "OgreQuaternion.h"

namespace Ogre
{
        // Forward declaration
        class COLLADADocumentPtr;

        /**
         * class ColladaDocument
         */
        class _OgreColladaExport ColladaDocument : public Resource
        {
        friend class ColladaManager;

        public:
        /** Constructor - use resource manager's create method rather than this.
        */
                ColladaDocument(ResourceManager* creator, const String& name, ResourceHandle handle,
                        const String& group, bool isManual = false, ManualResourceLoader* loader = 0);

                ~ColladaDocument();

        /**
         * Set the active Ogre scene manager that will be used when converting Collada resources to Ogre resource.
         * @param   scenemgr    the scene manager that will be used to display the Collada scene.
        */
        void setSceneManager(SceneManager *scenemgr);

                /** 
                 * import a Collada XML Document (*.dae ascii file) in Ogre
                 * parse the file and build up a scene with Ogre specific functions and elements
                 *
                 * @param       filename        the name of the file to import, it should ends with ".dae"
                 * @param       options         an option string, each option is separated by ";" (not yet implemented)
                 * @return                              true if it succeeds, false otherwise
                 */
                bool doImport(const String &filename, const String &options = "");

                /**
                 * export mesh/scene to Collada XML File
                 * not yet implemented! (maybe it could be combined or used with XMLConverter?)
                 *
                 * @param       none
                 * @return      void
                 */
                void doExport(void);

                ColladaSceneNode                *getScene(void) const { return mScene; }
                ColladaLibraryContainer *getLibrary(void) const { return mLibrary; }
        /** Get the Ogre scenemanager currently being used by the Collada document.
        */
                SceneManager                    *getSceneManager(void) const { return mSceneMgr; }
        /** Get the quaternion rotation that will convert the Collada up orientation to Ogre orientation.
            Orge's up axis is equivalent to Collada Y_UP so the quaternion would be unity in this case. 
        */
        const Quaternion& getUpRotation() const { return mUpRotation; }
        /** Get the up Axis indicator for all the Collada assets in the document.
        */
        UpAxis getUpAxis() const;
        /** corrects the vector axis alignment based on the documents up axis so that the ogre display matches the same
         *  orientation as the COLLADA document.
         * @param vec is a reference to an Ogre::Vector3 that will get rotated to the corrected axis
         */
        void correctAxis(Vector3& vec) const;
        /** corrects the vector axis alignment based on the documents up axis so that the ogre display matches the same
         *  orientation as the COLLADA document.
         * @param vec is a pointer to an array of 3 Ogre::Reals that will get rotated to the corrected axis
         */
        void correctAxis(Real* vec) const;
        /** corrects the vector axis alignment based on the documents up axis so that the ogre display matches the same
         *  orientation as the COLLADA document.
         * @param quat is a reference to a Ogre::Quaternion that will be rotated to the corrected axis
         */
        void correctAxis(Quaternion& quat) const;


    protected:
        /** Overridden from Resource.
                */
                void loadImpl(void);

                /** Unloads the material, frees resources etc.
                @see
                Resource
                */
                void unloadImpl(void);
                /// @copydoc Resource::calculateSize
                size_t calculateSize(void) const { return 0; } // Default to 0 for now


        private:
                xmlDocPtr                               mXmlDoc;                // the parsed collada (xml) document tree
                SceneManager                    *mSceneMgr;             // the ogre scene manager

                ColladaLibraryContainer *mLibrary;              // a container with all libraries
                ColladaSceneNode                *mScene;                // the scene root node (DAG graph)
        ColladaAsset            *mAsset;        // the asset element node for the document
        Quaternion               mUpRotation;   // rotation required to re-orientate collada axis to Ogre

                /**
                 * import asset information
                 * common document information, like authors, coordinates direction
                 * 
                 * @param       node    <asset> node
                 * @return      void
                 */
                void importAsset(xmlNode *node);

                /** 
                 * import <COLLADA> XML document
                 * the <COLLADA> element is the document entity (root element) in a COLLADA instance document
                 * child elements (in order and occurrence ([minOccur, maxOccur]))
                 *      asset           [1,1]
         *      library         [0,*]
                 *      scene           [0,1]
                 *
                 * @param       element <COLLADA> root element
                 * @return      true if succeeds, false otherwise
                 */
                bool importCollada(xmlNode *element);
        };


        /** Specialisation of SharedPtr to allow SharedPtr to be assigned to COLLADADocumentPtr 
        @note Has to be a subclass since we need operator=.
        We could templatise this instead of repeating per Resource subclass, 
        except to do so requires a form VC6 does not support i.e.
        ResourceSubclassPtr<T> : public SharedPtr<T>
        */
        class _OgreColladaExport ColladaDocumentPtr : public SharedPtr<ColladaDocument> 
        {
        public:
                ColladaDocumentPtr() : SharedPtr<ColladaDocument>() {}
                explicit ColladaDocumentPtr(ColladaDocument* rep) : SharedPtr<ColladaDocument>(rep) {}
                ColladaDocumentPtr(const ColladaDocumentPtr& r) : SharedPtr<ColladaDocument>(r) {} 
                ColladaDocumentPtr(const ResourcePtr& r) : SharedPtr<ColladaDocument>()
                {
                        // lock & copy other mutex pointer
                        OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
                        OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
                        pRep = static_cast<ColladaDocument*>(r.getPointer());
                        pUseCount = r.useCountPointer();
                        if (pUseCount)
                        {
                                ++(*pUseCount);
                        }
                }

                /// Operator used to convert a ResourcePtr to a MaterialPtr
                ColladaDocumentPtr& operator=(const ResourcePtr& r)
                {
                        if (pRep == static_cast<ColladaDocument*>(r.getPointer()))
                                return *this;
                        release();
                        // lock & copy other mutex pointer
                        OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
                        OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
                        pRep = static_cast<ColladaDocument*>(r.getPointer());
                        pUseCount = r.useCountPointer();
                        if (pUseCount)
                        {
                                ++(*pUseCount);
                        }
                        return *this;
                }
        };
}

#endif // __COLLADA_DOCUMENT_H__