---

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

/*

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


*/

#include            "vector.h"
#include            "forward.h"

/****************************************************************************
 ****************************************************************************
 * TYPES ********************************************************************
 ****************************************************************************
 ****************************************************************************/
 
#if !defined(OMICRON_TYPES_BRUSH_DEFINED)
#define             OMICRON_TYPES_BRUSH_DEFINED

#define             BIGPOLYSIZE         1000

class brushface_c
{
protected:

    ulong           vertexcount;        
    vertex_t        *vertices;          

    plane_t         plane;              

    const struct shader_s *
                    shader;             
    vec2_c          scale, offset;      
    float           rotation;

    void                                
        createvertices();

public:

    // ctor, dtor

                    brushface_c();
                    ~brushface_c();


    void
        create_from_plane(const plane_t *p);

    bool
        cut(const plane_t *p);

    inline ulong                        
        get_vertex_count();

    inline const vertex_t *             
        get_vertices();

    inline vec3_c                       
        get_normal();

    inline const plane_t *              
        get_plane();

    void
        get_vertex(ulong num, vertex_t *out);

    void
        get_edge(ulong num, edge_t out);

    inline void                         
        set_shader(const struct shader_s *_shader);

    inline const struct shader_s *      
        get_shader();

    void
        set_tex_params(const vec2_t scale, const vec2_t offset, float rot);

    void
        draw();
        
};

// inlines

inline ulong brushface_c::get_vertex_count()
{
    AssertThisV;    return vertexcount;
}

inline const vertex_t *brushface_c::get_vertices()
{
    AssertThisV;    return vertices;
}

inline vec3_c brushface_c::get_normal()
{
    AssertThisValue(vec3_c());     
    return vec3_c(plane.n);
}

inline const plane_t *brushface_c::get_plane()
{
    AssertThisV;    return &plane;
}

inline void brushface_c::set_shader(
    const struct shader_s *_shader      
)
{
    AssertThis;     shader = _shader;
}

inline const struct shader_s *brushface_c::get_shader()
{
    AssertThisV;    return shader;
};


class brush_c
{
protected:

    array_c <brushface_c> *
                    faces;              

    edge_t          *edges;             

    ulong           edgecount;          

    const shader_t *shader;             

    void                                
        find_edges();

public:

    // ctor, dtor

                    brush_c();
                    ~brush_c();


    void
        add_plane(const plane_t *p);

    void
        set_shader(const shader_t *shader);

    void
        set_face_shader(ulong face, const shader_t *shader);


    void
        draw();

    /*
    // experimental! -->
    void                                
        ray_collide(const vec3_t p1, const vec3_t p2, collision_t *out);

    void                                
        box_collide(const bbox_t *bbox, collision_t *out);
    // <-- experimental!
    */

    brushface_c *
        get_brush_face
    (
        ulong       i                   
    )
    {
        AssertThisV;

        return faces->get(i); 
    }
};

#endif

---