random-mirrors
/
librw
mirror of https://github.com/aap/librw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

made (most of) streaming work on big endian

This commit is contained in:
aap 2020-05-01 08:42:56 +02:00
parent 3010dad0cc
commit e4b4bf9d16
25 changed files with 377 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/anim.cpp
View File

@ -128,8 +128,8 @@ Animation::streamReadLegacy(Stream *stream)
anim = Animation::create(interpInfo, numFrames, flags, duration);
HAnimKeyFrame *frames = (HAnimKeyFrame*)anim->keyframes;
for(int32 i = 0; i < anim->numFrames; i++){
stream->read(&frames[i].q, 4*4);
stream->read(&frames[i].t, 3*4);
stream->read32(&frames[i].q, 4*4);
stream->read32(&frames[i].t, 3*4);
frames[i].time = stream->readF32();
int32 prev = stream->readI32();
frames[i].prevFrame = &frames[prev];
@ -159,8 +159,8 @@ Animation::streamWriteLegacy(Stream *stream)
assert(interpInfo->id == 1);
HAnimKeyFrame *frames = (HAnimKeyFrame*)this->keyframes;
for(int32 i = 0; i < this->numFrames; i++){
stream->write(&frames[i].q, 4*4);
stream->write(&frames[i].t, 3*4);
stream->write32(&frames[i].q, 4*4);
stream->write32(&frames[i].t, 3*4);
stream->writeF32(frames[i].time);
stream->writeI32(frames[i].prevFrame - frames);
}

153
src/base.cpp
View File

@ -692,53 +692,166 @@ makePath(char *filename)
#endif
}
void
memNative32_func(void *data, uint32 size)
{
uint8 *bytes = (uint8*)data;
uint32 *words = (uint32*)data;
size >>= 2;
while(size--){
*words++ = (uint32)bytes[0] | (uint32)bytes[1]<<8 |
(uint32)bytes[2]<<16 | (uint32)bytes[3]<<24;
bytes += 4;
}
}
void
memNative16_func(void *data, uint32 size)
{
uint8 *bytes = (uint8*)data;
uint16 *words = (uint16*)data;
size >>= 1;
while(size--){
*words++ = (uint16)bytes[0] | (uint16)bytes[1]<<8;
bytes += 2;
}
}
void
memLittle32_func(void *data, uint32 size)
{
uint32 w;
uint8 *bytes = (uint8*)data;
uint32 *words = (uint32*)data;
size >>= 2;
while(size--){
w = *words++;
*bytes++ = w;
*bytes++ = w >> 8;
*bytes++ = w >> 16;
*bytes++ = w >> 24;
}
}
void
memLittle16_func(void *data, uint32 size)
{
uint16 w;
uint8 *bytes = (uint8*)data;
uint16 *words = (uint16*)data;
size >>= 1;
while(size--){
w = *words++;
*bytes++ = w;
*bytes++ = w >> 8;
}
}
uint32
Stream::write32(const void *data, uint32 length)
{
#ifdef BIGENDIAN
uint8 *src = (uint8*)data;
uint32 buf[256];
int32 n, len;
for(len = length >>= 2; len > 0; len -= 256){
n = len < 256 ? len : 256;
memcpy(buf, src, n*4);
memLittle16(buf, n*4);
write8(buf, n*4);
src += n*4;
}
return length;
#else
return write8(data, length);
#endif
}
uint32
Stream::write16(const void *data, uint32 length)
{
#ifdef BIGENDIAN
uint8 *src = (uint8*)data;
uint16 buf[256];
int32 n, len;
for(len = length >>= 1; len > 0; len -= 256){
n = len < 256 ? len : 256;
memcpy(buf, src, n*2);
memLittle16(buf, n*2);
write8(buf, n*2);
src += n*2;
}
return length;
#else
return write8(data, length);
#endif
}
uint32
Stream::read32(void *data, uint32 length)
{
uint32 ret;
ret = read8(data, length);
memNative32(data, length);
return ret;
}
uint32
Stream::read16(void *data, uint32 length)
{
uint32 ret;
ret = read8(data, length);
memNative16(data, length);
return ret;
}
int32
Stream::writeI8(int8 val)
{
return write(&val, sizeof(int8));
return write8(&val, sizeof(int8));
}
int32
Stream::writeU8(uint8 val)
{
return write(&val, sizeof(uint8));
return write8(&val, sizeof(uint8));
}
int32
Stream::writeI16(int16 val)
{
return write(&val, sizeof(int16));
return write16(&val, sizeof(int16));
}
int32
Stream::writeU16(uint16 val)
{
return write(&val, sizeof(uint16));
return write16(&val, sizeof(uint16));
}
int32
Stream::writeI32(int32 val)
{
return write(&val, sizeof(int32));
return write32(&val, sizeof(int32));
}
int32
Stream::writeU32(uint32 val)
{
return write(&val, sizeof(uint32));
return write32(&val, sizeof(uint32));
}
int32
Stream::writeF32(float32 val)
{
return write(&val, sizeof(float32));
return write32(&val, sizeof(float32));
}
int8
Stream::readI8(void)
{
int8 tmp;
read(&tmp, sizeof(int8));
read8(&tmp, sizeof(int8));
return tmp;
}
@ -746,7 +859,7 @@ uint8
Stream::readU8(void)
{
uint8 tmp;
read(&tmp, sizeof(uint8));
read8(&tmp, sizeof(uint8));
return tmp;
}
@ -754,7 +867,7 @@ int16
Stream::readI16(void)
{
int16 tmp;
read(&tmp, sizeof(int16));
read16(&tmp, sizeof(int16));
return tmp;
}
@ -762,7 +875,7 @@ uint16
Stream::readU16(void)
{
uint16 tmp;
read(&tmp, sizeof(uint16));
read16(&tmp, sizeof(uint16));
return tmp;
}
@ -770,7 +883,7 @@ int32
Stream::readI32(void)
{
int32 tmp;
read(&tmp, sizeof(int32));
read32(&tmp, sizeof(int32));
return tmp;
}
@ -778,7 +891,7 @@ uint32
Stream::readU32(void)
{
uint32 tmp;
read(&tmp, sizeof(uint32));
read32(&tmp, sizeof(uint32));
return tmp;
}
@ -786,7 +899,7 @@ float32
Stream::readF32(void)
{
float32 tmp;
read(&tmp, sizeof(float32));
read32(&tmp, sizeof(float32));
return tmp;
}
@ -798,7 +911,7 @@ StreamMemory::close(void)
}
uint32
StreamMemory::write(const void *data, uint32 len)
StreamMemory::write8(const void *data, uint32 len)
{
if(this->eof())
return 0;
@ -816,7 +929,7 @@ StreamMemory::write(const void *data, uint32 len)
}
uint32
StreamMemory::read(void *data, uint32 len)
StreamMemory::read8(void *data, uint32 len)
{
if(this->eof())
return 0;
@ -900,13 +1013,13 @@ StreamFile::close(void)
}
uint32
StreamFile::write(const void *data, uint32 length)
StreamFile::write8(const void *data, uint32 length)
{
return (uint32)fwrite(data, 1, length, this->file);
}
uint32
StreamFile::read(void *data, uint32 length)
StreamFile::read8(void *data, uint32 length)
{
return (uint32)fread(data, 1, length, this->file);
}
@ -936,7 +1049,7 @@ writeChunkHeader(Stream *s, int32 type, int32 size)
int32 type, size;
uint32 id;
} buf = { type, size, libraryIDPack(version, build) };
s->write(&buf, 12);
s->write32(&buf, 12);
return true;
}
@ -947,7 +1060,7 @@ readChunkHeaderInfo(Stream *s, ChunkHeaderInfo *header)
int32 type, size;
uint32 id;
} buf;
s->read(&buf, 12);
s->read32(&buf, 12);
if(s->eof())
return false;
assert(header != nil);

6
src/bmp.cpp
View File

