xskinmesh.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
/*
 * Based on skin and mesh code from Wine sources.
 * Copyright (C) 2005 Henri Verbeet
 * Copyright (C) 2006 Ivan Gyurdiev
 * Copyright (C) 2009 David Adam
 * Copyright (C) 2010 Tony Wasserka
 * Copyright (C) 2011 Dylan Smith
 * Copyright (C) 2011 Michael Mc Donnell
 * Copyright (C) 2013 Christian Costa
 */
 
#ifndef WINTERMUTE_XSKINMESH_H
#define WINTERMUTE_XSKINMESH_H
 
#include "engines/wintermute/base/gfx/xbuffer.h"
#include "engines/wintermute/base/gfx/xfile_loader.h"
#include "engines/wintermute/base/gfx/xmath.h"
 
namespace Wintermute {
 
#define DXFVF_XYZ             0x0002
#define DXFVF_NORMAL          0x0010
#define DXFVF_DIFFUSE         0x0040
#define DXFVF_TEX1            0x0100
 
typedef enum {
    DXDECLUSAGE_NORMAL        = 3,
    DXDECLUSAGE_TEXCOORD      = 5,
    DXDECLUSAGE_TANGENT       = 6,
    DXDECLUSAGE_BINORMAL      = 7,
} DXDECLUSAGE;
 
typedef enum {
    DXDECLTYPE_FLOAT2         =  1,
    DXDECLTYPE_FLOAT3         =  2,
} DXDECLTYPE;
 
#if defined(SCUMMVM_USE_PRAGMA_PACK)
#pragma pack(4)
#endif
 
struct DXAttributeRange {
    uint32 _attribId;
    uint32 _faceStart;
    uint32 _faceCount;
    uint32 _vertexStart;
    uint32 _vertexCount;
};
 
struct DXAttributeRangeTable {
    uint32 _size;
    DXAttributeRange *_ptr;
};
 
typedef union {
    struct {
        float _r;
        float _g;
        float _b;
        float _a;
    } color;
    float _data[4];
} DXColorValue;
 
typedef struct {
    DXColorValue   _diffuse;
    DXColorValue   _ambient;
    DXColorValue   _specular;
    DXColorValue   _emissive;
    float          _power;
    char           _textureFilename[XMAX_NAME_LEN];
} DXMaterial;
 
struct DXBone {
    char *_name;
    DXMatrix _transform;
    uint32 _numInfluences;
    uint32 *_vertices;
    float *_weights;
};
 
#if defined(SCUMMVM_USE_PRAGMA_PACK)
#pragma pack()
#endif
 
class DXSkinInfo {
    uint32 _fvf{};
    uint32 _numVertices{};
    uint32 _numBones{};
    DXBone *_bones{};
 
public:
    ~DXSkinInfo() { destroy(); }
    bool create(uint32 vertexCount, uint32 fvf, uint32 boneCount);
    void destroy();
    uint32 getNumBones() { return _numBones; }
    bool setBoneName(uint32 boneIdx, const char *name);
    char *getBoneName(uint32 boneIdx) { return _bones[boneIdx]._name; }
    bool setBoneInfluence(uint32 boneIdx, uint32 numInfluences, const uint32 *vertices, const float *weights);
    DXBone *getBone(uint32 boneIdx);
    bool setBoneOffsetMatrix(uint32 boneIdx, const float *boneTransform);
    DXMatrix *getBoneOffsetMatrix(uint32 boneIdx) { return &_bones[boneIdx]._transform; }
    bool updateSkinnedMesh(const DXMatrix *boneTransforms, void *srcVertices, void *dstVertices);
};
 
class DXMesh {
    uint32 _numFaces;
    uint32 _numVertices;
    uint32 _fvf;
    uint32 _vertexSize;
    DXBuffer _vertexBuffer;
    DXBuffer _indexBuffer;
    DXBuffer _attribBuffer;
    DXAttributeRangeTable _attribTable;
 
    struct DXVertexMetadata {
        float _key;
        uint32 _vertexIndex;
        uint32 _firstSharedIndex;
    };
 
    static int compareVertexKeys(const void *a, const void *b);
 
public:
    ~DXMesh() { destroy(); }
    bool create(uint32 numFaces, uint32 numVertices, uint32 fvf);
    void destroy();
    bool cloneMesh(DXMesh **cloneMeshOut);
    uint32 getNumFaces() { return _numFaces; }
    uint32 getNumVertices() { return _numVertices; }
    uint32 getFVF() { return _fvf; }
    DXBuffer getVertexBuffer() { return _vertexBuffer; }
    DXBuffer getIndexBuffer() { return _indexBuffer; }
    DXBuffer getAtribBuffer() { return _attribBuffer; }
    DXAttributeRangeTable *getAttributeTable() { return &_attribTable; }
    bool generateAdjacency(uint32 *adjacency);
};
 
bool DXLoadSkinMesh(XFileData *fileData, DXBuffer &materialsOut, uint32 &numMaterialsOut, DXSkinInfo **skinInfoOut, DXMesh **meshOut);
uint32 DXGetFVFVertexSize(uint32 fvf);
bool DXComputeBoundingBox(DXVector3 *pfirstposition, uint32 numvertices, uint32 dwstride, DXVector3 *pmin, DXVector3 *pmax);
 
} // namespace Wintermute
 
#endif