WINTERMUTE: Implement X file loader and restore original engine code

engines/wintermute/base/gfx/opengl/meshx_opengl_shader.cpp

@@ -49,8 +49,8 @@ XMeshOpenGLShader::~XMeshOpenGLShader() {
 	glDeleteBuffers(1, &_indexBuffer);
 }
 
-bool XMeshOpenGLShader::loadFromX(const Common::String &filename, XFileLexer &lexer, Common::Array<MaterialReference> &materialReferences) {
+bool XMeshOpenGLShader::loadFromXData(const Common::String &filename, XFileData *xobj, Common::Array<MaterialReference> &materialReferences) {
-	if (XMesh::loadFromX(filename, lexer, materialReferences)) {
+	if (XMesh::loadFromXData(filename, xobj, materialReferences)) {
 		glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
 		glBufferData(GL_ARRAY_BUFFER, 4 * kVertexComponentCount * _vertexCount, _vertexData, GL_DYNAMIC_DRAW);
 

engines/wintermute/base/gfx/opengl/meshx_opengl_shader.h

@@ -41,7 +41,7 @@ public:
 	XMeshOpenGLShader(BaseGame *inGame, OpenGL::Shader *shader, OpenGL::Shader *flatShadowShader);
 	~XMeshOpenGLShader() override;
 
-	bool loadFromX(const Common::String &filename, XFileLexer &lexer, Common::Array<MaterialReference> &materialReferences) override;
+	bool loadFromXData(const Common::String &filename, XFileData *xobj, Common::Array<MaterialReference> &materialReferences) override;
 	bool render(XModel *model) override;
 	bool renderFlatShadowModel() override;
 	bool update(FrameNode *parentFrame) override;

engines/wintermute/base/gfx/xanimation.cpp

@@ -26,11 +26,12 @@
  */
 
 #include "engines/wintermute/base/base_game.h"
+#include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/base/gfx/xanimation.h"
 #include "engines/wintermute/base/gfx/xanimation_set.h"
 #include "engines/wintermute/base/gfx/xframe_node.h"
 #include "engines/wintermute/base/gfx/xmodel.h"
-#include "engines/wintermute/base/gfx/xloader.h"
+#include "engines/wintermute/base/gfx/xfile_loader.h"
 #include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
@@ -67,72 +68,197 @@ bool Animation::findBone(FrameNode *rootFrame) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool Animation::loadFromX(XFileLexer &lexer, AnimationSet *parentAnimSet) {
+bool Animation::load(XFileData *xobj, AnimationSet *parentAnimSet) {
-	if (lexer.tokenIsIdentifier()) {
+	bool result;
-		lexer.advanceToNextToken(); // skip name
+	XClassType objectType;
-		lexer.advanceOnOpenBraces();
-	} else {
-		lexer.advanceOnOpenBraces();
-	}
 
-	bool ret = true;
+	if (xobj->isReference()) {
+		// The original data is found
+		result = xobj->getType(objectType);
+		if (!result)
+			return result;
 
-	while (!lexer.eof()) {
+		// The object must be a frame
-		if (lexer.tokenIsIdentifier("AnimationKey")) {
+		if (objectType == kXClassFrame) {
-			lexer.advanceToNextToken();
+			// The frame is found, get its name
-			lexer.advanceToNextToken(); // skip name
+			// The name will be used later by the findBone function to get
-			lexer.advanceOnOpenBraces();
+			// a pointer to the target frame
-
+			if (_targetFrame) {
-			int keyType = lexer.readInt();
+				BaseEngine::LOG(0, "Animation frame name reference duplicated");
-			int keyCount = lexer.readInt();
+				return false;
-
-			switch (keyType) {
-			case 0:
-				loadRotationKeyData(lexer, keyCount);
-				break;
-			case 1:
-				loadScaleKeyData(lexer, keyCount);
-				break;
-			case 2:
-				loadPositionKeyData(lexer, keyCount);
-				break;
-			case 3:
-			case 4:
-				loadMatrixKeyData(lexer, keyCount);
-				break;
-			default:
-				warning("Animation::loadFromX unknown key type encountered");
 			}
 
-			lexer.advanceToNextToken(); // skip closed braces
+			// get name
+			result = XModel::loadName(_targetName, xobj);
+			if (!result) {
+				BaseEngine::LOG(0, "Error retrieving frame name while loading animation");
+				return false;
+			}
+		}
+	} else {
+		// a data object is found, get its type
+		result = xobj->getType(objectType);
+		if (!result)
+			return false;
 
-		} else if (lexer.tokenIsIdentifier("AnimationOptions")) {
+		if (objectType == kXClassAnimationKey) {
-			lexer.advanceToNextToken();
+			// an animation key is found, load the data
-			lexer.advanceToNextToken();
+			XAnimationKeyObject *animationKey = xobj->getXAnimationKeyObject();
-			lexer.advanceOnOpenBraces();
+			if (!animationKey)
-
+				return false;
-			// I think we can ignore these for the moment
+			result = loadAnimationKeyData(animationKey);
-			lexer.readInt(); // whether animation is open or closed
+			if (!result)
-			lexer.readInt(); // position quality
+				return false;
-			lexer.advanceToNextToken(); // skip closed braces
+		} else if (objectType == kXClassAnimationOptions) {
-		} else if (lexer.tokenIsOfType(OPEN_BRACES)) {
+			XAnimationOptionsObject *animationOptions = xobj->getXAnimationOptionsObject();
-			// this is a reference to a frame/bone, given as an identifier
+			if (!animationOptions)
-			lexer.advanceToNextToken();
+				return false;
-			_targetName = lexer.readString();
+			result = loadAnimationOptionData(animationOptions, parentAnimSet);
-		} else if (lexer.tokenIsIdentifier("Animation")) {
+			if (!result)
-			// pass it up
+				return false;
-			break;
-		} else if (lexer.reachedClosedBraces()) {
-			lexer.advanceToNextToken(); // skip closed braces
-			break;
-		} else {
-			warning("Animation::loadFromX unexpected token encounterd");
-			ret = false;
-			break;
 		}
 	}
 
-	return ret;
+	return true;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool Animation::loadAnimationOptionData(XAnimationOptionsObject *animationOptionData, AnimationSet *parentAnimSet) {
+	if (animationOptionData->_openclosed && parentAnimSet)
+		parentAnimSet->_looping = true;
+
+	return true;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool Animation::loadAnimationKeyData(XAnimationKeyObject *animationKey) {
+	// get the type and count of the key
+	uint32 keyType = animationKey->_keyType;
+	uint32 numKeys = animationKey->_numKeys;
+
+	if (keyType == 0) { // rotation key
+		if (_rotKeys.size() != 0) {
+			BaseEngine::LOG(0, "Rotation key duplicated");
+			return false;
+		}
+
+		for (uint32 key = 0; key < numKeys; key++) {
+			const XTimedFloatKeys *fileRotKey = &animationKey->_keys[key];
+			assert(fileRotKey->_numTfkeys == 4);
+
+			BoneRotationKey *rotKey = new BoneRotationKey;
+			rotKey->_time         = fileRotKey->_time;
+			// NOTE x files are w x y z and QUATERNIONS are x y z w
+			rotKey->_rotation.w() = fileRotKey->_tfkeys[0];
+			rotKey->_rotation.x() = fileRotKey->_tfkeys[1];
+			rotKey->_rotation.y() = fileRotKey->_tfkeys[2];
+			// mirror z component
+			rotKey->_rotation.z() = -fileRotKey->_tfkeys[3];
+
+			_rotKeys.push_back(rotKey);
+		}
+	} else if (keyType == 1) { // scale key
+		if (_scaleKeys.size() != 0) {
+			BaseEngine::LOG(0, "Scale key duplicated");
+			return false;
+		}
+
+		for (uint32 key = 0; key < numKeys; key++) {
+			const XTimedFloatKeys *fileScaleKey = &animationKey->_keys[key];
+			assert(fileScaleKey->_numTfkeys == 3);
+
+			BoneScaleKey *scaleKey = new BoneScaleKey;
+			scaleKey->_time  = fileScaleKey->_time;
+			for (uint i = 0; i < fileScaleKey->_numTfkeys; ++i) {
+				scaleKey->_scale.getData()[i] = fileScaleKey->_tfkeys[i];
+			}
+
+			_scaleKeys.push_back(scaleKey);
+		}
+	} else if (keyType == 2) { // position key
+		if (_posKeys.size() != 0) {
+			BaseEngine::LOG(0, "Position key duplicated");
+			return false;
+		}
+
+		for (uint32 key = 0; key < numKeys; key++) {
+			const XTimedFloatKeys *filePosKey = &animationKey->_keys[key];
+			assert(filePosKey->_numTfkeys == 3);
+
+			BonePositionKey *posKey = new BonePositionKey;
+			posKey->_time = filePosKey->_time;
+			for (uint i = 0; i < filePosKey->_numTfkeys; ++i) {
+				posKey->_pos.getData()[i] = filePosKey->_tfkeys[i];
+			}
+
+			// mirror Z
+			posKey->_pos.getData()[2] *= -1.0f;
+
+			_posKeys.push_back(posKey);
+		}
+	} else if (keyType == 4) { // matrix key
+		if (_rotKeys.size() != 0 || _scaleKeys.size() != 0 || _posKeys.size() != 0) {
+			BaseEngine::LOG(0, "Matrix key duplicated");
+			return false;
+		}
+
+		for (uint32 key = 0; key < numKeys; key++) {
+			const XTimedFloatKeys *fileMatrixKey = &animationKey->_keys[key];
+			uint32 time = fileMatrixKey->_time;
+			assert(fileMatrixKey->_numTfkeys == 16);
+
+			Math::Matrix4 keyData;
+			for (int r = 0; r < 4; ++r) {
+				for (int c = 0; c < 4; ++c) {
+					keyData(c, r) = fileMatrixKey->_tfkeys[r * 4 + c];
+				}
+			}
+
+			// mirror at orign
+			keyData(2, 3) *= -1.0f;
+
+			// mirror base vectors
+			keyData(2, 0) *= -1.0f;
+			keyData(2, 1) *= -1.0f;
+
+			// change handedness
+			keyData(0, 2) *= -1.0f;
+			keyData(1, 2) *= -1.0f;
+
+			Math::Vector3d translation = keyData.getPosition();
+
+			Math::Vector3d scale;
+			scale.x() = keyData(0, 0) * keyData(0, 0) + keyData(1, 0) * keyData(1, 0) + keyData(2, 0) * keyData(2, 0);
+			scale.x() = sqrtf(scale.x());
+			scale.y() = keyData(0, 1) * keyData(0, 1) + keyData(1, 1) * keyData(1, 1) + keyData(2, 1) * keyData(2, 1);
+			scale.y() = sqrtf(scale.y());
+			scale.z() = keyData(0, 2) * keyData(0, 2) + keyData(1, 2) * keyData(1, 2) + keyData(2, 2) * keyData(2, 2);
+			scale.z() = sqrtf(scale.z());
+
+			Math::Quaternion rotation;
+			rotation.fromMatrix(keyData.getRotation());
+
+			BonePositionKey *positionKey = new BonePositionKey;
+			BoneScaleKey *scaleKey = new BoneScaleKey;
+			BoneRotationKey *rotationKey = new BoneRotationKey;
+
+			positionKey->_time = time;
+			scaleKey->_time = time;
+			rotationKey->_time = time;
+
+			positionKey->_pos = translation;
+			scaleKey->_scale = scale;
+			rotationKey->_rotation = rotation;
+
+			_posKeys.push_back(positionKey);
+			_scaleKeys.push_back(scaleKey);
+			_rotKeys.push_back(rotationKey);
+		}
+	} else {
+		// the type is unknown, report the error
+		BaseEngine::LOG(0, "Unexpected animation key type (%d)", keyType);
+	}
+	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -307,146 +433,4 @@ uint32 Animation::getTotalTime() {
 	return totalTime;
 }
 
-// try to put these functions into a template?
-bool Animation::loadRotationKeyData(XFileLexer &lexer, int count) {
-	for (int keyIndex = 0; keyIndex < count; ++keyIndex) {
-		BoneRotationKey *key = new BoneRotationKey;
-		key->_time = lexer.readInt();
-
-		int floatCount = lexer.readInt();
-		assert(floatCount == 4);
-
-		// .X file format puts the w coordinate first
-		key->_rotation.w() = lexer.readFloat();
-		key->_rotation.x() = lexer.readFloat();
-		key->_rotation.y() = lexer.readFloat();
-		// mirror z component
-		key->_rotation.z() = -lexer.readFloat();
-
-		lexer.skipTerminator(); // skip semicolon
-
-		if (lexer.tokenIsOfType(SEMICOLON) || lexer.tokenIsOfType(COMMA)) {
-			lexer.advanceToNextToken(); // skip closed braces
-		}
-
-		_rotKeys.push_back(key);
-	}
-
-	return true;
-}
-
-bool Animation::loadScaleKeyData(XFileLexer &lexer, int count) {
-	for (int keyIndex = 0; keyIndex < count; ++keyIndex) {
-		BoneScaleKey *key = new BoneScaleKey;
-		key->_time = lexer.readInt();
-
-		int floatCount = lexer.readInt();
-		assert(floatCount == 3);
-
-		for (int i = 0; i < floatCount; ++i) {
-			key->_scale.getData()[i] = lexer.readFloat();
-		}
-
-		lexer.skipTerminator(); // skip semicolon
-
-		if (lexer.tokenIsOfType(SEMICOLON) || lexer.tokenIsOfType(COMMA)) {
-			lexer.advanceToNextToken(); // skip closed braces
-		}
-
-		_scaleKeys.push_back(key);
-	}
-
-	return true;
-}
-
-bool Animation::loadPositionKeyData(XFileLexer &lexer, int count) {
-	for (int keyIndex = 0; keyIndex < count; ++keyIndex) {
-		BonePositionKey *key = new BonePositionKey;
-		key->_time = lexer.readInt();
-
-		int floatCount = lexer.readInt();
-		assert(floatCount == 3);
-
-		for (int i = 0; i < floatCount; ++i) {
-			key->_pos.getData()[i] = lexer.readFloat();
-		}
-
-		key->_pos.getData()[2] *= -1.0f;
-
-		lexer.skipTerminator(); // skip semicolon
-
-		if (lexer.tokenIsOfType(SEMICOLON) || lexer.tokenIsOfType(COMMA)) {
-			lexer.advanceToNextToken(); // skip closed braces
-		}
-
-		_posKeys.push_back(key);
-	}
-
-	return true;
-}
-
-bool Animation::loadMatrixKeyData(XFileLexer &lexer, int count) {
-	for (int keyIndex = 0; keyIndex < count; ++keyIndex) {
-		uint32 time = lexer.readInt();
-		int floatCount = lexer.readInt();
-		assert(floatCount == 16);
-
-		Math::Matrix4 keyData;
-
-		for (int r = 0; r < 4; ++r) {
-			for (int c = 0; c < 4; ++c) {
-				keyData(c, r) = lexer.readFloat();
-			}
-		}
-
-		// mirror at orign
-		keyData(2, 3) *= -1.0f;
-
-		// mirror base vectors
-		keyData(2, 0) *= -1.0f;
-		keyData(2, 1) *= -1.0f;
-
-		// change handedness
-		keyData(0, 2) *= -1.0f;
-		keyData(1, 2) *= -1.0f;
-
-		Math::Vector3d translation = keyData.getPosition();
-
-		Math::Vector3d scale;
-		scale.x() = keyData(0, 0) * keyData(0, 0) + keyData(1, 0) * keyData(1, 0) + keyData(2, 0) * keyData(2, 0);
-		scale.x() = sqrtf(scale.x());
-		scale.y() = keyData(0, 1) * keyData(0, 1) + keyData(1, 1) * keyData(1, 1) + keyData(2, 1) * keyData(2, 1);
-		scale.y() = sqrtf(scale.y());
-		scale.z() = keyData(0, 2) * keyData(0, 2) + keyData(1, 2) * keyData(1, 2) + keyData(2, 2) * keyData(2, 2);
-		scale.z() = sqrtf(scale.z());
-
-		Math::Quaternion rotation;
-		rotation.fromMatrix(keyData.getRotation());
-
-		BonePositionKey *positionKey = new BonePositionKey;
-		BoneScaleKey *scaleKey = new BoneScaleKey;
-		BoneRotationKey *rotationKey = new BoneRotationKey;
-
-		positionKey->_time = time;
-		scaleKey->_time = time;
-		rotationKey->_time = time;
-
-		positionKey->_pos = translation;
-		scaleKey->_scale = scale;
-		rotationKey->_rotation = rotation;
-
-		_posKeys.push_back(positionKey);
-		_scaleKeys.push_back(scaleKey);
-		_rotKeys.push_back(rotationKey);
-
-		lexer.skipTerminator(); // skip semicolon
-
-		if (lexer.tokenIsOfType(SEMICOLON) || lexer.tokenIsOfType(COMMA)) {
-			lexer.advanceToNextToken(); // skip closed braces
-		}
-	}
-
-	return true;
-}
-
 } // namespace Wintermute

engines/wintermute/base/gfx/xanimation.h

@@ -38,14 +38,16 @@ namespace Wintermute {
 
 class FrameNode;
 class AnimationSet;
-class XFileLexer;
+class XFileData;
+struct XAnimationKeyObject;
+struct XAnimationOptionsObject;
 
 class Animation : public BaseClass {
 public:
 	Animation(BaseGame *inGame);
 	virtual ~Animation();
 
-	bool loadFromX(XFileLexer &lexer, AnimationSet *parentAnimationSet);
+	bool load(XFileData *xobj, AnimationSet *parentAnimSet);
 
 	bool findBone(FrameNode *rootFrame);
 	bool update(int slot, uint32 localTime, float animLerpValue);
@@ -79,10 +81,8 @@ protected:
 	BaseArray<BoneScaleKey *> _scaleKeys;
 
 private:
-	bool loadRotationKeyData(XFileLexer &lexer, int count);
+	bool loadAnimationKeyData(XAnimationKeyObject *animationKey);
-	bool loadScaleKeyData(XFileLexer &lexer, int count);
+	bool loadAnimationOptionData(XAnimationOptionsObject *animationSet, AnimationSet *parentAnimSet);
-	bool loadPositionKeyData(XFileLexer &lexer, int count);
-	bool loadMatrixKeyData(XFileLexer &lexer, int count);
 };
 
 } // namespace Wintermute

engines/wintermute/base/gfx/xanimation_set.cpp

@@ -28,7 +28,6 @@
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/gfx/xanimation_set.h"
 #include "engines/wintermute/base/gfx/xmodel.h"
-#include "engines/wintermute/base/gfx/xloader.h"
 #include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
@@ -56,39 +55,6 @@ AnimationSet::~AnimationSet() {
 	_events.clear();
 }
 
-bool AnimationSet::loadFromX(XFileLexer &lexer, const Common::String &filename) {
-	if (lexer.tokenIsIdentifier()) {
-		setName(lexer.tokenToString().c_str());
-		lexer.advanceToNextToken();
-	} else {
-		Common::String name = filename + "_animation";
-		setName(name.c_str());
-	}
-
-	lexer.advanceToNextToken();
-
-	bool ret = true;
-
-	while (!lexer.eof()) {
-		if (lexer.tokenIsIdentifier("Animation")) {
-			lexer.advanceToNextToken();
-
-			Animation *animation = new Animation(_gameRef);
-			animation->loadFromX(lexer, this);
-			_animations.add(animation);
-		} else if (lexer.reachedClosedBraces()) {
-			lexer.advanceToNextToken(); // skip closed braces
-			break;
-		} else {
-			warning("AnimationSet::loadFromX unexpected token");
-			ret = false;
-			break;
-		}
-	}
-
-	return ret;
-}
-
 //////////////////////////////////////////////////////////////////////////
 bool AnimationSet::findBones(FrameNode *rootFrame) {
 	for (uint32 i = 0; i < _animations.size(); i++) {

engines/wintermute/base/gfx/xanimation_set.h

@@ -38,7 +38,6 @@
 namespace Wintermute {
 
 class XModel;
-class XFileLexer;
 
 class AnimationSet : public BaseNamedObject {
 public:
@@ -75,7 +74,6 @@ public:
 	AnimationSet(BaseGame *inGame, XModel *model);
 	virtual ~AnimationSet();
 
-	bool loadFromX(XFileLexer &lexer, const Common::String &filename);
 	bool findBones(FrameNode *rootFrame);
 	bool addAnimation(Animation *anim);
 	bool addEvent(AnimationEvent *event);

engines/wintermute/base/gfx/xfile.cpp

@@ -0,0 +1,89 @@
+/* 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/>.
+ *
+ */
+
+/*
+ * This file is based on WME.
+ * http://dead-code.org/redir.php?target=wme
+ * Copyright (c) 2003-2013 Jan Nedoma and contributors
+ */
+
+#include "engines/wintermute/base/base_file_manager.h"
+#include "engines/wintermute/base/base_game.h"
+#include "engines/wintermute/base/base_engine.h"
+#include "engines/wintermute/base/gfx/xfile.h"
+#include "engines/wintermute/dcgf.h"
+
+namespace Wintermute {
+
+//////////////////////////////////////////////////////////////////////////
+XFile::XFile(BaseGame *inGame) : BaseClass(inGame) {
+	_xfile = nullptr;
+}
+
+//////////////////////////////////////////////////////////////////////////
+XFile::~XFile() {
+	closeFile();
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool XFile::closeFile() {
+	delete _xfile;
+	_xfile = nullptr;
+
+	return true;
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool XFile::openFile(const Common::String &filename) {
+	closeFile();
+
+	// load file
+	uint32 size;
+	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename, &size);
+	if (!buffer) {
+		closeFile();
+		return false;
+	}
+
+	_xfile = new XFileLoader();
+	if (!_xfile) {
+		delete[] buffer;
+		return false;
+	}
+
+	bool res = _xfile->load(buffer, size);
+	delete[] buffer;
+	if (!res) {
+		BaseEngine::LOG(0, "Error loading X file '%s'", filename.c_str());
+		return false;
+	}
+
+	// create enum object
+	if (!res || !_xfile->createEnumObject(_xenum)) {
+		BaseEngine::LOG(res, "Error creating XFile enum object for '%s'", filename.c_str());
+		closeFile();
+		return false;
+	}
+
+	return true;
+}
+
+} // namespace Wintermute

engines/wintermute/base/gfx/xfile.h

@@ -0,0 +1,56 @@
+/* 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/>.
+ *
+ */
+
+/*
+ * This file is based on WME.
+ * http://dead-code.org/redir.php?target=wme
+ * Copyright (c) 2003-2013 Jan Nedoma and contributors
+ */
+
+#ifndef WINTERMUTE_XFILE_H
+#define WINTERMUTE_XFILE_H
+
+#include "engines/wintermute/base/base.h"
+#include "engines/wintermute/base/gfx/xfile_loader.h"
+
+namespace Wintermute {
+
+class XFile : public BaseClass {
+public:
+	XFile(BaseGame *inGame);
+	virtual ~XFile();
+
+	bool openFile(const Common::String &filename);
+	bool closeFile();
+
+	XFileEnumObject getEnum() {
+		return _xenum;
+	}
+
+private:
+
+	XFileLoader *_xfile;
+	XFileEnumObject _xenum;
+};
+
+} // namespace Wintermute
+
+#endif

engines/wintermute/base/gfx/xfile_loader.h

@@ -0,0 +1,566 @@
+/* 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/>.
+ *
+ */
+
+/*
+ * Partially based on XFile parser code from Wine sources.
+ * Copyright 2008 Christian Costa
+ */
+
+#ifndef WINTERMUTE_XFILE_LOADER_H
+#define WINTERMUTE_XFILE_LOADER_H
+
+#include "common/str.h"
+#include "common/stack.h"
+
+namespace Wintermute {
+
+enum XTokenType : uint16 {
+	XTOKEN_ERROR        = 0xffff,
+	XTOKEN_NONE         = 0,
+	XTOKEN_NAME         = 1,
+	XTOKEN_STRING       = 2,
+	XTOKEN_INTEGER      = 3,
+	XTOKEN_GUID         = 5,
+	XTOKEN_INTEGER_LIST = 6,
+	XTOKEN_FLOAT_LIST   = 7,
+	XTOKEN_OBRACE       = 10,
+	XTOKEN_CBRACE       = 11,
+	XTOKEN_OPAREN       = 12,
+	XTOKEN_CPAREN       = 13,
+	XTOKEN_OBRACKET     = 14,
+	XTOKEN_CBRACKET     = 15,
+	XTOKEN_OANGLE       = 16,
+	XTOKEN_CANGLE       = 17,
+	XTOKEN_DOT          = 18,
+	XTOKEN_COMMA        = 19,
+	XTOKEN_SEMICOLON    = 20,
+	XTOKEN_TEMPLATE     = 31,
+	XTOKEN_WORD         = 40,
+	XTOKEN_DWORD        = 41,
+	XTOKEN_FLOAT        = 42,
+	XTOKEN_DOUBLE       = 43,
+	XTOKEN_CHAR         = 44,
+	XTOKEN_UCHAR        = 45,
+	XTOKEN_SWORD        = 46,
+	XTOKEN_SDWORD       = 47,
+	XTOKEN_VOID         = 48,
+	XTOKEN_LPSTR        = 49,
+	XTOKEN_UNICODE      = 50,
+	XTOKEN_CSTRING      = 51,
+	XTOKEN_ARRAY        = 52
+};
+
+#define XMAX_NAME_LEN   120
+#define XMAX_STRING_LEN 500
+
+struct XToken {
+	XTokenType      _type;
+	char            _textVal[XMAX_STRING_LEN];
+	uint32          _integerVal;
+	float           _floatVal;
+};
+
+struct XVector {
+	float           _x;
+	float           _y;
+	float           _z;
+};
+
+struct XCoords2d {
+	float           _u;
+	float           _v;
+};
+
+struct XMeshFace {
+	uint32          _numFaceVertexIndices;
+	uint32          _faceVertexIndices[4];
+};
+
+struct XTimedFloatKeys {
+	float           _time;
+	uint32          _numTfkeys;
+	float           _tfkeys[16];
+};
+
+struct XIndexedColor {
+	uint32          _index;
+	float           _indexColorR;
+	float           _indexColorG;
+	float           _indexColorB;
+	float           _indexColorA;
+};
+
+struct XVertexElement {
+	uint32          _type;
+	uint32          _method;
+	uint32          _usage;
+	uint32          _usageIndex;
+};
+
+struct XMeshMaterialListObject {
+	uint32          _nMaterials;
+	uint32          _numFaceIndexes;
+	uint32          *_faceIndexes{};
+
+	~XMeshMaterialListObject() {
+		delete[] _faceIndexes;
+	}
+};
+
+struct XVertexDuplicationIndicesObject {
+	uint32          _nOriginalVertices;
+	uint32          _numIndices;
+	uint32          *_indices{};
+
+	~XVertexDuplicationIndicesObject() {
+		delete[] _indices;
+	}
+};
+
+struct XSkinMeshHeaderObject{
+	uint32          _nMaxSkinWeightsPerVertex;
+	uint32          _nMaxSkinWeightsPerFace;
+	uint32          _nBones;
+};
+
+struct XSkinWeightsObject {
+	char            _transformNodeName[XMAX_NAME_LEN];
+	uint32          _numVertexIndices;
+	uint32          *_vertexIndices{};
+	uint32          _numWeights;
+	float           *_weights{};
+	float           _matrixOffset[16];
+
+	~XSkinWeightsObject() {
+		delete[] _vertexIndices;
+		delete[] _weights;
+	}
+};
+
+struct XMeshObject {
+	uint32          _numVertices;
+	XVector         *_vertices{};
+	uint32          _numFaces;
+	XMeshFace       *_faces{};
+
+	~XMeshObject() {
+		delete[] _vertices;
+		delete[] _faces;
+	}
+};
+
+struct XMeshNormalsObject {
+	uint32          _numNormals;
+	XVector         *_normals{};
+	uint32          _numFaceNormals;
+	XMeshFace       *_faceNormals{};
+
+	~XMeshNormalsObject() {
+		delete[] _normals;
+		delete[] _faceNormals;
+	}
+};
+
+struct XMeshVertexColorsObject {
+	uint32          _numVertexColors;
+	XIndexedColor   *_vertexColors{};
+
+	~XMeshVertexColorsObject() {
+		delete[] _vertexColors;
+	}
+};
+
+struct XMeshTextureCoordsObject {
+	uint32          _numTextureCoords;
+	XCoords2d       *_textureCoords{};
+
+	~XMeshTextureCoordsObject() {
+		delete[] _textureCoords;
+	}
+};
+
+struct XMaterialObject {
+	float           _colorR;
+	float           _colorG;
+	float           _colorB;
+	float           _colorA;
+	float           _power;
+	float           _specularR;
+	float           _specularG;
+	float           _specularB;
+	float           _emissiveR;
+	float           _emissiveG;
+	float           _emissiveB;
+};
+
+struct XTextureFilenameObject {
+	char            _filename[XMAX_NAME_LEN];
+};
+
+struct XAnimTicksPerSecondObject {
+	uint32          _animTicksPerSecond;
+};
+
+struct XAnimationSetObject{
+};
+
+struct XAnimationObject{
+};
+
+struct XAnimationKeyObject {
+	uint32          _keyType;
+	uint32          _numKeys;
+	XTimedFloatKeys *_keys{};
+
+	~XAnimationKeyObject() {
+		delete[] _keys;
+	}
+};
+
+struct XAnimationOptionsObject {
+	uint32          _openclosed;
+	uint32          _positionquality;
+};
+
+struct XFrameObject {
+};
+
+struct XFrameTransformMatrixObject {
+	float           _frameMatrix[16];
+};
+
+struct XDeclDataObject {
+	uint32          _numElements;
+	XVertexElement  *_elements{};
+	uint32          _numData;
+	uint32          *_data{};
+
+	~XDeclDataObject() {
+		delete[] _elements;
+		delete[] _data;
+	}
+};
+
+struct XFVFDataObject {
+	uint32          _dwFVF;
+	uint32          _numData;
+	uint32          *_data{};
+
+	~XFVFDataObject() {
+		delete[] _data;
+	}
+};
+
+enum XClassType {
+	kXClassUnknown = 0,
+	kXClassAnimTicksPerSecond,
+	kXClassFrameTransformMatrix,
+	kXClassFrame,
+	kXClassMesh,
+	kXClassMeshNormals,
+	kXClassMeshVertexColors,
+	kXClassMeshTextureCoords,
+	kXClassMeshMaterialList,
+	kXClassVertexDuplicationIndices,
+	kXClassMaterial,
+	kXClassTextureFilename,
+	kXClassSkinMeshHeader,
+	kXClassSkinWeights,
+	kXClassAnimationSet,
+	kXClassAnimation,
+	kXClassAnimationKey,
+	kXClassAnimationOptions,
+	kXClassDeclData,
+	kXClassFVFData,
+};
+
+class XFileEnumObject;
+
+class XObject {
+	friend class XFileLoader;
+	friend class XFileData;
+	friend class XFileEnumObject;
+
+private:
+
+	Common::String _name;
+	XClassType _classType{};
+	void *_object{};
+	XObject *_targetObject{};
+	Common::Stack<XObject *> _children;
+
+public:
+
+	void deinit() {
+		switch (_classType) {
+		case kXClassAnimTicksPerSecond:
+			delete (XAnimTicksPerSecondObject *)_object;
+			break;
+		case kXClassAnimationKey:
+			delete (XAnimationKeyObject *)_object;
+			break;
+		case kXClassAnimation:
+			delete (XAnimationObject *)_object;
+			break;
+		case kXClassAnimationOptions:
+			delete (XAnimationOptionsObject *)_object;
+			break;
+		case kXClassAnimationSet:
+			delete (XAnimationSetObject *)_object;
+			break;
+		case kXClassDeclData:
+			delete (XDeclDataObject *)_object;
+			break;
+		case kXClassFrame:
+			delete (XFrameObject *)_object;
+			break;
+		case kXClassFrameTransformMatrix:
+			delete (XFrameTransformMatrixObject *)_object;
+			break;
+		case kXClassFVFData:
+			delete (XFVFDataObject *)_object;
+			break;
+		case kXClassMaterial:
+			delete (XMaterialObject *)_object;
+			break;
+		case kXClassMesh:
+			delete (XMeshObject *)_object;
+			break;
+		case kXClassMeshMaterialList:
+			delete (XMeshMaterialListObject *)_object;
+			break;
+		case kXClassMeshNormals:
+			delete (XMeshNormalsObject *)_object;
+			break;
+		case kXClassMeshVertexColors:
+			delete (XMeshVertexColorsObject *)_object;
+			break;
+		case kXClassMeshTextureCoords:
+			delete (XMeshTextureCoordsObject *)_object;
+			break;
+		case kXClassSkinMeshHeader:
+			delete (XSkinMeshHeaderObject *)_object;
+			break;
+		case kXClassSkinWeights:
+			delete (XSkinWeightsObject *)_object;
+			break;
+		case kXClassVertexDuplicationIndices:
+			delete (XVertexDuplicationIndicesObject *)_object;
+			break;
+		case kXClassTextureFilename:
+			delete (XTextureFilenameObject *)_object;
+			break;
+		case kXClassUnknown:
+			break;
+		}
+	}
+};
+
+class XFileLoader {
+	friend class XFileEnumObject;
+
+private:
+
+	const int kCabBlockSize = 0x8000;
+	const int kCabInputmax = kCabBlockSize + 12;
+
+	bool _initialised{};
+	XToken _currentToken;
+	byte *_decompBuffer{};
+	byte *_buffer;
+	uint32 _bufferLeft;
+	bool _isText;
+	uint32 _listNbElements;
+	bool _listTypeFloat;
+	bool _listSeparator;
+	bool _tokenPresent;
+
+	Common::Stack<XObject *> _xobjects;
+
+public:
+
+	XFileLoader();
+	~XFileLoader();
+	bool load(byte *buffer, uint32 bufferSize);
+	bool createEnumObject(XFileEnumObject &xobj);
+
+private:
+
+	void init();
+	void deinit();
+
+	FORCEINLINE bool readChar(char &c);
+	FORCEINLINE void rewindBytes(uint32 size);
+	bool readBytes(void *data, uint32 size);
+	bool readLE16(uint16 *data);
+	bool readLE32(uint32 *data);
+	bool readBE32(uint32 *data);
+
+	FORCEINLINE bool getInteger(uint32 &value);
+	FORCEINLINE bool getFloat(float &value);
+	FORCEINLINE bool getString(char *str, uint maxLen);
+	FORCEINLINE bool skipSemicolonComma();
+
+	FORCEINLINE bool isSpace(char c);
+	FORCEINLINE bool isOperator(char c);
+	FORCEINLINE bool isSeparator(char c);
+	FORCEINLINE bool isPrimitiveType(XTokenType token);
+	FORCEINLINE bool isGuid();
+	FORCEINLINE bool isName();
+	FORCEINLINE bool isFloat();
+	FORCEINLINE bool isInteger();
+	FORCEINLINE bool isString();
+	FORCEINLINE bool isKeyword(const char *keyword, uint len);
+	FORCEINLINE XTokenType getKeywordToken();
+	FORCEINLINE XTokenType checkToken();
+	XTokenType getToken();
+	void parseToken();
+
+	bool decompressMsZipData();
+
+	bool parseHeader();
+
+	bool parseTemplate();
+	bool parseTemplateParts();
+	bool parseTemplateOptionInfo();
+	bool parseTemplateMembersList();
+	XObject *resolveChildObject(XObject *object, const Common::String &referenceName);
+	bool resolveObject(XObject *referenceObject, const Common::String &referenceName);
+	bool parseObject(XObject *object);
+	bool parseChildObjects(XObject *object);
+	bool parseObjectParts(XObject *object);
+};
+
+class XFileData {
+	friend class XFileEnumObject;
+
+private:
+
+	XObject *_xobject{};
+	bool _reference{};
+
+public:
+
+	bool getChild(uint id, XFileData &child) {
+		if (_xobject) {
+			if (id < _xobject->_children.size()) {
+				child._xobject = _xobject->_children[id];
+				if (child._xobject->_targetObject) {
+					child._xobject = child._xobject->_targetObject;
+					child._reference = true;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+
+	bool getChildren(uint &num) {
+		if (_xobject) {
+			num = _xobject->_children.size();
+			return true;
+		}
+		return false;
+	}
+
+	bool getName(Common::String &name) {
+		if (_xobject) {
+			name = _xobject->_name;
+			return true;
+		}
+		return false;
+	}
+
+	bool getType(XClassType &classType) {
+		if (_xobject) {
+			classType = _xobject->_classType;
+			return true;
+		}
+		return false;
+	}
+
+	bool isReference() {
+		if (_xobject) {
+			return _reference;
+		}
+		return false;
+	}
+
+#define GET_OBJECT_FUNC(objectName) \
+	objectName *get ## objectName() { \
+		if (_xobject) \
+			return static_cast<objectName *>(_xobject->_object); \
+		else \
+			return nullptr; \
+	}
+
+	GET_OBJECT_FUNC(XAnimTicksPerSecondObject)
+	GET_OBJECT_FUNC(XAnimationKeyObject)
+	GET_OBJECT_FUNC(XAnimationObject)
+	GET_OBJECT_FUNC(XAnimationOptionsObject)
+	GET_OBJECT_FUNC(XAnimationSetObject)
+	GET_OBJECT_FUNC(XDeclDataObject)
+	GET_OBJECT_FUNC(XFrameObject)
+	GET_OBJECT_FUNC(XFrameTransformMatrixObject)
+	GET_OBJECT_FUNC(XFVFDataObject)
+	GET_OBJECT_FUNC(XMaterialObject)
+	GET_OBJECT_FUNC(XMeshObject)
+	GET_OBJECT_FUNC(XMeshMaterialListObject)
+	GET_OBJECT_FUNC(XMeshNormalsObject)
+	GET_OBJECT_FUNC(XMeshVertexColorsObject)
+	GET_OBJECT_FUNC(XMeshTextureCoordsObject)
+	GET_OBJECT_FUNC(XSkinMeshHeaderObject)
+	GET_OBJECT_FUNC(XSkinWeightsObject)
+	GET_OBJECT_FUNC(XVertexDuplicationIndicesObject)
+	GET_OBJECT_FUNC(XTextureFilenameObject)
+};
+
+class XFileEnumObject {
+	friend class XFileLoader;
+
+private:
+
+	XFileLoader *_file{};
+
+public:
+
+	bool getChild(uint id, XFileData &child) {
+		if (_file) {
+			if (id < _file->_xobjects.size()) {
+				child._xobject = _file->_xobjects[id];
+				return true;
+			}
+		}
+		return false;
+	}
+
+	bool getChildren(uint &num) {
+		if (_file) {
+			num = _file->_xobjects.size();
+			return true;
+		}
+		return false;
+	}
+};
+
+} // namespace Wintermute
+
+#endif

engines/wintermute/base/gfx/xframe_node.cpp

@@ -26,11 +26,12 @@
  */
 
 #include "engines/wintermute/base/base_game.h"
+#include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/base/gfx/base_renderer3d.h"
 #include "engines/wintermute/base/gfx/xmaterial.h"
 #include "engines/wintermute/base/gfx/xframe_node.h"
 #include "engines/wintermute/base/gfx/xmodel.h"
-#include "engines/wintermute/base/gfx/xloader.h"
+#include "engines/wintermute/base/gfx/xfile_loader.h"
 #include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
@@ -97,42 +98,35 @@ void FrameNode::setTransformation(int slot, Math::Vector3d pos, Math::Vector3d s
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool FrameNode::loadFromX(const Common::String &filename, XFileLexer &lexer, XModel *model, Common::Array<MaterialReference> &materialReferences) {
+bool FrameNode::loadFromXData(const Common::String &filename, XModel *model, XFileData *xobj, Common::Array<MaterialReference> &materialReferences) {
 	_gameRef->miniUpdate();
 
-	bool ret = true;
+	bool res = true;
 
-	setName(lexer.tokenToString().c_str());
+	// get the type of the object
-	lexer.advanceToNextToken();
+	XClassType objectType;
-	lexer.advanceOnOpenBraces();
+	res = xobj->getType(objectType);
-
-	while (!lexer.eof()) {
-		if (lexer.tokenIsIdentifier("Frame")) {
-			lexer.advanceToNextToken();
-			FrameNode *child = new FrameNode(_gameRef);
-			if (child->loadFromX(filename, lexer, model, materialReferences)) {
-				_frames.add(child);
-			} else {
-				delete child;
-			}
-		} else if (lexer.tokenIsIdentifier("Mesh")) {
-			lexer.advanceToNextToken();
-			XMesh *mesh = _gameRef->_renderer3D->createXMesh();
-
-			if (mesh->loadFromX(filename, lexer, materialReferences)) {
-				_meshes.add(mesh);
-			} else {
-				delete mesh;
-			}
-		} else if (lexer.tokenIsIdentifier("FrameTransformMatrix")) {
-			lexer.advanceToNextToken();
-			lexer.advanceToNextToken(); // skip optional name
-			lexer.advanceOnOpenBraces();
 
+	if (objectType == kXClassMesh) { // load a child mesh
+		XMesh *mesh = _gameRef->_renderer3D->createXMesh();
+		res = mesh->loadFromXData(filename, xobj, materialReferences);
+		if (res) {
+			_meshes.add(mesh);
+			return true;
+		} else {
+			delete mesh;
+			return false;
+		}
+	} else if (objectType == kXClassFrameTransformMatrix) { // load the transformation matrix
+		XFrameTransformMatrixObject *frameTransformMatrix = xobj->getXFrameTransformMatrixObject();
+		if (!frameTransformMatrix) {
+			BaseEngine::LOG(0, "Error loading transformation matrix");
+			return false;
+		} else {
 			// TODO: check if this is the right format
 			for (int r = 0; r < 4; ++r) {
 				for (int c = 0; c < 4; ++c) {
-					_transformationMatrix(c, r) = lexer.readFloat();
+					_transformationMatrix(c, r) = frameTransformMatrix->_frameMatrix[r * 4 + c];
 				}
 			}
 
@@ -148,84 +142,85 @@ bool FrameNode::loadFromX(const Common::String &filename, XFileLexer &lexer, XMo
 			_transformationMatrix(1, 2) *= -1.0f;
 
 			_originalMatrix = _transformationMatrix;
-
+			return true;
-			lexer.skipTerminator();
-			lexer.advanceToNextToken();
-
-		} else if (lexer.reachedClosedBraces()) {
-			lexer.advanceToNextToken();
-			break;
-		} else {
-			warning("FrameNode::loadFromX unexpected %i token excountered", lexer.getTypeOfToken());
-			ret = false;
-			break;
 		}
+	} else if (objectType == kXClassAnimationSet) { // load animation set
+		return model->loadAnimationSet(filename, xobj);
+	} else if (objectType == kXClassAnimation) { // load a single animation (shouldn't happen here)
+		return model->loadAnimation(filename, xobj);
+	} else if (objectType == kXClassFrame) { // create a new child frame
+		FrameNode *childFrame = new FrameNode(_gameRef);
+
+		// get the name of the child frame
+		res = XModel::loadName(childFrame, xobj);
+		if (!res) {
+			BaseEngine::LOG(0, "Error loading frame name");
+			delete childFrame;
+			return res;
+		}
+
+		// Enumerate child objects.
+		res = false;
+		uint32 numChildren = 0;
+		xobj->getChildren(numChildren);
+		for (uint32 i = 0; i < numChildren; i++) {
+			XFileData xchildData;
+			res = xobj->getChild(i, xchildData);
+			if (res)
+				res = childFrame->loadFromXData(filename, model, &xchildData, materialReferences);
+		}
+		if (res)
+			_frames.add(childFrame);
+		else
+			delete childFrame;
+		return res;
+	} else if (objectType == kXClassAnimTicksPerSecond) {
+		if (!xobj->getXAnimTicksPerSecondObject()) {
+			BaseEngine::LOG(0, "Error loading ticks per seconds info");
+			return res;
+		} else {
+			model->_ticksPerSecond = xobj->getXAnimTicksPerSecondObject()->_animTicksPerSecond;
+			return true;
+		}
+	} else if (objectType == kXClassMaterial) {
+		MaterialReference materialReference;
+		xobj->getName(materialReference._name);
+		materialReference._material = new Material(_gameRef);
+		materialReference._material->loadFromX(xobj, filename);
+		materialReferences.push_back(materialReference);
+		return true;
 	}
 
-	return ret;
+	return true;
 }
 
-bool FrameNode::loadFromXAsRoot(const Common::String &filename, XFileLexer &lexer, XModel *model, Common::Array<MaterialReference> &materialReferences) {
+bool FrameNode::mergeFromXData(const Common::String &filename, XModel *model, XFileData *xobj) {
-	// technically, there is no root node in a .X file
+	bool res = true;
-	// so we just start parsing it here
-	lexer.advanceToNextToken();
 
-	while (!lexer.eof()) {
+	// get the type of the object
-		if (lexer.tokenIsIdentifier("Frame")) {
+	XClassType objectType;
-			lexer.advanceToNextToken();
+	res = xobj->getType(objectType);
-			FrameNode *child = new FrameNode(_gameRef);
+	if (!res) {
-			if (child->loadFromX(filename, lexer, model, materialReferences)) {
+		BaseEngine::LOG(0, "Error getting object type");
-				_frames.add(child);
+		return res;
-			} else {
+	} else if (objectType == kXClassAnimationSet) { // load animation set
-				delete child;
+		return model->loadAnimationSet(filename, xobj);
-			}
+	} else if (objectType == kXClassAnimation) { // load a single animation (shouldn't happen here)
-		} else if (lexer.tokenIsIdentifier("Mesh")) {
+		return model->loadAnimation(filename, xobj);
-			lexer.advanceToNextToken();
+	} else if (objectType == kXClassFrame) { // scan child frames
-			XMesh *mesh = _gameRef->_renderer3D->createXMesh();
+		// Enumerate child objects.
+		res = false;
 
-			if (mesh->loadFromX(filename, lexer, materialReferences)) {
+		uint32 numChildren = 0;
-				_meshes.add(mesh);
+		xobj->getChildren(numChildren);
-			} else {
+		for (uint32 i = 0; i < numChildren; i++) {
-				delete mesh;
+			XFileData xchildData;
-			}
+			res = xobj->getChild(i, xchildData);
-		} else if (lexer.tokenIsIdentifier("AnimTicksPerSecond")) {
+			if (res)
-			lexer.advanceToNextToken();
+				res = mergeFromXData(filename, model, &xchildData);
-			lexer.advanceOnOpenBraces();
-
-			model->_ticksPerSecond = lexer.readInt();
-			lexer.advanceToNextToken(); // skip closed braces
-		} else if (lexer.tokenIsIdentifier("AnimationSet")) {
-			lexer.advanceToNextToken();
-			model->loadAnimationSet(lexer, filename);
-		} else if (lexer.tokenIsIdentifier("template")) {
-			// we can ignore templates
-			while (!lexer.eof()) {
-				if (lexer.reachedClosedBraces()) {
-					break;
-				}
-
-				lexer.advanceToNextToken();
-			}
-
-			lexer.advanceToNextToken();
-		} else if(lexer.tokenIsIdentifier("Material")) {
-			lexer.advanceToNextToken();
-			MaterialReference materialReference;
-
-			materialReference._name = lexer.tokenToString();
-			materialReference._material = new Material(_gameRef);
-			materialReference._material->loadFromX(lexer, filename);
-
-			materialReferences.push_back(materialReference);
-		} else if (lexer.tokenIsOfType(NULL_CHAR)) {
-			// prevents some unnecessary warnings
-			lexer.advanceToNextToken();
-		} else {
-			warning("FrameNode::loadFromXAsRoot unknown token %i encountered", lexer.getTypeOfToken());
-			lexer.advanceToNextToken(); // just ignore it for the moment
 		}
+		return res;
 	}
-
 	return true;
 }
 

engines/wintermute/base/gfx/xframe_node.h

@@ -40,8 +40,8 @@
 namespace Wintermute {
 
 class XModel;
+class XFileData;
 class BaseSprite;
-class XFileLexer;
 
 class FrameNode : public BaseNamedObject {
 public:
@@ -55,8 +55,8 @@ public:
 	bool renderFlatShadowModel();
 	bool updateShadowVol(ShadowVolume *shadow, Math::Matrix4 &modelMat, const Math::Vector3d &light, float extrusionDepth);
 
-	bool loadFromX(const Common::String &filename, XFileLexer &lexer, XModel *model, Common::Array<MaterialReference> &materialReferences);
+	bool loadFromXData(const Common::String &filename, XModel *model, XFileData *xobj, Common::Array<MaterialReference> &materialReferences);
-	bool loadFromXAsRoot(const Common::String &filename, XFileLexer &lexer, XModel *model, Common::Array<MaterialReference> &materialReferences);
+	bool mergeFromXData(const Common::String &filename, XModel *model, XFileData *xobj);
 	bool findBones(FrameNode *rootFrame);
 	FrameNode *findFrame(const char *frameName);
 	Math::Matrix4 *getCombinedMatrix();

engines/wintermute/base/gfx/xloader.cpp

@@ -1,483 +0,0 @@
-/* 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/algorithm.h"
-#include "common/scummsys.h"
-#include "common/str.h"
-#include "common/textconsole.h"
-#include "common/util.h"
-
-#include "engines/wintermute/base/gfx/xloader.h"
-
-namespace Wintermute {
-
-void nextTokenText(Common::MemoryReadStream &buffer, int &lineCount, Token &tok) {
-	char current = buffer.readSByte();
-
-	while (true) {
-		if (Common::isSpace(current)) {
-			if (current == '\n') {
-				++lineCount;
-			}
-
-			current = buffer.readSByte();
-		} else if (current == '/' || current == '#') {
-			// single slashes do not seem to be used in .X files,
-			// so checking for one should be enough
-
-			while (current != '\n') {
-				current = buffer.readSByte();
-			}
-
-			current = buffer.readSByte();
-			++lineCount;
-		} else {
-			break;
-		}
-	}
-
-	if (Common::isAlpha(current) || current == '_') {
-		tok.pushChar(current);
-		current = buffer.readSByte();
-
-		while (Common::isAlnum(current) || current == '_' || current == '-') {
-			tok.pushChar(current);
-			current = buffer.readSByte();
-		}
-
-		buffer.seek(-1, SEEK_CUR);
-		tok._type = IDENTIFIER;
-		return;
-	} else if (Common::isDigit(current) || current == '-') {
-		tok.pushChar(current);
-		current = buffer.readSByte();
-
-		while (Common::isDigit(current)) {
-			tok.pushChar(current);
-			current = buffer.readSByte();
-		}
-
-		if (current == '.') {
-			tok.pushChar(current);
-			current = buffer.readSByte();
-
-			while (Common::isDigit(current)) {
-				tok.pushChar(current);
-				current = buffer.readSByte();
-			}
-
-			buffer.seek(-1, SEEK_CUR);
-			tok._type = FLOAT;
-			return;
-		}
-
-		buffer.seek(-1, SEEK_CUR);
-		tok._type = INT;
-		return;
-	} else if (current == '<') {
-		// a uuid consists of 36 characters, 32 alphanumeric characters
-		// and four "-". We add space for a null character at the
-		// end of the tempoary buffer
-		const int uuidSize = 37;
-		char uuid[uuidSize];
-		buffer.read(uuid, 36);
-		uuid[uuidSize - 1] = 0;
-
-		current = buffer.readSByte();
-
-		if (current != '>') {
-			warning("Wrong UUID format at line %i", lineCount);
-		} else {
-			tok._textVal = uuid;
-			tok._type = UUID;
-			return;
-		}
-	} else if (current == '"') {
-		current = buffer.readSByte();
-
-		while (current != '"') {
-			tok.pushChar(current);
-			current = buffer.readSByte();
-		}
-
-		tok._type = STRING;
-		return;
-	}
-
-	switch (current) {
-	case '(':
-		tok._type = OPEN_PAREN;
-		break;
-	case ')':
-		tok._type = CLOSE_PAREN;
-		break;
-	case '{':
-		tok._type = OPEN_BRACES;
-		break;
-	case '}':
-		tok._type = CLOSE_BRACES;
-		break;
-	case ']':
-		tok._type = OPEN_BRACKET;
-		break;
-	case '[':
-		tok._type = CLOSE_BRACKET;
-		break;
-	case ',':
-		tok._type = COMMA;
-		break;
-	case ';':
-		tok._type = SEMICOLON;
-		break;
-	case '.':
-		tok._type = DOT;
-		break;
-	case '\0':
-		tok._type = NULL_CHAR;
-		break;
-	default:
-		tok._type = UNKNOWN_TOKEN;
-		warning("Unknown token %c at line %i", current, lineCount);
-	}
-}
-
-// based on MSDN .X file format documentation
-const uint16 XBIN_TOKEN_NAME         = 1;
-const uint16 XBIN_TOKEN_STRING       = 2;
-const uint16 XBIN_TOKEN_INTEGER      = 3;
-const uint16 XBIN_TOKEN_GUID         = 5;
-const uint16 XBIN_TOKEN_INTEGER_LIST = 6;
-const uint16 XBIN_TOKEN_FLOAT_LIST   = 7;
-
-const uint16 XBIN_TOKEN_OBRACE    = 10;
-const uint16 XBIN_TOKEN_CBRACE    = 11;
-const uint16 XBIN_TOKEN_OPAREN    = 12;
-const uint16 XBIN_TOKEN_CPAREN    = 13;
-const uint16 XBIN_TOKEN_OBRACKET  = 14;
-const uint16 XBIN_TOKEN_CBRACKET  = 15;
-const uint16 XBIN_TOKEN_OANGLE    = 16;
-const uint16 XBIN_TOKEN_CANGLE    = 17;
-const uint16 XBIN_TOKEN_DOT       = 18;
-const uint16 XBIN_TOKEN_COMMA     = 19;
-const uint16 XBIN_TOKEN_SEMICOLON = 20;
-const uint16 XBIN_TOKEN_TEMPLATE  = 31;
-const uint16 XBIN_TOKEN_WORD      = 40;
-const uint16 XBIN_TOKEN_DWORD     = 41;
-const uint16 XBIN_TOKEN_FLOAT     = 42;
-const uint16 XBIN_TOKEN_DOUBLE    = 43;
-const uint16 XBIN_TOKEN_CHAR      = 44;
-const uint16 XBIN_TOKEN_UCHAR     = 45;
-const uint16 XBIN_TOKEN_SWORD     = 46;
-const uint16 XBIN_TOKEN_SDWORD    = 47;
-const uint16 XBIN_TOKEN_VOID      = 48;
-const uint16 XBIN_TOKEN_LPSTR     = 49;
-const uint16 XBIN_TOKEN_UNICODE   = 50;
-const uint16 XBIN_TOKEN_CSTRING   = 51;
-const uint16 XBIN_TOKEN_ARRAY     = 52;
-
-void XFileLexer::nextTokenBinary() {
-	uint16 current = _buffer.readUint16LE();
-	uint32 length = -1;
-
-	switch (current) {
-	case XBIN_TOKEN_NAME:
-		length = _buffer.readUint32LE();
-
-		for (uint32 i = 0; i < length; ++i) {
-			_tok.pushChar(_buffer.readByte());
-		}
-
-		_tok._type = IDENTIFIER;
-		break;
-	case XBIN_TOKEN_STRING:
-		length = _buffer.readUint32LE();
-
-		for (uint32 i = 0; i < length; ++i) {
-			_tok.pushChar(_buffer.readByte());
-		}
-
-		_tok._type = STRING;
-		break;
-	case XBIN_TOKEN_INTEGER:
-		_tok._integerVal = _buffer.readUint32LE();
-		_tok._type = INT;
-		break;
-	case XBIN_TOKEN_GUID:
-		// ignore the UUID value
-		_buffer.readUint32LE();
-		_buffer.readUint16LE();
-		_buffer.readUint16LE();
-
-		for (int i = 0; i < 8; ++i) {
-			_buffer.readByte();
-		}
-
-		_tok._type = UUID;
-		break;
-	case XBIN_TOKEN_INTEGER_LIST:
-		_integersToRead = _buffer.readUint32LE();
-		_tok._type = INT;
-		_expectsTerminator = false;
-		break;
-	case XBIN_TOKEN_FLOAT_LIST:
-		_floatsToRead = _buffer.readUint32LE();
-		_tok._type = FLOAT;
-		_expectsTerminator = false;
-		break;
-	case XBIN_TOKEN_OBRACE:
-		_tok._type = OPEN_BRACES;
-		break;
-	case XBIN_TOKEN_CBRACE:
-		_tok._type = CLOSE_BRACES;
-		break;
-	case XBIN_TOKEN_OPAREN:
-		_tok._type = OPEN_PAREN;
-		break;
-	case XBIN_TOKEN_CPAREN:
-		_tok._type = CLOSE_PAREN;
-		break;
-	case XBIN_TOKEN_OBRACKET:
-		_tok._type = OPEN_BRACKET;
-		break;
-	case XBIN_TOKEN_CBRACKET:
-		_tok._type = CLOSE_BRACKET;
-		break;
-	case XBIN_TOKEN_OANGLE:
-		_tok._type = OPEN_ANGLE;
-		break;
-	case XBIN_TOKEN_CANGLE:
-		_tok._type = CLOSE_ANGLE;
-		break;
-	case XBIN_TOKEN_DOT:
-		_tok._type = DOT;
-		break;
-	case XBIN_TOKEN_COMMA:
-		_tok._type = COMMA;
-		break;
-	case XBIN_TOKEN_SEMICOLON:
-		_tok._type = SEMICOLON;
-		break;
-	case XBIN_TOKEN_TEMPLATE:
-		_tok._textVal = "template";
-		_tok._type = IDENTIFIER;
-		break;
-	case XBIN_TOKEN_WORD:
-		break;
-	case XBIN_TOKEN_DWORD:
-		break;
-	case XBIN_TOKEN_FLOAT:
-		break;
-	case XBIN_TOKEN_DOUBLE:
-		break;
-	case XBIN_TOKEN_CHAR:
-		break;
-	case XBIN_TOKEN_UCHAR:
-		break;
-	case XBIN_TOKEN_SWORD:
-		break;
-	case XBIN_TOKEN_SDWORD:
-		break;
-	case XBIN_TOKEN_VOID:
-		break;
-	case XBIN_TOKEN_LPSTR:
-		break;
-	case XBIN_TOKEN_UNICODE:
-		break;
-	case XBIN_TOKEN_CSTRING:
-		break;
-	case XBIN_TOKEN_ARRAY:
-		break;
-	case 0:
-		_tok._type = NULL_CHAR;
-		break;
-	default:
-		_tok._type = UNKNOWN_TOKEN;
-		warning("XFileLexer::nextBinaryToken: Unknown token encountered");
-	}
-}
-
-XFileLexer::XFileLexer(byte *buffer, uint32 fileSize, bool isText)
-	: _buffer(buffer, fileSize), _lineCount(1), _isText(isText), _integersToRead(0), _floatsToRead(0), _expectsTerminator(true) {
-}
-
-void XFileLexer::advanceToNextToken() {
-	_tok._textVal.clear();
-
-	if (_isText) {
-		nextTokenText(_buffer, _lineCount, _tok);
-	} else {
-		nextTokenBinary();
-	}
-}
-
-void XFileLexer::skipTerminator() {
-	if (_expectsTerminator) {
-		advanceToNextToken();
-	}
-
-	_expectsTerminator = (_floatsToRead == 0) && (_integersToRead == 0);
-}
-
-bool XFileLexer::eof() {
-	return _buffer.pos() == _buffer.size();
-}
-
-bool XFileLexer::tokenIsIdentifier() {
-	return _tok._type == IDENTIFIER;
-}
-
-bool XFileLexer::tokenIsIdentifier(const char *val) {
-	return _tok._type == IDENTIFIER && _tok._textVal == val;
-}
-
-void XFileLexer::advanceOnOpenBraces() {
-	if (_tok._type == OPEN_BRACES) {
-		advanceToNextToken();
-	}
-}
-
-bool XFileLexer::reachedClosedBraces() {
-	return _tok._type == CLOSE_BRACES;
-}
-
-TokenType XFileLexer::getTypeOfToken() {
-	return _tok._type;
-}
-
-bool XFileLexer::tokenIsOfType(TokenType type) {
-	return _tok._type == type;
-}
-
-int XFileLexer::tokenToInt() {
-	return atoi(_tok._textVal.c_str());
-}
-
-double XFileLexer::tokenToFloat() {
-	return atof(_tok._textVal.c_str());
-}
-
-Common::String XFileLexer::tokenToString() {
-	return _tok._textVal;
-}
-
-uint32 XFileLexer::tokenToUint32() {
-	// All integer values in a .X file are unsigned and at most 32 bit
-	// so parsing to unsigned long and then converting down should be fine
-	return strtoul(_tok._textVal.c_str(), nullptr, 10);
-}
-
-void XFileLexer::skipObject() {
-	advanceToNextToken(); // optional name
-	advanceToNextToken();
-	advanceOnOpenBraces();
-
-	// we have one open braces right now, once the counter reaches zero, we're done
-	int closedBracesCount = 1;
-
-	while (closedBracesCount > 0) {
-		while (_integersToRead > 0 || _floatsToRead > 0) {
-			if (_integersToRead > 0) {
-				readInt();
-			}
-
-			if (_floatsToRead > 0) {
-				readFloat();
-			}
-		}
-
-		if (_tok._type == OPEN_BRACES) {
-			++closedBracesCount;
-		}
-
-		if (_tok._type == CLOSE_BRACES) {
-			--closedBracesCount;
-		}
-
-		advanceToNextToken();
-	}
-}
-
-void Token::pushChar(char c) {
-	_textVal.insertChar(c, _textVal.size());
-}
-
-float XFileLexer::readFloat() {
-	if (_floatsToRead > 0) {
-		--_floatsToRead;
-		float tmp = _buffer.readFloatLE();
-
-		if (_floatsToRead == 0) {
-			advanceToNextToken();
-		}
-
-		return tmp;
-	}
-
-	float tmp = tokenToFloat();
-	advanceToNextToken();
-	advanceToNextToken(); // skip comma or semicolon
-	return tmp;
-}
-
-int XFileLexer::readInt() {
-	if (_integersToRead > 0) {
-		--_integersToRead;
-		int tmp = _buffer.readUint32LE();
-
-		if (_integersToRead == 0) {
-			advanceToNextToken();
-		}
-
-		return tmp;
-	}
-
-	int tmp = tokenToInt();
-	advanceToNextToken();
-	advanceToNextToken(); // skip comma or semicolon
-	return tmp;
-}
-
-Common::String XFileLexer::readString() {
-	Common::String tmp = tokenToString();
-	advanceToNextToken();
-	advanceToNextToken(); // skip comma or semicolon
-	return tmp;
-}
-
-uint32 XFileLexer::readUint32() {
-	if (_integersToRead > 0) {
-		--_integersToRead;
-		uint32 tmp = _buffer.readUint32LE();
-
-		if (_integersToRead == 0) {
-			advanceToNextToken();
-		}
-
-		return tmp;
-	}
-
-	uint32 tmp = tokenToUint32();
-	advanceToNextToken();
-	advanceToNextToken(); // skip comma or semicolon
-	return tmp;
-}
-
-} // namespace Wintermute

engines/wintermute/base/gfx/xloader.h

@@ -1,100 +0,0 @@
-/* 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/>.
- *
- */
-
-#ifndef WINTERMUTE_X_FILE_LEXER_H
-#define WINTERMUTE_X_FILE_LEXER_H
-
-#include "common/memstream.h"
-#include "common/scummsys.h"
-#include "common/str.h"
-
-namespace Wintermute {
-
-enum TokenType {
-	IDENTIFIER = 0,
-	STRING,
-	UUID,
-	INT,
-	FLOAT,
-	OPEN_BRACES,
-	CLOSE_BRACES,
-	OPEN_PAREN,
-	CLOSE_PAREN,
-	OPEN_ANGLE,
-	CLOSE_ANGLE,
-	OPEN_BRACKET,
-	CLOSE_BRACKET,
-	SEMICOLON,
-	COMMA,
-	DOT,
-	NULL_CHAR,
-	UNKNOWN_TOKEN
-};
-
-struct Token {
-	TokenType _type;
-	Common::String _textVal;
-	int _integerVal;
-	float _floatVal;
-
-	void pushChar(char c);
-};
-
-class XFileLexer {
-public:
-	XFileLexer(byte *buffer, uint32 fileSize, bool isText);
-
-	void advanceToNextToken();
-	void skipTerminator();
-	bool eof();
-	bool tokenIsIdentifier();
-	bool tokenIsIdentifier(const char *val);
-	void advanceOnOpenBraces();
-	bool reachedClosedBraces();
-	TokenType getTypeOfToken();
-	bool tokenIsOfType(TokenType type);
-	int tokenToInt();
-	double tokenToFloat();
-	Common::String tokenToString();
-	uint32 tokenToUint32();
-
-	void skipObject();
-
-	float readFloat();
-	int readInt();
-	Common::String readString();
-	uint32 readUint32();
-
-private:
-	void nextTokenBinary();
-
-	Token _tok;
-	Common::MemoryReadStream _buffer;
-	int _lineCount;
-	bool _isText;
-	int _integersToRead;
-	int _floatsToRead;
-	bool _expectsTerminator;
-};
-
-} // namespace Wintermute
-
-#endif

engines/wintermute/base/gfx/xmaterial.cpp

@@ -30,7 +30,7 @@
 #include "engines/wintermute/base/base_surface_storage.h"
 #include "engines/wintermute/base/gfx/base_surface.h"
 #include "engines/wintermute/base/gfx/xmaterial.h"
-#include "engines/wintermute/base/gfx/xloader.h"
+#include "engines/wintermute/base/gfx/xfile_loader.h"
 #include "engines/wintermute/dcgf.h"
 #include "engines/wintermute/utils/path_util.h"
 #include "engines/wintermute/video/video_theora_player.h"
@@ -141,51 +141,44 @@ BaseSurface *Material::getSurface() {
 	}
 }
 
-bool Material::loadFromX(XFileLexer &lexer, const Common::String &filename) {
+bool Material::loadFromX(XFileData *xobj, const Common::String &filename) {
-	lexer.advanceToNextToken(); // skip optional name
+	XMaterialObject *material = xobj->getXMaterialObject();
-	lexer.advanceOnOpenBraces();
+	if (!material)
+		return false;
 
-	_diffuse.r() = lexer.readFloat();
+	_diffuse.r() = material->_colorR;
-	_diffuse.g() = lexer.readFloat();
+	_diffuse.g() = material->_colorG;
-	_diffuse.b() = lexer.readFloat();
+	_diffuse.b() = material->_colorB;
-	_diffuse.a() = lexer.readFloat();
+	_diffuse.a() = material->_colorA;
-	lexer.skipTerminator(); // skip semicolon
 
-	_shininess = lexer.readFloat();
+	_shininess = material->_power;
 
-	_specular.r() = lexer.readFloat();
+	_specular.r() = material->_specularR;
-	_specular.g() = lexer.readFloat();
+	_specular.g() = material->_specularG;
-	_specular.b() = lexer.readFloat();
+	_specular.b() = material->_specularB;
 	_specular.a() = 1.0f;
-	lexer.skipTerminator(); // skip semicolon
 
-	_emissive.r() = lexer.readFloat();
+	_emissive.r() = material->_emissiveR;
-	_emissive.g() = lexer.readFloat();
+	_emissive.g() = material->_emissiveG;
-	_emissive.b() = lexer.readFloat();
+	_emissive.b() = material->_emissiveB;
 	_emissive.a() = 1.0f;
-	lexer.skipTerminator();
 
-	while (!lexer.eof()) {
+	uint32 numChildren = 0;
-		// according to assimp sources, we got both possibilities
+	xobj->getChildren(numChildren);
-		// wine also seems to support this
-		// MSDN only names the first option
-		if (lexer.tokenIsIdentifier("TextureFilename") || lexer.tokenIsIdentifier("TextureFileName")) {
-			lexer.advanceToNextToken(); // skip optional name
-			lexer.advanceOnOpenBraces();
 
-			Common::String textureFilename = lexer.readString();
+	for (uint32 i = 0; i < numChildren; i++) {
-			PathUtil::getDirectoryName(filename);
+		XFileData xchildData;
-			setTexture(PathUtil::getDirectoryName(filename) + textureFilename);
+		XClassType objectType;
-			lexer.advanceToNextToken(); // skip semicolon
+		bool res = xobj->getChild(i, xchildData);
-		} else if (lexer.tokenIsIdentifier()) {
+		if (res) {
-			warning("Material::loadFromX unexpected token %i", lexer.getTypeOfToken());
+			res = xchildData.getType(objectType);
-			return false;
+			if (res && objectType == kXClassTextureFilename) {
-		} else {
+				Common::String textureFilename = xchildData.getXTextureFilenameObject()->_filename;
-			break;
+				setTexture(PathUtil::getDirectoryName(filename) + textureFilename);
+			}
 		}
 	}
 
-	lexer.advanceToNextToken(); // skip semicolon
 	return true;
 }
 

engines/wintermute/base/gfx/xmaterial.h

@@ -35,7 +35,7 @@ namespace Wintermute {
 class BaseSprite;
 class BaseSurface;
 class VideoTheoraPlayer;
-class XFileLexer;
+class XFileData;
 
 struct ColorValue {
 	float &r() {
@@ -89,7 +89,7 @@ public:
 	bool setTheora(VideoTheoraPlayer *theora, bool adoptName = false);
 	BaseSurface *getSurface();
 
-	bool loadFromX(XFileLexer &lexer, const Common::String &filename);
+	bool loadFromX(XFileData *xobj, const Common::String &filename);
 
 	bool invalidateDeviceObjects();
 	bool restoreDeviceObjects();

engines/wintermute/base/gfx/xmesh.cpp

@@ -29,8 +29,9 @@
 #include "engines/wintermute/base/gfx/xmaterial.h"
 #include "engines/wintermute/base/gfx/xmesh.h"
 #include "engines/wintermute/base/gfx/xframe_node.h"
-#include "engines/wintermute/base/gfx/xloader.h"
+#include "engines/wintermute/base/gfx/xfile_loader.h"
 #include "engines/wintermute/base/gfx/xmodel.h"
+#include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/math/math_util.h"
 
 namespace Wintermute {
@@ -60,10 +61,20 @@ XMesh::~XMesh() {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool XMesh::loadFromX(const Common::String &filename, XFileLexer &lexer, Common::Array<MaterialReference> &materialReferences) {
+bool XMesh::loadFromXData(const Common::String &filename, XFileData *xobj, Common::Array<MaterialReference> &materialReferences) {
-	lexer.advanceToNextToken(); // skip the name
+	// get name
-	lexer.advanceOnOpenBraces();
+	if (!XModel::loadName(this, xobj)) {
-	_vertexCount = lexer.readInt();
+		BaseEngine::LOG(0, "Error loading mesh name");
+		return false;
+	}
+
+	XMeshObject *mesh = xobj->getXMeshObject();
+	if (!mesh) {
+		BaseEngine::LOG(0, "Error loading skin mesh");
+		return false;
+	}
+
+	_vertexCount = mesh->_numVertices;
 
 	// vertex format for .X meshes will be position + normals + textures
 	_vertexData = new float[kVertexComponentCount * _vertexCount]();
@@ -72,76 +83,47 @@ bool XMesh::loadFromX(const Common::String &filename, XFileLexer &lexer, Common:
 	// TODO: might have to generate normals if file does not contain any
 	_vertexNormalData = new float[3 * _vertexCount]();
 
-	parsePositionCoords(lexer);
+	parsePositionCoords(mesh);
 
-	int faceCount = lexer.readInt();
+	int faceCount = mesh->_numFaces;
 
 	Common::Array<int> indexCountPerFace;
 
-	parseFaces(lexer, faceCount, indexCountPerFace);
+	parseFaces(mesh, faceCount, indexCountPerFace);
 
-	while (!lexer.eof()) {
+	uint32 numChildren = 0;
-		if (lexer.tokenIsIdentifier("MeshTextureCoords")) {
+	xobj->getChildren(numChildren);
-			lexer.advanceToNextToken();
-			lexer.advanceToNextToken();
-			lexer.advanceOnOpenBraces();
 
-			parseTextureCoords(lexer);
+	for (uint32 i = 0; i < numChildren; i++) {
-		} else if (lexer.tokenIsIdentifier("MeshNormals")) {
+		XFileData xchildData;
-			lexer.advanceToNextToken();
+		XClassType objectType;
-			lexer.advanceToNextToken();
+		if (xobj->getChild(i, xchildData)) {
-			lexer.advanceOnOpenBraces();
+			if (xchildData.getType(objectType)) {
+				if (objectType == kXClassMeshTextureCoords) {
+					parseTextureCoords(&xchildData);
+				} else if (objectType == kXClassMeshNormals) {
+					parseNormalCoords(&xchildData);
+				} else if (objectType == kXClassMeshMaterialList) {
+					parseMaterials(&xchildData, faceCount, filename, materialReferences, indexCountPerFace);
+				} else if (objectType == kXClassMaterial) {
+					Material *mat = new Material(_gameRef);
+					mat->loadFromX(&xchildData, filename);
+					_materials.add(mat);
 
-			parseNormalCoords(lexer);
+					// one material = one index range
-		} else if (lexer.tokenIsIdentifier("MeshMaterialList")) {
+					_numAttrs = 1;
-			lexer.advanceToNextToken();
+					_indexRanges.push_back(0);
-			lexer.advanceToNextToken();
+					_indexRanges.push_back(_indexData.size());
-			lexer.advanceOnOpenBraces();
+				} else if (objectType == kXClassSkinMeshHeader) {
-
+					int boneCount = xchildData.getXSkinMeshHeaderObject()->_nBones;
-			parseMaterials(lexer, faceCount, filename, materialReferences, indexCountPerFace);
+					_skinnedMesh = boneCount > 0;
-		} else if (lexer.tokenIsIdentifier("Material")) {
+				} else if (objectType == kXClassSkinWeights) {
-			lexer.advanceToNextToken();
+					_skinnedMesh = true;
-			Material *mat = new Material(_gameRef);
+					parseSkinWeights(&xchildData);
-			mat->loadFromX(lexer, filename);
+				} else if (objectType == kXClassDeclData) {
-			_materials.add(mat);
+					parseVertexDeclaration(&xchildData);
-
+				}
-			// one material = one index range
+			}
-			_numAttrs = 1;
-			_indexRanges.push_back(0);
-			_indexRanges.push_back(_indexData.size());
-		} else if (lexer.tokenIsIdentifier("XSkinMeshHeader")) {
-			lexer.advanceToNextToken();
-			lexer.advanceOnOpenBraces();
-
-			// if any of this is zero, we should have an unskinned mesh
-			lexer.readInt(); // max skin weights per vertex
-			lexer.readInt(); // max skin weights per face
-			int boneCount = lexer.readInt();
-
-			_skinnedMesh = boneCount > 0;
-
-			lexer.advanceToNextToken(); // skip semicolon
-		} else if (lexer.tokenIsIdentifier("SkinWeights")) {
-			// but now we certainly should have a skinned mesh
-			_skinnedMesh = true;
-			lexer.advanceToNextToken();
-			lexer.advanceOnOpenBraces();
-
-			parseSkinWeights(lexer);
-		} else if (lexer.tokenIsIdentifier("DeclData")) {
-			lexer.advanceToNextToken();
-			lexer.advanceToNextToken();
-			lexer.advanceOnOpenBraces();
-
-			parseVertexDeclaration(lexer);
-		} else if (lexer.tokenIsIdentifier()) {
-			lexer.skipObject();
-		} else if (lexer.reachedClosedBraces()) {
-			lexer.advanceToNextToken(); // skip closed braces
-			break;
-		} else {
-			warning("XMesh::loadFromX unknown token %i encountered", lexer.getTypeOfToken());
-			lexer.advanceToNextToken();
 		}
 	}
 
@@ -468,43 +450,41 @@ bool XMesh::restoreDeviceObjects() {
 	}
 }
 
-bool XMesh::parsePositionCoords(XFileLexer &lexer) {
+bool XMesh::parsePositionCoords(XMeshObject *mesh) {
 	for (uint i = 0; i < _vertexCount; ++i) {
+		_vertexPositionData[i * 3 + 0] = mesh->_vertices[i]._x;
+		_vertexPositionData[i * 3 + 1] = mesh->_vertices[i]._y;
+		_vertexPositionData[i * 3 + 2] = mesh->_vertices[i]._z;
 		for (int j = 0; j < 3; ++j) {
-			_vertexPositionData[i * 3 + j] = lexer.readFloat();
 			_vertexData[i * kVertexComponentCount + kPositionOffset + j] = _vertexPositionData[i * 3 + j];
 		}
 
 		_vertexPositionData[i * 3 + 2] *= -1.0f;
 		_vertexData[i * kVertexComponentCount + kPositionOffset + 2] *= -1.0f;
-
-		lexer.skipTerminator(); // skip semicolon
 	}
 
 	return true;
 }
 
-bool XMesh::parseFaces(XFileLexer &lexer, int faceCount, Common::Array<int>& indexCountPerFace) {
+bool XMesh::parseFaces(XMeshObject *mesh, int faceCount, Common::Array<int> &indexCountPerFace) {
 	for (int i = 0; i < faceCount; ++i) {
-		int indexCount = lexer.readInt();
+		XMeshFace *face = &mesh->_faces[i];
-
+		int indexCount = face->_numFaceVertexIndices;
 		if (indexCount == 3) {
-			uint16 index1 = lexer.readInt();
+			uint16 index1 = face->_faceVertexIndices[0];
-			uint16 index2 = lexer.readInt();
+			uint16 index2 = face->_faceVertexIndices[1];
-			uint16 index3 = lexer.readInt();
+			uint16 index3 = face->_faceVertexIndices[2];
 
 			_indexData.push_back(index3);
 			_indexData.push_back(index2);
 			_indexData.push_back(index1);
 
-			lexer.skipTerminator(); // skip semicolon
-
 			indexCountPerFace.push_back(3);
 		} else if (indexCount == 4) {
-			uint16 index1 = lexer.readInt();
+			uint16 index1 = face->_faceVertexIndices[0];
-			uint16 index2 = lexer.readInt();
+			uint16 index2 = face->_faceVertexIndices[1];
-			uint16 index3 = lexer.readInt();
+			uint16 index3 = face->_faceVertexIndices[2];
-			uint16 index4 = lexer.readInt();
+			uint16 index4 = face->_faceVertexIndices[3];
 
 			_indexData.push_back(index3);
 			_indexData.push_back(index2);
@@ -514,8 +494,6 @@ bool XMesh::parseFaces(XFileLexer &lexer, int faceCount, Common::Array<int>& ind
 			_indexData.push_back(index3);
 			_indexData.push_back(index1);
 
-			lexer.skipTerminator(); // skip semicolon
-
 			indexCountPerFace.push_back(6);
 		} else {
 			warning("XMeshOpenGL::loadFromX faces with more than four vertices are not supported");
@@ -526,62 +504,59 @@ bool XMesh::parseFaces(XFileLexer &lexer, int faceCount, Common::Array<int>& ind
 	return true;
 }
 
-bool XMesh::parseTextureCoords(XFileLexer &lexer) {
+bool XMesh::parseTextureCoords(XFileData *xobj) {
+	XMeshTextureCoordsObject *texCoords = xobj->getXMeshTextureCoordsObject();
+	if (!texCoords)
+		return false;
 	// should be the same as _vertexCount
-	int textureCoordCount = lexer.readInt();
+	int textureCoordCount = texCoords->_numTextureCoords;
 
 	for (int i = 0; i < textureCoordCount; ++i) {
-		_vertexData[i * kVertexComponentCount + kTextureCoordOffset + 0] = lexer.readFloat();
+		_vertexData[i * kVertexComponentCount + kTextureCoordOffset + 0] = texCoords->_textureCoords[i]._u;
-		_vertexData[i * kVertexComponentCount + kTextureCoordOffset + 1] = lexer.readFloat();
+		_vertexData[i * kVertexComponentCount + kTextureCoordOffset + 1] = texCoords->_textureCoords[i]._v;
-		lexer.skipTerminator(); // skip semicolon
-	}
-
-	if (lexer.reachedClosedBraces()) {
-		lexer.advanceToNextToken();
-	} else {
-		warning("Missing } in mesh object");
 	}
 
 	return true;
 }
 
-bool XMesh::parseNormalCoords(XFileLexer &lexer) {
+bool XMesh::parseNormalCoords(XFileData *xobj) {
+	XMeshNormalsObject *normals = xobj->getXMeshNormalsObject();
+	if (!normals)
+		return false;
 	// should be the same as _vertex count
-	uint vertexNormalCount = lexer.readInt();
+	uint vertexNormalCount = normals->_numNormals;
-//	assert(vertexNormalCount == _vertexCount);
+	//assert(vertexNormalCount == _vertexCount);
 
 	Common::Array<float> vertexNormalData;
 	vertexNormalData.resize(3 * vertexNormalCount);
 
 	for (uint i = 0; i < vertexNormalCount; ++i) {
-		vertexNormalData[i * 3 + 0] = lexer.readFloat();
+		vertexNormalData[i * 3 + 0] = normals->_normals[i]._x;
-		vertexNormalData[i * 3 + 1] = lexer.readFloat();
+		vertexNormalData[i * 3 + 1] = normals->_normals[i]._y;
 		// mirror z coordinate to change to OpenGL coordinate system
-		vertexNormalData[i * 3 + 2] = -lexer.readFloat();
+		vertexNormalData[i * 3 + 2] = -normals->_normals[i]._z;
-		lexer.skipTerminator(); // skip semicolon
 	}
 
-	uint faceNormalCount = lexer.readInt();
+	uint faceNormalCount = normals->_numFaceNormals;
 	Common::Array<int> faceNormals;
 
 	for (uint i = 0; i < faceNormalCount; ++i) {
-		int indexCount = lexer.readInt();
+		XMeshFace *normalFace = &normals->_faceNormals[i];
+		int indexCount = normalFace->_numFaceVertexIndices;
 
 		if (indexCount == 3) {
-			uint16 index1 = lexer.readInt();
+			uint16 index1 = normalFace->_faceVertexIndices[0];
-			uint16 index2 = lexer.readInt();
+			uint16 index2 = normalFace->_faceVertexIndices[1];
-			uint16 index3 = lexer.readInt();
+			uint16 index3 = normalFace->_faceVertexIndices[2];
 
 			faceNormals.push_back(index3);
 			faceNormals.push_back(index2);
 			faceNormals.push_back(index1);
-
-			lexer.skipTerminator(); // skip semicolon
 		} else if (indexCount == 4) {
-			uint16 index1 = lexer.readInt();
+			uint16 index1 = normalFace->_faceVertexIndices[0];
-			uint16 index2 = lexer.readInt();
+			uint16 index2 = normalFace->_faceVertexIndices[1];
-			uint16 index3 = lexer.readInt();
+			uint16 index3 = normalFace->_faceVertexIndices[2];
-			uint16 index4 = lexer.readInt();
+			uint16 index4 = normalFace->_faceVertexIndices[3];
 
 			faceNormals.push_back(index3);
 			faceNormals.push_back(index2);
@@ -590,8 +565,6 @@ bool XMesh::parseNormalCoords(XFileLexer &lexer) {
 			faceNormals.push_back(index4);
 			faceNormals.push_back(index3);
 			faceNormals.push_back(index1);
-
-			lexer.skipTerminator(); // skip semicolon
 		} else {
 			warning("XMeshOpenGL::loadFromX faces with more than four vertices are not supported");
 			return false;
@@ -610,27 +583,28 @@ bool XMesh::parseNormalCoords(XFileLexer &lexer) {
 		}
 	}
 
-	lexer.advanceToNextToken(); // skip closed braces
-
 	return true;
 }
 
-bool XMesh::parseMaterials(XFileLexer &lexer, int faceCount, const Common::String &filename, Common::Array<MaterialReference> &materialReferences, const Common::Array<int> &indexCountPerFace) {
+bool XMesh::parseMaterials(XFileData *xobj, int faceCount, const Common::String &filename, Common::Array<MaterialReference> &materialReferences, const Common::Array<int> &indexCountPerFace) {
+	XMeshMaterialListObject *materialList = xobj->getXMeshMaterialListObject();
+	if (!materialList)
+		return false;
+
 	// there can be unused materials inside a .X file
 	// so this piece of information is probably useless
-	lexer.readInt(); // material count
 	// should be the same as faceCount
-	int faceMaterialCount = lexer.readInt();
+	int faceMaterialCount = materialList->_numFaceIndexes;
 	assert(faceMaterialCount == faceCount);
 
 	_indexRanges.push_back(0);
-	int currentMaterialIndex = lexer.readInt();
+	int currentMaterialIndex = materialList->_faceIndexes[0];
 	_materialIndices.push_back(currentMaterialIndex);
 
 	int currentIndex = indexCountPerFace[0];
 
 	for (int i = 1; i < faceMaterialCount; ++i) {
-		int currentMaterialIndexTmp = lexer.readInt();
+		int currentMaterialIndexTmp = materialList->_faceIndexes[i];
 
 		if (currentMaterialIndex != currentMaterialIndexTmp) {
 			currentMaterialIndex = currentMaterialIndexTmp;
@@ -644,82 +618,65 @@ bool XMesh::parseMaterials(XFileLexer &lexer, int faceCount, const Common::Strin
 	_indexRanges.push_back(currentIndex);
 	_numAttrs = _indexRanges.size() - 1;
 
-	// Strange Change has an extra semicolon here
+	uint32 numChildren = 0;
-	if (lexer.tokenIsOfType(SEMICOLON)) {
+	xobj->getChildren(numChildren);
-		lexer.advanceToNextToken();
-	}
 
-	while (!lexer.eof()) {
+	for (uint32 i = 0; i < numChildren; i++) {
-		if (lexer.tokenIsIdentifier("Material")) {
+		XFileData xchildData;
-			lexer.advanceToNextToken();
+		XClassType objectType;
-			Material *mat = new Material(_gameRef);
+		bool res = xobj->getChild(i, xchildData);
-			mat->loadFromX(lexer, filename);
+		if (res) {
-			_materials.add(mat);
+			res = xchildData.getType(objectType);
-
+			if (res) {
-			MaterialReference materialReference;
+				if (xchildData.isReference()) {
-			materialReference._material = mat;
+					Common::String materialReference;
-			materialReferences.push_back(materialReference);
+					xchildData.getName(materialReference);
-		} else if (lexer.tokenIsIdentifier()) {
+					for (uint32 j = 0; j < materialReferences.size(); j++) {
-			while (!lexer.reachedClosedBraces()) {
+						if (materialReferences[j]._name == materialReference) {
-				lexer.advanceToNextToken();
+							_materials.add(materialReferences[j]._material);
-			}
+							break;
-
+						}
-			lexer.advanceToNextToken(); // skip closed braces
+					}
-		} else if (lexer.reachedClosedBraces()) {
+				} else if (objectType == kXClassMaterial) {
-			break;
+					Material *mat = new Material(_gameRef);
-		} else if (lexer.tokenIsOfType(OPEN_BRACES)) {
+					mat->loadFromX(&xchildData, filename);
-			lexer.advanceToNextToken();
+					_materials.add(mat);
-			Common::String materialReference = lexer.tokenToString();
+					MaterialReference materialReference;
-
+					materialReference._material = mat;
-			for (uint i = 0; i < materialReferences.size(); ++i) {
+					materialReferences.push_back(materialReference);
-				if (materialReferences[i]._name == materialReference) {
-					_materials.add(materialReferences[i]._material);
-					break;
 				}
 			}
-
-			lexer.advanceToNextToken();
-			lexer.advanceToNextToken();
-		} else {
-			warning("XMeshOpenGL::loadFromX unknown token %i encountered while loading materials", lexer.getTypeOfToken());
-			break;
 		}
 	}
 
-	lexer.advanceToNextToken(); // skip closed braces
-
 	return true;
 }
 
-bool XMesh::parseSkinWeights(XFileLexer &lexer) {
+bool XMesh::parseSkinWeights(XFileData *xobj) {
+	XSkinWeightsObject *skinWeights = xobj->getXSkinWeightsObject();
+	if (!skinWeights)
+		return false;
+
 	skinWeightsList.resize(skinWeightsList.size() + 1);
 	SkinWeights &currSkinWeights = skinWeightsList.back();
 
-	currSkinWeights._boneName = lexer.readString();
+	currSkinWeights._boneName = skinWeights->_transformNodeName;
 
-	int weightCount = lexer.readInt();
+	int weightCount = skinWeights->_numWeights;
 	currSkinWeights._vertexIndices.resize(weightCount);
 	currSkinWeights._vertexWeights.resize(weightCount);
 
 	for (int i = 0; i < weightCount; ++i) {
-		currSkinWeights._vertexIndices[i] = lexer.readInt();
+		currSkinWeights._vertexIndices[i] = skinWeights->_vertexIndices[i];
-	}
-
-	if (weightCount == 0 && lexer.tokenIsOfType(SEMICOLON)) {
-		lexer.advanceToNextToken();
 	}
 
 	for (int i = 0; i < weightCount; ++i) {
-		currSkinWeights._vertexWeights[i] = lexer.readFloat();
+		currSkinWeights._vertexWeights[i] = skinWeights->_weights[i];
-	}
-
-	if (weightCount == 0 && lexer.tokenIsOfType(SEMICOLON)) {
-		lexer.advanceToNextToken();
 	}
 
 	for (int r = 0; r < 4; ++r) {
 		for (int c = 0; c < 4; ++c) {
-			currSkinWeights._offsetMatrix(c, r) = lexer.readFloat();
+			currSkinWeights._offsetMatrix(c, r) = skinWeights->_matrixOffset[r * 4 + c];
 		}
 	}
 
@@ -734,14 +691,15 @@ bool XMesh::parseSkinWeights(XFileLexer &lexer) {
 	currSkinWeights._offsetMatrix(0, 2) *= -1.0f;
 	currSkinWeights._offsetMatrix(1, 2) *= -1.0f;
 
-	lexer.skipTerminator(); // semicolon of matrix
-	lexer.advanceToNextToken(); // closed braces of skin weights object
-
 	return true;
 }
 
-bool XMesh::parseVertexDeclaration(XFileLexer &lexer) {
+bool XMesh::parseVertexDeclaration(XFileData *xobj) {
-	int vertexElementCount = lexer.readInt();
+	XDeclDataObject *declData = xobj->getXDeclDataObject();
+	if (!declData)
+		return false;
+
+	int vertexElementCount = declData->_numElements;
 
 	// size of a vertex measured in four byte blocks
 	int vertexSize = 0;
@@ -749,11 +707,10 @@ bool XMesh::parseVertexDeclaration(XFileLexer &lexer) {
 	int textureOffset = -1;
 
 	for (int i = 0; i < vertexElementCount; ++i) {
-		int type = lexer.readInt();
+		int type = declData->_elements[i]._type;
-		int method = lexer.readInt();
+		int method = declData->_elements[i]._method;
-		int usage = lexer.readInt();
+		int usage = declData->_elements[i]._usage;
-		int usageIndex = lexer.readInt();
+		int usageIndex = declData->_elements[i]._usageIndex;
-		lexer.skipTerminator();
 
 		debug("Vertex Element: Type: %i, Method: %i, Usage: %i, Usage index: %i", type, method, usage, usageIndex);
 
@@ -842,24 +799,14 @@ bool XMesh::parseVertexDeclaration(XFileLexer &lexer) {
 		}
 	}
 
-	if (lexer.tokenIsOfType(SEMICOLON)) {
+	int dataSize = declData->_numData;
-		lexer.advanceToNextToken();
-	}
-
-	int dataSize = lexer.readInt();
 	Common::Array<uint32> data;
 	data.reserve(dataSize);
 
 	for (int i = 0; i < dataSize; ++i) {
-		data.push_back(lexer.readUint32());
+		data.push_back(declData->_data[i]);
 	}
 
-	if (lexer.tokenIsOfType(SEMICOLON)) {
-		lexer.advanceToNextToken();
-	}
-
-	lexer.advanceToNextToken(); // skip closed braces
-
 	assert(dataSize % vertexSize == 0);
 	assert(dataSize / vertexSize == static_cast<int>(_vertexCount));
 

engines/wintermute/base/gfx/xmesh.h

@@ -43,7 +43,7 @@ class Material;
 class XModel;
 class ShadowVolume;
 class VideoTheoraPlayer;
-class XFileLexer;
+struct XMeshObject;
 
 struct SkinWeights {
 	Common::String _boneName;
@@ -57,7 +57,7 @@ public:
 	XMesh(BaseGame *inGame);
 	virtual ~XMesh();
 
-	virtual bool loadFromX(const Common::String &filename, XFileLexer &lexer, Common::Array<MaterialReference> &materialReferences);
+	virtual bool loadFromXData(const Common::String &filename, XFileData *xobj, Common::Array<MaterialReference> &materialReferences);
 	bool findBones(FrameNode *rootFrame);
 	virtual bool update(FrameNode *parentFrame);
 	virtual bool render(XModel *model) = 0;
@@ -84,13 +84,13 @@ protected:
 	// anything which does not fit into 16 bits would we fine
 	static const uint32 kNullIndex = 0xFFFFFFFF;
 
-	bool parsePositionCoords(XFileLexer &lexer);
+	bool parsePositionCoords(XMeshObject *mesh);
-	bool parseFaces(XFileLexer &lexer, int faceCount, Common::Array<int> &indexCountPerFace);
+	bool parseFaces(XMeshObject *mesh, int faceCount, Common::Array<int> &indexCountPerFace);
-	bool parseTextureCoords(XFileLexer &lexer);
+	bool parseTextureCoords(XFileData *xobj);
-	bool parseNormalCoords(XFileLexer &lexer);
+	bool parseNormalCoords(XFileData *xobj);
-	bool parseMaterials(XFileLexer &lexer, int faceCount, const Common::String &filename, Common::Array<MaterialReference> &materialReferences, const Common::Array<int> &indexCountPerFace);
+	bool parseMaterials(XFileData *xobj, int faceCount, const Common::String &filename, Common::Array<MaterialReference> &materialReferences, const Common::Array<int> &indexCountPerFace);
-	bool parseSkinWeights(XFileLexer &lexer);
+	bool parseSkinWeights(XFileData *xobj);
-	bool parseVertexDeclaration(XFileLexer &lexer);
+	bool parseVertexDeclaration(XFileData *xobj);
 
 	void updateBoundingBox();
 

engines/wintermute/base/gfx/xmodel.cpp

@@ -29,6 +29,7 @@
 
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/base/base_game.h"
+#include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/base/base_parser.h"
 #include "engines/wintermute/base/gfx/base_renderer.h"
 #include "engines/wintermute/base/gfx/opengl/base_render_opengl3d.h"
@@ -38,7 +39,8 @@
 #include "engines/wintermute/base/gfx/xframe_node.h"
 #include "engines/wintermute/base/gfx/xmaterial.h"
 #include "engines/wintermute/base/gfx/xmodel.h"
-#include "engines/wintermute/base/gfx/xloader.h"
+#include "engines/wintermute/base/gfx/xfile.h"
+#include "engines/wintermute/base/gfx/xfile_loader.h"
 #include "engines/wintermute/dcgf.h"
 #include "engines/wintermute/utils/path_util.h"
 #include "engines/wintermute/utils/utils.h"
@@ -46,106 +48,6 @@
 
 namespace Wintermute {
 
-static const int kCabBlockSize = 0x8000;
-static const int kCabInputmax = kCabBlockSize + 12;
-
-static byte *DecompressMsZipData(byte *buffer, uint32 inputSize, uint32 &decompressedSize) {
-#ifdef USE_ZLIB
-	bool error = false;
-
-	Common::MemoryReadStream data(buffer, inputSize);
-	byte *compressedBlock = new byte[kCabInputmax];
-	byte *decompressedBlock = new byte[kCabBlockSize];
-
-	// Read decompressed size of compressed data and minus 16 bytes of xof header
-	decompressedSize = data.readUint32LE() - 16;
-
-	uint32 remainingData = inputSize;
-	uint32 decompressedPos = 0;
-	byte *decompressedData = new byte[decompressedSize];
-	if (!decompressedData)
-		error = true;
-
-	while (!error && remainingData) {
-		uint16 uncompressedLen = data.readUint16LE();
-		uint16 compressedLen = data.readUint16LE();
-		remainingData -= 4;
-
-		if (data.err()) {
-			error = true;
-			break;
-		}
-
-		if (remainingData == 0) {
-			break;
-		}
-
-		if (compressedLen > kCabInputmax || uncompressedLen > kCabBlockSize) {
-			error = true;
-			break;
-		}
-
-		// Read the compressed block
-		if (data.read(compressedBlock, compressedLen) != compressedLen) {
-			error = true;
-			break;
-		}
-		remainingData -= compressedLen;
-
-		// Check the CK header
-		if (compressedBlock[0] != 'C' || compressedBlock[1] != 'K') {
-			error = true;
-			break;
-		}
-
-		// Decompress the block. If it isn't the first, provide the previous block as dictonary
-		byte *dict = decompressedPos ? decompressedBlock : nullptr;
-		bool decRes = Common::inflateZlibHeaderless(decompressedBlock, uncompressedLen, compressedBlock + 2, compressedLen - 2, dict, kCabBlockSize);
-		if (!decRes) {
-			error = true;
-			break;
-		}
-
-		// Copy the decompressed data
-		memcpy(decompressedData + decompressedPos, decompressedBlock, uncompressedLen);
-		decompressedPos += uncompressedLen;
-	}
-	if (decompressedSize != decompressedPos)
-		error = true;
-
-	delete[] compressedBlock;
-	delete[] decompressedBlock;
-
-	if (!error)
-		return decompressedData;
-#endif
-	warning("DecompressMsZipData: Error decompressing data!");
-	decompressedSize = 0;
-	return nullptr;
-}
-
-static XFileLexer createXFileLexer(byte *&buffer, uint32 fileSize) {
-	// xof header of an .X file consists of 16 bytes
-	// bytes 9 to 12 contain a string which can be 'txt ', 'bin ', 'bzip, 'tzip', depending on the format
-	byte dataFormatBlock[5];
-	Common::copy(buffer + 8, buffer + 12, dataFormatBlock);
-	dataFormatBlock[4] = '\0';
-
-	bool textMode = (strcmp((char *)dataFormatBlock, "txt ") == 0 || strcmp((char *)dataFormatBlock, "tzip") == 0);
-
-	if (strcmp((char *)dataFormatBlock, "bzip") == 0 || strcmp((char *)dataFormatBlock, "tzip") == 0) {
-		uint32 decompressedSize;
-		// we skip the 16 bytes xof header of the file
-		byte *buf = DecompressMsZipData(buffer + 16, fileSize - 16, decompressedSize);
-		delete[] buffer;
-		buffer = buf;
-		return XFileLexer(buffer, decompressedSize, textMode);
-	} else {
-		// we skip the 16 bytes xof header of the file
-		return XFileLexer(buffer + 16, fileSize - 16, textMode);
-	}
-}
-
 IMPLEMENT_PERSISTENT(XModel, false)
 
 //////////////////////////////////////////////////////////////////////////
@@ -221,98 +123,197 @@ void XModel::cleanup(bool complete) {
 bool XModel::loadFromFile(const Common::String &filename, XModel *parentModel) {
 	cleanup(false);
 
+	XFile *xfile = new XFile(_gameRef);
+	if (!xfile)
+		return false;
+
+	XFileData xobj;
+	bool resLoop = false;
+
 	_parentModel = parentModel;
 
-	uint32 fileSize = 0;
+	bool res = xfile->openFile(filename);
-	byte *buffer = BaseFileManager::getEngineInstance()->getEngineInstance()->readWholeFile(filename, &fileSize);
+	if (!res) {
-	XFileLexer lexer = createXFileLexer(buffer, fileSize);
+		delete xfile;
+		//return false;
+		error("XModel: Error loading X file: %s", filename.c_str());
+	}
 
 	_rootFrame = new FrameNode(_gameRef);
 
-	bool res = _rootFrame->loadFromXAsRoot(filename, lexer, this, _materialReferences);
+	uint32 numChildren = 0;
-	if (res) {
+	xfile->getEnum().getChildren(numChildren);
-		findBones(false, parentModel);
+	for (uint i = 0; i < numChildren; i++) {
+		resLoop = xfile->getEnum().getChild(i, xobj);
+		if (!resLoop)
+			break;
+
+		bool res = _rootFrame->loadFromXData(filename, this, &xobj, _materialReferences);
+		if (!res) {
+			BaseEngine::LOG(0, "Error loading top level object from '%s'", filename.c_str());
+			break;
+		}
 	}
 
+	if (!_rootFrame->hasChildren()) {
+		BaseEngine::LOG(0, "Error getting any top level objects in '%s'", filename.c_str());
+		res = false;
+	}
+
+	if (res) {
+		res = findBones(false, parentModel);
+	}
+
+	// setup animation channels
 	for (int i = 0; i < X_NUM_ANIMATION_CHANNELS; ++i) {
 		_channels[i] = new AnimationChannel(_gameRef, this);
 	}
 
 	setFilename(filename.c_str());
 
-	delete[] buffer;
+	delete xfile;
 
 	return res;
 }
 
+//////////////////////////////////////////////////////////////////////////
 bool XModel::mergeFromFile(const Common::String &filename) {
 	if (!_rootFrame) {
+		BaseEngine::LOG(0, "Error: XModel::mergeFromFile called on an empty model");
 		return false;
 	}
 
-	uint32 fileSize = 0;
+	XFile *xfile = new XFile(_gameRef);
-	byte *buffer = BaseFileManager::getEngineInstance()->getEngineInstance()->readWholeFile(filename, &fileSize);
+	if (!xfile)
-	XFileLexer lexer = createXFileLexer(buffer, fileSize);
+		return false;
 
-	lexer.advanceToNextToken();
+	bool res = xfile->openFile(filename);
-	parseFrameDuringMerge(lexer, filename);
+	if (!res) {
+		delete xfile;
+		return false;
+	}
 
-	findBones(false, nullptr);
+	XFileData xobj;
+	bool resLoop = false;
+
+	uint32 numChildren = 0;
+	xfile->getEnum().getChildren(numChildren);
+	for (uint i = 0; i < numChildren; i++) {
+		resLoop = xfile->getEnum().getChild(i, xobj);
+		if (!resLoop)
+			break;
+
+		res = _rootFrame->mergeFromXData(filename, this, &xobj);
+		if (!res) {
+			BaseEngine::LOG(0, "Error loading top level object from '%s'", filename.c_str());
+			break;
+		}
+	}
+
+	if (res) {
+		res = findBones(true);
+	}
 
 	bool found = false;
-
 	for (uint i = 0; i < _mergedModels.size(); ++i) {
 		if (scumm_stricmp(_mergedModels[i], filename.c_str()) == 0) {
 			found = true;
 			break;
 		}
 	}
-
 	if (!found) {
 		char *path = new char[filename.size() + 1];
 		strcpy(path, filename.c_str());
 		_mergedModels.add(path);
 	}
 
-	delete[] buffer;
+	delete xfile;
 
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool XModel::loadAnimationSet(XFileLexer &lexer, const Common::String &filename) {
+bool XModel::loadAnimationSet(const Common::String &filename, XFileData *xobj) {
 	bool res = true;
 
 	AnimationSet *animSet = new AnimationSet(_gameRef, this);
-
+	res = loadName(animSet, xobj);
-	if (animSet->loadFromX(lexer, filename)) {
+	if (!res) {
-		_animationSets.add(animSet);
-	} else {
 		delete animSet;
-		res = false;
+		return res;
 	}
 
-	return res;
+	// use the filename for unnamed animation sets
+	if (animSet->_name[0] == '\0') {
+		animSet->setName(PathUtil::getFileName(filename).c_str());
+	}
+
+	XFileData xchildData;
+	XClassType objectType;
+
+	uint32 numChildren = 0;
+	xobj->getChildren(numChildren);
+
+	for (uint32 i = 0; i < numChildren; i++) {
+		_gameRef->miniUpdate();
+
+		res = xobj->getChild(i, xchildData);
+		if (res) {
+			res = xchildData.getType(objectType);
+			if (!res) {
+				delete animSet;
+				BaseEngine::LOG(0, "Error getting object type while loading animation set");
+				return res;
+			}
+
+			if (objectType == kXClassAnimation) {
+				res = loadAnimation(filename, &xchildData, animSet);
+				if (!res) {
+					delete animSet;
+					return res;
+				}
+			}
+		}
+	}
+
+	_animationSets.add(animSet);
+
+	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool XModel::loadAnimation(const Common::String &filename, AnimationSet *parentAnimSet) {
+bool XModel::loadAnimation(const Common::String &filename, XFileData *xobj, AnimationSet *parentAnimSet) {
-	// not sure if we need this here (not completely implemented anyways and also not called)
-	// are there animation objects in .X outside of an animation set?
-
 	// if no parent anim set is specified, create one
 	bool newAnimSet = false;
 	if (parentAnimSet == nullptr) {
 		parentAnimSet = new AnimationSet(_gameRef, this);
 
 		parentAnimSet->setName(PathUtil::getFileName(filename).c_str());
+
 		newAnimSet = true;
 	}
 
 	// create the new object
-	Animation *Anim = new Animation(_gameRef);
+	Animation *anim = new Animation(_gameRef);
 
-	parentAnimSet->addAnimation(Anim);
+	uint32 numChildren = 0;
+	xobj->getChildren(numChildren);
+
+	for (uint32 i = 0; i < numChildren; i++) {
+		XFileData xchildData;
+		bool res = xobj->getChild(i, xchildData);
+		if (res) {
+			res = anim->load(&xchildData, parentAnimSet);
+			if (!res) {
+				delete anim;
+				if (newAnimSet) {
+					delete parentAnimSet;
+				}
+				return res;
+			}
+		}
+	}
+	parentAnimSet->addAnimation(anim);
 
 	if (newAnimSet) {
 		_animationSets.add(parentAnimSet);
@@ -340,22 +341,23 @@ bool XModel::findBones(bool animOnly, XModel *parentModel) {
 	return true;
 }
 
-void XModel::parseFrameDuringMerge(XFileLexer &lexer, const Common::String &filename) {
+//////////////////////////////////////////////////////////////////////////
-	while (!lexer.eof()) {
+bool XModel::loadName(BaseNamedObject *obj, XFileData *data) {
-		if (lexer.tokenIsIdentifier("Frame")) {
+	Common::String name;
-			lexer.advanceToNextToken();
+	if (data->getName(name)) {
-			parseFrameDuringMerge(lexer, filename);
+		obj->_name = new char[name.size() + 1];
-		} else if (lexer.tokenIsIdentifier("AnimationSet")) {
+		Common::strlcpy(obj->_name, name.c_str(), name.size() + 1);
-			lexer.advanceToNextToken();
+		return true;
-			loadAnimationSet(lexer, filename);
+	} else {
-		} else if (lexer.tokenIsOfType(IDENTIFIER)) {
+		return false;
-			lexer.skipObject();
-		} else {
-			lexer.advanceToNextToken(); // we ignore anything else here
-		}
 	}
 }
 
+//////////////////////////////////////////////////////////////////////////
+bool XModel::loadName(Common::String &targetStr, XFileData *data) {
+	return data->getName(targetStr);
+}
+
 //////////////////////////////////////////////////////////////////////////
 bool XModel::update() {
 	// reset all bones to default position

engines/wintermute/base/gfx/xmodel.h

@@ -46,7 +46,7 @@ class AnimationSet;
 class FrameNode;
 class Material;
 class ShadowVolume;
-class XFileLexer;
+class XFileData;
 
 struct MaterialReference {
 	Common::String _name;
@@ -152,8 +152,11 @@ public:
 
 	bool isTransparentAt(int x, int y);
 
-	bool loadAnimationSet(XFileLexer &lexer, const Common::String &filename);
+	static bool loadName(BaseNamedObject *obj, XFileData *data);
-	bool loadAnimation(const Common::String &filename, AnimationSet *parentAnimSet);
+	static bool loadName(Common::String &targetStr, XFileData *data);
+
+	bool loadAnimationSet(const Common::String &filename, XFileData *xobj);
+	bool loadAnimation(const Common::String &filename, XFileData *xobj, AnimationSet *parentAnimSet = nullptr);
 
 	Math::Matrix4 _lastWorldMat;
 	Rect32 _boundingRect;
@@ -186,8 +189,6 @@ private:
 	void cleanup(bool complete = true);
 	bool findBones(bool animOnly = false, XModel *parentModel = nullptr);
 
-	void parseFrameDuringMerge(XFileLexer &lexer, const Common::String &filename);
-
 	void updateBoundingRect();
 	void static inline updateRect(Rect32 *rc, int32 x, int32 y);
 	Rect32 _drawingViewport;

engines/wintermute/module.mk

@@ -168,11 +168,12 @@ MODULE_OBJS += \
 	base/gfx/xanimation.o \
 	base/gfx/xanimation_channel.o \
 	base/gfx/xanimation_set.o \
+	base/gfx/xfile.o \
+	base/gfx/xfile_loader.o \
 	base/gfx/xframe_node.o \
 	base/gfx/xmaterial.o \
 	base/gfx/xmesh.o \
 	base/gfx/xmodel.o \
-	base/gfx/xloader.o \
 	base/gfx/opengl/base_surface_opengl3d.o \
 	base/gfx/opengl/base_render_opengl3d.o \
 	base/gfx/opengl/base_render_opengl3d_shader.o \