---

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

/*

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


*/

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

/****************************************************************************
 ****************************************************************************
 * PLANE ROUTINES ***********************************************************
 ****************************************************************************
 ****************************************************************************/ 

/****************************************************************************
 * plane_frompoints                               create plane from points *
 ****************************************************************************/
plane_t  plane_frompoints
(
    const vec3_t a, 
    const vec3_t b, 
    const vec3_t c
)
{ 
    // need optimization ;) 
    plane_t     p; 
    vec3_c      ta,tb, tmp; 

    p.d = 0;
    vec3_c(0,0,0).copy(p.n);
 
    AssertReturnValue3(a,b,c, p);

    ta = vec3_c(b) - a;
    tb = vec3_c(c) - a;
 
    tmp = ta.cross(tb);
    tmp.normalize().copy(p.n);

    p.d = -tmp.dot(a); 
 
    return p; 
} 
 
/****************************************************************************
 * plane_line_intersect                            find intersection point *
 ****************************************************************************/
float plane_line_intersect
(
    const vec3_t   a, 
    const vec3_t   b, 
    const plane_t  *p, 
    vec3_t   out
)
{ 
    AssertReturnValue4(a,b,p,out,0);

    float aDot  = vec3_c(a).dot(p->n); 
    float bDot  = vec3_c(b).dot(p->n); 
    float scale = ( p->d - aDot ) / ( bDot - aDot ); 
 
    vec3_c d; 
 
    if (bDot == aDot) 
        return 0; 
 
    d = (vec3_c(b) - a) * scale + a;
    d.copy(out);
 
    return scale; 
} 


/****************************************************************************
 * plane_pointdist                             distance of vector and plane *
 ****************************************************************************/
float plane_pointdist
( 
    const vec3_t v, 
    const plane_t *p 
) 
{ 
    AssertReturnValue1(v, 0);
    AssertReturnValue1(p, 0);

    return vec3_c(p->n).dot(v)-p->d; 
} 

/****************************************************************************
 * plane_pointside                                      vec's side of plane *
 ****************************************************************************/
int plane_pointside
( 
    const vec3_t v, 
    const plane_t *p 
) 
{ 
    AssertReturnValue1(v, 0);
    AssertReturnValue1(p, 0);

    return (int)_sgn(vec3_c(p->n).dot(v)-p->d); 
} 

/****************************************************************************
 * plane_clipbox                            intersection of a box and plane *
 ****************************************************************************/
int plane_clip_box
(
    const plane_t  *p, 
    const bbox_t   *bbox
)
{
    int         k;
    int         d;
    bool        back    = false;
    bool        front   = false;

    AssertReturnValue2(p, bbox, 0);

    for (k=0; k<8; k++)
    {
        vec3_c pt;

        pt.set( bbox->size[(k>>0)&1][0],
                bbox->size[(k>>1)&1][1],
                bbox->size[(k>>2)&1][2]  );

        d = plane_pointside(pt, p);

        if (d>0)
            front = true;
        else if (d<0) 
            back  = true;

        if (front && back)
            return 0;
    }

    if (front && !back)
        return 1;

    return -1;

    // 1 total in front
    // 0 partially in front
    // -1 all behind
}

---