scummvm-cursorfix/engines/wintermute/base/gfx/xmodel.h

/* 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_XMODEL_H
#define WINTERMUTE_XMODEL_H

#include "engines/wintermute/base/base_object.h"
#include "engines/wintermute/base/base_sprite.h"
#include "engines/wintermute/base/gfx/xmath.h"
#include "engines/wintermute/base/gfx/3deffect.h"
#include "engines/wintermute/base/gfx/3deffect_params.h"
#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 {

class AnimationChannel;
class AnimationSet;
class FrameNode;
class Material;
class ShadowVolume;
class XFileData;
class Effect3D;
class Effect3DParams;

#define X_NUM_ANIMATION_CHANNELS 10

class XModel : public BaseObject {
private:
	class XModelMatSprite {
	public:
		char *_matName;
		char *_effectFile;
		BaseSprite *_sprite;
		VideoTheoraPlayer *_theora;
		Effect3D *_effect;
		Effect3DParams *_effectParams;

		XModelMatSprite() {
			_matName = nullptr;
			_sprite = nullptr;
			_theora = nullptr;
			_effect = nullptr;
			_effectFile = nullptr;
			_effectParams = nullptr;
		}

		XModelMatSprite(const char *matName, BaseSprite *sprite) {
			_theora = nullptr;
			_matName = nullptr;
			_effect = nullptr;
			BaseUtils::setString(&_matName, matName);
			_sprite = sprite;
			_effectFile = nullptr;
			_effectParams = nullptr;
		}

		XModelMatSprite(const char *matName, VideoTheoraPlayer *theora) {
			_sprite = nullptr;
			_matName = nullptr;
			_effect = nullptr;
			BaseUtils::setString(&_matName, matName);
			_theora = theora;
			_effectFile = nullptr;
			_effectParams = nullptr;
		}

		XModelMatSprite(const char *matName, Effect3D *effect) {
			_sprite = nullptr;
			_matName = nullptr;
			_theora = nullptr;
			BaseUtils::setString(&_matName, matName);
			_effect = effect;
			_effectFile = nullptr;
			_effectParams = new Effect3DParams();
		}

		~XModelMatSprite() {
			SAFE_DELETE_ARRAY(_matName);
			SAFE_DELETE_ARRAY(_effectFile);
			SAFE_DELETE(_sprite);
			SAFE_DELETE(_theora);
			SAFE_DELETE(_effect);
			SAFE_DELETE(_effectParams);
		}

		bool setSprite(BaseSprite *sprite) {
			SAFE_DELETE(_theora);
			SAFE_DELETE(_sprite);
			_sprite = sprite;

			return true;
		}

		bool setTheora(VideoTheoraPlayer *theora) {
			SAFE_DELETE(_theora);
			SAFE_DELETE(_sprite);
			_theora = theora;

			return true;
		}

		bool setEffect(Effect3D *effect) {
			SAFE_DELETE(_effect);
			_effect = effect;

			if (!_effectParams)
				_effectParams = new Effect3DParams();
			else
				_effectParams->clear();

			return true;
		}

		bool persist(BasePersistenceManager *persistMgr) {
			persistMgr->transferCharPtr(TMEMBER(_matName));
			persistMgr->transferPtr(TMEMBER(_sprite));

			persistMgr->transferPtr(TMEMBER(_theora));

			if (persistMgr->getIsSaving()) {
				char *effectFileName = nullptr;
				if (_effect)
					BaseUtils::setString(&effectFileName, _effect->getFileName());
				else
					effectFileName = nullptr;

				persistMgr->transferCharPtr(TMEMBER(effectFileName));
				SAFE_DELETE_ARRAY(effectFileName);
			} else {
				persistMgr->transferCharPtr(TMEMBER(_effectFile));
			}

			if (persistMgr->getIsSaving()) {
				bool hasParams = _effectParams != nullptr;
				persistMgr->transferBool(TMEMBER(hasParams));

				if (hasParams)
					_effectParams->persist(persistMgr);
			} else {
				bool hasParams;
				persistMgr->transferBool(TMEMBER(hasParams));

				if (hasParams) {
					_effectParams = new Effect3DParams();
					_effectParams->persist(persistMgr);
				} else
					_effectParams = nullptr;
			}

			return true;
		}
	};

public:

	const static int kDefaultTicksPerSecond = 4800;

	DECLARE_PERSISTENT(XModel, BaseObject)

	XModel(BaseGame *inGame, BaseObject *owner);
	virtual ~XModel();

	XModel *_parentModel{};

	bool loadFromFile(const char *filename, XModel *parentModel = nullptr);
	bool mergeFromFile(const char *filename);

	bool loadAnimationSet(const char *filename, XFileData *xobj);
	bool loadAnimation(const char *filename, XFileData *xobj, AnimationSet *parentAnimSet = nullptr);

	bool update() override;
	bool render();
	bool renderFlatShadowModel(uint32 shadowColor);
	bool reset();

	bool updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3 *light, float extrusionDepth);

	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);

	bool isTransparentAt(int x, int y);

	static bool loadName(BaseNamedObject *obj, XFileData *data);
	static bool loadName(Common::String &targetStr, XFileData *data);

	Common::Rect32 _boundingRect;
	BaseObject *_owner{};

	bool parseAnim(char *buffer);
	bool parseEvent(AnimationSet *anim, char *buffer);
	AnimationSet *getAnimationSetByName(const char *name);

	bool stopAnim(int channel, uint32 transitionTime);
	bool stopAnim(uint32 transitionTime);

	DXMatrix *getBoneMatrix(const char *boneName);
	FrameNode *getRootFrame();

	bool setMaterialSprite(const char *materialName, const char *spriteFilename);
	bool setMaterialTheora(const char *materialName, const char *theoraFilename);
	bool setMaterialEffect(const char *materialName, const char *effectFilename);
	bool removeMaterialEffect(const char *materialName);
	bool setMaterialEffectParam(const char *materialName, const char *paramName, ScValue *val);
	bool setMaterialEffectParam(const char *materialName, const char *paramName, DXVector4 val);
	bool initializeSimple();

	bool invalidateDeviceObjects() override;
	bool restoreDeviceObjects() override;

	bool unloadAnimation(const char *animName);

	uint32 _ticksPerSecond{};

	BaseArray<AnimationSet *> _animationSets;

private:
	void cleanup(bool complete = true);
	bool findBones(bool animOnly = false, XModel *parentModel = nullptr);

	void updateBoundingRect();
	void static inline updateRect(Common::Rect32 *rc, DXVector3 *vec);
	DXViewport _drawingViewport{};
	DXMatrix _lastWorldMat;
	DXMatrix _lastViewMat;
	DXMatrix _lastProjMat;
	int32 _lastOffsetX{};
	int32 _lastOffsetY{};

	DXVector3 _BBoxStart;
	DXVector3 _BBoxEnd;

protected:
	BaseArray<const char*> _mergedModels;
	AnimationChannel *_channels[X_NUM_ANIMATION_CHANNELS]{};

	FrameNode *_rootFrame{};

	BaseArray<XModelMatSprite *> _matSprites;
};

} // namespace Wintermute

#endif