Subversion Repositories Games.Descent

/*

 * Portions of this file are copyright Rebirth contributors and licensed as

 * described in COPYING.txt.

 * Portions of this file are copyright Parallax Software and licensed

 * according to the Parallax license below.

 * See COPYING.txt for license details.

THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX

SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO

END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A

ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS

IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS

SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE

FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE

CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS

AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.

COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.

*/

/*

 *

 * Definitions for graphics lib.

 *

 */

#pragma once

#include <cassert>

#include "fwd-gr.h"

#include "pstypes.h"

#include "maths.h"

#include "palette.h"

#include "dxxsconf.h"

#include "dsx-ns.h"

#include "fmtcheck.h"

#include "pack.h"

#include <array>

struct grs_point

{

        fix x,y;

};

struct grs_bitmap : prohibit_void_ptr<grs_bitmap>

{

        uint16_t bm_x,bm_y; // Offset from parent's origin

        uint16_t bm_w,bm_h; // width,height

private:

        uint8_t bm_type;

        uint8_t bm_flags;

public:

        uint8_t get_type() const

        {

                return bm_type;

        }

        void set_type(uint8_t t)

        {

                bm_type = t;

        }

        uint8_t get_flags() const

        {

                return bm_flags;

        }

        uint8_t get_flag_mask(const uint8_t mask) const

        {

                return get_flags() & mask;

        }

        void set_flags(const uint8_t f)

        {

                bm_flags = f;

        }

        void clear_flags()

        {

                set_flags(0);

        }

        void set_flag_mask(const bool set, const uint8_t mask)

        {

                const auto f = get_flags();

                set_flags(set ? f | mask : f & ~mask);

        }

        void add_flags(const uint8_t f)

        {

                bm_flags |= f;

        }

                            // bit 1 on means it has supertransparency

                            // bit 2 on means it doesn't get passed through lighting.

        short   bm_rowsize; // unsigned char offset to next row

        std::array<fix, 3> avg_color_rgb; // same as above but real rgb value to be used to textured objects that should emit light

        union {

                const color_palette_index *bm_data;     // ptr to pixel data...

                                        //   Linear = *parent+(rowsize*y+x)

                                        //   ModeX = *parent+(rowsize*y+x/4)

                                        //   SVGA = *parent+(rowsize*y+x)

                color_palette_index *bm_mdata;

        };

        const color_palette_index *get_bitmap_data() const { return bm_data; }

        color_palette_index *get_bitmap_data() { return bm_mdata; }

        struct grs_bitmap  *bm_parent;

#if DXX_USE_OGL

        struct ogl_texture *gltexture;

#else

        uint8_t avg_color;  //  Average color of all pixels in texture map.

#endif /* def OGL */

};

struct grs_canvas : prohibit_void_ptr<grs_canvas>

{

        ~grs_canvas()

        {

                /* `grd_curcanv` points to the currently active canvas.  If it

                 * points to `this` when the destructor runs, then any further

                 * attempts to use the referenced canvas will access an

                 * out-of-scope variable, leading to undefined behavior.  Assert

                 * that `grd_curcanv` does not point to the expiring variable so

                 * that potential misuses are detected before they manifest as

                 * undefined behavior.

                 *

                 * If you get an assertion failure here, enable

                 * `DXX_DEBUG_CURRENT_CANVAS_ORIGIN` to trace where the canvas

                 * was most recently set.

                 *

                 * Eventually, `grd_curcanv` will be removed and this test will

                 * become obsolete.

                 */

                assert(this != grd_curcanv);

                /* If the canvas is reset before next use, then no crash.

                 * If the canvas is not reset, then crash instead of accessing

                 * freed memory.

                 */

                if (grd_curcanv == this)

                        grd_curcanv = nullptr;

        }

        grs_bitmap  cv_bitmap;      // the bitmap for this canvas

        const grs_font *  cv_font;        // the currently selected font

        short       cv_font_fg_color;   // current font foreground color (-1==Invisible)

        short       cv_font_bg_color;   // current font background color (-1==Invisible)

        unsigned cv_fade_level;  // transparency level

};

//=========================================================================

// System functions:

// setup and set mode. this creates a grs_screen structure and sets

// grd_curscreen to point to it.  grs_curcanv points to this screen's

// canvas.  Saves the current VGA state and screen mode.

#ifdef __cplusplus

union screen_mode

{

private:

        uint32_t wh;

public:

        struct {

                uint16_t width, height;

        };

        bool operator==(const screen_mode &rhs)

        {

                return wh == rhs.wh;

        }

        bool operator!=(const screen_mode &rhs)

        {

                return !(*this == rhs);

        }

        screen_mode() = default;

        constexpr screen_mode(uint16_t &&w, uint16_t &&h) :

                width(w), height(h)

        {

        }

};

static inline uint16_t SM_W(const screen_mode &s)

{

        return s.width;

}

static inline uint16_t SM_H(const screen_mode &s)

{

        return s.height;

}

class grs_screen : prohibit_void_ptr<grs_screen>

{    // This is a video screen

        screen_mode sc_mode;

public:

        grs_canvas  sc_canvas;  // Represents the entire screen

        fix     sc_aspect;      //aspect ratio (w/h) for this screen

        uint16_t get_screen_width() const

        {

                return SM_W(sc_mode);

        }

        uint16_t get_screen_height() const

        {

                return SM_H(sc_mode);

        }

        screen_mode get_screen_mode() const

