BlockCommon.h

#pragma once

#include <vector>
#include <array>
#include <unordered_set>
#include <stdint.h>
#include <bitset>

#include "BlockConfig.h"
#include "BlockCoordinate.h"
#include "BlockIndex.h"

namespace ParaEngine
{
    class Block;
    class BlockChunk;
    class BlockRegion;
    class BlockLight;
    class RenderableChunk;
    class LightGrid;
    class BlockVertexCompressed;


    enum BlockRenderPass
    {
        BlockRenderPass_Opaque = 0,
        BlockRenderPass_AlphaTest,
        BlockRenderPass_AlphaBlended,
        // do not cast shadow, this is special in deferred shading. 
        BlockRenderPass_ReflectedWater,
    };

    struct CBlockSelectGroup
    {
    public:
        CBlockSelectGroup();

        std::map<int64_t, Uint16x3>& GetBlocks();

    public:
        std::map<int64_t, Uint16x3> m_blocks;
        float m_fScaling;
        bool m_bEnableBling;
        LinearColor m_color;
        bool m_bOnlyRenderClickableArea;
        bool m_bWireFrame;
    };

    enum RelativeBlockPos
    {
        rbp_center = 0,
        rbp_pX,
        rbp_nX,
        rbp_pY,
        rbp_nY,
        rbp_pZ,
        rbp_nZ,

        rbp_pXpY,
        rbp_pXnY,
        rbp_pXpZ,
        rbp_pXnZ,

        rbp_nXpY,
        rbp_nXnY,
        rbp_nXpZ,
        rbp_nXnZ,

        rbp_pYpZ,
        rbp_pYnZ,
        rbp_nYpZ,
        rbp_nYnZ,

        rbp_pXpYpZ,
        rbp_pXpYnZ,
        rbp_pXnYPz,
        rbp_pXnYnZ,
        rbp_nXpYpZ,
        rbp_nXpYnZ,
        rbp_nXnYPz,
        rbp_nXnYnZ,
    };

    enum DirectionFlag
    {
        dir_center = 0x0000,
        dir_x = 0x0001,
        dir_nx = 0x0002,
        dir_z = 0x0004,
        dir_nz = 0x0008,
        dir_y = 0x0010,
        dir_ny = 0x0020,

        dir_xy = dir_x | dir_y,
        dir_xny = dir_x | dir_ny,
        dir_xz = dir_x | dir_z,
        dir_xnz = dir_x | dir_nz,

        dir_nxy = dir_nx | dir_y,
        dir_nxny = dir_nx | dir_ny,
        dir_nxz = dir_nx | dir_z,
        dir_nxnz = dir_nx | dir_nz,
    };

    struct PickResult
    {
        float X;
        float Y;
        float Z;
        float Distance;
        uint16_t BlockX;
        uint16_t BlockY;
        uint16_t BlockZ;
        uint16_t Side;
    };

    enum BlockRenderMethod
    {
        BLOCK_RENDER_FIXED_FUNCTION = 0,
        BLOCK_RENDER_FAST_SHADER,
        BLOCK_RENDER_FANCY_SHADER,
    };

    enum BlockGroundIDEnum
    {
        BLOCK_GROUP_ID_HIGHLIGHT = 0,
        // scale 1.01
        BLOCK_GROUP_ID_WIREFRAME,
        // scale 1
        BLOCK_GROUP_ID_WIREFRAME1,
        BLOCK_GROUP_ID_MAX = 10,
    };

    class BlockCommon
    {
    public:
        static Vector3 ConvertToRealPosition(uint16 x, uint16 y, uint16 z, int nSide = -1);
        static float ConvertToRealY(uint16 y);

        static void GetBlockPosBySide(int& x, int& y, int& z, int nSide = 4);

        static void ConvertToBlockIndex(float x,float y,float z, uint16& idx_x, uint16& idx_y, uint16& idx_z);

        static Vector3 GetBlockCenter(float x, float y, float z);

        static Vector3 GetNormalBySide(int nSide);

        static bool IsOppositeSide(int nSide1, int nSide2);

        static bool IsCornerSide(int nSide1, int nSide2);

        static void ConstrainPos(Vector3& vMovePos,const Vector3& vMinPos,  const Vector3& vMaxPos);
        static void ConstrainPos(DVector3& vMovePos, const Vector3& vMinPos, const Vector3& vMaxPos);

        static void ConstrainPosOuter(Vector3& vMovePos,const Vector3& vMinPos,  const Vector3& vMaxPos, float fBoarderDist);

        static const Int16x3 NeighborOfsTable[27];

        static const int32_t NeighborLightOrder[];
        static const int32_t RBP_SixNeighbors[];

        // x, z direction vectors : east, south, west, north
        static int32 g_xzDirectionsConst[4][2];
    };
}