cl_renderer.h

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2023 UFO: Alien Invasion.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#pragma once

#include "renderer/r_image.h"
#include "renderer/r_model.h"
#include "renderer/r_program.h"

#include <SDL.h>

/* e.g. used for sequences and particle editor */
#define RDF_NOWORLDMODEL    1
#define RDF_IRGOGGLES       2   
#define WEATHER_NONE    0
#define WEATHER_FOG     1

#define VID_NORM_WIDTH      1024
#define VID_NORM_HEIGHT     768

#define MAX_PTL_ART     1024
#define MAX_PTLS        2048

typedef struct corona_s {
    vec3_t org;
    float radius;
    vec3_t color;
} corona_t;

#define MAX_CORONAS         128

#define MAX_GL_LIGHTS 8

typedef struct {
    model_t* model;         
    const char* name;       
    float* origin;          
    float* angles;          
    float* scale;           
    float* center;          
    int frame, oldframe;    
    float backlerp;         
    int skin;               
    int mesh;               
    float* color;
} modelInfo_t;

typedef struct ptlCmd_s {
    byte cmd;   
    byte type;  
    int ref;    
} ptlCmd_t;

typedef struct ptlDef_s {
    char name[MAX_VAR]; 
    ptlCmd_t* init;     
    ptlCmd_t* run;      
    ptlCmd_t* think;    
    ptlCmd_t* round;    
    ptlCmd_t* physics;  
} ptlDef_t;

typedef enum artType_s {
    ART_PIC,
    ART_MODEL
} artType_t;

typedef struct ptlArt_s {
    char name[MAX_VAR]; 
    int frame;
    int skin;           
    union {
        const image_t* image;
        model_t* model;
    } art;
    artType_t type;     
} ptlArt_t;

typedef struct ptl_s {
    bool inuse;             
    bool invis;             
    r_program_t* program;   
    ptlArt_t* pic;          
    ptlArt_t* model;        
    blend_t blend;          
    style_t style;          
    vec2_t size;
    vec3_t scale;
    vec4_t color;
    vec3_t s;               
    vec3_t origin;          
    vec3_t offset;
    vec3_t angles;
    vec3_t lightColor;
    float lightIntensity;
    float lightSustain;
    int levelFlags;

    int skin;               
    struct ptl_s* children; 
    struct ptl_s* next;     
    struct ptl_s* parent;   
    /* private */
    ptlDef_t* ctrl;         
    int startTime;
    int frame, endFrame;
    float fps;              
    float lastFrame;        
    float tps;              
    float lastThink;
    fade_t thinkFade, frameFade;
    float t;        
    float dt;       
    float life;     
    int rounds;     
    int roundsCnt;
    float scrollS;
    float scrollT;
    vec3_t a;       
    vec3_t v;       
    vec3_t oldV;    
    vec3_t omega;   
    bool physics;   
    bool autohide;  
    bool stayalive; 
    bool weather;   
    bool hitSolid;  
    bool stick;     
    bool bounce;    
} ptl_t;

typedef struct {
    bool ready; 
    float fieldOfViewX, fieldOfViewY;
    vec3_t viewOrigin;
    vec3_t viewAngles;
    float time;                 
    int rendererFlags;          
    int worldlevel;
    int brushCount, aliasCount, batchCount;
    int FFPToShaderCount, shaderToShaderCount, shaderToFFPCount;

    int weather;                
    vec4_t fogColor;
    vec4_t ambientColor;
    vec4_t modelAmbientColor;   
    vec4_t sunDiffuseColor;
    vec4_t sunSpecularColor;
    vec4_t sunVector;           
    /* entity, dynamic lights and corona lists are repopulated each frame, don't use them as persistent */
    int numEntities;
    int numDynamicLights;
    light_t dynamicLights[MAX_GL_LIGHTS];

    /* static lights (populated when loading the world) */
    light_t staticLights[MAX_STATIC_LIGHTS];
    int numStaticLights;

    int numCoronas;
    corona_t coronas[MAX_CORONAS];

    trace_t trace;              
    struct entity_s* traceEntity;

    mapTiles_t* mapTiles;
} rendererData_t;

extern rendererData_t refdef;

/* threading state */
typedef enum {
    THREAD_DEAD,
    THREAD_IDLE,
    THREAD_CLIENT,
    THREAD_BSP,
    THREAD_RENDERER
} threadstate_t;

typedef enum {
    LONGLINES_WRAP,
    LONGLINES_CHOP,
    LONGLINES_PRETTYCHOP,

    LONGLINES_LAST
} longlines_t;

typedef struct renderer_threadstate_s {
    SDL_Thread* thread;
    threadstate_t state;
} renderer_threadstate_t;

extern renderer_threadstate_t r_threadstate;

void R_Color(const vec4_t rgba);

void R_ModBeginLoading(const char* tiles, bool day, const char* pos, const char* mapName, const char* mapZone);
void R_SwitchModelMemPoolTag(void);

void R_LoadImage(const char* name, byte** pic, int* width, int* height);

void R_FontShutdown(void);
void R_FontInit(void);
void R_FontRegister(const char* name, int size, const char* path, const char* style);
void R_FontSetTruncationMarker(const char* marker);

void R_FontTextSize(const char* fontId, const char* text, int maxWidth, longlines_t method, int* width, int* height, int* lines, bool* isTruncated);
int R_FontDrawString(const char* fontId, align_t align, int x, int y, int absX, int maxWidth, int lineHeight, const char* c, int boxHeight, int scrollPos, int* curLine, longlines_t method);