cl_renderer.h

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2010 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.

*/

#ifndef CLIENT_REF_H
#define CLIENT_REF_H

#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 RF_TRANSLUCENT      0x00000001
#define RF_BOX              0x00000002  
#define RF_PATH             0x01000000  
#define RF_ARROW            0x02000000  
#define RF_SHADOW           0x00000004  
#define RF_BLOOD            0x00000008  
#define RF_SELECTED         0x00000010  
#define RF_MEMBER           0x00000020  
#define RF_ALLIED           0x00000040  
#define RF_ACTOR            0x00000080  
#define RF_PULSE            0x00000100  
#define RF_IRGOGGLES        0x00000200  
#define EARTH_RADIUS 8192.0f
#define MOON_RADIUS 1024.0f
#define SUN_RADIUS 1024.0f

#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 {
    vec3_t origin;
    vec4_t color;
    vec4_t ambient;
    float radius;
} light_t;

typedef struct sustain_s {
    light_t light;
    float time;
    float sustain;
} sustain_t;

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 {
    qboolean inuse;         
    qboolean 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 omega;   
    qboolean physics;   
    qboolean autohide;  
    qboolean stayalive; 
    qboolean weather;   
} ptl_t;

typedef struct {
    qboolean ready; 
    float fieldOfViewX, fieldOfViewY;
    vec3_t viewOrigin;
    vec3_t viewAngles;
    float time;                 
    int rendererFlags;              
    int worldlevel;
    int brushCount, aliasCount;

    int weather;                
    vec4_t fogColor;

    int numEntities;
    int numLights;
    int numCoronas;
    corona_t coronas[MAX_CORONAS];

    trace_t trace;              
    struct entity_s *traceEntity;

    mapTiles_t *mapTiles;

    const char *mapZone;        
} 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;

struct model_s *R_RegisterModelShort(const char *name);
const image_t *R_RegisterImage(const char *name);

void R_Color(const vec4_t rgba);

void R_ModBeginLoading(const char *tiles, qboolean day, const char *pos, const char *mapName);
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, qboolean *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);

#endif /* CLIENT_REF_H */