IMUValues Protocol::evalIMU(uint8_t inBuf[])
{
IMUValues result = {
readInt16(inBuf,0), readInt16(inBuf,1), readInt16(inBuf,2), readInt16(inBuf,3), readInt16(inBuf,4), readInt16(inBuf,5)
};
return result;
}
size_t Buffer::readString16(String16& _dst, size_t _offset)
{
if(_offset != npos)
_pf_readOffset = _offset;
int16_t strLen;
_pm_checkIfEnoughBytesToRead(sizeof(strLen), _pf_readOffset);
readInt16(strLen, _offset); // <-- readOffset += 2;
// Штука спорной нужности, так как откатывать всё это придётся ловцу исключения.
// Но на всякий случай сделаем так.
if(!_pm_checkIfEnoughBytesToRead_noEx(strLen, _pf_readOffset))
{
_pf_readOffset -= sizeof(strLen);
throw Exception_NotEnoughDataToRead();
}
int16_t ch;
for(int i = 0; i < strLen; ++i)
{
readInt16(ch);
_dst.push_back(ch);
}
return _pf_readOffset;
}
PGF readPGF(char *filename) {
FILE *f = fopen(filename, "rb");
if (f == NULL)
return NULL;
int maj_ver = readInt16(f);
int min_ver = readInt16(f);
Flags flags = readFlags(f);
struct _Abstract abstr;
readAbstr(f, &abstr);
int nConcr = readInt(f);
PGF pgf = (PGF) malloc(sizeof(struct _PGF)+sizeof(Concrete)*nConcr);
pgf->flags = flags;
pgf->abstract = abstr;
pgf->nConcr = nConcr;
int i;
// for (i = 0; i < nConcr; i++) {
// readConcr(f, &pgf->concretes[i]);
// }
fclose(f);
return pgf;
}
XYAngle Protocol::evalAtt(uint8_t inBuf[]) {
int16_t angx = readInt16(inBuf,0);
int16_t angy = readInt16(inBuf,1);
int16_t angle = readInt16(inBuf,2);
XYAngle ang = {
angx, angy, angle };
return ang;
}
void WAVStream::readFormatSubchunk(int size)
{
format_.audioFormat = readInt16();
format_.channelCount = readInt16();
format_.sampleRate = readInt32();
format_.byteRate = readInt32();
format_.blockAlign = readInt16();
format_.bitsPerSample = readInt16();
streamInfo_.sampleRate = format_.sampleRate;
}
MotorValues Protocol::evalMotor(uint8_t inBuf[])
{
int16_t motor1 = readInt16(inBuf,0);
int16_t motor2 = readInt16(inBuf,1);
int16_t motor3 = readInt16(inBuf,2);
int16_t motor4 = readInt16(inBuf,3);
MotorValues result = {
motor1, motor2, motor3, motor4
};
return result;
}
RCInput Protocol::evalRC(uint8_t inBuf[])
{
int16_t roll = readInt16(inBuf,0);
int16_t pitch = readInt16(inBuf,1);
int16_t yaw = readInt16(inBuf,2);
int16_t throttle = readInt16(inBuf,3);
RCInput result = {
roll, pitch, yaw, throttle
};
return result;
}
WaveInfo WaveReader::readHeader() {
int chunkId = 0;
bool dataChunk = false;
WaveInfo info;
while (!dataChunk) {
chunkId = readInt32();
switch (chunkId) {
case FORMAT:
//printf("Format\n");
info.formatSize = readInt32();
info.format = readInt16();
info.channels = readInt16();
info.sampleRate = readInt32();
info.bitsPerSecond = readInt32();
info.formatBlockAlign = readInt16();
info.bitDepth = readInt16();
if (info.formatSize == 18) {
int extraData = readInt16();
fseek(mWavFile, extraData, SEEK_CUR);
}
break;
case RIFF_HEADER:
//printf("Riff Header\n");
info.headerId = chunkId;
info.memSize = readInt32();
info.riffStyle = readInt32();
break;
case DATA:
//printf("Data\n");
dataChunk = true;
info.dataSize = readInt32();
break;
default:
int skipSize = readInt32();
//printf("Skip Size = %d\n", skipSize);
fseek(mWavFile, skipSize, SEEK_CUR);
break;
}
}
return info;
}
void MessageIn::postInit()
{
// Read the message ID
mId = readId();
IGNOREDEBUGLOG;
DEBUGLOG2("Receive packet", 0, "MessageIn");
readInt16("packet id");
}
void MessageIn::postInit(const char *const str)
{
// Read the message ID
mId = readId();
IGNOREDEBUGLOG;
DEBUGLOG2("Receive packet", 0, "MessageIn");
readInt16(str);
}
void File::readFloat16(float *dest) {
if (!readSafeCheck(dest)) return;
unsigned short v=0;
readInt16(&v);
unsigned int f=half_to_float(v);
*dest = *(float*)&(f);
}
MessageIn::MessageIn(const char *data, int length):
mData(data),
mLength(length),
mPos(0)
{
// Read the message ID
mId = readInt16();
}
void BaseSerializedObj::readInt16Array(int16_t** o)
{
uint64_t size = readUInt64();
*o = (int16_t *) malloc(size*byteSize_writeInt16);
uint64_t i = 0;
while(i != size)
{
(*o)[i] = readInt16();
i++;
}
}
int BinTreeNodeReader::readListSize(int token)
{
switch (token) {
case 0: return 0;
case 248: return readInt8(this->in);
case 249: return readInt16(this->in);
default:
throw new WAException("invalid list size in readListSize: token " + token, WAException::CORRUPT_STREAM_EX, 0);
}
return 0;
}
int WaveReader::readSample(int bytes) {
switch (bytes) {
case 1:
return readInt8();
case 2:
return readInt16();
case 4:
return readInt32();
}
return 0;
}
quint32 BinTreeNodeReader::readListSize(qint32 token, QDataStream& in)
{
int size;
if (token == 0)
size = 0;
else if (token == 0xf8)
size = readInt8(in);
else if (token == 0xf9)
size = readInt16(in);
else
throw ProtocolException("Invalid list size in readListSize: token 0x" + QString::number(token,16));
return size;
}
quint32 BinTreeNodeReader::readListSize(qint32 token, QDataStream& in)
{
int size;
if (token == 0)
size = 0;
else if (token == 0xf8)
size = readInt8(in);
else if (token == 0xf9)
size = readInt16(in);
else {
qDebug() << "Invalid list size in readListSize: token 0x" << QString::number(token,16);
//socket->disconnectFromHost();
Q_EMIT socketBroken();
}
return size;
}
void MessageIn::postInit(const char *const str,
const unsigned int version)
{
// Read the message ID
mId = readId();
mVersion = version;
IGNOREDEBUGLOG;
DEBUGLOG2("Receive packet", 0, "MessageIn");
#ifdef ENABLEDEBUGLOG
if (mVersion > 0)
{
const std::string verStr = toString(mVersion);
DEBUGLOG2("Version", 0, verStr.c_str());
}
#endif // ENABLEDEBUGLOG
readInt16(str);
}
std::string MessageIn::readString(int length)
{
// Get string length
if (length < 0)
length = readInt16();
// Make sure the string isn't erroneous
if (length < 0 || mPos + length > mLength)
{
mPos = mLength + 1;
return "";
}
// Read the string
char const *stringBeg = mData + mPos;
char const *stringEnd = (char const *)memchr(stringBeg, '\0', length);
std::string readString(stringBeg,
stringEnd ? stringEnd - stringBeg : length);
mPos += length;
return readString;
}
bool BinTreeNodeReader::readListSize(qint32 token, int& size)
{
size = -1;
if (token == 0) {
size = 0;
} else if (token == 0xf8) {
quint8 b;
if (!readInt8(b)) {
qDebug() << "failed to read 8bit size";
return false;
}
size = b;
} else if (token == 0xf9) {
qint16 b; //TODO: changed from quint16 to qint16. check if valid
if (!readInt16(b)) {
qDebug() << "failed to read 16bit size";
return false;
}
size = b;
} else {
throw ProtocolException("Invalid list size in readListSize: token 0x" + QString::number(token,16));
}
return true;
}
void ScriptInterpreter::cmd_loadConstant() {
int16 value = readInt16();
debug(4, "value = %04X (%d)", value, value);
_stack.setTop(value);
}
void ScriptInterpreter::cmd_branch() {
int16 ofs = readInt16();
_codeIp = _codeBase + ofs;
}
void ScriptInterpreter::cmd_branchFalse() {
int16 ofs = readInt16();
if (_stack.top() == 0)
_codeIp = _codeBase + ofs;
}
MessageIn::MessageIn(const char *data, unsigned int length):
Net::MessageIn(data, length)
{
// Read the message ID
mId = readInt16();
}
void ScriptInterpreter::execOpcode(byte opcode) {
int16 ofs;
debug(1, "opcode = %d", opcode);
switch (opcode) {
case 0:
{
// ok
_subCode = _code;
byte length = readByte();
debug(1, "length = %d", length);
uint16 index = readInt16();
debug(1, "callScriptFunction %d", index);
execScriptFunction(index);
_code += length - 2;
break;
}
case 1:
// ok
_regs.reg0 = readInt16();
break;
case 2:
// ok
_regs.reg1 = readInt16();
break;
case 3:
// ok
_regs.reg3 = readInt16();
break;
case 4:
// ok
_regs.reg5 = _regs.reg0;
break;
case 5:
// ok
_regs.reg3 = _regs.reg0;
break;
case 6:
// ok
_regs.reg1 = _regs.reg0;
break;
case 7:
_regs.reg1 = localRead16(_regs.reg3);
break;
case 8:
localWrite16(_regs.reg3, _regs.reg0);
break;
case 9:
localWrite16(readInt16(), _regs.reg0);
break;
case 10:
localWrite8(readInt16(), _regs.reg0);
break;
case 11:
localWrite16(readInt16(), _regs.reg5);
break;
case 12:
localWrite16(readInt16(), _regs.reg4);
break;
case 13:
localWrite16(readInt16(), _regs.reg3);
break;
case 14:
_regs.reg3 = localRead16(readInt16());
break;
case 15:
_regs.reg2 = localRead16(_regs.reg1);
break;
case 16:
_regs.reg2 = localRead16(_regs.reg1 + readInt16());
break;
case 17:
_regs.reg2 = _regs.reg0;
break;
case 18:
_regs.reg0 += readInt16();
break;
case 19:
localWrite16(_regs.reg3, localRead16(_regs.reg3) + _regs.reg0);
break;
case 20:
_regs.reg0 += _regs.reg2;
break;
case 21:
_regs.reg3 += _regs.sp;
break;
case 22:
_regs.reg1 += _regs.sp;
break;
case 23:
localWrite16(_regs.reg3, localRead16(_regs.reg3) - _regs.reg0);
break;
case 24:
_regs.reg0 /= readInt16();
break;
case 25:
localWrite16(_regs.reg3, localRead16(_regs.reg3) / _regs.reg0);
break;
case 26:
// NOP
break;
case 27:
_regs.reg0 *= readInt16();
break;
case 28:
localWrite16(_regs.reg3, localRead16(_regs.reg3) * _regs.reg0);
break;
case 29:
_regs.reg0 *= _regs.reg2;
break;
case 30:
localWrite16(_regs.reg3, localRead16(_regs.reg3) + 1);
break;
case 31:
localWrite16(_regs.reg3, localRead16(_regs.reg3) - 1);
break;
case 32:
_switchLocalDataFar = true;
break;
case 33:
_switchLocalDataToStack = true;
break;
case 34:
pushInt16(_regs.reg0);
break;
case 35:
pushInt16(_regs.reg1);
break;
case 36:
_regs.reg1 = popInt16();
break;
case 37:
_regs.reg0 = popInt16();
break;
case 38:
_regs.reg2 = -_regs.reg2;
break;
case 39:
_regs.reg8 = readInt16();
_cmpBitTest = false;
break;
case 40:
_regs.reg8 = _regs.reg0;
_cmpBitTest = false;
break;
case 41:
_regs.reg8 = readInt16();
_cmpBitTest = true;
break;
case 42:
_regs.reg8 = _regs.reg0;
_cmpBitTest = true;
break;
case 43:
_code = getSlotData(_regs.reg4) + _regs.reg0;
break;
case 44:
_code = getSlotData(_regs.reg5) + _regs.reg0;
_regs.reg4 = _regs.reg5;
_switchLocalDataNear = true;
break;
case 45:
pushInt16(_code - getSlotData(_regs.reg4));
pushInt16(_regs.reg4);
_code = getSlotData(_regs.reg4) + _regs.reg0;
break;
case 46:
pushInt16(_code - getSlotData(_regs.reg4));
pushInt16(_regs.reg4);
_code = getSlotData(_regs.reg5) + _regs.reg0;
_regs.reg4 = _regs.reg5;
_switchLocalDataNear = true;
break;
case 47:
_regs.reg4 = popInt16();
ofs = popInt16();
_code = getSlotData(_regs.reg4) + ofs;
_switchLocalDataNear = true;
break;
case 48:
_regs.reg4 = popInt16();
ofs = popInt16();
_code = getSlotData(_regs.reg4) + ofs;
_regs.sp += _regs.reg0;
_switchLocalDataNear = true;
break;
case 49:
ofs = readByte();
_code += ofs;
break;
case 50:
if (_cmpBitTest) {
_regs.reg1 &= _regs.reg8;
if (_regs.reg1 == 0)
_code += 4;
} else {
if (_regs.reg1 == _regs.reg8)
_code += 4;
}
_code++;
break;
case 51:
if (_cmpBitTest) {
_regs.reg1 &= _regs.reg8;
if (_regs.reg1 != 0)
_code += 4;
} else {
if (_regs.reg1 != _regs.reg8)
_code += 4;
}
_code++;
break;
case 52:
if ((uint16)_regs.reg1 >= (uint16)_regs.reg8)
_code += 4;
_code++;
break;
case 53:
if ((uint16)_regs.reg1 <= (uint16)_regs.reg8)
_code += 4;
_code++;
break;
case 54:
if ((uint16)_regs.reg1 < (uint16)_regs.reg8)
_code += 4;
_code++;
break;
case 55:
if ((uint16)_regs.reg1 > (uint16)_regs.reg8)
_code += 4;
_code++;
break;
default:
error("Invalid opcode %d", opcode);
}
}
void
OgreMeshReader::readGeometryVertexBufferData(UInt32 vertCount,
UInt16 bindIdx,
VertexElementStore &vertexElements,
BufferVertexMap &bufferMap )
{
OSG_OGRE_LOG(("OgreMeshReader::readGeometryVertexBufferData\n"));
for(UInt32 i = 0; i < vertCount; ++i)
{
for(UInt32 j = 0; j < bufferMap[bindIdx].size(); ++j)
{
UInt32 veIdx = bufferMap[bindIdx][j];
switch(vertexElements[veIdx].type)
{
case VET_FLOAT1:
{
Vec1f v(readReal32(_is));
vertexElements[veIdx].prop->addValue(v);
}
break;
case VET_FLOAT2:
{
Vec2f v;
v[0] = readReal32(_is);
v[1] = readReal32(_is);
vertexElements[veIdx].prop->addValue(v);
}
break;
case VET_FLOAT3:
{
Vec3f v;
v[0] = readReal32(_is);
v[1] = readReal32(_is);
v[2] = readReal32(_is);
vertexElements[veIdx].prop->addValue(v);
}
break;
case VET_FLOAT4:
{
Vec4f v;
v[0] = readReal32(_is);
v[1] = readReal32(_is);
v[2] = readReal32(_is);
v[3] = readReal32(_is);
vertexElements[veIdx].prop->addValue(v);
}
break;
case VET_COLOUR:
break;
case VET_SHORT1:
{
Vec1s v(readInt16(_is));
vertexElements[veIdx].prop->addValue(v);
}
break;
case VET_SHORT2:
{
Vec2s v;
v[0] = readInt16(_is);
v[1] = readInt16(_is);
vertexElements[veIdx].prop->addValue(v);
}
break;
case VET_SHORT3:
{
Vec3s v;
v[0] = readInt16(_is);
v[1] = readInt16(_is);
v[2] = readInt16(_is);
vertexElements[veIdx].prop->addValue(v);
}
break;
case VET_SHORT4:
{
Vec4s v;
v[0] = readInt16(_is);
v[1] = readInt16(_is);
v[2] = readInt16(_is);
v[3] = readInt16(_is);
vertexElements[veIdx].prop->addValue(v);
}
break;
case VET_UBYTE4:
readUInt32(_is);
SWARNING << "OgreMeshReader::readGeometryVertexBufferData: "
<< "type VET_UBYTE4 NIY" << std::endl;
break;
case VET_COLOUR_ARGB:
SWARNING << "OgreMeshReader::readGeometryVertexBufferData: "
<< "type VET_COLOUR_ARGB NIY" << std::endl;
break;
case VET_COLOUR_ABGR:
SWARNING << "OgreMeshReader::readGeometryVertexBufferData: "
<< "type VET_COLOUR_ABGR NIY" << std::endl;
break;
}
}
}
}
void initFileObject(lua_State* L)
{
luaL_newmetatable(L, meta<File>());
// Duplicate the metatable on the stack.
lua_pushvalue(L, -1);
// metatable.__index = metatable
lua_setfield(L, -2, "__index");
// Put the members into the metatable.
const luaL_Reg functions[] = {
{"__gc", [](lua_State* L) { return script::wrapped<File>(L, 1)->gc(L); }},
{"__index", [](lua_State* L) { return script::wrapped<File>(L, 1)->index(L); }},
{"__newindex", [](lua_State* L) { return script::wrapped<File>(L, 1)->newindex(L); }},
{"__tostring", [](lua_State* L) { return script::wrapped<File>(L, 1)->tostring(L); }},
{"__pairs", [](lua_State* L) { return script::wrapped<File>(L, 1)->pairs(L); }},
{"close", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
file->close();
return 0;
}},
{"readUnsigned8", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
uint8_t value;
if(file->readUnsigned8(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readUnsigned16", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
uint16_t value;
if(file->readUnsigned16(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readUnsigned32", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
uint32_t value;
if(file->readUnsigned32(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readInt8", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
int8_t value;
if(file->readInt8(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readInt16", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
int16_t value;
if(file->readInt16(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readInt32", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
int32_t value;
if(file->readInt32(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readFloat", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
float value;
if(file->readFloat(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readDouble", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
double value;
if(file->readDouble(value))
{
script::push(L, value);
return 1;
}
return 0;
}},
{"readString", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto blockSize = script::get<int>(L, 2);
std::string buffer(blockSize, 0);
if(file->readString(buffer))
{
lua_pushlstring(L, buffer.data(), buffer.size());
return 1;
}
return 0;
}},
{"readLine", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
std::string value;
if(file->readLine(value))
{
script::push(L, value.c_str());
return 1;
}
return 0;
}},
{"readFully", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
// Get current position.
auto pos = file->tell();
if(pos == -1)
{
return 0;
}
// Length to read = position of end - current.
auto length = 0;
if(!file->seek(pos, FileSeekMode::End))
{
return 0;
}
length = file->tell() - pos;
if(!file->seek(pos, FileSeekMode::Start))
{
return 0;
}
// Read the entire file into a string.
std::string buf(length, 0);
if(file->readString(buf))
{
lua_pushlstring(L, buf.data(), buf.size());
return 1;
}
return 0;
}},
{"writeUnsigned8", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeUnsigned8(value));
return 1;
}},
{"writeUnsigned16", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeUnsigned16(value));
return 1;
}},
{"writeUnsigned32", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeUnsigned32(value));
return 1;
}},
{"writeInt8", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeInt8(value));
return 1;
}},
{"writeInt16", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeInt16(value));
return 1;
}},
{"writeInt32", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<int>(L, 2);
script::push(L, file->writeInt32(value));
return 1;
}},
{"writeFloat", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<double>(L, 2);
script::push(L, file->writeFloat((float) value));
return 1;
}},
{"writeDouble", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto value = script::get<double>(L, 2);
script::push(L, file->writeDouble(value));
return 1;
}},
{"writeString", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
size_t length = 0;
const char* buffer = luaL_checklstring(L, 2, &length);
std::string value(buffer, buffer + length);
script::push(L, file->writeString(value));
return 1;
}},
{"writeLine", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
size_t length = 0;
const char* buffer = luaL_checklstring(L, 2, &length);
std::string value(buffer, buffer + length);
script::push(L, file->writeLine(value));
return 1;
}},
{"tell", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
script::push(L, int(file->tell()));
return 1;
}},
{"seek", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
auto position = script::get<int>(L, 2);
auto mode = FileSeekMode(script::get<int>(L, 3));
script::push(L, file->seek(position, mode));
return 1;
}},
{"flush", [](lua_State* L)
{
auto file = script::ptr<File>(L, 1);
file->flush();
return 0;
}},
{nullptr, nullptr},
};
luaL_setfuncs(L, functions, 0);
lua_pop(L, 1);
// Push plum namespace.
lua_getglobal(L, "plum");
// plum.File = <function create>
script::push(L, "File");
lua_pushcfunction(L, [](lua_State* L)
{
auto filename = script::get<const char*>(L, 1);
auto mode = FileOpenMode(script::get<int>(L, 2));
auto f = new File(filename, mode);
// Failure.
if(!f->isActive())
{
delete f;
return 0;
}
script::push(L, f, LUA_NOREF);
return 1;
});
lua_settable(L, -3);
// Pop plum namespace.
lua_pop(L, 1);
}
void ScriptInterpreter::cmd_loadVariable() {
int16 variable = readInt16();
int16 value = _vm->_dat->getVar(variable);
debug(4, "variable = %d; value = %d (%04X)", variable, value, value);
_stack.setTop(value);
}
void ScriptInterpreter::cmd_set() {
int16 variable = readInt16();
debug(4, "var(%d) = %04d (%d)", variable, _stack.top(), _stack.top());
_vm->_dat->setVar(variable, _stack.top());
}
void MapFileSerializer::importMapFile( Ogre::DataStreamPtr& stream, WorldMapFile& dest )
{
const auto fileSize = stream->size();
auto numBlocks = fileSize / kWorldMapBlockSize;
for ( unsigned int j=0; j<numBlocks; j++ )
{
SBlock block;
const size_t basePos = kWorldMapBlockSize*j;
stream->seek( basePos );
// Read the offset to compressed data in this block
BlockHeader header = {};
for ( auto i=0u; i<16; i++)
{
readUInt32( stream, header.mCompressedDataOffsets[i] );
}
for ( auto i=0u; i<16; i++)
{
SBlockPart blockPart;
// Go to the offset
stream->seek( basePos + header.mCompressedDataOffsets[i] );
// Read the size of the compressed data
uint32 compressedDataSize = 0;
readUInt32( stream, compressedDataSize );
// Go back to before the compressed data size
stream->seek( basePos + header.mCompressedDataOffsets[i] );
// Read the compressed data into a temp buffer, including the compressed data size
std::vector<uint8> buffer( compressedDataSize + 4 );
stream->read(buffer.data(), buffer.size());
// Decompress the data
auto decompressed = LzsBuffer::Decompress(buffer);
Ogre::MemoryDataStream decStream(decompressed.data(), decompressed.size(), false, true);
readUInt16(decStream, blockPart.mHeader.NumberOfTriangles);
readUInt16(decStream, blockPart.mHeader.NumberOfVertices);
/*
std::cout << "block: " << j
<< " from offset " << header.mCompressedDataOffsets[i]
<< " old size: " << buffer.size()
<< " decompressed size is " << decompressed.size()
<< " header is tris: " << blockPart.mHeader.NumberOfTriangles
<< " verts " << blockPart.mHeader.NumberOfVertices
<< std::endl;*/
blockPart.mTris.resize(blockPart.mHeader.NumberOfTriangles);
for ( int k=0; k<blockPart.mHeader.NumberOfTriangles; k++)
{
BlockTriangle& s = blockPart.mTris[k];
readUInt8( decStream, s.Vertex0Index );
readUInt8( decStream, s.Vertex1Index );
readUInt8( decStream, s.Vertex2Index );
readUInt8( decStream, s.WalkabilityInfo );
//readUInt8( decStream, s.Unknown );
readUInt8( decStream, s.uVertex0 );
readUInt8( decStream, s.vVertex0 );
readUInt8( decStream, s.uVertex1 );
readUInt8( decStream, s.vVertex1 );
readUInt8( decStream, s.uVertex2 );
readUInt8( decStream, s.vVertex2 );
readUInt16( decStream, s.TextureInfo );
s.TextureInfo = s.TextureInfo & 0x1FF;
//readUInt16( decStream, s.Location );
/*
std::cout << "v0: " << int(s.Vertex0Index)
<< " v1 " << int(s.Vertex1Index)
<< " v2 " << int(s.Vertex2Index)
<< " walk " << int(s.WalkabilityInfo)
<< " u1 " << int(s.uVertex1)
<< " v1 " << int(s.vVertex1)
<< " v2 " << int(s.uVertex2)
<< " u2 " << int(s.vVertex2)
<< " texture " << s.TextureInfo
<< " locId " << s.Location
<< std::endl;*/
}
blockPart.mNormal.resize( blockPart.mHeader.NumberOfVertices );
blockPart.mVertices.resize( blockPart.mHeader.NumberOfVertices );
// All verts
for ( int k=0; k<blockPart.mHeader.NumberOfVertices; k++)
{
Vertex& v = blockPart.mVertices[k];
readInt16( decStream, v.X );
readInt16( decStream, v.Y );
readInt16( decStream, v.Z );
readUInt16( decStream, v.Unused );
}
// Then all normals
for ( int k=0; k<blockPart.mHeader.NumberOfVertices; k++)
{
Normal& n = blockPart.mNormal[k];
readInt16( decStream, n.X );
readInt16( decStream, n.Y );
readInt16( decStream, n.Z );
readUInt16( decStream, n.Unused );
}
block.mMeshes.push_back( blockPart );
}
mBlocks.push_back(block);
}
}
