t3d.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/>.
 *
 */

#ifndef WATCHMAKER_T3D_H
#define WATCHMAKER_T3D_H

#include "common/array.h"
#include "common/stream.h"
#include "watchmaker/render.h"
#include "watchmaker/types.h"
#include "watchmaker/3d/types3d.h"

namespace Watchmaker {

//************************************************************************************************************************
//  defines
//************************************************************************************************************************

#define T3D_PI                              3.14159265358979323846f
#define T3D_2PI                             (3.14159265358979323846f*2.0f)
#define DEGREE_TO_RADIANS(x)                ((x)*T3D_PI/180.0f)
#define RADIANS_TO_DEGREE(x)                ((x)*180.0f/T3D_PI)

#define T3D_NAMELEN                         32          // default name len
#define T3D_MAX_LEVELS                      5           // max bounds level per room
#define T3D_MAX_PATHNODES                   1000        // max path nodes per walk
#define T3D_MAX_WALKSTEPS                   4000        // max walk steps per walk
#define T3D_MAX_BLOCK_MESHES                3           // max block meshes per room
#define T3D_MAX_CHARACTERS                  26          // max characters
#define T3D_MAX_SHADOWBOX_PER_CHAR          10          // max shadow box per character

// Normal Array Define; used in flag field
#define T3D_NORMAL_INVISIBLE                (1<<0)      // invisible
#define T3D_NORMAL_VISIBLE                  (1<<1)      // visible

//Matrices flags
#define T3D_MATRIX_IDENTITY                 (1<<0)      // is identical

//Faces flags - additional to T3D_MATERIAL_FLAGS
#define T3D_FACE_VISIBLE                    (1<<13)     // is visiuble
#define T3D_FACE_CASTSHADOWS                (1<<14)     // cast shadows
#define T3D_FACE_RECEIVESHADOWS             (1<<15)     // receive shadows

//Mesh flags
#define T3D_MESH_CASTSHADOWS                (1<<0)      // Mesh cast shadow
#define T3D_MESH_RECEIVESHADOWS             (1<<1)      // Mesh receive shadows
#define T3D_MESH_NOLIGHTMAP                 (1<<2)      // Mesh without lightmap
#define T3D_MESH_VISIBLE                    (1<<3)      // Mesh visible
#define T3D_MESH_NOBOUNDBOX                 (1<<4)      // Disable BoundBox check
#define T3D_MESH_NOPORTALCHECK              (1<<5)      // Disable Portal check
#define T3D_MESH_HIDDEN                     (1<<6)      // Mesh Hidden
#define T3D_MESH_DEFAULTANIM                (1<<7)      // if takes animartions from the default set
#define T3D_MESH_CHARACTER                  (1<<8)      // set if mesh is part of a character
#define T3D_MESH_PORTAL                     (1<<9)      // mesh is a portal
#define T3D_MESH_MIRROR                     (1<<10)     // mesh is a mirror
#define T3D_MESH_INVISIBLEFROMSECT          (1<<11)     // mesh is VISIBLE form the current sector
#define T3D_MESH_RAYBAN                     (1<<12)     // mesh reject ray detection
#define T3D_MESH_ABS_ANIM                   (1<<13)     // se animazione e' assoluta o relativa
#define T3D_MESH_LAST_DEFAULTANIM           (1<<14)     // if last frame was DEFAULTANIM
#define T3D_MESH_RECEIVERIPPLES             (1<<15)     // Mesh accepts ripples on it's material texture
#define T3D_MESH_WAVESTEXTURE               (1<<16)     // Waves textures on all the material textures
#define T3D_MESH_POOLWATER                  (1<<17)     // Mesh accepts swimming pool water fx
#define T3D_MESH_PREPROCESSPORTAL           (1<<18)     // Preprocess portal for mesh visibilities
#define T3D_MESH_CASTREALTIMESHADOWS        (1<<19)     // Mesh calc realtime shadows using shadows-volumes
#define T3D_MESH_UPDATEVB                   (1<<20)     // needs to update materail VB
#define T3D_MESH_ONLYINMIRRORS              (1<<21)     // appears only in mirrors
#define T3D_MESH_VIEWONLYPORTAL             (1<<22)     // if it's a View Only portal
#define T3D_MESH_PORTALPROCESSED            (1<<23)     // if it was just processed by another portal
#define T3D_MESH_ALWAYSVISIBLE              (1<<24)     // if this mesh is always visible
#define T3D_MESH_SOLARVARIATION             (1<<25)     // if change when sun moves

//Light flags
#define T3D_LIGHT_SPOTLIGHT                 (1<<0)      // is a spot
#define T3D_LIGHT_LIGHTON                   (1<<1)      // light is on
#define T3D_LIGHT_ATTENUATION               (1<<2)      // is attenuated
#define T3D_LIGHT_CASTSHADOWS               (1<<3)      // cast shadows
#define T3D_LIGHT_PULSE                     (1<<4)      // is flicking
#define T3D_LIGHT_ALLLIGHTSOFF              (1<<5)      // turn off all the lights in the room
#define T3D_LIGHT_FLARE                     (1<<6)      // is a flare
#define T3D_LIGHT_CANDLESMOKE               (1<<7)      // light from a moving candle
#define T3D_LIGHT_REALTIME                  (1<<8)      // affects realtime objects
#define T3D_LIGHT_SUN                       (1<<9)      // if it's the sunlight position
#define T3D_LIGHT_SOLARVARIATION            (1<<10)     // if change when sun moves
#define T3D_LIGHT_OFF_MORNING               (1<<11)     // disable during the morning
#define T3D_LIGHT_OFF_AFTERNOON             (1<<12)     // disable during the afternoon
#define T3D_LIGHT_OFF_EVENING               (1<<13)     // disable during the evening
#define T3D_LIGHT_OFF_NIGHT                 (1<<14)     // disable during the night

// Character flags
#define T3D_CHARACTER_HIDE                  (1<<0)      // is hidden
#define T3D_CHARACTER_ENABLEDINMIRROR       (1<<1)      // is in first person but enabled in the mirror
#define T3D_CHARACTER_CASTREALTIMESHADOWS   (1<<2)      // cast real time shadows
#define T3D_CHARACTER_REALTIMELIGHTING      (1<<3)      // needs realtime lighting
#define T3D_CHARACTER_VOLUMETRICLIGHTING    (1<<4)      // needs realtime volumetric lighting
#define T3D_CHARACTER_BNDHIDE               (1<<5)      // don't use char BND
#define T3D_CHARACTER_DIARYDISABLE          (1<<6)      // diable diary

struct t3dM3X3F {
    t3dF32  M[9] = {};                           // Matrix 3 x 3
    uint8   Flags = 0;                          // flags: if identity
    constexpr t3dM3X3F() = default;
};

struct t3dBONE {
    t3dM3X3F    *Matrix = nullptr;            // matrix list
    t3dV3F      *Trasl = nullptr;             // traslation list
    Common::Array<int32> ModVertices;       // modified vertices list
};

struct t3dBONEANIM {
    t3dBONE     *BoneTable = nullptr;           // bones list
    t3dF32      *Dist = nullptr;                // distanca form start frame (for walk and default)
    uint16      NumBones = 0;                   // num bones
    uint16      NumFrames = 0;                  // num frames

