spritepool.h

Go to the documentation of this file.

/*
 * Copyright (c) since 2021 by PopolonY2k and Leidson Campos A. Ferreira
 * 
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef __SPRITEPOOL_H__
#define __SPRITEPOOL_H__
 
#include <deque>
#include <map>
#include <optional>
#include <string>
#include <unordered_map>
#include "engine/spritehandle.h"
#include "sprite/sprite.h"
#include "canvas/texturecanvas.h"
 
 
namespace Scarab  {
    namespace Engine  {
 
        class SpritePool  {
 
            struct stNativeTextureSize  {
                std :: optional<int>  nWidth;
                std :: optional<int>  nHeight;
            };
 
            struct stSlot  {
                SunLight :: Sprite :: Sprite                          sprite;
                std :: map<int, SunLight :: Canvas :: TextureCanvas>  textures;
                /*
                 * Sprite::AddTextureSequence unconditionally aliases a
                 * TextureCanvas's own dimension to the owning Sprite's shared
                 * dimension the first time it's called for that texture object
                 * - fine for a fresh sprite, but means a reconfigured (recycled)
                 * texture's GetDimension2D() no longer reflects it's own natural
                 * pixel size, it reflects whatever the sprite's size happened to
                 * be left at. Cache each sequence's true natural size the first
                 * time it's seen (while still reliable) so later reconfigures on
                 * a recycled slot don't compute a frame width from stale/aliased
                 * data.
                 */
                std :: map<int, stNativeTextureSize>                  nativeTextureSizes;
                std :: string                                         strTypeTag;
                uint16_t                                              nGeneration;
                bool                                                   bInUse;
            };
 
            typedef std :: deque<uint32_t>  __FreeList;
 
            /*
             * std::deque (not std::vector) so growing the pool never invalidates
             * references/pointers into slots already handed out.
             */
            std :: deque<stSlot>                              m_Slots;
            std :: unordered_map<std :: string, __FreeList>   m_FreeListsByType;
 
            public:
 
            SpritePool( void );
            ~SpritePool( void );
 
            bool RegisterType( const std :: string &strTypeTag, uint32_t nCapacity );
            SpriteHandle Acquire( const std :: string &strTypeTag );
            bool Release( SpriteHandle handle );
            SunLight :: Sprite :: Sprite* Resolve( SpriteHandle handle );
            SunLight :: Canvas :: TextureCanvas* GetTexture( SpriteHandle handle, int nSequenceId );
            SunLight :: Canvas :: TextureCanvas* GetOrCreateTexture( SpriteHandle handle, int nSequenceId );
            int GetOrCacheNativeWidth( SpriteHandle handle, int nSequenceId, int nCurrentWidth );
            int GetOrCacheNativeHeight( SpriteHandle handle, int nSequenceId, int nCurrentHeight );
            void UpdateAll( void );
            void Clear( void );
        };
    }
}
 
#endif  /* __SPRITEPOOL_H__ */