mirror of
https://github.com/scummvm/scummvm.git
synced 2025-04-02 10:52:32 -04:00
241 lines
7.2 KiB
C++
241 lines
7.2 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "twine/parser/body.h"
|
|
#include "twine/renderer/renderer.h"
|
|
#include "common/memstream.h"
|
|
|
|
#define INFO_TRI 1
|
|
#define INFO_ANIM 2
|
|
|
|
namespace TwinE {
|
|
|
|
void BodyData::reset() {
|
|
_vertices.clear();
|
|
_bones.clear();
|
|
_normals.clear();
|
|
_polygons.clear();
|
|
_spheres.clear();
|
|
_lines.clear();
|
|
}
|
|
|
|
void BodyData::loadVertices(Common::SeekableReadStream &stream) {
|
|
const uint16 numVertices = stream.readUint16LE();
|
|
if (stream.eos())
|
|
return;
|
|
|
|
_vertices.reserve(numVertices);
|
|
for (uint16 i = 0U; i < numVertices; ++i) {
|
|
const int16 x = stream.readSint16LE();
|
|
const int16 y = stream.readSint16LE();
|
|
const int16 z = stream.readSint16LE();
|
|
const uint16 bone = 0;
|
|
_vertices.push_back({x, y, z, bone});
|
|
}
|
|
}
|
|
|
|
void BodyData::loadBones(Common::SeekableReadStream &stream) {
|
|
const uint16 numBones = stream.readUint16LE();
|
|
if (stream.eos())
|
|
return;
|
|
|
|
_bones.reserve(numBones);
|
|
for (uint16 i = 0; i < numBones; ++i) {
|
|
const int16 firstPoint = stream.readSint16LE() / 6;
|
|
const int16 numPoints = stream.readSint16LE();
|
|
const int16 basePoint = stream.readSint16LE() / 6;
|
|
const int16 baseElementOffset = stream.readSint16LE();
|
|
BoneFrame boneframe;
|
|
boneframe.type = (BoneType)stream.readSint16LE();
|
|
boneframe.x = stream.readSint16LE();
|
|
boneframe.y = stream.readSint16LE();
|
|
boneframe.z = stream.readSint16LE();
|
|
/*int16 unk1 =*/ stream.readSint16LE();
|
|
const int16 numNormals = stream.readSint16LE();
|
|
/*int16 unk2 =*/ stream.readSint16LE();
|
|
/*int32 field_18 =*/ stream.readSint32LE();
|
|
/*int32 y =*/ stream.readSint32LE();
|
|
/*int32 field_20 =*/ stream.readSint32LE();
|
|
/*int32 field_24 =*/ stream.readSint32LE();
|
|
|
|
// PatchObjet in original sources
|
|
BodyBone bone;
|
|
bone.parent = baseElementOffset == -1 ? 0xffff : baseElementOffset / 38;
|
|
bone.vertex = basePoint;
|
|
bone.firstVertex = firstPoint;
|
|
bone.numVertices = numPoints;
|
|
bone.initalBoneState = boneframe;
|
|
bone.numNormals = numNormals;
|
|
|
|
// assign the bone index to the vertices
|
|
for (int j = 0; j < numPoints; ++j) {
|
|
_vertices[firstPoint + j].bone = i;
|
|
}
|
|
|
|
_bones.push_back(bone);
|
|
_boneStates[i] = bone.initalBoneState;
|
|
}
|
|
}
|
|
|
|
void BodyData::loadNormals(Common::SeekableReadStream &stream) {
|
|
const uint16 numNormals = stream.readUint16LE();
|
|
if (stream.eos())
|
|
return;
|
|
|
|
_normals.reserve(numNormals);
|
|
for (uint16 i = 0; i < numNormals; ++i) {
|
|
BodyNormal shape;
|
|
shape.x = stream.readSint16LE();
|
|
shape.y = stream.readSint16LE();
|
|
shape.z = stream.readSint16LE();
|
|
shape.prenormalizedRange = stream.readUint16LE();
|
|
_normals.push_back(shape);
|
|
}
|
|
}
|
|
|
|
void BodyData::loadPolygons(Common::SeekableReadStream &stream) {
|
|
const uint16 numPolygons = stream.readUint16LE();
|
|
if (stream.eos())
|
|
return;
|
|
|
|
_polygons.reserve(numPolygons);
|
|
for (uint16 i = 0; i < numPolygons; ++i) {
|
|
BodyPolygon poly;
|
|
poly.materialType = stream.readByte();
|
|
const uint8 numVertices = stream.readByte();
|
|
|
|
poly.intensity = stream.readSint16LE();
|
|
int16 normal = -1;
|
|
if (poly.materialType == MAT_FLAT || poly.materialType == MAT_GRANIT) {
|
|
// only one shade value is used
|
|
normal = stream.readSint16LE();
|
|
}
|
|
|
|
poly.indices.reserve(numVertices);
|
|
poly.normals.reserve(numVertices);
|
|
for (int k = 0; k < numVertices; ++k) {
|
|
if (poly.materialType >= MAT_GOURAUD) {
|
|
normal = stream.readSint16LE();
|
|
}
|
|
// numPoint is point index precomupted * 6
|
|
const uint16 vertexIndex = stream.readUint16LE() / 6;
|
|
poly.indices.push_back(vertexIndex);
|
|
poly.normals.push_back(normal);
|
|
}
|
|
|
|
_polygons.push_back(poly);
|
|
}
|
|
}
|
|
|
|
void BodyData::loadLines(Common::SeekableReadStream &stream) {
|
|
const uint16 numLines = stream.readUint16LE();
|
|
if (stream.eos())
|
|
return;
|
|
|
|
_lines.reserve(numLines);
|
|
for (uint16 i = 0; i < numLines; ++i) {
|
|
BodyLine line;
|
|
stream.skip(1);
|
|
line.color = stream.readByte();
|
|
stream.skip(2);
|
|
// indexPoint is point index precomupted * 6
|
|
line.vertex1 = stream.readUint16LE() / 6;
|
|
line.vertex2 = stream.readUint16LE() / 6;
|
|
_lines.push_back(line);
|
|
}
|
|
}
|
|
|
|
void BodyData::loadSpheres(Common::SeekableReadStream &stream) {
|
|
const uint16 numSpheres = stream.readUint16LE();
|
|
if (stream.eos())
|
|
return;
|
|
|
|
_spheres.reserve(numSpheres);
|
|
for (uint16 i = 0; i < numSpheres; ++i) {
|
|
BodySphere sphere;
|
|
sphere.fillType = stream.readByte();
|
|
sphere.color = stream.readUint16LE();
|
|
stream.readByte();
|
|
sphere.radius = stream.readUint16LE();
|
|
sphere.vertex = stream.readUint16LE() / 6;
|
|
_spheres.push_back(sphere);
|
|
}
|
|
}
|
|
|
|
bool BodyData::loadFromStream(Common::SeekableReadStream &stream, bool lba1) {
|
|
reset();
|
|
if (lba1) {
|
|
const uint16 flags = stream.readUint16LE();
|
|
animated = (flags & INFO_ANIM) != 0;
|
|
bbox.mins.x = stream.readSint16LE();
|
|
bbox.maxs.x = stream.readSint16LE();
|
|
bbox.mins.y = stream.readSint16LE();
|
|
bbox.maxs.y = stream.readSint16LE();
|
|
bbox.mins.z = stream.readSint16LE();
|
|
bbox.maxs.z = stream.readSint16LE();
|
|
offsetToData = stream.readSint16LE();
|
|
|
|
// using this value as the offset crashes the demo of lba1 - see https://bugs.scummvm.org/ticket/14294
|
|
// stream.seek(offsetToData);
|
|
stream.seek(0x1A);
|
|
|
|
loadVertices(stream);
|
|
loadBones(stream);
|
|
loadNormals(stream);
|
|
loadPolygons(stream);
|
|
loadLines(stream);
|
|
loadSpheres(stream);
|
|
} else {
|
|
// T_BODY_HEADER (lba2)
|
|
const uint32 flags = stream.readUint32LE();
|
|
animated = (flags & INFO_ANIM) != 0;
|
|
stream.skip(4); // int16 size of header and int16 dummy
|
|
bbox.mins.x = stream.readSint32LE();
|
|
bbox.maxs.x = stream.readSint32LE();
|
|
bbox.mins.y = stream.readSint32LE();
|
|
bbox.maxs.y = stream.readSint32LE();
|
|
bbox.mins.z = stream.readSint32LE();
|
|
bbox.maxs.z = stream.readSint32LE();
|
|
stream.seek(0x20);
|
|
#if 0
|
|
const uint32 bonesSize = stream.readUint32LE();
|
|
const uint32 bonesOffset = stream.readUint32LE();
|
|
const uint32 verticesSize = stream.readUint32LE();
|
|
const uint32 verticesOffset = stream.readUint32LE();
|
|
const uint32 normalsSize = stream.readUint32LE();
|
|
const uint32 normalsOffset = stream.readUint32LE();
|
|
const uint32 unk1Size = stream.readUint32LE();
|
|
const uint32 unk1Offset = stream.readUint32LE();
|
|
const uint32 polygonsSize = stream.readUint32LE();
|
|
const uint32 polygonsOffset = stream.readUint32LE();
|
|
const uint32 linesSize = stream.readUint32LE();
|
|
const uint32 linesOffset = stream.readUint32LE();
|
|
const uint32 spheresSize = stream.readUint32LE();
|
|
const uint32 spheresOffset = stream.readUint32LE();
|
|
const uint32 uvGroupsSize = stream.readUint32LE();
|
|
const uint32 uvGroupsOffset = stream.readUint32LE();
|
|
#endif
|
|
}
|
|
|
|
return !stream.err();
|
|
}
|
|
|
|
} // namespace TwinE
|