3d.h

Go to the documentation of this file.

/*
 * Copyright (C) Volition, Inc. 1999.  All rights reserved.
 *
 * All source code herein is the property of Volition, Inc. You may not sell 
 * or otherwise commercially exploit the source or things you created based on the 
 * source.
 *
*/


#ifndef _3D_H
#define _3D_H

#include "camera/camera.h"
#include "graphics/2d.h"
#include "graphics/grbatch.h"
#include "graphics/tmapper.h"
#include "math/vecmat.h"

//flags for point structure
#define PF_PROJECTED     1      //has been projected, so sx,sy valid
#define PF_OVERFLOW              2      //can't project
#define PF_TEMP_POINT    4      //created during clip

//clipping codes flags
#define CC_OFF_LEFT     1
#define CC_OFF_RIGHT    2
#define CC_OFF_BOT      4
#define CC_OFF_TOP      8
#define CC_OFF_USER     16
#define CC_BEHIND               0x80

// Combo!
#define CC_OFF                  (CC_OFF_LEFT | CC_OFF_RIGHT | CC_OFF_BOT | CC_OFF_TOP | CC_OFF_USER | CC_BEHIND)

#define g3_start_frame(zbuffer_flag) g3_start_frame_func(zbuffer_flag, __FILE__, __LINE__ )

extern void g3_start_frame_func(int zbuffer_flag, const char *filename, int lineno);

#define g3_end_frame() g3_end_frame_func( __FILE__, __LINE__ )
extern void g3_end_frame_func(const char *filename, int lineno);

extern int g3_in_frame();

void g3_set_view_angles(const vec3d *view_pos, const angles *view_orient, float zoom);

void g3_set_view(camera *cam);

void g3_set_view_matrix(const vec3d *view_pos, const matrix *view_matrix, float zoom);

// Never set these!
extern matrix           View_matrix;            // The matrix to convert local coordinates to screen
extern vec3d            View_position;          // The offset to convert local coordinates to screen

extern matrix           Light_matrix;           // Used to rotate world points into current local coordinates
extern vec3d            Light_base;                     // Used to rotate world points into current local coordinates

extern matrix           Eye_matrix;                     // Where the viewer's eye is pointing in World coordinates
extern vec3d            Eye_position;           // Where the viewer's eye is at in World coordinates
extern float            Eye_fov;                        // What the viewer's FOV is

extern vec3d Object_position;
extern matrix   Object_matrix;                  // Where the opject is pointing in World coordinates

extern float Proj_fov;                                  // Projection matrix fov (for HT&L)

void g3_draw_horizon(int sky_color,int ground_color);

void g3_draw_horizon_line();

int g3_compute_sky_polygon(float *points_2d,vec3d *vecs);

void g3_start_instance_matrix(const vec3d *pos, const matrix *orient, bool set_api = true);

void g3_start_instance_angles(const vec3d *pos, const angles *orient);

void g3_done_instance(bool set_api = false);

void g3_get_FOV(float *fov_x,float *fov_y);

float g3_get_zoom(char axis,float fov,int window_width,int window_height);

void g3_get_view_vectors(vec3d *forward,vec3d *up,vec3d *right);

int g3_check_normal_facing(const vec3d *v, const vec3d *norm);

ccodes g3_check_codes(int nv, vertex **pointlist);

ubyte g3_rotate_vertex(vertex *dest, const vec3d *src);

ubyte g3_rotate_vertex_popped(vertex *dest, const vec3d *src);

ubyte g3_rotate_faraway_vertex(vertex *dest, const vec3d *src);

int g3_project_vertex(vertex *point);

ubyte g3_project_vector(const vec3d *p, float *sx, float *sy );

ubyte g3_rotate_vector(vec3d *dest, const vec3d *src);

ubyte g3_code_vector(const vec3d * p);

float g3_calc_point_depth(const vec3d *pnt);

void g3_point_to_vec(vec3d *v,int sx,int sy);

void g3_point_to_vec_delayed(vec3d *v,int sx,int sy);

/*
 * Code a point. Fills in the p3_codes field of the point, and returns the codes
 */
ubyte g3_code_vertex(vertex *point);

vec3d *g3_rotate_delta_x(vec3d *dest,float dx);
vec3d *g3_rotate_delta_y(vec3d *dest,float dy);
vec3d *g3_rotate_delta_z(vec3d *dest,float dz);
vec3d *g3_rotate_delta_vec(vec3d *dest,vec3d *src);
ubyte g3_add_delta_vec(vertex *dest,vertex *src,vec3d *deltav);

int g3_draw_poly(int nv, vertex **pointlist,uint tmap_flags);

