---

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

/*

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


*/

#include            "omicron/internal.h"
#include            "omicron/render.h"
#include            "omicron/array.h"
#include            "omicron/brush.h"

/****************************************************************************
 ****************************************************************************
 * BRUSHFACE CLASS **********************************************************
 ****************************************************************************
 ****************************************************************************/

brushface_c::brushface_c()
{
    // init
    vertexcount = 0;
    vertices    = NULL;
    shader      = NULL;
}

brushface_c::~brushface_c()
{
    AssertThis;

    SafeArrayDelete(vertices);
}

void
brushface_c::create_from_plane
(
    const plane_t * p                  
)
{
    AssertThis;
    AssertReturn1(p);

    SafeArrayDelete(vertices);
    plane = *p;

    scale.set(1,1);
    offset.set(0,0);
    rotation = 0;

    createvertices();
}

void
brushface_c::createvertices
(
)
{
    AssertThis;

    // reset vertices
    SafeArrayDelete(vertices);

    // create face
    vec3_c     vu, vv, vn, vtn;

    vn = plane.n;

    vtn.set(    (float)fabs(vn[0]),
                (float)fabs(vn[1]),
                (float)fabs(vn[2]) );

    // find u and v vectors
    if (vtn[0]>=vtn[1] && vtn[0]>=vtn[2])       // plane normal goes to x
        vu = vec3_c::vec3z;
    else if (vtn[1]>vtn[0] && vtn[1]>=vtn[2])   // plane normal goes to y
        vu = vec3_c::vec3x;
    else if (vtn[2]>vtn[1] && vtn[2]>vtn[0])    // plane normal goes to z
        vu = vec3_c::vec3y;

    // find a v vector
    vv = vu.cross(vn);

    // correct v vector
    vu = vv.cross(vu);

    vv = vv.normalize() * BIGPOLYSIZE;
    vu = vu.normalize() * BIGPOLYSIZE;

    // create a quad
    vertices = new vertex_t[4];
    vertexcount = 4;

    for (ulong i=0; i<4; i++)
    {
        // set quad vertices

                (vu * QUADVERTX(i) + vv * QUADVERTY(i) + vec3_c(plane.n) * plane.d).copy(vertices[i].xyz);

        // set texture coordinates
        vec2_c(
            QUADVERTX(i)*BIGPOLYSIZE*scale[0]+offset[0], 
            QUADVERTY(i)*BIGPOLYSIZE*scale[1]+offset[1]).copy(vertices[i].uv[0]);

        // other vertex stuff
        vertices[i].diffuse = 0xFFFFFFFF;
        (vec3_c(plane.n)).copy(vertices[i].normal);
    }

    // done
}

bool
brushface_c::cut
(
    const plane_t * p                   
)
{
    AssertThisV;
    AssertReturnValue2(p, vertices, false);

    vertex_t    *tmpverts   = new vertex_t[vertexcount+2];
    ulong       vcount      = 0;

    ulong       idxthis     = vertexcount-1;
    ulong       idxnext     = 0;

    sshort      sidethis    = -_sgn(plane_pointdist(vertices[idxthis].xyz, p));
    sshort      sidenext    = 0;
    
    // cut the polygon as sutherland and hodgeman would :)
    for (idxnext=0; idxnext<vertexcount; ++idxnext)
    {
        sidenext = -_sgn(plane_pointdist(vertices[idxnext].xyz, p));

        // if in front of plane just add the vertex
        if (sidethis>=0)
            vertex_copy(&vertices[idxthis], &tmpverts[vcount++]);

        // crossed the plane?
        if (sidethis == -sidenext && sidethis)
        {
            vec3_c      v;
            vec3_t      vt;
            vertex_t    *vx;
            float       frac;

            vx = &tmpverts[vcount++];
            
            frac = plane_line_intersect(vertices[idxthis].xyz, 
                                        vertices[idxnext].xyz, p, vt);

            v = vt;

            v.copy(vx->xyz);
            vec3_c(plane.n).copy(vx->normal);

            vec2_c::linear(vertices[idxthis].uv[0], 
                           vertices[idxnext].uv[0], frac).copy(vx->uv[0]);
                           
            vec2_c::linear(vertices[idxthis].uv[1], 
                           vertices[idxnext].uv[1], frac).copy(vx->uv[1]);
                           
            vx->diffuse = vertices[idxthis].diffuse;
        }
        idxthis     = idxnext;
        sidethis    = sidenext;
    }

    SafeArrayDelete(vertices);
    vertexcount = vcount;
    vertices    = tmpverts;

    return (vertexcount==0);
}

void
brushface_c::get_vertex
(
    ulong           num,                
    vertex_t *      out                 
)
{
    AssertThis;

    AssertReturn2(out, vertices);

    vertex_copy(&vertices[num%vertexcount], out);
}

void
brushface_c::get_edge
(
    ulong           num,                
    edge_t          out                 
)
{
    AssertThis;
    AssertReturn2(out, vertices);

    (vec3_c(vertices[num%vertexcount].xyz)).copy(out[0]);
    (vec3_c(vertices[(num+1)%vertexcount].xyz)).copy(out[1]);
}

void
brushface_c::set_tex_params
(
    const vec2_t    _scale,             
    const vec2_t    _offset,            
    float           rot                 
)
{
    AssertThis;

    scale       = _scale;
    offset      = _offset;
    rotation    = rot;
}

void
brushface_c::draw
()
{
    AssertThis;

    AssertReturn1(vertices);

    gv.renderer->use_shader(shader);
    gv.renderer->render_verts(vertices, vertexcount, PT_TRIANGLEFAN);
}

