set_pc.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.
 *
 * Additional copyright for this file:
 * Copyright (C) 1999-2000 Revolution Software Ltd.
 * This code is based on source code created by Revolution Software,
 * used with permission.
 *
 * 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 ICB_SET_PC_H
#define ICB_SET_PC_H
 
#include "engines/icb/p4_generic.h"
#include "engines/icb/gfx/psx_pcdefines.h"
#include "engines/icb/gfx/rlp_api.h"
#include "engines/icb/common/pc_props.h"
#include "engines/icb/common/px_staticlayers.h"
 
#include "common/endian.h"
 
namespace ICB {
 
#define WEATHER_SCREEN_WIDTH SCREEN_WIDTH
#define WEATHER_HALF_SCREEN_WIDTH (WEATHER_SCREEN_WIDTH / 2)
#define WEATHER_SCREEN_HEIGHT SCREEN_DEPTH
#define WEATHER_HALF_SCREEN_HEIGHT (WEATHER_SCREEN_HEIGHT / 2)
#define WEATHER_SCREEN_DEPTH 512
#define WEATHER_HALF_SCREEN_DEPTH (WEATHER_SCREEN_DEPTH / 2)
#define WEATHER_MAX_PARTICLES 256
 
#define MAX_PROP_STATES 512
#define MAX_CAMERA_PROPS 16
 
#define _MAX_SHADOW_LAYERS_ 4
#define WEATHER_NONE 0
#define WEATHER_RAIN 1
#define WEATHER_SNOW 2
 
extern uint32 bg_buffer_id;
extern LRECT full_rect;
 
class _set {
    friend void sv_WeatherControls();
 
public:
    _set();
    ~_set();
 
public:
    bool8 Init(const char *camera_name, const char *h_camera_name); // camera name
    void Init_construction_matrices();
    void Init_base_bitmap_buffers();
    void ReInit();
 
private:
    void Load_props();
    void Load_props_old();
 
public:
    inline PXcamera &GetCamera();
    inline rlp_API *GetPRig();
    inline pcStaticLayers *GetStaticLayers();
    inline pcPropFile *GetProps();
    inline pcInteractibleFile *GetInteractibles();
    inline uint8 *GetBackground();
    inline uint32 GetPropQty();
    inline const char *GetPropName(uint32 n);
    inline uint32 GetPropRange(uint32 n);
    bool8 DoesPropExist(const char *propName);
 
    int32 OK() { return m_setOk; };
    void Reset();
    bool8 DoesCameraExist(const char *camera_name, const char *camera_cluster_name);
 
private:
    void HackMakeCamera();
 
public: /* Drawing Functions */
    void RefreshBackdrop();
    void Set_draw(bool8 helper);
 
    const char *GetSetName() const { return set_name; }
 
private:                       /* Member variables .... Move this to private section */
    char set_name[MAXPATHLEN];    // the camera name (no url)
    char set_url[MAXPATHLEN];     // the full url of the camera
    uint32 set_url_hash;         // the hashed url of the camera
    char set_cluster[MAXPATHLEN]; // cluster file name
    uint32 set_cluster_hash;     // hashed cluster file name
    /* Waiting for removal */
    char h_set_name[MAXPATHLEN]; // just the hash camera name - not full url
    char rvpcm_file_name[MAXPATHLEN]; // Props & Construction Matrix
    uint32 rvpcm_file_hash;          // Props & Construction Matrix hash value
    char rvcam_file_name[MAXPATHLEN]; // Camera
    uint32 rvcam_file_hash;          // Camera hash value
    char rvsl_file_name[MAXPATHLEN];  // Static Layers
    uint32 rvsl_file_hash;           // Static Layers hash value
    char rvbg_file_name[MAXPATHLEN];  // Background
    uint32 rvbg_file_hash;           // Background hash value
    char rlx_file_name[MAXPATHLEN];   // Poly Lighting rig
    uint32 rlx_file_hash;            // Poly Lighting rig hash
    void SettleCamera();
    /* Waiting for removal */
 
public: /* _ WEATHER _ RAIN _ SNOW _ LIGHTNING _ SPARKLE */
    void DrawSparkles();
    void DrawWeather();
    void InitWeather(int32 type, int32 particleQty, int32 lightning, int32 windX, int32 windY, int32 windZ);
 
private:
    int16 m_wParticleX[WEATHER_MAX_PARTICLES]; // -320 - 320
    int16 m_wParticleY[WEATHER_MAX_PARTICLES]; // -240 - 240
    int16 m_wParticleZ[WEATHER_MAX_PARTICLES]; // -512 - 512
    int8 m_wParticleDX[WEATHER_MAX_PARTICLES];
    int8 m_wParticleDY[WEATHER_MAX_PARTICLES];
    int8 m_wParticleDZ[WEATHER_MAX_PARTICLES];
    int32 m_wLightningTimer;
    int32 m_wType;
    int32 m_wWindX;
    int32 m_wWindY;
    int32 m_wWindZ;
    int32 m_wParticleQty;
    int32 m_wLightning;
 
private:
    int32 m_setOk;                   // Is The Set OK flag
    PXcamera m_camera;             // The camera
    _pcSetHeader *m_currentCamera; // All the camera data
 
    pcPropFile *m_props;
 
public: /* Prop Surfaces */
    uint32 m_propSurfaceIds[MAX_CAMERA_PROPS];
    int32 m_propSurfaces[MAX_PROP_STATES];
    int32 m_propResolutions[MAX_CAMERA_PROPS];
    int32 m_TotalPropSurfaces;
};
 
inline rlp_API *_set::GetPRig() { return (rlp_API *)(((uint8 *)m_currentCamera) + FROM_LE_32(m_currentCamera->lightOffset)); }
 
inline pcStaticLayers *_set::GetStaticLayers() { return (pcStaticLayers *)(((uint8 *)m_currentCamera) + FROM_LE_32(m_currentCamera->layerOffset)); }
 
inline pcInteractibleFile *_set::GetInteractibles() {
    if (m_currentCamera->id == PCSETFILE_ID_ICB) {
        static pcInteractibleFile temp;
        temp.SetQty(0);
        temp.SetSchema(PCINTERACTIBLE_SCHEMA);
        temp.SetId(PCINTERACTIBLE_ID);
        return &temp;
    }
    else
        return (pcInteractibleFile *)(((uint8 *)m_currentCamera) + FROM_LE_32(m_currentCamera->interactiblesOffset));
}
 
inline pcPropFile *_set::GetProps() { return m_props; }
 
inline uint8 *_set::GetBackground() { return (uint8 *)(((uint8 *)m_currentCamera) + FROM_LE_32(m_currentCamera->backgroundOffset)); }
 
inline PXcamera &_set::GetCamera() { return m_camera; }
 
inline uint32 _set::GetPropQty() {
    // Load the prop file
    pcPropFile *propFile = GetProps();
    return propFile->GetPropQty();
}
 
inline const char *_set::GetPropName(uint32 n) {
    // Load the prop file
    pcPropFile *propFile = GetProps();
    // Get the name of prop n
    return propFile->GetProp(n)->GetName();
}
 
inline uint32 _set::GetPropRange(uint32 n) {
    // Load the prop file
    pcPropFile *propFile = GetProps();
    // Get the name of prop n
    return propFile->GetProp(n)->GetStateQty();
}
 
} // End of namespace ICB
 
#endif