FgApplyDaz.cpp

//
// Copyright (c) 2023 Singular Inversions Inc. (facegen.com)
//
// Authors:     Andrew Beatty
// Created:     Oct. 4, 2011
//
 
#include "stdafx.h"
 
#include "FgSerial.hpp"
#include "FgApply.hpp"
#include "FgTestUtils.hpp"
#include "FgParse.hpp"
#include "Fg3Sam.hpp"
#include "Fg3Face.hpp"
#include "FgGuiApi.hpp"
#include "Fg3dMeshIo.hpp"
#include "FgTime.hpp"
#include "FgSystem.hpp"
#include "FgAnthropometry.hpp"
#include "FgRender.hpp"
 
#ifdef _MSC_VER
#pragma warning(disable:4996)       // ignore 'gmtime' security deprecation warning
#endif
 
using namespace std;
 
namespace Fg {
 
namespace {
 
String8             formatDsfPath(String8 const & str)
{
    String8         slash = str.replace('\\','/');
    return replaceCharWithString(slash,char32_t(' '),String8("%20"));
}
 
string              dateTimeISO8601()
{
    time_t      now;
    time(&now);
    char        buff[sizeof "2019-10-22T08:06:00Z"];
    strftime(buff,sizeof buff,"%FT%TZ",gmtime(&now));
    return string(buff);
}
 
void                exportScmMap(
    String8 const &         scmPathBase,
    String8 const &         outPathBase,
    Sam3Coord const &       coord,
    Bytes const &          detailEnc,
    ImgFormat               imgFormat)
{
    PushIndent              op(pathToName(scmPathBase).m_str);
    Timer                   time;
    Scm3                    scm(scmPathBase);
    time.report("SCM load");
    ImgRgba8                detail = scm.transformDetail(detailEnc);
    time.report("Detail transform");
    ImgRgba8                colorMap = scm.applyFaceCoord(coord.ts(1,0),detail);
    time.report("SCM application");
    String                  ext = getImgFormatInfo(imgFormat).extensions.at(0);
    saveImage(colorMap,outPathBase+"."+ext);
    time.report("Save image");
}
 
void                createCustomBodyMap(
    String8 const &         basePathName,
    Arr3D                   colorFac,
    String8 const &         outPathBase,
    ImgFormat               imgFormat)
{
    PushIndent              op(pathToName(basePathName).m_str);
    //Timer                   time;
    ImgRgba8                baseImg = loadImage(basePathName);
    ImgRgba8                shiftImg = applyColorFac(baseImg,colorFac);
    String                  ext = getImgFormatInfo(imgFormat).extensions.at(0);
    saveImage(shiftImg,outPathBase+"."+ext);
    //time.report("Body load, shift, save");
}
 
// returns the per-channel least-squares multiplicative factor to adjust the given daz map to the fg map color:
Arr3D               createFaceMap(
    String8 const &         scmPathBase,
    String8 const &         dazPath,
    String8 const &         outPathBase,
    Sam3Coord const &       coord,
    Bytes const &           detailBlob,
    TattooImage const &     tattooImage,
    Arr3D                   renderFac={1,1,1})    // multiplicative factor to adjust fg map to daz render input
{
    //PushIndent              op {"createFaceMap"};
    //Timer                   time;
    Scm3                    scm {scmPathBase};
    ImgUC                   faceFade = toUC(loadImage(scmPathBase+"_fade.jpg"));
    //time.report("SCM load");
    ImgRgba8                scmMap = scm.calcScmColorMap(coord);
    //time.report("SCM apply");
    ImgRgba8                dazImg = loadImage(dazPath);
    //time.report("Base image load");
    ImgRgba8                detail = scm.transformDetail(detailBlob);
    //time.report("Detail transform");
    ImgUC                   skinSampleRegion = getSkinSampleRegion(scm.detailXfm);
    Arr3D                   colorFac = calcColorFac(dazImg,scmMap,skinSampleRegion),
                            facegenFac = mapMul(renderFac,colorFac);
    // make sure to do this AFTER color sampling but BEFORE detail application:
    if (tattooImage) {
        tattooImage(scm.detailXfm,scmMap);
        //time.report("add logo");
    }
    ImgRgba8                detailMap = applyColorFac(imgModulate(scmMap,detail),renderFac);
    //time.report("Detail modulation");
    ImgRgba8                dazMapAdj = applyColorFac(dazImg,facegenFac),
                            blendMap = imgBlend(detailMap,dazMapAdj,faceFade);
    //time.report("Shift and blend");
    saveImage(blendMap,outPathBase+".jpg");
    //time.report("Save image");
    return facegenFac;
}
 
ostream &           operator<<(ostream & os,IdxVec3F const & v)
{
    os  << "                        [ " << v.idx << ", "
        << v.vec[0] << ", "
        << v.vec[1] << ", "
        << v.vec[2] << " ]";
    return os;
}
 
void                dazSaveDsfMorphV6(
    String8 const &         libPath,
    String8 const &         relPath,            // must end with delimiter but not start with one
    String8 const &         controlName,
    String8 const &         parent,
    string const &          modifierNodeId,
    size_t                  totNumVerts,
    IdxVec3Fs const &       morph,
    String8                 group,
    Arr<Vec3F,2>            eyeCentreDeltas)    // 0 - left, 1 - right
{
    if (group.m_str[0] != '/')
        group.m_str.insert(group.m_str.begin(),'/');    // Must start with '/'
    Ofstream        ofs(libPath+relPath+controlName+".dsf");
    String8         controlID = "FG"+controlName,
                    parentFmt = formatDsfPath(parent);
    // Spaces in PATHS are changed to '%20' to match files Daz produces, but spaces in just the names
    // (eg. modifier_library id/name) cannot contain '%' but can contain spaces, so leave those unchanged.
    // 'auto_follow' is for hairstyles (& clothing?) to follow new head shape.
    ofs.precision(7);
    ofs.setf(ios::fixed);
    ofs << R"({
    "file_version" : "0.6.0.0",
    "asset_info" : {
        "id" : "/)" << formatDsfPath(relPath+controlName) << R"(.dsf",
        "type" : "modifier",
        "contributor" : {
            "author" : "FaceGen",
            "email" : "",
            "website" : "https://facegen.com"
        },
        "revision" : "1.0",
        "modified" : ")" << dateTimeISO8601() << R"("
    },
    "modifier_library" : [
        {
            "id" : ")" << controlID << R"(",
            "name" : ")" << controlID << R"(",
            "parent" : ")" << parentFmt << modifierNodeId << R"(",
            "presentation" : {
                "type" : "Modifier/Shape",
                "label" : "",
                "description" : "",
                "icon_large" : "",
                "colors" : [ [ 0.1568627, 0.1568627, 0.1568627 ], [ 1, 1, 1 ] ]
            },
            "channel" : {
                "id" : "value",
                "type" : "float",
                "name" : "Value",
                "label" : ")" << controlName << R"(",
                "value" : 0,
                "min" : 0,
                "max" : 1,
                "clamped" : true,
                "display_as_percent" : true,
                "step_size" : 0.01,
                "auto_follow" : true
            },
            "region" : "Head",
            "group" : ")" << group << R"(",
            "formulas" : [)";
    Strings         coords {"x","y","z"};
    for (size_t ss=0; ss<2; ++ss) {
        String          eye = (ss==0) ? "lEye" : "rEye";
        for (uint dd=0; dd<3; ++dd) {
            ofs << R"(
                {
                    "output" : ")" << eye << ":" << parentFmt << eye << "?center_point/" << coords[dd] << R"(",
                    "operations" : [
                        { "op" : "push", "url" : ")" << modifierNodeId << ":#" << controlID << R"(?value" },
                        { "op" : "push", "val" : )" << eyeCentreDeltas[ss][dd] << R"( },
                        { "op" : "mult" }
                    ]
                })";
            if ((ss==0) || (dd<2))
                ofs << ",";
        }
    }
    ofs << R"(
            ],
            "morph" : {
                "vertex_count" : )" << totNumVerts << R"(,
                "deltas" : {
                    "count" : )" << morph.size() << R"(,
                    "values" : [
)"
        << morph[0];
    for (size_t ii=1; ii<morph.size(); ++ii)
        ofs << ",\n" << morph[ii];
    ofs << R"(
                    ]
                }
            }
        }
    ],
    "scene" : {
        "modifiers" : [
            {
                "id" : ")" << controlID << R"(-1",
                "url" : "#)" << controlID << R"("
            }
        ]
    }
})";
}
 
}
 
