renderer.h

Go to the documentation of this file.

 
#ifndef RENDERER_H
#define RENDERER_H
 
#include "mapobjects.h"
#include "workerpool.h"
 
#include <QVector2D>
#include <QVector3D>
#include <QImage>
#include <QList>
 
#include <atomic>
#include <stdint.h>
 
#include <smmintrin.h>
 
/*****************************************************************************/
typedef enum : uint32_t {
    RENDERER_FLAG_WALLS                   = 0x0001,
    RENDERER_FLAG_SURFACES                = 0x0002,
    RENDERER_FLAG_LIGHTS                  = 0x0004,
    RENDERER_FLAG_AMBIENT_OCCLUSION       = 0x0008,
    RENDERER_FLAG_GLOWMAP_REBUILD         = 0x0010,
    RENDERER_FLAG_MOTIONBLUR              = 0x0100,
    RENDERER_FLAG_VIGNETTE                = 0x0200,
    RENDERER_FLAG_GAMMA                   = 0x0400,
    RENDERER_FLAG_MULTITHREADING          = 0x1000,
    RENDERER_FLAG_ALPHA_FEATURES          = 0x2000,
    RENDERER_FLAGS_DEFAULT                = RENDERER_FLAG_WALLS | RENDERER_FLAG_SURFACES | RENDERER_FLAG_LIGHTS | RENDERER_FLAG_AMBIENT_OCCLUSION | RENDERER_FLAG_GAMMA,
} RENDERER_FLAGS;
 
/*****************************************************************************/
typedef struct {
    QVector3D pos;
    QVector3D offset;
    float pan;
    float tilt;
} Viewpoint;
 
/*****************************************************************************/
constexpr float D2R = 3.14159265f / 180.0f;
constexpr float R2D = 180.0f / 3.14159265f;
 
/*****************************************************************************/
class Renderer
{
public:
    static constexpr int DefaultFrameResoX = 960;
    static constexpr int DefaultFrameResoY = 536;
    static constexpr int DefaultGlowmapReso = 256;
    static constexpr float DefaultGlowmapArea = 1024.0f;
    static constexpr int DefaultNodesMax = 2048;
    static constexpr int DefaultWallsMax = 1024;
    static constexpr int DefaultTexturesMax = 32;
    static constexpr int DefaultLightsMax = 64;
 
    static constexpr float GlowSampleDistance = 1.0f;
    static constexpr float GlowBleedFactor = 0.25f;
    static constexpr float LightFallOff = 32.0f;
 
    static constexpr float HeightMax =  16384.0f;
    static constexpr float HeightMin = -16384.0f;

    static constexpr uint16_t ClickNoWall = 0xFFFF;

    typedef struct {
        QVector3D pos;
        uint16_t flags;
    } Node;

    typedef struct {
        uint16_t nodeID1;
        uint16_t nodeID2;
        float height;
 
        QVector3D offset;
        Surface surfaces[WALL_SURFACES_COUNT];
        uint16_t textureID;
        uint16_t flags;
 
        uint32_t rayFront;
        uint32_t rayBack;
    } Wall;

    typedef struct {
        uint32_t * pixels;
        uint16_t size;
        uint16_t count;
        uint16_t mask;
        uint32_t block;
    } Texture;

    typedef struct {
        uint16_t nodeID;
        uint32_t color;
        float strength;
        float x, z;
        __m128 argb;
        bool still;
    } Light;
 
    Renderer();

    void init();

    void terminate();

    void render(Viewpoint & vp);

    QImage * getImage() const {return image;}

    void setFlags(RENDERER_FLAGS flags);

    void checkFlag(RENDERER_FLAGS flag, bool checked);
    RENDERER_FLAGS getFlags() const {return (RENDERER_FLAGS) flags;}

    void setGlowmapSize(int size);
    int getGlowmapSize() const {return glowmapSize;}

    void setGlowmapArea(float area);
    float getGlowmapArea() const {return glowmapArea;}

    void setFramesReso(int width, int height);
    int getFrameResoX() const {return frameResoX;}
    int getFrameResoY() const {return frameResoY;}

    void setFOVAngle(float angle);
    void setFOVDistanceNear(float distance);
    void setFOVDistanceFar(float distance);

    void clickRegister(int x, int y);

    uint16_t clickGetWallID() const {return clickWallID;}
 
// Shared render state (written by Map::pass and Env::pass)
    uint32_t flags;             
 
// Field of view
    float fovAngle;             
    float fovDistanceNear;      
    float fovDistanceFar;       
 
// Sun lighting (fed by Env::pass)
    uint32_t sunAmbient;        
    uint32_t sunRayColor;       
    QVector3D sunRayDirection;  
    float sunAmbientStrength;   
    float sunRayStrength;       
 
// Distance fog (fed by Env::pass)
    float fogDistanceNear;      
    float fogDistanceFar;       
    uint32_t fogFarColor;       
    uint16_t fogFlags;          
 
// Ambient occlusion
    float occlusionLength;      
    float occlusionDarken;      
 
// Post-fx settings
    float motionBlurFactor;     
    float vignetteInnerRadius;  
    float vignetteOuterRadius;  
    float gammaKRed;            
    float gammaKGreen;          
    float gammaKBlue;           
 
// Object pools, repopulated by Map::pass before each render
    Node * nodes;
    int nodesCount;
    int nodesAllocated;
 