@ -75,6 +75,7 @@ BMPheader::write(Stream *stream)
Image*
readBMP(const char *afilename)
{
ASSERTLITTLE;
Image *image;
char *filename;
uint32 length;
@ -99,7 +100,7 @@ readBMP(const char *afilename)
DIBheader dib;
if(!bmp.read(&file))
goto lose;
file.read(&dib, sizeof(dib));
file.read8(&dib, sizeof(dib));
file.seek(dib.headerSize-sizeof(dib)); // skip the part of the header we're ignoring
if(dib.headerSize <= 16){
dib.compression = 0;
@ -205,6 +206,7 @@ lose:
void
writeBMP(Image *image, const char *filename)
{
ASSERTLITTLE;
uint8 *p;
StreamFile file;
if(!file.open(filename, "wb")){
@ -239,7 +241,7 @@ writeBMP(Image *image, const char *filename)
dib.vres = 2835; // 72dpi
dib.paletteLen = 0;
dib.numImportant = 0;
file.write(&dib, dib.headerSize);
file.write8(&dib, dib.headerSize);
for(int i = 0; i < pallen; i++){
file.writeU8(image->palette[i*4+2]);

4
src/camera.cpp
View File

@ -455,7 +455,7 @@ Camera::streamRead(Stream *stream)
RWERROR((ERR_CHUNK, "STRUCT"));
return nil;
}
stream->read(&buf, sizeof(CameraChunkData));
stream->read32(&buf, sizeof(CameraChunkData));
Camera *cam = Camera::create();
cam->viewWindow = buf.viewWindow;
cam->viewOffset = buf.viewOffset;
@ -481,7 +481,7 @@ Camera::streamWrite(Stream *stream)
buf.farPlane = this->farPlane;
buf.fogPlane = this->fogPlane;
buf.projection = this->projection;
stream->write(&buf, sizeof(CameraChunkData));
stream->write32(&buf, sizeof(CameraChunkData));
s_plglist.streamWrite(stream, this);
return true;
}

16
src/clump.cpp
View File

@ -157,7 +157,7 @@ Clump::streamRead(Stream *stream)
RWERROR((ERR_CHUNK, "STRUCT"));
return nil;
}
stream->read(buf, length);
stream->read32(buf, length);
int32 numAtomics = buf[0];
int32 numLights = 0;
int32 numCameras = 0;
@ -292,10 +292,10 @@ Clump::streamWrite(Stream *stream)
int32 numAtomics = this->countAtomics();
int32 numLights = this->countLights();
int32 numCameras = this->countCameras();
int buf[3] = { numAtomics, numLights, numCameras };
int32 buf[3] = { numAtomics, numLights, numCameras };
size = version > 0x33000 ? 12 : 4;
writeChunkHeader(stream, ID_STRUCT, size);
stream->write(buf, size);
stream->write32(buf, size);
FrameList_ frmlst;
frmlst.numFrames = this->getFrame()->count();
@ -519,7 +519,7 @@ Atomic::streamReadClump(Stream *stream,
RWERROR((ERR_CHUNK, "STRUCT"));
return nil;
}
stream->read(buf, version < 0x30400 ? 12 : 16);
stream->read32(buf, version < 0x30400 ? 12 : 16);
Atomic *atomic = Atomic::create();
if(atomic == nil)
return nil;
@ -564,7 +564,7 @@ Atomic::streamWriteClump(Stream *stream, FrameList_ *frmlst)
if(version < 0x30400){
buf[1] = this->object.object.flags;
stream->write(buf, sizeof(int[3]));
stream->write32(buf, sizeof(int32[3]));
this->geometry->streamWrite(stream);
}else{
buf[1] = 0;
@ -576,7 +576,7 @@ Atomic::streamWriteClump(Stream *stream, FrameList_ *frmlst)
return false;
foundgeo:
buf[2] = this->object.object.flags;
stream->write(buf, sizeof(buf));
stream->write32(buf, sizeof(buf));
}
s_plglist.streamWrite(stream, this);
@ -632,7 +632,7 @@ Atomic::defaultRenderCB(Atomic *atomic)
static Stream*
readAtomicRights(Stream *stream, int32, void *, int32, int32)
{
stream->read(atomicRights, 8);
stream->read32(atomicRights, 8);
return stream;
}
@ -643,7 +643,7 @@ writeAtomicRights(Stream *stream, int32, void *object, int32, int32)
uint32 buffer[2];
buffer[0] = atomic->pipeline->pluginID;
buffer[1] = atomic->pipeline->pluginData;
stream->write(buffer, 8);
stream->write32(buffer, 8);
return stream;
}

38
src/d3d/d3d8.cpp
View File

@ -101,6 +101,7 @@ destroyNativeData(void *object, int32, int32)
Stream*
readNativeData(Stream *stream, int32, void *object, int32, int32)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
uint32 platform;
if(!findChunk(stream, ID_STRUCT, nil, nil)){
@ -118,7 +119,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
int32 size = stream->readI32();
uint8 *data = rwNewT(uint8, size, MEMDUR_FUNCTION | ID_GEOMETRY);
stream->read(data, size);
stream->read8(data, size);
uint8 *p = data;
header->serialNumber = *(uint16*)p; p += 2;
header->numMeshes = *(uint16*)p; p += 2;
@ -149,14 +150,14 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
assert(inst->indexBuffer == nil);
inst->indexBuffer = createIndexBuffer(inst->numIndices*2, false);
uint16 *indices = lockIndices(inst->indexBuffer, 0, 0, 0);
stream->read(indices, 2*inst->numIndices);
stream->read8(indices, 2*inst->numIndices);
unlockIndices(inst->indexBuffer);
inst->managed = 1;
assert(inst->vertexBuffer == nil);
inst->vertexBuffer = createVertexBuffer(inst->stride*inst->numVertices, 0, false);
uint8 *verts = lockVertices(inst->vertexBuffer, 0, 0, D3DLOCK_NOSYSLOCK);
stream->read(verts, inst->stride*inst->numVertices);
stream->read8(verts, inst->stride*inst->numVertices);
unlockVertices(inst->vertexBuffer);
inst++;
@ -167,6 +168,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
Stream*
writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
writeChunkHeader(stream, ID_STRUCT, len-12);
if(geometry->instData == nil ||
@ -200,17 +202,17 @@ writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
*p++ = inst->remapped;
inst++;
}
stream->write(data, size);
stream->write8(data, size);
rwFree(data);
inst = header->inst;
for(uint32 i = 0; i < header->numMeshes; i++){
uint16 *indices = lockIndices(inst->indexBuffer, 0, 0, 0);
stream->write(indices, 2*inst->numIndices);
stream->write8(indices, 2*inst->numIndices);
unlockIndices(inst->indexBuffer);
uint8 *verts = lockVertices(inst->vertexBuffer, 0, 0, D3DLOCK_NOSYSLOCK);
stream->write(verts, inst->stride*inst->numVertices);
stream->write8(verts, inst->stride*inst->numVertices);
unlockVertices(inst->vertexBuffer);
inst++;
}
@ -448,10 +450,10 @@ readAsImage(Stream *stream, int32 width, int32 height, int32 depth, int32 format
if(format & Raster::PAL4){
pallen = 16;
stream->read(palette, 4*32);
stream->read8(palette, 4*32);
}else if(format & Raster::PAL8){
pallen = 256;
stream->read(palette, 4*256);
stream->read8(palette, 4*256);
}
if(!Raster::formatHasAlpha(format))
for(int32 i = 0; i < pallen; i++)
@ -462,7 +464,7 @@ readAsImage(Stream *stream, int32 width, int32 height, int32 depth, int32 format
uint32 size = stream->readU32();
if(i == 0){
data = rwNewT(uint8, size, MEMDUR_FUNCTION | ID_IMAGE);
stream->read(data, size);
stream->read8(data, size);
}else
stream->seek(size);
}
@ -509,8 +511,8 @@ readNativeTexture(Stream *stream)
// Texture
tex->filterAddressing = stream->readU32();
stream->read(tex->name, 32);
stream->read(tex->mask, 32);
stream->read8(tex->name, 32);
stream->read8(tex->mask, 32);
// Raster
uint32 format = stream->readU32();
@ -547,7 +549,7 @@ readNativeTexture(Stream *stream)
// TODO: check if format supported and convert if necessary
if(pallength != 0)
stream->read(ras->palette, 4*pallength);
stream->read8(ras->palette, 4*pallength);
uint32 size;
uint8 *data;
@ -555,7 +557,7 @@ readNativeTexture(Stream *stream)
size = stream->readU32();
if(i < raster->getNumLevels()){
data = raster->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
stream->read(data, size);
stream->read8(data, size);
raster->unlock(i);
}else
stream->seek(size);
@ -572,8 +574,8 @@ writeNativeTexture(Texture *tex, Stream *stream)
// Texture
stream->writeU32(tex->filterAddressing);
stream->write(tex->name, 32);
stream->write(tex->mask, 32);
stream->write8(tex->name, 32);
stream->write8(tex->mask, 32);
// Raster
Raster *raster = tex->raster;
@ -608,9 +610,9 @@ writeNativeTexture(Texture *tex, Stream *stream)
stream->writeU8(compression);
if(raster->format & Raster::PAL4)
stream->write(ras->palette, 4*32);
stream->write8(ras->palette, 4*32);
else if(raster->format & Raster::PAL8)
stream->write(ras->palette, 4*256);
stream->write8(ras->palette, 4*256);
uint32 size;
uint8 *data;
@ -618,7 +620,7 @@ writeNativeTexture(Texture *tex, Stream *stream)
size = getLevelSize(raster, i);
stream->writeU32(size);
data = raster->lock(i, Raster::LOCKREAD);
stream->write(data, size);
stream->write8(data, size);
raster->unlock(i);
}
}

42
src/d3d/d3d9.cpp
View File

@ -149,6 +149,7 @@ destroyNativeData(void *object, int32, int32)
Stream*
readNativeData(Stream *stream, int32, void *object, int32, int32)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
uint32 platform;
if(!findChunk(stream, ID_STRUCT, nil, nil)){
@ -166,7 +167,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
int32 size = stream->readI32();
uint8 *data = rwNewT(uint8, size, MEMDUR_FUNCTION | ID_GEOMETRY);
stream->read(data, size);
stream->read8(data, size);
uint8 *p = data;
header->serialNumber = *(uint32*)p; p += 4;
header->numMeshes = *(uint32*)p; p += 4;
@ -196,19 +197,19 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
VertexElement elements[NUMDECLELT];
uint32 numDeclarations = stream->readU32();
stream->read(elements, numDeclarations*8);
stream->read8(elements, numDeclarations*8);
header->vertexDeclaration = createVertexDeclaration(elements);
assert(header->indexBuffer == nil);
header->indexBuffer = createIndexBuffer(header->totalNumIndex*2, false);
uint16 *indices = lockIndices(header->indexBuffer, 0, 0, 0);
stream->read(indices, 2*header->totalNumIndex);
stream->read8(indices, 2*header->totalNumIndex);
unlockIndices(header->indexBuffer);
VertexStream *s;
p = data;
for(int i = 0; i < 2; i++){
stream->read(p, 16);
stream->read8(p, 16);
s = &header->vertexStream[i];
s->vertexBuffer = (void*)(uintptr)*(uint32*)p; p += 4;
s->offset = 0; p += 4;
@ -223,7 +224,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
assert(s->vertexBuffer == nil);
s->vertexBuffer = createVertexBuffer(s->stride*header->totalNumVertex, 0, false);
uint8 *verts = lockVertices(s->vertexBuffer, 0, 0, D3DLOCK_NOSYSLOCK);
stream->read(verts, s->stride*header->totalNumVertex);
stream->read8(verts, s->stride*header->totalNumVertex);
unlockVertices(s->vertexBuffer);
}
@ -241,6 +242,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
Stream*
writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
writeChunkHeader(stream, ID_STRUCT, len-12);
if(geometry->instData == nil ||
@ -277,15 +279,15 @@ writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
*(uint32*)p = inst->numPrimitives; p += 4;
inst++;
}
stream->write(data, size);
stream->write8(data, size);
VertexElement elements[NUMDECLELT];
uint32 numElt = getDeclaration(header->vertexDeclaration, elements);
stream->writeU32(numElt);
stream->write(elements, 8*numElt);
stream->write8(elements, 8*numElt);
uint16 *indices = lockIndices(header->indexBuffer, 0, 0, 0);
stream->write(indices, 2*header->totalNumIndex);
stream->write8(indices, 2*header->totalNumIndex);
unlockIndices(header->indexBuffer);
VertexStream *s;
@ -298,12 +300,12 @@ writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
*(uint16*)p = s->geometryFlags; p += 2;
*p++ = s->managed;
*p++ = s->dynamicLock;
stream->write(data, 16);
stream->write8(data, 16);
if(s->vertexBuffer == nil)
continue;
uint8 *verts = lockVertices(s->vertexBuffer, 0, 0, D3DLOCK_NOSYSLOCK);
stream->write(verts, s->stride*header->totalNumVertex);
stream->write8(verts, s->stride*header->totalNumVertex);
unlockVertices(s->vertexBuffer);
}
@ -708,8 +710,8 @@ readNativeTexture(Stream *stream)
// Texture
tex->filterAddressing = stream->readU32();
stream->read(tex->name, 32);
stream->read(tex->mask, 32);
stream->read8(tex->name, 32);
stream->read8(tex->mask, 32);
// Raster
int32 format = stream->readI32();
@ -756,9 +758,9 @@ readNativeTexture(Stream *stream)
// TODO: check if format supported and convert if necessary
if(raster->format & Raster::PAL4)
stream->read(ext->palette, 4*32);
stream->read8(ext->palette, 4*32);
else if(raster->format & Raster::PAL8)
stream->read(ext->palette, 4*256);
stream->read8(ext->palette, 4*256);
uint32 size;
uint8 *data;
@ -766,7 +768,7 @@ readNativeTexture(Stream *stream)
size = stream->readU32();
if(i < raster->getNumLevels()){
data = raster->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
stream->read(data, size);
stream->read8(data, size);
raster->unlock(i);
}else
stream->seek(size);
@ -783,8 +785,8 @@ writeNativeTexture(Texture *tex, Stream *stream)
// Texture
stream->writeU32(tex->filterAddressing);
stream->write(tex->name, 32);
stream->write(tex->mask, 32);
stream->write8(tex->name, 32);
stream->write8(tex->mask, 32);
// Raster
Raster *raster = tex->raster;
@ -806,9 +808,9 @@ writeNativeTexture(Texture *tex, Stream *stream)
stream->writeU8(flags);
if(raster->format & Raster::PAL4)
stream->write(ext->palette, 4*32);
stream->write8(ext->palette, 4*32);
else if(raster->format & Raster::PAL8)
stream->write(ext->palette, 4*256);
stream->write8(ext->palette, 4*256);
uint32 size;
uint8 *data;
@ -816,7 +818,7 @@ writeNativeTexture(Texture *tex, Stream *stream)
size = getLevelSize(raster, i);
stream->writeU32(size);
data = raster->lock(i, Raster::LOCKREAD);
stream->write(data, size);
stream->write8(data, size);
raster->unlock(i);
}
}

