UsdExporterUtils.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
#ifndef ATOMS_UNREAL
#ifndef NOMINMAX
#define NOMINMAX 
#endif
 
#include <pxr/pxr.h>
#include <pxr/usd/usd/stage.h>
#include <pxr/usd/usd/modelAPI.h>
#include <pxr/usd/usd/editContext.h>
#if (PXR_MINOR_VERSION < 20)
#include <pxr/usd/usd/references.h>
#else
#include <pxr/usd/usd/payloads.h>
#endif
#include <pxr/usd/kind/registry.h>
#include <pxr/usd/usdGeom/scope.h>
#include <pxr/usd/usdGeom/metrics.h>
#include <pxr/usd/usdGeom/xform.h>
#include <pxr/usd/usdGeom/mesh.h>
#include <pxr/usd/usdGeom/primvarsAPI.h>
#include <pxr/usd/usdSkel/skeleton.h>
#include <pxr/usd/usdSkel/blendShape.h>
#include <pxr/usd/usdSkel/bindingAPI.h>
#include <pxr/usd/usdSkel/animation.h>
#include <pxr/usd/sdf/valueTypeName.h>
#include <pxr/usd/sdf/path.h>
#include <pxr/usd/usdShade/materialBindingAPI.h>
#include <pxr/base/tf/token.h>
#include <pxr/base/gf/matrix4d.h>
#include <pxr/base/vt/types.h>
#include <pxr/base/vt/value.h>
 
#include <Atoms/Usd/Globals.h>
#include <AtomsCore/AtomsMath.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Metadata/ArrayMetadata.h>
#include <AtomsCore/Metadata/MeshMetadata.h>
#include <AtomsCore/Joint.h>
#include <AtomsCore/Skeleton.h>
#include <Atoms/Variations.h>
 
 
 
struct MaterialData {
    AtomsCore::Vector3 diffuseColorValue;
    AtomsCore::Vector3 specularColorValue;
    std::string diffusePathValue;
    std::string specularPathValue;
    std::string normalPathValue;
    double diffuseWeight;
    double specularWeight;
    double cosinePowerValue;
    double specularEccentricity;
 
    MaterialData() :
        diffusePathValue(""),
        diffuseColorValue(AtomsCore::Vector3(0.0, 1.0, 0.0)),
        specularPathValue(""),
        specularColorValue(AtomsCore::Vector3(1.0, 1.0, 1.0)),
        normalPathValue(""),
        diffuseWeight(0.8),
        specularWeight(0.2),
        cosinePowerValue(0.5),
        specularEccentricity(0.5)
    {
 
    }
};
 
 
struct TransformData {
    PXR_NS::VtVec3fArray t;
    PXR_NS::VtVec3hArray s;
    PXR_NS::VtQuatfArray r;
    PXR_NS::GfMatrix4d w;
    PXR_NS::TfToken v;
    AtomsMath::Box3f box;
    AtomsCore::MapMetadata metadata;
    bool useVisibility;
 
    TransformData() :
        v(PXR_NS::UsdGeomTokensType().inherited),
        useVisibility(true)
    {
        t.clear();
        s.clear();
        r.clear();
        w.SetIdentity();
        box.makeEmpty();
        metadata.clear();
    }
};
 
 
struct BlendShapeData {
    PXR_NS::VtTokenArray blendShapeNames;
    std::map<int, PXR_NS::VtFloatArray> blendShapeWeights;
 
    BlendShapeData()
    {
        blendShapeNames.clear();
        blendShapeWeights.clear();
    }
};
 
struct UsdAgentData
{
    std::string agentType;
    std::string variation;
    std::string lod;
    std::string groupName;
    int variationSeed;
    int sourceGroupId;
    std::vector<std::string> variationsOverrides;
    std::vector<std::string> variationsGeometryFilters;
    std::vector<std::string> variationsGeoMatOverrides;
    int groupId;
    std::map<int, TransformData> transforms;
    BlendShapeData blendShapes;
};
 
 
std::string cleanNameForUSD(
    const std::string& name);
 
PXR_NS::GfMatrix4d convertAtomsMatrix(
    const AtomsCore::Matrix& mtx);
 
AtomsCore::Matrix convertUsdMatrix(
    const PXR_NS::GfMatrix4d& mtx);
 
void convertMaterial(
    const PXR_NS::UsdStageRefPtr& stage,
    const std::string& name,
    const std::string& parent,
    MaterialData& materialData,
    PXR_NS::UsdShadeMaterial& material);
 
 
std::string buildJointFullPath(
    const AtomsCore::Joint& j);
 
 
std::vector<std::string> buildJointNamesFromSkeleton(
    const AtomsCore::Skeleton& skeleton);
 
 
std::vector<std::string> convertAtomsSkeleton(
    const AtomsCore::Skeleton& atomsSkeleton,
    const PXR_NS::UsdSkelSkeleton& skel);
 
std::vector<std::string> saveAtomsSkeleton(
    const AtomsCore::Skeleton& atomsSkeleton,
    const std::string& skeletonOutput,
    const std::string& name);
 
 
void atomsMeshToUsdMesh(
    const AtomsUtils::Mesh& atomsMesh,
    PXR_NS::UsdGeomMesh& meshPrim,
    const AtomsCore::Matrix& worldMatrix);
 
 
void setupSkinWeights(
    AtomsPtr<const AtomsCore::MapMetadata> geoMap,
    PXR_NS::UsdGeomMesh& meshPrim);
 
 
void setMetadataPrimVar(
    PXR_NS::UsdGeomPrimvarsAPI& primvarsApi,
    const PXR_NS::TfToken& primVarName,
    const std::string& metaName,
    unsigned int metaTypeId,
    AtomsPtr<const AtomsCore::MapMetadata> meta,
    int* frame = nullptr);
 
void setMetadataAsAttributes(
    PXR_NS::UsdPrim& primvarsApi,
    const std::string& metaName,
    const AtomsPtr<AtomsCore::Metadata>& meta,
    int* frame = nullptr);
 
 
std::vector<std::string> getBlendShapeNames(
    const Atoms::Variations& variationMap,
    const std::string& agentTypeName,
    const std::string& variationName);
 
 
void atomsBlendShapesToUsdBlendShapes(
    const PXR_NS::UsdStageRefPtr& stage,
    PXR_NS::UsdGeomMesh& meshPrim,
    const AtomsUtils::Mesh& atomsMesh,
    AtomsPtr<const AtomsCore::ArrayMetadata>& blendShapes,
    const std::string& blendShapeName);
 
 
void processChildMesh(
    const PXR_NS::UsdStageRefPtr& stage,
    const std::string& childPath,
    AtomsPtr<const AtomsCore::MapMetadata>& currentChild,
    bool useDefaultMaterial,
    const std::string& blendShapeName,
    const std::string& outAssetFolder,
    bool mergeTransformAndShape,
    PXR_NS::SdfPathVector& meshesPaths);
 
bool saveAtomsMesh(
    const AtomsCore::MapMetadata* atomsMesh,
    const std::string& putputPath,
    const std::string& name,
    AtomsCore::MapMetadata* parameters);
 
PXR_NS::UsdStageRefPtr createNewUSDStage(const std::string& path);
 
#endif