    t3dBONEANIM() = default;
    t3dBONEANIM(const t3dBONEANIM &other) = default;
    t3dBONEANIM& operator=(const t3dBONEANIM &rhs) = default;
    t3dBONEANIM(t3dBONEANIM &&old) :
        BoneTable(old.BoneTable),
        Dist(old.Dist),
        NumBones(old.NumBones),
        NumFrames(old.NumFrames) {

        old.BoneTable = nullptr;
        old.Dist = nullptr;
        old.NumBones = 0;
        old.NumFrames = 0;
    }
};

struct t3dMODVERTS {
    uint16  NumVert = 0;                    // vertex indices in mesh
    uint16  NumBone = 0;                    // modified by bone number
    t3dMODVERTS(Common::SeekableReadStream &stream) {
        NumVert = stream.readSint32LE();
        NumBone = stream.readSint32LE();
    }
};

struct t3dMORPH {
    struct t3dMORPHVERT {
        uint32 _index = 0;                      // vertex indices in mesh
        t3dV3F _v;                              // new vertex coords
        t3dMORPHVERT(Common::SeekableReadStream &stream) {
            _index = (uint32)stream.readSint16LE();  // Legge indice vertice
            _v = t3dV3F(stream);          // legge nuova posizione
        }
    };

    Common::Array<t3dMORPHVERT>    _morphModVertices;  // morph verteices list
    t3dMORPH(Common::SeekableReadStream &stream) {
        int morphNumModVertices = stream.readSint16LE();                    // Legge e alloca numero vertici che si muovono
        _morphModVertices.reserve(morphNumModVertices);
        if (morphNumModVertices) {
            for (int j = 0; j < morphNumModVertices; j++) {
                _morphModVertices.push_back(t3dMORPHVERT(stream));
            }
        }
    }
};

struct t3dVERTEX {
    t3dV3F  p;                              // Coordinate vertice in Obj-space  12
    uint8   r = 0;                          // Preilluminazione R vertice       1
    uint8   g = 0;                          // Preilluminazione G vertice       1
    uint8   b = 0;                          // Preilluminazione B vertice       1   15
};

struct t3dPathCamera {
    uint8   PathIndex = 0;                  // path number in room
    uint8   NumCamera = 0;                  // num destination camera
    int8   Direction = 0;                  // path direction: source->dest or dest->source
public:
    explicit t3dPathCamera(Common::SeekableReadStream &stream);
};

struct t3dCAMERAGRID {
    t3dV3F  TopLeft, BottomRight;           // world coords of camera grid
    uint16  Row = 0, Col = 0;               // number of cells
    t3dV3F  CellDim;                        // cell dimensiom
    Common::Array<uint8>   Grid;              // grid
};

struct t3dCAMERAPATH {
    uint16  NumPoints() {
        return PList.size();    // num points in path
    }
    Common::Array<t3dV3F>  PList;                    // points list
    uint32  CarrelloDist = 0;                      // if carrello: max distance from the target
public:
    explicit t3dCAMERAPATH(Common::SeekableReadStream &stream);
};

struct t3dCAMERA {
    t3dV3F      Source;                       // camera eye
    t3dV3F      Target;                       // camera target
    t3dV3F      MaxTarget;                    // original 3dsmax target
    t3dV3F      NormalizedDir;                // cam direction
    t3dF32      Fov;                          // cam field of view
    t3dV2F      Center;                       // cam center
    t3dM3X3F    Matrix;                       // cam view matrix
    t3dF32      NearClipPlane, FarClipPlane;  // camera planes
    uint8       Index;                        // cam index 9in room
    Common::Array<t3dPathCamera> CameraPaths;

