LocalReflection.cc

Go to the documentation of this file.

#include <gra/reflection/LocalReflection.h>
#include <esg/SceneGraphObject.h>
#include <esg/Statistics.h>
#include <esg/explorer/ShadowExplorer.h>


using namespace gra;

bool LocalReflection::_light_visible(unsigned              i,
                                     const Vector3&        ldir,
                                     double                ldist,
                                     const Vector3&        inters,
                                     SceneGraphObject::OID loid)
{
    static Matrix3  rMat;
    static Vector3  tVec, sVec;
    static PointEnv surr;

    /*
     * test cached blocking objects
     */
    
    const LightArray::BlockingObj * pBO =
        _pLights->getBlockingObject(_useCache, i);
                
    if (pBO && pBO->pObj) { // test cached blocking objects first
        Geometry * pGeom = pBO->pObj->geometry();
        if (pGeom) {
            if (pBO->transformed) {
                Vector3 o;
                Vector3 d;
                pBO->trMat.get(rMat, tVec, sVec);
                ESG_INVERSE_TR_RAY(rMat, tVec, sVec, inters, o, ldir, d);
                pGeom->rayIntersection(&surr,
                                       ENV_WANT_INTERFERENCE|ENV_USE_CACHE,
                                       o, d, ldist);
            } else {
                pGeom->rayIntersection(&surr,
                                       ENV_WANT_INTERFERENCE|ENV_USE_CACHE,
                                       inters, ldir, ldist);
            }
            if (surr.mask & ENV_HAVE_INTERFERENCE) return false;
            else _pLights->setBlockingObj(_useCache,i,NULL,NULL);
        }
    }

    ShadowExplorer shExplorer(inters, ldir, loid, ldist);
    shExplorer.explore(*(_pScene->root()));
    pBO = &(shExplorer.getBlockingObj());
    if (pBO->pObj) { // we have shading object
        _pLights->setBlockingObj(_useCache, i, pBO->pObj,
                                 (pBO->transformed) ? &(pBO->trMat) : NULL);
        return false;
    } else {
        _pLights->setBlockingObj(_useCache, i, NULL, NULL);
        return true;
    }
}

LocalReflection::LocalReflection(DiffuseBRDF     * db,
                                 SpecularBRDF    * sb,
                                 Emittance       * e,
                                 ShadowDetection   s,
                                 unsigned          ns,
                                 unsigned          c,
                                 unsigned          u)
    : ReflectionModel(db, sb, e),
      _pLights(NULL),
      _shadowDetection(s),
      _lightTests(ns),
      _numCaches(c),
      _useCache(u)
{
}

void LocalReflection::setScene(Scene * s)
{
    _pScene = s;
    if (_pLights) delete _pLights;
    LightsExplorer explorer(_numCaches);
    if (_pScene && _pScene->root()) explorer.explore(*(_pScene->root()));
    _pLights = explorer.result();
}

Color3f* LocalReflection::illuminatePoint(PointEnv& env)
{
    if ((env.mask & ENV_HAVE_ASOC_PRIMITIVE) && env.pVisitableObj) {
        MatVisitor visitor;
        env.pVisitableObj->inspectMaterials(visitor);
        return illuminatePoint(env, visitor);
    } else
        return NULL;
}

