Background2D.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears 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.
 */
 
#pragma once
 
#include <OgreHardwareVertexBuffer.h>
#include <OgreRenderQueueListener.h>
#include <OgreRoot.h>
#include "map/VGearsBackground2DFile.h"
#include "Background2DAnimation.h"
#include "Entity.h"
#include "ScriptManager.h"
 
class Background2D : public Ogre::RenderQueueListener{
 
    public:
 
        typedef VGears::Blending  Blending;
 
        enum SCROLL_TYPE{
 
            NONE,
 
            LINEAR,
            SMOOTH
        };
 
        Background2D();
 
        virtual ~Background2D();
 
        void InputDebug(const VGears::Event& event);
 
        void Hide();
 
        void Show();
 
        void Update();
 
        void UpdateDebug();
 
        void OnResize();
 
        void Clear();
 
        void ScriptAutoScrollToEntity(Entity* entity);
 
        Entity* GetAutoScrollEntity() const;
 
        void ScriptScrollToPlayer(const SCROLL_TYPE type, const unsigned int seconds);
 
        void ScriptScrollToPosition(
          const float x, const float y, const SCROLL_TYPE type, const float seconds
        );
 
        int ScriptScrollSync();
 
        void ScriptOffset(const float x, const float y);
 
        void UnsetScroll();
 
        const Ogre::Vector2& GetScrollPositionStart() const;
 
        const Ogre::Vector2& GetScrollPositionEnd() const;
 
        SCROLL_TYPE GetScrollType() const;
 
        float GetScrollSeconds() const;
 
        void SetScrollCurrentSeconds(const float seconds);
 
        float GetScrollCurrentSeconds() const;
 
        void SetScreenScroll(const Ogre::Vector2& position);
 
        const Ogre::Vector2 GetScreenScroll() const;
 
        void SetScroll(const Ogre::Vector2& position);
 
        const Ogre::Vector2& GetScroll() const;
 
        void SetImage( const Ogre::String& image );
 
        void SetRange(const int min_x, const int min_y, const int max_x, const int max_y);
 
        void SetRange(const Ogre::Vector4& range);
 
        void AddTile(
          const int x, const int y, const int width, const int height, const float depth,
          const float u1, const float v1, const float u2, const float v2, const Blending blending
        );
 
        void AddTile(
          const Ogre::Vector2& destination, const int width, const int height,
          const float depth, const Ogre::Vector4& uv, const Blending blending
        );
 
        void AddTile(const VGears::Tile& tile);
 
        void UpdateTileUV(
          const unsigned int tile_id, const float u1, const float v1, const float u2, const float v2
        );
 
        void AddAnimation(Background2DAnimation* animation);
 
        void PlayAnimation(const Ogre::String& animation, const Background2DAnimation::State state);
 
        void ScriptPlayAnimationLooped(const char* name);
 
        void ScriptPlayAnimationOnce(const char* name);
 
        int ScriptAnimationSync(const char* name);
 
        void renderQueueEnded(
          Ogre::uint8 queueGroupId, const Ogre::String& invocation, bool& repeatThisInvocation
        ) override;
 
        struct Tile{
 
            int x;
 
            int y;
 
            int width;
 
            int height;
 
            size_t start_vertex_index;
 
            Blending blending;
        };
 
        typedef std::vector<Tile> TileList;
 
        virtual void load(const VGears::Background2DFilePtr &background);
 
    protected:
 
        virtual void load(const VGears::Background2DFile::TileList &tiles);
 
        virtual void load( const size_t tile_index, const VGears::AnimationMap &animations);
 
        virtual void applyScroll();
 
        virtual void calculateScreenScale();
 
 
        virtual void virtualScreenToWorldSpace(Ogre::Vector2 &pos) const;
 
        enum{
 
            TILE_VERTEX_COUNT = 6,
 
            TILE_VERTEX_INDEX_SIZE = TILE_VERTEX_COUNT + 3
        };
 
    private:
 
        void CreateVertexBuffers();
 
        void DestroyVertexBuffers();
 
        Ogre::SceneManager* scene_manager_;
 
        Ogre::RenderSystem* render_system_;
 
        TileList tiles_;
 
        Ogre::RenderOperation alpha_render_op_;
 
        Ogre::HardwareVertexBufferSharedPtr alpha_vertex_buffer_;
 
        unsigned int alpha_max_vertex_count_;
 
        Ogre::MaterialPtr alpha_material_;
 
        Ogre::RenderOperation add_render_op_;
 
        Ogre::HardwareVertexBufferSharedPtr add_vertex_buffer_;
 
        unsigned int add_max_vertex_count_;
 
        Ogre::MaterialPtr add_material;
 
        Ogre::RenderOperation subtract_render_op_;
 
        Ogre::HardwareVertexBufferSharedPtr subtract_vertex_buffer_;
 
        unsigned int subtract_max_vertex_count_;
 
        Ogre::MaterialPtr subtract_material_;
 
        Entity* scroll_entity_;
 
        Ogre::Vector2 scroll_position_start_;
 
        Ogre::Vector2 scroll_position_end_;
 
        SCROLL_TYPE scroll_type_;
 
        float scroll_seconds_;
 
        float scroll_current_seconds_;
 
        std::vector<ScriptId> scroll_sync_;
 
        Ogre::Vector2 position_;
 
        Ogre::Vector2 offset_;
 
        Ogre::Vector2 position_real_;
 
        Ogre::Real screen_scale_;
 
        Ogre::Vector2 screen_proportion_;
 
        Ogre::Vector2 virtual_screen_size_;
 
        Ogre::AxisAlignedBox range_;
 
        struct AnimationPlayed{
 
            Ogre::String name;
 
            std::vector<ScriptId> sync;
 
            Background2DAnimation::State state;
        };
 
        std::vector<AnimationPlayed> animation_played_;
 
        std::vector<Background2DAnimation*> animations_;
};