Svec<DazGenesis>    cDazGenesisInfo()
{
    return {
        {DazGenesisVer::G1,"1"},
        {DazGenesisVer::G2,"2"},
        {DazGenesisVer::G3,"3"},
        {DazGenesisVer::G8,"8"},
        {DazGenesisVer::G81,"81"},
        {DazGenesisVer::G9,"9"},
    };
}
 
ostream &           operator<<(ostream & os,DazGenesisVer ver)
{
    return os << findFirst(cDazGenesisInfo(),ver).str;
}
 
Strings             dazGenesisBodyMapNames(DazGenesisVer ver)
{
    map<DazGenesisVer,Strings>      verMaps {
        {DazGenesisVer::G1,{"limbs","torso"}},
        {DazGenesisVer::G2,{"limbs","torso"}},
        {DazGenesisVer::G3,{"arms","legs","torso"}},
        {DazGenesisVer::G8,{"arms","legs","torso"}},
        {DazGenesisVer::G81,{"arms","body","head","legs"}},
    };
    return verMaps.at(ver);
}
 
String              dazRelMorphDir(DazGenesisVer ver,bool female)
{
    map<DazGenesisVer,string>   morphVerDir {
        {DazGenesisVer::G1,"Genesis"},
        {DazGenesisVer::G2,"Genesis 2"},
        {DazGenesisVer::G3,"Genesis 3"},
        {DazGenesisVer::G8,"Genesis 8"},
        {DazGenesisVer::G81,"Genesis 8"},
    };
    bool            isV1 = (ver == DazGenesisVer::G1);
    string          genderStr = isV1 ? "" : (female ? "Female" : "Male"),
                    morphGenderVer = (ver == DazGenesisVer::G81 ? " 8_1" : ""),
                    morphGenderDir = isV1 ? "Base" : genderStr;
    return "data/DAZ 3D/" + morphVerDir[ver] + "/" + morphGenderDir + morphGenderVer + "/";
}
 
