opengta/OpenGTA
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
net
OpenGTA/read_gry.cpp
Vladislav Khorev ef0392fb63 Get rid of Loki
2018-09-23 10:57:34 +05:00

1056 lines
38 KiB
C++
Executable File
Raw Permalink Blame History

/************************************************************************
* Copyright (c) 2005-2007 tok@openlinux.org.uk *
* *
* This file contains code derived from information copyrighted by *
* DMA Design. It may not be used in a commercial product. *
* *
* See license.txt for details. *
* *
* This notice may not be removed or altered. *
************************************************************************/
#include <iostream>
#include <cassert>
#include <sstream>
#include <algorithm>
#include "opengta.h"
#include "buffercache.h"
#include "log.h"
#include "m_exceptions.h"
#include "set.h"
using namespace Util;
namespace OpenGTA {
#define GTA_GRAPHICS_GRX 290
#define GTA_GRAPHICS_GRY 325
#define GTA_GRAPHICS_G24 336
PHYSFS_uint16 GraphicsBase::SpriteNumbers::countByType(const SpriteTypes & t) const {
switch (t) {
case ARROW:
return GTA_SPRITE_ARROW;
case DIGIT:
return GTA_SPRITE_DIGITS;
case BOAT:
return GTA_SPRITE_BOAT;
case BOX:
return GTA_SPRITE_BOX;
case BUS:
return GTA_SPRITE_BUS;
case CAR:
return GTA_SPRITE_CAR;
case OBJECT:
return GTA_SPRITE_OBJECT;
case PED:
return GTA_SPRITE_PED;
case SPEEDO:
return GTA_SPRITE_SPEEDO;
case TANK:
return GTA_SPRITE_TANK;
case TRAFFIC_LIGHT:
return GTA_SPRITE_TRAFFIC_LIGHTS;
case TRAIN:
return GTA_SPRITE_TRAIN;
case TRDOOR:
return GTA_SPRITE_TRDOORS;
case BIKE:
return GTA_SPRITE_BIKE;
case TRAM:
return GTA_SPRITE_TRAM;
case WBUS:
return GTA_SPRITE_WBUS;
case WCAR:
return GTA_SPRITE_WCAR;
case EX:
return GTA_SPRITE_EX;
case TUMCAR:
return GTA_SPRITE_TUMCAR;
case TUMTRUCK:
return GTA_SPRITE_TUMTRUCK;
case FERRY:
return GTA_SPRITE_FERRY;
default:
break;
}
INFO << "UPS: " << t << std::endl;
assert(0);
}
PHYSFS_uint16 GraphicsBase::SpriteNumbers::reIndex(const PHYSFS_uint16 & id, const SpriteTypes & t) const {
switch (t) {
case ARROW:
return id;
case DIGIT:
return GTA_SPRITE_ARROW + id;
case BOAT:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + id;
case BOX:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT + id;
case BUS:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + id;
case CAR:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + id;
case OBJECT:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + id;
case PED:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ id;
case SPEEDO:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + id;
case TANK:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + id;
case TRAFFIC_LIGHT:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK + id;
case TRAIN:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + id;
case TRDOOR:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + id;
case BIKE:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + GTA_SPRITE_TRDOORS + id;
case TRAM:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + GTA_SPRITE_TRDOORS +
GTA_SPRITE_BIKE + id;
case WBUS:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + GTA_SPRITE_TRDOORS +
GTA_SPRITE_BIKE + GTA_SPRITE_TRAM + id;
case WCAR:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + GTA_SPRITE_TRDOORS +
GTA_SPRITE_BIKE + GTA_SPRITE_TRAM + GTA_SPRITE_WBUS + id;
case EX:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + GTA_SPRITE_TRDOORS +
GTA_SPRITE_BIKE + GTA_SPRITE_TRAM + GTA_SPRITE_WBUS + GTA_SPRITE_WCAR + id;
case TUMCAR:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + GTA_SPRITE_TRDOORS +
GTA_SPRITE_BIKE + GTA_SPRITE_TRAM + GTA_SPRITE_WBUS + GTA_SPRITE_WCAR +
GTA_SPRITE_TUMCAR + id;
case TUMTRUCK:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + GTA_SPRITE_TRDOORS +
GTA_SPRITE_BIKE + GTA_SPRITE_TRAM + GTA_SPRITE_WBUS + GTA_SPRITE_WCAR +
GTA_SPRITE_TUMCAR + GTA_SPRITE_TUMCAR + id;
case FERRY:
return GTA_SPRITE_ARROW + GTA_SPRITE_DIGITS + GTA_SPRITE_BOAT +
GTA_SPRITE_BOX + GTA_SPRITE_BUS + GTA_SPRITE_CAR + GTA_SPRITE_OBJECT
+ GTA_SPRITE_PED + GTA_SPRITE_SPEEDO + GTA_SPRITE_TANK +
+ GTA_SPRITE_TRAFFIC_LIGHTS + GTA_SPRITE_TRAIN + GTA_SPRITE_TRDOORS +
GTA_SPRITE_BIKE + GTA_SPRITE_TRAM + GTA_SPRITE_WBUS + GTA_SPRITE_WCAR +
GTA_SPRITE_TUMCAR + GTA_SPRITE_TUMCAR + GTA_SPRITE_TUMTRUCK + id;
}
assert(0); // should never be reached
return 0;
}
GraphicsBase::GraphicsBase() : sideTexBlockMove(256) {
rawTiles = NULL;
rawSprites = NULL;
delta_is_a_set = false;
for (int i=0; i < 256; ++i)
sideTexBlockMove.set_item(i, true);
}
bool GraphicsBase::isBlockingSide(uint8_t id) {
return sideTexBlockMove.get_item(id);
}
void GraphicsBase::setupBlocking(const std::string & filename) {
// style001
sideTexBlockMove.set_item(10, false);
sideTexBlockMove.set_item(20, false);
sideTexBlockMove.set_item(97, false);
sideTexBlockMove.set_item(109, false);
sideTexBlockMove.set_item(110, false);
sideTexBlockMove.set_item(115, false);
sideTexBlockMove.set_item(116, false);
sideTexBlockMove.set_item(155, false);
sideTexBlockMove.set_item(156, false);
sideTexBlockMove.set_item(157, false);
sideTexBlockMove.set_item(158, false);
}
bool GraphicsBase::getDeltaHandling() {
return delta_is_a_set;
}
void GraphicsBase::setDeltaHandling(bool delta_as_set) {
delta_is_a_set = delta_as_set;
}
GraphicsBase::~GraphicsBase() {
if (fd)
PHYSFS_close(fd);
std::vector<LoadedAnim*>::iterator i = animations.begin();
while (i != animations.end()) {
delete *i;
i++;
}
animations.clear();
std::vector<SpriteInfo*>::iterator i2 = spriteInfos.begin();
while (i2 != spriteInfos.end()) {
delete *i2;
i2++;
}
spriteInfos.clear();
std::vector<ObjectInfo*>::iterator i3 = objectInfos.begin();
while (i3 != objectInfos.end()) {
delete *i3;
i3++;
}
objectInfos.clear();
std::vector<CarInfo*>::iterator i4 = carInfos.begin();
while (i4 != carInfos.end()) {
delete *i4;
i4++;
}
carInfos.clear();
if (rawTiles)
delete [] rawTiles;
if (rawSprites)
delete [] rawSprites;
}
bool GraphicsBase::isAnimatedBlock(uint8_t area_code, uint8_t id) {
std::vector<LoadedAnim*>::iterator i = animations.begin();
while (i != animations.end()) {
if ((*i)->which == area_code && (*i)->block == id)
return true;
++i;
}
return false;
}
GraphicsBase::CarInfo* GraphicsBase::findCarByModel(PHYSFS_uint8 model) {
std::vector<CarInfo*>::iterator i = carInfos.begin();
while (i != carInfos.end()) {
if ((*i)->model == model)
return *i;
++i;
}
//throw std::string("Failed to find car by model");
std::ostringstream o;
o << "Searching for car model " << int(model) << " failed";
throw E_UNKNOWNKEY(o.str());
return NULL;
}
unsigned int GraphicsBase::getRandomPedRemapNumber() {
return int(rand() * (1.0f / (1.0f + RAND_MAX)) *
(lastValidPedRemap - firstValidPedRemap) +
firstValidPedRemap);
}
unsigned int GraphicsBase::getPedRemapNumberType(unsigned int _type) {
ERROR << "not implemented"<< std::endl;
return _type;
}
uint8_t GraphicsBase::getFormat() {
if (_topHeaderSize == 52)
return 0;
else if (_topHeaderSize == 64)
return 1;
throw E_INVALIDFORMAT("graphics-base header size");
return 255;
}
Graphics8Bit::Graphics8Bit(const std::string& style) : GraphicsBase() {
fd = PHYSFS_openRead(style.c_str());
if (fd == NULL) {
std::string style2(style);
std::transform(style2.begin(), style2.end(), style2.begin(), tolower);
fd = PHYSFS_openRead(style2.c_str());
}
if (fd == NULL) {
//throw std::string("FileNotFound: ") + style;
std::ostringstream o;
o << style << " with error: " << SDL_GetError();
throw E_FILENOTFOUND(o.str());
}
_topHeaderSize = 52;
rawTiles = NULL;
rawSprites = NULL;
masterRGB = NULL;
auxBlockTrailSize = 0;
loadHeader();
setupBlocking(style);
firstValidPedRemap = 131;
lastValidPedRemap = 187;
}
Graphics8Bit::~Graphics8Bit() {
//if (rawSprites)
// delete [] rawSprites;
if (masterRGB)
delete masterRGB;
}
void Graphics8Bit::dump() {
uint32_t gs = sideSize + lidSize + auxSize;
INFO << "* graphics info *" << std::endl <<
gs << " bytes in " << gs / 65536 << " pages " << gs / 4096
<< " images" << std::endl <<
spriteInfos.size() << " sprites (" << spriteInfoSize <<") total: " <<
spriteGraphicsSize << " bytes" << std::endl <<
"sprite numbers: " << std::endl <<
spriteNumbers.GTA_SPRITE_ARROW << " arrows" << std::endl <<
spriteNumbers.GTA_SPRITE_DIGITS << " digits" << std::endl <<
spriteNumbers.GTA_SPRITE_BOAT << " boats" << std::endl <<
spriteNumbers.GTA_SPRITE_BOX << " boxes" << std::endl <<
spriteNumbers.GTA_SPRITE_BUS << " buses" << std::endl <<
spriteNumbers.GTA_SPRITE_CAR << " cars" << std::endl <<
spriteNumbers.GTA_SPRITE_OBJECT << " objects" << std::endl <<
spriteNumbers.GTA_SPRITE_PED << " peds" << std::endl <<
spriteNumbers.GTA_SPRITE_SPEEDO << " speedos" << std::endl <<
spriteNumbers.GTA_SPRITE_TANK << " tanks" << std::endl <<
spriteNumbers.GTA_SPRITE_TRAFFIC_LIGHTS << " traffic lights" << std::endl <<
spriteNumbers.GTA_SPRITE_TRAIN << " trains" << std::endl <<
spriteNumbers.GTA_SPRITE_TRDOORS << " train doors" << std::endl <<
spriteNumbers.GTA_SPRITE_BIKE << " bikes" << std::endl <<
spriteNumbers.GTA_SPRITE_TRAM << " trams" << std::endl <<
spriteNumbers.GTA_SPRITE_WBUS << " wbuses" << std::endl <<
spriteNumbers.GTA_SPRITE_WCAR << " wcars" << std::endl <<
spriteNumbers.GTA_SPRITE_EX << " exes"<< std::endl <<
spriteNumbers.GTA_SPRITE_TUMCAR << " tumcars" << std::endl <<
spriteNumbers.GTA_SPRITE_TUMTRUCK << " tumtrucks" << std::endl <<
spriteNumbers.GTA_SPRITE_FERRY << " ferries"<< std::endl <<
"#object-info: " << objectInfos.size() << " #car-info: " << carInfos.size() << std::endl;
}
void Graphics8Bit::loadHeader() {
PHYSFS_uint32 vc;
PHYSFS_readULE32(fd, &vc);
if(vc != GTA_GRAPHICS_GRY) {
ERROR << "graphics file specifies version " << vc <<
" instead of " << GTA_GRAPHICS_GRY << std::endl;
throw E_INVALIDFORMAT("8-bit loader failed");
return;
}
PHYSFS_readULE32(fd, &sideSize);
PHYSFS_readULE32(fd, &lidSize);
PHYSFS_readULE32(fd, &auxSize);
PHYSFS_readULE32(fd, &animSize);
PHYSFS_readULE32(fd, &paletteSize);
PHYSFS_readULE32(fd, &remapSize);
PHYSFS_readULE32(fd, &remapIndexSize);
PHYSFS_readULE32(fd, &objectInfoSize);
PHYSFS_readULE32(fd, &carInfoSize);
PHYSFS_readULE32(fd, &spriteInfoSize);
PHYSFS_readULE32(fd, &spriteGraphicsSize);
PHYSFS_readULE32(fd, &spriteNumberSize);
INFO << "Block textures: S " << sideSize / 4096 << " L " <<
lidSize / 4096 << " A " << auxSize / 4096 << std::endl;
if (sideSize % 4096 != 0) {
ERROR << "Side-Block texture size is not a multiple of 4096" << std::endl;
return;
}
if (lidSize % 4096 != 0) {
ERROR << "Lid-Block texture size is not a multiple of 4096" << std::endl;
return;
}
if (auxSize % 4096 != 0) {
ERROR << "Aux-Block texture size is not a multiple of 4096" << std::endl;
return;
}
PHYSFS_uint32 tmp = sideSize / 4096 + lidSize / 4096 + auxSize / 4096;
tmp = tmp % 4;
if (tmp) {
auxBlockTrailSize = (4 - tmp) * 4096;
INFO << "adjusting aux-block by " << auxBlockTrailSize << std::endl;
}
INFO << "Anim size: " << animSize << " palette size: " << paletteSize <<
" remap size: " << remapSize << " remap-index size: " << remapIndexSize << std::endl;
INFO << "Obj-info size: " << objectInfoSize << " car-size: " << carInfoSize <<
" sprite-info size: " << spriteInfoSize << " graphic size: " << spriteGraphicsSize <<
" numbers s: " << spriteNumberSize << std::endl;
if (spriteNumberSize != 42) {
ERROR << "spriteNumberSize is " << spriteNumberSize << " (should be 42)" << std::endl;
return;
}
loadTileTextures();
loadAnim();
loadPalette();
loadRemapTables();
loadRemapIndex();
loadObjectInfo();
loadCarInfo();
loadSpriteInfo();
loadSpriteGraphics();
loadSpriteNumbers();
dump();
}
void GraphicsBase::loadAnim() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize;
PHYSFS_seek(fd, st);
PHYSFS_uint8 numAnim;
PHYSFS_read(fd, static_cast<void*>(&numAnim), 1, 1);
for (int i=0; i<numAnim;i++) {
uint8_t block, which, speed, frameCount;
PHYSFS_read(fd, static_cast<void*>(&block), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&which), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&speed), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&frameCount), 1, 1);
LoadedAnim *animation = new LoadedAnim(frameCount);
animation->block = block;
animation->which = which;
animation->speed = speed;
animation->frameCount = frameCount;
if (animation->frameCount > 180) {
ERROR << "found animation with " << int(animation->frameCount)
<< " frames ???" << std::endl;
}
for (int j=0; j<animation->frameCount; j++) {
uint8_t val;
PHYSFS_read(fd, static_cast<void*>(&val), 1, 1);
animation->frame[j] = val;
//PHYSFS_read(fd, static_cast<void*>(&animations[i].frame[j]), 1, 1);
}
animations.push_back(animation);
}
}
void Graphics8Bit::loadPalette() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize;
PHYSFS_seek(fd, st);
if (masterRGB)
delete masterRGB;
masterRGB = new RGBPalette(fd);
}
void Graphics8Bit::loadRemapTables() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize + paletteSize;
PHYSFS_seek(fd, st);
PHYSFS_read(fd, static_cast<void*>(remapTables), 256, 256);
/*
for (int i=0; i < 256; i++) {
for (int j = 0; j < 256; j++) {
std::cout << int(remapTables[i][j]) << " ";
}
std::cout << std::endl;
}*/
}
void Graphics8Bit::loadRemapIndex() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize + paletteSize +
remapSize;
PHYSFS_seek(fd, st);
PHYSFS_read(fd, static_cast<void*>(&remapIndex), 4, 256);
/*
std::cout << "LID remap tables" << std::endl;
for (int i=0; i<256; ++i) {
std::cout << i << ": " << int(remapIndex[i][0]) << ", " << int(remapIndex[i][1]) <<
", " << int(remapIndex[i][2]) << ", " << int(remapIndex[i][3]) << std::endl;
}*/
}
void GraphicsBase::loadObjectInfo_shared(PHYSFS_uint64 offset) {
PHYSFS_seek(fd, offset);
assert(objectInfoSize % 20 == 0);
int c = objectInfoSize / 20;
for (int i=0; i< c; i++) {
ObjectInfo *obj = new ObjectInfo();
PHYSFS_readULE32(fd, &obj->width);
PHYSFS_readULE32(fd, &obj->height);
PHYSFS_readULE32(fd, &obj->depth);
PHYSFS_readULE16(fd, &obj->sprNum);
PHYSFS_readULE16(fd, &obj->weight);
PHYSFS_readULE16(fd, &obj->aux);
PHYSFS_read(fd, static_cast<void*>(&obj->status), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&obj->numInto), 1, 1);
objectInfos.push_back(obj);
}
}
void Graphics8Bit::loadObjectInfo() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize + paletteSize +
remapSize + remapIndexSize;
loadObjectInfo_shared(st);
}
void GraphicsBase::loadCarInfo_shared(PHYSFS_uint64 offset) {
PHYSFS_seek(fd, offset);
//INFO << "starting at offset " << offset << std::endl;
PHYSFS_uint32 bytes_read = 0;
while (bytes_read < carInfoSize) {
//INFO << bytes_read << ": " << carInfoSize << std::endl;
CarInfo * car = new CarInfo();
PHYSFS_readSLE16(fd, &car->width);
PHYSFS_readSLE16(fd, &car->height);
PHYSFS_readSLE16(fd, &car->depth);
PHYSFS_readSLE16(fd, &car->sprNum);
PHYSFS_readSLE16(fd, &car->weightDescriptor);
PHYSFS_readSLE16(fd, &car->maxSpeed);
PHYSFS_readSLE16(fd, &car->minSpeed);
PHYSFS_readSLE16(fd, &car->acceleration);
PHYSFS_readSLE16(fd, &car->braking);
PHYSFS_readSLE16(fd, &car->grip);
PHYSFS_readSLE16(fd, &car->handling);
bytes_read += 2 * 11;
for (int i=0; i < 12; i++) {
PHYSFS_readSLE16(fd, &car->remap24[i].h);
PHYSFS_readSLE16(fd, &car->remap24[i].l);
PHYSFS_readSLE16(fd, &car->remap24[i].s);
}
bytes_read += 12 * 3 * 2;
for (int i=0; i < 12; i++) {
PHYSFS_read(fd, static_cast<void*>(&car->remap8[i]), 1, 1);
}
bytes_read += 12;
PHYSFS_read(fd, static_cast<void*>(&car->vtype), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->model), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->turning), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->damagable), 1, 1);
bytes_read += 4;
for (int i=0; i < 4; i++)
PHYSFS_readULE16(fd, &car->value[i]);
bytes_read += 4 * 2;
PHYSFS_read(fd, static_cast<void*>(&car->cx), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->cy), 1, 1);
PHYSFS_readULE32(fd, &car->moment);
bytes_read += 2 + 4;
PHYSFS_uint32 fixed_tmp;
PHYSFS_readULE32(fd, &fixed_tmp);
car->rbpMass = float(fixed_tmp)/65536;
PHYSFS_readULE32(fd, &fixed_tmp);
car->g1_Thrust = float(fixed_tmp)/65536;
PHYSFS_readULE32(fd, &fixed_tmp);
car->tyreAdhesionX = float(fixed_tmp)/65536;
PHYSFS_readULE32(fd, &fixed_tmp);
car->tyreAdhesionY = float(fixed_tmp)/65536;
PHYSFS_readULE32(fd, &fixed_tmp);
car->handBrakeFriction = float(fixed_tmp)/65536;
PHYSFS_readULE32(fd, &fixed_tmp);
car->footBrakeFriction = float(fixed_tmp)/65536;
PHYSFS_readULE32(fd, &fixed_tmp);
car->frontBrakeBias = float(fixed_tmp)/65536;
bytes_read += 7 * 4;
PHYSFS_readSLE16(fd, &car->turnRatio);
PHYSFS_readSLE16(fd, &car->driveWheelOffset);
PHYSFS_readSLE16(fd, &car->steeringWheelOffset);
bytes_read += 3 * 2;
PHYSFS_readULE32(fd, &fixed_tmp);
car->backEndSlideValue = float(fixed_tmp)/65536;
PHYSFS_readULE32(fd, &fixed_tmp);
car->handBrakeSlideValue = float(fixed_tmp)/65536;
bytes_read += 2 * 4;
PHYSFS_read(fd, static_cast<void*>(&car->convertible), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->engine), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->radio), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->horn), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->soundFunction), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&car->fastChangeFlag), 1, 1);
bytes_read += 6;
PHYSFS_readSLE16(fd, &car->numDoors);
bytes_read += 2;
if (car->numDoors > 2) {
WARN << "num-doors: " << car->numDoors << " > 2 ???" << std::endl;
car->numDoors = 0;
}
for (int i=0; i < car->numDoors; i++) {
PHYSFS_readSLE16(fd, &car->door[i].rpy);
PHYSFS_readSLE16(fd, &car->door[i].rpx);
PHYSFS_readSLE16(fd, &car->door[i].object);
PHYSFS_readSLE16(fd, &car->door[i].delta);
bytes_read += 4 * 2;
}
carInfos.push_back(car);
}
assert(bytes_read == carInfoSize);
}
void Graphics8Bit::loadCarInfo() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize + paletteSize +
remapSize + remapIndexSize + objectInfoSize;
loadCarInfo_shared(st);
}
void Graphics8Bit::loadSpriteInfo() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize + paletteSize +
remapSize + remapIndexSize + objectInfoSize + carInfoSize;
PHYSFS_seek(fd, st);
PHYSFS_uint8 v;
PHYSFS_uint32 w;
PHYSFS_uint32 _bytes_read = 0;
while (_bytes_read < spriteInfoSize) {
SpriteInfo *si = new SpriteInfo();
PHYSFS_read(fd, static_cast<void*>(&si->w), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&si->h), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&si->deltaCount), 1, 1);
PHYSFS_read(fd, static_cast<void*>(&v), 1, 1);
PHYSFS_readULE16(fd, &si->size);
PHYSFS_readULE32(fd, &w);
_bytes_read += 10;
//si->ptr = reinterpret_cast<unsigned char*>(w);
si->page = w / 65536;
si->xoffset = (w % 65536) % 256;
si->yoffset = (w % 65536) / 256;
si->clut = 0;
/*
std::cout << int(si->w) << "," << int(si->h) << " = " << si->size << " deltas: " << int(si->deltaCount) <<
" at " << w << std::endl;
*/
// sanity check
if (v)
WARN << "Compression flag active in sprite!" << std::endl;
if (int(si->w) * int(si->h) != int(si->size)) {
ERROR << "Sprite info size mismatch: " << int(si->w) << "x" << int(si->h) <<
" != " << si->size << std::endl;
return;
}
if (si->deltaCount > 32) {
ERROR << "Delta count of sprite is " << si->deltaCount << std::endl;
return;
}
for (PHYSFS_uint8 j = 0; j < 33; ++j) {
si->delta[j].size = 0;
si->delta[j].ptr = 0;
if (si->deltaCount && (j < si->deltaCount)) {
//std::cout << "reading " << int(j) << std::endl;
PHYSFS_readULE16(fd, &si->delta[j].size);
PHYSFS_readULE32(fd, &w);
_bytes_read += 6;
si->delta[j].ptr = reinterpret_cast<unsigned char*>(w);
}
}
spriteInfos.push_back(si);
}
st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize + paletteSize +
remapSize + remapIndexSize + objectInfoSize + carInfoSize + spriteInfoSize;
assert(PHYSFS_tell(fd) == PHYSFS_sint64(st));
}
void Graphics8Bit::loadSpriteGraphics() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize + paletteSize +
remapSize + remapIndexSize + objectInfoSize + carInfoSize + spriteInfoSize;
PHYSFS_seek(fd, st);
rawSprites = new unsigned char[spriteGraphicsSize];
assert(rawSprites != NULL);
PHYSFS_read(fd, static_cast<void*>(rawSprites), spriteGraphicsSize, 1);
if (spriteInfos.size() == 0) {
INFO << "No SpriteInfo post-loading work done - structure is empty" << std::endl;
return;
}
std::vector<SpriteInfo*>::const_iterator i = spriteInfos.begin();
std::vector<SpriteInfo*>::const_iterator end = spriteInfos.end();
PHYSFS_uint32 _pagewise = 256 * 256;
while (i != end) {
SpriteInfo *info = *i;
/*
PHYSFS_uint32 offset = reinterpret_cast<PHYSFS_uint32>(info->ptr);
PHYSFS_uint32 page = offset / 65536;
PHYSFS_uint32 y = (offset % 65536) / 256;
PHYSFS_uint32 x = (offset % 65536) % 256;
*/
//std::cout << int(info->w) << "x" << int(info->h) << " " << int(info->deltaCount) << " deltas" << std::endl;
//std::cout << offset << " page " << page << " x,y " << x <<","<<y<< std::endl;
//info->ptr = rawSprites + page * _pagewise + 256 * y + x;
for (uint8_t k = 0; k < info->deltaCount; ++k) {
PHYSFS_uint32 offset = reinterpret_cast<PHYSFS_uint32>(info->delta[k].ptr);
PHYSFS_uint32 page = offset / 65536;
PHYSFS_uint32 y = (offset % 65536) / 256;
PHYSFS_uint32 x = (offset % 65536) % 256;
info->delta[k].ptr = rawSprites + page * _pagewise + 256 * y + x;
}
i++;
}
return;
}
void GraphicsBase::loadSpriteNumbers_shared(PHYSFS_uint64 offset) {
PHYSFS_seek(fd, offset);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_ARROW);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_DIGITS);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_BOAT);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_BOX);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_BUS);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_CAR);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_OBJECT);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_PED);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_SPEEDO);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_TANK);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_TRAFFIC_LIGHTS);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_TRAIN);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_TRDOORS);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_BIKE);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_TRAM);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_WBUS);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_WCAR);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_EX);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_TUMCAR);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_TUMTRUCK);
PHYSFS_readULE16(fd, &spriteNumbers.GTA_SPRITE_FERRY);
}
void Graphics8Bit::loadSpriteNumbers() {
PHYSFS_uint64 st = static_cast<PHYSFS_uint64>(_topHeaderSize) +
sideSize + lidSize + auxSize + auxBlockTrailSize + animSize + paletteSize +
remapSize + remapIndexSize + objectInfoSize + carInfoSize +
spriteInfoSize + spriteGraphicsSize;
loadSpriteNumbers_shared(st);
}
void GraphicsBase::loadTileTextures() {
PHYSFS_seek(fd, static_cast<PHYSFS_uint64>(_topHeaderSize));
PHYSFS_uint64 ts = sideSize+lidSize+auxSize;
rawTiles = new unsigned char[ts];
int r = PHYSFS_read(fd, static_cast<void*>(rawTiles), 1, ts);
if ( PHYSFS_uint64(r) == ts )
return;
else if ( r == -1) {
INFO << "Could not read texture raw data" << std::endl;
return;
}
else
INFO << "This message should never be displayed! (" << std::endl;
}
void GraphicsBase::handleDeltas(const SpriteInfo & info, unsigned char* buffer, Uint32 delta) {
const unsigned int b_offset = 256 * info.yoffset + info.xoffset;
if (delta_is_a_set) {
Util::Set delta_set(32, (unsigned char*)&delta);
for (int i = 0; i < 20; ++i) {
if (delta_set.get_item(i)) {
assert(i < info.deltaCount);
const DeltaInfo & di = info.delta[i];
applyDelta(info, buffer, b_offset, di);
}
}
for (int i=20; i < 24; i++) {
if (delta_set.get_item(i)) {
const DeltaInfo & di = info.delta[i - 20 + 6];
applyDelta(info, buffer, b_offset, di, true);
}
}
for (int i=24; i < 28; i++) {
if (delta_set.get_item(i)) {
const DeltaInfo & di = info.delta[i - 24 + 11];
applyDelta(info, buffer, b_offset, di, true);
}
}
//assert(0);
}
else {
// delta is only an index; one to big
assert(delta <= info.deltaCount);
const DeltaInfo & di = info.delta[delta - 1];
applyDelta(info, buffer, b_offset, di);
}
}
unsigned char* Graphics8Bit::getSpriteBitmap(size_t id, int remap = -1, Uint32 delta = 0) {
SpriteInfo *info = spriteInfos[id];
assert(info != NULL);
//PHYSFS_uint32 offset = reinterpret_cast<PHYSFS_uint32>(info->ptr);
//const PHYSFS_uint32 page = offset / 65536;
const PHYSFS_uint32 y = info->yoffset; // (offset % 65536) / 256;
const PHYSFS_uint32 x = info->xoffset; // (offset % 65536) % 256;
const PHYSFS_uint32 page_size = 256 * 256;
unsigned char * page_start = rawSprites + info->page * page_size;// + 256 * y + x;
assert(page_start != NULL);
BufferCache & bcache = BufferCacheHolder::Instance();
unsigned char * dest = bcache.requestBuffer(page_size);
bcache.lockBuffer(dest);
unsigned char * result = dest;
assert(dest != NULL);
memcpy(dest, page_start, page_size);
if (delta > 0) {
handleDeltas(*info, result, delta);
/*
assert(delta < info->deltaCount);
DeltaInfo & di = info->delta[delta];
applyDelta(*info, result+256*y+x, di);
*/
}
if (remap > -1)
applyRemap(page_size, remap, result);
unsigned char* bigbuf = bcache.requestBuffer(page_size * 4);
masterRGB->apply(page_size, result, bigbuf, true);
assert(page_size > PHYSFS_uint32(info->w * info->h * 4));
for (uint16_t i = 0; i < info->h; i++) {
memcpy(result, bigbuf+(256*y+x)*4, info->w * 4);
result += info->w * 4;
bigbuf += 256 * 4;
}
return dest;
}
void GraphicsBase::applyDelta(const SpriteInfo & spriteInfo, unsigned
char* buffer, Uint32 page_offset, const DeltaInfo & deltaInfo, bool mirror) {
unsigned char* b = buffer + page_offset;
unsigned char* delta = deltaInfo.ptr;
PHYSFS_sint32 length_to_go = deltaInfo.size;
if (mirror) {
PHYSFS_uint32 doff = 0;
while (length_to_go > 0) {
PHYSFS_uint16* offset = (PHYSFS_uint16*) delta;
doff += *offset;
delta += 2;
unsigned char this_length = *delta;
++delta;
PHYSFS_uint32 noff = page_offset + doff;
PHYSFS_uint32 _y = noff / 256 * 256;
PHYSFS_uint32 _x = doff % 256;
for (int i=0; i < this_length; i++)
*(buffer + _y + spriteInfo.xoffset + spriteInfo.w - _x - i - 1) = *(delta+i);
length_to_go -= (this_length + 3);
doff += this_length;
delta += this_length;
}
return;
}
while (length_to_go > 0) {
PHYSFS_uint16* offset = (PHYSFS_uint16*) delta;
b += *offset;
delta += 2;
unsigned char this_length = *delta;
++delta;
memcpy(b, delta, this_length);
b += this_length;
delta += this_length;
length_to_go -= (this_length + 3);
}
}
void Graphics8Bit::applyRemap(unsigned int len, unsigned int which, unsigned char* buffer) {
assert(buffer!=NULL);
unsigned char* t = buffer;
for (unsigned int i = 0; i < len; ++i) {
*t = remapTables[which][*t]; //FIXME: is this the right order? Is this correct at all?
t++;
}
}
void GraphicsBase::prepareSideTexture(unsigned int idx, unsigned char* dst) {
assert(dst!=NULL);
++idx;
assert(rawTiles);
unsigned char* rt = rawTiles + (idx / 4) * 4096 * 4 + (idx % 4) * 64;
for (int i=0; i<64; i++) {
memcpy(dst, rt, 64);
dst += 64;
rt += 64*4;
}
}
unsigned char* Graphics8Bit::getSide(unsigned int idx, unsigned int palIdx, bool rgba = false) {
prepareSideTexture(idx-1, reinterpret_cast<unsigned char*>(tileTmp));
unsigned char *res;
if (rgba) {
masterRGB->apply(4096, reinterpret_cast<unsigned char*>(tileTmp),
reinterpret_cast<unsigned char*>(tileTmpRGBA), true);
res = reinterpret_cast<unsigned char*>(tileTmpRGBA);
}
else {
masterRGB->apply(4096, reinterpret_cast<unsigned char*>(tileTmp),
reinterpret_cast<unsigned char*>(tileTmpRGB), false);
res = reinterpret_cast<unsigned char*>(tileTmpRGB);
}
return res;
}
void GraphicsBase::prepareLidTexture(unsigned int idx, unsigned char* dst) {
assert(dst!=NULL);
unsigned char* rt = rawTiles;
assert(rawTiles);
idx += sideSize / 4096 + 1; // FIXME: assumes partition == block end
rt += (idx / 4) * 4096 * 4 + (idx % 4) * 64;
for (int i=0; i<64; i++) {
memcpy(dst, rt, 64);
dst += 64;
rt += 64*4;
}
}
unsigned char *Graphics8Bit::getLid(unsigned int idx, unsigned int palIdx, bool rgba = false) {
prepareLidTexture(idx-1, reinterpret_cast<unsigned char*>(tileTmp));
if (palIdx > 0)
applyRemap(4096, palIdx, reinterpret_cast<unsigned char*>(tileTmp));
unsigned char *res;
if (rgba) {
masterRGB->apply(4096, reinterpret_cast<unsigned char*>(tileTmp),
reinterpret_cast<unsigned char*>(tileTmpRGBA), true);
res = reinterpret_cast<unsigned char*>(tileTmpRGBA);
}
else {
masterRGB->apply(4096, reinterpret_cast<unsigned char*>(tileTmp),
reinterpret_cast<unsigned char*>(tileTmpRGB), false);
res = reinterpret_cast<unsigned char*>(tileTmpRGB);
}
return res;
}
void GraphicsBase::prepareAuxTexture(unsigned int idx, unsigned char* dst) {
assert(dst!=NULL);
unsigned char* rt = rawTiles;
assert(rawTiles);
idx += (sideSize+lidSize)/4096 + 1; // FIXME: assumes partition == block end
rt += (idx / 4) * 4096 * 4 + (idx % 4) * 64;
for (int i=0; i<64; i++) {
memcpy(dst, rt, 64);
dst += 64;
rt += 64*4;
}
}
unsigned char* Graphics8Bit::getAux(unsigned int idx, unsigned int palIdx, bool rgba = false) {
prepareAuxTexture(idx-1, reinterpret_cast<unsigned char*>(tileTmp));
unsigned char *res;
if (rgba) {
masterRGB->apply(4096, reinterpret_cast<unsigned char*>(tileTmp),
reinterpret_cast<unsigned char*>(tileTmpRGBA), true);
res = reinterpret_cast<unsigned char*>(tileTmpRGBA);
}
else {
masterRGB->apply(4096, reinterpret_cast<unsigned char*>(tileTmp),
reinterpret_cast<unsigned char*>(tileTmpRGB), false);
res = reinterpret_cast<unsigned char*>(tileTmpRGB);
}
return res;
}
unsigned char* GraphicsBase::getTmpBuffer(bool rgba = false) {
if (rgba)
return reinterpret_cast<unsigned char*>(tileTmpRGBA);
return reinterpret_cast<unsigned char*>(tileTmpRGB);
}
/* RGBPalette */
Graphics8Bit::RGBPalette::RGBPalette() {
}
Graphics8Bit::RGBPalette::RGBPalette(const std::string& palette) {
PHYSFS_file* fd = PHYSFS_openRead(palette.c_str());
if (fd == NULL) {
std::string pal2(palette);
transform(pal2.begin(), pal2.end(), pal2.begin(), tolower);
fd = PHYSFS_openRead(pal2.c_str());
}
if (!fd) {
std::ostringstream o;
o << palette << " with error: " << PHYSFS_getLastError();
throw E_FILENOTFOUND(o.str());
}
loadFromFile(fd);
}
Graphics8Bit::RGBPalette::RGBPalette(PHYSFS_file* fd) {
loadFromFile(fd);
}
int Graphics8Bit::RGBPalette::loadFromFile(PHYSFS_file* fd) {
PHYSFS_read(fd, static_cast<void*>(&data), 1, 256*3);
/*
int max_sum = 0;
for (int i = 1; i < 256; i+=3) {
int sum = int(data[i]) + int(data[i+1]) + int(data[i+2]);
if (sum > max_sum)
max_sum = sum;
}*/
return 0;
}
void Graphics8Bit::RGBPalette::apply(unsigned int len, const unsigned char* src,
unsigned char* dst, bool rgba ) {
for (unsigned int i = 0; i < len; i++) {
*dst = data[*src * 3 ]; ++dst;
*dst = data[*src * 3 + 1]; ++dst;
*dst = data[*src * 3 + 2]; ++dst;
if (rgba) {
if (*src == 0)
*dst = 0x00;
else
*dst = 0xff;
++dst;
}
++src;
}
}
}
Reference in New Issue View Git Blame Copy Permalink