Rectangle.cc

Go to the documentation of this file.

#include <esg/geometry/Rectangle.h>

using namespace esg;

void esg::Rectangle::_duplicate_attributes (const Geometry& src)
{
    Polygon::_duplicate_attributes(src);

    _width = ((Rectangle&)src)._width;
    _width = ((Rectangle&)src)._height;
    _xDir.set(((Rectangle&)src)._xDir);
    _yDir.set(((Rectangle&)src)._yDir);
}

void esg::Rectangle::_rotateX(float a)
{
    Matrix3d trMat;
    trMat.rotX(a);
    for (unsigned i = 0; i < _nVert; i++) {
        trMat.transform(_vertices[i]);
        if (haveVertNormals()) trMat.transform(_normals[i]);
    }
    trMat.transform(_normal);
    trMat.transform(_xDir);
    trMat.transform(_yDir);
    _set_edge_projection();
    _precompute_proj();
    _fxyz = - _normal.dot(_get_vertex(0));
}

void esg::Rectangle::_rotateY(float a)
{
    Matrix3d trMat;
    trMat.rotY(a);
    for (unsigned i = 0; i < _nVert; i++) {
        trMat.transform(_vertices[i]);
        if (haveVertNormals()) trMat.transform(_normals[i]);
    }
    trMat.transform(_normal);
    trMat.transform(_xDir);
    trMat.transform(_yDir);
    _set_edge_projection();
    _precompute_proj();
    _fxyz = - _normal.dot(_get_vertex(0));
}

void esg::Rectangle::_rotateZ(float a)
{
    Matrix3d trMat;
    trMat.rotZ(a);
    for (unsigned i = 0; i < _nVert; i++) {
        trMat.transform(_vertices[i]);
        if (haveVertNormals()) trMat.transform(_normals[i]);
    }
    trMat.transform(_normal);
    trMat.transform(_xDir);
    trMat.transform(_yDir);
    _set_edge_projection();
    _precompute_proj();
    _fxyz = - _normal.dot(_get_vertex(0));
}

void esg::Rectangle::_rotate(float a, const Vector3& axis)
{
    Matrix4d trMat;
    Matrix3d rotMat;
    trMat.rotationGL(a, axis);
    trMat.get(rotMat);
    for (unsigned i = 0; i < _nVert; i++) {
        trMat.transform(_vertices[i]);
        if (haveVertNormals()) rotMat.transform(_normals[i]);
    }
    rotMat.transform(_normal);
    rotMat.transform(_xDir);
    rotMat.transform(_yDir);
    _set_edge_projection();
    _precompute_proj();
    _fxyz = - _normal.dot(_get_vertex(0));
}

void esg::Rectangle::_rotate(const Matrix3& rotMat)
{
    for (unsigned i = 0; i < _nVert; i++) {
        rotMat.transform(_vertices[i]);
        if (haveVertNormals()) rotMat.transform(_normals[i]);
    }
    rotMat.transform(_normal);
    rotMat.transform(_xDir);
    rotMat.transform(_yDir);
    _set_edge_projection();
    _precompute_proj();
    _fxyz = - _normal.dot(_get_vertex(0));
}

void esg::Rectangle::_translate(float x, float y, float z)
{
    for (unsigned i = 0; i < _nVert; i++) {
        _vertices[i].add(Vector3d(x,y,z));
    }
    _fxyz = - _normal.dot(_get_vertex(0));
}

void esg::Rectangle::_transform(const Matrix4& trMat)
{
    Matrix3d rotMat;
    trMat.get(rotMat);
    for (unsigned i = 0; i < _nVert; i++) {
        trMat.transform(_vertices[i]);
        if (haveVertNormals()) rotMat.transform(_normals[i]);
    }
    rotMat.transform(_normal);
    rotMat.transform(_xDir);
    rotMat.transform(_yDir);
    _set_edge_projection();
    _precompute_proj();
    _fxyz = - _normal.dot(_get_vertex(0));
}