// Returns empty if registryPath doesn't exist or has no content directories:
static String8s     getContentDirs(String8 const registryPath)
{
    String8s            ret;
    // This gives the number of non-cloud content dirs:
    Opt<ulong>          numDirs = getWinRegistryUlong(registryPath,"NumContentDirs");
    if (!numDirs.has_value())
        return ret;
    // These are all non-cloud content dirs. The "Daz Connect" cloud content dir is in 'CloudDir' but we don't
    // use that as Daz Studio won't load custom morphs from it:
    String8             nameRoot = "ContentDir";
    for (ulong ii=0; ii<numDirs.value(); ++ii) {
        String8             name = nameRoot + toStr(ii);
        Opt<String8>        dirOpt = getWinRegistryString(registryPath,name);
        if (dirOpt.has_value()) {
            String8             dirSlash = toNativeDirSep(dirOpt.value()+"/");   // They lack a trailing separator
            if (!contains(ret,dirSlash))
                ret.push_back(dirSlash);
        }
    }
    return ret;
}
 
String8s            getDazContentDirs()
{
    String8s            releaseDirs = getContentDirs("Software\\Daz\\Studio4");
    // Do not remove this; many people use the public beta version instead of the release version as they like access
    // to the latest working features, and the content directory presumably has to be different to support new formats:
    String8s            betaDirs = getContentDirs("Software\\Daz\\Studio4PublicBuild");
    String8s            ret;
    for (String8 const & dir : cat(releaseDirs,betaDirs)) {
        if (!contains(ret,dir)) {   // don't think a beta dir can be the same as a release dir but you never know
            if (pathExists(dir))
                ret.push_back(dir);
        }
    }
    return ret;
}
 
String8             getDazContentDirContaining(String const & relPath)
{
    String8s            cds = getDazContentDirs();
    for (String8 const & cd : cds) {
        if (pathExists(cd+relPath))
            return cd;
    }
    return {};
}
 
String8             getDazConnectDirContaining(String const & relDir)
{
    auto                findFn = [&](String const & registryPath)
    {
        Opt<String8>        cdo = getWinRegistryString(registryPath,"CloudDir");
        if (cdo.has_value()) {
            String8 const &     cd = cdo.value();
            DirContents         dcs = getDirContents(cd+"/data/cloud/");
            String8s            vers = sortAll(select(dcs.dirnames,[](String8 const & d){return d.beginsWith("1_"); }));
            for (auto it = vers.rbegin(); it != vers.rend(); ++it) {
                String8             ret = cd+"/data/cloud/"+*it+"/";
                String8             path = ret + relDir;
                if (pathExists(path))
                    return ret;
            }
        }
        return String8{};
    };
    String8             ret = findFn("Software\\Daz\\Studio4");
    if (ret.empty())
        ret = findFn("Software\\Daz\\Studio4PublicBuild");
    return ret;
}
 
