---

m_vector4.cpp

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:06 $
// By           :       $Author: kolrabi $
// $Id: m_vector4.cpp,v 1.1.1.1 2002/12/07 19:02:06 kolrabi Exp $ 

/*

  $Log: m_vector4.cpp,v $
  Revision 1.1.1.1  2002/12/07 19:02:06  kolrabi
  initial release


*/
 
#include            "omicron/internal.h"
#include            <math.h>

const vec4_t vec4_c::vec4x   = { 1, 0, 0, 0 };
const vec4_t vec4_c::vec4y   = { 0, 1, 0, 0 };
const vec4_t vec4_c::vec4z   = { 0, 0, 1, 0 };
const vec4_t vec4_c::vec4w   = { 0, 0, 0, 1 };
const vec4_t vec4_c::vec40   = { 0, 0, 0, 0 };

/**************************************************************************** 
 **************************************************************************** 
 * VECTOR ROUTINES ********************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

vec4_c::vec4_c()
{
    set(0,0,0,0);
}

vec4_c::vec4_c(const vec4_t v)
{
    set(v[0], v[1], v[2], v[3]);
}

vec4_c::vec4_c(const vec4_c &v)
{
    set(v.vec[0], v.vec[1], v.vec[2], v.vec[3]);
}

vec4_c::vec4_c(float x, float y, float z, float w)
{
    set(x,y,z,w);
}

vec4_c::~vec4_c()
{
}

vec4_c::operator const float*()
{
    return vec;
}

// -- 

void vec4_c::set(float x, float y, float z, float w)
{
    vec[0] = x;
    vec[1] = y;
    vec[2] = z;
    vec[3] = w;
}

void vec4_c::set_component(int n, float x)
{
    vec[n] = x;
}

void vec4_c::clear()
{
    set(0,0,0,0);
}

float vec4_c::length()
{
    return (float)sqrt(
        vec[VECT_X]*vec[VECT_X] +
        vec[VECT_Y]*vec[VECT_Y] +
        vec[VECT_Z]*vec[VECT_Z] +
        vec[VECT_W]*vec[VECT_W]
        );       // sqrts are slow :( 
}

float vec4_c::length_squared()
{
    return vec[VECT_X]*vec[VECT_X] + vec[VECT_Y]*vec[VECT_Y] + vec[VECT_Z]*vec[VECT_Z] + vec[VECT_W]*vec[VECT_W];
}

bool vec4_c::operator ==(const vec4_t v)
{
    ulong     i; 

    AssertReturnValue1(v, false);

    for (i=0 ; ++i<4;) 
        if (fabs(vec[i]-v[i]) > EQUAL_EPSILON) 
            return false; 
 
    return true; 
}

vec4_c vec4_c::operator +(const vec4_t v)
{
    return vec4_c(v[0]+vec[0], v[1]+vec[1], v[2]+vec[2], v[3]+vec[3]);
}

vec4_c vec4_c::operator -(const vec4_t v)
{
    return vec4_c(vec[0]-v[0], vec[1]-v[1], vec[2]-v[2], vec[3]-v[3]);
}

vec4_c vec4_c::operator *(const float f)
{
    return vec4_c(f*vec[0], f*vec[1], f*vec[2], f*vec[3]);
}

vec4_c vec4_c::operator *(const vec4_t v)
{
    return vec4_c(vec[0]*v[0], vec[1]*v[1], vec[2]*v[2], vec[3]*v[3]);
}

/**************************************************************************** 
 * vector_dot                                        calculate dot product * 
 ****************************************************************************/
float vec4_c::dot
( 
    const vec4_t v
) 
{ 
    AssertReturnValue1(v, 0);

    return  v[VECT_X]*vec[VECT_X] + 
            v[VECT_Y]*vec[VECT_Y] +
            v[VECT_Z]*vec[VECT_Z] +
            v[VECT_W]*vec[VECT_W]
            ; 
} // vector_dot 

vec4_c vec4_c::ma(const vec_t s, const vec4_t v)
{
    return *this+vec4_c(v)*s;
}

vec4_c vec4_c::ma_vec(const vec4_t s, const vec4_t v)
{
    return *this+vec4_c(v)*s;
}

vec4_c vec4_c::operator =(const vec4_t v)
{
    vec[0] = v[0];
    vec[1] = v[1];
    vec[2] = v[2];
    vec[3] = v[3];

    return *this;
}

vec4_c vec4_c::normalize()
{
    return *this * (1/length());
}

/****************************************************************************
 * vector_linear                              interpolation of two vectors *
 ****************************************************************************/
vec4_c vec4_c::linear
(
    const vec4_t p1, 
    const vec4_t p2, 
    float frac
) 
{ 
    AssertReturnValue2(p1,p2, vec4_c());

    vec4_c vec;

    for (ulong i=0; i<4; i++) 
        vec.set_component(i, _interpolate_float_linear(p1[i], p2[i], frac));

    return vec;
} 

/****************************************************************************
 * vector_hermite                     hermite interpolation of two vectors *
 ****************************************************************************/
vec4_c vec4_c::hermite
(
    const vec4_t p1, 
    const vec4_t t1, 
    const vec4_t p2, 
    const vec4_t t2, 
    float   frac
) 
{ 
    AssertReturnValue4(p1,p2,t1,t2, vec4_c());

    vec4_c vec;

    float tsquared  = frac*frac; 
    float tsquared3 = tsquared*3; 
    float tcubed    = frac*tsquared; 
    float tcubed2   = tcubed*2; 
    float t         = frac; 
 
    float a = (tcubed2-tsquared3+1); 
    float b = (tcubed-(2*tsquared)+t); 
    float c = (tcubed-tsquared); 
    float d = (-tcubed2+tsquared3); 
 
    for (ulong i=0; i<4; i++) 
    { 
        float   pa = p1[i]; 
        float   pb = p2[i]; 
        float   ma = t1[i]; 
        float   mb = t2[i]; 
 
        vec.set_component(i, a*pa+b*ma+c*mb+d*pb);
    } 

    return vec;
} 

---