D:/VL/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlCore/Transform.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://www.visualizationlibrary.com                                               */
/*                                                                                    */
/*  Copyright (c) 2005-2010, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef Transform_INCLUDE_ONCE
#define Transform_INCLUDE_ONCE

#include <vlCore/vlnamespace.hpp>
#include <vlCore/Object.hpp>
#include <vlCore/Matrix4.hpp>
#include <vector>
#include <set>
#include <algorithm>

namespace vl
{
  class Camera;

  // mic fixme: finalize the generalization by
  // - moving the local matrix management away from ITransform
  // - implementing a Quat/Scale/Translation-based transform type: QuScTrTransform?
  // - rename Transform to MatrixTransform
  // - the engine, rendering, actors etc. should use ITransform instead of MatrixTransform

  //------------------------------------------------------------------------------
  // TransformHierarchy
  //------------------------------------------------------------------------------
  class VLCORE_EXPORT ITransform: public Object
  {
  public:
    ITransform(): mWorldMatrixUpdateTick(0), mAssumeIdentityWorldMatrix(false)  
    {
      #if VL_TRANSFORM_USER_DATA 
        mTransformUserData = NULL;
      #endif
    }

    virtual size_t childrenCount() const = 0;
    
    virtual ITransform* getChildren(size_t i) = 0;
    
    virtual const ITransform* getChildren(size_t i) const = 0;
    
    virtual ITransform* parent() = 0;
    
    virtual const ITransform* parent() const = 0;
    
    void setLocalMatrix(const mat4& m)
    { 
      mLocalMatrix = m;
    }

    const mat4& localMatrix() const
    { 
      return mLocalMatrix;
    }

    virtual void computeWorldMatrix(Camera* /*camera*/ = NULL)
    {
      if( assumeIdentityWorldMatrix() )
      {
        setWorldMatrix(mat4()); 
      }
      else
      /* top Transforms are usually assumeIdentityWorldMatrix() == true for performance reasons */
      if( parent() && !parent()->assumeIdentityWorldMatrix() )
      {
        setWorldMatrix( parent()->worldMatrix() * localMatrix() );
      }
      else
        setWorldMatrix( localMatrix() );
    }

    void computeWorldMatrixRecursive(Camera* camera = NULL)
    {
      computeWorldMatrix(camera);
      for(size_t i=0; i<childrenCount(); ++i)
        getChildren(i)->computeWorldMatrixRecursive(camera);
    }

    mat4 getComputedWorldMatrix()
    {
      mat4 world = localMatrix();
      ref<ITransform> par = parent();
      while(par)
      {
        world = par->localMatrix() * world;
        par = par->parent();
      }
      return world;
    }

    const mat4& worldMatrix() const 
    { 
      return mWorldMatrix;
    }

    void setWorldMatrix(const mat4& matrix) 
    { 
      mWorldMatrix = matrix; 
      ++mWorldMatrixUpdateTick;
    }

    long long worldMatrixUpdateTick() const { return mWorldMatrixUpdateTick; }

    void setAssumeIdentityWorldMatrix(bool assume_I) { mAssumeIdentityWorldMatrix = assume_I; }

    bool assumeIdentityWorldMatrix() { return mAssumeIdentityWorldMatrix; }

    bool hasDuplicatedChildren() const
    {
      std::set<const ITransform*> tr_set;
      for(size_t i=0; i<childrenCount(); ++i)
        tr_set.insert(getChildren(i));
      return tr_set.size() != childrenCount();
    }

#if VL_TRANSFORM_USER_DATA 
  public:
    void setTransformUserData(void* data) { mTransformUserData = data; }
    const void* transformUserData() const { return mTransformUserData; }
    void* transformUserData() { return mTransformUserData; }

  private:
    void* mTransformUserData;