30
src/d3d/xbox.cpp
View File

@ -67,6 +67,7 @@ destroyNativeData(void *object, int32, int32)
Stream*
readNativeData(Stream *stream, int32, void *object, int32, int32)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
uint32 vers;
uint32 platform;
@ -92,7 +93,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
// We don't have it but it's used for alignment.
header->data = rwNewT(uint8, size + 0x18, MEMDUR_EVENT | ID_GEOMETRY);
uint8 *p = header->data+0x18+4;
stream->read(p, size-4);
stream->read8(p, size-4);
header->size = size;
header->serialNumber = *(uint16*)p; p += 2;
@ -120,13 +121,14 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
header->end = inst;
header->vertexBuffer = rwNewT(uint8, header->stride*header->numVertices, MEMDUR_EVENT | ID_GEOMETRY);
stream->read(header->vertexBuffer, header->stride*header->numVertices);
stream->read8(header->vertexBuffer, header->stride*header->numVertices);
return stream;
}
Stream*
writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
writeChunkHeader(stream, ID_STRUCT, len-12);
if(geometry->instData == nil ||
@ -160,8 +162,8 @@ writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
inst++;
}
stream->write(header->data+0x18, header->size);
stream->write(header->vertexBuffer, header->stride*header->numVertices);
stream->write8(header->data+0x18, header->size);
stream->write8(header->vertexBuffer, header->stride*header->numVertices);
return stream;
}
@ -823,8 +825,8 @@ readNativeTexture(Stream *stream)
// Texture
tex->filterAddressing = stream->readU32();
stream->read(tex->name, 32);
stream->read(tex->mask, 32);
stream->read8(tex->name, 32);
stream->read8(tex->mask, 32);
// Raster
int32 format = stream->readI32();
@ -856,13 +858,13 @@ readNativeTexture(Stream *stream)
tex->raster = raster;
if(raster->format & Raster::PAL4)
stream->read(ras->palette, 4*32);
stream->read8(ras->palette, 4*32);
else if(raster->format & Raster::PAL8)
stream->read(ras->palette, 4*256);
stream->read8(ras->palette, 4*256);
// exploit the fact that mipmaps are allocated consecutively
uint8 *data = raster->lock(0, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
stream->read(data, totalSize);
stream->read8(data, totalSize);
raster->unlock(0);
return tex;
@ -877,8 +879,8 @@ writeNativeTexture(Texture *tex, Stream *stream)
// Texture
stream->writeU32(tex->filterAddressing);
stream->write(tex->name, 32);
stream->write(tex->mask, 32);
stream->write8(tex->name, 32);
stream->write8(tex->mask, 32);
// Raster
Raster *raster = tex->raster;
@ -901,13 +903,13 @@ writeNativeTexture(Texture *tex, Stream *stream)
stream->writeI32(totalSize);
if(raster->format & Raster::PAL4)
stream->write(ras->palette, 4*32);
stream->write8(ras->palette, 4*32);
else if(raster->format & Raster::PAL8)
stream->write(ras->palette, 4*256);
stream->write8(ras->palette, 4*256);
// exploit the fact that mipmaps are allocated consecutively
uint8 *data = raster->lock(0, Raster::LOCKREAD);
stream->write(data, totalSize);
stream->write8(data, totalSize);
raster->unlock(0);
}

