Initial commit

engines/wintermute/base/gfx/3dloader_3ds.cpp

@@ -0,0 +1,525 @@
+/* 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 "engines/wintermute/dcgf.h"
+#include "engines/wintermute/math/math_util.h"
+#include "engines/wintermute/base/base_file_manager.h"
+#include "engines/wintermute/base/gfx/3dloader_3ds.h"
+#include "engines/wintermute/base/gfx/3dface.h"
+#include "engines/wintermute/base/gfx/3dvertex.h"
+#include "engines/wintermute/base/gfx/3dutils.h"
+
+namespace Wintermute {
+
+#define MAIN3DS                       0x4D4D // level 1
+#define EDIT3DS                       0x3D3D // level 1
+#define NAMED_OBJECT                  0x4000 // level 2
+#define TRIANGLE_MESH                 0x4100 // level 3
+#define TRIANGLE_VERTEXLIST           0x4110 // level 4
+#define TRIANGLE_FACELIST             0x4120 // level 4
+#define CHUNK_CAMERA                  0x4700 // level 3
+#define CHUNK_LIGHT                   0x4600
+#define LIGHT_SPOTLIGHT               0x4610
+#define LIGHT_IS_OFF                  0x4620
+#define RGB_FLOAT                     0x0010
+#define RGB_BYTE                      0x0011
+#define KEYFRAMER                     0xB000 // level 1
+#define KEYFRAMER_AMBIENT_INFO        0xB001
+#define KEYFRAMER_MESH_INFO           0xB002
+#define KEYFRAMER_CAMERA_INFO         0xB003
+#define KEYFRAMER_CAMERA_TARGET_INFO  0xB004
+#define KEYFRAMER_OMNI_INFO           0xB005
+#define KEYFRAMER_SPOT_TARGET_INFO    0xB006
+#define KEYFRAMER_SPOT_INFO           0xB007
+#define NODE_HDR                      0xB010
+#define ROLL_TRACK_TAG                0xB024
+
+
+//////////////////////////////////////////////////////////////////////////
+Loader3DS::Loader3DS(BaseGame *inGame) : BaseNamedObject(inGame) {
+	_filename = nullptr;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+Loader3DS::~Loader3DS() {
+	for (int32 i = 0; i < _objects.getSize(); i++)
+		delete _objects[i];
+	_objects.removeAll();
+
+	SAFE_DELETE_ARRAY(_filename);
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+Loader3DS::FileObject3DS::FileObject3DS() {
+	_name = nullptr;
+	_type = OBJ_3DS_NONE;
+
+	_numVertices = 0;
+	_vertices = nullptr;
+
+	_numFaces = 0;
+	_faces = nullptr;
+
+	_lightOff = false;
+	_lightSpotlight = false;
+	_lightColor = 0;
+	_lightHotspot = false;
+	_lightFalloff = false;
+	_lightTarget._x = _lightTarget._y = _lightTarget._z = 0.0f;
+	_lightPos._x = _lightPos._y = _lightPos._z = 0.0f;
+
+	_cameraBank = 0;
+	_cameraLens = 0;
+	_cameraFOV = 0;
+	_cameraPos._x = _cameraPos._y = _cameraPos._z = 0.0f;
+
+	_hidden = false;
+}
+
+
+//////////////////////////////////////////////////////////////////////
+Loader3DS::FileObject3DS::~FileObject3DS() {
+	if (_name != nullptr)
+		delete[] _name;
+	if (_vertices != nullptr)
+		delete[] _vertices;
+	if (_faces != nullptr)
+		delete[] _faces;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool Loader3DS::parseFile(const char *filename) {
+	SAFE_DELETE_ARRAY(_filename);
+	size_t filenameSize = strlen(filename) + 1;
+	_filename = new char[filenameSize];
+	Common::strcpy_s(_filename, filenameSize, filename);
+
+	uint32 fileSize;
+	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename, &fileSize);
+	if (!buffer)
+		return false;
+
+	uint16 keyframerSection = 0;
+	char *keyframerObject = nullptr;
+	FileObject3DS *obj = nullptr;
+	uint16 i;
+
+	Common::MemoryReadStream fileStream(buffer, fileSize);
+
+	while (fileStream.pos() < fileStream.size()) {
+		uint16 chunkId = fileStream.readUint16LE();
+		uint32 chunkLength = fileStream.readUint32LE();
+
+		bool handled = true;
+
+		switch (chunkId) {
+			case MAIN3DS:
+			break;
+
+			case EDIT3DS:
+			break;
+
+			//////////////////////////////////////////////////////////////////////
+			// object ////////////////////////////////////////////////////////////
+			case NAMED_OBJECT: {
+				obj = new FileObject3DS;
+				auto name = fileStream.readString();
+				size_t nameSize = name.size() + 1;
+				obj->_name = new char[nameSize];
+				Common::strcpy_s(obj->_name, nameSize, name.c_str());
+				_objects.add(obj);
+			}
+			break;
+
+
+			// mesh //////////////////////////////////////////////////////////////
+			case TRIANGLE_MESH:
+				if (obj == nullptr)
+					break;
+				obj->_type = OBJ_3DS_MESH;
+			break;
+
+
+			case TRIANGLE_VERTEXLIST:
+				if (obj == nullptr || obj->_type != OBJ_3DS_MESH)
+					break;
+
+				obj->_numVertices = fileStream.readUint16LE();
+				obj->_vertices = new DXVector3[obj->_numVertices];
+				for (i = 0; i < obj->_numVertices; i++) {
+					obj->_vertices[i]._x = fileStream.readFloatLE();
+					obj->_vertices[i]._z = fileStream.readFloatLE();
+					obj->_vertices[i]._y = fileStream.readFloatLE();
+				}
+			break;
+
+
+			case TRIANGLE_FACELIST:
+				if (obj == nullptr || obj->_type != OBJ_3DS_MESH)
+					break;
+
+				obj->_numFaces = fileStream.readUint16LE();
+
+				obj->_faces = new SFace[obj->_numFaces];
+				for (i = 0; i < obj->_numFaces; i++) {
+					obj->_faces[i]._a = fileStream.readUint16LE();
+					obj->_faces[i]._c = fileStream.readUint16LE();
+					obj->_faces[i]._b = fileStream.readUint16LE();
+					fileStream.readUint16LE(); // skip
+				}
+			break;
+
+
+			// camera //////////////////////////////////////////////////////////////
+			case CHUNK_CAMERA:
+				if (obj == nullptr)
+					break;
+				obj->_type = OBJ_3DS_CAMERA;
+
+				obj->_cameraPos._x = fileStream.readFloatLE();
+				obj->_cameraPos._z = fileStream.readFloatLE();
+				obj->_cameraPos._y = fileStream.readFloatLE();
+
+				obj->_cameraTarget._x = fileStream.readFloatLE();
+				obj->_cameraTarget._z = fileStream.readFloatLE();
+				obj->_cameraTarget._y = fileStream.readFloatLE();
+				
+				obj->_cameraBank = fileStream.readFloatLE();
+				obj->_cameraLens = fileStream.readFloatLE();
+				if (obj->_cameraLens > 0)
+					obj->_cameraFOV = 1900.0f / obj->_cameraLens;
+				else
+					obj->_cameraFOV = 45.0f;
+			break;
+
+
+			// light //////////////////////////////////////////////////////////////
+			case CHUNK_LIGHT:
+				if (obj == nullptr)
+					break;
+				obj->_type = OBJ_3DS_LIGHT;
+
+				obj->_lightPos._x = fileStream.readFloatLE();
+				obj->_lightPos._z = fileStream.readFloatLE();
+				obj->_lightPos._y = fileStream.readFloatLE();
+			break;
+
+			case LIGHT_SPOTLIGHT:
+				if (obj == nullptr || obj->_type != OBJ_3DS_LIGHT)
+					break;
+
+				obj->_lightTarget._x = fileStream.readFloatLE();
+				obj->_lightTarget._z = fileStream.readFloatLE();
+				obj->_lightTarget._y = fileStream.readFloatLE();
+
+				obj->_lightHotspot = fileStream.readFloatLE();
+				obj->_lightFalloff = fileStream.readFloatLE();
+				obj->_lightSpotlight = true;
+			break;
+
+			case LIGHT_IS_OFF:
+				if (obj == nullptr || obj->_type != OBJ_3DS_LIGHT)
+					break;
+
+				obj->_lightOff = true;
+			break;
+
+
+			// colors ////////////////////////////////////////////////////////////////////////
+			case RGB_FLOAT:
+				if (obj && obj->_type == OBJ_3DS_LIGHT) {
+					float r, g, b;
+					r = fileStream.readFloatLE();
+					g = fileStream.readFloatLE();
+					b = fileStream.readFloatLE();
+
+					obj->_lightColor = BYTETORGBA((int)(r * 255), (int)(g * 255), (int)(b * 255), 255);
+				} else
+					handled = false;
+			break;
+
+			case RGB_BYTE:
+				if (obj && obj->_type == OBJ_3DS_LIGHT) {
+					byte r, g, b;
+					r = fileStream.readByte();
+					g = fileStream.readByte();
+					b = fileStream.readByte();
+
+					obj->_lightColor = BYTETORGBA(r, g, b, 255);
+				} else
+					handled = false;
+			break;
+
+			// keyframer stuff
+			case KEYFRAMER:
+			break;
+
+			case KEYFRAMER_AMBIENT_INFO:
+			case KEYFRAMER_MESH_INFO:
+			case KEYFRAMER_CAMERA_INFO:
+			case KEYFRAMER_CAMERA_TARGET_INFO:
+			case KEYFRAMER_OMNI_INFO:
+			case KEYFRAMER_SPOT_TARGET_INFO:
+			case KEYFRAMER_SPOT_INFO:
+				keyframerSection = chunkId;
+			break;
+
+			case NODE_HDR: {
+				// object name
+				SAFE_DELETE_ARRAY(keyframerObject);
+				auto keyname = fileStream.readString();
+				size_t keynameSize = keyname.size() + 1;
+				keyframerObject = new char[keynameSize];
+				Common::strcpy_s(keyframerObject, keynameSize, keyname.c_str());
+				// flags1
+				fileStream.readUint16LE();
+				// flags2
+				fileStream.readUint16LE();
+				// hierarchy
+				fileStream.readUint16LE();
+			}
+			break;
+
+			case ROLL_TRACK_TAG:
+				if (keyframerSection == KEYFRAMER_CAMERA_INFO && keyframerObject != nullptr) {
+					// flags
+					fileStream.readUint16LE();
+					// unknown
+					fileStream.readUint16LE();
+					fileStream.readUint16LE();
+					fileStream.readUint16LE();
+					fileStream.readUint16LE();
+					// keys
+					uint16 keys = fileStream.readUint16LE();
+					// unknown
+					fileStream.readUint16LE();
+
+					for (uint16 key = 0; key < keys; key++) {
+						// frame number
+						fileStream.readUint16LE();
+						// unknown
+						fileStream.readUint32LE();
+						// camera roll
+						float cameraRoll = fileStream.readFloatLE();
+
+						// inject this roll value to the camera
+						if (key == 0) {
+							for (int32 index = 0; index < _objects.getSize(); index++) {
+								if (_objects[index]->_type == OBJ_3DS_CAMERA && scumm_stricmp(_objects[index]->_name, keyframerObject) == 0) {
+									_objects[index]->_cameraBank = cameraRoll;
+									break;
+								}
+							}
+						}
+					}
+				} else
+					handled = false;
+				break;
+
+			default:
+				handled = false;
+		}
+
+		if (!handled)
+			fileStream.seek(chunkLength - 6, SEEK_CUR);
+	}
+
+	SAFE_DELETE_ARRAY(keyframerObject);
+
+	delete[] buffer;
+
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+int32 Loader3DS::getNumMeshes() {
+	int32 ret = 0;
+
+	for (int32 i = 0; i < _objects.getSize(); i++)
+		if (_objects[i]->_type == OBJ_3DS_MESH)
+			ret++;
+
+	return ret;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+char *Loader3DS::getMeshName(int index) {
+	int32 pos = -1;
+
+	for (int32 i = 0; i < _objects.getSize(); i++) {
+		if (_objects[i]->_type == OBJ_3DS_MESH)
+			pos++;
+		if (pos == index)
+			return _objects[i]->_name;
+	}
+	return nullptr;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool Loader3DS::loadMesh(int index, Mesh3DS *mesh) {
+	if (!mesh)
+		return false;
+
+	int pos = -1;
+	for (int32 i = 0; i < _objects.getSize(); i++) {
+		if (_objects[i]->_type == OBJ_3DS_MESH)
+			pos++;
+		if (pos == index){
+			FileObject3DS *obj = _objects[i];
+			mesh->cleanup();
+
+			mesh->_numVertices = obj->_numVertices;
+			mesh->_numFaces = obj->_numFaces;
+
+			int j;
+
+			mesh->_vertices = new Vertex3D[mesh->_numVertices];
+			for (j = 0; j < mesh->_numVertices; j++) {
+				mesh->_vertices[j]._pos._x = obj->_vertices[j]._x;
+				mesh->_vertices[j]._pos._y = obj->_vertices[j]._y;
+				mesh->_vertices[j]._pos._z = obj->_vertices[j]._z;
+			}
+
+			mesh->_faces = new Face3D[mesh->_numFaces];
+			for (j = 0; j < mesh->_numFaces; j++) {
+				mesh->_faces[j]._vertices[0] = obj->_faces[j]._a;
+				mesh->_faces[j]._vertices[1] = obj->_faces[j]._b;
+				mesh->_faces[j]._vertices[2] = obj->_faces[j]._c;
+			}
+
+			mesh->setName(obj->_name);
+
+			return true;
+		}
+	}
+	return false;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+int32 Loader3DS::getNumLights() {
+	int ret = 0;
+
+	for (int32 i = 0; i < _objects.getSize(); i++)
+		if (_objects[i]->_type == OBJ_3DS_LIGHT)
+			ret++;
+
+	return ret;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+char *Loader3DS::getLightName(int index) {
+	int pos = -1;
+
+	for (int32 i = 0; i < _objects.getSize(); i++) {
+		if (_objects[i]->_type == OBJ_3DS_LIGHT)
+			pos++;
+		if (pos == index)
+			return _objects[i]->_name;
+	}
+	return nullptr;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool Loader3DS::loadLight(int index, Light3D *light) {
+	if (!light)
+		return false;
+
+	int pos = -1;
+	for (int32 i = 0; i < _objects.getSize(); i++) {
+		if (_objects[i]->_type == OBJ_3DS_LIGHT) {
+			pos++;
+			if (pos == index) {
+				light->setName(_objects[i]->_name);
+				light->_pos = _objects[i]->_lightPos;
+				light->_target = _objects[i]->_lightTarget;
+				light->_isSpotlight = _objects[i]->_lightSpotlight;
+				light->_active = !_objects[i]->_lightOff;
+				light->_diffuseColor = _objects[i]->_lightColor;
+				light->_falloff = _objects[i]->_lightFalloff;
+			}
+		}
+	}
+
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+int32 Loader3DS::getNumCameras() {
+	int32 ret = 0;
+
+	for (int32 i = 0; i < _objects.getSize(); i++)
+		if (_objects[i]->_type == OBJ_3DS_CAMERA)
+			ret++;
+
+	return ret;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+char *Loader3DS::getCameraName(int index) {
+	int32 pos = -1;
+	for (int32 i = 0; i < _objects.getSize(); i++) {
+		if (_objects[i]->_type == OBJ_3DS_CAMERA)
+			pos++;
+		if (pos == index)
+			return _objects[i]->_name;
+	}
+	return nullptr;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+bool Loader3DS::loadCamera(int index, Camera3D *camera) {
+	if (!camera)
+		return false;
+
+	int pos = -1;
+	for (int32 i = 0; i < _objects.getSize(); i++) {
+		if (_objects[i]->_type == OBJ_3DS_CAMERA)
+			pos++;
+		if (pos == index) {
+			camera->setupPos(_objects[i]->_cameraPos, _objects[i]->_cameraTarget, _objects[i]->_cameraBank);
+			camera->setName(_objects[i]->_name);
+			camera->_fov = camera->_origFov = degToRad(_objects[i]->_cameraFOV);
+
+			return true;
+		}
+	}
+	return false;
+}
+
+} // namespace Wintermute