object.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/>.
 *
 * Object Manager data structures
 */

#ifndef TINSEL_OBJECT_H // prevent multiple includes
#define TINSEL_OBJECT_H

#include "tinsel/dw.h"
#include "common/frac.h"
#include "common/rect.h"

namespace Tinsel {

struct PALQ;

enum {
    NUM_OBJECTS = 512,

    // object flags
    DMA_WNZ     = 0x0001,   
    DMA_CNZ     = 0x0002,   
    DMA_RLWA    = 0x0002,   
    DMA_CONST   = 0x0004,   
    DMA_WA      = 0x0008,   
    DMA_FLIPH   = 0x0010,   
    DMA_FLIPV   = 0x0020,   
    DMA_CLIP    = 0x0040,   
    DMA_TRANS   = 0x0084,   
    DMA_ABS     = 0x0100,   
    DMA_CHANGED = 0x0200,   
    DMA_USERDEF = 0x0400,   
    DMA_GHOST   = 0x0080,

    DMA_HARDFLAGS   = (DMA_WNZ | DMA_CNZ | DMA_CONST | DMA_WA | DMA_FLIPH | DMA_FLIPV | DMA_TRANS)
};

struct IMAGE {
    short imgWidth;           
    unsigned short imgHeight; 
    short anioffX;            
    short anioffY;            
    SCNHANDLE hImgBits;       
    SCNHANDLE hImgPal;        
    short isRLE;              
    short colorFlags;         
};

typedef uint32 FRAME;

// object structure
struct OBJECT {
    OBJECT *pNext;  
    OBJECT *pSlave; 
//  char *pOnDispList;  ///< pointer to display list byte for background objects
//  frac_t xVel;        ///< x velocity of object
//  frac_t yVel;        ///< y velocity of object
    frac_t xPos;        
    frac_t yPos;        
    int zPos;           
    Common::Rect rcPrev;        
    int flags;          
    PALQ *pPal;         
    short isRLE;        
    short colorFlags;   
    int constant;       
    int width;          
    int height;         
    SCNHANDLE hBits;    
    SCNHANDLE hImg;     
    SCNHANDLE hShape;   
    SCNHANDLE hMirror;  
    int oid;            

    void reset() {
        pNext = nullptr;
        pSlave = nullptr;
        //pOnDispList = nullptr;
        //xVel = 0;
        //yVel = 0;
        xPos = 0;
        yPos = 0;
        zPos = 0;
        rcPrev.top = 0;
        rcPrev.left = 0;
        rcPrev.bottom = 0;
        rcPrev.right = 0;
        flags = 0;
        pPal = nullptr;
        constant = 0;
        width = 0;
        height = 0;
        hBits = 0;
        hImg = 0;
        hShape = 0;
        hMirror = 0;
        oid = 0;
    }

    OBJECT() { reset(); }
};

// object initialisation structure
struct OBJ_INIT {
    SCNHANDLE hObjImg;  // objects shape - handle to IMAGE structure
    int32 objFlags;     // objects flags
    int32 objID;        // objects id
    int32 objX;     // objects initial x position
    int32 objY;     // objects initial y position
    int32 objZ;     // objects initial z position
};

/*----------------------------------------------------------------------*\
|*          Object Function Prototypes          *|
\*----------------------------------------------------------------------*/

void KillAllObjects();  // kill all objects and place them on free list

void FreeObjectList();  // free the object list

#ifdef  DEBUG
void ObjectStats();     // Shows the maximum number of objects used at once
#endif

OBJECT *AllocObject();  // allocate a object from the free list

void FreeObject(        // place a object back on the free list
    OBJECT *pFreeObj);  // object to free

bool isValidObject(OBJECT *obj);

void CopyObject(        // copy one object to another
    OBJECT *pDest,      // destination object
    OBJECT *pSrc);      // source object

void InsertObject(      // insert a object onto a sorted object list
    OBJECT **pObjList,  // list to insert object onto
    OBJECT *pInsObj);   // object to insert

void DelObject(         // delete a object from a object list and add to free list
    OBJECT **pObjList,  // list to delete object from
    OBJECT *pDelObj);   // object to delete

void SortObjectList(        // re-sort an object list
    OBJECT **pObjList); // list to sort

void GetAniOffset(  // returns the anim offsets of a image, takes into account orientation
    SCNHANDLE hImg, // image to get animation offset of
    int flags,  // images current flags
    int *pAniX, // gets set to new X animation offset
    int *pAniY);    // gets set to new Y animation offset

void GetAniPosition(    // Returns a objects x,y animation point
    OBJECT *pObj,   // pointer to object
    int *pPosX, // gets set to objects X animation position
    int *pPosY);    // gets set to objects Y animation position

OBJECT *InitObject(     // Init a object using a OBJ_INIT struct
    const OBJ_INIT *pInitTbl);  // pointer to object initialisation table

void AnimateObjectFlags(    // Give a object a new image and new orientation flags
    OBJECT *pAniObj,    // object to be updated
    int newflags,       // objects new flags
    SCNHANDLE hNewImg); // objects new image

void AnimateObject(     // give a object a new image
    OBJECT *pAniObj,    // object to animate
    SCNHANDLE hNewImg); // objects new image

void HideObject(        // Hides a object by giving it a "NullImage" image pointer
    OBJECT *pObj);      // object to be hidden

OBJECT *RectangleObject(    // create a rectangle object of the given dimensions
    SCNHANDLE hPal,     // palette for the rectangle object
    int color,      // which color offset from the above palette
    int width,      // width of rectangle
    int height);        // height of rectangle

OBJECT *TranslucentObject(  // create a translucent rectangle object of the given dimensions
    int width,      // width of rectangle
    int height);        // height of rectangle

} // End of namespace Tinsel

#endif  // TINSEL_OBJECT_H