render_stack.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <string>
#include <d2d1_1.h>
#include <dwrite.h>
#include <Strings/components/utils/saferelease/saferelease.h>
 
#include "res/resource.h"
#include "components/content/fonts/fonts.h"
 
//stack type definitions
#define STACKTYPE_GENERIC StackType::Generic
#define STACKTYPE_IMGUI StackType::ImGUI
#define STACKTYPE_RECT StackType::ST_Rectangle
#define STACKTYPE_ROUNDED_RECT StackType::RoundedRect
#define STACKTYPE_DWTEXT StackType::DWText
#define STACKTYPE_ELLIPSE StackType::ST_Ellipse
#define STACKTYPE_LINE StackType::Line
#define STACKTYPE_BITMAP StackType::Bitmap
#define STACKTYPE_GEOMETRY StackType::Geometry
#define STACKTYPE_GLYPHRUN StackType::GlyphRun
#define STACKTYPE_FILLEDMESH StackType::FilledMesh
#define STACKTYPE_BITMAP_TEXT StackType::BitmapText
#define STACKTYPE_FPS_COUNTER StackType::FPSCounter
#define STACKTYPE_CONSOLE StackType::Console
#define STACKTYPE_STATS StackType::Stats
#define STACKTYPE_DEBUG_MENU StackType::DebugMenu
#define STACKTYPE_TEXT StackType::Text
 
 
//stack object display mode definitions
#define DRAWMODE_FILL StackItemDrawMode::Fill
#define DRAWMODE_OUTLINE StackItemDrawMode::Outline
#define DRAWMODE_BOTH StackItemDrawMode::Both
 
#define DEFAULT_DRAWMODE DRAWMODE_OUTLINE
 
/*
Geometry
GlyphRun
FilledMesh
*/
 
#ifndef BLAM
#define BLAM
#endif
 
#define AREA_DEBUG_THICKNESS 2
 
enum StackType
{
    // Core types
    Generic,       
    ImGUI,         
 
    // Direct2D Primitives
    ST_Rectangle,  
    RoundedRect,   
    DWText,        
    ST_Ellipse,    
    Line,          
    Bitmap,        
    Geometry,      
    GlyphRun,      
    FilledMesh,    
 
    // Custom primitives
    BitmapText,    
    Text,          
 
    // Widgets
    FPSCounter,    
    Console,       
    Stats,         
    DebugMenu      
};
 
enum StackItemDrawMode
{
    Fill,    
    Outline, 
    Both     
};
 
namespace BlamRendering
{
    namespace RenderStack
    {
        class StackObjectBase;
 
        BLAM int                AddToStack(std::string id, StackObjectBase* object);
 
        BLAM void               RemoveFromStack(std::string id);
 
        BLAM void               RemoveFromStack(int index);
 
        BLAM StackObjectBase*   GetStackItem(std::string id);
 
        BLAM bool               ContainsImGUIObject();
 
        BLAM void               Cleanup();
        
        BLAM std::vector<StackObjectBase*>* GetStack();
 
        BLAM std::string GetStackTypeLabel(StackType type);
 
        BLAM std::string GetDrawModeLabel(StackItemDrawMode type);
 
        BLAM std::vector<StackType> GetStackTypesList();
 
        BLAM std::vector<StackItemDrawMode> GetDrawModesList();
 
        class StackObjectBase
        {
            public:
                StackObjectBase()
                {
                    //default area
                    area.top = 0;
                    area.left = 0;
                    area.bottom = 100;
                    area.right = 100;
 
                    //default color
                    color.r = 1;
                    color.g = 1;
                    color.b = 1;
                    color.a = 1;
 
                    //default size
                    width = 100;
                    height = 100;
 
                    unique_id = "item_" + std::to_string(rand());
                }
 
                ~StackObjectBase() {};
 
                virtual void Draw() {};
 
                virtual void ShowImPropertyEditor() {};
 
                virtual void HandleResize() {};
 
                void SetArea(float new_area[4]);
 
                void SetArea(float top, float bottom, float left, float right);
 
                void SetArea(D2D1_RECT_F new_area);
 
                void SetColor(float new_color[3]);
 
                void SetColor(float r, float g, float b);
 
                void SetColor(float r, float g, float b, float a);
 
                void SetColor(D2D1::ColorF color);
 
                void SetZOrder(int z);
 
                void SetTranslation(float new_x, float new_y);
 
                void PokeTranslation();
 
                void SetSize(float new_width, float new_height);
 
                void PokeSize();
 
                void ValidateSizeAndTranslation();
 
                std::string GetType();
 
                std::string GetDrawModeLabel();
 
