Transform.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, 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;

  //------------------------------------------------------------------------------
  // Transform
  //------------------------------------------------------------------------------
  class VLCORE_EXPORT Transform: public Object
  {
    VL_INSTRUMENT_CLASS(vl::Transform, Object)

  public:
    Transform(): mWorldMatrixUpdateTick(0), mAssumeIdentityWorldMatrix(false), mParent(NULL)
    {
      VL_DEBUG_SET_OBJECT_NAME()

      #ifdef VL_USER_DATA_TRANSFORM
        mTransformUserData = NULL;
      #endif
    }

    Transform(const mat4& matrix): mWorldMatrixUpdateTick(0), mAssumeIdentityWorldMatrix(false), mParent(NULL)
    {
      VL_DEBUG_SET_OBJECT_NAME()

      #ifdef VL_USER_DATA_TRANSFORM
        mTransformUserData = NULL;
      #endif

      setLocalMatrix(matrix);
      setWorldMatrix(matrix);
    }

    ~Transform();

    const Transform* parent() const { return mParent; }

    Transform* parent() { return mParent; }

    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);

    void preMultiply(const mat4& m);

    void postMultiply(const mat4& m);

    void setLocalMatrix(const mat4& m)
    {
      mLocalMatrix = m;
    }

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

    mat4& localMatrix()
    {
      return mLocalMatrix;
    }

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

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

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

    long long worldMatrixUpdateTick() const { return mWorldMatrixUpdateTick; }

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

    bool assumeIdentityWorldMatrix() { return mAssumeIdentityWorldMatrix; }

    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<mChildren.size(); ++i)
        mChildren[i]->computeWorldMatrixRecursive(camera);
    }

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

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

    const ref<Transform>* children() const { if (mChildren.empty()) return NULL; else return &mChildren[0]; }

    ref<Transform>* children() { if (mChildren.empty()) return NULL; else return &mChildren[0]; }

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

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

      mChildren.push_back(child);
      child->mParent = this;
    }

    void addChildren(Transform*const* children, size_t count)
    {
      VL_CHECK(children != NULL)

      if (count)
      {
        size_t insert_point = mChildren.size();
        mChildren.resize(mChildren.size() + count);
        vl::ref<Transform>* 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<Transform>* children, size_t count)
    {
      VL_CHECK(children != NULL)

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

    void addChildren(const std::vector< ref<Transform> >& children)
    {
      if (children.size())
        addChildren( &children[0], children.size() );
    }

    void addChildren(const std::vector< Transform* >& children)
    {
      if (children.size())
        addChildren( &children[0], children.size() );
    }

    void setChild(int index, Transform* child)
    {
      VL_CHECK(child)
      VL_CHECK( index < (int)mChildren.size() )
      mChildren[index]->mParent = NULL;
      mChildren[index] = child;
      mChildren[index]->mParent = this;
    }

    const Transform* lastChild() const { return mChildren.back().get(); }

    Transform* lastChild() { return mChildren.back().get(); }

    void eraseChild(const Transform* child)
    {
      VL_CHECK(child != NULL)
      std::vector< ref<Transform> >::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 flattenHierarchy()
    {
      for(int i=0; i<(int)mChildren.size(); ++i)
      {
        mChildren[i]->setLocalAndWorldMatrix( mChildren[i]->worldMatrix() );
        mChildren[i]->eraseAllChildrenRecursive();
        mChildren[i]->mParent = NULL;
      }
      mChildren.clear();
    }

    void removeFromParent()
    {
      if (parent())
      {
        mParent->eraseChild(this);
        setLocalMatrix( worldMatrix() );
      }
    }

    void shrink()
    {
      std::vector< ref<Transform> > 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); }

    bool hasDuplicatedChildren() const
    {
      std::set<const Transform*> tr_set;
      for(size_t i=0; i<mChildren.size(); ++i)
        tr_set.insert( mChildren[i].get() );
      return tr_set.size() != mChildren.size();
    }

#ifdef VL_USER_DATA_TRANSFORM
  public:
    const Object* transformUserData() const { return mTransformUserData.get(); }
    Object* transformUserData() { return mTransformUserData.get(); }
    void setTransformUserData(Object* data) { mTransformUserData = data; }

  private:
    ref<Object> mTransformUserData;
#endif

  protected:
    mat4 mLocalMatrix;
    mat4 mWorldMatrix;
    long long mWorldMatrixUpdateTick;
    bool mAssumeIdentityWorldMatrix;
    std::vector< ref<Transform> > mChildren;
    Transform* mParent;
  };

}

#endif