void                dazExport(
    DazGenesisVer           ver,
    bool                    female,
    String8 const &         contentDir,
    Sam3Coord const &       coord,
    Bytes const &           detail,
    bool                    sphericalEyes,
    String8 const &         group,
    String8 const &         controlName,
    String8s const &        baseMapNames,
    WorkerCallback const &  fnUpdate,
    EmbossMesh const &      embossMesh,
    TattooImage const &     tattooImage)
{
    // SSM:
    map<DazGenesisVer,string>   fullVerStr {
        {DazGenesisVer::G1,""},
        {DazGenesisVer::G2,"2"},
        {DazGenesisVer::G3,"3"},
        {DazGenesisVer::G8,"8"},
        {DazGenesisVer::G81,"8_1"},
    };
    map<DazGenesisVer,string>   nodeIdVerStr {
        {DazGenesisVer::G1,""},
        {DazGenesisVer::G2,""},
        {DazGenesisVer::G3,"3"},
        {DazGenesisVer::G8,"8"},
        {DazGenesisVer::G81,"8_1"},
    };
    bool            isV1 = (ver == DazGenesisVer::G1);
    string          verStr = toStr(ver),
                    genderStr = isV1 ? "" : (female ? "Female" : "Male"),
                    genderChar = female ? "F" : "M",
                    morphRelDir = dazRelMorphDir(ver,female),
                    genFileBase = "Genesis" + fullVerStr[ver] + genderStr;
    string          parent = "/" + morphRelDir + genFileBase + ".dsf#",
                    modifierNodeId = "Genesis" + nodeIdVerStr[ver] + (isV1 ? "" : genderStr);
    String8         dd = dataDir() + "artist/daz/Genesis" + verStr + genderChar + "/";
    Mesh            dazShape = loadTri(dd+"allVerts_eyeSurfs.tri"),
                    fgShape = loadTri(dd+"fit_allVerts_eyeSurfs.tri");
    FGASSERT(dazShape.verts.size() == fgShape.verts.size());
    String8         ssmName = sphericalEyes ? "fit_allVerts.egm" : "fit_allVerts_eyeSurfs.egm";
    Ssm3            ssm(fgShape.verts,dd+ssmName);
    Vec3Fs          idShape = ssm.applyCoord(coord);
    Vec3Fs          dazEyeCentres = loadTri(dd+"eyeCentres.tri").verts;
    Ssm3            fgEyeCentres(dd+"fit_eyeCentres");
    Vec3Fs          eyeDeltas = fgEyeCentres.applyCoord(coord) - dazEyeCentres;
    Arr<Vec3F,2>    eyeCentreDeltas {eyeDeltas[0],eyeDeltas[1]};
    if (embossMesh) {
        // Must use a mesh with only face UVs for the emboss, or other head parts (eg. lacrimals)
        // with overlapping UV coordinates (for different maps) will get embossed:
        Mesh            fgShapeFace = loadTri(dd+"tex_face.tri");
        embossMesh(loadFim(dd+"tex_face.fim"),fgShapeFace);
        idShape += (fgShapeFace.verts - fgShape.verts);
    }
    IdxVec3Fs       morph;
    for (size_t ii=0; ii<idShape.size(); ++ii) {
        Vec3F           delta = idShape[ii] - dazShape.verts[ii];
        if (delta.magD() > 0.0f)
            morph.emplace_back(scast<uint>(ii),delta);
    }
    string          morphDir = morphRelDir + "Morphs/FaceGen/";
    createPath(contentDir+morphDir);
    dazSaveDsfMorphV6(contentDir,morphDir,controlName,parent,modifierNodeId,idShape.size(),morph,group,eyeCentreDeltas);
    if (baseMapNames.empty())
        return;
    // SCM takes all the time:
    if (fnUpdate && fnUpdate(true))
        return;
    Strings         bodyMapNames = dazGenesisBodyMapNames(ver);
    FGASSERT(baseMapNames.size() == bodyMapNames.size()+1);
    String8         outPath = contentDir+"Runtime/Textures/FaceGen/Genesis"+verStr+genderChar+"/"+controlName+"/";
    createPath(outPath);
    outPath += controlName + "_";
    Arr3D           colorFac = createFaceMap(dd+"tex_face",baseMapNames[0],outPath+"face",coord,detail,tattooImage);
    if (fnUpdate && fnUpdate(true))
        return;
    exportScmMap(dd+"tex_eyes",outPath+"eyes",coord,detail,ImgFormat::jpg);      // Don't support custom base for eyes
    for (size_t ii=0; ii<bodyMapNames.size(); ++ii) {
        if (fnUpdate && fnUpdate(true))
            return;
        createCustomBodyMap(baseMapNames[ii+1],colorFac,outPath+bodyMapNames[ii],ImgFormat::jpg);
    }
}
 