                //data
                D2D1_RECT_F area;    
                D2D1_COLOR_F color;  
                int z_order = 0;     
                StackType type_label = STACKTYPE_GENERIC;        
                StackItemDrawMode draw_mode = DEFAULT_DRAWMODE;  
 
                bool visible = true;  
 
                float x = 0;         
                float y = 0;         
                float width = 100;   
                float height = 100;  
                
                std::string unique_id = "";  
        };
 
        class ImGUIObject : public StackObjectBase
        {
            public:
                ImGUIObject() 
                {
                    type_label = STACKTYPE_IMGUI;
                }
 
                ~ImGUIObject() {};
 
                void Draw();
 
                void ShowImPropertyEditor();
        };
 
        class Rectangle : public StackObjectBase
        {
            public:
                Rectangle()
                {
                    type_label = STACKTYPE_RECT;
 
                    //default fill color
                    fill_color.r = 1;
                    fill_color.g = 1;
                    fill_color.b = 1;
                    fill_color.a = 1;
 
                    //unique_id = "item_" + std::to_string(rand());
                }
 
                ~Rectangle() {}
                void Draw();
                void ShowImPropertyEditor();
 
                void SetThickness(float new_thickness);
 
                //data
                float thickness = 1;      
                D2D1_COLOR_F fill_color;  
        };
 
        class RoundedRectangle : public StackObjectBase
        {
        public:
            RoundedRectangle()
            {
                type_label = STACKTYPE_ROUNDED_RECT;
 
                //default fill color
                fill_color.r = 1;
                fill_color.g = 1;
                fill_color.b = 1;
                fill_color.a = 1;
 
                //default rounded rect radius and area
                rounded_rect.radiusX = 10;
                rounded_rect.radiusY = 10;
                rounded_rect.rect = area;
            }
 
            ~RoundedRectangle() {}
            void Draw();
            void ShowImPropertyEditor();
 
            void SetThickness(float new_thickness);
 
            void PokeRoundedRectArea();
 
            //data
            float thickness = 1;      
            D2D1_COLOR_F fill_color;  
            D2D1_ROUNDED_RECT rounded_rect;  
        };
 
        class Ellipse : public StackObjectBase
        {
        public:
            Ellipse()
            {
                type_label = STACKTYPE_ELLIPSE;
 
                //default fill color
                fill_color.r = 1;
                fill_color.g = 1;
                fill_color.b = 1;
                fill_color.a = 1;
 
                //default ellipse placement and size
                ellipse.point.x = x;
                ellipse.point.y = y;
 
                ellipse.radiusX = 100;
                ellipse.radiusY = 100;
            }
 
            ~Ellipse() {}
            void Draw();
            void ShowImPropertyEditor();
 
            void SetThickness(float new_thickness);
 
            void PokeEllipseTranslation();
 
            //data
            float thickness = 1;      
            D2D1_COLOR_F fill_color;  
            D2D1_ELLIPSE ellipse;     
        };
 
        class Bitmap : public StackObjectBase
        {
        public:
            Bitmap()
            {
                type_label = STACKTYPE_BITMAP;
            }
 
            ~Bitmap() {}
            void Draw();
            void ShowImPropertyEditor();
 
            //data
            int resource_id = IDB_THEME_DEFAULT_ICON; 
            const char* resource_type = "PNG";        
        };
 
        class Line : public StackObjectBase
        {
        public:
            Line()
            {
                type_label = STACKTYPE_LINE;
 
                //default start/end points
                start_point.x = 50;
                start_point.y = 50;
                
                end_point.x = 250;
                end_point.y = 250;
 
                //default zone color
                zone_color.r = 1;
                zone_color.g = 0;
                zone_color.b = 0;
                zone_color.a = 1;
            }
 
            ~Line() {}
            void Draw();
            void ShowImPropertyEditor();
 
            void PokeLineTranslation();
 
            void SetThickness(float new_thickness);
 
            //data
            D2D1_POINT_2F start_point;  
            D2D1_POINT_2F end_point;    
 
            float thickness = 1;        
            
            bool show_zone = false;     
            D2D1_COLOR_F zone_color;    
            float zone_thickness = 1;   
        };
 
        class DWText : public StackObjectBase
        {
        public:
            DWText()
            {
                //set type so we can fetch it elsewhere
                type_label = STACKTYPE_DWTEXT;
 
                //default zone color
                zone_color.r = 1;
                zone_color.g = 0;
                zone_color.b = 0;
                zone_color.a = 1;
            }
 
            ~DWText() {};
            void Draw();
            void ShowImPropertyEditor();
 