void esg::Rectangle::_scale(float s)
{
    for (unsigned i = 0; i < _nVert; i++) _vertices[i].scale(s);
    _width  *= s;
    _height *= s;
    _precompute_proj();
    _fxyz *= s;
}


//-------- public ----------

esg::Rectangle::Rectangle(const Vector3& corner,
                          const Vector3& u,
                          const Vector3& v,
                          const Vector2  uva[4],
                          bool           oneside)
{
    _normals  = NULL;
    _uvCoords = NULL;
    _proj     = NULL;
    _nVert    = 4;
    _vertices = new Vector3d [4];
    
    _vertices[0].set(corner);
    _vertices[1].set(_vertices[0]); _vertices[1].add(u);
    _vertices[2].set(_vertices[1]); _vertices[2].add(v);
    _vertices[3].set(_vertices[0]); _vertices[3].add(v);
    
    if (uva) {
        _uvCoords = new Vector2 [4];
        for (unsigned i = 0; i < 4; i++) _uvCoords[i].set(uva[i]);
    }
    
    _normal.set(_get_facet_normal());
    _normalFixed = oneside;
    _fxyz = - _normal.dot(_get_vertex(0));
    _set_edge_projection();

    _width  = u.length();
    _height = v.length();
    _xDir.set(u); _xDir.normalize();
    _yDir.set(v); _yDir.normalize();
}

esg::Rectangle::Rectangle(const Vector3& corner,
                     const Vector3& u,
                     const Vector3& v,
                     const Vector2  uva[4],
                     bool           oneside,
                     const Vector3& normal)
{
    _normals  = NULL;
    _uvCoords = NULL;
    _proj     = NULL;
    _nVert    = 4;
    _vertices = new Vector3d [4];

    _vertices[0].set(corner);
    _vertices[1].set(_vertices[0]); _vertices[1].add(u);
    _vertices[2].set(_vertices[1]); _vertices[2].add(v);
    _vertices[3].set(_vertices[0]); _vertices[3].add(v);

    if (uva) {
        _uvCoords = new Vector2 [4];
        for (unsigned i = 0; i < 4; i++) _uvCoords[i].set(uva[i]);
    }

    _normal.set(normal);
    _normalFixed = oneside;
    _fxyz = - _normal.dot(_get_vertex(0));
    _set_edge_projection();

    _width  = u.length();
    _height = v.length();
    _xDir.set(u); _xDir.normalize();
    _yDir.set(v); _yDir.normalize();
}

void esg::Rectangle::randomSample(int mask, PointEnv& pe, double* pdf)
{
    pe.mask = ENV_HAVE_NOTHING;

    if (mask & (ENV_WANT_SURFACE_POINT|ENV_WANT_NORMAL|ENV_WANT_UV_COORD)) {
        double u = ESG_DBL_RAND * _width;
        double v = ESG_DBL_RAND * _height;
        Vector3 aux(_xDir);
        aux.scale(u);
        pe.intersection.set(_yDir);
        //fprintf(stderr,"1: %f %f %f\n",pe.intersection.x,pe.intersection.y,pe.intersection.z);
        pe.intersection.scaleAdd(v, aux);
        //fprintf(stderr,"2: %f %f %f\n",pe.intersection.x,pe.intersection.y,pe.intersection.z);
        pe.intersection.add(_get_vertex(0));
        //fprintf(stderr,"0: %f %f %f\n",_get_vertex(0).x,_get_vertex(0).y,_get_vertex(0).z);
        //fprintf(stderr,"3: %f %f %f\n",pe.intersection.x,pe.intersection.y,pe.intersection.z);
        pe.uvCoord.set(u,v);
        pe.mask |= (ENV_HAVE_SURFACE_POINT|ENV_HAVE_UV_COORD);

        if (mask & ENV_WANT_NORMAL) {
            pe.normal.set(_normal);
            pe.mask |= ENV_HAVE_NORMAL;
            pe.normalOrientation =
                (_normalFixed) ? PointEnv::OUTWARDS_NORMAL : PointEnv::RANDOM_NORMAL;
        }
    }
}

---