mirror of
https://github.com/libretro/scummvm.git
synced 2025-01-07 10:21:31 +00:00
583 lines
18 KiB
C++
583 lines
18 KiB
C++
/* 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_STRUCT_H
|
|
#define WATCHMAKER_STRUCT_H
|
|
|
|
#include "watchmaker/t3d.h"
|
|
#include "watchmaker/types.h"
|
|
#include "watchmaker/sysdef.h"
|
|
#include "common/stream.h"
|
|
#include "watchmaker/message.h"
|
|
|
|
namespace Watchmaker {
|
|
|
|
class SerializableAsset {
|
|
public:
|
|
virtual ~SerializableAsset() {}
|
|
virtual void loadFromStream(Common::SeekableReadStream &stream) = 0;
|
|
};
|
|
|
|
template<uint32 strSize>
|
|
class SerializableString : public SerializableAsset {
|
|
char str[strSize] = {};
|
|
public:
|
|
char *c_str() {
|
|
return str;
|
|
}
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
stream.read(str, strSize);
|
|
};
|
|
};
|
|
|
|
template<typename T>
|
|
void loadArrayFromStream(Common::SeekableReadStream &stream, T array[], uint32 size) {
|
|
for (uint32 i = 0; i < size; i++) {
|
|
array[i].loadFromStream(stream);
|
|
}
|
|
}
|
|
|
|
template<>
|
|
inline void loadArrayFromStream(Common::SeekableReadStream &stream, uint8 array[], uint32 size) {
|
|
for (uint32 i = 0; i < size; i++) {
|
|
array[i] = stream.readByte();
|
|
}
|
|
}
|
|
|
|
template<>
|
|
inline void loadArrayFromStream(Common::SeekableReadStream &stream, uint16 array[], uint32 size) {
|
|
for (uint32 i = 0; i < size; i++) {
|
|
array[i] = stream.readUint16LE();
|
|
}
|
|
}
|
|
|
|
template<>
|
|
inline void loadArrayFromStream(Common::SeekableReadStream &stream, int32 array[], uint32 size) {
|
|
for (uint32 i = 0; i < size; i++) {
|
|
array[i] = stream.readSint32LE();
|
|
}
|
|
}
|
|
|
|
template<typename T, uint32 arraySize>
|
|
class SerializableArray : public SerializableAsset {
|
|
T _array[arraySize]; // Can't do initializer here, as GCC 4.8 crashes in that case
|
|
public:
|
|
SerializableArray() : _array{} {}
|
|
T &operator[](int index) {
|
|
return _array[index];
|
|
};
|
|
T *rawArray() {
|
|
return _array;
|
|
}
|
|
uint32 size() const {
|
|
return arraySize;
|
|
}
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
loadArrayFromStream(stream, _array, arraySize);
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
class SerializableDynamicArray : public SerializableAsset {
|
|
T *_array = nullptr;
|
|
uint32 _size = 0;
|
|
public:
|
|
SerializableDynamicArray() : SerializableDynamicArray(0) {} // TODO
|
|
SerializableDynamicArray(uint32 size) : _size(size) {
|
|
_array = new T[size] {};
|
|
}
|
|
~SerializableDynamicArray() {
|
|
delete[] _array;
|
|
}
|
|
uint32 size() const {
|
|
return _size;
|
|
}
|
|
T &operator[](int index) {
|
|
return _array[index];
|
|
};
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
loadArrayFromStream(stream, _array, _size);
|
|
}
|
|
};
|
|
|
|
struct SRoom : public SerializableAsset {
|
|
uint8 name[T3D_NAMELEN]; // nome della stanza
|
|
char desc[64]; // descrizione della stanza
|
|
uint16 flags; // DONE | EXTRA
|
|
uint16 env; // EAX preset environment number
|
|
uint16 music; // Music for this room
|
|
SerializableArray<uint16, MAX_OBJS_IN_ROOM> objects; // oggetti nella stanza rivelabili dal mouse
|
|
SerializableArray<uint16, MAX_SOUNDS_IN_ROOM> sounds; // sounds per room
|
|
SerializableArray<uint16, MAX_ANIMS_IN_ROOM> anims; // animazioni per room
|
|
SerializableArray<uint16, MAX_ACTIONS_IN_ROOM> actions; // azioni per room
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
stream.read(name, T3D_NAMELEN);
|
|
stream.read(desc, 64);
|
|
flags = stream.readUint16LE();
|
|
env = stream.readUint16LE();
|
|
music = stream.readUint16LE();
|
|
objects.loadFromStream(stream);
|
|
sounds.loadFromStream(stream);
|
|
anims.loadFromStream(stream);
|
|
actions.loadFromStream(stream);
|
|
}
|
|
};
|
|
|
|
struct SObject : public SerializableAsset {
|
|
uint16 name; // frase nome
|
|
SerializableArray<uint16, MAX_PLAYERS> examine; // frase esamina
|
|
SerializableArray<uint16, MAX_PLAYERS> action; // frase azione
|
|
SerializableArray<uint16, MAX_OBJ_USER_SENTS> text; // Frasi user
|
|
SerializableArray<uint16, MAX_PLAYERS> anim; // animazione su action
|
|
SerializableArray<uint16, MAX_PLAYERS> anim2; // animazione aggiunta (su examine)
|
|
uint8 room; // Stanza in cui si trova l'oggetto
|
|
uint8 goroom; // Se direzione num stanza - se persona num dialog
|
|
uint8 ninv; // ptr inventario
|
|
uint16 flags; // EXAMINE | EXAMINEACT | ROOM | PERSON | TAKE | USEWITH | EXTRA | EXTRA2 | DONE | ON | HIDE
|
|
uint8 pos; // 0 se no position
|
|
SerializableArray<SerializableArray<uint8, T3D_NAMELEN>, MAX_OBJ_MESHLINKS> meshlink_int = {};// link -> oggetto mesh (nome mesh) -> da rimuovere
|
|
uint8 *meshlink[MAX_OBJ_MESHLINKS];
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
name = stream.readUint16LE();
|
|
examine.loadFromStream(stream);
|
|
action.loadFromStream(stream);
|
|
text.loadFromStream(stream);
|
|
anim.loadFromStream(stream);
|
|
anim2.loadFromStream(stream);
|
|
room = stream.readByte();
|
|
goroom = stream.readByte();
|
|
ninv = stream.readByte();
|
|
flags = stream.readUint16LE();
|
|
pos = stream.readByte();
|
|
meshlink_int.loadFromStream(stream);
|
|
// HACK:
|
|
for (int i = 0; i < MAX_OBJ_MESHLINKS; i++) {
|
|
meshlink[i] = meshlink_int.rawArray()[i].rawArray();
|
|
}
|
|
}
|
|
};
|
|
|
|
struct SInvObject : public SerializableAsset {
|
|
uint16 name; // Nome Oggetto in inventario
|
|
SerializableArray<uint16, MAX_PLAYERS> examine; // Frase se si esamina
|
|
SerializableArray<uint16, MAX_PLAYERS> action; // Frase se si opera
|
|
uint16 flags; // USEWITH | EXTRA | EXTRA2 | DONE | ON | WITHI | WITHO
|
|
SerializableArray<uint16, MAX_ICON_USER_SENTS> text; // Frasi user
|
|
uint16 uwobj; // usewithobj automatico
|
|
SerializableArray<uint16, MAX_PLAYERS> anim; // animazione su usewith
|
|
SerializableArray<uint16, MAX_PLAYERS> anim2; // animazione su usewith
|
|
SerializableArray<uint8, T3D_NAMELEN> meshlink; // link -> mesh
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
name = stream.readUint16LE();
|
|
examine.loadFromStream(stream);
|
|
action.loadFromStream(stream);
|
|
flags = stream.readUint16LE();
|
|
text.loadFromStream(stream);
|
|
uwobj = stream.readUint16LE();
|
|
anim.loadFromStream(stream);
|
|
anim2.loadFromStream(stream);
|
|
meshlink.loadFromStream(stream);
|
|
}
|
|
};
|
|
|
|
struct SAtFrame : public SerializableAsset {
|
|
uint8 type = 0; // ATFTEXT, ATFSND, ATFEVENT
|
|
uint8 anim = 0; // solo se subanim e' attiva
|
|
int16 nframe = 0; // 10000 se attraversa portale
|
|
uint16 index = 0;
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
type = stream.readByte();
|
|
anim = stream.readByte();
|
|
nframe = stream.readSint16LE();
|
|
index = stream.readUint16LE();
|
|
}
|
|
};
|
|
|
|
struct SAnim : public SerializableAsset {
|
|
SerializableArray<SerializableArray<uint8, T3D_NAMELEN>, MAX_SUBANIMS> meshlink; // link -> anim mesh (nome mesh) -> da rimuovere
|
|
SerializableArray<SerializableArray<uint8, T3D_NAMELEN>, MAX_SUBANIMS> name; // nome animazione
|
|
SerializableArray<uint8, T3D_NAMELEN> RoomName; // nome stanza destinazione
|
|
SerializableArray<SAtFrame, MAX_ATFRAMES> atframe; // atframe
|
|
uint32 flags;
|
|
int16 active; // indece tra le animazioni attive
|
|
int32 obj; // obj a cui e' collegato
|
|
uint8 pos; // posizione
|
|
uint8 cam; // camera per l'azione
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
meshlink.loadFromStream(stream);
|
|
name.loadFromStream(stream);
|
|
RoomName.loadFromStream(stream);
|
|
atframe.loadFromStream(stream);
|
|
flags = stream.readUint32LE();
|
|
active = stream.readSint16LE();
|
|
obj = stream.readSint32LE();
|
|
pos = stream.readByte();
|
|
cam = stream.readByte();
|
|
}
|
|
};
|
|
|
|
struct SSound : public SerializableAsset {
|
|
char name[T3D_NAMELEN];
|
|
uint8 flags;
|
|
SerializableArray<SerializableArray<uint8, T3D_NAMELEN>, MAX_SOUND_MESHLINKS> meshlink;
|
|
uint32 ConeInside, ConeOutside;
|
|
int32 ConeOutsideVolume;
|
|
t3dF32 MinDist, MaxDist;
|
|
int32 Angle;
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
stream.read(name, T3D_NAMELEN);
|
|
flags = stream.readByte();
|
|
meshlink.loadFromStream(stream);
|
|
ConeInside = stream.readUint32LE();
|
|
ConeOutside = stream.readUint32LE();
|
|
ConeOutsideVolume = stream.readSint32LE();
|
|
MinDist = stream.readFloatLE();
|
|
MaxDist = stream.readFloatLE();
|
|
Angle = stream.readSint32LE();
|
|
}
|
|
};
|
|
|
|
struct SMusic : public SerializableAsset {
|
|
char name[MAX_SUB_MUSICS][T3D_NAMELEN];
|
|
SerializableArray<int32, MAX_SUB_MUSICS> vol;
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
for (int i = 0; i < MAX_SUB_MUSICS; i++) {
|
|
stream.read(name[i], T3D_NAMELEN);
|
|
}
|
|
vol.loadFromStream(stream);
|
|
}
|
|
};
|
|
|
|
struct SDlgMenu : public SerializableAsset { // struttura di appoggio per riempiere i DlgItem
|
|
uint8 parent, on;
|
|
uint16 titolo; // indice della sentence di titolo
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
parent = stream.readByte();
|
|
on = stream.readByte();
|
|
titolo = stream.readUint16LE();
|
|
}
|
|
};
|
|
|
|
struct SItemCommand : public SerializableAsset {
|
|
uint8 com; // comando
|
|
uint16 param1; // parametro 1
|
|
uint16 param2; // parametro 2
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
com = stream.readByte();
|
|
param1 = stream.readUint16LE();
|
|
param2 = stream.readUint16LE();
|
|
}
|
|
};
|
|
|
|
struct SDlgItem : public SerializableAsset {
|
|
SerializableArray<SerializableArray<SItemCommand, MAX_IC_PER_DLG_ITEM>, MAX_PLAYERS> item; // lista di comandi per personaggio
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
item.loadFromStream(stream);
|
|
}
|
|
};
|
|
|
|
struct SDialog : public SerializableAsset {
|
|
uint16 flags; // flags del dialogo - per ora non serve
|
|
int32 obj; // Personaggio con cui fa il dialogo
|
|
SerializableArray<int32, MAX_ALTERNATES> AltPosSco; // Scostamento posizione alternate
|
|
SerializableArray<int32, MAX_ALTERNATES> AltCamSco; // Scostamento camere alternate
|
|
SerializableArray<SerializableArray<SerializableArray<int32, 2>, MAX_ALT_ANIMS>, MAX_ALTERNATES> AltAnims; // Rimappatura anim alternative dialoghi
|
|
SerializableArray<uint16, MAX_DLG_MENUS> ItemIndex; // indice delle liste di comandi
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
flags = stream.readUint16LE();
|
|
obj = stream.readSint32LE();
|
|
AltPosSco.loadFromStream(stream);
|
|
AltCamSco.loadFromStream(stream);
|
|
AltAnims.loadFromStream(stream);
|
|
ItemIndex.loadFromStream(stream);
|
|
}
|
|
};
|
|
|
|
struct SDiaryItem : public SerializableAsset {
|
|
uint16 rand;
|
|
uint16 loop;
|
|
uint16 loopc;
|
|
uint16 bnd, saved_bnd;
|
|
uint16 cur;
|
|
uint16 on;
|
|
SerializableArray<uint16, MAX_ANIMS_PER_DIARY_ITEM> anim;
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
rand = stream.readUint16LE();
|
|
loop = stream.readUint16LE();
|
|
loopc = stream.readUint16LE();
|
|
bnd = stream.readUint16LE();
|
|
saved_bnd = stream.readUint16LE();
|
|
cur = stream.readUint16LE();
|
|
on = stream.readUint16LE();
|
|
anim.loadFromStream(stream);
|
|
}
|
|
};
|
|
|
|
struct SDiary : public SerializableAsset {
|
|
uint16 startt, endt;
|
|
int32 room;
|
|
uint16 obj;
|
|
uint16 cur;
|
|
uint16 end_hideobj; //se il bit piu' alto e' settato vuol dire che il diario e' stato lanciato almeno una volta e quindi questa variabile e' valida solo per oggetti da 0..32767
|
|
SerializableArray<SDiaryItem, MAX_DIARY_ITEMS> item;
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
startt = stream.readUint16LE();
|
|
endt = stream.readUint16LE();
|
|
room = stream.readSint32LE();
|
|
obj = stream.readUint16LE();
|
|
cur = stream.readUint16LE();
|
|
end_hideobj = stream.readUint16LE();
|
|
item.loadFromStream(stream);
|
|
}
|
|
};
|
|
|
|
struct SPlayerStand {
|
|
uint8 pos = 0;
|
|
int32 an = 0;
|
|
int32 cr = 0;
|
|
uint16 bnd = 0;
|
|
Common::String roomName;
|
|
SPlayerStand() = default;
|
|
SPlayerStand(Common::SeekableReadStream &stream) {
|
|
pos = stream.readByte();
|
|
an = stream.readSint32LE();
|
|
cr = stream.readSint32LE();
|
|
bnd = stream.readUint16LE();
|
|
}
|
|
};
|
|
|
|
struct SPDALog : public SerializableAsset {
|
|
int32 time = 0;
|
|
SerializableString<MAX_STRING_LEN> info;
|
|
SerializableArray<int32, MAX_PDA_INFO> text;
|
|
SerializableArray<SerializableString<MAX_TEXT_CHARS>, MAX_PDA_LINES *MAX_PDA_INFO> formatted;
|
|
int32 menu_appartenenza = 0, menu_creato = 0;
|
|
int32 flags = 0;
|
|
int32 lines = 0;
|
|
int32 dx = 0, dy = 0;
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
time = stream.readSint32LE();
|
|
info.loadFromStream(stream);
|
|
text.loadFromStream(stream);
|
|
formatted.loadFromStream(stream);
|
|
menu_appartenenza = stream.readSint32LE();
|
|
menu_creato = stream.readSint32LE();
|
|
flags = stream.readSint32LE();
|
|
lines = stream.readSint32LE();
|
|
dx = stream.readSint32LE();
|
|
dy = stream.readSint32LE();
|
|
}
|
|
};
|
|
|
|
struct SString {
|
|
char text[MAX_STRING_LEN] = {};
|
|
uint16 x = 0, y = 0, dx = 0;
|
|
|
|
constexpr SString() = default;
|
|
SString(const char *_text, uint16 _x = 0, uint16 _y = 0, uint16 _dx = 0) : x(_x), y(_y), dx(_dx) {
|
|
if (_text != nullptr) {
|
|
memcpy(this->text, _text, strlen(_text));
|
|
}
|
|
}
|
|
};
|
|
|
|
struct SRect {
|
|
int32 x1 = 0, y1 = 0, x2 = 0, y2 = 0;
|
|
constexpr SRect() = default;
|
|
constexpr SRect(int32 _x1, int32 _y1, int32 _x2, int32 _y2): x1(_x1), y1(_y1), x2(_x2), y2(_y2) {}
|
|
|
|
void reset() {
|
|
x1 = 0;
|
|
y1 = 0;
|
|
x2 = 0;
|
|
y2 = 0;
|
|
}
|
|
};
|
|
|
|
struct SD3DRect {
|
|
int32 px = 0, py = 0, dx = 0, dy = 0;
|
|
uint8 r = 0, g = 0, b = 0, a = 0;
|
|
};
|
|
struct SD3DTriangle {
|
|
int32 x1 = 0, y1 = 0, x2 = 0, y2 = 0, x3 = 0, y3 = 0;
|
|
uint8 r = 0, g = 0, b = 0, a = 0;
|
|
};
|
|
struct SD3DBitmap {
|
|
int32 tnum = 0;
|
|
int32 px = 0, py = 0, dx = 0, dy = 0;
|
|
int32 rtype = 0;
|
|
};
|
|
struct SDDBitmap {
|
|
int32 tnum;
|
|
int32 px, py, ox, oy, dx, dy;
|
|
|
|
SDDBitmap() {
|
|
reset();
|
|
}
|
|
|
|
void reset() {
|
|
tnum =0;
|
|
px = 0;
|
|
py = 0;
|
|
ox = 0;
|
|
oy = 0;
|
|
dx = 0;
|
|
dy = 0;
|
|
}
|
|
};
|
|
|
|
struct SDDText {
|
|
SDDText() {
|
|
reset();
|
|
}
|
|
|
|
SDDText(const char *_text, FontKind _font, FontColor _color, int32 _tnum) : font(_font),
|
|
color(_color),
|
|
tnum(_tnum) {
|
|
Common::strlcpy(this->text, _text, sizeof(this->text));
|
|
}
|
|
|
|
void reset() {
|
|
for(uint i = 0; i < ARRAYSIZE(text); i++) text[i] = '\0';
|
|
font = FontKind::Standard;
|
|
color = FontColor::WHITE_FONT;
|
|
tnum = 0;
|
|
}
|
|
|
|
char text[MAX_STRING_LEN];
|
|
FontKind font;
|
|
FontColor color;
|
|
int32 tnum;
|
|
};
|
|
|
|
struct SScript {
|
|
uint16 firstframe = 0;
|
|
uint8 flags = 0; // 0 - BREAKABLE - Se si interrompe con la pressione dei tasti del mouse
|
|
}; // 1 - DIALOGEXITNOANIM - Se lo script e' lanciato da un dialogo all'ultima battuta esce dal dialogo senza anim di link e di default
|
|
|
|
struct SGameOptions {
|
|
uint8 sound_on = 0;
|
|
uint8 sound_volume = 0;
|
|
uint8 music_on = 0;
|
|
uint8 music_volume = 0;
|
|
uint8 speech_on = 0;
|
|
uint8 speech_volume = 0;
|
|
uint8 subtitles_on = 0;
|
|
};
|
|
|
|
|
|
// MESSAGGI PER LO SCHEDULER
|
|
struct message {
|
|
EventClass classe; // message classe
|
|
uint8 event = 0; // message name
|
|
uint16 flags = 0; // message priority | NOWAIT per script
|
|
|
|
uint8 bparam = 0;
|
|
int16 wparam1 = 0; // t3dS16 parameter 1
|
|
int16 wparam2 = 0; // t3dS16 parameter 2
|
|
union {
|
|
int32 lparam[3] = {}; // long parameter
|
|
t3dF32 fparam[3]; // float parameter
|
|
};
|
|
|
|
message() = default;
|
|
message(EventClass _classe, uint8 _event, uint16 _flags) : classe(_classe), event(_event), flags(_flags) {}
|
|
|
|
void reset() {
|
|
classe = MC_IDLE;
|
|
event = 0;
|
|
flags = 0;
|
|
bparam = 0;
|
|
wparam1 = 0;
|
|
wparam2 = 0;
|
|
for (uint i = 0; i < ARRAYSIZE(lparam); i++) lparam[i] = 0;
|
|
// fparam cleared as union with lparam i.e. shared memory
|
|
}
|
|
};
|
|
|
|
struct pqueue {
|
|
uint8 head = 0, tail = 0, len = 0;
|
|
message *event[MAX_MESSAGES] = {};
|
|
};
|
|
|
|
|
|
// STRUTTURE PER TITOLI DI CODA
|
|
struct SCreditsName : public SerializableAsset {
|
|
char name[64] = {};
|
|
uint16 role = 0;
|
|
uint8 flags = 0;
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
stream.read(name, 64);
|
|
role = stream.readUint16LE();
|
|
flags = stream.readByte();
|
|
}
|
|
};
|
|
|
|
struct SCreditsRole : public SerializableAsset {
|
|
char role[48] = {};
|
|
uint8 flags = 0;
|
|
|
|
void loadFromStream(Common::SeekableReadStream &stream) override {
|
|
stream.read(role, 48);
|
|
flags = stream.readByte();
|
|
}
|
|
};
|
|
|
|
struct STitoliCoda {
|
|
char *s = nullptr; //puntatore alla stringa
|
|
int32 px = 0, py = 0; //posizione
|
|
int32 dx = 0, dy = 0; //dimensione
|
|
int32 tnum = 0; //bitmap
|
|
|
|
uint32 time = 0; //quando deve apparire (solo nel caso degli StaticCredits)
|
|
};
|
|
|
|
struct SRoomInfo {
|
|
char name[64] = {}; //nome della stanza
|
|
char fullstring[64 + 16 + 1] = {}; //stringa con ora
|
|
int32 px = 0, py = 0; //posizione
|
|
int32 dx = 0, dy = 0; //dimensione totale
|
|
int32 _dx = 0, _dy = 0; //dimensione della stringa attuale
|
|
int32 tnum = 0; //bitmap
|
|
char *letter_ptr = nullptr; //puntatore alla lettera corrente
|
|
int16 t_next_letter = 0; //quando deve apparire la nuova lettera
|
|
FontKind f; //il font
|
|
};
|
|
|
|
} // End of namespace Watchmaker
|
|
|
|
#endif // WATCHMAKER_STRUCT_H
|