    uint8 NumAvailablePaths() const {
        return CameraPaths.size();
    }

public:
    t3dCAMERA() {
        reset();
    }

    explicit t3dCAMERA(Common::SeekableReadStream &stream);

    void reset() {
        Source = t3dV3F();
        Target = t3dV3F();
        MaxTarget = t3dV3F();
        NormalizedDir = t3dV3F();
        Fov = 0.0f;
        Center = t3dV2F();
        Matrix = t3dM3X3F();
        NearClipPlane = 0.0f, FarClipPlane = 0.0f;
        Index = 0;
        CameraPaths.clear();
    }

    void normalizedSight();
};

struct t3dVolLights {
    t3dF32  CellsSize = 0.0f;                   // cell cube dimension
    uint32  xcells = 0;                         // number of cells for x dir
    uint32  ycells = 0;                         // number of cells for y dir
    uint32  zcells = 0;                         // number of cells for z dir
    Common::Array<uint8>   VolMap;                // volumetric map
};

struct t3dBODY;

struct t3dParticle {
    uint16  ParticleIndex;
    uint16  Num;
    t3dF32  Lung;
    t3dF32  Size;
    t3dF32  Seg1;
    t3dF32  Seg2;
    t3dF32  Dim1;
    t3dF32  Dim2;
    t3dF32  Speed;
    t3dF32  Speed1;
    t3dF32  Speed2;
    t3dF32  Caos;
    t3dF32  Caos1;
    t3dF32  Caos2;
    uint32  Delay;
    uint8   OR1, Type;
    t3dF32  R1, G1, B1;
    t3dF32  R2, G2, B2;
    t3dF32  R3, G3, B3;
public:
    explicit t3dParticle(Common::SeekableReadStream &stream);
};

struct t3dAnimLight {
    Common::Array<gVertex *> VisVerts;        // pointer to visible vertices from lights
    uint16      NumVisVerts() const {
        return VisVerts.size();    // num visible vertices from lights
    }
    //t3dU32      *SavedLightColor;           // pointer to original vartex illumination
    int8       LastRandomizer;             // randomizer for flicker effects
};

struct t3dLIGHT {
    uint32      Type;                       // light type
    t3dV3F      Source;                     // source
    t3dV3F      Target;                     // target
    t3dF32      Multiplier;                 // light multiplier
    t3dF32      NearRange, FarRange;        // attenuation ranges
    t3dF32      HotSpot, FallOff;           // spot ranges
    t3dV3F      Color;                      // orig color
    uint8       Flicker;                    // flicker activated
    uint8       FlickerDelay = 0;           // flicker delay
    int8       LightRandomizer = 0;         // flicker randomizer
    Common::SharedPtr<t3dParticle> Particle;  // paticles attached
    t3dF32      FlareSize = 0;              // flare size
    gMaterial   Material[2];                // flare material
    t3dAnimLight AnimLight;                 // animation attached
    t3dV3F      SolarColor[4];              // Ambient color value for solar movement
    t3dV3F      SolarPos[4];                // Position movements due to solar movement
public:
    t3dLIGHT(WGame &game, t3dBODY *b, WorkDirs &workDirs, Common::SeekableReadStream &stream);
private:
    void setupVisibleVerticesFromLight(t3dBODY *b);
    void SetVisibleFromLight(gVertex *v);
};
typedef t3dLIGHT *LightPtr;

struct t3dPLIGHT {
    uint8   Num = 0;                        // index positional light in room
    t3dV3F  Pos;                            // position (world)
    t3dV3F  Dir;                            // destination (world)
public:
    explicit t3dPLIGHT(Common::SeekableReadStream &stream);
};

struct PointXZ {
    float x = 0.0f, z = 0.0f;
    static PointXZ readFromStream(Common::SeekableReadStream &stream) {
        PointXZ result;
        result.x = stream.readFloatLE();
        result.z = stream.readFloatLE();
        return result;
    }
};

// Struct for returning from "partial" functions mathematically
struct PointResult {
    PointXZ result;
    bool isValid = false;
};

struct t3dPAN {
    PointXZ a, b;                           // point A / B position
    PointXZ backA, backB;                   // back to point A / B
    uint16 near1 = 0;                       // panel near to A
    uint16 near2 = 0;                       // panel near to B
};

struct t3dPATHNODE {
    PointXZ pos;                                // path node position
    float dist = 0.0f;                          // distance from start
    short oldp = 0;                             // last panel hit
    short curp = 0;                             // cur panel hit
};

struct t3dSTEPS {
    t3dV3F  Pos;                            // position
    t3dF32  Angle = 0.0f;                   // angle
    int16  curp = 0;                       // cur panel
    int16  Act = 0, Frame = 0;             // cur action and frame

