OgreTangentSpaceCalc.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 _OgreTangentSpaceCalc_H_
#define _OgreTangentSpaceCalc_H_

#include "OgrePrerequisites.h"
#include "OgreRenderOperation.h"
#include "OgreVector2.h"
#include "OgreVector3.h"
#include "OgreVertexIndexData.h"

namespace Ogre
{

    class _OgreExport TangentSpaceCalc
    {
    public:
        TangentSpaceCalc();
        virtual ~TangentSpaceCalc();

        typedef std::pair<size_t, size_t> VertexSplit;

        struct IndexRemap
        {
            size_t indexSet;
            size_t faceIndex;
            VertexSplit splitVertex;
        
            IndexRemap() {} // to keep container happy
            IndexRemap(size_t i, size_t f, const VertexSplit& s) : indexSet(i), faceIndex(f), splitVertex(s) {}
        };
        typedef list<IndexRemap>::type IndexRemapList;

        typedef list<VertexSplit>::type VertexSplits;

        struct Result
        {
            VertexSplits vertexSplits;
            IndexRemapList indexesRemapped;
        };

        void clear();

        void setVertexData(VertexData* v_in);

        void addIndexData(IndexData* i_in, RenderOperation::OperationType opType = RenderOperation::OT_TRIANGLE_LIST);

        void setStoreParityInW(bool enabled) { mStoreParityInW = enabled; }

        bool getStoreParityInW() const { return mStoreParityInW; }

        void setSplitMirrored(bool split) { mSplitMirrored = split; }
        
        bool getSplitMirrored() const { return mSplitMirrored; }

        void setSplitRotated(bool split) { mSplitRotated = split; }
        bool getSplitRotated() const { return mSplitRotated; }

        Result build(VertexElementSemantic targetSemantic = VES_TANGENT,
            unsigned short sourceTexCoordSet = 0, unsigned short index = 1);


    protected:

        VertexData* mVData;
        typedef vector<IndexData*>::type IndexDataList;
        typedef vector<RenderOperation::OperationType>::type OpTypeList;
        IndexDataList mIDataList;
        OpTypeList mOpTypes;
        bool mSplitMirrored;
        bool mSplitRotated;
        bool mStoreParityInW;


        struct VertexInfo
        {
            Vector3 pos;
            Vector3 norm;
            Vector2 uv;
            Vector3 tangent;
            Vector3 binormal;
            // Which way the tangent space is oriented (+1 / -1) (set on first time found)
            int parity;
            // What index the opposite parity vertex copy is at (0 if not created yet)
            size_t oppositeParityIndex;

            VertexInfo() : tangent(Vector3::ZERO), binormal(Vector3::ZERO), 
                parity(0), oppositeParityIndex(0) {}
        };
        typedef vector<VertexInfo>::type VertexInfoArray;
        VertexInfoArray mVertexArray;

        void extendBuffers(VertexSplits& splits);
        void insertTangents(Result& res,
            VertexElementSemantic targetSemantic, 
            unsigned short sourceTexCoordSet, unsigned short index);

        void populateVertexArray(unsigned short sourceTexCoordSet);
        void processFaces(Result& result);
        void calculateFaceTangentSpace(const size_t* vertInd, Vector3& tsU, Vector3& tsV, Vector3& tsN);
        Real calculateAngleWeight(size_t v0, size_t v1, size_t v2);
        int calculateParity(const Vector3& u, const Vector3& v, const Vector3& n);
        void addFaceTangentSpaceToVertices(size_t indexSet, size_t faceIndex, size_t *localVertInd, 
            const Vector3& faceTsU, const Vector3& faceTsV, const Vector3& faceNorm, Result& result);
        void normaliseVertices();
        void remapIndexes(Result& res);
        template <typename T>
        void remapIndexes(T* ibuf, size_t indexSet, Result& res)
        {
            for (IndexRemapList::iterator i = res.indexesRemapped.begin();
                i != res.indexesRemapped.end(); ++i)
            {
                IndexRemap& remap = *i;

                // Note that because this is a vertex split situation, and vertex
                // split is only for some faces, it's not a case of replacing all
                // instances of vertex index A with vertex index B
                // It actually matters which triangle we're talking about, so drive
                // the update from the face index

                if (remap.indexSet == indexSet)
                {
                    T* pBuf;
                    pBuf = ibuf + remap.faceIndex * 3;

                    for (int v = 0; v < 3; ++v, ++pBuf)
                    {
                        if (*pBuf == remap.splitVertex.first)
                        {
                            *pBuf = (T)remap.splitVertex.second;
                        }
                    }
                }


            }
        }
        

    };
}



#endif