void                dazSaveDsfMorphV6G9(
    String8 const &         libPath,
    String8 const &         relPath,
    String8 const &         controlName,
    String8 const &         parent,
    size_t                  totNumVerts,
    IdxVec3Fs const &       morph,
    String8                 group,              // must begin with slash but not end with one
    Arr<Vec3F,2>            eyeCentreDeltas,    // 0 - left, 1 - right
    Arr<float,2>            eyeScaleDeltas)     // "
{
    String8         fname = libPath+relPath+controlName+".dsf";
    Ofstream        ofs {fname};
    String8         controlID = "FaceGen_"+controlName;
    // Spaces in PATHS are changed to '%20' to match files Daz produces, but spaces in just the names
    // (eg. modifier_library id/name) cannot contain '%' but can contain spaces, so leave those unchanged.
    // 'auto_follow' is for hairstyles (& clothing?) to follow new head shape.
    ofs.precision(7);
    ofs.setf(ios::fixed);
    ofs << R"({
    "file_version" : "0.6.0.0",
    "asset_info" : {
        "id" : "/)" << formatDsfPath(relPath+controlName) << R"(.dsf",
        "type" : "modifier",
        "contributor" : {
            "author" : "FaceGen",
            "email" : "",
            "website" : "https://facegen.com"
        },
        "revision" : "1.0",
        "modified" : ")" << dateTimeISO8601() << R"("
    },
    "modifier_library" : [
        {
            "id" : ")" << controlID << R"(",
            "name" : ")" << controlID << R"(",
            "parent" : ")" << parent << R"(",
            "presentation" : {
                "type" : "Modifier/Shape",
                "label" : "",
                "description" : "",
                "icon_large" : "",
                "colors" : [ [ 0.1568627, 0.1568627, 0.1568627 ], [ 1, 1, 1 ] ]
            },
            "channel" : {
                "id" : "value",
                "type" : "float",
                "name" : "Value",
                "label" : ")" << controlName << R"(",
                "value" : 0,
                "min" : 0,
                "max" : 1,
                "clamped" : true,
                "display_as_percent" : true,
                "step_size" : 0.01,
                "auto_follow" : true
            },
            "region" : "Head",
            "group" : ")" << group << R"(",
            "formulas" : [)";
    if (cMagD(eyeCentreDeltas) > 0) {
        Strings         coords {"x","y","z"};
        for (size_t ss=0; ss<2; ++ss) {
            String          eye = (ss==0) ? "l_eye" : "r_eye";
            for (uint dd=0; dd<3; ++dd) {
                ofs << R"(
                {
                    "output" : ")" << eye << ":/data/Daz%203D/Genesis%209/Base/Genesis9.dsf#" << eye << "?center_point/" << coords[dd] << R"(",
                    "operations" : [
                        { "op" : "push", "url" : "Genesis9:#)" << controlID << R"(?value" },
                        { "op" : "push", "val" : )" << eyeCentreDeltas[ss][dd] << R"( },
                        { "op" : "mult" }
                    ]
                },)";
                //if ((ss<1) || (dd<2))
                //    ofs << ",";
            }
        }
    }
    if (cMagD(eyeScaleDeltas) > 0) {
        for (size_t ss=0; ss<2; ++ss) {
            String          eye = (ss==0) ? "l_eye" : "r_eye";
            ofs << R"(
                {
                    "output" : ")" << eye << ":/data/Daz%203D/Genesis%209/Base/Genesis9.dsf#" << eye << R"(?scale/general",
                    "operations" : [
                        { "op" : "push", "url" : "Genesis9:#)" << controlID << R"(?value" },
                        { "op" : "push", "val" : )" << eyeScaleDeltas[ss] << R"( },
                        { "op" : "mult" }
                    ]
                })";
            if (ss==0)
                ofs << ",";
        }
    }
    ofs << R"(
            ],
            "morph" : {
                "vertex_count" : )" << totNumVerts << R"(,
                "deltas" : {
                    "count" : )" << morph.size() << R"(,
                    "values" : [
)"
        << morph[0];
    for (size_t ii=1; ii<morph.size(); ++ii)
        ofs << ",\n" << morph[ii];
    ofs << R"(
                    ]
                }
            }
        }
    ],
    "scene" : {
        "modifiers" : [
            {
                "id" : ")" << controlID << R"(-1",
                "url" : "#)" << controlID << R"("
            }
        ]
    }
})";
    fgout << fgnl << fname;
}
 
