TranslatorContext.h

//
// Copyright 2017 Animal Logic
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.//
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#pragma once

#include "../../Api.h"

#include <AL/usdmaya/ForwardDeclares.h>
#include "maya/MPxData.h"
#include "maya/MGlobal.h"
#include "maya/MObject.h"
#include "maya/MObjectHandle.h"
#include "maya/MObjectArray.h"
#include "maya/MDGModifier.h"
#include "pxr/pxr.h"
#include "pxr/base/tf/refPtr.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/base/tf/debug.h"
#include "AL/usdmaya/DebugCodes.h"

#include <vector>
#include <string>
#include "AL/usd/utils/ForwardDeclares.h"

PXR_NAMESPACE_USING_DIRECTIVE


namespace AL {
namespace usdmaya {
namespace fileio {
namespace translators {

typedef std::vector<MObjectHandle> MObjectHandleArray;


//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
struct TranslatorParameters
{
  inline void setForcePrimImport(bool forceImport)
    { forcePrimImport = forceImport; }

  inline bool forceTranslatorImport() const
    { return forcePrimImport; }

private:
  bool forcePrimImport = false;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
struct TranslatorContext
  : public TfRefBase
{
public:
  typedef TranslatorContext This; 
  typedef TfRefPtr<This> RefPtr; 

  static RefPtr create(nodes::ProxyShape* proxyShape)
    {
      RefPtr res = TfCreateRefPtr(new This(proxyShape));
      res->setForceDefaultRead(false);
      return res;
    }

  const nodes::ProxyShape* getProxyShape() const
    { return m_proxyShape; }

  AL_USDMAYA_PUBLIC
  UsdStageRefPtr getUsdStage() const;

  bool getTransform(const UsdPrim& prim, MObjectHandle& object)
    { return getTransform(prim.GetPath(), object); }

  AL_USDMAYA_PUBLIC
  bool getTransform(const SdfPath& path, MObjectHandle& object);

  bool getMObject(const UsdPrim& prim, MObjectHandle& object, MTypeId type)
    { return getMObject(prim.GetPath(), object, type); }

  AL_USDMAYA_PUBLIC
  bool getMObject(const SdfPath& path, MObjectHandle& object, MTypeId type);

  bool getMObject(const UsdPrim& prim, MObjectHandle& object, MFn::Type type)
    { return getMObject(prim.GetPath(), object, type); }

  AL_USDMAYA_PUBLIC
  bool getMObject(const SdfPath& path, MObjectHandle& object, MFn::Type type);

  bool getMObjects(const UsdPrim& prim, MObjectHandleArray& returned)
    { return getMObjects(prim.GetPath(), returned); }

  AL_USDMAYA_PUBLIC
  bool getMObjects(const SdfPath& path, MObjectHandleArray& returned);

  AL_USDMAYA_PUBLIC
  void insertItem(const UsdPrim& prim, MObjectHandle object);

  void removeItems(const UsdPrim& prim)
    { removeItems(prim.GetPath()); }

  AL_USDMAYA_PUBLIC
  void removeItems(const SdfPath& path);

  AL_USDMAYA_PUBLIC
  ~TranslatorContext();
   
  TfToken getTypeForPath(SdfPath path) const
  {
    const auto it = find(path);
    if(it != m_primMapping.end())
    {
      return it->type();
    }
    TF_DEBUG(ALUSDMAYA_TRANSLATORS).Msg("TranslatorContext::getTypeForPath did not find item in mapping.%s\n", path.GetText());
    return TfToken();
  }

  AL_USDMAYA_PUBLIC
  void updatePrimTypes();

  AL_USDMAYA_PUBLIC
  void registerItem(const UsdPrim& prim, MObjectHandle object);
   
  AL_USDMAYA_PUBLIC
  MString serialise() const;

  AL_USDMAYA_PUBLIC
  void deserialise(const MString& string);

  AL_USDMAYA_PUBLIC
  void validatePrims();

  bool hasEntry(const SdfPath& path, const TfToken& type)
  {
    auto it = find(path);
    if(it != m_primMapping.end())
    {
      return type == it->type();
    }
    return false;
  }

  AL_USDMAYA_PUBLIC
  void preRemoveEntry(const SdfPath& primPath, SdfPathVector& itemsToRemove, bool callPreUnload=true);

  AL_USDMAYA_PUBLIC
  void removeEntries(const SdfPathVector& itemsToRemove);

  struct PrimLookup
  {
    PrimLookup(const SdfPath& path, const TfToken& type, MObject mayaObj)
      : m_path(path), m_type(type), m_object(mayaObj), m_createdNodes() {}

    ~PrimLookup() {}

    const SdfPath& path() const
      { return m_path; }

    MObjectHandle objectHandle() const
      { return m_object; }

    MObject object() const
      { return m_object.object(); }

    TfToken type() const
      { return m_type; }

    MObjectHandleArray& createdNodes()
      { return m_createdNodes; }

    const MObjectHandleArray& createdNodes() const
      { return m_createdNodes; }

  private:
    SdfPath m_path;
    TfToken m_type;
    MObjectHandle m_object;
    MObjectHandleArray m_createdNodes;
  };

  typedef std::vector<PrimLookup> PrimLookups;

  struct value_compare
  {
    inline bool operator() (const PrimLookup& a, const SdfPath& b) const
      { return a.path() < b; }

    inline bool operator() (const SdfPath& a, const PrimLookup& b) const
      { return a < b.path(); }

    inline bool operator() (const PrimLookup& a, const PrimLookup& b) const
      { return a.path() < b.path(); }
  };

  void clearPrimMappings()
    { m_primMapping.clear(); }

  AL_USDMAYA_PUBLIC
  bool addExcludedGeometry(const SdfPath& newPath)
  {
    auto foundPath = m_excludedGeometry.find(newPath);

    if(foundPath != m_excludedGeometry.end())
    {
      return false;
    }

    m_excludedGeometry.insert(newPath);
    m_isExcludedGeometryDirty = true;
    return true;
  }

  AL_USDMAYA_PUBLIC
  bool removeExcludedGeometry(const SdfPath& newPath)
  {
    auto foundPath = m_excludedGeometry.find(newPath);

    if(foundPath == m_excludedGeometry.end())
    {
      return false;
    }
    m_excludedGeometry.erase(newPath);
    m_isExcludedGeometryDirty = true;
    return true;
  }

  inline const SdfPathSet& excludedGeometry()
    {return m_excludedGeometry;}

  inline bool isExcludedGeometryDirty()
    {return m_isExcludedGeometryDirty;}

private:
  void unloadPrim(
      const SdfPath& primPath,
      const MObject& primObj);
  void preUnloadPrim(
      UsdPrim& primPath,
      const MObject& primObj);

  bool isNodeAncestorOf(MObjectHandle ancestorHandle, MObjectHandle objectHandleToTest);

  bool isPrimInTransformChain(const SdfPath& path);

  inline PrimLookups::iterator find(const SdfPath& path)
  {
    PrimLookups::iterator end = m_primMapping.end();
    PrimLookups::iterator it = std::lower_bound(m_primMapping.begin(), end, path, value_compare());
    if(it != end)
    {
      if(it->path() == path)
        return it;
    }
    return end;
  }

  inline PrimLookups::const_iterator find(const SdfPath& path) const
  {
    PrimLookups::const_iterator end = m_primMapping.end();
    PrimLookups::const_iterator it = std::lower_bound(m_primMapping.begin(), end, path, value_compare());
    if(it != end)
    {
      if(it->path() == path)
        return it;
    }
    return end;
  }

  inline PrimLookups::iterator findLocation(const SdfPath& path)
  {
    PrimLookups::iterator end = m_primMapping.end();
    PrimLookups::iterator it = std::lower_bound(m_primMapping.begin(), end, path, value_compare());
    return it;
  }


  TranslatorContext(nodes::ProxyShape* proxyShape)
    : m_proxyShape(proxyShape), m_primMapping()
    {}

  nodes::ProxyShape* m_proxyShape;

  // map between a usd prim path and either a dag parent node or
  // a dependency node
  PrimLookups m_primMapping;

  // true to make all translators that default to not importing Prims to always import Prims via the translators
  bool m_forcePrimImport;

  // list of geometry that has been request to be excluded during the translation
  SdfPathSet m_excludedGeometry;
  bool m_isExcludedGeometryDirty;

public:
  void setForceDefaultRead(bool forceDefaultRead)
    { m_forceDefaultRead = forceDefaultRead; }

  bool getForceDefaultRead()
    { return m_forceDefaultRead; }

private:
  // If true, will explicitly read default attribute values.
  bool m_forceDefaultRead;

};

typedef TfRefPtr<TranslatorContext> TranslatorContextPtr;

//----------------------------------------------------------------------------------------------------------------------
} // translators
} // fileio
} // usdmaya
} // AL
//----------------------------------------------------------------------------------------------------------------------