RayTracing.cc

Go to the documentation of this file.

#include <gra/reflection/RayTracing.h>
#include <esg/Statistics.h>

using namespace gra;

void RayTracing::_check_point_of_intersection(PointEnv& surr) const
{
    // transform found intersection
    if (surr.mask & ENV_HAVE_TRANSFORMATION) {
        Matrix3 rotMat;
        surr.trMat.get(rotMat);
        surr.trMat.transform(surr.intersection);
        rotMat.transform(surr.normal);
    }

    // Get & orient normal and get its dot product with view dir.
    if (!(surr.mask & ENV_HAVE_N_DOT_D)) {
        surr.nd = -surr.normal.dot(surr.viewerDir);
        surr.mask |= ENV_HAVE_N_DOT_D;
    }
    if (surr.nd > 0.) {
       surr.normal.negate();
       surr.nd = -surr.nd;
       surr.normalOrientation = PointEnv::RANDOM_NORMAL;
    }
}

MatVisitor* RayTracing::_check_material(SceneGraphObject* o, bool firstObjHit)
{
    SceneGraphObject::OID oid = o->getOID();
    MatVisitor * pMatVisitor = _matCache[oid];
    if (!pMatVisitor) {
        pMatVisitor = new MatVisitor;
        o->inspectMaterials(*pMatVisitor);
        _matCache[oid] = pMatVisitor;
    }
    if (_pLocalReflection && firstObjHit) {
        _pLocalReflection->setEmittance(o->emittance());
        DiffuseBRDF * pDiffBRDF = o->diffuseBRDF();
        SpecularBRDF* pSpecBRDF = o->specularBRDF();
        _pLocalReflection->setDiffuseBRDF((pDiffBRDF)
                                          ? pDiffBRDF
                                          : _pDiffuseBRDF);
        _pLocalReflection->setSpecularBRDF((pSpecBRDF)
                                           ? pSpecBRDF
                                           : _pSpecularBRDF);
        _pTexture = o->texture();
    }

    return pMatVisitor;
}

PointEnv* RayTracing::_cast_ray(const Vector3& src, const Vector3& dir)
{
    _riExplorer.reinit(src, dir, _pIntersector);
    _pIntersector->init(ENV_WANT_INTERSECTION | ENV_WANT_NORMAL | 
                        ENV_WANT_ASOC_PRIMITIVE | ENV_WANT_DISTANCE | 
                        ENV_WANT_N_DOT_D);
    _riExplorer.explore(*(_pScene->root()));
    PointEnv* pNewSurr = _riExplorer.result();

    if (!pNewSurr) return NULL;

    if (!pNewSurr->mask & (ENV_HAVE_ASOC_PRIMITIVE | 
                           ENV_HAVE_INTERSECTION | 
                           ENV_HAVE_NORMAL))
    { // no intersection
        pNewSurr->pVisitableObj = NULL; 
        delete pNewSurr;
        return NULL;
    }

    pNewSurr->viewerDir.set(dir);
    pNewSurr->viewerDir.negate();
    
    if (!(pNewSurr->mask & ENV_HAVE_DISTANCE)) 
        pNewSurr->distance = ((Vector3)(pNewSurr->intersection-src)).length();

    pNewSurr->mask |= ENV_HAVE_VIEWER_DIR|ENV_HAVE_DISTANCE;

    return pNewSurr;
}

void RayTracing::_apply_texture(PointEnv& surr, Color3f& a)
{
    if (!_pTexture) return;
    
    Color3f c; 
    if (_pTexture->mapping() & Texture::UV_MAPPING) { 
        if (surr.mask & ENV_HAVE_UV_COORD) { 
            (void) _pTexture->mapUV(surr.uvCoord, c); 
            a.x *= c.x;
            a.y *= c.y;
            a.z *= c.z; 
        } else { 
            Geometry* g = surr.pVisitableObj->geometry(); 
            if (g) { 
                Vector2 uv; 
                if (g->mapToUV(surr.intersection, uv)) { 
                    (void) _pTexture->mapUV(uv, c); 
                    a.x *= c.x;
                    a.y *= c.y;
                    a.z *= c.z; 
                } 
            } 
        }
    } else { 
        if (_pTexture->mapXYZ(surr.intersection, c)) {
            a.x *= c.x;
            a.y *= c.y;
            a.z *= c.z;  
        } 
    } 
}

