Geometer.h

Go to the documentation of this file.

/*
 *
 *  Acoustic Geometer Class
 *  Header
 *
 *  Brent Lehman
 *  17 April 2002
 *
 *
 */

#ifndef GEOMETER_H
#define GEOMETER_H

#include "CyberX3D.h"

// The author wanted to eliminate unnecessary function calls 
// so he developed these macros for vector arithmetic.  For 
// those who don't know, "##" is a token-pasting operator.  
// It directs the preprocessor to paste together the tokens 
// found on either side of the operator.  For example, if the 
// variable "vec" is passed to the EXPAND macro below, as in 
// "EXPAND(vec)", the result of the macro will be "vec_x, 
// vec_y, vec_z".  The author had never used this operator 
// before.  The C++ compiler in Microsoft Visual Studio 6.0 
// handles it well and the convention appears to be portable.  
// The author hasn't actually tried it with other compilers.

// To use these macros the programmer declares three floating 
// point variables per vector.  Each vector represents a 
// different Cartesian component of that vector and as such 
// has "_x", "_y", or "_z" as a suffix.  Each triplet has the 
// same prefix.  The programmer passes on the prefixes to the 
// macros, which rely on the preprocessor to append the 
// appropriate suffixes.  Developers generally use structs 
// with members named "x", "y", and "z", but the author 
// didn't trust the compiler to handle the memory access for 
// these constructs efficiently.

using namespace CyberX3D;

namespace csl {

#define EXPAND(a) a##_x, a##_y, a##_z
#define ZERO(a) ((a##_x == 0.0f) && (a##_y == 0.0f) && (a##_z == 0.0f))
#define SET(a, x, y, z) \
    a##_x = x; \
    a##_y = y; \
    a##_z = z;
#define VECTOR_COPY(d, s) \
    d##_x = s##_x;\
    d##_y = s##_y;\
    d##_z = s##_z;
#define SCALAR_PRODUCT(p, s, a) \
    p##_x = s * a##_x;\
    p##_y = s * a##_y;\
    p##_z = s * a##_z;
#define DOT_PRODUCT(a, b) \
    (a##_x*b##_x + a##_y*b##_y + a##_z*b##_z)
#define CROSS_PRODUCT(p, a, b) \
    p##_x = a##_y * b##_z - a##_z * b##_y; \
    p##_y = a##_z * b##_x - a##_x * b##_z; \
    p##_z = a##_x * b##_y - a##_y * b##_x;
#define COMPONENTWISE_PRODUCT(p, a, b) \
    p##_x = a##_x * b##_x;\
    p##_y = a##_y * b##_y;\
    p##_z = a##_z * b##_z;
#define VECTOR_SCALE(p, s) \
    p##_x *= s;\
    p##_y *= s;\
    p##_z *= s;
#define VECTOR_SUM(s, a, b) \
    s##_x = a##_x + b##_x;\
    s##_y = a##_y + b##_y;\
    s##_z = a##_z + b##_z;
#define VECTOR_ADD(s, a) \
    s##_x += a##_x;\
    s##_y += a##_y;\
    s##_z += a##_z;
#define VECTOR_DIFF(s, a, b) \
    s##_x = a##_x - b##_x;\
    s##_y = a##_y - b##_y;\
    s##_z = a##_z - b##_z;
#define MAGNITUDE(a) \
    sqrt(a##_x*a##_x + a##_y*a##_y + a##_z*a##_z)
#define PROJECT(p, t, a, b, n, s) \
    VECTOR_DIFF(p, a, b) \
    if (ZERO(p)) \
    { \
        if (s == DOT_PRODUCT(n, a)) \
        { \
            t = 0.5f; \
            VECTOR_COPY(p, a) \
        } \
        else \
        { \
            t = 1e38f; \
            p##_x = 1e38f; \
            p##_y = 1e38f; \
            p##_z = 1e38f; \
        } \
    } \
    else \
    { \
        t = (s - DOT_PRODUCT(n, b)) / DOT_PRODUCT(n, p); \
        VECTOR_SCALE(p, t) \
        VECTOR_ADD(p, b) \
    }
#define REFLECT(r, t, a, n, s) \
    t = s - DOT_PRODUCT(n, a); \
    t += t; \
    SCALAR_PRODUCT(r, t, n) \
    VECTOR_ADD(r, a)
#define XYROTATE(r, a, phi) \
    r##_x = a##_x*cos(phi) - a##_y*sin(phi); \
    r##_y = a##_x*sin(phi) + a##_y*cos(phi); \
    r##_z = a##_z;


typedef struct {

    double distance;
    double hangle;
    double vangle;

} soundray;


typedef struct {

    int num_vertices; // How many vertices the polygon has
    int allocated_vertices; // How many vertices the data structure has room to record
    int* vertex_indices; // Indices into the global list of vertices
    float normal_x; // components of the polygons normal vector
    float normal_y;
    float normal_z;
    float offset; // ploygon's distance from the origin
    float* bounding_normals_x; // normals of polygon's bounding planes
    float* bounding_normals_y;
    float* bounding_normals_z;
    float* bounding_offsets; // bounding planes' distances from the origin

    void dump(float*, float*, float*);

} polygon;


class Geometer
{

    soundray* current_rayset; // Rays resulting from most recent computing effort
    int num_rays; // Number of rays in the current rayset
    int rayset_spaces; // Number of rays this data structure has room to record
    float max_ray_length; // radius of the clipping sphere
    float source_x;
    float source_y;
    float source_z;
    float ear_x;
    float ear_y;
    float ear_z;
    float ear_hangle; // ear's counterclockwise angle of rotation; 0 is positive X asis
    float* vertices_x;
    float* vertices_y;
    float* vertices_z;
    int* vertices_num_polygons; // number of polygons that include each vertex
    int** vertices_polygon_indices; // indices of polygons that include each vertex
    int num_vertices; // total number of vertices in the world
    int allocated_vertices; // number of vertices this data structure has room to record
    polygon* polygons; // array of all of the polygons in the world
    int num_polygons; // total number of polygons in the world
    int allocated_polygons; // how much room

    void traverse(SceneGraph& sg); // traverse the scene graph
    void traverse(Node* n, SceneGraph& sg); // traverse a node of the scene graph
    // apply transform to every descendant of the given transform node
    void apply_transform(int starting_point, CyberX3D::TransformNode* transform_node);

    // These functions are described in the code
    bool _check_ray(float from_x, float from_y, float from_z,
        float to_x, float to_y, float to_z,
        polygon* exempta, polygon* exemptb);
    int _find_rays(int depth, float vsrc_x, float vsrc_y, float vsrc_z, 
        float last_distance=0.0);

public:

    bool fileIsValid;

    Geometer();
    ~Geometer();

    void set_range(float r); // set max ray length, also known as radius of clipping sphere
    void set_source(float x, float y, float z);
    void set_ear(float x, float y, float z, float direction);
    void set_polygons(polygon* w, int n);
    void set_everything(char* filename);
    void set_everything_using_VRML(char* filename);

    soundray* find_rays();
    int number_of_rays() { return num_rays; }
};

}

#endif

---