Cppcheck report - GATE C/C++ Framework: apps/graphic/gategames/blocklevels.cpp

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/
#include "blocklevels.hpp"

#include "gate/graphics/gl_apis.hpp"
#include "gate/mathematics.hpp"
#include "gate/graphics/pixmapimages.hpp"

#include "textures/texture_block_cobblestone.xpm"
#include "textures/texture_block_grass_side.xpm"
#include "textures/texture_block_grass_top.xpm"
#include "textures/texture_block_dirt.xpm"
#include "textures/texture_block_oak_planks.xpm"
#include "textures/texture_block_oak_side.xpm"
#include "textures/texture_block_oak_top.xpm"
#include "textures/texture_block_oak_leaves.xpm"
#include "textures/texture_block_brick.xpm"
#include "textures/texture_block_stone.xpm"
#include "textures/texture_block_stonebrick.xpm"

#define GATEGAMES_SIMPLE_BLOCKS 1

namespace gate
{
    namespace apps
    {

        struct Id2TextureMapping
        {
            BlockLevelsGame::BlockTextureType   type;
            char const* const* texture;
        };

        static Id2TextureMapping global_id_2_texture_mapping[] =
        {
            { BlockLevelsGame::BlockTexture_Dirt, texture_block_dirt_xpm },
            { BlockLevelsGame::BlockTexture_Cobblestone, texture_block_cobblestone_xpm },
            { BlockLevelsGame::BlockTexture_GrassTop, texture_block_grass_top_xpm },
            { BlockLevelsGame::BlockTexture_GrassSide, texture_block_grass_side_xpm },
            { BlockLevelsGame::BlockTexture_OakPlanks, texture_block_oak_planks_xpm },
            { BlockLevelsGame::BlockTexture_OakSide, texture_block_oak_side_xpm },
            { BlockLevelsGame::BlockTexture_OakTop, texture_block_oak_top_xpm },
            { BlockLevelsGame::BlockTexture_OakLeaves, texture_block_oak_leaves_xpm },
            { BlockLevelsGame::BlockTexture_Stone, texture_block_stone_xpm },
            { BlockLevelsGame::BlockTexture_StoneBrick, texture_block_stonebrick_xpm },
            { BlockLevelsGame::BlockTexture_Brick, texture_block_brick_xpm }
        };

        struct CharToIdMapping
        {
            char character;
            bool solid;
            BlockLevelsGame::BlockType  block;
        };

        static char const BlockId_Empty = ' ';
        static char const BlockId_Dirt = 'D';
        static char const BlockId_OakPlanks = 'P';
        static char const BlockId_Oak = 'W';
        static char const BlockId_OakLeaves = 'L';
        static char const BlockId_Cobble = 'C';
        static char const BlockId_Grass = 'G';
        static char const BlockId_Brick = 'B';
        static char const BlockId_Stone = 'S';
        static char const BlockId_StoneBrick = 's';

        static char const BlockId_Start1 = '1';

        static struct CharToIdMapping char_to_block_mappings[] =
        {
            { BlockId_Empty,        false, BlockLevelsGame::Block_Empty },
            { BlockId_Dirt,         true, BlockLevelsGame::Block_Dirt },
            { BlockId_OakPlanks,    true, BlockLevelsGame::Block_OakPlanks },
            { BlockId_Oak,          true, BlockLevelsGame::Block_Oak },
            { BlockId_OakLeaves,    true, BlockLevelsGame::Block_OakLeaves },
            { BlockId_Cobble,       true, BlockLevelsGame::Block_Cobble },
            { BlockId_Grass,        true, BlockLevelsGame::Block_Grass },
            { BlockId_Brick,        true, BlockLevelsGame::Block_Brick },
            { BlockId_Stone,        true, BlockLevelsGame::Block_Stone },
            { BlockId_StoneBrick,   true, BlockLevelsGame::Block_StoneBrick },

            { BlockId_Start1,       false, BlockLevelsGame::Block_Start1 }
        };

        static size_t const char_to_block_mappings_count = sizeof(char_to_block_mappings) / sizeof(char_to_block_mappings[0]);

        static bool isSolidBlockId(char blockId)
        {
            for (size_t ndx = 0; ndx != char_to_block_mappings_count; ++ndx)
            {
                if (char_to_block_mappings[ndx].character == blockId)
                {
                    return char_to_block_mappings[ndx].solid;
                }
            }
            return false;
        }

        struct GATE_API_LOCAL BlockLayout
        {
            typedef BlockLevelsGame::BlockType BlockType;
            typedef BlockLevelsGame::BlockTextureType BlockTextureType;

            BlockType           type;
            Color               borderColor;
            Color               fillColor;
            BlockTextureType    textures[6];
        };

        static BlockLayout blockLayouts[BlockLevelsGame::Block_End];

        static void initBlockLayout(
            BlockLevelsGame::BlockType type, Color border, Color fill, 
            BlockLevelsGame::BlockTextureType tex1,
            BlockLevelsGame::BlockTextureType tex2,
            BlockLevelsGame::BlockTextureType tex3,
            BlockLevelsGame::BlockTextureType tex4,
            BlockLevelsGame::BlockTextureType texTop,
            BlockLevelsGame::BlockTextureType texBottom)
        {
            BlockLayout& bl = blockLayouts[type];
            bl.type = type;
            bl.borderColor = border;
            bl.fillColor = fill;
            bl.textures[0] = tex1;
            bl.textures[1] = tex2;
            bl.textures[2] = tex3;
            bl.textures[3] = tex4;
            bl.textures[4] = texTop;
            bl.textures[5] = texBottom;
        }
        static void initBlockLayout(
            BlockLevelsGame::BlockType type, Color border, Color fill, 
            BlockLevelsGame::BlockTextureType texSide,
            BlockLevelsGame::BlockTextureType texTop,
            BlockLevelsGame::BlockTextureType texBottom)
        {
            initBlockLayout(type, border, fill, texSide, texSide, texSide, texSide, texTop, texBottom);
        }
        static void initBlockLayout(
            BlockLevelsGame::BlockType type, Color border, Color fill, 
            BlockLevelsGame::BlockTextureType tex)
        {
            initBlockLayout(type, border, fill, tex, tex, tex, tex, tex, tex);
        }

        static void initBlockLayouts()
        {
            typedef BlockLevelsGame BLG;
            initBlockLayout(BLG::Block_Dirt,        Color::Black, Color::Brown, BLG::BlockTexture_Dirt);
            initBlockLayout(BLG::Block_OakPlanks,   Color::Black, Color(204,102, 51), BLG::BlockTexture_OakPlanks);
            initBlockLayout(BLG::Block_Oak,         Color::Black, Color(153, 51, 0), BLG::BlockTexture_OakSide, BLG::BlockTexture_OakTop, BLG::BlockTexture_OakTop);
            initBlockLayout(BLG::Block_OakLeaves,   Color::Black, Color::Green, BLG::BlockTexture_OakLeaves);
            initBlockLayout(BLG::Block_Cobble,      Color::Black, Color::DarkGray, BLG::BlockTexture_Cobblestone);
            initBlockLayout(BLG::Block_Grass,       Color::Black, Color::BrightGreen, BLG::BlockTexture_GrassSide, BLG::BlockTexture_GrassTop, BLG::BlockTexture_Dirt );
            initBlockLayout(BLG::Block_Brick,       Color::Black, Color(204, 51, 51), BLG::BlockTexture_Brick);
            initBlockLayout(BLG::Block_Stone,       Color::Black, Color(102,102,102), BLG::BlockTexture_Stone);
            initBlockLayout(BLG::Block_StoneBrick,  Color::Black, Color(153,153,153), BLG::BlockTexture_StoneBrick);
        }

