r_entity.h

Go to the documentation of this file.

 
/*
Copyright (C) 1997-2001 Id Software, Inc.
 
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
 
#define MAX_ANIMLIST    8
#define MAX_ENTITY_LIGHTS 7
 
#include "r_light.h"
#include "r_lighting.h"

#define RF_NONE             0x00000000  
#define RF_TRANSLUCENT      0x00000001
#define RF_BOX              0x00000002  
#define RF_PATH             0x01000000  
#define RF_ARROW            0x02000000  

#define RF_NO_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 RF_NEUTRAL          0x00000400  
#define RF_SHADOW           0x00000800  
#define RF_OPPONENT         0x00001000  
#define RF_IRGOGGLESSHOT    0x00002000  
 
typedef struct animState_s {
    int frame;
    int oldframe;
    float backlerp;             
    int time;
    int dt;
    int mesh;                   
 
    byte list[MAX_ANIMLIST];    
    byte lcur;                  
    byte ladd;
    byte change;
 
    animState_s() :
        frame(0),
        oldframe(0),
        backlerp(0.0f),
        time(0),
        dt(0),
        mesh(0),
        lcur(0),
        ladd(0),
        change(0)
    {
        OBJZERO(list);
    }
} animState_t;

typedef struct transform_s {
    bool done;                  
    bool processing;            
    float matrix[16];           
 
    transform_s() : done(false), processing(false)
    {
        OBJZERO(matrix);
    }
} transform_t;
 
typedef struct entity_s {
    struct model_s* model;
    vec3_t angles;
    vec3_t scale;
    vec3_t color;
    vec3_t origin;
    vec3_t oldorigin;
    AABB eBox;
 
    /* tag positioning */
    struct entity_s* tagent;    
    const char* tagname;        
 
    /* misc */
    int skinnum;
    float alpha;                
    int flags;
    float distanceFromViewOrigin;
 
    bool isOriginBrushModel;    
 
    animState_t as;
 
    transform_t transform;
 
    vec4_t shell;               
 
    const image_t* texture;
 
    lighting_t* lighting;       
 
    struct entity_s* next;      
 
 
    inline entity_s (int flag = RF_NONE) :
        model(nullptr),
        eBox(AABB()),
        tagent(nullptr),
        tagname(nullptr),
        skinnum(0),
        alpha(0.0f),
        flags(flag),
        distanceFromViewOrigin(0.0f),
        isOriginBrushModel(false),
        as(animState_s()),
        transform(transform_s()),
        texture(nullptr),
        lighting(nullptr),
        next(nullptr)
    {
        VectorClear(angles);
        VectorClear(scale);
        VectorClear(color);
        VectorClear(origin);
        VectorClear(oldorigin);
        Vector4Clear(shell);
    }
 
    inline void setScale(const vec3_t scale_)
    {
        VectorCopy(scale_, scale);
    }
 
    inline vec_t getScaleX() const
    {
        return scale[0];
    }
} entity_t;
 
/* entity chains for rendering */
extern entity_t* r_opaque_mesh_entities;
extern entity_t* r_blend_mesh_entities;
extern entity_t* r_null_entities;
extern entity_t* r_special_entities;
 
 
int R_AddEntity(const entity_t* ent);
entity_t* R_GetFreeEntity(void);
entity_t* R_GetEntity(int id);
void R_EntitySetOrigin(entity_t* ent, const vec3_t origin);
void R_EntityAddToOrigin(entity_t* ent, const vec3_t offset);
void R_TransformForEntity(const entity_t* e, const vec3_t in, vec3_t out);
 
void R_DrawEntityEffects(void);
void R_DrawMeshEntities(entity_t* ents);
void R_DrawOpaqueMeshEntities(entity_t* ents);
void R_DrawBlendMeshEntities(entity_t* ents);
void R_DrawSpecialEntities(const entity_t* ents);
void R_DrawNullEntities(const entity_t* ents);