[Scummvm-git-logs] scummvm master -> b8a3614b2be94dfb35c8696f982cad325547a978

aquadran noreply at scummvm.org
Fri Sep 5 14:17:54 UTC 2025


This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://api.github.com/repos/scummvm/scummvm .

Summary:
b8a3614b2b WINTERMUTE: Synced with original code


Commit: b8a3614b2be94dfb35c8696f982cad325547a978
    https://github.com/scummvm/scummvm/commit/b8a3614b2be94dfb35c8696f982cad325547a978
Author: Paweł Kołodziejski (aquadran at gmail.com)
Date: 2025-09-05T16:17:50+02:00

Commit Message:
WINTERMUTE: Synced with original code

Changed paths:
    engines/wintermute/ad/ad_actor.cpp
    engines/wintermute/ad/ad_actor.h
    engines/wintermute/ad/ad_actor_3dx.cpp
    engines/wintermute/ad/ad_actor_3dx.h
    engines/wintermute/ad/ad_attach_3dx.cpp
    engines/wintermute/ad/ad_attach_3dx.h
    engines/wintermute/base/base_animation_transition_time.cpp
    engines/wintermute/base/base_animation_transition_time.h
    engines/wintermute/base/base_object.h
    engines/wintermute/base/gfx/xmesh.cpp
    engines/wintermute/base/gfx/xmesh.h
    engines/wintermute/base/gfx/xmodel.cpp
    engines/wintermute/base/gfx/xmodel.h


diff --git a/engines/wintermute/ad/ad_actor.cpp b/engines/wintermute/ad/ad_actor.cpp
index 35b4330e22a..f126925c611 100644
--- a/engines/wintermute/ad/ad_actor.cpp
+++ b/engines/wintermute/ad/ad_actor.cpp
@@ -44,6 +44,7 @@
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/particles/part_emitter.h"
 #include "engines/wintermute/base/base_engine.h"
+#include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
@@ -73,11 +74,21 @@ AdActor::AdActor(BaseGame *inGame) : AdTalkHolder(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdActor::setDefaultAnimNames() {
-	_talkAnimName = "talk";
-	_idleAnimName = "idle";
-	_walkAnimName = "walk";
-	_turnLeftAnimName = "turnleft";
-	_turnRightAnimName = "turnright";
+	_talkAnimName = nullptr;
+	BaseUtils::setString(&_talkAnimName, "talk");
+
+	_idleAnimName = nullptr;
+	BaseUtils::setString(&_idleAnimName, "idle");
+
+	_walkAnimName = nullptr;
+	BaseUtils::setString(&_walkAnimName, "walk");
+
+	_turnLeftAnimName = nullptr;
+	BaseUtils::setString(&_turnLeftAnimName, "turnleft");
+
+	_turnRightAnimName = nullptr;
+	BaseUtils::setString(&_turnRightAnimName, "turnright");
+
 	return STATUS_OK;
 }
 
@@ -103,6 +114,12 @@ AdActor::~AdActor() {
 	}
 	_talkSpritesEx.removeAll();
 
+	SAFE_DELETE_ARRAY(_talkAnimName);
+	SAFE_DELETE_ARRAY(_idleAnimName);
+	SAFE_DELETE_ARRAY(_walkAnimName);
+	SAFE_DELETE_ARRAY(_turnLeftAnimName);
+	SAFE_DELETE_ARRAY(_turnRightAnimName);
+
 	for (int32 i = 0; i < _anims.getSize(); i++) {
 		SAFE_DELETE(_anims[i]);
 	}
@@ -1228,9 +1245,9 @@ bool AdActor::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "TalkAnimName") == 0) {
 		if (value->isNULL()) {
-			_talkAnimName = "talk";
+			BaseUtils::setString(&_talkAnimName, "talk");
 		} else {
-			_talkAnimName = value->getString();
+			BaseUtils::setString(&_talkAnimName, value->getString());
 		}
 		return STATUS_OK;
 	}
@@ -1240,9 +1257,9 @@ bool AdActor::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "WalkAnimName") == 0) {
 		if (value->isNULL()) {
-			_walkAnimName = "walk";
+			BaseUtils::setString(&_walkAnimName, "walk");
 		} else {
-			_walkAnimName = value->getString();
+			BaseUtils::setString(&_walkAnimName, value->getString());
 		}
 		return STATUS_OK;
 	}
@@ -1252,9 +1269,9 @@ bool AdActor::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "IdleAnimName") == 0) {
 		if (value->isNULL()) {
-			_idleAnimName = "idle";
+			BaseUtils::setString(&_idleAnimName, "idle");
 		} else {
-			_idleAnimName = value->getString();
+			BaseUtils::setString(&_idleAnimName, value->getString());
 		}
 		return STATUS_OK;
 	}
@@ -1264,9 +1281,9 @@ bool AdActor::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "TurnLeftAnimName") == 0) {
 		if (value->isNULL()) {
-			_turnLeftAnimName = "turnleft";
+			BaseUtils::setString(&_turnLeftAnimName, "turnleft");
 		} else {
-			_turnLeftAnimName = value->getString();
+			BaseUtils::setString(&_turnLeftAnimName, value->getString());
 		}
 		return STATUS_OK;
 	}