        static BlockLayout const& getBlockLayout(BlockLevelsGame::BlockType type)
        {
            return blockLayouts[type];
        }

        static BlockLevelsGame::BlockType load_block_type(char chr)
        {
            for (size_t n = 0; n != char_to_block_mappings_count; ++n)
            {
                if (char_to_block_mappings[n].character == chr)
                {
                    return char_to_block_mappings[n].block;
                }
            }
            return BlockLevelsGame::Block_Empty;
        }

        static char const* const house0[] =
        {
            "       ",
            " CCCCC ",
            " CPPPC ",
            " CPPPC ",
            " CPPPC ",
            " CCCCC ",
            "       ",
            NULL
        };
        static char const* const house1[] =
        {
            "       ",
            " sS Ss ",
            " S   S ",
            " S   S ",
            " S   S ",
            " sSSSs ",
            "       ",
            NULL
        };
        static char const* const house2[] =
        {
            "       ",
            " sS Ss ",
            " S   S ",
            "       ",
            " S   S ",
            " sS Ss ",
            "       ",
            NULL
        };
        static char const* const house3[] =
        {
            "       ",
            " sSSSs ",
            " S   S ",
            " S   S ",
            " S   S ",
            " sSSSs ",
            "       ",
            NULL
        };
        static char const* const house4[] =
        {
            "WWWWWWW",
            "WWWWWWW",
            "WW   WW",
            "WW   WW",
            "WW   WW",
            "WWWWWWW",
            "WWWWWWW",
            NULL
        };
        static char const* const house5[] =
        {
            "       ",
            " WWWWW ",
            " WW WW ",
            " WW WW ",
            " WW WW ",
            " WWWWW ",
            "       ",
            NULL
        };
        static char const* const house6[] =
        {
            "       ",
            "       ",
            "  WWW  ",
            "  WWW  ",
            "  WWW  ",
            "       ",
            "       ",
            NULL
        };
        static char const* const house7[] =
        {
            "       ",
            "       ",
            "       ",
            "   W   ",
            "       ",
            "       ",
            "       ",
            NULL
        };

        static char const* const* const house_map[] =
        {
            house0,
            house1,
            house2,
            house3,
            house4,
            house5,
            house6,
            NULL
        };

        static char const* const demo_ground0[] =
        {
            "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
            "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCDDDDDDDDDDDDDDDDDDDDDDDDDDCC",
            "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
            "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
            NULL
        };

        static char const* const demo_ground1[] =
        {
            "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
            "C                            C",
            "C                            C",
            "C   WWWW   DDD  BBBBB  PPPP  C",
            "C  W      D D D   B    P     C",
            "C  W WWW  DDDDD   B    PPP   C",
            "C  W  WW  D   D   B    P     C",
            "C   WW W  D   D   B    PPPP  C",
            "C    W    D                  C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C PPPPPPP P                  C",
            "C P     P P P  PPPPPPPPPPPPP C",
            "C P PPP P P       P        P C",
            "C P   P P PPPPPPP P PP PPPPP C",
            "C PPP P P P     P P P  P   P C",
            "C     P   P PPP   P P PPPP P C",
            "C PPPPPPPPP P PPPPP P P  P P C",
            "C                            C",
            "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
            NULL
        };

        static char const* const demo_ground2[] =
        {
            "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
            "C                            C",
            "C                            C",
            "C   WWWW   GGG  BBBBB  PPPP  C",
            "C  W      G   G   B    P     C",
            "C  W WWW  GGGGG   B    PPP   C",
            "C  W  WW  G   G   B    P     C",
            "C   WW W  G   G   B    PPPP  C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C              1             C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C                            C",
            "C PPPPPPP P                  C",
            "C P     P P P  PPPPPPPPPPPPP C",
            "C P PPP P P       P        P C",
            "C P   P P PPPPPPP P PP PPPPP C",
            "C PPP P P P     P P P  P   P C",
            "C     P   P PPP   P P PPPP P C",
            "C PPPPPPPPP P PPPPP P P  P P C",
            "C                            C",
            "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
            NULL
        };

        static char const* const* demo_ground_map[] =
        {
            demo_ground0,
            demo_ground1,
            demo_ground2,
            NULL
        };


        static char const* const tree0[] =
        {
            "         ",
            "         ",
            "         ",
            "         ",
            "    W    ",
            "         ",
            "         ",
            "         ",
            "         ",
            NULL
        };
        static char const* const tree1[] =
        {
            "         ",
            "         ",
            "         ",
            "         ",
            "    W    ",
            "         ",
            "         ",
            "         ",
            "         ",
            NULL
        };
        static char const* const tree2[] =
        {
            "         ",
            "         ",
            "         ",
            "   LLL   ",
            "  LLWLL  ",
            "   LLL   ",
            "         ",
            "         ",
            "         ",
            NULL
        };
        static char const* const tree3[] =
        {
            "  LLLLL  ",
            " LLLLLLL ",
            " LLLLLLL ",
            "LLLLLLLLL",
            "LLLLWLLLL",
            "LLLLLLLLL",
            " LLLLLLL ",
            " LLLLLLL ",
            "  LLLLL  ",
            NULL
        };
        static char const* const tree4[] =
        {
            "  LLLLL  ",
            " LLLLLLL ",
            " LLLLLLL ",
            "LLLLLLLLL",
            "LLLLWLLLL",
            "LLLLLLLLL",
            " LLLLLLL ",
            " LLLLLLL ",
            "  LLLLL  ",
            NULL
        };
        static char const* const tree5[] =
        {
            "   LLL   ",
            "  LLLLL  ",
            " LLLLLLL ",
            " LLLLLLL ",
            "LLLLWLLLL",
            " LLLLLLL ",
            " LLLLLLL ",
            "  LLLLL  ",
            "   LLL   ",
            NULL
        };
        static char const* const tree6[] =
        {
            "         ",
            "    L    ",
            "   LLL   ",
            "  LLLLL  ",
            " LLLWLLL ",
            "  LLLLL  ",
            "   LLL   ",
            "    L    ",
            "         ",
            NULL
        };
        static char const* const tree7[] =
        {
            "         ",
            "         ",
            "   LLL   ",
            "  LLLLL  ",
            "  LLWLL  ",
            "  LLLLL  ",
            "   LLL   ",
            "         ",
            "         ",
            NULL
        };
        static char const* const tree8[] =
        {
            "         ",
            "         ",
            "         ",
            "   LLL   ",
            "   LLL   ",
            "   LLL   ",
            "         ",
            "         ",
            "         ",
            NULL
        };

        static char const* const* tree_map[] =
        {
            tree0,
            tree1,
            tree2,
            tree3,
            tree4,
            tree5,
            tree6,
            tree7,
            tree8,
            NULL
        };



        typedef struct object_map
        {
            index_t x;
            index_t y;
            index_t z;

            char const* const* const* levels;
        } object_map_t;

