FDH6.cc

Go to the documentation of this file.

#include <esg/geometry/FDH6.h>
#include <esg/mesh/BoxMesh.h>

using namespace esg;

const unsigned FDH6::DIRS      =  3;             // number of directions
const unsigned FDH6::SIZE      =  6 ;            // 2 * DIRS
const float    FDH6::FDHMat[6][3] =              // matrix of FDH
{
  {  1,  0,  0 },
  {  0,  1,  0 },
  {  0,  0,  1 },
  { -1,  0,  0 },
  {  0, -1,  0 },
  {  0,  0, -1 },
};

Vector3d* FDH6::_get_corners(unsigned  & numCorners,
                             unsigned  (*facetVert)[100],
                             unsigned    nFacetVert[]) const
{
    Vector3d* vertRepos = new Vector3d [8];

    vertRepos[0].set(_values[3], _values[1], _values[2]);
    vertRepos[0].set(_values[0], _values[1], _values[2]);
    vertRepos[0].set(_values[0], _values[1], _values[5]);
    vertRepos[0].set(_values[3], _values[1], _values[5]);
    vertRepos[0].set(_values[3], _values[4], _values[2]);
    vertRepos[0].set(_values[0], _values[4], _values[2]);
    vertRepos[0].set(_values[0], _values[4], _values[5]);
    vertRepos[0].set(_values[3], _values[4], _values[5]);
    numCorners = 8;
    
    if (facetVert && nFacetVert) {
        facetVert[0][0] = 0;
        facetVert[0][1] = 4;
        facetVert[0][2] = 5;
        facetVert[0][3] = 1;
        facetVert[1][0] = 1;
        facetVert[1][1] = 5;
        facetVert[1][2] = 6;
        facetVert[1][3] = 2;
        facetVert[2][0] = 2;
        facetVert[2][1] = 6;
        facetVert[2][2] = 7;
        facetVert[2][3] = 3;
        facetVert[3][0] = 3;
        facetVert[3][1] = 7;
        facetVert[3][2] = 4;
        facetVert[3][3] = 0;
        facetVert[4][0] = 0;
        facetVert[4][1] = 1;
        facetVert[4][2] = 2;
        facetVert[4][3] = 3;
        facetVert[5][0] = 4;
        facetVert[5][1] = 7;
        facetVert[5][2] = 6;
        facetVert[5][3] = 5;
        nFacetVert[0] = 4;
        nFacetVert[1] = 4;
        nFacetVert[2] = 4;
        nFacetVert[3] = 4;
        nFacetVert[4] = 4;
        nFacetVert[5] = 4;
    }

    return vertRepos;
}

Mesh* FDH6::_mesh(int d) const
{
    Mesh* pMesh = (Mesh*) new BoxMesh(_values[0] + _values[3],
                                      _values[1] + _values[4],
                                      _values[2] + _values[5]);
    pMesh->translate(Vector3(-_values[3], -_values[4], -_values[5]));
    return pMesh;
}

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

void FDH6::rayIntersection(PointEnv*      pPE,
                           int            mask,
                           const Vector3& origin,
                           const Vector3& direction,
                           float          maxDist)
{
    if (!pPE) {
        fprintf(stderr,"FDH6::rayIntersection(): No point environment structure defined\n");
        return;
    }
    
    pPE->mask = ENV_HAVE_NOTHING;
    
    register double t_out, t1, t2;
    double& t_in = pPE->distance;
    
    if (mask&ENV_WANT_UV_COORD)
        fprintf(stderr,"FDH6::rayIntersection(): UV mapping is not implemented");
    
    if (mask & ENV_WANT_NORMAL) {
        register int plane1 = 0, plane2 = 0;
        FDH_CLIP_LINE_INDEX_INIT(origin.x, direction.x, 0, 3);
        FDH_CLIP_LINE_INDEX_CONT(origin.y, direction.y, 1, 4);
        FDH_CLIP_LINE_INDEX_CONT(origin.z, direction.z, 2, 5);
        if (t_in < Geometry::EPS)    // ray starts inside FDH
            pPE->normal.set(_mat[plane2][0],_mat[plane2][1],_mat[plane2][2]);
        else
            pPE->normal.set(_mat[plane1][0],_mat[plane1][1],_mat[plane1][2]);
        pPE->normalOrientation = PointEnv::OUTWARDS_NORMAL;
        pPE->mask |= ENV_HAVE_NORMAL;
    } else {
        FDH_CLIP_LINE_INIT(origin.x, direction.x, 0, 3);
        FDH_CLIP_LINE_CONT(origin.y, direction.y, 1, 4);
        FDH_CLIP_LINE_CONT(origin.z, direction.z, 2, 5);
    }
    
    if (mask & ENV_WANT_DISTANCE) {
        if (t_in < Geometry::EPS) t_in = t_out; // &t_in = pPE->distance
        if (mask & ENV_WANT_INTERSECTION) {
            pPE->intersection.set(direction);
            pPE->intersection.scaleAdd(t_in, origin);
            pPE->mask |= ENV_HAVE_INTERSECTION|ENV_HAVE_DISTANCE|ENV_HAVE_INTERFERENCE;
        } else
            pPE->mask |= ENV_HAVE_DISTANCE|ENV_HAVE_INTERFERENCE;
    } else {
        if (mask & ENV_WANT_INTERSECTION) {
            pPE->intersection.set(direction);
            pPE->intersection.scaleAdd((t_in<Geometry::EPS)?t_out:t_in, origin);
            pPE->mask |= ENV_HAVE_INTERSECTION|ENV_HAVE_INTERFERENCE;
        } else
            pPE->mask |= ENV_HAVE_INTERFERENCE;  
    }
}

bool FDH6::mapToUV(const Vector3& v, Vector2& uv)
{
    // FDH matrix dependent !

    unsigned plane = 0;
    if      (v.x == _values[0]) plane = 0;
    else if (v.y == _values[1]) plane = 1;
    else if (v.z == _values[2]) plane = 2;
    else if (v.x == _values[3]) plane = 3;
    else if (v.y == _values[4]) plane = 4;
    else if (v.z == _values[5]) plane = 5;
    else return false;
    
    switch (plane) {
    case 0:
        uv.set((v.z - _values[2]) / (-_values[5] - _values[2]),
               (v.y + _values[4]) / ( _values[1] + _values[4]));
        break;
    case 1:
        uv.set((v.x + _values[3]) / (_values[0] + _values[3]),
               (v.z - _values[2]) / (-_values[5] - _values[2]));
        break;
    case 2:
        uv.set((v.x + _values[3]) / (_values[0] + _values[3]),
               (v.y + _values[4]) / (_values[1] + _values[4]));
        break;
    case 3:
        uv.set((v.z + _values[5]) / (_values[2] + _values[5]),
               (v.y + _values[4]) / (_values[1] + _values[4]));
        break;
    case 4:
        uv.set((v.x + _values[3]) / (_values[0] + _values[3]),
               (v.z + _values[5]) / (_values[2] + _values[5]));
        break;
    case 5:
        uv.set((v.x - _values[0]) / (-_values[3] - _values[0]),
               (v.y + _values[4]) / ( _values[1] + _values[4]));
        break;
    }

    return true;
}

Geometry* FDH6::clone(const Matrix4* pTrMat) const
{
  FDH6* pRet = new FDH6;
  pRet->_duplicate_attributes(*this);
  if (pTrMat) pRet->_transform(*pTrMat);
  return pRet;
}

---