void                dazExportShapeG9(
    Sam3Coord const &   coord,
    String8 const &     contentDir,
    String8 const &     group,
    String8 const &     name,
    IdxVec3Fs const &   headDeltas)
{
    String8             dd = dataDir() + "artist/daz/Genesis9/";
    Arr<Vec3F,2>        eyeCentreDeltas;
    Arr<float,2>        eyeScaleDeltas;
    {
        Mesh                lmsMesh = loadMesh(dd+"lms.fgmesh");
        FaceLmPos3Fs        lmsBase = toFaceLmPoss(lmsMesh.markedVertsAsNameVecs());
        Ssm3                ssm {dd+"nrr-lms"};
        Vec3Fs              lmsTarg = ssm.applyCoord(coord);
        Arr<ScaleTrans3F,2> xfs = cEyesTransform(lmsBase,lmsTarg);
        Mesh                eyeL = loadMesh(dd+"eyeL.fgmesh"),
                            eyeR = loadMesh(dd+"eyeR.fgmesh");
        // eye similarity was tested as a morph but we now use Daz transform fields:
        //Vec3Fs              eyes = cat(mapMul(xfs[0],eyeL.verts),mapMul(xfs[1],eyeR.verts));    // verts are consecutive in order L,R
        //IdxVec3Fs           morph = toIndexedDeltaMorph(eyes-cat(eyeL.verts,eyeR.verts),0);
        //String8             relDir = "data/DAZ 3D/Genesis 9/Genesis 9 Eyes/Morphs/FaceGen/",
        //                    parent = "/data/Daz%203D/Genesis%209/Genesis%209%20Eyes/Genesis9Eyes.dsf#Genesis9Eyes-1";
        //createPath(contentDir+relDir);
        //dazSaveDsfMorphV6G9(contentDir,relDir,name,parent,eyes.size(),morph,group,{});
        for (size_t ss=0; ss<2; ++ss) {
            Mesh const &        eye = (ss==0) ? eyeL : eyeR;
            Vec3F               eyeCentreB = eye.joints[0].pos,
                                eyeCentreT = xfs[ss] * eyeCentreB;
            eyeCentreDeltas[ss] = eyeCentreT - eyeCentreB;
            eyeScaleDeltas[ss] = xfs[ss].scale - 1;
        }
    }
    {
        Vec3Fs              base = loadMesh(dd+"base.fgmesh").verts;
        size_t              V = base.size();
        Ssm3                ssm {dd+"nrr-base"};
        Vec3Fs              targ = cHead(ssm.applyCoord(coord),V);      // don't need allVerts, just vert list
        accDeltaMorph_(headDeltas,targ);
        IdxVec3Fs           morph = toIndexedDeltaMorph(targ-base,0);
        String8             relDir = "data/daz 3D/genesis 9/base/morphs/FaceGen/",
                            parent = "/data/Daz%203D/Genesis%209/Base/Genesis9.dsf#Genesis9-1";
        createPath(contentDir+relDir);
        dazSaveDsfMorphV6G9(contentDir,relDir,name,parent,V,morph,group,eyeCentreDeltas,eyeScaleDeltas);
    }
    {
        Vec3Fs              base = loadMesh(dd+"mouth.fgmesh").verts;
        size_t              V = base.size();
        Ssm3                ssm {dd+"nrr-mouth"};
        Vec3Fs              targ = cHead(ssm.applyCoord(coord),V);      // just vert list
        IdxVec3Fs           morph = toIndexedDeltaMorph(targ-base,0);
        String8             relDir = "data/DAZ 3D/Genesis 9/Genesis 9 Mouth/Morphs/FaceGen/",
                            parent = "/data/Daz%203D/Genesis%209/Genesis%209%20Mouth/Genesis9Mouth.dsf#Genesis9Mouth-1";
        createPath(contentDir+relDir);
        dazSaveDsfMorphV6G9(contentDir,relDir,name,parent,V,morph,group,{},{});
    }
}
 
