/* ** Command & Conquer Generals(tm) ** Copyright 2025 Electronic Arts Inc. ** ** 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 . */ //////////////////////////////////////////////////////////////////////////////// // // // (c) 2001-2003 Electronic Arts Inc. // // // //////////////////////////////////////////////////////////////////////////////// // FILE: AnimateWindowManager.h ///////////////////////////////////////////////// //----------------------------------------------------------------------------- // // Electronic Arts Pacific. // // Confidential Information // Copyright (C) 2002 - All Rights Reserved // //----------------------------------------------------------------------------- // // created: Mar 2002 // // Filename: AnimateWindowManager.h // // author: Chris Huybregts // // purpose: The Animate Window class will be used by registering a window with // the manager with stating what kind of animation to do. Then on every // update, we'll move the windows. // //----------------------------------------------------------------------------- /////////////////////////////////////////////////////////////////////////////// #pragma once #ifndef __ANIMATEWINDOWMANAGER_H_ #define __ANIMATEWINDOWMANAGER_H_ //----------------------------------------------------------------------------- // SYSTEM INCLUDES //////////////////////////////////////////////////////////// //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // USER INCLUDES ////////////////////////////////////////////////////////////// //----------------------------------------------------------------------------- #include "Lib/BaseType.h" #include "Common/SubsystemInterface.h" #include "Common/GameMemory.h" //----------------------------------------------------------------------------- // FORWARD REFERENCES ///////////////////////////////////////////////////////// //----------------------------------------------------------------------------- class GameWindow; class ProcessAnimateWindowSlideFromBottom; class ProcessAnimateWindowSlideFromBottomTimed; class ProcessAnimateWindowSlideFromTop; class ProcessAnimateWindowSlideFromLeft; class ProcessAnimateWindowSlideFromRight; class ProcessAnimateWindowSlideFromRightFast; class ProcessAnimateWindowSpiral; class ProcessAnimateWindowSlideFromTopFast; class ProcessAnimateWindowSideSelect; class ProcessAnimateWindow; //----------------------------------------------------------------------------- // TYPE DEFINES /////////////////////////////////////////////////////////////// //----------------------------------------------------------------------------- enum AnimTypes { WIN_ANIMATION_NONE = 0, WIN_ANIMATION_SLIDE_RIGHT, WIN_ANIMATION_SLIDE_RIGHT_FAST, WIN_ANIMATION_SLIDE_LEFT, WIN_ANIMATION_SLIDE_TOP, WIN_ANIMATION_SLIDE_BOTTOM, WIN_ANIMATION_SPIRAL, WIN_ANIMATION_SLIDE_BOTTOM_TIMED, WIN_ANIMATION_SLIDE_TOP_FAST, WIN_ANIMATION_COUNT } ; //----------------------------------------------------------------------------- class AnimateWindow : public MemoryPoolObject { MEMORY_POOL_GLUE_WITH_USERLOOKUP_CREATE(AnimateWindow, "AnimateWindow") public: AnimateWindow( void ); //~AnimateWindow( void ); void setAnimData( ICoord2D startPos, ICoord2D endPos, ICoord2D curPos, ICoord2D restPos, Coord2D vel, UnsignedInt startTime, UnsignedInt endTime); ICoord2D getStartPos( void ); ///< Get the Start Position 2D coord ICoord2D getCurPos( void ); ///< Get the Current Position 2D coord ICoord2D getEndPos( void ); ///< Get the End Position 2D coord ICoord2D getRestPos( void ); ///< Get the Rest Position 2D coord GameWindow *getGameWindow( void ); ///< Get the GameWindow that will be animating AnimTypes getAnimType( void ); ///< Get the Animation type UnsignedInt getDelay( void ); ///< Get the Time Delay Coord2D getVel( void ); ///< Get the Velocity Position 2D coord UnsignedInt getStartTime( void ); ///< Get the start time of the time-based anim UnsignedInt getEndTime( void ); ///< Get the end time of the time-based anim void setStartPos( ICoord2D starPos); ///< Set the Start Position 2D coord void setCurPos( ICoord2D curPos); ///< Set the Current Position 2D coord void setEndPos( ICoord2D endPos); ///< Set the End Position 2D coord void setRestPos( ICoord2D restPos); ///< Set the Rest Position 2D coord void setGameWindow( GameWindow *win); ///< Set the GameWindow that will be animating void setAnimType( AnimTypes animType); ///< Set the Animation type void setDelay( UnsignedInt delay); ///< Set the Time Delay void setVel( Coord2D vel); ///< Set the Velocity Position 2D coord void setStartTime( UnsignedInt t); ///< Set the start time of the time-based anim void setEndTime( UnsignedInt t); ///< Set the end time of the time-based anim void setFinished(Bool finished); ///< Set if the animation has finished Bool isFinished( void ); ///< Return if the animation has finished or not. void setNeedsToFinish( Bool needsToFinish); ///< set if we need this animation to finish for the manager to return true Bool needsToFinish( void ); ///< set if the animation has finished private: UnsignedInt m_delay; ///< Holds the delay time in which the animation will start (in milliseconds) ICoord2D m_startPos; ///< Holds the starting position of the animation ///<(usuall is also the end position of the animation when the animation is reversed) ICoord2D m_endPos; ///< Holds the target End Position (usually is the same as the rest position) ICoord2D m_curPos; ///< It's Current Position ICoord2D m_restPos; ///< When the Manager Resets, It sets the window's position to this position GameWindow *m_win; ///< the window that this animation is happening on Coord2D m_vel; ///< the Velocity of the animation UnsignedInt m_startTime; ///< time we started the time-based anim UnsignedInt m_endTime; ///< time we should end the time-based anim AnimTypes m_animType; ///< The type of animation that will happen Bool m_needsToFinish; ///< Flag to tell the manager if we need to finish before it's done with it's animation Bool m_isFinished; ///< We're finished }; //----------------------------------------------------------------------------- typedef std::list AnimateWindowList; //----------------------------------------------------------------------------- class AnimateWindowManager : public SubsystemInterface { public: AnimateWindowManager( void ); ~AnimateWindowManager( void ); // Inhertited from subsystem ==================================================================== virtual void init( void ); virtual void reset( void ); virtual void update( void ); //=============================================================================================== void registerGameWindow(GameWindow *win, AnimTypes animType, Bool needsToFinish, UnsignedInt ms = 0, UnsignedInt delayMs = 0); // Registers a new window to animate. Bool isFinished( void ); ///< Are all the animations that need to be finished, finished? void reverseAnimateWindow( void ); ///< tell each animation type to setup the windows to run in reverse void resetToRestPosition( void ); ///< Reset all windows to their rest position Bool isReversed( void ); ///< Returns whether or not we're in our reversed state. Bool isEmpty( void ); private: AnimateWindowList m_winList; ///< A list of AnimationWindows that we don't care if their finished animating AnimateWindowList m_winMustFinishList; ///< A list of AnimationWindows that we do care about Bool m_needsUpdate; ///< If we're done animating all our monitored windows, then this will be false Bool m_reverse; ///< Are we in a reverse state? ProcessAnimateWindowSlideFromRight *m_slideFromRight; ///< Holds the process in which the windows slide from the right ProcessAnimateWindowSlideFromRightFast *m_slideFromRightFast; ProcessAnimateWindowSlideFromTop *m_slideFromTop; ///< Holds the process in which the windows slide from the Top ProcessAnimateWindowSlideFromLeft *m_slideFromLeft; ///< Holds the process in which the windows slide from the Left ProcessAnimateWindowSlideFromBottom *m_slideFromBottom; ///< Holds the process in which the windows slide from the Bottom ProcessAnimateWindowSpiral *m_spiral; ///< Holds the process in which the windows Spiral onto the screen ProcessAnimateWindowSlideFromBottomTimed *m_slideFromBottomTimed; ///< Holds the process in which the windows slide from the Bottom in a time-based fashion ProcessAnimateWindowSlideFromTopFast *m_slideFromTopFast; ///< holds the process in wich the windows slide from the top,fast ProcessAnimateWindow *getProcessAnimate( AnimTypes animType); ///< returns the process for the kind of animation we need. }; //----------------------------------------------------------------------------- // INLINING /////////////////////////////////////////////////////////////////// //----------------------------------------------------------------------------- inline ICoord2D AnimateWindow::getStartPos( void ) { return m_startPos; }; inline ICoord2D AnimateWindow::getCurPos( void ) { return m_curPos; }; inline ICoord2D AnimateWindow::getEndPos( void ) { return m_endPos; }; inline ICoord2D AnimateWindow::getRestPos( void ) { return m_restPos; }; inline GameWindow *AnimateWindow::getGameWindow( void ){ return m_win; }; inline AnimTypes AnimateWindow::getAnimType( void ) { return m_animType; }; inline UnsignedInt AnimateWindow::getDelay( void ) { return m_delay; }; inline Coord2D AnimateWindow::getVel( void ) { return m_vel; }; inline UnsignedInt AnimateWindow::getStartTime( void ) { return m_startTime; }; inline UnsignedInt AnimateWindow::getEndTime( void ) { return m_endTime; }; inline void AnimateWindow::setStartPos( ICoord2D startPos) { m_startPos = startPos; }; inline void AnimateWindow::setCurPos( ICoord2D curPos) { m_curPos = curPos; }; inline void AnimateWindow::setEndPos( ICoord2D endPos) { m_endPos = endPos; }; inline void AnimateWindow::setRestPos( ICoord2D restPos) { m_restPos = restPos; }; inline void AnimateWindow::setGameWindow( GameWindow *win) { m_win = win; }; inline void AnimateWindow::setAnimType( AnimTypes animType) { m_animType = animType; }; inline void AnimateWindow::setDelay( UnsignedInt delay) { m_delay = delay; }; inline void AnimateWindow::setVel( Coord2D vel) { m_vel = vel; }; inline void AnimateWindow::setStartTime( UnsignedInt t ) { m_startTime = t; } inline void AnimateWindow::setEndTime( UnsignedInt t ) { m_endTime = t; } inline void AnimateWindow::setFinished( Bool finished) { m_isFinished = finished; }; inline Bool AnimateWindow::isFinished( void ) { return m_isFinished; }; inline void AnimateWindow::setNeedsToFinish( Bool needsToFinish) { m_needsToFinish = needsToFinish; }; inline Bool AnimateWindow::needsToFinish( void ) { return m_needsToFinish; }; inline Bool AnimateWindowManager::isFinished( void ) { return !m_needsUpdate; }; inline Bool AnimateWindowManager::isReversed( void ) { return m_reverse; }; inline Bool AnimateWindowManager::isEmpty( void ){return (m_winList.size() == 0 && m_winMustFinishList.size() == 0); } //----------------------------------------------------------------------------- // EXTERNALS ////////////////////////////////////////////////////////////////// //----------------------------------------------------------------------------- #endif // __ANIMATEWINDOWMANAGER_H_