int g3_draw_polygon(const vec3d *pos, const matrix *ori, float width, float height, int tmap_flags = TMAP_FLAG_TEXTURED);
int g3_draw_polygon(const vec3d *pos, const vec3d *norm, float width, float height, int tmap_flags = TMAP_FLAG_TEXTURED);

int g3_draw_poly_constant_sw(int nv, vertex **pointlist, uint tmap_flags, float constant_sw);

int g3_draw_poly_if_facing(int nv, vertex **pointlist, uint tmap_flags, const vec3d *norm, const vec3d *pnt);

int g3_draw_line(vertex *p0, vertex *p1);

int g3_draw_rod(const vec3d *p0, float width1, const vec3d *p1, float width2, vertex *verts, uint tmap_flags);

int g3_draw_bitmap(vertex *pos, int orient, float radius, uint tmap_flags, float depth = 0.0f);

int g3_get_bitmap_dims(int bitmap, vertex *pos, float radius, int *x, int *y, int *w, int *h, int *size);

int g3_draw_sphere(vertex *pnt, float rad);

int g3_draw_sphere_ez(const vec3d *pnt, float rad);

float g3_draw_laser(const vec3d *headp, float head_width, const vec3d *tailp, float tail_width, uint tmap_flags = TMAP_FLAG_TEXTURED, float max_len = 0.0f );

float g3_draw_laser_rgb(const vec3d *headp, float head_width, const vec3d *tailp, float tail_width, int r, int g, int b, uint tmap_flags = TMAP_FLAG_TEXTURED | TMAP_FLAG_RGB, float max_len = 0.0f );

int g3_draw_rotated_bitmap(vertex *pnt, float angle, float radius, uint tmap_flags, float depth = 0.0f);

int g3_draw_perspective_bitmap(const angles *a, float scale_x, float scale_y, int div_x, int div_y, uint tmap_flags);

void g3_draw_2d_shield_icon(const coord2d coords[6], const int r, const int g, const int b, const int a);

void g3_draw_2d_rect(int x, int y, int w, int h, int r, int g, int b, int a);

int g3_draw_2d_poly_bitmap(float x, float y, float w, float h, uint additional_tmap_flags = 0);

void g3_start_user_clip_plane(const vec3d *plane_point, const vec3d *plane_normal);

void g3_stop_user_clip_plane();

ubyte g3_transfer_vertex(vertex *dest, const vec3d *src);

int g3_draw_2d_poly_bitmap_list(bitmap_2d_list* b_list, int n_bm, uint additional_tmap_flags);
int g3_draw_2d_poly_bitmap_rect_list(bitmap_rect_list* b_list, int n_bm, uint additional_tmap_flags);

void g3_draw_htl_line(const vec3d *start, const vec3d *end);

void g3_draw_htl_sphere(const vec3d *position, float radius);

struct flash_beam{
        vertex start;
        vertex end;
        float width;
};

class flash_ball{
        flash_beam *ray;
        vec3d center;
        int n_rays;
        static geometry_batcher batcher;
        void parse_bsp(int offset, ubyte *bsp_data);
        void defpoint(int off, ubyte *bsp_data);

public:
        flash_ball(int number, float min_ray_width, float max_ray_width = 0, const vec3d* dir = &vmd_zero_vector, const vec3d* pcenter = &vmd_zero_vector, float outer = PI2, float inner = 0.0f, ubyte max_r = 255, ubyte max_g = 255, ubyte max_b = 255, ubyte min_r = 255, ubyte min_g = 255, ubyte min_b = 255)
                :ray(NULL),n_rays(0)
        {
                        initialize(number, min_ray_width, max_ray_width, dir, pcenter, outer, inner, max_r, max_g, max_b, min_r, min_g, min_b);
        }

        ~flash_ball()
        {
                if (ray)
                        vm_free(ray);
        }

        void initialize(int number, float min_ray_width, float max_ray_width = 0, const vec3d* dir = &vmd_zero_vector, const vec3d* pcenter = &vmd_zero_vector, float outer = PI2, float inner = 0.0f, ubyte max_r = 255, ubyte max_g = 255, ubyte max_b = 255, ubyte min_r = 255, ubyte min_g = 255, ubyte min_b = 255);
        void initialize(ubyte *bsp_data, float min_ray_width, float max_ray_width = 0, const vec3d* dir = &vmd_zero_vector, const vec3d* pcenter = &vmd_zero_vector, float outer = PI2, float inner = 0.0f, ubyte max_r = 255, ubyte max_g = 255, ubyte max_b = 255, ubyte min_r = 255, ubyte min_g = 255, ubyte min_b = 255);
        void render(float rad, float intinsity, float life);
        void render(int texture, float rad, float intinsity, float life);
};
#endif