Strings             dazGetMapPathsG9(String8 const & materialDuf,Strings const & parts)
{
    Strings             partSrcPaths (parts.size());                    // relative to content dir
    {   // load the DUF for the given G9 base material and extract the diffuse map paths for each part:
        Any                 duf = parseJson(loadRawString(materialDuf));
        JsonObject const &  obj = duf.ref<JsonObject>();
        Anys const &        lib = findFirst(obj,"image_library").val.as<Anys>();
        for (size_t ii=0; ii<lib.size(); ++ii) {
            Any const &         node = lib[ii];
            JsonObject const &  map = node.as<JsonObject>();
            String const &      id = findFirst(map,"id").val.as<String>();
            for (size_t pp=0; pp<parts.size(); ++pp) {
                String              ss = "_" + parts[pp] + "_D_";       // diffuse map for this part
                if (containsSubstr(id,ss)) {
                    Anys const &        mm = findFirst(map,"map").val.as<Anys>();
                    JsonObject const &  mo = mm.at(0).as<JsonObject>();
                    partSrcPaths[pp] = findFirst(mo,"url").val.as<String>();
                }
            }
        }
    }
    return partSrcPaths;
}
 
void                saveImagePrint(ImgRgba8 const & img,String8 const & fname)
{
    saveImage(img,fname);
    fgout << fgnl << fname;
};
void                copyFilePrint(String8 const & from,String8 const & to)
{
    copyFile(from,to,true);
    fgout << fgnl << to;
}
 