@@ -1276,9 +1293,9 @@ bool AdActor::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "TurnRightAnimName") == 0) {
 		if (value->isNULL()) {
-			_turnRightAnimName = "turnright";
+			BaseUtils::setString(&_turnRightAnimName, "turnright");
 		} else {
-			_turnRightAnimName = value->getString();
+			BaseUtils::setString(&_turnRightAnimName, value->getString());
 		}
 		return STATUS_OK;
 	} else {
@@ -1329,7 +1346,7 @@ BaseSprite *AdActor::getTalkStance(const char *stance) {
 	if (!ret) {
 		BaseArray<AdSpriteSet *> talkAnims;
 		for (int32 i = 0; i < _anims.getSize(); i++) {
-			if (_talkAnimName.compareToIgnoreCase(_anims[i]->_name) == 0) {
+			if (scumm_stricmp(_anims[i]->_name, _talkAnimName) == 0) {
 				talkAnims.add(_anims[i]);
 			}
 		}
@@ -1410,11 +1427,11 @@ bool AdActor::persist(BasePersistenceManager *persistMgr) {
 	persistMgr->transferPtr(TMEMBER_PTR(_walkSprite));
 
 	persistMgr->transferPtr(TMEMBER_PTR(_animSprite2));
-	persistMgr->transferString(TMEMBER(_talkAnimName));
-	persistMgr->transferString(TMEMBER(_idleAnimName));
-	persistMgr->transferString(TMEMBER(_walkAnimName));
-	persistMgr->transferString(TMEMBER(_turnLeftAnimName));
-	persistMgr->transferString(TMEMBER(_turnRightAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_talkAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_idleAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_walkAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_turnLeftAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_turnRightAnimName));
 
 	_anims.persist(persistMgr);
 
@@ -1467,14 +1484,13 @@ int32 AdActor::getHeight() {
 
 
 //////////////////////////////////////////////////////////////////////////
-AdSpriteSet *AdActor::getAnimByName(const Common::String &animName) {
-	if (animName.empty())
+AdSpriteSet *AdActor::getAnimByName(const char *animName) {
+	if (!animName)
 		return nullptr;
 
 	for (int32 i = 0; i < _anims.getSize(); i++) {
-		if (animName.compareToIgnoreCase(_anims[i]->_name) == 0) {
+		if (scumm_stricmp(_anims[i]->_name, animName) == 0)
 			return _anims[i];
-		}
 	}
 	return nullptr;
 }
diff --git a/engines/wintermute/ad/ad_actor.h b/engines/wintermute/ad/ad_actor.h
index f8b1672c18c..f97d2b954c0 100644
--- a/engines/wintermute/ad/ad_actor.h
+++ b/engines/wintermute/ad/ad_actor.h
@@ -69,14 +69,14 @@ public:
 	bool loadBuffer(char *buffer, bool complete = true);
 
 	// new anim system
-	Common::String _talkAnimName;
-	Common::String _idleAnimName;
-	Common::String _walkAnimName;
-	Common::String _turnLeftAnimName;
-	Common::String _turnRightAnimName;
+	char *_talkAnimName;
+	char *_idleAnimName;
+	char *_walkAnimName;
+	char *_turnLeftAnimName;
+	char *_turnRightAnimName;
 	BaseArray<AdSpriteSet *> _anims;
 	bool playAnim(const char *filename) override;
-	AdSpriteSet *getAnimByName(const Common::String &animName);
+	AdSpriteSet *getAnimByName(const char *animName);
 
 	// scripting interface
 	ScValue *scGetProperty(const char *name) override;
diff --git a/engines/wintermute/ad/ad_actor_3dx.cpp b/engines/wintermute/ad/ad_actor_3dx.cpp
index 8b9f7f6e388..f3028e52e88 100644
--- a/engines/wintermute/ad/ad_actor_3dx.cpp
+++ b/engines/wintermute/ad/ad_actor_3dx.cpp
@@ -74,22 +74,30 @@ AdActor3DX::AdActor3DX(BaseGame *inGame) : AdObject3D(inGame) {
 	_path3D = new AdPath3D(inGame);
 	_path2D = new AdPath(inGame);
 
-	_talkAnimName = Common::String("talk");
+	_talkAnimName = nullptr;
+	BaseUtils::setString(&_talkAnimName, "talk");
 
-	_idleAnimName = Common::String("idle");
+	_idleAnimName = nullptr;
+	BaseUtils::setString(&_idleAnimName, "idle");
 
-	_walkAnimName = Common::String("walk");
+	_walkAnimName = nullptr;
+	BaseUtils::setString(&_walkAnimName, "walk");
 
-	_turnLeftAnimName = Common::String("turnleft");
+	_turnLeftAnimName = nullptr;
+	BaseUtils::setString(&_turnLeftAnimName, "turnleft");
 
-	_turnRightAnimName = Common::String("turnright");
+	_turnRightAnimName = nullptr;
+	BaseUtils::setString(&_turnRightAnimName, "turnright");
 
 	_talkAnimChannel = 0;
 
 	_game->_renderer3D->enableShadows();
 
+	// direct controls
 	_directWalkMode = DIRECT_WALK_NONE;
 	_directTurnMode = DIRECT_TURN_NONE;
+	_directWalkAnim = nullptr;
+	_directTurnAnim = nullptr;
 	_directWalkVelocity = 0.0f;
 	_directTurnVelocity = 0.0f;
 
@@ -99,6 +107,7 @@ AdActor3DX::AdActor3DX(BaseGame *inGame) : AdObject3D(inGame) {
 
 	_goToTolerance = 2;
 
+	_partBone = nullptr;
 	_partOffset = DXVector3(0.0f, 0.0f, 0.0f);
 }
 
@@ -116,10 +125,21 @@ AdActor3DX::~AdActor3DX() {
 	}
 	_transitionTimes.removeAll();
 
+	SAFE_DELETE_ARRAY(_talkAnimName);
+	SAFE_DELETE_ARRAY(_idleAnimName);
+	SAFE_DELETE_ARRAY(_walkAnimName);
+	SAFE_DELETE_ARRAY(_turnLeftAnimName);
+	SAFE_DELETE_ARRAY(_turnRightAnimName);
+
+	SAFE_DELETE_ARRAY(_directWalkAnim);
+	SAFE_DELETE_ARRAY(_directTurnAnim);
+
 	SAFE_DELETE(_path2D);
 	SAFE_DELETE(_path3D);
 
 	SAFE_DELETE(_targetPoint2D);
+
+	SAFE_DELETE_ARRAY(_partBone);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -159,7 +179,7 @@ bool AdActor3DX::update() {
 			if (_directWalkMode != DIRECT_WALK_NONE) {
 				// disabled in original code
 			} else if (_directTurnMode != DIRECT_TURN_NONE) {
-				if (!_directTurnAnim.empty()) {
+				if (_directTurnAnim) {
 					_xmodel->playAnim(0, _directTurnAnim, _defaultTransTime, false, _defaultStopTransTime);
 				} else {
 					_xmodel->playAnim(0, _idleAnimName, _defaultTransTime, false, _defaultStopTransTime);
@@ -208,7 +228,7 @@ bool AdActor3DX::update() {
 				}
 
 				if (canWalk) {
-					if (!_directWalkAnim.empty()) {
+					if (_directWalkAnim != nullptr) {
 						_xmodel->playAnim(0, _directWalkAnim, _defaultTransTime, false, _defaultStopTransTime);
 					} else {
 						_xmodel->playAnim(0, _walkAnimName, _defaultTransTime, false, _defaultStopTransTime);
@@ -407,12 +427,7 @@ bool AdActor3DX::display() {
 	bool res = _xmodel->render();
 
 	if (_registrable) {
-		_game->_renderer->_rectList.add(new BaseActiveRect(_game, this, _xmodel,
-		                                                      _xmodel->_boundingRect.left,
-		                                                      _xmodel->_boundingRect.top,
-		                                                      _xmodel->_boundingRect.right - _xmodel->_boundingRect.left,
-		                                                      _xmodel->_boundingRect.bottom - _xmodel->_boundingRect.top,
-		                                                      true));
+		_game->_renderer->_rectList.add(new BaseActiveRect(_game, this, _xmodel, _xmodel->_boundingRect.left, _xmodel->_boundingRect.top, _xmodel->_boundingRect.right - _xmodel->_boundingRect.left, _xmodel->_boundingRect.bottom - _xmodel->_boundingRect.top, true));
 	}
 
 	displayAttachments(true);
@@ -465,9 +480,7 @@ bool AdActor3DX::displayShadowVolume() {
 
 	_game->_renderer3D->setWorldTransform(_worldMatrix);
 
-	DXVector3 lightPos = DXVector3(_shadowLightPos._x * _scale3D,
-	                               _shadowLightPos._y * _scale3D,
-	                               _shadowLightPos._z * _scale3D);
+	DXVector3 lightPos = DXVector3(_shadowLightPos._x * _scale3D, _shadowLightPos._y * _scale3D, _shadowLightPos._z * _scale3D);
 	pos = _posVector + lightPos;
 	target = _posVector;
 
@@ -499,7 +512,7 @@ bool AdActor3DX::displayShadowVolume() {
 			continue;
 		}
 
-		DXMatrix *boneMat = _xmodel->getBoneMatrix(at->getParentBone().c_str());
+		DXMatrix *boneMat = _xmodel->getBoneMatrix(at->getParentBone());
 		if (!boneMat) {
 			continue;
 		}
@@ -577,7 +590,7 @@ bool AdActor3DX::displayAttachments(bool registerObjects) {
 			continue;
 		}
 
-		DXMatrix *boneMat = _xmodel->getBoneMatrix(at->getParentBone().c_str());
+		DXMatrix *boneMat = _xmodel->getBoneMatrix(at->getParentBone());
 		if (!boneMat) {
 			continue;
 		}
@@ -1722,7 +1735,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		ScValue *valVelocity = stack->pop();
 		ScValue *valAnim = stack->pop();
 
-		_directWalkAnim.clear();
+		SAFE_DELETE_ARRAY(_directWalkAnim);
 
 		if (!valVelocity->isNULL()) {
 			_directWalkVelocity = valVelocity->getFloat();
@@ -1731,7 +1744,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		}
 
 		if (!valAnim->isNULL()) {
-			_directWalkAnim = valAnim->getString();
+			BaseUtils::setString(&_directWalkAnim, valAnim->getString());
 		}
 
 		_state = STATE_DIRECT_CONTROL;
@@ -1766,7 +1779,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		ScValue *valVelocity = stack->pop();
 		ScValue *valAnim = stack->pop();
 
-		_directTurnAnim.clear();
+		SAFE_DELETE_ARRAY(_directTurnAnim);
 
 		if (!valVelocity->isNULL()) {
 			_directTurnVelocity = valVelocity->getFloat();
@@ -1775,7 +1788,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		}
 
 		if (!valAnim->isNULL()) {
-			_directTurnAnim = valAnim->getString();
+			BaseUtils::setString(&_directTurnAnim, valAnim->getString());
 		}
 
 		_state = STATE_DIRECT_CONTROL;
@@ -1958,7 +1971,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		bool found = false;
 		for (int32 i = 0; i < _transitionTimes.getSize(); i++) {
 			BaseAnimationTransitionTime *trans = _transitionTimes[i];
-			if (!trans->_animFrom.empty() && !trans->_animTo.empty() && trans->_animFrom.compareToIgnoreCase(animFrom) == 0 && trans->_animTo.compareToIgnoreCase(animTo) == 0) {
+			if (trans->_animFrom && trans->_animTo && scumm_stricmp(trans->_animFrom, animFrom) == 0 && scumm_stricmp(trans->_animTo, animTo) == 0) {
 				found = true;
 				if (time < 0) {
 					delete trans;
@@ -1990,7 +2003,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		for (int32 i = 0; i < _transitionTimes.getSize(); i++) {
 			BaseAnimationTransitionTime *trans = _transitionTimes[i];
 
-			if (!trans->_animFrom.empty() && !trans->_animTo.empty() && trans->_animFrom.compareToIgnoreCase(animFrom) == 0 && trans->_animTo.compareToIgnoreCase(animTo) == 0) {
+			if (trans->_animFrom && trans->_animTo && scumm_stricmp(trans->_animFrom, animFrom) == 0 && scumm_stricmp(trans->_animTo, animTo) == 0) {
 				time = trans->_time;
 				break;
 			}
@@ -2133,9 +2146,9 @@ bool AdActor3DX::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	if (strcmp(name, "TalkAnimName") == 0) {
 		if (value->isNULL()) {
-			_talkAnimName = "talk";
+			BaseUtils::setString(&_talkAnimName, "talk");
 		} else {
-			_talkAnimName = value->getString();
+			BaseUtils::setString(&_talkAnimName, value->getString());
 		}
 
 		return true;
@@ -2154,9 +2167,9 @@ bool AdActor3DX::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "WalkAnimName") == 0) {
 		if (value->isNULL()) {
-			_walkAnimName = "walk";
+			BaseUtils::setString(&_walkAnimName, "walk");
 		} else {
-			_walkAnimName = value->getString();
+			BaseUtils::setString(&_walkAnimName, value->getString());
 		}
 		return true;
 	}
@@ -2166,9 +2179,9 @@ bool AdActor3DX::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "IdleAnimName") == 0) {
 		if (value->isNULL()) {
-			_idleAnimName = "idle";
+			BaseUtils::setString(&_idleAnimName, "idle");
 		} else {
-			_idleAnimName = value->getString();
+			BaseUtils::setString(&_idleAnimName, value->getString());
 		}
 
 		return true;
@@ -2179,9 +2192,9 @@ bool AdActor3DX::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "TurnLeftAnimName") == 0) {
 		if (value->isNULL()) {
-			_turnLeftAnimName = "turnleft";
+			BaseUtils::setString(&_turnLeftAnimName, "turnleft");
 		} else {
-			_turnLeftAnimName = value->getString();
+			BaseUtils::setString(&_turnLeftAnimName, value->getString());
 		}
 
 		return true;
@@ -2192,9 +2205,9 @@ bool AdActor3DX::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "TurnRightAnimName") == 0) {
 		if (value->isNULL()) {
-			_turnRightAnimName = "turnright";
+			BaseUtils::setString(&_turnRightAnimName, "turnright");
 		} else {
-			_turnRightAnimName = value->getString();
+			BaseUtils::setString(&_turnRightAnimName, value->getString());
 		}
 		return true;
 	}
@@ -2261,17 +2274,17 @@ bool AdActor3DX::persist(BasePersistenceManager *persistMgr) {
 	persistMgr->transferBool(TMEMBER(_turningLeft));
 	persistMgr->transferFloat(TMEMBER(_afterWalkAngle));
 
-	persistMgr->transferString(TMEMBER(_talkAnimName));
-	persistMgr->transferString(TMEMBER(_idleAnimName));
-	persistMgr->transferString(TMEMBER(_walkAnimName));
-	persistMgr->transferString(TMEMBER(_turnLeftAnimName));
-	persistMgr->transferString(TMEMBER(_turnRightAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_talkAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_idleAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_walkAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_turnLeftAnimName));
+	persistMgr->transferCharPtr(TMEMBER(_turnRightAnimName));
 
 	// direct controls
 	persistMgr->transferSint32(TMEMBER_INT(_directWalkMode));
 	persistMgr->transferSint32(TMEMBER_INT(_directTurnMode));
-	persistMgr->transferString(TMEMBER(_directWalkAnim));
-	persistMgr->transferString(TMEMBER(_directTurnAnim));
+	persistMgr->transferCharPtr(TMEMBER(_directWalkAnim));
+	persistMgr->transferCharPtr(TMEMBER(_directTurnAnim));
 	persistMgr->transferFloat(TMEMBER(_directWalkVelocity));
 	persistMgr->transferFloat(TMEMBER(_directTurnVelocity));
 
@@ -2302,7 +2315,7 @@ bool AdActor3DX::persist(BasePersistenceManager *persistMgr) {
 
 	persistMgr->transferSint32(TMEMBER(_talkAnimChannel));
 
-	persistMgr->transferString(TMEMBER(_partBone));
+	persistMgr->transferCharPtr(TMEMBER(_partBone));
 	persistMgr->transferVector3d(TMEMBER(_partOffset));
 
 	return true;
@@ -2420,10 +2433,10 @@ bool AdActor3DX::isGoToNeeded(int32 x, int32 y) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-uint32 AdActor3DX::getAnimTransitionTime(char *from, char *to) {
+uint32 AdActor3DX::getAnimTransitionTime(const char *from, const char *to) {
 	for (int32 i = 0; i < _transitionTimes.getSize(); i++) {
 		BaseAnimationTransitionTime *trans = _transitionTimes[i];
-		if (!trans->_animFrom.empty() && !trans->_animTo.empty() && trans->_animFrom.compareToIgnoreCase(from) == 0 && trans->_animTo.compareToIgnoreCase(to) == 0) {
+		if (trans->_animFrom && trans->_animTo && scumm_stricmp(trans->_animFrom, from) == 0 && scumm_stricmp(trans->_animTo, to) == 0) {
 			return trans->_time;
 		}
 	}
@@ -2433,13 +2446,13 @@ uint32 AdActor3DX::getAnimTransitionTime(char *from, char *to) {
 
 //////////////////////////////////////////////////////////////////////////
 PartEmitter *AdActor3DX::createParticleEmitter(bool followParent, int offsetX, int offsetY) {
-	_partBone.clear();
+	SAFE_DELETE_ARRAY(_partBone);
 	return AdObject::createParticleEmitter(followParent, offsetX, offsetY);
 }
 
 //////////////////////////////////////////////////////////////////////////
 PartEmitter *AdActor3DX::createParticleEmitter(const char *boneName, DXVector3 offset) {
-	_partBone = boneName;
+	BaseUtils::setString(&_partBone, boneName);
 	_partOffset = offset;
 	return AdObject::createParticleEmitter(true);
 }
@@ -2450,7 +2463,7 @@ bool AdActor3DX::updatePartEmitter() {
 		return false;
 	}
 
-	if (_partBone.empty()) {
+	if (!_partBone) {
 		return AdObject::updatePartEmitter();
 	}
 
@@ -2461,7 +2474,7 @@ bool AdActor3DX::updatePartEmitter() {
 	}
 
 	DXVector3 bonePos;
-	getBonePosition3D(_partBone.c_str(), &bonePos, &_partOffset);
+	getBonePosition3D(_partBone, &bonePos, &_partOffset);
 	int32 x = 0, y = 0;
 	static_cast<AdGame *>(_game)->_scene->_geom->convert3Dto2D(&bonePos, &x, &y);
 
diff --git a/engines/wintermute/ad/ad_actor_3dx.h b/engines/wintermute/ad/ad_actor_3dx.h
index 6e07f922690..eecd4aeaa5a 100644
--- a/engines/wintermute/ad/ad_actor_3dx.h
+++ b/engines/wintermute/ad/ad_actor_3dx.h
@@ -45,7 +45,7 @@ public:
 	PartEmitter *createParticleEmitter(bool followParent = false, int offsetX = 0, int offsetY = 0) override;
 	virtual PartEmitter *createParticleEmitter(const char *boneName, DXVector3 offset);
 	bool updatePartEmitter() override;
-	Common::String _partBone;
+	char *_partBone;
 	DXVector3 _partOffset;
 
 	bool displayShadowVolume();
@@ -58,7 +58,7 @@ public:
 	bool playAnim3DX(const char *name, bool setState);
 	bool playAnim3DX(int channel, const char *name, bool setState);
 
-	uint32 getAnimTransitionTime(char *from, char *to) override;
+	uint32 getAnimTransitionTime(const char *from, const char *to) override;
 	BaseArray<BaseAnimationTransitionTime *> _transitionTimes;
 
 	virtual bool renderModel() override;
@@ -67,18 +67,18 @@ public:
 	uint32 _defaultStopTransTime;
 
 	float _afterWalkAngle;
-	Common::String _talkAnimName;
-	Common::String _idleAnimName;
-	Common::String _walkAnimName;
-	Common::String _turnLeftAnimName;
-	Common::String _turnRightAnimName;
+	char *_talkAnimName;
+	char *_idleAnimName;
+	char *_walkAnimName;
+	char *_turnLeftAnimName;
+	char *_turnRightAnimName;
 
 	int32 _talkAnimChannel;
 
 	TDirectWalkMode _directWalkMode;
 	TDirectTurnMode _directTurnMode;
-	Common::String _directWalkAnim;
-	Common::String _directTurnAnim;
+	char *_directWalkAnim;
+	char *_directTurnAnim;
 	float _directWalkVelocity;
 	float _directTurnVelocity;
 
diff --git a/engines/wintermute/ad/ad_attach_3dx.cpp b/engines/wintermute/ad/ad_attach_3dx.cpp
index a8147f3201b..f25a85eceba 100644
--- a/engines/wintermute/ad/ad_attach_3dx.cpp
+++ b/engines/wintermute/ad/ad_attach_3dx.cpp
@@ -43,11 +43,13 @@ IMPLEMENT_PERSISTENT(AdAttach3DX, false)
 //////////////////////////////////////////////////////////////////////////
 AdAttach3DX::AdAttach3DX(BaseGame *inGame, BaseObject *owner) : AdObject3D(inGame) {
 	_owner = owner;
+	_parentBone = nullptr;
 	_dropToFloor = false;
 }
 
 //////////////////////////////////////////////////////////////////////////
 AdAttach3DX::~AdAttach3DX() {
+	SAFE_DELETE_ARRAY(_parentBone);
 	_owner = nullptr; // ref only
 }
 
@@ -55,7 +57,7 @@ AdAttach3DX::~AdAttach3DX() {
 bool AdAttach3DX::init(const char *modelFile, const char *name, const char *parentBone) {
 	SAFE_DELETE(_xmodel);
 
-	_parentBone = parentBone;
+	BaseUtils::setString(&_parentBone, parentBone);
 	setName(name);
 
 	_xmodel = new XModel(_game, _owner);
@@ -119,7 +121,7 @@ bool AdAttach3DX::displayShadowVol(DXMatrix *modelMat, DXVector3 *light, float e
 }
 
 //////////////////////////////////////////////////////////////////////////
-Common::String AdAttach3DX::getParentBone() {
+char *AdAttach3DX::getParentBone() {
 	return _parentBone;
 }
 
@@ -132,7 +134,7 @@ bool AdAttach3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSt
 	//////////////////////////////////////////////////////////////////////////
 	if (strcmp(name, "PlayAnim") == 0 || strcmp(name, "PlayAnimAsync") == 0) {
 		stack->correctParams(1);
-		Common::String animName = stack->pop()->getString();
+		const char *animName = stack->pop()->getString();
 		if (!_xmodel || !_xmodel->playAnim(0, animName, 0, true)) {
 			stack->pushBool(false);
 		} else {
@@ -227,7 +229,7 @@ bool AdAttach3DX::persist(BasePersistenceManager *persistMgr) {
 	AdObject3D::persist(persistMgr);
 
 	persistMgr->transferPtr(TMEMBER(_owner));
-	persistMgr->transferString(TMEMBER(_parentBone));
+	persistMgr->transferCharPtr(TMEMBER(_parentBone));
 
 	return true;
 }
diff --git a/engines/wintermute/ad/ad_attach_3dx.h b/engines/wintermute/ad/ad_attach_3dx.h
index 0613defef64..c99a7702037 100644
--- a/engines/wintermute/ad/ad_attach_3dx.h
+++ b/engines/wintermute/ad/ad_attach_3dx.h
@@ -46,7 +46,7 @@ public:
 	bool invalidateDeviceObjects() override;
 	bool restoreDeviceObjects() override;
 
-	Common::String getParentBone();
+	char *getParentBone();
 
 	// scripting interface
 	ScValue *scGetProperty(const char *name) override;
@@ -56,7 +56,7 @@ public:
 
 private:
 	BaseObject *_owner;
-	Common::String _parentBone;
+	char *_parentBone;
 };
 
 } // namespace Wintermute
diff --git a/engines/wintermute/base/base_animation_transition_time.cpp b/engines/wintermute/base/base_animation_transition_time.cpp
index b91d93eb79d..74df89699ae 100644
--- a/engines/wintermute/base/base_animation_transition_time.cpp
+++ b/engines/wintermute/base/base_animation_transition_time.cpp
@@ -27,30 +27,39 @@
 
 #include "engines/wintermute/base/base_animation_transition_time.h"
 #include "engines/wintermute/persistent.h"
+#include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
 //////////////////////////////////////////////////////////////////////////
-BaseAnimationTransitionTime::BaseAnimationTransitionTime(const Common::String &from, const Common::String &to, uint32 time) {
-	_animFrom = from;
-	_animTo = to;
+BaseAnimationTransitionTime::BaseAnimationTransitionTime(const char *from, const char *to, uint32 time) {
+	_animFrom = nullptr;
+	_animTo = nullptr;
+
+	BaseUtils::setString(&_animFrom, from);
+	BaseUtils::setString(&_animTo, to);
 	_time = time;
 }
 
 //////////////////////////////////////////////////////////////////////////
 BaseAnimationTransitionTime::BaseAnimationTransitionTime() {
+	_animFrom = nullptr;
+	_animTo = nullptr;
 	_time = 0;
 }
 
 //////////////////////////////////////////////////////////////////////////
 BaseAnimationTransitionTime::~BaseAnimationTransitionTime() {
+	SAFE_DELETE_ARRAY(_animFrom);
+	SAFE_DELETE_ARRAY(_animTo);
 }
 
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseAnimationTransitionTime::persist(BasePersistenceManager *persistMgr) {
-	persistMgr->transferString(TMEMBER(_animFrom));
-	persistMgr->transferString(TMEMBER(_animTo));
+	persistMgr->transferCharPtr(TMEMBER(_animFrom));
+	persistMgr->transferCharPtr(TMEMBER(_animTo));
 	persistMgr->transferUint32(TMEMBER(_time));
 
 	return true;
diff --git a/engines/wintermute/base/base_animation_transition_time.h b/engines/wintermute/base/base_animation_transition_time.h
index 2b14c03711f..e51582e7699 100644
--- a/engines/wintermute/base/base_animation_transition_time.h
+++ b/engines/wintermute/base/base_animation_transition_time.h
@@ -34,13 +34,13 @@ namespace Wintermute {
 
 class BaseAnimationTransitionTime {
 public:
-	BaseAnimationTransitionTime(const Common::String &from, const Common::String &to, uint32 Time);
+	BaseAnimationTransitionTime(const char *from, const char *to, uint32 Time);
 	BaseAnimationTransitionTime();
 	virtual ~BaseAnimationTransitionTime();
 	bool persist(BasePersistenceManager *persistMgr);
 
-	Common::String _animFrom;
-	Common::String _animTo;
+	char *_animFrom;
+	char *_animTo;
 	uint32 _time;
 };
 
diff --git a/engines/wintermute/base/base_object.h b/engines/wintermute/base/base_object.h
index cd0675d7cf9..c3d167c63cf 100644
--- a/engines/wintermute/base/base_object.h
+++ b/engines/wintermute/base/base_object.h
@@ -153,7 +153,7 @@ public:
 	DXVector3 _shadowLightPos;
 	bool _drawBackfaces;
 	TShadowType _shadowType;
-	virtual uint32 getAnimTransitionTime(char *from, char *to) {
+	virtual uint32 getAnimTransitionTime(const char *from, const char *to) {
 		return 0;
 	};
 #endif
diff --git a/engines/wintermute/base/gfx/xmesh.cpp b/engines/wintermute/base/gfx/xmesh.cpp
index e147238ec24..321862690f3 100644
--- a/engines/wintermute/base/gfx/xmesh.cpp
+++ b/engines/wintermute/base/gfx/xmesh.cpp
@@ -302,9 +302,9 @@ bool XMesh::pickPoly(DXVector3 *pickRayOrig, DXVector3 *pickRayDir) {
 }
 
 ////////////////////////////////////////////////////////////////////////////
-bool XMesh::setMaterialSprite(const Common::String &matName, BaseSprite *sprite) {
+bool XMesh::setMaterialSprite(const char *matName, BaseSprite *sprite) {
 	for (int32 i = 0; i < _materials.getSize(); i++) {
-		if (_materials[i]->_name && scumm_stricmp(_materials[i]->_name,  matName.c_str()) == 0) {
+		if (_materials[i]->_name && scumm_stricmp(_materials[i]->_name,  matName) == 0) {
 			_materials[i]->setSprite(sprite);
 		}
 	}
@@ -312,9 +312,9 @@ bool XMesh::setMaterialSprite(const Common::String &matName, BaseSprite *sprite)
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool XMesh::setMaterialTheora(const Common::String &matName, VideoTheoraPlayer *theora) {
+bool XMesh::setMaterialTheora(const char *matName, VideoTheoraPlayer *theora) {
 	for (int32 i = 0; i < _materials.getSize(); i++) {
-		if (_materials[i]->_name && scumm_stricmp(_materials[i]->_name, matName.c_str()) == 0) {
+		if (_materials[i]->_name && scumm_stricmp(_materials[i]->_name, matName) == 0) {
 			_materials[i]->setTheora(theora);
 		}
 	}
@@ -322,9 +322,9 @@ bool XMesh::setMaterialTheora(const Common::String &matName, VideoTheoraPlayer *
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool XMesh::setMaterialEffect(const Common::String &matName, Effect3D *effect, Effect3DParams *params) {
+bool XMesh::setMaterialEffect(const char *matName, Effect3D *effect, Effect3DParams *params) {
 	for (int32 i = 0; i < _materials.getSize(); i++) {
-		if (_materials[i]->_name && scumm_stricmp(_materials[i]->_name, matName.c_str()) == 0) {
+		if (_materials[i]->_name && scumm_stricmp(_materials[i]->_name, matName) == 0) {
 			_materials[i]->setEffect(effect, params);
 		}
 	}
@@ -332,9 +332,9 @@ bool XMesh::setMaterialEffect(const Common::String &matName, Effect3D *effect, E
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool XMesh::removeMaterialEffect(const Common::String &matName) {
+bool XMesh::removeMaterialEffect(const char *matName) {
 	for (int32 i = 0; i < _materials.getSize(); i++) {
-		if (_materials[i]->_name && scumm_stricmp(_materials[i]->_name, matName.c_str()) == 0) {
+		if (_materials[i]->_name && scumm_stricmp(_materials[i]->_name, matName) == 0) {
 			_materials[i]->setEffect(nullptr, nullptr);
 		}
 	}
diff --git a/engines/wintermute/base/gfx/xmesh.h b/engines/wintermute/base/gfx/xmesh.h
index df21886c02e..8bc455f47fa 100644
--- a/engines/wintermute/base/gfx/xmesh.h
+++ b/engines/wintermute/base/gfx/xmesh.h
@@ -63,10 +63,10 @@ public:
 	DXVector3 _BBoxStart;
 	DXVector3 _BBoxEnd;
 
-	bool setMaterialSprite(const Common::String &matName, BaseSprite *sprite);
-	bool setMaterialTheora(const Common::String &matName, VideoTheoraPlayer *theora);
-	bool setMaterialEffect(const Common::String &matName, Effect3D *effect, Effect3DParams *params);
-	bool removeMaterialEffect(const Common::String &matName);
+	bool setMaterialSprite(const char *matName, BaseSprite *sprite);
+	bool setMaterialTheora(const char *matName, VideoTheoraPlayer *theora);
+	bool setMaterialEffect(const char *matName, Effect3D *effect, Effect3DParams *params);
+	bool removeMaterialEffect(const char *matName);
 
 	bool invalidateDeviceObjects();
 	bool restoreDeviceObjects();
diff --git a/engines/wintermute/base/gfx/xmodel.cpp b/engines/wintermute/base/gfx/xmodel.cpp
index acc16149e4b..602c9c43d89 100644
--- a/engines/wintermute/base/gfx/xmodel.cpp
+++ b/engines/wintermute/base/gfx/xmodel.cpp
@@ -378,14 +378,14 @@ bool XModel::update() {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool XModel::playAnim(int channel, const Common::String &name, uint32 transitionTime, bool forceReset, uint32 stopTransitionTime) {
+bool XModel::playAnim(int channel, const char *name, uint32 transitionTime, bool forceReset, uint32 stopTransitionTime) {
 	if (channel < 0 || channel >= X_NUM_ANIMATION_CHANNELS) {
 		return false;
 	}
 
 	// are we already playing this animation?
 	if (!forceReset) {
-		if (_channels[channel]->getName() && name.equalsIgnoreCase(_channels[channel]->getName())) {
+		if (_channels[channel]->getName() && scumm_stricmp(name, _channels[channel]->getName()) == 0) {
 			return true;
 		}
 	}
@@ -394,8 +394,8 @@ bool XModel::playAnim(int channel, const Common::String &name, uint32 transition
 	AnimationSet *anim = getAnimationSetByName(name);
 	if (anim) {
 		char *currentAnim = _channels[channel]->getName();
-		if (_owner && currentAnim && !name.empty()) {
-			transitionTime = _owner->getAnimTransitionTime(currentAnim, const_cast<char *>(name.c_str()));
+		if (_owner && currentAnim && name) {
+			transitionTime = _owner->getAnimTransitionTime(currentAnim, name);
 		}
 
 		return _channels[channel]->playAnim(anim, transitionTime, stopTransitionTime);
@@ -667,9 +667,9 @@ void XModel::updateRect(Common::Rect32 *rc, DXVector3 *vec) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-AnimationSet *XModel::getAnimationSetByName(const Common::String &name) {
+AnimationSet *XModel::getAnimationSetByName(const char *name) {
 	for (int32 i = 0; i < _animationSets.getSize(); i++) {
-		if (name.equalsIgnoreCase(_animationSets[i]->_name)) {
+		if (scumm_stricmp(name, _animationSets[i]->_name) == 0) {
 			return _animationSets[i];
 		}
 	}
diff --git a/engines/wintermute/base/gfx/xmodel.h b/engines/wintermute/base/gfx/xmodel.h
index 172b26b3e67..76bf4c6bdca 100644
--- a/engines/wintermute/base/gfx/xmodel.h
+++ b/engines/wintermute/base/gfx/xmodel.h
@@ -36,6 +36,7 @@
 #include "engines/wintermute/coll_templ.h"
 #include "engines/wintermute/video/video_theora_player.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -101,41 +102,32 @@ private:
 		}
 
 		~XModelMatSprite() {
-			delete[] _matName;
-			_matName = nullptr;
-			delete _effectFile;
-			_effectFile = nullptr;
-			delete _sprite;
-			_sprite = nullptr;
-			delete _theora;
-			_theora = nullptr;
-			delete _effect;
-			_effect = nullptr;
-			delete _effectParams;
-			_effectParams = nullptr;
+			SAFE_DELETE_ARRAY(_matName);
+			SAFE_DELETE_ARRAY(_effectFile);
+			SAFE_DELETE(_sprite);
+			SAFE_DELETE(_theora);
+			SAFE_DELETE(_effect);
+			SAFE_DELETE(_effectParams);
 		}
 
 		bool setSprite(BaseSprite *sprite) {
-			delete _theora;
-			_theora = nullptr;
-			delete _sprite;
+			SAFE_DELETE(_theora);
+			SAFE_DELETE(_sprite);
 			_sprite = sprite;
 
 			return true;
 		}
 
 		bool setTheora(VideoTheoraPlayer *theora) {
-			delete _theora;
-			_theora = nullptr;
-			delete _sprite;
-			_sprite = nullptr;
+			SAFE_DELETE(_theora);
+			SAFE_DELETE(_sprite);
 			_theora = theora;
 
 			return true;
 		}
 
 		bool setEffect(Effect3D *effect) {
-			delete _effect;
+			SAFE_DELETE(_effect);
 			_effect = effect;
 
 			if (!_effectParams)
@@ -210,7 +202,7 @@ public:
 
 	bool updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth);
 
-	bool playAnim(int channel, const Common::String &anim, uint32 transitionTime = 0, bool forceReset = false, uint32 stopTransitionTime = 0);
+	bool playAnim(int channel, const char *anim, uint32 transitionTime = 0, bool forceReset = false, uint32 stopTransitionTime = 0);
 	bool isAnimPending(char *animName = nullptr);
 	bool isAnimPending(int channel, const char *animName = nullptr);
 
@@ -224,7 +216,7 @@ public:
 
 	bool parseAnim(char *buffer);
 	bool parseEvent(AnimationSet *anim, char *buffer);
-	AnimationSet *getAnimationSetByName(const Common::String &name);
+	AnimationSet *getAnimationSetByName(const char *name);
 
 	bool stopAnim(int channel, uint32 transitionTime);
 	bool stopAnim(uint32 transitionTime);




More information about the Scummvm-git-logs mailing list