Initial commit

engines/tetraedge/te/te_model.cpp

@@ -0,0 +1,647 @@
+/* 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 "common/file.h"
+#include "common/util.h"
+#include "common/substream.h"
+#include "common/compression/deflate.h"
+
+#include "tetraedge/tetraedge.h"
+#include "tetraedge/te/te_light.h"
+#include "tetraedge/te/te_model.h"
+#include "tetraedge/te/te_model_animation.h"
+#include "tetraedge/te/te_renderer.h"
+#include "tetraedge/te/te_trs.h"
+
+namespace Tetraedge {
+
+TeModel::TeModel() : _enableLights(false), _skipSkinOffsets(false), _matrixForced(false) {
+	_modelAnim.setDeleteFn(&TeModelAnimation::deleteLaterStatic);
+	_modelVertexAnim.setDeleteFn(&TeModelVertexAnimation::deleteLaterStatic);
+	create();
+}
+
+TeModel::~TeModel() {
+	destroy();
+}
+
+void TeModel::blendAnim(TeIntrusivePtr<TeModelAnimation> &anim, float seconds, bool repeat) {
+	if (!_modelAnim) {
+		setAnim(anim, repeat);
+	} else {
+		BonesBlender *blender = new BonesBlender(anim, seconds);
+		anim->_repeatCount = (repeat ? -1 : 1);
+		anim->play();
+		_boneBlenders.push_back(blender);
+	}
+}
+
+void TeModel::blendMesh(const Common::String &s1, const Common::String &s2, float amount) {
+	_meshBlenders.push_back(new MeshBlender(s1, s2, amount, this));
+}
+
+int TeModel::checkFileType(Common::SeekableReadStream &instream) const {
+	char buf[4];
+	instream.seek(0);
+	int sz = instream.read(buf, 4);
+	instream.seek(0);
+	if (sz == 4 && strncmp("TEMD", buf, 4) == 0) {
+		return 1;
+	} else if (sz == 4 && strncmp("TEAN", buf, 4) == 0) {
+		return 2;
+	}
+	return 0;
+}
+
+void TeModel::create() {
+	// TODO: set field_0x158 to 0
+	_modelAnim.release();
+	_modelVertexAnim.release();
+	_matrixForced = false;
+	_skipSkinOffsets = false;
+}
+
+void TeModel::destroy() {
+	_weightElements.clear();
+	_lerpedElements.clear();
+	_meshes.clear();
+	_bones.clear();
+	_boneMatricies.clear();
+	_skinOffsets.clear();
+	for (MeshBlender *blender : _meshBlenders)
+		delete blender;
+	_meshBlenders.clear();
+	for (BonesBlender *blender : _boneBlenders)
+		delete blender;
+	_boneBlenders.clear();
+}
+
+void TeModel::draw() {
+	TeRenderer *renderer = g_engine->getRenderer();
+
+	if (worldVisible()) {
+		const TeMatrix4x4 transform = transformationMatrix();
+		renderer->sendModelMatrix(transform);
+		renderer->pushMatrix();
+		renderer->multiplyMatrix(transform);
+		/*
+		if (name().contains("DEPLIANT")) {
+			debug("Draw model %p (%s, %d meshes)", this, name().empty() ? "no name" : name().c_str(), _meshes.size());
+			debug("   renderMatrix %s", renderer->currentMatrix().toString().c_str());
+			//debug("   position   %s", position().dump().c_str());
+			debug("   worldPos   %s", worldPosition().dump().c_str());
+			//debug("   scale      %s", scale().dump().c_str());
+			debug("   worldScale %s", worldScale().dump().c_str());
+			//debug("   rotation   %s", rotation().dump().c_str());
+			debug("   worldRot   %s", worldRotation().dump().c_str());
+		}*/
+		for (auto &mesh : _meshes) {
+			// TODO: Set some flag (_drawWires?) in mesh to this->field_0x158??
+			mesh->draw();
+		}
+		renderer->popMatrix();
+		// Note: no corresponding enableAll - they can be enabled inside TeMaterial::apply
+		renderer->disableAllLights();
+	}
+}
+
+void TeModel::forceMatrix(const TeMatrix4x4 &matrix) {
+	_matrixForced = true;
+	_forcedMatrix = matrix;
+}
+
+TeTRS TeModel::getBone(TeIntrusivePtr<TeModelAnimation> anim, uint num) {
+	if (anim) {
+		int boneNo = anim->findBone(_bones[num]._name);
+		if (boneNo != -1)
+			return anim->getTRS(boneNo, anim->curFrame2(), false);
+	}
+	return _bones[num]._trs;
+}
+
+void TeModel::invertNormals() {
+	for (auto &mesh : _meshes) {
+		for (uint i = 0; i < mesh->numIndexes() / 3; i += 3) {
+			// Swap order of verticies in each triangle.
+			uint idx0 = mesh->index(i * 3);
+			uint idx2 = mesh->index(i * 3 + 2);
+			mesh->setIndex(i * 3, idx2);
+			mesh->setIndex(i * 3 + 2, idx0);
+		}
+		for (uint i = 0; i < mesh->numVerticies(); i++) {
+			mesh->setNormal(i, -mesh->normal(i));
+		}
+	}
+}
+
+TeMatrix4x4 TeModel::lerpElementsMatrix(uint weightsNum, const Common::Array<TeMatrix4x4> &matricies) {
+	TeMatrix4x4 retval;
+	// Start with a 0 matrix.
+	for (uint i = 0; i < 4; i++)
+		retval.setValue(i, i, 0);
+
+	const Common::Array<weightElement> &weights = _weightElements[weightsNum];
+	for (const auto &weight : weights) {
+		const TeMatrix4x4 offset = matricies[weight._x].meshScale(weight._weight);
+		retval.meshAdd(offset);
+	}
+
+	return retval;
+}
+
+void TeModel::removeAnim() {
+	for (TeModel::BonesBlender *blender : _boneBlenders) {
+		delete blender;
+	}
+	_boneBlenders.clear();
+	_modelAnim.release();
+}
+
+void TeModel::setColor(const TeColor &col) {
+	Te3DObject2::setColor(col);
+	for (auto &mesh : _meshes) {
+		mesh->setColor(col);
+	}
+}
+
+void TeModel::update() {
+	//if (name().contains("Kate"))
+	//	debug("TeModel::update model %s", name().c_str());
+	if (_bones.size()) {
+		Common::Array<TeMatrix4x4> matricies(_bones.size());
+		for (uint i = 0; i < _bones.size(); i++) {
+			const Bone &b = _bones[i];
+			const TeMatrix4x4 matrix = TeMatrix4x4::fromTRS(b._trs);
+			if (b._parentBone == -1 || _bones.size() < 2) {
+				matricies[0] = matrix;
+			} else {
+				matricies[i] = matricies[b._parentBone] * matrix;
+			}
+		}
+
+		_boneMatricies.resize(_bones.size());
+		_lerpedElements.resize(_weightElements.size());
+
+		TeMatrix4x4 invertx;
+		invertx.scale(TeVector3f32(-1, 1, 1));
+		for (uint b = 0; b < _bones.size(); b++) {
+			TeTRS trs = getBone(_modelAnim, b);
+			for (uint i = 0; i < _boneBlenders.size(); i++) {
+				BonesBlender *blender = _boneBlenders[i];
+				float complete = blender->coef();
+				TeTRS endTRS = getBone(blender->_anim, b);
+				if (complete == 1.0f) {
+					_modelAnim = blender->_anim;
+					delete blender;
+					_boneBlenders.remove_at(i);
+					trs = endTRS;
+					i--;
+				} else {
+					trs = trs.lerp(endTRS, complete);
+				}
+			}
+
+			TeMatrix4x4 newBoneMatrix;
+			if (!_matrixForced) {
+				newBoneMatrix = TeMatrix4x4::fromTRS(trs);
+			} else {
+				newBoneMatrix = invertx * _forcedMatrix;
+				_matrixForced = false;
+			}
+
+			if (_bones.size() < 2 || _bones[b]._parentBone == -1) {
+				_boneMatricies[b] = newBoneMatrix;
+				_boneMatricies[b].rotate(_boneRotation);
+			} else {
+				_boneMatricies[b] = (invertx * _boneMatricies[_bones[b]._parentBone]) * newBoneMatrix;
+			}
+			_boneMatricies[b] = invertx * _boneMatricies[b];
+			_bonesUpdatedSignal.call(_bones[b]._name, _boneMatricies[b]);
+		}
+
+		if (!_skinOffsets.empty() && !_bones.empty()) {
+			for (uint b = 0; b < _bones.size(); b++) {
+				_boneMatricies[b] = _boneMatricies[b] * _skinOffsets[b];
+			}
+		}
+
+		if (!_skipSkinOffsets && !_weightElements.empty()) {
+			for (uint i = 0; i < _weightElements.size(); i++) {
+				_lerpedElements[i] = lerpElementsMatrix(i, _boneMatricies);
+			}
+		}
+
+		for (uint m = 0; m < _meshes.size(); m++) {
+			TeMesh &mesh = *_meshes[m];
+			if (!mesh.visible())
+				continue;
+
+			if (!_skipSkinOffsets && _bones.size() < 2 ) {
+				if (_modelVertexAnim && mesh.name() == _modelVertexAnim->head()) {
+					mesh.update(_modelVertexAnim);
+					// TODO: lines 422 - 427.. set some vals and goto LAB_doMeshBlends;
+				}
+				mesh.update(&_boneMatricies, &_lerpedElements);
+			} else {
+				mesh.resizeUpdatedTables(mesh.numVerticies());
+				Common::Array<TeVector3f32> verticies;
+				if (_modelVertexAnim && mesh.name() == _modelVertexAnim->head())
+					verticies = _modelVertexAnim->getVertices();
+
+				for (uint i = 0; i < mesh.numVerticies(); i++) {
+					TeVector3f32 vertex;
+					if (verticies.empty()) {
+						vertex = mesh.preUpdatedVertex(i);
+					} else {
+						if (i < verticies.size())
+							vertex = verticies[i];
+					}
+					TeVector3f32 normal = mesh.preUpdatedNormal(i);
+					int idx = (int)mesh.matrixIndex(i);
+
+					TeVector3f32 updatedvertex;
+					TeVector3f32 updatednormal;
+
+					if (idx < (int)_bones.size()) {
+						updatedvertex = vertex;
+						if (verticies.empty())
+							updatedvertex = _boneMatricies[idx] * updatedvertex;
+						updatednormal = _boneMatricies[idx].mult3x3(normal);
+					} else {
+						idx -= _bones.size();
+						for (uint w = 0; w < _weightElements[idx].size(); w++) {
+							const TeMatrix4x4 &wmatrix = _boneMatricies[_weightElements[idx][w]._x];
+							float weight = _weightElements[idx][w]._weight;
+							updatedvertex = updatedvertex + ((wmatrix * vertex) * weight);
+							updatednormal = updatednormal + (wmatrix.mult3x3(normal) * weight);
+						}
+					}
+
+					mesh.setUpdatedVertex(i, updatedvertex);
+					mesh.setUpdatedNormal(i, updatednormal);
+				}
+			}
+
+			for (MeshBlender *mb : _meshBlenders) {
+				if (mesh.name().contains(mb->_name)) {
+					error("TODO: Finish meshblend part of model::update");
+					// TODO: Finish TeModel::update. (disasm 585 ~ 644), LAB_doMeshBlends
+					//float blendamount = MIN(mb->_timer.getTimeFromStart() / 1000000.0f, 1.0f);
+
+				}
+			}
+		}
+	} else {
+		// No bones..
+		for (auto &mesh : _meshes) {
+			if (!_modelVertexAnim) {
+				mesh->update(nullptr, nullptr);
+			} else {
+				if (mesh->name() != _modelVertexAnim->head()) {
+					mesh->update(nullptr, nullptr);
+				} else {
+					mesh->update(_modelVertexAnim);
+				}
+			}
+		}
+	}
+}
+
+TeModel::MeshBlender::MeshBlender(const Common::String &name, const Common::String &meshName, float amount, TeModel *model) :
+_name(name), _amount(amount) {
+	const auto &meshes = model->_meshes;
+	uint i = 0;
+	for (; i < meshes.size(); i++) {
+		if (meshes[i]->name().contains(meshName))
+			break;
+	}
+	_meshNo = i;
+	_timer.start();
+}
+
+/*static*/
+void TeModel::loadAlign(Common::SeekableReadStream &stream) {
+	int64 pos = stream.pos();
+	if (pos % 4) {
+		stream.seek(4 - (pos % 4), SEEK_CUR);
+	}
+}
+
+/*static*/
+void TeModel::saveAlign(Common::SeekableWriteStream &stream) {
+	int64 pos = stream.pos();
+	if (pos % 4) {
+		stream.seek(4 - (pos % 4), SEEK_CUR);
+	}
+}
+
+bool TeModel::load(Common::SeekableReadStream &stream) {
+	destroy();
+	create();
+
+	if (!loadAndCheckFourCC(stream, "TEMD")) {
+		error("[TeModel::load] Unknown format.");
+	}
+
+	uint version = stream.readUint32LE();
+	if (!((version == 11) || (version == 13))) {
+		error("[TeModel::load] Unsupported version %d", version);
+	}
+
+	uint32 meshCount = stream.readUint32LE();
+	if (meshCount > 100000)
+		error("TeModel::load: Unexpected number of meshes %d", meshCount);
+	_meshes.resize(meshCount);
+	for (uint i = 0; i < meshCount; i++)
+		_meshes[i].reset(TeMesh::makeInstance());
+
+	uint32 weightCount = stream.readUint32LE();
+	if (weightCount > 100000)
+		error("TeModel::load: Unexpected number of weights %d", weightCount);
+	_weightElements.resize(weightCount);
+	uint32 bonecount = stream.readUint32LE();
+	if (bonecount > 100000)
+		error("TeModel::load: Unexpected number of bones %d", bonecount);
+	_bones.resize(bonecount);
+	_skinOffsets.resize(bonecount);
+
+	if (version == 13) {
+		_skipSkinOffsets = stream.readUint32LE();
+	}
+
+	if (!loadAndCheckFourCC(stream, "SKEL")) {
+		error("[TeModel::load] Unable to find skeleton.");
+	}
+
+	for (uint i = 0; i < _bones.size(); i++) {
+		_bones[i]._name = Te3DObject2::deserializeString(stream);
+		loadAlign(stream);
+		_bones[i]._parentBone = stream.readUint32LE();
+		TeTRS::deserialize(stream, _bones[i]._trs);
+		if (!_skipSkinOffsets || g_engine->gameType() == TetraedgeEngine::kSyberia2) {
+			_skinOffsets[i].deserialize(stream);
+		}
+	}
+
+	for (uint m = 0; m < _meshes.size(); m++) {
+		if (!loadMesh(stream, *_meshes[m])) {
+			error("[TeModel::load] Error on meshes loading.");
+		}
+	}
+
+	if (!loadAndCheckFourCC(stream, "WEIG")) {
+		error("[TeModel::load] Unable to load weight.");
+	}
+	for (uint i = 0; i < _weightElements.size(); i++) {
+		loadWeights(stream, _weightElements[i]);
+	}
+
+	if (_bones.empty())
+		_bones.resize(1);
+	return true;
+}
+
+bool TeModel::load(const Common::Path &path) {
+	Common::File modelFile;
+	if (!modelFile.open(path)) {
+		warning("[TeModel::load] Can't open file : %s.", path.toString(Common::Path::kNativeSeparator).c_str());
+		return false;
+	}
+
+	bool retval;
+	if (loadAndCheckFourCC(modelFile, "TEZ0")) {
+		Common::SeekableReadStream *zlibStream = tryLoadZlibStream(modelFile);
+		if (!zlibStream)
+			return false;
+		retval = load(*zlibStream);
+		delete zlibStream;
+	} else {
+		modelFile.seek(0);
+		retval = load(modelFile);
+	}
+	return retval;
+}
+
+Common::SeekableReadStream *TeModel::tryLoadZlibStream(Common::SeekableReadStream &stream) {
+	byte version = stream.readByte();
+	if (version != 1) {
+		warning("[TeModel::load] invalid version number %d (expect 1)", version);
+		return nullptr;
+	}
+	uint32 compressedSize = stream.readUint32LE();
+	if (compressedSize > stream.size()) {
+		warning("[TeModel::load] invalid size %d (file size %d)", compressedSize, (int)stream.size());
+		return nullptr;
+	}
+	uint32 uncompressedSize = stream.readUint32LE();
+	Common::SeekableSubReadStream *substream = new Common::SeekableSubReadStream(&stream, stream.pos(), stream.size());
+	return Common::wrapCompressedReadStream(substream, DisposeAfterUse::YES, uncompressedSize);
+}
+
+bool TeModel::loadWeights(Common::ReadStream &stream, Common::Array<weightElement> &weights) {
+	uint32 nweights = stream.readUint32LE();
+	if (nweights > 100000)
+		error("Improbable number of weights %d", (int)nweights);
+	weights.resize(nweights);
+	for (uint i = 0; i < nweights; i++) {
+		weights[i]._weight = stream.readFloatLE();
+		weights[i]._x = stream.readUint16LE();
+		stream.readUint16LE();
+	}
+	return true;
+}
+
+bool TeModel::loadMesh(Common::SeekableReadStream &stream, TeMesh &mesh) {
+	if (!loadAndCheckFourCC(stream, "MESH"))
+		return false;
+
+	uint32 vertcount = stream.readUint32LE();
+	uint32 matcount = stream.readUint32LE();
+	uint32 matidxcount = stream.readUint32LE();
+	uint32 idxcount = stream.readUint32LE();
+
+	if (vertcount > 100000 || matcount > 100000 || matidxcount > 100000 || idxcount > 100000)
+		error("Improbable mesh sizes %d %d %d %d", vertcount, matcount, matidxcount, idxcount);
+
+	mesh.setConf(vertcount, idxcount, TeMesh::MeshMode_Triangles, matcount, matidxcount);
+
+	uint32 flags = stream.readUint32LE();
+	if (flags & 1)
+		mesh.setColor(0, TeColor(0xff, 0xff, 0xff, 0xff));
+	if (flags & 2)
+		mesh.setTextureUV(0, TeVector2f32(0.0f, 0.0f));
+
+	mesh.setName(Te3DObject2::deserializeString(stream));
+	loadAlign(stream);
+
+	if (!loadAndCheckFourCC(stream, "MTRL"))
+		return false;
+
+	for (uint i = 0; i < mesh.materials().size(); i++) {
+		TeMaterial mat;
+		TeMaterial::deserialize(stream, mat, _texturePath);
+		if (_enableLights)
+			mat._enableLights = true;
+		mesh.attachMaterial(i, mat);
+	}
+
+	if (!loadAndCheckFourCC(stream, "VERT"))
+		return false;
+
+	for (uint i = 0; i < mesh.numVerticies(); i++) {
+		TeVector3f32 v;
+		TeVector3f32::deserialize(stream, v);
+		mesh.setVertex(i, v);
+	}
+	if (mesh.hasUvs()) {
+		if (!loadAndCheckFourCC(stream, "TUVS"))
+			return false;
+		for (uint i = 0; i < mesh.numVerticies(); i++) {
+			TeVector2f32 v;
+			TeVector2f32::deserialize(stream, v);
+			mesh.setTextureUV(i, v);
+		}
+	}
+
+	if (!loadAndCheckFourCC(stream, "NORM"))
+		return false;
+
+	for (uint i = 0; i < mesh.numVerticies(); i++) {
+		TeVector3f32 v;
+		TeVector3f32::deserialize(stream, v);
+		mesh.setNormal(i, v);
+	}
+
+	if (mesh.hasColor()) {
+		if (!loadAndCheckFourCC(stream, "COLS"))
+			return false;
+
+		for (uint i = 0; i < mesh.numVerticies(); i++) {
+			TeColor c;
+			c.deserialize(stream);
+			mesh.setColor(i, c);
+		}
+	}
+
+	if (!loadAndCheckFourCC(stream, "FCPM"))
+		return false;
+
+	for (uint i = 0; i < mesh.materials().size(); i++) {
+		mesh.facesPerMaterial(i, stream.readUint16LE());
+	}
+
+	loadAlign(stream);
+	if (!loadAndCheckFourCC(stream, "MTXI"))
+		return false;
+
+	for (uint i = 0; i < mesh.numVerticies(); i++) {
+		mesh.matrixIndex(i, stream.readUint16LE());
+	}
+
+	loadAlign(stream);
+	if (!loadAndCheckFourCC(stream, "IDXS"))
+		return false;
+
+	for (uint i = 0; i < mesh.numIndexes(); i++) {
+		mesh.setIndex(i, stream.readUint16LE());
+	}
+
+	loadAlign(stream);
+	return true;
+}
+
+void TeModel::setQuad(const TeIntrusivePtr<Te3DTexture> &tex, const Common::Array<TeVector3f32> &verts, const TeColor &col) {
+	_meshes.clear();
+	Common::SharedPtr<TeMesh> mesh(TeMesh::makeInstance());
+	mesh->setConf(4, 4, TeMesh::MeshMode_TriangleStrip, 0, 0);
+	mesh->defaultMaterial(tex);
+
+	for (int i = 0; i < 2; i++) {
+		float f = (i == 0 ? 0.0f : 1.0f);
+		for (int j = 0; j < 2; j++) {
+			int index = i * 2 + j;
+			mesh->setVertex(index, verts[i * 2 + j]);
+			mesh->setTextureUV(index, TeVector2f32(f, (j == 0 ? 0.0f : 1.0f)));
+			mesh->setIndex(index, index);
+			if (col.a() != 0)
+				mesh->setColor(index, col);
+		}
+	}
+
+	const TeVector3f32 v1 = verts[1] - verts[0];
+	const TeVector3f32 v2 = verts[2] - verts[0];
+	TeVector3f32 v3 = TeVector3f32::crossProduct(v1, v2);
+	v3.normalize();
+	for (int i = 0; i < 4; i++) {
+		mesh->setNormal(i, v3);
+	}
+	_meshes.push_back(mesh);
+}
+
+void TeModel::setAnim(TeIntrusivePtr<TeModelAnimation> &anim, bool repeat) {
+	for (TeModel::BonesBlender *blender : _boneBlenders) {
+		delete blender;
+	}
+	_boneBlenders.clear();
+	anim->_repeatCount = (repeat ? -1 : 1);
+	_modelAnim = anim;
+}
+
+void TeModel::setVertexAnim(TeIntrusivePtr<TeModelVertexAnimation> &anim, bool repeat) {
+	anim->_repeatCount = (repeat ? -1 : 1);
+	_modelVertexAnim = anim;
+}
+
+void TeModel::setVisibleByName(const Common::String &name, bool vis) {
+	for (auto &mesh : _meshes) {
+		if (mesh->name().contains(name)) {
+			mesh->setVisible(vis);
+		}
+	}
+}
+
+TeMatrix4x4 TeModel::skinOffset(uint boneno) const {
+	if (boneno >= _skinOffsets.size())
+		return TeMatrix4x4();
+	return _skinOffsets[boneno];
+}
+
+void TeModel::setMeshCount(uint count) {
+	assert(count < 100000);
+	while (_meshes.size() < count)
+		_meshes.push_back(Common::SharedPtr<TeMesh>(TeMesh::makeInstance()));
+
+	if (_meshes.size() > count)
+		_meshes.resize(count);
+}
+
+TeModel::BonesBlender::BonesBlender(TeIntrusivePtr<TeModelAnimation> anim, float seconds) : _anim(anim), _seconds(seconds) {
+	_anim.setDeleteFn(&TeModelAnimation::deleteLaterStatic);
+	_timer.stop();
+	_timer.start();
+}
+
+float TeModel::BonesBlender::coef() {
+	float elapsed = (_timer.getTimeFromStart() / 1000000.0) / _seconds;
+	return MIN(elapsed, 1.0f);
+}
+
+} // end namespace Tetraedge