/****************************************************************************
 ****************************************************************************
 * BRUSH CLASS **************************************************************
 ****************************************************************************
 ****************************************************************************/

brush_c::brush_c()
{
    faces       = new array_c<brushface_c>;
    edges       = NULL;
    edgecount   = 0;
}

brush_c::~brush_c()
{
    AssertThis;

    for (slong i=0; i<faces->get_count(); i++)
    {
        brushface_c *f = faces->get(i);
        SafeDelete(f);
    }
    SafeDelete(faces);
    SafeArrayDelete(edges);
}

void
brush_c::add_plane
(
    const plane_t * p                   
)
{
    AssertThis;
    AssertReturn1(p);

    brushface_c    *face;
    face = new brushface_c;

    face->create_from_plane(p);
    face->set_shader(shader);
    faces->add(face);

    for (slong i=0; i<faces->get_count(); i++)
    {
        brushface_c *f = faces->get(i);

        if (f)
        {
            for (slong j=0; j<faces->get_count(); j++)
            {
                if (i==j) continue;

                brushface_c *f2 = faces->get(j);

                if (f2)
                {
                    if (f->cut(f2->get_plane()))
                    {
                        faces->remove(i);
                        SafeDelete(f);
                        break;
                    }
                }
            }
        }
    }

    // create edge table
    find_edges();
}

void
brush_c::set_shader
(
    const shader_t *_shader             
)
{
    AssertThis;

    for (slong i=0; i<faces->get_count(); i++)
    {
        brushface_c *f = faces->get(i);

        if (f)
            f->set_shader(_shader);
    }

    shader = _shader;
}

void
brush_c::set_face_shader
(
    ulong           face,               
    const shader_t *shader              
)
{
    AssertThis;

    if ((slong)face>faces->get_count())
        return;

    ulong num = 0;

    for (slong i=0; i<faces->get_count(); i++)
    {
        brushface_c *f = faces->get(i);

        if (f)
        {
            if (++num = face)
                f->set_shader(shader);
        }
    }
}

void
brush_c::draw
()
{
    AssertThis;

    AssertReturn1(faces);

    for (slong i=0; i<faces->get_count(); i++)
    {
        brushface_c *f = faces->get(i);

        if (f)
            f->draw();
    }
}

void
brush_c::find_edges
()
{
    AssertThis;

    SafeArrayDelete(edges);

    edgecount = 0;

    AssertReturn1(faces);

    slong i, edge = 0;

    for (i=0; i<faces->get_count(); i++)
    {
        brushface_c *f = faces->get(i);

        if (f)
            edgecount += f->get_vertex_count();
    }

    edges = new edge_t[edgecount];

    AssertReturn1(edges);

    for (i=0; i<faces->get_count(); i++)
    {
        brushface_c *f = faces->get(i);

        if (f)
            for (ulong j=0; j<f->get_vertex_count(); j++)
                f->get_edge(j, edges[edge++]);
    }
}

/* experimental -->

// collide brush agains ray
void brush_c::ray_collide(const vec3_t p1, const vec3_t p2, collision_t *out)
{
    AssertThis;

    AssertReturn3(p1, p2, out);

    float   t;
    slong   i;
    vec3_c  v;
    vec3_t  vt;

    out->t = 1;
    vec3_c(p2).copy(out->pos);
    vec3_c(0,0,0).copy(out->normal);

    for (i=0; i<faces->get_count(); i++)
    {
        brushface_c *f = faces->get(i);

        if (f)
        {
            t = plane_line_intersect(p1, p2, f->get_plane(), vt);
            v = vt;

            if (t>0 && t<1)
            {
                bool broke = false;

                for (slong j=0; j<(slong)f->get_vertex_count(); j++)
                {
                    if (i==j) continue;

                    brushface_c *f2 = faces->get(j);

                    if (!f2) continue;

                    if (plane_pointdist(v, f2->get_plane())>0)
                    {
                        broke = true;
                        break;
                    }
                }

                out->t = t;
                v.copy(out->pos);
                f->get_normal().copy(out->normal);
                return;
            }
        }
    }
}

// collide brush agains box
void brush_c::box_collide(const bbox_t *bbox, collision_t *out)
{
    AssertThis;

    AssertReturn2(bbox, out);

    ulong  k;
    
    vec3_c d;

    collision_t tmpout;

    d = vec3_c(bbox->pos1) - bbox->pos2;

    // check each bbox vertex for collision with faces
    for (k=0; k<8; k++)
    {
        vec3_c v;
        vec3_c p, p2;

        v[0] = bbox->size[(k>>0)&1][0];
        v[1] = bbox->size[(k>>1)&1][0];
        v[2] = bbox->size[(k>>2)&1][0];

        if (v.dot(d)>0)
            continue;

        // check
        p  = v + bbox->pos1;
        p2 = v + bbox->pos2;
        raycollide(p, p2, &tmpout);

        if (tmpout.t<1 && tmpout.t>=0)
        {
            (vec3_c(tmpout.pos) - (float*)v).copy(bbox->pos2);

            *out = tmpout;
            break;
        }
    }

    if (edges)
    // check each brush vertex for collision with bbox
    for (k=0; k<edgecount; k++)
    {
        vec3_c v;

        v = edges[k][0];

        vector_intersect_bbox(v, bbox, &tmpout);

        if (tmpout.t<1 && tmpout.t>=0)
        {
            if (tmpout.t < out->t)
            {
                *out = tmpout;
                vector_linear(bbox->pos1, bbox->pos2, out->t, bbox->pos2);
                break;
            }
        }
    }
}

*/

---