Fg3Face.hpp

//
// Copyright (c) Singular Inversions Inc. 2012
//
// Authors:     Andrew Beatty
// Created:     Feb 16, 2012
//
 
#ifndef FG3FACE_HPP
#define FG3FACE_HPP
 
#include "FgSerial.hpp"
#include "FgImage.hpp"
 
namespace Fg {
 
typedef enum
{
        FANTYPE_GEO = 0,
        FANTYPE_TEX,
        FANTYPE_SIZE
}       FanTypeE;
 
extern Strings   fg3ModeTypeStrs;
 
typedef enum
{
        FANSYMM_SYMM = 0,
        FANSYMM_ASYM,
        FANSYMM_SIZE
}       FanSymmE;
 
extern Strings   fg3ModeSymmStrs;
 
struct      Sam3Coord
{
    Mat<Floats,2,2>     crd {Floats(50,0),Floats(30,0),Floats(50,0),Floats(),};
    FG_SER1(crd)
 
    Sam3Coord() {};
    explicit Sam3Coord(Floats const & coord);
    explicit Sam3Coord(Doubles const & coord);
    // Components can be of arbitrary dimensions:
    explicit Sam3Coord(Mat<Floats,2,2> const & m) : crd{m} {}
 
    static Mat22UI      dims;
 
    bool                valid() const;      // Ensure dimensions are a valid FG coord
    Floats const &      ts(uint type,uint symm) const {return crd.rc(type,symm); }
    Floats &            ts(uint type,uint symm) {return crd.rc(type,symm); }
    Sam3Coord           operator*(float f) const {return Sam3Coord{{crd[0]*f,crd[1]*f,crd[2]*f,crd[3]*f,}}; }
    inline Sam3Coord    operator+(const Sam3Coord & rhs) const {return Sam3Coord{crd+rhs.crd}; }
    inline Sam3Coord    operator-(const Sam3Coord & rhs) const {return Sam3Coord{crd-rhs.crd}; }
    inline size_t       getVectorDim() const {return crd[0].size()+crd[1].size()+crd[2].size()+crd[3].size(); }
    inline Floats       getVector() const {return cat(crd[0],crd[1],crd[2],crd[3]); }
    void                setVector(Floats const & coord);
    inline bool         operator==(const Sam3Coord & rhs) const {return (crd == rhs.crd); }
};
 
std::ostream &      operator<<(std::ostream &,Sam3Coord const &);
inline double       cMagD(Sam3Coord const & sc) {return cMagD(sc.crd); }
 
// Linear inpolation (aka 'tween') between 2 face coordinates:
Sam3Coord           interpolate(
    Sam3Coord const &   coord0,
    Sam3Coord const &   coord1,
    float               param);     // 0: 'coord0', 1: 'coord1'
 
struct      Face3
{
    Sam3Coord           coord;
    Bytes               detail;
    FG_SER2(coord,detail)
 
    Face3() {}
    explicit Face3(Sam3Coord const & c) : coord(c) {}
    Face3(Sam3Coord const & c,Bytes const & d) : coord(c), detail(d) {}
    explicit Face3(String8 const & filename_fg);
 
    void                load(String8 const & filename_fg);
    void                save(String8 const & filename_fg) const;
    void                getDetail(ImgRgba8 & img) const;
    bool                operator==(const Face3 & rhs) const
    {return ((coord == rhs.coord) && (detail == rhs.detail)); }
};
 
typedef Svec<Face3>     Face3s;
 
std::ostream &      operator<<(std::ostream &,Face3 const &);
 
inline Face3        loadFg(String8 const & filename)
{
    Face3         ret;
    ret.load(filename);
    return ret;
}
 
inline void         saveFg(Face3 const & face,String8 const & fname) {face.save(fname); }
 
}
 
#endif