void                dazExportColorG9(
    Sam3Coord const &   coord,
    Bytes const &       detail,
    String8 const &     contentDir,
    String8s const &    baseMapPaths,
    String8 const &     group,         
    String8 const &     name,
    bool                adjustIray,
    WorkerCallback const & updateFn,
    TattooImage const & tattoo)
{
    FGASSERT(baseMapPaths.size() == 5);
    if (updateFn && updateFn(true))
        return;
    // create the modified diffuse color images:
    String8             imgRelDir = "Runtime/Textures/FaceGen/Genesis9/" + name + "/",
                        imgSaveDir = contentDir + imgRelDir;
    createPath(imgSaveDir);
    String8             ddg9 = dataDir()+"artist/daz/Genesis9/",
                        headPath = baseMapPaths[0];
    FGASSERT(!headPath.empty());
    String8             imgSaveDirBase = imgSaveDir + "Head";
    Arr3D const         irayFac = adjustIray ? Arr3D{1,1.2,1.2} : Arr3D{1,1,1};
    Arr3D               colorFac = createFaceMap(ddg9+"nrr-head",headPath,imgSaveDirBase,coord,detail,tattoo,irayFac);
    // make a copy for the SSS (simpler for user to modify, plus Daz has trouble using same soure file for 2 channels):
    copyFilePrint(imgSaveDirBase+".jpg",imgSaveDirBase+"-SSS.jpg");
    Strings             parts {"Head","Arms","Body","Legs"};        // first includes face
    for (size_t pp=1; pp<4; ++pp) {         // Arms, Body, Legs
        if (updateFn && updateFn(true))
            return;
        String              part = parts[pp];
        String8             baseMapPath = baseMapPaths[pp];
        FGASSERT(!baseMapPath.empty());
        //PushIndent              op {part};
        //Timer                   time;
        imgSaveDirBase = imgSaveDir+part;
        ImgRgba8                baseImg = loadImage(baseMapPath);
        ImgRgba8                adjImg = applyColorFac(baseImg,colorFac);
        saveImagePrint(adjImg,imgSaveDir+part+".jpg");
        copyFilePrint(imgSaveDirBase+".jpg",imgSaveDirBase+"-SSS.jpg");
        //time.report("Body load, shift, save");
    }
    if (updateFn && updateFn(true))
        return;
    //Timer               time;
    // get the iris color and adjust the Daz iris diffuse map:
    Sam3                sam {dataDir()+"photofit/si"};
    sam.transform(cIbfcsToHcsi());      // needed for thumbnail below
    sam.applyFace(Face3{coord,detail});
    ImgUC               fgIrisSample = toUC(loadImage(dataDir()+"photofit/si-iris-sample.png")),
                        g9IrisRegion = toUC(loadImage(ddg9+"eyes-iris-region.png"));
    ImgRgba8            g9EyesMap = loadImage(baseMapPaths[4]);     // daz eyes base
    Arr3D               clrFg = sampleColor(sam.mesh.surfaces[0].albedoMapRef(),fgIrisSample),
                        clrFgAdj = mapMul(clrFg,irayFac),
                        clrG9 = sampleColor(g9EyesMap,g9IrisRegion),
                        clrDel = clrFgAdj-clrG9;
    shiftColor_(clrDel,g9IrisRegion,g9EyesMap);
    saveImagePrint(g9EyesMap,imgSaveDir+"Eyes.jpg");
    //time.report("Eyes");
    // create the DUF that points to the images:
    String8             dufRelPathBase = "People/Genesis 9/Materials" + group + "/" + name;
    JsonObject          contributor {
        {"author",Any{String{"FaceGen"}}},
        {"email",Any{String{}}},
        {"website",Any{String{"FaceGen.com"}}},
    };
    JsonObject          asset_info {
        {"id",Any{"/"+encodeUrl(dufRelPathBase)+".duf"}},
        {"type",Any{String{"preset_material"}}},
        {"contributor",Any{contributor}},
        {"revision",Any{String{"1.0"}}},
        {"modified",Any{getDateTimeString()}},
    };
    Anys                image_library;
    String              idBase = "FG-G9-" + encodeUrl(name) + "-";
    auto                addImageFn = [&](String const & part)
    {
        String              id = idBase + part,
                            url = "/" + encodeUrl(imgRelDir + part + ".jpg");
        JsonObject          ul {
            {"url",Any{url}},
            {"label",Any{id}},
        };
        JsonObject          ile {
            {"id",Any{id}},
            {"name",Any{id}},
            {"map_gamma",Any{0.0}},
            {"map",Any{Anys{Any{ul}}}},
        };
        image_library.push_back(Any{ile});
    };
    for (String const & part : parts) {
        addImageFn(part);
        addImageFn(part+"-SSS");
    }
    addImageFn("Eyes");
    Anys                animations;
    auto                addLinkFn = [&](String const & partRef,String const & imgName)
    {
        String              url = "name://@selection#materials/" + partRef + "/image_file",   // NOT URL encoded
                            path = "/" + encodeUrl(imgRelDir+imgName+".jpg");
        Any                 key {Anys{Any{0.0},Any{path}}};
        Anys                keys {key,};
        JsonObject          anim {
            {"url",Any{url}},
            {"keys",Any{keys}},
        };
        animations.push_back(Any{anim});
    };
    for (String const & part : parts) {
        addLinkFn(part+":?diffuse",part);                                                               // link diffuse reflectance
        addLinkFn(part+":?extra/studio_material_channels/channels/Translucency%20Color",part+"-SSS");   // link diffuse SSS
    }
    addLinkFn("Eye%20Left:?diffuse","Eyes");
    addLinkFn("Eye%20Right:?diffuse","Eyes");
    JsonObject          scene {
        {"animations",Any{animations}},
    };
    JsonObject          duf {
        {"file_version",Any{String{"0.6.1.0"}}},
        {"asset_info",Any{asset_info}},
        {"image_library",Any{image_library}},
        {"scene",Any{scene}},
    };
    createPath(contentDir+dufRelPathBase);
    {
        String8             fname = contentDir+dufRelPathBase+".duf";
        saveRaw(writeJson(Any{duf}),fname);
        fgout << fgnl << fname;
    }
    // create the thumbnail for the DUF:
    ImgRgba8            thumb = renderSoft({91U,91U},{sam.mesh},{0,0,0,1});
    saveImagePrint(thumb,contentDir+dufRelPathBase+".png");
}
 
}
 
// */