        static object_map_t demo_ground = { 0, 0, 0, demo_ground_map };
        static object_map_t houseA = { 20, 15, 1, house_map };
        static object_map_t houseB = { 10, 20, 1, house_map };
        static object_map_t houseC = { 0, 20, 1, house_map };
        static object_map_t treeA = { 15, 5, 1, tree_map };

        static object_map_t const* object_maps[] =
        {
            &demo_ground,
            &houseA,
            //&houseB,
            //&houseC,
            &treeA,
            NULL
        };


        void BlockLevelsGame::loadObjectMapIntoWorld(BlockLevelsGame::World& world, index_t start_x, index_t start_y, index_t start_z, char const* const* const* objectLevels)
        {
            index_t z = start_z;
            char const* const* ptrLevel;
            while (NULL != (ptrLevel = *objectLevels))
            {
                index_t y = start_y;
                char const* ptrLine;
                while (NULL != (ptrLine = *ptrLevel))
                {
                    index_t x = start_x;
                    char block;
                    while (0 != (block = *ptrLine))
                    {
                        if (block != ' ')
                        {
                            world.set(x, y, z, block);
                        }
                        ++x;
                        ++ptrLine;
                    }
                    ++y;
                    ++ptrLevel;
                }
                ++z;
                ++objectLevels;
            }

        }



        BlockLevelsGame::World::World(index_t x_length, index_t y_width, index_t z_height)
            : length(x_length), width(y_width), height(z_height), buffer(static_cast<size_t>(x_length* y_width* z_height))
        {
            size_t totalLength = x_length * y_width * z_height;
            this->buffer.add(' ', totalLength);
        }

        char* BlockLevelsGame::World::getBlockPtr(index_t x, index_t y, index_t z) const
        {
            if ((x < 0) || (y < 0) || (z < 0) || (x >= this->length) || (y >= this->width) || (z >= this->height))
            {
                return NULL;
            }
            else
            {
                size_t levelLength = static_cast<size_t>(this->width * this->length);
                size_t bufferIndex = static_cast<size_t>(z * levelLength + y * this->length + x);
                void* ptr = gate_arraylist_get(this->buffer.c_impl(), bufferIndex);
                return static_cast<char*>(ptr);
            }
        }

        void BlockLevelsGame::World::set(index_t x, index_t y, index_t z, char block)
        {
            char* ptr = this->getBlockPtr(x, y, z);
            if (NULL != ptr)
            {
                *ptr = block;
            }
        }
        char BlockLevelsGame::World::get(index_t x, index_t y, index_t z) const
        {
            char* ptr = this->getBlockPtr(x, y, z);
            if (NULL == ptr)
            {
                return ' ';
            }
            else
            {
                return *ptr;
            }
        }

        index_t BlockLevelsGame::World::Length() const
        {
            return this->length;
        }
        index_t BlockLevelsGame::World::Width() const
        {
            return this->width;
        }
        index_t BlockLevelsGame::World::Height() const
        {
            return this->height;
        }


        char BlockLevelsGame::World::operator()(index_t x, index_t y, index_t z) const
        {
            return this->get(x, y, z);
        }


        BlockLevelsGame::BlockLevelsGame()
        :   ptrHost(NULL), simpleBlocks(false),
            translucentObjects(false), x(0.0f), y(0.0f), z(1.5), direction(0.0f),
            moveVelocity(0.0f), strafeVelocity(0.0f), angularVelocity(0.0f),
            loadedWorld(createWorld()),
            shader_program((gate::uintptr_t)-1),
            shader_loc_projection(-1),
            shader_loc_view(-1),
            shader_loc_model(-1),
            shader_loc_position(-1),
            shader_loc_color(-1),
            shader_loc_texture(-1),
            shader_loc_texcoord(-1),
            shader_loc_usetex(-1),
            vbo_positions((unsigned)-1),
            vbo_colors((unsigned)-1),
            vbo_usetex((unsigned)-1),
            vbo_texture((unsigned)-1)
        {
        }

        BlockLevelsGame::~BlockLevelsGame() noexcept
        {
        }

        void BlockLevelsGame::init(GameHost& host)
        {
            this->ptrHost = &host;
        }

        static void convert_cartesian_to_gl(real32_t& x, real32_t& y, real32_t& z)
        {
            real32_t nx = y;
            real32_t ny = z;
            real32_t nz = x;
            x = nx;
            y = ny;
            z = nz;
        }

        void BlockLevelsGame::addCuboid(Vertex point, Vertex dimension, Color borderColor, Color fillColor)
        {
            this->cuboids.add(Cuboid(point, dimension, borderColor, fillColor));
        }

        void BlockLevelsGame::addCuboid(Vertex point, Vertex dimension, void* const* texture_ids, size_t texture_count)
        {
            this->cuboids.add(Cuboid(point, dimension, texture_ids, texture_count));
        }

#if defined(GATE_GRAPHICS_OPENGL2_SUPPORT)

        static void makePerspectiveMatrix(float fovY, float aspect, float zNear, float zFar, float* m)
        {
            float f = 1.0f / math::tan(fovY * (GATE_MATH_CONST_PI / 180.0f) / 2.0f);

            m[0]  = f / aspect;
            m[1]  = 0.0f;
            m[2]  = 0.0f;
            m[3]  = 0.0f;

            m[4]  = 0.0f;
            m[5]  = f;
            m[6]  = 0.0f;
            m[7]  = 0.0f;

            m[8]  = 0.0f;
            m[9]  = 0.0f;
            m[10] = (zFar + zNear) / (zNear - zFar);
            m[11] = -1.0f;

            m[12] = 0.0f;
            m[13] = 0.0f;
            m[14] = (2.0f * zFar * zNear) / (zNear - zFar);
            m[15] = 0.0f;
        }


        static void normalize(float v[3])
        {
            real32_t const len = math::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
            if (len > 0.0f)
            {
                v[0] /= len;
                v[1] /= len;
                v[2] /= len;
            }
        }

        
        static void cross(const float a[3], const float b[3], float result[3])
        {
            result[0] = a[1]*b[2] - a[2]*b[1];
            result[1] = a[2]*b[0] - a[0]*b[2];
            result[2] = a[0]*b[1] - a[1]*b[0];
        }

        static void makeLookAtMatrix(float eyeX, float eyeY, float eyeZ,
                                     float centerX, float centerY, float centerZ,
                                     float upX, float upY, float upZ,
                                     float* m)
        {
            float f[3] = { centerX - eyeX, centerY - eyeY, centerZ - eyeZ };
            float up[3] = { upX, upY, upZ };
            float s[3];
            float u[3];

            normalize(f);
            normalize(up);
            cross(f, up, s);
            normalize(s);
            cross(s, f, u);

            m[0]  = s[0];
            m[1]  = u[0];
            m[2]  = -f[0];
            m[3]  = 0.0f;

            m[4]  = s[1];
            m[5]  = u[1];
            m[6]  = -f[1];
            m[7]  = 0.0f;

            m[8]  = s[2];
            m[9]  = u[2];
            m[10] = -f[2];
            m[11] = 0.0f;

            m[12] = -(s[0]*eyeX + s[1]*eyeY + s[2]*eyeZ);
            m[13] = -(u[0]*eyeX + u[1]*eyeY + u[2]*eyeZ);
            m[14] =  (f[0]*eyeX + f[1]*eyeY + f[2]*eyeZ);
            m[15] = 1.0f;
        }