void RayTracing::_apply_texture(PointEnv& surr, Vector3& a)
{
    if (!_pTexture) return;
    
    Color3f c; 
    if (_pTexture->mapping() & Texture::UV_MAPPING) { 
        if (surr.mask & ENV_HAVE_UV_COORD) { 
            (void) _pTexture->mapUV(surr.uvCoord, c); 
            a.x *= c.x;
            a.y *= c.y;
            a.z *= c.z; 
        } else { 
            Geometry* g = surr.pVisitableObj->geometry(); 
            if (g) { 
                Vector2 uv; 
                if (g->mapToUV(surr.intersection, uv)) { 
                    (void) _pTexture->mapUV(uv, c); 
                    a.x *= c.x;
                    a.y *= c.y;
                    a.z *= c.z; 
                } 
            } 
        }
    } else { 
        if (_pTexture->mapXYZ(surr.intersection, c)) {
            a.x *= c.x;
            a.y *= c.y;
            a.z *= c.z;  
        } 
    } 
}

void RayTracing::_direct_illumination(PointEnv&   surr,
                                      MatVisitor& matVisitor,
                                      unsigned    actDepth,
                                      Color3f&    contribution)
{
    _pLocalReflection->setActBlockingObjCache(actDepth);
    Color3f* pContrib = _pLocalReflection->illuminatePoint(surr, matVisitor);
    if (pContrib) {
        _apply_texture(surr, *pContrib);
        contribution.x += pContrib->x * surr.energy.x;
        contribution.y += pContrib->y * surr.energy.y;
        contribution.z += pContrib->z * surr.energy.z;
        delete pContrib;
    }
}

RayTracing::RefrDir RayTracing::_refraction_dir(PointEnv&   surr,
                                                MatVisitor& matVisitor,
                                                bool        firstObjHit,
                                                Vector3&    nDir)
{
    double ior = ((firstObjHit) ?
                  _defaultMediumRefraction / matVisitor.indexOfRefraction() :
                  matVisitor.indexOfRefraction() / _defaultMediumRefraction);
    double t = 1.0 + (ior * ior) * ((surr.nd * surr.nd) - 1.0);
    
    if (t < 0.0) { // reflection inside medium
        nDir.set(surr.normal);
        nDir.scale(-2.0 * surr.nd);
        nDir.sub(surr.viewerDir);
        return REFR_DIR_REFLECTION;
    } else { // refraction into medium on another side
        Vector3 aux(surr.normal);
        nDir.set(surr.viewerDir);
        aux.scale(-ior * surr.nd - sqrt(t));
        nDir.scaleAdd(-ior, aux);
        return REFR_DIR_REFRACTION;
    }
}

void RayTracing::_reflection_dir(PointEnv& surr, Vector3& nDir)
{
    // Get reflection direction R = 2(N*L)N - L, L = vDir
    nDir.set(surr.normal);
    nDir.scale(-2.0 * surr.nd);
    nDir.sub(surr.viewerDir);

#ifdef ESG_STATISTICS
    _numReflections++;
#endif
}

