---

vector.h

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine 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.
//
// The Omicron Engine  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 The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/07 19:02:18 $
// By           :       $Author: kolrabi $
// $Id: vector.h,v 1.1.1.1 2002/12/07 19:02:18 kolrabi Exp $ 

/*

  $Log: vector.h,v $
  Revision 1.1.1.1  2002/12/07 19:02:18  kolrabi
  initial release


*/

/**************************************************************************** 
 **************************************************************************** 
 * DEFINES ****************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
/* VECTOR ELEMENTS **********************************************************/ 
 
#define         VECT_X                  0       
#define         VECT_Y                  1       
#define         VECT_Z                  2       
#define         VECT_W                  3       
 
#define         ANGLE_YAW               0       
#define         ANGLE_PITCH             1       
#define         ANGLE_ROLL              2       
 

#define         V2TOFS(a)               (float)a[0], (float)a[1] 
#define         V3TOFS(a)               V2TOFS(a), (float)a[2] 
#define         V4TOFS(a)               V3TOFS(a), (float)a[3] 

/**************************************************************************** 
 **************************************************************************** 
 * TYPEDEFS ***************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
#ifndef OMICRON_VECTOR_TYPES_DEFINED 
#define OMICRON_VECTOR_TYPES_DEFINED

typedef float       vec_t;              
typedef vec_t       vec2_t[2];          
typedef vec_t       vec3_t[3];          
typedef vec_t       vec4_t[4];          
typedef vec_t       vec5_t[5];          

typedef vec3_t      edge_t[2];          

typedef class vec3_c spline_t[3];       
typedef spline_t    patch_t[3];         

typedef struct collision_s              
{
    float           t;                  
    vec3_t          pos, normal;        
} collision_t;

typedef struct bbox_s                   
{
    vec3_t          pos1, pos2;         
    vec3_t          size[2];            
} bbox_t;
 
typedef float       matrix3_t[4][4];    
typedef float       matrix4_t[4][4];    
 
typedef struct plane_s                  
{ 
    vec3_t          n;                  
    vec_t           d;                  
} plane_t; 
 
typedef struct vertex_s                 
{ 
    vec3_t          xyz;                
    vec2_t          uv[2];              
    vec3_t          normal;             
    long            diffuse;            
} vertex_t; 

typedef struct intersection_s
{
    float           t;                  
    vec3_t          pos;                
    plane_t         plane;              
} intersection_t;


#ifndef ushort
typedef unsigned short ushort;
typedef unsigned long ulong;
#endif

class vec3_c
{
protected:

    vec3_t          vec;                

public:

    static const vec3_t          vec3x;
    static const vec3_t          vec3y;
    static const vec3_t          vec3z;
    static const vec3_t          vec30;

    vec3_c();                           
    vec3_c(const vec3_c &);             
    vec3_c(const vec3_t);               
    vec3_c(float, float, float);        

    virtual ~vec3_c();                  

    operator const float *();           

    void
    set
    ( 
        float               x,
        float               y,
        float               z
        );

    void
    set_component
    (
        int                 n,
        float               x
    );

    void
    clear
    ();

    float 
    length
    ();

    float
    length_squared             
    ();

    // ******************************************************************* //
    // OPERATIONS (OPERATORS, CROSSPRODUCT ETC)

    vec3_c                              
    operator -(const vec3_t);

//    vec3_c
//    operator +(const vec3_t);           /// add vectors

        friend vec3_c
        operator +(const vec3_t, const vec3_c);

    vec3_c
    operator *(float);                  

    vec3_c                              
    operator *(const vec3_t);

    vec3_c                              
    operator =(const vec3_t);

    bool                                
    operator ==(const vec3_t);

    vec3_c
    normalize();

    vec3_c
    cross                    
    ( 
        const vec3_t        v
    );

    float
    dot
    ( 
        const vec3_t        v
    );

    // ******************************************************************* //
    // PROJECTION

    vec3_c
    project();

    vec3_c
    project_ex(ulong w, ulong h);

    vec3_c
    unproject();

    vec3_c
    unproject_ex(ulong w, ulong h);

    vec3_c
    rotate
    ( 
        const vec3_t        angles          
    );

    vec3_c
    project_on_plane
    ( 
        const vec3_t        normal          
    );

    vec3_c
    perpendicular               
    ( 
    );

    vec3_c
    rotate_vec
    ( 
        const float         degrees,        
        const vec3_t        dir             
    );

    void
    get_view_from_angles
    ( 
        vec3_c              &forward,       
        vec3_c              &right,         
        vec3_c              &up             
    );

    ushort
    pack_normal
    ( 
    );

    /* experimental -->
    float
    vector_intersect_bbox
    (
        const vec3_t        v,              
        const bbox_t        *bbox,          
        collision_t         *out            
    );
    */

    void copy(vec3_t out)
    {
        out[0] = vec[0];
        out[1] = vec[1];
        out[2] = vec[2];
    }

    // ******************************************************************* //
    // STATIC

    static vec3_c
    unpack_normal
    ( 
        ushort      in                  
    );

    static vec3_c
    bezier_patch
    (
        const patch_t       patch,
        float               u,
        float               v
    );

    static vec3_c
    bezier_spline
    ( 
        const spline_t      spline,
        const float         frac            
    );

    static vec3_c
    hermite
    ( 
        const vec3_t        p1,             
        const vec3_t        t1,             
        const vec3_t        p2,             
        const vec3_t        t2,             
        const float         frac            
    );

    static vec3_c
    linear
    ( 
        const vec3_t        p1,             
        const vec3_t        p2,             
        const float         frac            
    );
};

#endif  // OMICRON_VECTOR_TYPES_DEFINED

// include 2 and 4 dimensional stuff too..
 
#include            "vector2.h"
#include            "vector4.h"
 
/**************************************************************************** 
 **************************************************************************** 
 * FUNCTIONS **************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 

// plane stuff

plane_t
plane_frompoints
// Creates a plane from three points that lie in that plane.
( 
    const vec3_t        a,              
    const vec3_t        b, 
    const vec3_t        c 
);

float
plane_line_intersect
( 
    const vec3_t        a,              
    const vec3_t        b,              
    const plane_t       *p,             
    vec3_t              out             
);

float
plane_pointdist
(
    const vec3_t        v,              
    const plane_t       *p              
);

int
plane_pointside
(
    const vec3_t        v,              
    const plane_t       *p              
);

int
plane_clip_box
(
    const plane_t       *p,             
    const bbox_t        *bbox           
);

// vertex stuff

void
vertex_set_ex
(
    vertex_t            *vert,          
    float               x,              
    float               y, 
    float               z, 
    float               u,              
    float               v, 
    float               lu,             
    float               lv 
);

void
vertex_set
( 
    vertex_t            *vert,          
    float               x,              
    float               y, 
    float               z, 
    float               u,              
    float               v
);

void
vertex_copy
( 
    vertex_t            *in,            
    vertex_t            *out            
);

// matrix stuff

void
matrix3_mult
( 
    const matrix3_t     a,              
    const matrix3_t     b,              
    matrix3_t           out             
);

vec3_c
operator +(const vec3_t, vec3_c);

---