        static uintptr_t load_shaders(GlApi& gl)
        {
            static char const* vertexShaderProjViewModelColor[] =
            {
                "attribute vec3 position;"  GATE_STR_LF,
                "attribute vec3 color;"     GATE_STR_LF,
                "attribute vec2 texcoord;"  GATE_STR_LF,
                "attribute float usetex;"   GATE_STR_LF,
                "varying float vUseTex;"    GATE_STR_LF,
                "varying vec3 vColor;"      GATE_STR_LF,
                "varying vec2 vTexCoord;"   GATE_STR_LF,
                "uniform mat4 uProjection;" GATE_STR_LF,
                "uniform mat4 uView;"       GATE_STR_LF,
                "uniform mat4 uModel;"      GATE_STR_LF,
                "void main() {"             GATE_STR_LF,
                "  gl_Position = uProjection * uView * uModel * vec4(position, 1.0);"   GATE_STR_LF,
                "  vColor = color;"         GATE_STR_LF,
                "  vTexCoord = texcoord;"   GATE_STR_LF,
                "  vUseTex = usetex;"       GATE_STR_LF,
                "}"                         GATE_STR_LF,
            };

            static char const* fragmentShaderColor[] =
            {
                "precision mediump float;"      GATE_STR_LF,
                "uniform sampler2D uTexture;"   GATE_STR_LF,
                "varying float vUseTex;"        GATE_STR_LF,
                "varying vec3 vColor;"          GATE_STR_LF,
                "varying vec2 vTexCoord;"       GATE_STR_LF,
                "void main() {"                 GATE_STR_LF,
                "  if (vUseTex == 0.0f) {"                              GATE_STR_LF,
                "    gl_FragColor = vec4(vColor, 1.0);"                 GATE_STR_LF,
                "  } else {"                                            GATE_STR_LF,
                "    gl_FragColor = texture2D(uTexture, vTexCoord);"    GATE_STR_LF,
                "  }"                                                   GATE_STR_LF,
                "}"                             GATE_STR_LF
            };

            intptr_t success = 0;

            // color-vertex-shader
            uintptr_t vertex_shader = gl.createShader(gate_gl2_api_shader_type_vertex);
            gl.shaderSource(vertex_shader, 
                            sizeof(vertexShaderProjViewModelColor) / sizeof(vertexShaderProjViewModelColor[0]), 
                            vertexShaderProjViewModelColor, NULL);
            gl.compileShader(vertex_shader);
            gl.getShaderIv(vertex_shader, gate_gl2_api_shader_param_compile_status, &success);
            if (!success)
            {
                char infoLog[1024];
                gate_size_t infoLoglength = sizeof(infoLog) - 1;
                gl.getShaderInfoLog(vertex_shader, infoLoglength, infoLoglength, infoLog);
                infoLog[infoLoglength] = 0;
                raiseException(results::Failed, infoLog, "glCompileShader(vertex)");
            }

            // color-fragment-shader
            uintptr_t fragment_shader = gl.createShader(gate_gl2_api_shader_type_fragment);
            gl.shaderSource(fragment_shader, 
                            sizeof(fragmentShaderColor) / sizeof(fragmentShaderColor[0]), 
                            fragmentShaderColor, NULL);
            gl.compileShader(fragment_shader);
            gl.getShaderIv(fragment_shader, gate_gl2_api_shader_param_compile_status, &success);
            if (!success)
            {
                char infoLog[1024];
                gate_size_t infoLoglength = sizeof(infoLog);<--- Assignment 'infoLoglength=sizeof(infoLog)', assigned value is 1024
                gl.getShaderInfoLog(fragment_shader, infoLoglength, infoLoglength, infoLog);
                infoLog[infoLoglength] = 0;<--- Array index out of bounds
                raiseException(results::Failed, infoLog, "glCompileShader(fragment)");
            }

            uintptr_t program = gl.createProgram();
            gl.attachShader(program, vertex_shader);
            gl.attachShader(program, fragment_shader);
            gl.linkProgram(program);
            gl.getProgramIv(program,gate_gl2_api_program_param_link_status, &success);
            if (!success)
            {
                char infoLog[1024];
                gate_size_t infoLoglength = sizeof(infoLog) - 1;
                gl.getProgramInfoLog(program, infoLoglength, &infoLoglength, infoLog);
                infoLog[infoLoglength] = 0;
                raiseException(results::Failed, infoLog, "glLinkProgram()");
            }

            gl.deleteShader(vertex_shader);
            gl.deleteShader(fragment_shader);

            return program;
        }

#endif /* GATE_GRAPHICS_OPENGL2_SUPPORT */

        static void load_quad_vertexes(real32_t* v,
            BlockLevelsGame::Vertex const& p1, BlockLevelsGame::Vertex const& p2,
            BlockLevelsGame::Vertex const& p3, BlockLevelsGame::Vertex const& p4)
        {
            v[0] = p2.x; v[1] = p2.y; v[2] = p2.z;
            v[3] = p1.x; v[4] = p1.y; v[5] = p1.z;
            v[6] = p4.x; v[7] = p4.y; v[8] = p4.z;
            v[9] = p3.x; v[10] = p3.y; v[11] = p3.z;

            convert_cartesian_to_gl(v[0], v[1], v[2]);
            convert_cartesian_to_gl(v[3], v[4], v[5]);
            convert_cartesian_to_gl(v[6], v[7], v[8]);
            convert_cartesian_to_gl(v[9], v[10], v[11]);
        }

        void BlockLevelsGame::renderQuadArea(GlApi& gl, Vertex const& p1, Vertex const& p2, Vertex const& p3, Vertex const& p4, Color const& col)
        {
            real32_t v[12];
            load_quad_vertexes(v, p1, p2, p3, p4);

        #if defined(GATE_GRAPHICS_OPENGL2_SUPPORT)
            real32_t c[12];
            real32_t const r = (real32_t)col->r / 255.0f;
            real32_t const g = (real32_t)col->g / 255.0f;
            real32_t const b = (real32_t)col->b / 255.0f;
            for (size_t ndx = 0; ndx != 4; ++ndx)
            {
                c[ndx * 3 + 0] = r;
                c[ndx * 3 + 1] = g;
                c[ndx * 3 + 2] = b;
            }

            static real32_t const f[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_usetex);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(f), f, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_usetex, 1, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_positions);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(v), v, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_position, 3, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_colors);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(c), c, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_color, 3, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.drawArrays(GlApi::DrawMode_TriangleFan, 0, 4);

        #else
            gl.enableClientState(OpenGL::ClientState_VertexArray);

            gl.setVertexPointer(3, v);  // 3 coords for one vertex
            gl.setColorByte(col->r, col->g, col->b, col->a);
            gl.drawArrays(OpenGL::DrawMode_TriangleFan, 0, 4);  // draw 4 vertices