    Wall * walls;
    int wallsCount;
    int wallsAllocated;
 
    Texture * textures;
    int texturesCount;
    int texturesAllocated;
 
    Light * lights;
    int lightsCount;
    int lightsAllocated;
 
// Floor / ceiling heights under the camera, updated by the last render
    float lastFloor;
    float lastCeiling;
 
private:
    static constexpr int StripsMax = 512;

    typedef enum : uint16_t {
        VSTRIP_FLAG_FREE        = 0x0000,
        VSTRIP_FLAG_INVISIBLE   = 0x0001,
        VSTRIP_FLAG_ALPHA       = 0x0004,
        VSTRIP_FLAG_HASCEILING  = 0x0100,
        VSTRIP_FLAG_HASFLOOR    = 0x0200,
        VSTRIP_FLAG_SEETHROUGH  = 0x0400,
        VSTRIP_FLAG_BACKCULLED  = 0x0800,
        VSTRIP_FLAG_HIGHLIGHTED = 0x1000,
    } VSTRIP_FLAGS;
 
    typedef struct {
        float k;
        float yTop;
        float yBot;
        float yNoclipTop;
        float yNoclipBot;
        float yDarkenTop;
        float yDarkenBot;
        float vTop;
        float vBot;
        float u;
        float dist;
        uint16_t wallId;
        bool back;
        uint16_t flags;
    } Strip;
 
    typedef struct {
        QVector3D casterPos;
        int casterX;
        float casterRx;
        float casterRz;
        float casterPC;
        float casterHorizon;
        float casterVShift;
 
        Strip vStrips[StripsMax];
        uint16_t vStripsMap[StripsMax];
        float vStripsZOrders[StripsMax];
        int vStripsCount;
 
        Strip vStripsClipped[StripsMax];
        int vStripsClippedCount;
 
        float currentCeiling;
        float currentFloor;
    } Context;
    Context renderStates[WorkerPool::WorkersMax];
 
    int frameResoX;
    int frameResoY;
    int glowmapSize;
    std::atomic<int> pendingFrameWidth;
    std::atomic<int> pendingFrameHeight;
    std::atomic<int> pendingGlowmapSize;
    Viewpoint viewPoint;
 
    QImage * image;
    uint32_t * frame;
    uint32_t * frameLast;
    bool framesAllocated;
 
    typedef struct {
        float bx, bz;
        float ex, ez;
        float dx, dz;
        float length;
        float invLen;
    } Segment;
    Segment * segments;
 
    uint32_t floorRay;
    uint32_t ceilingRay;
 
    __m128 sunAmbientArgb;
    __m128 sunRayColorArgb;
 
    float fogDistanceInv;
    float fogDistanceOffset;
 
    int clickX;
    int clickY;
    bool clickRegistered;
    uint16_t clickWallID;
 
    QVector2D sceneCornerBegin, sceneCornerEnd;
    float glowmapArea;
    float glowmapScale;
    __m128 * glowmap;
    __m128 * glowmapStill;
    __m128 glowBleed;
 
    float * pitchTable;
    float * panTable;
 
    void allocateObjects(int noNodes, int noWalls, int noTextures, int noLights);
    void allocateFrames(int width, int height);
    void allocateGlowmap(int size);
    bool allocatePixelBuffer(uint32_t *& pixels, int width, int height);
    void deallocate();
 
    void renderChunk(Context & state, int x1, int x2);
    void renderConcurrent();
 
    void fogSunMash();
    void wallsMash();
    void lightsMash();
    void glowmapChunk(__m128 * gm, bool still, int z1, int z2);
    void glowmapConcurrent(__m128 * gm, bool still);
    void texturesMash();
 
    void findFloorCeilings(Context & state);
    void renderVertical(Context & state, int depth, QList<float> stackBelow, QList<float> stackAbove, int scanTop, int scanBot);
    void drawVStrips(Context & state);
 
    void vstripAdd(Context & state, const Strip & strip, int scanTop, int scanBot);
    void vstripDraw(Context & state, const Strip & strip);
    void surfaceDraw(Context & state, const Wall & w, uint16_t sID, int scanTop, int scanBot, float height);
 
    void buildTables();
 
    void sceneBoundsInit();
    void sceneBoundsRegister(float x, float z);
    void sceneGetCoords(const float x, const float z, float & xs, float & zs);
    void worldGetCoords(const float xs, const float zs, float & x, float & z);
 
    __m128 sampleGlowmap(float gx, float gy);
 
    void configInit();
    bool configLoad(const QString & filename);
    bool configSave(const QString & filename);
};
 
extern Renderer renderer;
 
#endif // RENDERER_H