void RayTracing::_cast_secondary_rays(PointEnv&   surr,
                                      unsigned    actDepth,
                                      bool        firstObjHit,
                                      Color3f&    contribution,
                                      MatVisitor& matVisitor)
{
    Vector3 nDir;
    Vector3 newPower;

    /*
     * Treat refraction
     */ 

    RefrDir       rr;
    bool          transmit;
    const Vector3 refraction = matVisitor.transparency();
    
    if (refraction.x <= 0. && refraction.y <= 0. && refraction.z <= 0.) {
        transmit = false;
    } else {    
        newPower.set(surr.energy.x * refraction.x,
                     surr.energy.y * refraction.y,
                     surr.energy.z * refraction.z);
        _apply_texture(surr, newPower);

        // skip too small contribution
        if (newPower.x < _minRayWeight &&
            newPower.y < _minRayWeight &&
            newPower.z < _minRayWeight)
        {
            transmit = false;
        } else {
#ifdef ESG_STATISTICS
            _numRefractions++;
#endif
            rr = _refraction_dir(surr, matVisitor, firstObjHit, nDir);
            transmit = true;
        }
    }

    if (transmit) {
        PointEnv* pNewSurr = _cast_ray(surr.intersection, nDir);
        if (!pNewSurr) { 
            contribution.x += _background.x * newPower.x; 
            contribution.y += _background.y * newPower.y; 
            contribution.z += _background.z * newPower.z; 
            return; 
        } 
        pNewSurr->energy.set(newPower);
        /* We have new intersection => trace the ray racursivelly */
        _illuminate(*pNewSurr, actDepth+1,
                    (rr == REFR_DIR_REFLECTION) ? false : !firstObjHit,
                    contribution); 
        delete pNewSurr;

        // skip potential second reflection
        if (rr == REFR_DIR_REFLECTION) return; 
    }



    /*
     * Treat reflection
     */

    const Vector3 reflection = matVisitor.reflection();
    if (!firstObjHit ||
        (reflection.x <= 0. && reflection.y <= 0. && reflection.z <= 0))
        return;
    
    newPower.set(surr.energy.x * reflection.x,
                 surr.energy.y * reflection.y,
                 surr.energy.z * reflection.z);
    _apply_texture(surr, newPower);

    if (newPower.x < _minRayWeight &&
        newPower.y < _minRayWeight &&
        newPower.z < _minRayWeight) return;

    _reflection_dir(surr, nDir);

    PointEnv* pNewSurr = _cast_ray(surr.intersection, nDir);
    if (!pNewSurr) { 
        contribution.x += _background.x * newPower.x; 
        contribution.y += _background.y * newPower.y; 
        contribution.z += _background.z * newPower.z; 
        return; 
    } 
    pNewSurr->energy.set(newPower);
    /* We have new intersection => trace the ray racursivelly */
    _illuminate(*pNewSurr, actDepth+1, true, contribution); 
    delete pNewSurr; 
}

void RayTracing::_illuminate(PointEnv&      surr,
                             unsigned       actDepth,
                             bool           firstObjHit,
                             Color3f&       contribution)
{
    /*
     * We suppose that the given "surr" contains proper point of intersection,
     * normal vector and associated primitive.
     *
     * Transform point of intersection and properly orient normal.
     */
    _check_point_of_intersection(surr);
    
    /*
     * Inspect attributes that are necessary for local illumination,
     * reflection and transmission. Set correct BRDF and emittance for local
     * reflection. If the point of interest is the second point of refraction
     * ray then previous material is used (the object was not changed)
     */
    MatVisitor* pMatVisitor = _check_material(surr.pVisitableObj, firstObjHit);

    /*
     * Get local contribution from visible lights. Light visibility
     * is checked inside the local reflection when intersector is
     * properly set.
     */
    _direct_illumination(surr, *pMatVisitor, actDepth, contribution);

    if (actDepth >= _maxDepth) return;

    /*
     * Traverse transmission and mirror rays
     */
    _cast_secondary_rays(surr, actDepth+1, firstObjHit,
                         contribution, *pMatVisitor);
}



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

Color3f* RayTracing::illuminatePoint(PointEnv & env)
{
    if (!(_pLocalReflection && (_pDiffuseBRDF || _pSpecularBRDF))) return NULL;
    if (!(_pScene && _pScene->root())) return NULL;
    if (!_pIntersector) return NULL;
    if (!(env.mask & (ENV_HAVE_INTERSECTION|
                      ENV_HAVE_NORMAL|
                      ENV_HAVE_ASOC_PRIMITIVE|
                      ENV_HAVE_VIEWER_DIR))) return NULL;
    
    if (! env.pVisitableObj) return NULL;

    if (!(env.mask & ENV_HAVE_ENERGY)) env.energy.set(1.,1.,1.);

    Color3f* pColor = new Color3f(0.0, 0.0, 0.0);

#ifdef esG_STATISTICS
    _numReflections = (_numRefractions = 0);
#endif

    _illuminate(env, 0, true, *pColor);

#ifdef ESG_STATISTICS
    ((Counter*)Statistics::instance()->get(Statistics::OID_REFLECTIONS)->receptor())->add(_numReflections);
    ((Counter*)Statistics::instance()->get(Statistics::OID_REFRACTIONS)->receptor())->add(_numRefractions);
#endif
    
    return pColor;
}

---