    void reset() {
        Pos = t3dV3F();
        Angle = 0.0f;
        curp = 0;
        Act = 0;
        Frame = 0;
    }
};

struct t3dWALK {
    PointXZ Look;                                  // Point on the bounds
    PointXZ Cur;                                   // Point perpendicular
    t3dPAN  *Panel = nullptr;                      // pointer to cur panel struct
    t3dPATHNODE PathNode[T3D_MAX_PATHNODES] = {};  // path nodes list
    t3dSTEPS    WalkSteps[T3D_MAX_WALKSTEPS] = {}; // walk steps list
    int32  CurrentStep = 0;                // current step
    int32  PanelNum = 0;                   // num panels
    int32  NumPathNodes = 0;               // num path nodes
    int32  NumSteps = 0;                   // num steps
    int16  CurPanel = 0, OldPanel = 0;     // current panel
    int16  CurAction = 0, CurFrame = 0;    // cur action and frame
    int32  Check = 0;                      // intersection check
};

struct t3dMESH;

struct t3dCHARACTER {
    char        Name[T3D_NAMELEN] = {};     // character name
    t3dBODY     *Body = nullptr;            // caracter body
    t3dBODY     *Shadow = nullptr;          // shadow struct
    t3dMESH     *Mesh = nullptr;            // shortcut to first mesh
    t3dBODY     *CurRoom = nullptr;         // character cur room
    t3dV3F      Pos;                        // char pos (world)
    t3dV3F      Dir;                        // char dir
    t3dWALK     Walk;                       // walk struct
    uint8       Flags = 0;                  // char flags
    SHADOWBOX   *ShadowBox[T3D_MAX_SHADOWBOX_PER_CHAR] = {}; // active shadows
    t3dF32      Radius = 0.0f, Height = 0.0f;  // char dimension (for shadow)
    int32      CurExpressionSet = 0;          // current expression face set
};

struct t3dCHARSTOPSTATUS {
    uint8   BlendPercent = 0;
    int32  NumPathNodes = 0;
    int32  CurrentStep = 0;
    int32  NumSteps = 0;
    int16  CurAction = 0, CurFrame = 0;
    int16  mCurFrame = 0;
    t3dF32  posy = 0.0f, mposy = 0.0f;
    t3dM3X3F    Matrix;
};

} // End of namespace Watchmaker

#endif // WATCHMAKER_T3D_H