#endif

  protected:
    mat4 mLocalMatrix;
    mat4 mWorldMatrix;
    long long mWorldMatrixUpdateTick;
    bool mAssumeIdentityWorldMatrix;
  };

  //------------------------------------------------------------------------------
  // TransformHierarchy
  //------------------------------------------------------------------------------
  template<class Ttype>
  class TransformHierarchy: public ITransform
  {
  public:
    TransformHierarchy(): mParent(NULL) {}

    // --- --- ITransform interface implementation --- ---

    virtual size_t childrenCount() const { return mChildren.size(); }

    virtual ITransform* getChildren(size_t i) { return mChildren[i].get(); }
    
    virtual const ITransform* getChildren(size_t i) const { return mChildren[i].get(); }

    virtual const ITransform* parent() const { return mParent; }
    
    virtual ITransform* parent() { return mParent; }

    // --- --- children management --- ---

    const std::vector< ref<Ttype> >& children() const { return mChildren; }

    void addChild(Ttype* child)
    {
      VL_CHECK(child != NULL)
      VL_CHECK(child->mParent == NULL)

      mChildren.push_back(child);
      child->mParent = this;
    }
    
    void addChildren(Ttype*const* children, size_t count)
    {
      VL_CHECK(children != NULL)

      if (count)
      {
        size_t insert_point = mChildren.size();
        mChildren.resize(mChildren.size() + count);
        vl::ref<Ttype>* ptr = &mChildren[insert_point];
        for(size_t i=0; i<count; ++i, ++ptr)
        {
          VL_CHECK(children[i]->mParent == NULL);
          children[i]->mParent = this;
          (*ptr) = children[i];
        }
      }
    }

    void addChildren(const ref<Ttype>* children, size_t count)
    {
      VL_CHECK(children != NULL)

      if (count)
      {
        size_t insert_point = mChildren.size();
        mChildren.resize(mChildren.size() + count);
        vl::ref<Ttype>* ptr = &mChildren[insert_point];
        for(size_t i=0; i<count; ++i)
        {
          VL_CHECK(children[i]->mParent == NULL);
          children[i]->mParent = this;
          ptr[i] = children[i];
        }
      }
    }

    void addChildren(const std::vector< ref<Ttype> >& children)
    {
      if (children.size())
        addChildren( &children[0], children.size() );
    }
    
    void addChildren(const std::vector< Ttype* >& children)
    {
      if (children.size())
        addChildren( &children[0], children.size() );
    }
    
    void setChild(int index, Ttype* child)
    {
      VL_CHECK(child)
      VL_CHECK( index < (int)mChildren.size() )
      mChildren[index]->mParent = NULL;
      mChildren[index] = child;
      mChildren[index]->mParent = this;
    }
    
    Ttype* lastChild()
    {
      return mChildren.back().get();
    }
    
    void eraseChild(Ttype* child)
    {
      VL_CHECK(child != NULL)
      typename std::vector< ref<Ttype> >::iterator it;
      it = std::find(mChildren.begin(), mChildren.end(), child);
      VL_CHECK(it != mChildren.end())
      if (it != mChildren.end())
      {
        (*it)->mParent = NULL;
        mChildren.erase(it);
      }
    }
    
    void eraseChildren(int index, int count)
    {
      VL_CHECK( index + count <= (int)mChildren.size() );

      for(int j=index; j<index+count; ++j)
        mChildren[j]->mParent = NULL;

      for(int i=index+count, j=index; i<(int)mChildren.size(); ++i, ++j)
        mChildren[j] = mChildren[i];

      mChildren.resize( mChildren.size() - count );
    }    

    void eraseAllChildren()
    {
      for(int i=0; i<(int)mChildren.size(); ++i)
        mChildren[i]->mParent = NULL;
      mChildren.clear();
    }
    
    void eraseAllChildrenRecursive()
    {
      for(int i=0; i<(int)mChildren.size(); ++i)
      {
        mChildren[i]->eraseAllChildrenRecursive();
        mChildren[i]->mParent = NULL;
      }
      mChildren.clear();
    }

    void shrink()
    {
      std::vector< ref<Ttype> > tmp (mChildren);
      mChildren.swap(tmp);
    }

    void shrinkRecursive()
    {
      shrink();
      for(size_t i=0; i<mChildren.size(); ++i)
        mChildren[i]->shrinkRecursive();
    }

    void reserveChildren(size_t count) { mChildren.reserve(count); }

  protected:
    std::vector< ref<Ttype> > mChildren;
    TransformHierarchy* mParent;
  };

  //------------------------------------------------------------------------------
  // Transform
  //------------------------------------------------------------------------------
  class VLCORE_EXPORT Transform: public TransformHierarchy<Transform>
  {
  public:
    virtual const char* className() { return "vl::Transform"; }

    Transform()
    { 
      VL_DEBUG_SET_OBJECT_NAME()
    }

    Transform(const mat4& matrix)
    { 
      VL_DEBUG_SET_OBJECT_NAME()
      setLocalMatrix(matrix);
      setWorldMatrix(matrix);
    }

    void setLocalAndWorldMatrix(const mat4& matrix)
    { 
      mLocalMatrix = matrix;
      setWorldMatrix(matrix);
    }

    void translate(Real x, Real y, Real z);
    
    void translate(const vec3& t);
    
    void scale(Real x, Real y, Real z);
    
    void rotate(Real degrees, Real x, Real y, Real z);
    
    void rotate(const vec3& from, const vec3& to);
  };
}

#endif