---

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

/*

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


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

const vec2_t vec2_c::vec2x   = { 1, 0 };
const vec2_t vec2_c::vec2y   = { 0, 1 };
const vec2_t vec2_c::vec20   = { 0, 0 };

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

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

vec2_c::vec2_c(const vec2_t v)
{
    set(v[0], v[1]);
}

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

vec2_c::vec2_c(float x, float y)
{
    set(x,y);
}

vec2_c::~vec2_c()
{
}

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

// -- 

void vec2_c::set(float x, float y)
{
    vec[0] = x;
    vec[1] = y;
}

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

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

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

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

bool vec2_c::operator ==(const vec2_t v)
{
    ulong     i; 

    AssertReturnValue1(v, false);

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

vec2_c vec2_c::operator +(const vec2_t v)
{
    return vec2_c(v[0]+vec[0], v[1]+vec[1]);
}

vec2_c vec2_c::operator -(const vec2_t v)
{
    return vec2_c(vec[0]-v[0], vec[1]-v[1]);
}

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

vec2_c vec2_c::operator *(const vec2_t v)
{
    return vec2_c(vec[0]*v[0], vec[1]*v[1]);
}

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

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

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

vec2_c vec2_c::ma_vec(const vec2_t s, const vec2_t v)
{
    return *this+vec2_c(v)*s;
}

vec2_c vec2_c::operator =(const vec2_t v)
{
    vec[0] = v[0];
    vec[1] = v[1];

    return *this;
}

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

/****************************************************************************
 * vector_rotate                                    rotates a vector (ypr) *
 ****************************************************************************/
vec2_c vec2_c::rotate
( 
    const vec_t angle
)
{ 
    float rad; 
    float radsin; 
    float radcos; 
    vec2_t tmp;
 
    rad = -angle*DEG2RAD; 
    radsin = (float)(sin(rad)); radcos = (float)(cos(rad)); 
 
    tmp[0] = vec[0]*radcos-vec[1]*radsin; 
    tmp[1] = vec[0]*radsin+vec[1]*radcos; 

    return vec2_c(tmp);
} 

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

    vec2_c vec;

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

    return vec;
} 

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

    vec2_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<2; 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;
} 

---