Color3f* LocalReflection::illuminatePoint(PointEnv& env, MatVisitor& visitor)
{
    static Matrix3  rMat;
    static Vector3  tVec, sVec;
    
    if (!(_pDiffuseBRDF || _pSpecularBRDF)) {
        fprintf(stderr,"LocalReflection::illuminatePoint(): No BRDF defined\n");
        return NULL;
    }

    if (!(env.mask & (ENV_HAVE_INTERSECTION | ENV_HAVE_NORMAL))) return NULL;

    if (!_pScene) return NULL;

    Vector3       ldir;
    float         ldist;
    Color3f       contribe;
    Vector3       contribc;
    Vector3       contribb;
    Emittance   * pEmittance;
    Matrix4     * pTrMat;
    double        nl, nv = -1.0;
    Vector3       normal(env.normal);
    Vector3       trInt;
    Vector3     * pInt;
    SceneGraphObject::OID oid;

    // orient normal towards view dir (if exists)
    if (env.mask & ENV_HAVE_VIEWER_DIR) {
        nv = (env.mask & ENV_HAVE_N_DOT_D) ? -env.nd : env.viewerDir.dot(normal);
        if (nv == 0.0) return NULL;
        if (nv < 0.0) {
            normal.negate();
            nv = -nv;
        }
    }

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

     // self-emitting point of interest:
    if (_pEmittance && (env.mask & (ENV_HAVE_VIEWER_DIR|ENV_HAVE_DISTANCE))) 
        (void) _pEmittance->intensity(env.viewerDir, env.distance, *pColor);
    
    if (!_pLights) return pColor;

    Color3f auxColor;

    for (ESGint i = 0; i < LightArray::MAX_LIGHTS; i++) 
    {
        if (!_pLights->isOn(i)) continue;
        
        pEmittance = _pLights->getEmittance(i);
        if (!pEmittance) continue;

        /*
         * Get direction to the emittance and its distance
         */
        if (pEmittance->sourceLocation(ldir)) {
            pTrMat = _pLights->getTransformation(i);
            if (pTrMat) {
                pTrMat->get(rMat, tVec, sVec);
                ESG_INVERSE_TR_POINT(rMat, tVec, sVec,
                                     env.intersection, trInt);
                ldir.sub(trInt);
                pInt = &trInt;
            } else {
                ldir.sub(env.intersection);
                pInt = &(env.intersection);
            }
            ldist = ldir.length();
            ldir.scale(1.0 / ldist);
        } else {
            if (!pEmittance->beamDirection(ldir)) continue;
            pTrMat = _pLights->getTransformation(i);
            ldist = MAXFLOAT;
            if (pTrMat) {
                pTrMat->get(rMat);
                ESG_INVERSE_TR_DIR(rMat, ldir, ldir);
            }
            ldir.negate();
            pInt = NULL;
        }

        nl = ldir.dot(normal);
        if (nl == 0.0) continue;
        if (nl < 0.0) {
            if (env.mask & ENV_HAVE_VIEWER_DIR) continue; // light is on opposite half-space
            normal.negate();     // orient normal towards light source
            nl = -nl;
        }

        /*
         * Get/check BRDF reflectance of emitting source
         */
        BRDF::RetVal brdfRetDiff = BRDF::ZERO_CONTRIB;
        BRDF::RetVal brdfRetSpec = BRDF::ZERO_CONTRIB;
        if (_pDiffuseBRDF) {
            if (env.mask & ENV_HAVE_VIEWER_DIR) {
                brdfRetDiff = _pDiffuseBRDF->reflectanceVNL(visitor,
                                                            &ldir,
                                                            &(env.viewerDir),
                                                            &(normal),
                                                            nv,
                                                            nl,
                                                            contribb);
            } else {
                brdfRetDiff = _pDiffuseBRDF->reflectanceNL(visitor,
                                                           &ldir,
                                                           NULL,
                                                           &(normal),
                                                           nl,
                                                           contribb);
            }
        }
        if (_pSpecularBRDF) {
            if (env.mask & ENV_HAVE_VIEWER_DIR) {
                brdfRetSpec = _pSpecularBRDF->reflectanceVNL(visitor,
                                                             &ldir,
                                                             &(env.viewerDir),
                                                             &(normal),
                                                             nv,
                                                             nl,
                                                             contribc);
            } else {
                brdfRetSpec = _pSpecularBRDF->reflectanceNL(visitor,
                                                            &ldir,
                                                            NULL,
                                                            &(normal),
                                                            nl,
                                                            contribc);
            }
        }
        if (brdfRetDiff == BRDF::NONZERO_CONTRIB) {
            if (brdfRetSpec == BRDF::NONZERO_CONTRIB) contribb.add(contribc);
        } else{
            if (brdfRetSpec == BRDF::NONZERO_CONTRIB) contribb.set(contribc);
            else continue; // no contribution
        }

        /*
         * Then get the light intensity
         * edir = -ldir
         */
        ldir.negate();
        if (!pEmittance->intensity(ldir, ldist, contribe)) continue;
        ldir.negate();

        oid = _pLights->getOID(i);

        /*
         * Check the light visibility
         */
        if (_shadowDetection != SD_NONE) {
            Geometry * pGeom = _pLights->getGeometry(i);
            if (_shadowDetection == SD_RAY_FROM_EMITTANCE ||
                (_shadowDetection == SD_GEOMETRY_SAMPLING && ! pGeom))
            {           
#ifdef ESG_STATISTICS
                ((Counter*)Statistics::instance()->get(Statistics::OID_SHADOW_TESTS)->receptor())->increment();
                if (! _light_visible(i, ldir, ldist, env.intersection, oid)) {
                    ((Counter*)Statistics::instance()->get(Statistics::OID_SHADOW_TESTS_SUC)->receptor())->increment();
                    continue;
                }
#else
                if (! _light_visible(i, ldir, ldist, env.intersection, oid))
                    continue;
#endif // ESG_STATISTICS
            } else {
                PointEnv auxEnv;
                unsigned hits = 0;

                if (!pInt) {
                    if (pTrMat) { // pTrMat is set above
                        pTrMat->get(rMat, tVec, sVec);
                        ESG_INVERSE_TR_POINT(rMat, tVec, sVec,
                                             env.intersection, trInt);
                        pInt = &trInt;
                    } else {
                        pInt = &(env.intersection);
                    }
                }

                for (unsigned j = _lightTests; j > 0; j--) {
                    pGeom->randomSample(ENV_WANT_SURFACE_POINT, auxEnv, NULL);
                    if (auxEnv.mask & ENV_HAVE_SURFACE_POINT) {
                        ldir.set(auxEnv.intersection);
                        ldir.sub(*pInt);
                        ldist = ldir.length();
                        ldir.scale(1.0 / ldist);                               
                        if (_light_visible(i,ldir,ldist,env.intersection,oid))
                            hits++;
                        //else 
                            //fprintf(stderr,"%f %f %f, %f %f %f\n",env.intersection.x,env.intersection.y,env.intersection.z,ldir.x,ldir.y,ldir.z);
                    }
                }

                if (hits == 0 || _lightTests == 0) continue;

#ifdef ESG_STATISTICS
                ((Counter*)Statistics::instance()->get(Statistics::OID_SHADOW_TESTS)->receptor())->add(_lightTests);
                ((Counter*)Statistics::instance()->get(Statistics::OID_SHADOW_TESTS_SUC)->receptor())->add(_lightTests - hits);
#endif

                if (_lightTests > 1 && hits != _lightTests) 
                    contribe.scale((double) hits / (double) _lightTests);
            }
        }

        pColor->x += contribe.x * contribb.x * nl;
        pColor->y += contribe.y * contribb.y * nl;
        pColor->z += contribe.z * contribb.z * nl;

    } // for (ESGint i = 0; ...)

    return pColor;
}

---