            gl.disableClientState(OpenGL::ClientState_VertexArray);
        #endif
        }
        void BlockLevelsGame::renderQuadBorders(GlApi& gl, Vertex const& p1, Vertex const& p2, Vertex const& p3, Vertex const& p4, Color const& col)
        {
            real32_t v[12];
            load_quad_vertexes(v, p1, p2, p3, p4);

#if defined(GATE_GRAPHICS_OPENGL2_SUPPORT)
            real32_t c[12];
            real32_t const r = (real32_t)col->r / 255.0f;
            real32_t const g = (real32_t)col->g / 255.0f;
            real32_t const b = (real32_t)col->b / 255.0f;
            for (size_t ndx = 0; ndx != 4; ++ndx)
            {
                c[ndx * 3 + 0] = r;
                c[ndx * 3 + 1] = g;
                c[ndx * 3 + 2] = b;
            }

            static real32_t const f[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_usetex);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(f), f, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_usetex, 1, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_positions);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(v), v, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_position, 3, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_colors);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(c), c, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_color, 3, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.drawArrays(OpenGL::DrawMode_LineStrip, 0, 4);
#else
            gl.enableClientState(OpenGL::ClientState_VertexArray);

            gl.setVertexPointer(3, v);  // 3 coords form one vertex
            gl.setColorByte(col->r, col->g, col->b, col->a);
            gl.drawArrays(OpenGL::DrawMode_LineStrip, 0, 4);    // draw 4 vertices

            gl.disableClientState(OpenGL::ClientState_VertexArray);
#endif
        }


        void BlockLevelsGame::renderQuadTexture(GlApi& gl, Vertex const& p1, Vertex const& p2, Vertex const& p3, Vertex const& p4, void* texture)
        {
            real32_t v[12];

            load_quad_vertexes(v, p1, p2, p3, p4);

#if defined(GATE_GRAPHICS_OPENGL2_SUPPORT)
            static real32_t const t[8] = {
                0.0f, 0.0f,
                1.0f, 0.0f,
                1.0f, 1.0f,
                0.0f, 1.0f
            };

            gl.enableClientState(OpenGL::ClientState_VertexArray);
            gl.enableClientState(OpenGL::ClientState_TextureCoordArray);
            gl.enableCapability(OpenGL::Capability_Texture2D);

            static real32_t const f[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_usetex);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(f), f, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_usetex, 1, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_positions);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(v), v, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_position, 3, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.bindBuffers(gate_gl2_api_buffer_type_array, this->vbo_texture);
            gl.bufferData(gate_gl2_api_buffer_type_array, sizeof(t), t, gate_gl2_api_usage_type_static_draw);
            gl.vertexAttribPointer(this->shader_loc_texcoord, 2, gate_gl2_api_vertex_attrib_float, false, 0, NULL);

            gl.activeTexture(0);
            gl.bindTexture(texture);
            gl.uniform1i(this->shader_loc_texture, 0);

            gl.drawArrays(OpenGL::DrawMode_TriangleFan, 0, 4);

            gl.disableCapability(OpenGL::Capability_Texture2D);
            gl.disableClientState(OpenGL::ClientState_TextureCoordArray);
            gl.disableClientState(OpenGL::ClientState_VertexArray);
#else
            static real32_t const t[8] = {
                0.0f, 0.0f,
                1.0f, 0.0f,
                1.0f, 1.0f,
                0.0f, 1.0f
            };
            gl.enableClientState(OpenGL::ClientState_VertexArray);
            gl.enableClientState(OpenGL::ClientState_TextureCoordArray);
            gl.enableCapability(OpenGL::Capability_Texture2D);

            gl.setVertexPointer(3, v);  // 3 coords form one vertex
            gl.bindTexture(texture);
            gl.setTexCoordPointer(2, t);
            gl.drawArrays(OpenGL::DrawMode_TriangleFan, 0, 4);  // draw 4 vertices

            gl.disableCapability(OpenGL::Capability_Texture2D);
            gl.disableClientState(OpenGL::ClientState_TextureCoordArray);
            gl.disableClientState(OpenGL::ClientState_VertexArray);
