/*************************************************************************** * Copyright (C) 2005-2019 by the FIFE team * * http://www.fifengine.net * * This file is part of FIFE. * * * * FIFE is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This library 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ #ifndef FIFE_VIEW_VISUAL_H #define FIFE_VIEW_VISUAL_H // Standard C++ library includes // 3rd party library includes // FIFE includes // These includes are split up in two parts, separated by one empty line // First block: files included from the FIFE root src directory // Second block: files included from the same folder #include "model/metamodel/ivisual.h" #include "util/math/angles.h" #include "util/structures/rect.h" #include "video/animation.h" #include "video/color.h" namespace FIFE { class Object; class Instance; class Action; class Image; class OverlayColors { public: /** Constructors */ OverlayColors(); OverlayColors(ImagePtr image); OverlayColors(AnimationPtr animation); /** Destructor */ ~OverlayColors(); void setColorOverlayImage(ImagePtr image); ImagePtr getColorOverlayImage(); void setColorOverlayAnimation(AnimationPtr animation); AnimationPtr getColorOverlayAnimation(); void changeColor(const Color& source, const Color& target); const std::map& getColors(); void resetColors(); private: std::map m_colorMap; ImagePtr m_image; AnimationPtr m_animation; }; /** Base class for all 2 dimensional visual classes * Visual classes are extensions to visualize the stuff in model (e.g. instances) * The reason why its separated is to keep model view-agnostic, so that we could * have e.g. 3d, 2d and character based visualizations to the same data */ class Visual2DGfx: public IVisual { public: /** Destructor */ virtual ~Visual2DGfx(); protected: /** Constructor */ Visual2DGfx(); }; /** Object visual contains data that is needed for visualizing objects */ class ObjectVisual: public Visual2DGfx { public: /** Constructs and assigns it to the passed item */ static ObjectVisual* create(Object* object); /** Destructor */ virtual ~ObjectVisual(); /** Adds new static image with given angle (degrees) * Static images are used in case there are no actions active in the instance * There can be several static images for different angles, that are used in * case view / layer is rotated * In case there are no exact matches for current view angles, closest one is used * @param angle angle for image. 0 degrees starts from right and turns counter-clockwise * (normal math notation) @param image_index index of image to use for given degress */ void addStaticImage(uint32_t angle, int32_t image_index); /** Returns closest matching static image for given angle * @return id for static image */ int32_t getStaticImageIndexByAngle(int32_t angle); /** Adds new static color overlay with given angle (degrees). */ void addStaticColorOverlay(uint32_t angle, const OverlayColors& colors); /** Returns closest matching static color overlay for given angle * @return pointer to OverlayColor class */ OverlayColors* getStaticColorOverlay(int32_t angle); /** Removes a static color overlay with given angle (degrees). */ void removeStaticColorOverlay(int32_t angle); /** Returns closest matching image angle for given angle * @return closest matching angle */ int32_t getClosestMatchingAngle(int32_t angle); /** Returns list of available static image angles for this object */ void getStaticImageAngles(std::vector& angles); /** Indicates if there exists a color overlay. */ bool isColorOverlay() { return !m_colorOverlayMap.empty(); } private: /** Constructor */ ObjectVisual(); type_angle2id m_angle2img; typedef std::map AngleColorOverlayMap; AngleColorOverlayMap m_colorOverlayMap; type_angle2id m_map; }; /** Instance visual contains data that is needed to visualize the instance on screen */ class InstanceVisual: public Visual2DGfx { public: /** Constructs and assigns it to the passed item */ static InstanceVisual* create(Instance* instance); /** Destructor */ virtual ~InstanceVisual(); /** Sets transparency value for object to be visualized * @param transparency set the transparency */ void setTransparency(uint8_t transparency); /** Gets current transparency value (0-255) * @return current transparency value */ uint8_t getTransparency(); /** Sets visibility value for object to be visualized * @param visible is object visible or not */ void setVisible(bool visible); /** Is instance visible or not * @return is instance visible or not */ bool isVisible(); /** Sets stack position of the instance * Stack position is used to define the order in which instances residing * in the same location are drawn * @param stackposition new stack position */ void setStackPosition(int32_t stackposition); /** Gets current stack position of instance * @return current stack position */ int32_t getStackPosition(); private: /** Constructor */ InstanceVisual(); uint8_t m_transparency; bool m_visible; int32_t m_stackposition; Instance* m_instance; }; /** Action visual contains data that is needed to visualize different actions on screen */ class ActionVisual: public Visual2DGfx { public: /** Constructs and assigns it to the passed item */ static ActionVisual* create(Action* action); /** Destructor */ virtual ~ActionVisual(); /** Adds new animation with given angle (degrees) */ void addAnimation(uint32_t angle, AnimationPtr animationptr); /** Gets index to animation closest to given angle * @return animation index, -1 if no animations available */ AnimationPtr getAnimationByAngle(int32_t angle); /** Adds new animation overlay with given angle (degrees) and order */ void addAnimationOverlay(uint32_t angle, int32_t order, AnimationPtr animationptr); /** Gets map with animations closest to given angle * @return animation map */ std::map getAnimationOverlay(int32_t angle); /** Removes animation overlay with given angle (degrees) and order */ void removeAnimationOverlay(uint32_t angle, int32_t order); /** Adds new color overlay with given angle (degrees) and colors. * Note: Works only for single animations not for AnimationOverlays. (order is missing) */ void addColorOverlay(uint32_t angle, const OverlayColors& colors); /** Gets OverlayColors for given angle (degrees). * @return pointer to OverlayColors or Null */ OverlayColors* getColorOverlay(int32_t angle); /** Removes color overlay with given angle (degrees). */ void removeColorOverlay(int32_t angle); /** Adds new color overlay with given angle (degrees), order and colors. * Note: Works only for AnimationOverlays. */ void addColorOverlay(uint32_t angle, int32_t order, const OverlayColors& colors); /** Gets OverlayColors for given angle (degrees) and order. * @return pointer to OverlayColors or Null */ OverlayColors* getColorOverlay(int32_t angle, int32_t order); /** Removes color overlay with given angle (degrees) and order. */ void removeColorOverlay(int32_t angle, int32_t order); /** Returns list of available angles for this Action */ void getActionImageAngles(std::vector& angles); /** Convertes animations and optional color overlay to default animation overlay. * The default order value for both is 0. The old data remain, so if you remove the animation overlay * the old plain animations and colors be used again. */ void convertToOverlays(bool color); /** Returns true if it exists a animation overlay, otherwise false. */ bool isAnimationOverlay() { return !m_animationOverlayMap.empty(); } /** Returns true if it exists a color overlay, otherwise false. */ bool isColorOverlay() { return !m_colorOverlayMap.empty() || !m_colorAnimationOverlayMap.empty(); } private: /** Constructor */ ActionVisual(); // animations associated with this action typedef std::map AngleAnimationMap; AngleAnimationMap m_animation_map; typedef std::map > AngleAnimationOverlayMap; AngleAnimationOverlayMap m_animationOverlayMap; typedef std::map AngleColorOverlayMap; AngleColorOverlayMap m_colorOverlayMap; typedef std::map > AngleColorAnimationOverlayMap; AngleColorAnimationOverlayMap m_colorAnimationOverlayMap; //need this map to use the getIndexByAngle() function in angles.h type_angle2id m_map; }; } #endif