            void SetText(std::string new_text);
 
            void SetFont(std::string new_font_name);
 
            void ShowZoneEdge(bool show);
            
            void SetZoneColor(float new_color[3]);
 
            void SetZoneColor(float r, float g, float b);
 
            void SetZoneColor(float r, float g, float b, float a);
 
            void SetZoneColor(D2D1::ColorF color);
 
            void SetFontSize(float new_size);
 
            void SetZoneThickness(float new_thickness);
 
            //data
            std::wstring text = L"generic text";       
            std::wstring font_name = L"Comic Sans MS"; 
            float font_size = 12;                      
 
            bool show_zone = false;    
            D2D1_COLOR_F zone_color;   
            float zone_thickness = 1;  
 
            bool use_engine_font = false;            
            std::string engine_font_id = "";         
            IDWriteFontCollection* font_collection;  
 
            // Text buffers for ImGUI property view
            char text_buffer[1024] = "";  
            char font_buffer[256] = "";   
 
            bool auto_calculate_area = false;  
        };
 
        class StackGroup : public StackObjectBase
        {
            StackGroup()
            {
 
            }
 
            ~StackGroup() {};
            void Draw();
            void ShowImPropertyEditor();
        };
 
        class BitmapText : public StackObjectBase
        {
        public:
            BitmapText()
            {
                type_label = STACKTYPE_BITMAP_TEXT;
 
                //default shadow color
                shadow_color.r = 0;
                shadow_color.g = 0;
                shadow_color.b = 0;
                shadow_color.a = 1;
 
                zone_color.r = 1;
                zone_color.g = 0;
                zone_color.b = 0;
                zone_color.a = 1;
 
                text_bitmap = NULL;
            }
 
            ~BitmapText()
            {
                SafeRelease(&text_bitmap);
            }
 
            void Draw();
            void ShowImPropertyEditor();
 
            void updateCachedProperties();
 
            bool hasAnyPropertyChanged();
 
            std::string font_id = "undefined"; 
 
            std::string text = "abba";  
 
            //drop shadow
            int shadow_x = 1;          
            int shadow_y = 1;          
            D2D1_COLOR_F shadow_color; 
            bool use_shadow = false;   
            
            bool show_zone = false;    
            D2D1_COLOR_F zone_color;   
            float zone_thickness = 1;  
 
            ID2D1Bitmap* text_bitmap;  
            D2D1_RECT_F text_area;     
 
            int bitmap_width = 0;   
            int bitmap_height = 0;  
 
            bool force_regenerate = false;  
 
            bool currently_locked = false;  
 
            bool replace_color_codes = false; 
 
            // Text buffers for ImGUI property view
            char text_buffer[1024] = "";  
            char font_buffer[256] = "";   
 
            // Cached properties
            std::string c_font;  
            std::string c_text;  
            float c_x;  
            float c_y;  
            D2D1_COLOR_F c_color;  
            bool c_use_shadow;  
            int c_shadow_x;  
            int c_shadow_y;  
            D2D1_COLOR_F c_shadow_color;  
            bool c_show_zone;  
            D2D1_COLOR_F c_zone_color;  
            float c_zone_thickness;  
            int c_bitmap_width;    
            int c_bitmap_height;   
            float c_scale_factor;  
            bool c_replace_color_codes; 
        };
 
        class Text : public StackObjectBase
        {
        private:
            BitmapText* bitmap_text = NULL;  
            DWText* dw_text = NULL;          
            DWText* dw_text_shadow = NULL;   
 
            // Font data
            Blam::Content::Fonts::Font* font = NULL;  
            bool font_exists = false;                 
        public:
            Text();
 
            ~Text();
 
            void SetText(std::string text);
 
            void UpdateAllProperties();
 
            void SetFont(std::string new_font_id);
 
            std::string GetFont();
 
            void RefreshTranslation();
 
            void Draw();
            void ShowImPropertyEditor();
 
            // Font properties
            std::string text = "the quick brown fox jumped over the lazy dog";  
            float font_size = 12.0f;  
 
            // Text shadow properties
 
            int shadow_x = 1;          
            int shadow_y = 1;          
            D2D1_COLOR_F shadow_color; 
            bool use_shadow = false;   
 
            // Zone properties
            bool show_zone = false;    
            D2D1_COLOR_F zone_color;   
            float zone_thickness = 1;  
 
            // Background
            bool use_background = false;  
            D2D1_COLOR_F bg_color;        
 
            // Text buffers for ImGUI property view
            char text_buffer[1024] = "";  
            char font_buffer[256] = "";   
 
            bool auto_calculate_area = false;  
        };
    }
}