18
src/d3d/xboxskin.cpp
View File

@ -30,6 +30,7 @@ struct NativeSkin
Stream*
readNativeSkin(Stream *stream, int32, void *object, int32 offset)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
uint32 vers, platform;
if(!findChunk(stream, ID_STRUCT, nil, &vers)){
@ -53,16 +54,16 @@ readNativeSkin(Stream *stream, int32, void *object, int32 offset)
skin->init(numBones, 0, 0);
NativeSkin *natskin = rwNewT(NativeSkin, 1, MEMDUR_EVENT | ID_SKIN);
skin->platformData = natskin;
stream->read(natskin->table1, 256*sizeof(int32));
stream->read(natskin->table2, 256*sizeof(int32));
stream->read32(natskin->table1, 256*sizeof(int32));
stream->read32(natskin->table2, 256*sizeof(int32));
natskin->numUsedBones = stream->readI32();
skin->numWeights = stream->readI32();
stream->seek(4); // skip pointer to vertexBuffer
natskin->stride = stream->readI32();
int32 size = geometry->numVertices*natskin->stride;
natskin->vertexBuffer = rwNewT(uint8, size, MEMDUR_EVENT | ID_SKIN);
stream->read(natskin->vertexBuffer, size);
stream->read(skin->inverseMatrices, skin->numBones*64);
stream->read8(natskin->vertexBuffer, size);
stream->read32(skin->inverseMatrices, skin->numBones*64);
readSkinSplitData(stream, skin);
return stream;
@ -71,6 +72,7 @@ readNativeSkin(Stream *stream, int32, void *object, int32 offset)
Stream*
writeNativeSkin(Stream *stream, int32 len, void *object, int32 offset)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
Skin *skin = *PLUGINOFFSET(Skin*, object, offset);
assert(skin->platformData);
@ -80,15 +82,15 @@ writeNativeSkin(Stream *stream, int32 len, void *object, int32 offset)
writeChunkHeader(stream, ID_STRUCT, len-12);
stream->writeU32(PLATFORM_XBOX);
stream->writeI32(skin->numBones);
stream->write(natskin->table1, 256*sizeof(int32));
stream->write(natskin->table2, 256*sizeof(int32));
stream->write32(natskin->table1, 256*sizeof(int32));
stream->write32(natskin->table2, 256*sizeof(int32));
stream->writeI32(natskin->numUsedBones);
stream->writeI32(skin->numWeights);
stream->writeU32(0xBADEAFFE); // pointer to vertexBuffer
stream->writeI32(natskin->stride);
stream->write(natskin->vertexBuffer,
stream->write8(natskin->vertexBuffer,
geometry->numVertices*natskin->stride);
stream->write(skin->inverseMatrices, skin->numBones*64);
stream->write32(skin->inverseMatrices, skin->numBones*64);
writeSkinSplitData(stream, skin);
return stream;

4
src/frame.cpp
View File

@ -380,7 +380,7 @@ FrameList_::streamRead(Stream *stream)
}
for(int32 i = 0; i < this->numFrames; i++){
Frame *f;
stream->read(&buf, sizeof(buf));
stream->read32(&buf, sizeof(buf));
this->frames[i] = f = Frame::create();
if(f == nil){
// TODO: clean up frames?
@ -425,7 +425,7 @@ FrameList_::streamWrite(Stream *stream)
buf.parent = findPointer(f->getParent(), (void**)this->frames,
this->numFrames);
buf.matflag = 0; //f->matflag;
stream->write(&buf, sizeof(buf));
stream->write32(&buf, sizeof(buf));
}
for(int32 i = 0; i < this->numFrames; i++)
Frame::s_plglist.streamWrite(stream, this->frames[i]);

46
src/geometry.cpp
View File

@ -143,24 +143,24 @@ Geometry::streamRead(Stream *stream)
RWERROR((ERR_CHUNK, "STRUCT"));
return nil;
}
stream->read(&buf, sizeof(buf));
stream->read32(&buf, sizeof(buf));
Geometry *geo = Geometry::create(buf.numVertices,
buf.numTriangles, buf.flags);
if(geo == nil)
return nil;
geo->addMorphTargets(buf.numMorphTargets-1);
if(version < 0x34000)
stream->read(&surfProps, 12);
stream->read32(&surfProps, 12);
if(!(geo->flags & NATIVE)){
if(geo->flags & PRELIT)
stream->read(geo->colors, 4*geo->numVertices);
stream->read8(geo->colors, 4*geo->numVertices);
for(int32 i = 0; i < geo->numTexCoordSets; i++)
stream->read(geo->texCoords[i],
stream->read32(geo->texCoords[i],
2*geo->numVertices*4);
for(int32 i = 0; i < geo->numTriangles; i++){
uint32 tribuf[2];
stream->read(tribuf, 8);
stream->read32(tribuf, 8);
geo->triangles[i].v[0] = tribuf[0] >> 16;
geo->triangles[i].v[1] = tribuf[0];
geo->triangles[i].v[2] = tribuf[1] >> 16;
@ -170,13 +170,13 @@ Geometry::streamRead(Stream *stream)
for(int32 i = 0; i < geo->numMorphTargets; i++){
MorphTarget *m = &geo->morphTargets[i];
stream->read(&m->boundingSphere, 4*4);
stream->read32(&m->boundingSphere, 4*4);
int32 hasVertices = stream->readI32();
int32 hasNormals = stream->readI32();
if(hasVertices)
stream->read(m->vertices, 3*geo->numVertices*4);
stream->read32(m->vertices, 3*geo->numVertices*4);
if(hasNormals)
stream->read(m->normals, 3*geo->numVertices*4);
stream->read32(m->normals, 3*geo->numVertices*4);
}
if(!findChunk(stream, ID_MATLIST, nil, nil)){
@ -239,15 +239,15 @@ Geometry::streamWrite(Stream *stream)
buf.numTriangles = this->numTriangles;
buf.numVertices = this->numVertices;
buf.numMorphTargets = this->numMorphTargets;
stream->write(&buf, sizeof(buf));
stream->write32(&buf, sizeof(buf));
if(version < 0x34000)
stream->write(fbuf, sizeof(fbuf));
stream->write32(fbuf, sizeof(fbuf));
if(!(this->flags & NATIVE)){
if(this->flags & PRELIT)
stream->write(this->colors, 4*this->numVertices);
stream->write8(this->colors, 4*this->numVertices);
for(int32 i = 0; i < this->numTexCoordSets; i++)
stream->write(this->texCoords[i],
stream->write32(this->texCoords[i],
2*this->numVertices*4);
for(int32 i = 0; i < this->numTriangles; i++){
uint32 tribuf[2];
@ -255,21 +255,21 @@ Geometry::streamWrite(Stream *stream)
this->triangles[i].v[1];
tribuf[1] = this->triangles[i].v[2] << 16 |
this->triangles[i].matId;
stream->write(tribuf, 8);
stream->write32(tribuf, 8);
}
}
for(int32 i = 0; i < this->numMorphTargets; i++){
MorphTarget *m = &this->morphTargets[i];
stream->write(&m->boundingSphere, 4*4);
stream->write32(&m->boundingSphere, 4*4);
if(!(this->flags & NATIVE)){
stream->writeI32(m->vertices != nil);
stream->writeI32(m->normals != nil);
if(m->vertices)
stream->write(m->vertices,
stream->write32(m->vertices,
3*this->numVertices*4);
if(m->normals)
stream->write(m->normals,
stream->write32(m->normals,
3*this->numVertices*4);
}else{
stream->writeI32(0);
@ -780,7 +780,7 @@ MaterialList::streamRead(Stream *stream, MaterialList *matlist)
matlist->space = numMat;
indices = (int32*)rwMalloc(numMat*4, MEMDUR_FUNCTION | ID_MATERIAL);
stream->read(indices, numMat*4);
stream->read32(indices, numMat*4);
Material *m;
for(int32 i = 0; i < numMat; i++){
@ -931,7 +931,7 @@ Material::streamRead(Stream *stream)
RWERROR((ERR_CHUNK, "STRUCT"));
return nil;
}
stream->read(&buf, sizeof(buf));
stream->read32(&buf, sizeof(buf));
Material *mat = Material::create();
if(mat == nil)
return nil;
@ -939,7 +939,7 @@ Material::streamRead(Stream *stream)
if(version < 0x30400)
mat->surfaceProps = defaultSurfaceProps;
else
stream->read(&mat->surfaceProps, sizeof(SurfaceProperties));
stream->read32(&mat->surfaceProps, sizeof(SurfaceProperties));
if(buf.textured){
if(!findChunk(stream, ID_TEXTURE, &length, nil)){
RWERROR((ERR_CHUNK, "TEXTURE"));
@ -973,14 +973,14 @@ Material::streamWrite(Stream *stream)
buf.flags = 0;
buf.unused = 0;
buf.textured = this->texture != nil;
stream->write(&buf, sizeof(buf));
stream->write32(&buf, sizeof(buf));
if(rw::version >= 0x30400){
float32 surfaceProps[3];
surfaceProps[0] = this->surfaceProps.ambient;
surfaceProps[1] = this->surfaceProps.specular;
surfaceProps[2] = this->surfaceProps.diffuse;
stream->write(surfaceProps, sizeof(surfaceProps));
stream->write32(surfaceProps, sizeof(surfaceProps));
}
if(this->texture)
@ -1008,7 +1008,7 @@ Material::streamGetSize(void)
static Stream*
readMaterialRights(Stream *stream, int32, void *, int32, int32)
{
stream->read(materialRights, 8);
stream->read32(materialRights, 8);
// printf("materialrights: %X %X\n", materialRights[0], materialRights[1]);
return stream;
}
@ -1020,7 +1020,7 @@ writeMaterialRights(Stream *stream, int32, void *object, int32, int32)
uint32 buffer[2];
buffer[0] = material->pipeline->pluginID;
buffer[1] = material->pipeline->pluginData;
stream->write(buffer, 8);
stream->write32(buffer, 8);
return stream;
}

16
src/geoplg.cpp
View File

@ -116,7 +116,7 @@ readMesh(Stream *stream, int32 len, void *object, int32, int32)
uint16 *indices;
Geometry *geo = (Geometry*)object;
stream->read(&mhs, sizeof(MeshHeaderStream));
stream->read32(&mhs, sizeof(MeshHeaderStream));
// Have to do this dance for War Drum's meshes
bool32 hasData = len > sizeof(MeshHeaderStream)+mhs.numMeshes*sizeof(MeshStream);
assert(geo->meshHeader == nil);
@ -128,7 +128,7 @@ readMesh(Stream *stream, int32 len, void *object, int32, int32)
mesh = mh->getMeshes();
indices = mesh->indices;
for(uint32 i = 0; i < mh->numMeshes; i++){
stream->read(&ms, sizeof(MeshStream));
stream->read32(&ms, sizeof(MeshStream));
mesh->numIndices = ms.numIndices;
mesh->material = geo->matList.materials[ms.matIndex];
if(geo->flags & Geometry::NATIVE){
@ -136,7 +136,7 @@ readMesh(Stream *stream, int32 len, void *object, int32, int32)
if(hasData){
mesh->indices = indices;
indices += mesh->numIndices;
stream->read(mesh->indices,
stream->read16(mesh->indices,
mesh->numIndices*2);
}
}else{
@ -146,7 +146,7 @@ readMesh(Stream *stream, int32 len, void *object, int32, int32)
int32 numIndices = mesh->numIndices;
for(; numIndices > 0; numIndices -= 256){
int32 n = numIndices < 256 ? numIndices : 256;
stream->read(indbuf, n*4);
stream->read32(indbuf, n*4);
for(int32 j = 0; j < n; j++)
ind[j] = indbuf[j];
ind += n;
@ -167,16 +167,16 @@ writeMesh(Stream *stream, int32, void *object, int32, int32)
mhs.flags = geo->meshHeader->flags;
mhs.numMeshes = geo->meshHeader->numMeshes;
mhs.totalIndices = geo->meshHeader->totalIndices;
stream->write(&mhs, sizeof(MeshHeaderStream));
stream->write32(&mhs, sizeof(MeshHeaderStream));
Mesh *mesh = geo->meshHeader->getMeshes();
for(uint32 i = 0; i < geo->meshHeader->numMeshes; i++){
ms.numIndices = mesh->numIndices;
ms.matIndex = geo->matList.findIndex(mesh->material);
stream->write(&ms, sizeof(MeshStream));
stream->write32(&ms, sizeof(MeshStream));
if(geo->flags & Geometry::NATIVE){
assert(geo->instData != nil);
if(geo->instData->platform == PLATFORM_WDGL)
stream->write(mesh->indices,
stream->write16(mesh->indices,
mesh->numIndices*2);
}else{
uint16 *ind = mesh->indices;
@ -185,7 +185,7 @@ writeMesh(Stream *stream, int32, void *object, int32, int32)
int32 n = numIndices < 256 ? numIndices : 256;
for(int32 j = 0; j < n; j++)
indbuf[j] = ind[j];
stream->write(indbuf, n*4);
stream->write32(indbuf, n*4);
ind += n;
}
}

12
src/gl/gl3raster.cpp
View File

@ -450,8 +450,8 @@ readNativeTexture(Stream *stream)
// Texture
tex->filterAddressing = stream->readU32();
stream->read(tex->name, 32);
stream->read(tex->mask, 32);
stream->read8(tex->name, 32);
stream->read8(tex->mask, 32);
// Raster
uint32 format = stream->readU32();
@ -473,7 +473,7 @@ readNativeTexture(Stream *stream)
size = stream->readU32();
if(i < raster->getNumLevels()){
data = raster->lock(i, Raster::LOCKWRITE|Raster::LOCKNOFETCH);
stream->read(data, size);
stream->read8(data, size);
raster->unlock(i);
}else
stream->seek(size);
@ -493,8 +493,8 @@ writeNativeTexture(Texture *tex, Stream *stream)
// Texture
stream->writeU32(tex->filterAddressing);
stream->write(tex->name, 32);
stream->write(tex->mask, 32);
stream->write8(tex->name, 32);
stream->write8(tex->mask, 32);
// Raster
int32 numLevels = raster->getNumLevels();
@ -511,7 +511,7 @@ writeNativeTexture(Texture *tex, Stream *stream)
size = getLevelSize(raster, i);
stream->writeU32(size);
data = raster->lock(i, Raster::LOCKREAD);
stream->write(data, size);
stream->write8(data, size);
raster->unlock(i);
}
}

14
src/gl/wdgl.cpp
View File

@ -257,11 +257,12 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
header->ibo = 0;
header->numAttribs = stream->readU32();
header->attribs = rwNewT(AttribDesc, header->numAttribs, MEMDUR_EVENT | ID_GEOMETRY);
stream->read(header->attribs,
stream->read32(header->attribs,
header->numAttribs*sizeof(AttribDesc));
header->dataSize = header->attribs[0].stride*geometry->numVertices;
header->data = rwNewT(uint8, header->dataSize, MEMDUR_EVENT | ID_GEOMETRY);
stream->read(header->data, header->dataSize);
ASSERTLITTLE;
stream->read8(header->data, header->dataSize);
return stream;
}
@ -274,8 +275,9 @@ writeNativeData(Stream *stream, int32, void *object, int32, int32)
return stream;
InstanceDataHeader *header = (InstanceDataHeader*)geometry->instData;
stream->writeU32(header->numAttribs);
stream->write(header->attribs, header->numAttribs*sizeof(AttribDesc));
stream->write(header->data, header->dataSize);
stream->write32(header->attribs, header->numAttribs*sizeof(AttribDesc));
ASSERTLITTLE;
stream->write8(header->data, header->dataSize);
return stream;
}
@ -555,7 +557,7 @@ readNativeSkin(Stream *stream, int32, void *object, int32 offset)
int32 numBones = stream->readI32();
skin->init(numBones, 0, 0);
stream->read(skin->inverseMatrices, skin->numBones*64);
stream->read32(skin->inverseMatrices, skin->numBones*64);
return stream;
}
@ -566,7 +568,7 @@ writeNativeSkin(Stream *stream, int32 len, void *object, int32 offset)
stream->writeU32(PLATFORM_GL);
Skin *skin = *PLUGINOFFSET(Skin*, object, offset);
stream->writeI32(skin->numBones);
stream->write(skin->inverseMatrices, skin->numBones*64);
stream->write32(skin->inverseMatrices, skin->numBones*64);
return stream;
}

8
src/hanim.cpp
View File

@ -314,8 +314,8 @@ hAnimFrameRead(Stream *stream, Animation *anim)
HAnimKeyFrame *frames = (HAnimKeyFrame*)anim->keyframes;
for(int32 i = 0; i < anim->numFrames; i++){
frames[i].time = stream->readF32();
stream->read(&frames[i].q, 4*4);
stream->read(&frames[i].t, 3*4);
stream->read32(&frames[i].q, 4*4);
stream->read32(&frames[i].t, 3*4);
int32 prev = stream->readI32()/0x24;
frames[i].prevFrame = &frames[prev];
}
@ -327,8 +327,8 @@ hAnimFrameWrite(Stream *stream, Animation *anim)
HAnimKeyFrame *frames = (HAnimKeyFrame*)anim->keyframes;
for(int32 i = 0; i < anim->numFrames; i++){
stream->writeF32(frames[i].time);
stream->write(&frames[i].q, 4*4);
stream->write(&frames[i].t, 3*4);
stream->write32(&frames[i].q, 4*4);
stream->write32(&frames[i].t, 3*4);
stream->writeI32((frames[i].prevFrame - frames)*0x24);
}
}

15
src/light.cpp
View File

@ -99,8 +99,7 @@ struct LightChunkData
float32 radius;
float32 red, green, blue;
float32 minusCosAngle;
uint16 flags;
uint16 type;
uint32 type_flags;
};
Light*
@ -113,8 +112,8 @@ Light::streamRead(Stream *stream)
RWERROR((ERR_CHUNK, "STRUCT"));
return nil;
}
stream->read(&buf, sizeof(LightChunkData));
Light *light = Light::create(buf.type);
stream->read32(&buf, sizeof(LightChunkData));
Light *light = Light::create(buf.type_flags>>16);
if(light == nil)
return nil;
light->radius = buf.radius;
@ -125,7 +124,7 @@ Light::streamRead(Stream *stream)
else
// tan -> -cos
light->minusCosAngle = -1.0f/sqrt(a*a+1.0f);
light->object.object.flags = (uint8)buf.flags;
light->object.object.flags = (uint8)buf.type_flags;
if(s_plglist.streamRead(stream, light))
return light;
light->destroy();
@ -146,9 +145,9 @@ Light::streamWrite(Stream *stream)
buf.minusCosAngle = this->minusCosAngle;
else
buf.minusCosAngle = tan(acos(-this->minusCosAngle));
buf.flags = this->object.object.flags;
buf.type = this->object.object.subType;
stream->write(&buf, sizeof(LightChunkData));
buf.type_flags = (uint32)this->object.object.flags |
(uint32)this->object.object.subType << 16;
stream->write32(&buf, sizeof(LightChunkData));
s_plglist.streamWrite(stream, this);
return true;

14
src/ps2/ps2.cpp
View File

@ -79,6 +79,7 @@ destroyNativeData(void *object, int32, int32)
Stream*
readNativeData(Stream *stream, int32, void *object, int32, int32)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
uint32 platform;
if(!findChunk(stream, ID_STRUCT, nil, nil)){
@ -100,7 +101,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
for(uint32 i = 0; i < header->numMeshes; i++){
InstanceData *instance = &header->instanceMeshes[i];
uint32 buf[2];
stream->read(buf, 8);
stream->read32(buf, 8);
instance->dataSize = buf[0];
instance->dataRaw = rwNewT(uint8, instance->dataSize+0x7F, MEMDUR_EVENT | ID_GEOMETRY);
instance->data = ALIGNPTR(instance->dataRaw, 0x80);
@ -108,7 +109,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
uint32 a = (uint32)instance->data;
assert(a % 0x10 == 0);
#endif
stream->read(instance->data, instance->dataSize);
stream->read8(instance->data, instance->dataSize);
#ifdef RW_PS2
if(!buf[1])
fixDmaOffsets(instance);
@ -123,6 +124,7 @@ readNativeData(Stream *stream, int32, void *object, int32, int32)
Stream*
writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
{
ASSERTLITTLE;
Geometry *geometry = (Geometry*)object;
writeChunkHeader(stream, ID_STRUCT, len-12);
if(geometry->instData == nil ||
@ -135,8 +137,8 @@ writeNativeData(Stream *stream, int32 len, void *object, int32, int32)
uint32 buf[2];
buf[0] = instance->dataSize;
buf[1] = unfixDmaOffsets(instance);
stream->write(buf, 8);
stream->write(instance->data, instance->dataSize);
stream->write32(buf, 8);
stream->write8(instance->data, instance->dataSize);
#ifdef RW_PS2
if(!buf[1])
fixDmaOffsets(instance);
@ -1243,7 +1245,7 @@ readADC(Stream *stream, int32, void *object, int32 offset, int32)
}
int32 size = adc->numBits+3 & ~3;
adc->adcBits = rwNewT(int8, size, MEMDUR_EVENT | ID_ADC);
stream->read(adc->adcBits, size);
stream->read8(adc->adcBits, size);
return stream;
}
@ -1259,7 +1261,7 @@ writeADC(Stream *stream, int32 len, void *object, int32 offset, int32)
}
stream->writeI32(adc->numBits);
int32 size = adc->numBits+3 & ~3;
stream->write(adc->adcBits, size);
stream->write8(adc->adcBits, size);
return stream;
}

26
src/ps2/ps2raster.cpp
View File

@ -2056,12 +2056,12 @@ readNativeTexture(Stream *stream)
RWERROR((ERR_CHUNK, "STRING"));
goto fail;
}
stream->read(tex->name, length);
stream->read8(tex->name, length);
if(!findChunk(stream, ID_STRING, &length, nil)){
RWERROR((ERR_CHUNK, "STRING"));
goto fail;
}
stream->read(tex->mask, length);
stream->read8(tex->mask, length);
// Raster
StreamRasterExt streamExt;
@ -2074,7 +2074,8 @@ readNativeTexture(Stream *stream)
RWERROR((ERR_CHUNK, "STRUCT"));
goto fail;
}
stream->read(&streamExt, 0x40);
ASSERTLITTLE;
stream->read8(&streamExt, 0x40);
/*
printf("%X %X %X %X %X %016llX %X %X %016llX %016llX %X %X %X %X\n",
streamExt.width,
@ -2154,10 +2155,10 @@ streamExt.mipmapVal);
goto fail;
}
if(streamExt.type < 2){
stream->read(raster->pixels, length);
stream->read8(raster->pixels, length);
}else{
stream->read(((Ps2Raster::PixelPtr*)raster->originalPixels)->pixels, natras->pixelSize);
stream->read(raster->palette-0x50, natras->paletteSize);
stream->read8(((Ps2Raster::PixelPtr*)raster->originalPixels)->pixels, natras->pixelSize);
stream->read8(raster->palette-0x50, natras->paletteSize);
}
//printf("\n");
return tex;
@ -2177,10 +2178,10 @@ writeNativeTexture(Texture *tex, Stream *stream)
stream->writeU32(tex->filterAddressing);
int32 len = strlen(tex->name)+4 & ~3;
writeChunkHeader(stream, ID_STRING, len);
stream->write(tex->name, len);
stream->write8(tex->name, len);
len = strlen(tex->mask)+4 & ~3;
writeChunkHeader(stream, ID_STRING, len);
stream->write(tex->mask, len);
stream->write8(tex->mask, len);
int32 sz = ras->pixelSize + ras->paletteSize;
writeChunkHeader(stream, ID_STRUCT, 12 + 64 + 12 + sz);
@ -2204,14 +2205,15 @@ writeNativeTexture(Texture *tex, Stream *stream)
streamExt.paletteSize = ras->paletteSize;
streamExt.totalSize = ras->totalSize;
streamExt.mipmapVal = ras->kl;
stream->write(&streamExt, 64);
ASSERTLITTLE;
stream->write8(&streamExt, 64);
writeChunkHeader(stream, ID_STRUCT, sz);
if(streamExt.type < 2){
stream->write(raster->pixels, sz);
stream->write8(raster->pixels, sz);
}else{
stream->write(((Ps2Raster::PixelPtr*)raster->originalPixels)->pixels, ras->pixelSize);
stream->write(raster->palette-0x50, ras->paletteSize);
stream->write8(((Ps2Raster::PixelPtr*)raster->originalPixels)->pixels, ras->pixelSize);
stream->write8(raster->palette-0x50, ras->paletteSize);
}
}

14
src/ps2/ps2skin.cpp
View File

@ -82,7 +82,7 @@ readNativeSkin(Stream *stream, int32, void *object, int32 offset)
RWERROR((ERR_PLATFORM, platform));
return nil;
}
stream->read(header, 4);
stream->read8(header, 4);
Skin *skin = rwNewT(Skin, 1, MEMDUR_EVENT | ID_SKIN);
*PLUGINOFFSET(Skin*, geometry, offset) = skin;
@ -98,9 +98,9 @@ readNativeSkin(Stream *stream, int32, void *object, int32 offset)
skin->numWeights = header[2];
if(!oldFormat)
stream->read(skin->usedBones, skin->numUsedBones);
stream->read8(skin->usedBones, skin->numUsedBones);
if(skin->numBones)
stream->read(skin->inverseMatrices, skin->numBones*64);
stream->read32(skin->inverseMatrices, skin->numBones*64);
// dummy data in case we need to write data in the new format
if(oldFormat){
@ -137,14 +137,14 @@ writeNativeSkin(Stream *stream, int32 len, void *object, int32 offset)
header[2] = skin->numWeights;
}
header[3] = 0;
stream->write(header, 4);
stream->write8(header, 4);
if(!oldFormat)
stream->write(skin->usedBones, skin->numUsedBones);
stream->write(skin->inverseMatrices, skin->numBones*64);
stream->write8(skin->usedBones, skin->numUsedBones);
stream->write32(skin->inverseMatrices, skin->numBones*64);
if(!oldFormat){
uint32 buffer[4] = { 0, 0, 0, 0, };
stream->write(buffer, 4*4);
stream->write32(buffer, 4*4);
writeSkinSplitData(stream, skin);
}

42
src/rwbase.h
View File

@ -404,6 +404,29 @@ enum PrimitiveType
PRIMTYPEPOINTLIST
};
/*
* Memory
*/
void memNative32_func(void *data, uint32 size);
void memNative16_func(void *data, uint32 size);
void memLittle32_func(void *data, uint32 size);
void memLittle16_func(void *data, uint32 size);
#ifdef BIGENDIAN
inline void memNative32(void *data, uint32 size) { memNative32_func(data, size); }
inline void memNative16(void *data, uint32 size) { memNative16_func(data, size); }
inline void memLittle32(void *data, uint32 size) { memLittle32_func(data, size); }
inline void memLittle16(void *data, uint32 size) { memLittle16_func(data, size); }
#define ASSERTLITTLE assert(0 && "unsafe code on big-endian")
#else
inline void memNative32(void *data, uint32 size) { }
inline void memNative16(void *data, uint32 size) { }
inline void memLittle32(void *data, uint32 size) { }
inline void memLittle16(void *data, uint32 size) { }
#define ASSERTLITTLE
#endif
/*
* Streams
*/
@ -413,12 +436,17 @@ void makePath(char *filename);
class Stream
{
public:
virtual void close(void) = 0;
virtual uint32 write(const void *data, uint32 length) = 0;
virtual uint32 read(void *data, uint32 length) = 0;
virtual ~Stream(void) { close(); }
virtual void close(void) {}
virtual uint32 write8(const void *data, uint32 length) = 0;
virtual uint32 read8(void *data, uint32 length) = 0;
virtual void seek(int32 offset, int32 whence = 1) = 0;
virtual uint32 tell(void) = 0;
virtual bool eof(void) = 0;
uint32 write32(const void *data, uint32 length);
uint32 write16(const void *data, uint32 length);
uint32 read32(void *data, uint32 length);
uint32 read16(void *data, uint32 length);
int32 writeI8(int8 val);
int32 writeU8(uint8 val);
int32 writeI16(int16 val);
@ -443,8 +471,8 @@ class StreamMemory : public Stream
uint32 position;
public:
void close(void);
uint32 write(const void *data, uint32 length);
uint32 read(void *data, uint32 length);
uint32 write8(const void *data, uint32 length);
uint32 read8(void *data, uint32 length);
void seek(int32 offset, int32 whence = 1);
uint32 tell(void);
bool eof(void);
@ -462,8 +490,8 @@ class StreamFile : public Stream
public:
StreamFile(void) { file = nil; }
void close(void);
uint32 write(const void *data, uint32 length);
uint32 read(void *data, uint32 length);
uint32 write8(const void *data, uint32 length);
uint32 read8(void *data, uint32 length);
void seek(int32 offset, int32 whence = 1);
uint32 tell(void);
bool eof(void);

24
src/skin.cpp
View File

@ -84,7 +84,7 @@ readSkinSplitData(Stream *stream, Skin *skin)
if(skin->numMeshes){
sz = skin->numBones + 2*(skin->numMeshes+skin->rleSize);
data = (int8*)rwMalloc(sz, MEMDUR_EVENT | ID_SKIN);
stream->read(data, sz);
stream->read8(data, sz);
skin->remapIndices = data;
skin->rleCount = (Skin::RLEcount*)(data + skin->numBones);
skin->rle = (Skin::RLE*)(data + skin->numBones + 2*skin->numMeshes);
@ -99,7 +99,7 @@ writeSkinSplitData(Stream *stream, Skin *skin)
stream->writeI32(skin->numMeshes);
stream->writeI32(skin->rleSize);
if(skin->numMeshes)
stream->write(skin->remapIndices,
stream->write8(skin->remapIndices,
skin->numBones + 2*(skin->numMeshes+skin->rleSize));
return stream;
}
@ -132,7 +132,7 @@ readSkin(Stream *stream, int32 len, void *object, int32 offset, int32)
}
}
stream->read(header, 4); // numBones, numUsedBones,
stream->read8(header, 4); // numBones, numUsedBones,
// numWeights, unused
Skin *skin = rwNewT(Skin, 1, MEMDUR_EVENT | ID_SKIN);
*PLUGINOFFSET(Skin*, geometry, offset) = skin;
@ -150,15 +150,15 @@ readSkin(Stream *stream, int32 len, void *object, int32 offset, int32)
skin->numWeights = header[2];
if(!oldFormat)
stream->read(skin->usedBones, skin->numUsedBones);
stream->read8(skin->usedBones, skin->numUsedBones);
if(skin->indices)
stream->read(skin->indices, geometry->numVertices*4);
stream->read8(skin->indices, geometry->numVertices*4);
if(skin->weights)
stream->read(skin->weights, geometry->numVertices*16);
stream->read32(skin->weights, geometry->numVertices*16);
for(int32 i = 0; i < skin->numBones; i++){
if(oldFormat)
stream->seek(4); // skip 0xdeaddead
stream->read(&skin->inverseMatrices[i*16], 64);
stream->read32(&skin->inverseMatrices[i*16], 64);
}
if(oldFormat){
@ -203,15 +203,15 @@ writeSkin(Stream *stream, int32 len, void *object, int32 offset, int32)
header[2] = skin->numWeights;
}
header[3] = 0;
stream->write(header, 4);
stream->write8(header, 4);
if(!oldFormat)
stream->write(skin->usedBones, skin->numUsedBones);
stream->write(skin->indices, geometry->numVertices*4);
stream->write(skin->weights, geometry->numVertices*16);
stream->write8(skin->usedBones, skin->numUsedBones);
stream->write8(skin->indices, geometry->numVertices*4);
stream->write32(skin->weights, geometry->numVertices*16);
for(int32 i = 0; i < skin->numBones; i++){
if(oldFormat)
stream->writeU32(0xdeaddead);
stream->write(&skin->inverseMatrices[i*16], 64);
stream->write32(&skin->inverseMatrices[i*16], 64);
}
if(!oldFormat)

8
src/texture.cpp
View File

@ -379,13 +379,13 @@ Texture::streamRead(Stream *stream)
RWERROR((ERR_CHUNK, "STRING"));
return nil;
}
stream->read(name, length);
stream->read8(name, length);
if(!findChunk(stream, ID_STRING, &length, nil)){
RWERROR((ERR_CHUNK, "STRING"));
return nil;
}
stream->read(mask, length);
stream->read8(mask, length);
Texture *tex = Texture::read(name, mask);
if(tex == nil){
@ -415,13 +415,13 @@ Texture::streamWrite(Stream *stream)
strncpy(buf, this->name, 32);
size = strlen(buf)+4 & ~3;
writeChunkHeader(stream, ID_STRING, size);
stream->write(buf, size);
stream->write8(buf, size);
memset(buf, 0, 36);
strncpy(buf, this->mask, 32);
size = strlen(buf)+4 & ~3;
writeChunkHeader(stream, ID_STRING, size);
stream->write(buf, size);
stream->write8(buf, size);
s_plglist.streamWrite(stream, this);
return true;

6
src/tga.cpp
View File

@ -47,6 +47,7 @@ struct PACKED_STRUCT TGAHeader
Image*
readTGA(const char *afilename)
{
ASSERTLITTLE;
TGAHeader header;
Image *image;
char *filename;
@ -60,7 +61,7 @@ readTGA(const char *afilename)
rwFree(filename);
StreamMemory file;
file.open(data, length);
file.read(&header, sizeof(header));
file.read8(&header, sizeof(header));
assert(header.imageType == 1 || header.imageType == 2);
file.seek(header.IDlen);
@ -125,6 +126,7 @@ readTGA(const char *afilename)
void
writeTGA(Image *image, const char *filename)
{
ASSERTLITTLE;
TGAHeader header;
StreamFile file;
if(!file.open(filename, "wb")){
@ -144,7 +146,7 @@ writeTGA(Image *image, const char *filename)
header.height = image->height;
header.depth = image->depth == 4 ? 8 : image->depth;
header.descriptor = 0x20 | (image->depth == 32 ? 8 : 0);
file.write(&header, sizeof(header));
file.write8(&header, sizeof(header));
uint8 *palette = header.colorMapType ? image->palette : nil;
uint8 (*color)[4] = (uint8(*)[4])palette;;

16
src/userdata.cpp
View File

@ -126,17 +126,17 @@ readUserData(Stream *stream, int32, void *object, int32 offset, int32)
for(i = 0; i < ext->numArrays; i++){
int32 len = stream->readI32();
a->name = (char*)udMalloc(len);
stream->read(a->name, len);
stream->read8(a->name, len);
a->datatype = stream->readU32();
a->numElements = stream->readI32();
switch(a->datatype){
case USERDATAINT:
a->data = (int32*)udMalloc(sizeof(int32)*a->numElements);
stream->read(a->data, sizeof(int32)*a->numElements);
stream->read32(a->data, sizeof(int32)*a->numElements);
break;
case USERDATAFLOAT:
a->data = (float32*)udMalloc(sizeof(float32)*a->numElements);
stream->read(a->data, sizeof(float32)*a->numElements);
stream->read32(a->data, sizeof(float32)*a->numElements);
break;
case USERDATASTRING:
strar = (char**)udMalloc(sizeof(char*)*a->numElements);
@ -144,7 +144,7 @@ readUserData(Stream *stream, int32, void *object, int32 offset, int32)
for(j = 0; j < a->numElements; j++){
len = stream->readI32();
strar[j] = (char*)udMalloc(len);
stream->read(strar[j], len);
stream->read8(strar[j], len);
}
break;
}
@ -166,22 +166,22 @@ writeUserData(Stream *stream, int32, void *object, int32 offset, int32)
for(i = 0; i < ext->numArrays; i++){
len = (int32)strlen(a->name)+1;
stream->writeI32(len);
stream->write(a->name, len);
stream->write8(a->name, len);
stream->writeU32(a->datatype);
stream->writeI32(a->numElements);
switch(a->datatype){
case USERDATAINT:
stream->write(a->data, sizeof(int32)*a->numElements);
stream->write32(a->data, sizeof(int32)*a->numElements);
break;
case USERDATAFLOAT:
stream->write(a->data, sizeof(float32)*a->numElements);
stream->write32(a->data, sizeof(float32)*a->numElements);
break;
case USERDATASTRING:
strar = (char**)a->data;
for(j = 0; j < a->numElements; j++){
len = (int32)strlen(strar[j])+1;
stream->writeI32(len);
stream->write(strar[j], len);
stream->write8(strar[j], len);
}
break;
}

16
src/uvanim.cpp
View File

@ -134,13 +134,13 @@ uvAnimStreamRead(Stream *stream, Animation *anim)
UVAnimCustomData *custom = UVAnimCustomData::get(anim);
UVAnimKeyFrame *frames = (UVAnimKeyFrame*)anim->keyframes;
stream->readI32();
stream->read(custom->name, 32);
stream->read(custom->nodeToUVChannel, 8*4);
stream->read8(custom->name, 32);
stream->read32(custom->nodeToUVChannel, 8*4);
custom->refCount = 1;
for(int32 i = 0; i < anim->numFrames; i++){
frames[i].time = stream->readF32();
stream->read(frames[i].uv, 6*4);
stream->read32(frames[i].uv, 6*4);
int32 prev = stream->readI32();
frames[i].prev = &frames[prev];
}
@ -152,12 +152,12 @@ uvAnimStreamWrite(Stream *stream, Animation *anim)
UVAnimCustomData *custom = UVAnimCustomData::get(anim);
UVAnimKeyFrame *frames = (UVAnimKeyFrame*)anim->keyframes;
stream->writeI32(0);
stream->write(custom->name, 32);
stream->write(custom->nodeToUVChannel, 8*4);
stream->write8(custom->name, 32);
stream->write32(custom->nodeToUVChannel, 8*4);
for(int32 i = 0; i < anim->numFrames; i++){
stream->writeF32(frames[i].time);
stream->write(frames[i].uv, 6*4);
stream->write32(frames[i].uv, 6*4);
stream->writeI32(frames[i].prev - frames);
}
}
@ -369,7 +369,7 @@ readUVAnim(Stream *stream, int32, void *object, int32 offset, int32)
uint32 bit = 1;
for(int32 i = 0; i < 8; i++){
if(mask & bit){
stream->read(name, 32);
stream->read8(name, 32);
Animation *anim = nil;
if(currentUVAnimDictionary)
anim = currentUVAnimDictionary->find(name);
@ -413,7 +413,7 @@ writeUVAnim(Stream *stream, int32 size, void *object, int32 offset, int32)
if(uvanim->interp[i]){
UVAnimCustomData *custom =
UVAnimCustomData::get(uvanim->interp[i]->currentAnim);
stream->write(custom->name, 32);
stream->write8(custom->name, 32);
}
}
return stream;