#endif
        }

        static uint8_t const bit_front = 0x01;
        static uint8_t const bit_right = 0x02;
        static uint8_t const bit_back = 0x04;
        static uint8_t const bit_left = 0x08;
        static uint8_t const bit_bottom = 0x10;
        static uint8_t const bit_top = 0x20;

        void BlockLevelsGame::renderCuboid(GlApi& gl, Cuboid const& cuboid)
        {
            //static real32_t patch = 0.001f;
            Vertex ground[4];
            ground[0] = ground[1] = ground[2] = ground[3] = cuboid.point;
            ground[1].x += cuboid.dim.x;
            ground[2].x += cuboid.dim.x;
            ground[2].y += cuboid.dim.y;
            ground[3].y += cuboid.dim.y;

            Vertex top[4];
            top[0] = ground[0];
            top[1] = ground[1];
            top[2] = ground[2];
            top[3] = ground[3];
            top[0].z += cuboid.dim.z;
            top[1].z += cuboid.dim.z;
            top[2].z += cuboid.dim.z;
            top[3].z += cuboid.dim.z;

            Vertex s1[4];
            s1[0] = top[0];
            s1[1] = top[1];
            s1[2] = ground[1];
            s1[3] = ground[0];

            Vertex s2[4];
            s2[0] = top[1];
            s2[1] = top[2];
            s2[2] = ground[2];
            s2[3] = ground[1];

            Vertex s3[4];
            s3[0] = top[2];
            s3[1] = top[3];
            s3[2] = ground[3];
            s3[3] = ground[2];

            Vertex s4[4];
            s4[0] = top[3];
            s4[1] = top[0];
            s4[2] = ground[0];
            s4[3] = ground[3];

            if ((cuboid.fill->a == 0) && (cuboid.border->a == 0))
            {
                if (cuboid.side_bits & bit_bottom) BlockLevelsGame::renderQuadTexture(gl, ground[0], ground[1], ground[2], ground[3], cuboid.textures[5]);
                if (cuboid.side_bits & bit_front) BlockLevelsGame::renderQuadTexture(gl, s1[0], s1[1], s1[2], s1[3], cuboid.textures[0]);
                if (cuboid.side_bits & bit_right) BlockLevelsGame::renderQuadTexture(gl, s2[0], s2[1], s2[2], s2[3], cuboid.textures[1]);
                if (cuboid.side_bits & bit_back) BlockLevelsGame::renderQuadTexture(gl, s3[0], s3[1], s3[2], s3[3], cuboid.textures[2]);
                if (cuboid.side_bits & bit_left) BlockLevelsGame::renderQuadTexture(gl, s4[0], s4[1], s4[2], s4[3], cuboid.textures[3]);
                //BlockLevelsGame::renderQuadTexture(gl, top[0], top[1], top[2], top[3], cuboid.textures[4]);
                if (cuboid.side_bits & bit_top) BlockLevelsGame::renderQuadTexture(gl, top[3], top[2], top[1], top[0], cuboid.textures[4]);
            }

            if (cuboid.fill->a != 0)
            {
                if (cuboid.side_bits & bit_bottom) BlockLevelsGame::renderQuadArea(gl, ground[0], ground[1], ground[2], ground[3], cuboid.fill);
                if (cuboid.side_bits & bit_front) BlockLevelsGame::renderQuadArea(gl, s1[0], s1[1], s1[2], s1[3], cuboid.fill);
                if (cuboid.side_bits & bit_right) BlockLevelsGame::renderQuadArea(gl, s2[0], s2[1], s2[2], s2[3], cuboid.fill);
                if (cuboid.side_bits & bit_back) BlockLevelsGame::renderQuadArea(gl, s3[0], s3[1], s3[2], s3[3], cuboid.fill);
                if (cuboid.side_bits & bit_left) BlockLevelsGame::renderQuadArea(gl, s4[0], s4[1], s4[2], s4[3], cuboid.fill);
                if (cuboid.side_bits & bit_top) BlockLevelsGame::renderQuadArea(gl, top[3], top[2], top[1], top[0], cuboid.fill);
            }

            if (cuboid.border->a != 0)
            {
                //BlockLevelsGame::renderQuadBorders(gl, ground[0], ground[1], ground[2], ground[3], cuboid.border);
                BlockLevelsGame::renderQuadBorders(gl, s1[0], s1[1], s1[2], s1[3], cuboid.border);
                BlockLevelsGame::renderQuadBorders(gl, s2[0], s2[1], s2[2], s2[3], cuboid.border);
                BlockLevelsGame::renderQuadBorders(gl, s3[0], s3[1], s3[2], s3[3], cuboid.border);
                BlockLevelsGame::renderQuadBorders(gl, s4[0], s4[1], s4[2], s4[3], cuboid.border);
                //BlockLevelsGame::renderQuadBorders(gl, top[0], top[1], top[2], top[3], cuboid.border);
            }
        }

        void BlockLevelsGame::addBlock(BlockType type, Vertex const& point, uint8_t side_bits)
        {
            this->blocks.add(Block(type, point, side_bits));
        }

        void BlockLevelsGame::renderSimpleBlock(GlApi& gl, Vertex const& point, Color const& borderColor, Color const* colors, size_t colors_count, uint8_t side_bits)
        {
            static Vertex dim(1.0f, 1.0f, 1.0f);
            Cuboid c(point, dim, borderColor, *colors);
            c.side_bits = side_bits;
            renderCuboid(gl, c);
        }

        void BlockLevelsGame::renderBlock(GlApi& gl, Vertex const& point, BlockTextureType const* textypes, size_t texcount, uint8_t side_bits)
        {
            static Vertex dim(1.0f, 1.0f, 1.0f);
            void* texIds[6] = { 0 };
            for (size_t ndx = 0; ndx != texcount; ++ndx)
            {
                TextureMap::iterator iter = this->textures.get(intptr_t(textypes[ndx]));
                if (iter != this->textures.end())
                {
                    texIds[ndx] = iter.value();
                }
            }
            Cuboid c(point, dim, texIds, texcount);
            c.side_bits = side_bits;
            renderCuboid(gl, c);
        }

        char BlockLevelsGame::getBlockId(real32_t x, real32_t y, real32_t z)
        {
            char ret = BlockId_Empty;
            index_t nx, ny, nz;

            nx = static_cast<index_t>(x);
            ny = static_cast<index_t>(y);
            nz = static_cast<index_t>(z);

            ret = this->loadedWorld(nx, this->loadedWorld.Width() - 1 - ny, nz);
            return ret;
        }

        bool BlockLevelsGame::isSolidBlock(char blockId)
        {
            return isSolidBlockId(blockId);
        }
        bool BlockLevelsGame::isSolidBlock(real32_t x, real32_t y, real32_t z)
        {
            char blockId = this->getBlockId(x, y, z);
            return this->isSolidBlock(blockId);
        }

        void BlockLevelsGame::renderBlock(GlApi& gl, BlockType type, Vertex point, uint8_t side_bits)
        {
            switch (type)
            {
            case Block_Start1:
                {
                    // nothing to do
                    break;
                }
            case Block_Empty:
                {
                    // nothing to do
                    break;
                }
            default:
                {
                    BlockLayout const& layout = getBlockLayout(type);
                    if (this->simpleBlocks)
                    {
                        this->renderSimpleBlock(gl, point, layout.borderColor, &layout.fillColor, 1, side_bits);
                    }
                    else
                    {
                        this->renderBlock(gl, point, layout.textures, 6, side_bits);
                    }
                    break;
                }
            }
        }


        static void* loadTexture(GlApi& gl, char const* const* pixmap)
        {
            RasterImage image;
            PixmapImages::parse(image, pixmap);
            gate_color_t const* pixels = (gate_color_t const*)image.getPixelPtr(0, 0);
            return gl.createTexture(GlApi::PixelFormat_Rgba, image.getWidth(), image.getHeight(), pixels);
        }

        BlockLevelsGame::World BlockLevelsGame::createWorld(size_t x_length, size_t y_width, size_t z_height)
        {
            return World(x_length, y_width, z_height);
        }


        void BlockLevelsGame::loadModule(GlSurface& surface)
        {
            GlApi& gl = surface.getGlApi();

            initBlockLayouts();

            size_t texCount = sizeof(global_id_2_texture_mapping) / sizeof(global_id_2_texture_mapping[0]);
            for (size_t ndx = 0; ndx != texCount; ++ndx)
            {
                intptr_t const id = intptr_t(global_id_2_texture_mapping[ndx].type);
                void* texId = loadTexture(gl, global_id_2_texture_mapping[ndx].texture);
                this->textures.add(id, texId);
            }

            World world = createWorld(64, 64, 64);

            object_map_t const* const* ptrMaps = object_maps;
            while (*ptrMaps)
            {
                object_map_t const& omap = **ptrMaps;
                loadObjectMapIntoWorld(world, omap.x, omap.y, omap.z, omap.levels);
                ++ptrMaps;
            }

            Vertex v;

            const index_t max_z = world.Height();
            const index_t max_y = world.Width();
            const index_t max_x = world.Length();
            for (index_t z = 0; z != max_z; ++z)
            {
                v.z = real32_t(z);

                for (index_t y = 0; y != max_y; ++y)
                {
                    v.y = real32_t(max_y - y - 1);
                    //v.y = real32_t(y);

                    for (index_t x = 0; x < max_x; ++x)
                    {
                        v.x = real32_t(x);
                        char block = world.get(x, y, z);
                        char block_left = world.get(x - 1, y, z);
                        char block_right = world.get(x + 1, y, z);
                        char block_back = world.get(x, y - 1, z);
                        char block_front = world.get(x, y + 1, z);
                        char block_bottom = world.get(x, y, z - 1);
                        char block_top = world.get(x, y, z + 1);

                        BlockType bt = load_block_type(block);
                        switch (bt)
                        {
                        case BlockLevelsGame::Block_Start1:
                            {
                                this->x = v.x + 0.5f;
                                this->y = v.y + 0.5f;
                                this->z = v.z + 0.5f;
                                break;
                            }
                        default:
                            {
                                uint8_t side_bits = 0;
                                if (block_left == ' ') side_bits |= bit_left;
                                if (block_right == ' ') side_bits |= bit_right;
                                if (block_front == ' ') side_bits |= bit_front;
                                if (block_back == ' ') side_bits |= bit_back;
                                if (block_top == ' ') side_bits |= bit_top;
                                if (block_bottom == ' ') side_bits |= bit_bottom;

                                this->addBlock(bt, v, side_bits);
                                break;
                            }
                        }
                    }
                }
            }
            this->loadedWorld = world;
        }
        void BlockLevelsGame::unloadModule(GlSurface& surface)
        {
            GlApi& gl = surface.getGlApi();

            this->cuboids.clear();

            for (TextureMap::iterator iter(this->textures.begin()), end(this->textures.end()); iter != end; ++iter)
            {
                gl.deleteTexture(iter.value());
            }
            this->textures.clear();
        }

        void BlockLevelsGame::checkFloor()
        {
            if (this->isSolidBlock(this->x, this->y, this->z - 1))
            {
                //block below camera is solid, so we should try to step onto it
                if (!this->isSolidBlock(this->x, this->y, this->z + 1) && !this->isSolidBlock(this->x, this->y, this->z))
                {
                    // block above camera and of camera itself are non-solid, so we can step up.
                    this->z += 1.0f;
                }
            }
            else
            {
                if (!this->isSolidBlock(this->x, this->y, this->z - 2))
                {
                    // no floor below us, step down;
                    this->z -= 1.0f;
                }
            }
        }


        void BlockLevelsGame::move(real32_t addX, real32_t addY)
        {
            if (!this->isSolidBlock(this->x + addX, this->y + addY, this->z))
            {
                if (this->isSolidBlock(this->x + addX, this->y + addY, this->z - 1.0f))
                {
                    if (this->isSolidBlock(this->x + addX, this->y + addY, this->z + 1.0f) || this->isSolidBlock(this->x, this->y, this->z + 1.0f))
                    {
                        // cannot move into 1-block hole
                        return;
                    }
                }

                if (!this->isSolidBlock(this->x + addX + math::signum(addX) * 0.5f,
                    this->y + addY,
                    this->z))
                {
                    this->x += addX;
                }
                if (!this->isSolidBlock(this->x + addX,
                    this->y + addY + math::signum(addY) * 0.5f,
                    this->z))
                {
                    this->y += addY;
                }
            }

        }

        void BlockLevelsGame::resize(GlSurface& surface, uint32_t width, uint32_t height)
        {
            //uint32_t width = 0, height = 0;
            //surface.getSize(width, height);
            OpenGL& gl = surface.getGlApi();

#if defined(GATE_GRAPHICS_OPENGL2_SUPPORT)

            if(this->shader_program != ((gate::uintptr_t)-1))
            {
                gl.disableVertexAttribArray(this->shader_loc_position);
                gl.disableVertexAttribArray(this->shader_loc_color);
                gl.disableVertexAttribArray(this->shader_loc_texcoord);

                gl.deleteBuffers(1, &this->vbo_positions);
                gl.deleteBuffers(1, &this->vbo_colors);
                gl.deleteBuffers(1, &this->vbo_usetex);
                gl.deleteBuffers(1, &this->vbo_texture);

                gl.deleteProgram(this->shader_program);
                this->shader_program = (gate::uintptr_t)-1;<--- Variable 'this->shader_program' is reassigned a value before the old one has been used.
            }

            this->shader_program = load_shaders(gl);<--- Variable 'this->shader_program' is reassigned a value before the old one has been used.
            gl.useProgram(this->shader_program);

            // create buffer and shader-attribute reference for "position" vertexes
            gl.genBuffers(1, &this->vbo_positions);
            this->shader_loc_position = gl.getAttribLocation(this->shader_program, "position");
            gl.enableVertexAttribArray(this->shader_loc_position);

            // create buffer and shader-attribute reference for "color" vertexes
            gl.genBuffers(1, &this->vbo_colors);
            this->shader_loc_color = gl.getAttribLocation(this->shader_program, "color");
            gl.enableVertexAttribArray(this->shader_loc_color);

            gl.genBuffers(1, &this->vbo_usetex);
            this->shader_loc_usetex = gl.getAttribLocation(this->shader_program, "usetex");
            gl.enableVertexAttribArray(this->shader_loc_usetex);

            gl.genBuffers(1, &this->vbo_texture);
            this->shader_loc_texcoord = gl.getAttribLocation(this->shader_program, "texcoord");
            gl.enableVertexAttribArray(this->shader_loc_texcoord);

            // get shader-matrix-references
            this->shader_loc_projection = gl.getUniformLocation(this->shader_program, "uProjection");
            this->shader_loc_view = gl.getUniformLocation(this->shader_program, "uView");
            this->shader_loc_model = gl.getUniformLocation(this->shader_program, "uModel");

            this->shader_loc_texture = gl.getUniformLocation(this->shader_program, "uTexture");

#endif

            {   // reset renderer
                gl.setViewport(0, 0, width, height);
                gl.setShadeModel(OpenGL::ShadeModel_Flat);

                gl.enableCapability(OpenGL::Capability_CullFace);
                //gl.setCullFace(OpenGL::CullFace_Front);
                gl.setCullFace(OpenGL::CullFace_Back);

                gl.enableCapability(OpenGL::Capability_DepthTest);
                gl.setDepthFunc(OpenGL::Depth_Less);
                gl.setDepthMask(true);
                //gl.setHint(OpenGL::Hint_PerspectiveCorrection, OpenGL::HintMode_Fastest);
            }

            {   // setup projection
#if defined(GATE_GRAPHICS_OPENGL2_SUPPORT)
                real32_t perspectiveAngle = 45.0f;
                real32_t perspectiveNear = 0.25f;
                real32_t perspectiveFar = 60.0f;
                real32_t aspectRatio = real32_t(width) / real32_t(height);
                real32_t projection_matrix[16];
                makePerspectiveMatrix(perspectiveAngle, aspectRatio, perspectiveNear, perspectiveFar, projection_matrix);
                gl.uniform_matrix4fv(this->shader_loc_projection, 1, false, projection_matrix);
#else
                real32_t perspectiveAngle = 45.0f;
                real32_t perspectiveNear = 0.25f;
                real32_t perspectiveFar = 60.0f;
                real32_t aspectRatio = real32_t(width) / real32_t(height);
                gl.setMatrixMode(OpenGL::MatrixMode_Projection);
                gl.loadIdentity();
                gl.setPerspective(perspectiveAngle, aspectRatio, perspectiveNear, perspectiveFar);
#endif
            }

            {   // set model matrix
#if defined(GATE_GRAPHICS_OPENGL2_SUPPORT)
                const real32_t model_matrix[16] =
                {
                    1,0,0,0,
                    0,1,0,0,
                    0,0,1,0,
                    0,0,0,1
                };
                gl.uniform_matrix4fv(this->shader_loc_model, 1, false, model_matrix);
#else
#endif
            }

        }


        void BlockLevelsGame::render(GlSurface& surface)
        {
            TimeCounter now = TimeCounter::now();
            time::Microseconds timeDiff = now - this->timer;
            real32_t dir_x, dir_y;
            real32_t add_x, add_y;

            if (timeDiff.value() > 0)
            {
                real32_t timeSec = real32_t(timeDiff.value()) / 1000000.0f;

                if (!math::isZero(this->angularVelocity))
                {
                    this->direction += this->angularVelocity * timeSec;
                }

                this->checkFloor();

                dir_x = math::cos(this->direction);
                dir_y = math::sin(this->direction);

                if (!math::isZero(this->moveVelocity))
                {
                    real32_t length = this->moveVelocity * timeSec;
                    if (length > 1.0f) length = 1.0f;
                    add_x = length * dir_x;
                    add_y = length * dir_y;
                    this->move(add_x, add_y);
                }
                if (!math::isZero(this->strafeVelocity))
                {
                    real32_t length = this->strafeVelocity * timeSec;
                    add_x = length * real32_t(math::cos(this->direction + math::PI * 0.5f));
                    add_y = length * real32_t(math::sin(this->direction + math::PI * 0.5f));
                    this->move(add_x, add_y);
                }
            }
            else
            {
                dir_x = math::cos(this->direction);
                dir_y = math::sin(this->direction);
            }

            timer = now;

            OpenGL& gl = surface.getGlApi();

            {   // setup world - view matrix
                real32_t eyeX, eyeY, eyeZ;
                eyeX = this->x - dir_x * 0.25f;
                eyeY = this->y - dir_y * 0.25f;
                eyeZ = this->z;
                real32_t lookX, lookY, lookZ;
                lookX = this->x + dir_x;
                lookY = this->y + dir_y;
                lookZ = this->z - 0.25f;
                real32_t upX, upY, upZ;
                upX = upY = 0.0f;
                upZ = 1.0f;
                convert_cartesian_to_gl(eyeX, eyeY, eyeZ);
                convert_cartesian_to_gl(lookX, lookY, lookZ);
                convert_cartesian_to_gl(upX, upY, upZ);

#if defined(GATE_GRAPHICS_OPENGL2_SUPPORT)
                float view_matrix[16];
                makeLookAtMatrix(eyeX, eyeY, eyeZ, 
                                 lookX, lookY, lookZ, 
                                 upX, upY, upZ,
                                 view_matrix);
                gl.uniform_matrix4fv(this->shader_loc_view, 1, false, view_matrix);
#else
                gl.setMatrixMode(OpenGL::MatrixMode_ModelView);
                gl.loadIdentity();
                gl.lookAt(eyeX, eyeY, eyeZ,
                          lookX, lookY, lookZ,
                          upX, upY, upZ);
#endif
            }

            {   // clear screen
                gl.setClearColor(0.8f, 0.8f, 1.0f, 1.0f);
                gl.setClearDepth(1.0f);
                gl.clear(OpenGL::ClearBit_ColorBuffer | OpenGL::ClearBit_DepthBuffer | OpenGL::ClearBit_StencilBuffer);
            }

            {   // draw objects
                if (this->translucentObjects)
                {
                    gl.enableCapability(OpenGL::Capability_Blend);
                    gl.setBlendFunc(OpenGL::Blend_SrcAlpha, OpenGL::Blend_OneMinusSrcAlpha);
                }

                for (CuboidList::iterator cube(this->cuboids.begin()), cubeEnd(this->cuboids.end()); cube != cubeEnd; ++cube)
                {
                    renderCuboid(gl, *cube);
                }

                for (BlockList::iterator block(this->blocks.begin()), blockEnd(this->blocks.end()); block != blockEnd; ++block)
                {
                    renderBlock(gl, block->type, block->point, block->side_bits);
                }

                //gl.disableClientState(OpenGL::ClientState_VertexArray);

                if (this->translucentObjects)
                {
                    gl.disableCapability(OpenGL::Capability_Blend);
                }
            }

            {   // finish GL drawing and swap buffers
                gl.flush();
                surface.swapBuffers();
            }
        }

        static real32_t const defaultMoveVelocity = 8.0f;
        static real32_t const defaultAngularVelocity = 1.5f;


        void BlockLevelsGame::processKeyDown(Keyboard::KeyEnum key, uint32_t state)
        {
            switch (key)
            {
            case Keyboard::Key_W:
            case Keyboard::Key_Up:
                {
                    this->moveVelocity = defaultMoveVelocity;
                    break;
                }
            case Keyboard::Key_A:
            case Keyboard::Key_Left:
                {
                    if (state & Keyboard::KeyState_Shift)
                    {
                        this->strafeVelocity = defaultMoveVelocity;
                    }
                    else
                    {
                        this->angularVelocity = defaultAngularVelocity;
                    }
                    break;
                }
            case Keyboard::Key_S:
            case Keyboard::Key_Down:
                {
                    this->moveVelocity = -defaultMoveVelocity;
                    break;
                }

            case Keyboard::Key_D:
            case Keyboard::Key_Right:
                {
                    if (state & Keyboard::KeyState_Shift)
                    {
                        this->strafeVelocity = -defaultMoveVelocity;
                    }
                    else
                    {
                        this->angularVelocity = -defaultAngularVelocity;
                    }
                    break;
                }
            case Keyboard::Key_PgUp:
                {
                    this->z += 1.0f;
                    break;
                }
            case Keyboard::Key_PgDown:
                {
                    this->z -= 1.0f;
                    break;
                }
            case Keyboard::Key_Escape:
            case Keyboard::Key_F10:
                {
                    this->ptrHost->suspend();
                    break;
                }
            default:
                {
                    break;
                }
            }
        }

        void BlockLevelsGame::processKeyUp(Keyboard::KeyEnum key, uint32_t state)
        {
            switch (key)
            {
            case Keyboard::Key_W:
            case Keyboard::Key_Up:
                {
                    this->moveVelocity = 0.0f;
                    break;
                }
            case Keyboard::Key_A:
            case Keyboard::Key_Left:
                {
                    this->strafeVelocity = 0.0f;
                    this->angularVelocity = 0.0f;
                    break;
                }
            case Keyboard::Key_S:
            case Keyboard::Key_Down:
                {
                    this->moveVelocity = 0.0f;
                    break;
                }

            case Keyboard::Key_D:
            case Keyboard::Key_Right:
                {
                    this->strafeVelocity = 0.0f;
                    this->angularVelocity = 0.0f;
                    break;
                }
            case Keyboard::Key_T:
                {
                    this->simpleBlocks = !this->simpleBlocks;
                    break;
                }
            default:
                {
                    break;
                }
            }
        }

        void BlockLevelsGame::processPointerDown(real32_t x, real32_t y, real32_t xMax, real32_t yMax)
        {
            real32_t xCenter = xMax * 0.5f;
            real32_t yCenter = yMax * 0.5f;
            real32_t move = (y - yCenter) * -1.0f / yCenter;
            real32_t direction = (x - xCenter) * -math::signum(move) / xCenter;
            this->moveVelocity = move * defaultMoveVelocity;
            this->angularVelocity = direction * defaultAngularVelocity;
        }

        void BlockLevelsGame::processPointerMove(real32_t x, real32_t y, real32_t xMax, real32_t yMax)
        {
            real32_t xCenter = xMax * 0.5f;
            real32_t yCenter = yMax * 0.5f;
            real32_t move = (y - yCenter) * -1.0f / yCenter;
            real32_t direction = (x - xCenter) * -math::signum(move) / xCenter;
            this->moveVelocity = move * defaultMoveVelocity;
            this->angularVelocity = direction * defaultAngularVelocity;
        }

        void BlockLevelsGame::processPointerUp(real32_t x, real32_t y, real32_t xMax, real32_t yMax)
        {
            this->moveVelocity = 0.0f;
            this->strafeVelocity = 0.0f;
            this->angularVelocity = 0.0f;
        }

    } // end of namespace apps
} // end of namespace gate