        {

                return sc_mode;

        }

        void set_screen_width_height(uint16_t w, uint16_t h)

        {

                sc_mode.width = w;

                sc_mode.height = h;

        }

};

//=========================================================================

// Canvas functions:

// Makes a new canvas. allocates memory for the canvas and its bitmap,

// including the raw pixel buffer.

namespace dcx {

struct grs_main_canvas : grs_canvas

{

        ~grs_main_canvas();

};

// Creates a canvas that is part of another canvas.  this can be used to make

// a window on the screen.  the canvas structure is malloc'd; the address of

// the raw pixel data is inherited from the parent canvas.

struct grs_subcanvas : grs_canvas {};

// Free the bitmap and its pixel data

class grs_main_bitmap : public grs_bitmap

{

public:

        grs_main_bitmap();

        grs_main_bitmap(const grs_main_bitmap &) = delete;

        grs_main_bitmap &operator=(const grs_main_bitmap &) = delete;

        grs_main_bitmap(grs_main_bitmap &&r) :

                grs_bitmap(std::move(static_cast<grs_bitmap &>(r)))

        {

                r.bm_data = nullptr;

#if DXX_USE_OGL

                r.gltexture = nullptr;

#endif

        }

        grs_main_bitmap &operator=(grs_main_bitmap &&r)

        {

                if (this == &r)

                        return *this;

                reset();

                grs_bitmap::operator=(std::move(static_cast<grs_bitmap &>(r)));

                r.bm_data = nullptr;

#if DXX_USE_OGL

                r.gltexture = nullptr;

#endif

                return *this;

        }

        ~grs_main_bitmap()

        {

                reset();

        }

        void reset()

        {

                gr_free_bitmap_data(*this);

        }

};

// Free the bitmap, but not the pixel data buffer

class grs_subbitmap : public grs_bitmap

{

};

//font structure

struct grs_font : public prohibit_void_ptr<grs_font>

{

        int16_t     ft_w;           // Width in pixels

        int16_t     ft_h;           // Height in pixels

        int16_t     ft_flags;       // Proportional?

        int16_t     ft_baseline;    //

        uint8_t     ft_minchar;     // First char defined by this font

        uint8_t     ft_maxchar;     // Last char defined by this font

        std::array<char, 13> ft_filename;

        const uint8_t *ft_data = nullptr;        // Ptr to raw data.

        const uint8_t *const *ft_chars = nullptr;       // Ptrs to data for each char (required for prop font)

        const int16_t *ft_widths = nullptr;      // Array of widths (required for prop font)

        const uint8_t *ft_kerndata = nullptr;    // Array of kerning triplet data

        std::unique_ptr<uint8_t[]> ft_allocdata;

#if DXX_USE_OGL

        // These fields do not participate in disk i/o!

        std::unique_ptr<grs_bitmap[]> ft_bitmaps;

        grs_main_bitmap ft_parent_bitmap;

#endif /* def OGL */

};

}

static inline void gr_set_bitmap_flags(grs_bitmap &bm, uint8_t flags)

{

        bm.set_flags(flags);

}

static inline void gr_set_transparent(grs_bitmap &bm, bool bTransparent)

{

        bm.set_flag_mask(bTransparent, BM_FLAG_TRANSPARENT);

}

namespace dcx {

static inline void gr_set_font_fg_color(grs_canvas &canvas, int fg_color)

{

        canvas.cv_font_fg_color = fg_color;

}

static inline void gr_set_font_fg_color(grs_canvas &canvas, color_palette_index fg_color)

{

        canvas.cv_font_fg_color = static_cast<int>(fg_color);

}

static inline void gr_set_font_bg_color(grs_canvas &canvas, int bg_color)

{

        canvas.cv_font_bg_color = bg_color;

}

static inline void gr_set_font_bg_color(grs_canvas &canvas, color_palette_index bg_color)

{

        canvas.cv_font_bg_color = static_cast<int>(bg_color);

}

#define gr_set_fontcolor(C,F,B) \

        ( DXX_BEGIN_COMPOUND_STATEMENT {        \

                auto &gr_set_fontcolor = C;     \

                gr_set_font_fg_color(gr_set_fontcolor, F);      \

                gr_set_font_bg_color(gr_set_fontcolor, B);      \

                } DXX_END_COMPOUND_STATEMENT )

struct font_delete

{

        void operator()(grs_font *p) const

        {

                gr_close_font(std::unique_ptr<grs_font>(p));

        }

};

}

// Writes a string using current font. Returns the next column after last char.

static inline void gr_set_curfont(grs_canvas &canvas, const grs_font_ptr &p)

{

        gr_set_curfont(canvas, p.get());

}

static inline void (gr_set_current_canvas)(grs_canvas_ptr &canv DXX_DEBUG_CURRENT_CANVAS_FILE_LINE_COMMA_L_DECL_VARS)

{

        (gr_set_current_canvas)(canv.get() DXX_DEBUG_CURRENT_CANVAS_FILE_LINE_COMMA_L_PASS_VARS);

}

static inline void (gr_set_current_canvas)(grs_subcanvas_ptr &canv DXX_DEBUG_CURRENT_CANVAS_FILE_LINE_COMMA_L_DECL_VARS)

{

        (gr_set_current_canvas)(canv.get() DXX_DEBUG_CURRENT_CANVAS_FILE_LINE_COMMA_L_PASS_VARS);

}

#endif