FgApplyDna.cpp

//
// Copyright (c) Singular Inversions Inc. 2014
//
// Authors: Andrew Beatty
// Created: Jan 2, 2014
//
 
#include "stdafx.h"
 
#include "FgApply.hpp"
#include "FgMain.hpp"
#include "FgTestUtils.hpp"
#include "FgBuild.hpp"
#include "Fg3Face.hpp"
#include "Fg3dMeshIo.hpp"
#include "Fg3Sam.hpp"
#include "Fg3Freeform.hpp"
#include "FgParse.hpp"
#include "FgApply.hpp"
#include "Fg3dDisplay.hpp"
 
using namespace std;
 
namespace Fg {
 
namespace {
 
void                endianFlip_(uint16 & v)
{
    uchar               *ptr = reinterpret_cast<uchar*>(&v);
    swap(ptr[0],ptr[1]);
}
void                endianFlip_(uint32 & v)
{
    uchar               *ptr = reinterpret_cast<uchar*>(&v);
    swap(ptr[0],ptr[3]);
    swap(ptr[1],ptr[2]);
}
void                endianFlip_(float & v)
{
    uchar               *ptr = reinterpret_cast<uchar*>(&v);
    swap(ptr[0],ptr[3]);
    swap(ptr[1],ptr[2]);
}
template<typename T>
inline T            endianFlip(T v) {endianFlip_(v); return v; }
 
struct              DnaSectionLookup
{
    uint32              descriptor;
    uint32              definition;
    uint32              behavior;
    uint32              controls;
    uint32              joints;
    uint32              blendShapeChannels;
    uint32              animateMaps;
    uint32              geometry;
};
 
void                checkSig_(Bytes const & blob,size_t & pos)
{
    Arr3UC              sig = dsrlzT_<Arr3UC>(blob,pos);
    if (sig != Arr3UC{'D','N','A'})
        fgThrow("not a DNA file");
    uint16              verMaj = endianFlip(dsrlzT_<uint16>(blob,pos)),
                        verMin = endianFlip(dsrlzT_<uint16>(blob,pos));
    if (verMaj != 2)
        fgThrow("unsupported DNA file major version",toStr(verMaj));
    if (verMin != 1)
        fgWarn("unsupported DNA file minor versino",toStr(verMin));
}
 
template<typename T>
T                   get_(Bytes const & blob,size_t & pos) {return endianFlip(dsrlzT_<T>(blob,pos)); }
 
template<typename T>
Uints               gets_(Bytes const & blob,size_t & pos)
{
    size_t              sz = get_<uint32>(blob,pos);
    Uints               ret; ret.reserve(sz);
    for (size_t ii=0; ii<sz; ++ii)
        ret.push_back(get_<T>(blob,pos));
    return ret;
}
 
DnaSectionLookup    getDsl(Bytes const & blob,size_t & pos)
{
    auto                get32 = [&](){return get_<uint32>(blob,pos); };
    DnaSectionLookup    dsl;
    dsl.descriptor = get32();
    dsl.definition = get32();
    dsl.behavior = get32();
    dsl.controls = get32();
    dsl.joints = get32();
    dsl.blendShapeChannels = get32();
    dsl.animateMaps = get32();
    dsl.geometry = get32();
    return dsl;
}
 
Vec2Fs              getVec2Fs_(Bytes const & blob,size_t & pos)
{
    uint32              sz = get_<uint32>(blob,pos);    // number of X values
    Vec2Fs              vecs (sz);
    for (size_t vv=0; vv<sz; ++vv)
        vecs[vv][0] = get_<float>(blob,pos);            // read X values
    FGASSERT(get_<uint32>(blob,pos) == sz);             // number of Y values
    for (size_t vv=0; vv<sz; ++vv)
        vecs[vv][1] = get_<float>(blob,pos);            // read Y values
    return vecs;
};
 
Vec3Fs              getVec3Fs_(Bytes const & blob,size_t & pos) // as above
{
    auto                get32 = [&](){return get_<uint32>(blob,pos); };
    auto                getFlt = [&](){return get_<float>(blob,pos); };
    uint32              sz = get32();
    Vec3Fs              vecs (sz);
    for (size_t vv=0; vv<sz; ++vv)
        vecs[vv][0] = getFlt();
    FGASSERT(get32() == sz);
    for (size_t vv=0; vv<sz; ++vv)
        vecs[vv][1] = getFlt();
    FGASSERT(get32() == sz);
    for (size_t vv=0; vv<sz; ++vv)
        vecs[vv][2] = getFlt();
    return vecs;
};
 
}
 
// DNA format from ~MetaHuman-DNA-Calibration/dnacalib/DNACalib/src/dna/DNA.h
Meshes              dnaImport(Bytes const & blob)
{
    Meshes              ret;
    size_t              pos {0};
    checkSig_(blob,pos);
    auto                get16 = [&](){return get_<uint16>(blob,pos); };
    auto                get32 = [&](){return get_<uint32>(blob,pos); };
    auto                get16s = [&](){return gets_<uint16>(blob,pos); };
    auto                get32s = [&](){return gets_<uint32>(blob,pos); };
    auto                getVec2Fs = [&](){return getVec2Fs_(blob,pos); };
    auto                getVec3Fs = [&](){return getVec3Fs_(blob,pos); };
    auto                getVertInds = [&](Vec3UIs & tris,Vec4UIs & quads)
    {
        uint32              sz = get32();
        for (size_t ii=0; ii<sz; ++ii) {
            uint32              len = get32();
            if (len == 3) {
                Vec3UI              v;
                for (size_t jj=0; jj<3; ++jj)
                    v[jj] = get32();
                tris.push_back(v);
            }
            else if (len == 4) {
                Vec4UI              v;
                for (size_t jj=0; jj<4; ++jj)
                    v[jj] = get32();
                quads.push_back(v);
            }
            else
                fgThrow("unhandled polygon size",toStr(len));
        }
    };
    auto                getLodInds = [&]()
    {
        Uints               lods = get16s();
        size_t              sz = get32();
        Uintss              ret (sz);
        for (Uints & row : ret)
            row = get16s();
        return ret;
    };
    auto                getStrings = [&]()
    {
        size_t              sz = get32();
        Strings             ret (sz);
        for (String & str : ret) {
            size_t              ss = get32();
            FGASSERT(pos+ss <= blob.size());
            str = String{reinterpret_cast<char const *>(&blob[pos]),ss};
            pos += ss;
        }
        return ret;
    };
    DnaSectionLookup    dsl = getDsl(blob,pos);
    pos = dsl.definition;
    // for each LOD, the list of indices into the given data list:
    Uintss              jointLodInds = getLodInds(),
                        blendLodInds = getLodInds(),
                        animLodInds = getLodInds(),
                        meshLodInds = getLodInds();
    Strings             guiControlNames = getStrings(),
                        rawControlNames = getStrings(),
                        jointNames = getStrings(),
                        blendShapeChannelNames = getStrings(),
                        animatedMapNames = getStrings(),
                        meshNames = getStrings();
    pos = dsl.geometry;     // skip ahead to geometry (also skips marker at beginning of geometry)
    uint32              numMeshes = get32();
    FGASSERT(numMeshes == meshNames.size());
    for (size_t mm=0; mm<numMeshes; ++mm) {
        uint32              offset = get32();           // offset to next mesh or record
        Vec3Fs              verts = getVec3Fs();
        Vec2Fs              uvs = getVec2Fs();
        Vec3Fs              norms = getVec3Fs();
        Uints               vertList = get32s(),        // indices into 'verts'
                            uvList = get32s(),          // indices into 'uvs'
                            normList = get32s();        // indices into 'norms'
        size_t              listSz = vertList.size();
        FGASSERT(uvList.size() == listSz);
        FGASSERT(normList.size() == listSz);
        Vec3UIs             triInds;        // indices into 'vertList', 'uvList' and 'normList' for each tri
        Vec4UIs             quadInds;       // indices into 'vertList', 'uvList' and 'normList' for each quad
        getVertInds(triInds,quadInds);
        /*ushort              maxInfluence =*/ get16();
 
        TriInds             tInds; tInds.reserve(triInds.size());
        for (Vec3UI tri : triInds) {
            tInds.vertInds.emplace_back(vertList[tri[0]],vertList[tri[1]],vertList[tri[2]]);
            tInds.uvInds.emplace_back(uvList[tri[0]],uvList[tri[1]],uvList[tri[2]]);
        }
        QuadInds            qInds; qInds.reserve(quadInds.size());
        for (Vec4UI q : quadInds) {
            qInds.vertInds.emplace_back(vertList[q[0]],vertList[q[1]],vertList[q[2]],vertList[q[3]]);
            qInds.uvInds.emplace_back(uvList[q[0]],uvList[q[1]],uvList[q[2]],uvList[q[3]]);
        }
        Strings             names = splitChar(meshNames[mm],'_');
        String              name = names[1] + '-' + names[0];
        ret.push_back(Mesh{name,verts,uvs,{Surf{tInds,qInds}}});     // emplace_back doesn't like optional args
        pos = offset;   // jump to next mesh
    }
    return ret;
}
 
void                dnaInject_(Vec3Fss const & shapes,Bytes & blob)
{
    size_t              pos {0};
    checkSig_(blob,pos);
    auto                get32 = [&](){return get_<uint32>(blob,pos); };
    DnaSectionLookup    dsl = getDsl(blob,pos);
    pos = dsl.geometry;
    uint32              numMeshes = get32();
    if (numMeshes != shapes.size())
        fgThrow("number of vertex lists to inject differ from dna mesh count",toStr(shapes.size())+"!="+toStr(numMeshes));
    for (size_t mm=0; mm<numMeshes; ++mm) {
        Vec3Fs const &      shape = shapes[mm];
        uint32              offset = get32();           // offset to next mesh or record
        for (uint jj=0; jj<3; ++jj) {
            uint32              sz = get32();
            if (sz != shape.size())
                fgThrow("vertex count differs for mesh",toStr(mm));
            for (size_t vv=0; vv<sz; ++vv) {
                float               v = shape[vv][jj];
                byte                *ptr = reinterpret_cast<byte*>(&v);
                swap(ptr[0],ptr[3]);
                swap(ptr[1],ptr[2]);
                memcpy(&blob[pos],ptr,4);
                pos += 4;
            }
        }
        pos = offset;                                   // move to next mesh
    }
}
 
}