RTRender.cc

Go to the documentation of this file.

#include <gra/render/RTRender.h>
#include <esg/explorer/RayIntExplorer.h>
#include <gra/shader/RTShader.h>
#include <esg/Statistics.h>
#include <time.h>

using namespace gra;

void RTRender::_render_pixel_point(RayIntExplorer&   explorer,
                                   SceneGraphObject& scene,
                                   Shader&           shader,
                                   const Vector3&    point,
                                   Vector3           dir,
                                   Color3f&          pixelColor)
{
    Color3f * pEnergy = NULL;

    /*
     * Cast primary ray
     */
    
    explorer.reinit(point, dir, _pIntersector);
    _pIntersector->init(ENV_WANT_INTERSECTION |
                        ENV_WANT_NORMAL |
                        ENV_WANT_ASOC_PRIMITIVE |
                        ENV_WANT_N_DOT_D);
    explorer.explore(scene);

    /*
     * Check whether the ray has intersected some object
     */
    
    PointEnv* pSurr = explorer.result();
    if (!pSurr) {
        pixelColor.set(_background);
        return;
    }
    if (!(pSurr->mask & (ENV_HAVE_INTERSECTION|
                         ENV_HAVE_NORMAL|
                         ENV_HAVE_ASOC_PRIMITIVE))) {
        delete pSurr;
        pixelColor.set(_background);
        return;
    }

    /*
     * Recursion - get color of the object
     */

    dir.negate();

    double nv = ((pSurr->mask & ENV_HAVE_N_DOT_D) ?
                 -(pSurr->nd) :
                 pSurr->normal.dot(dir));

    if (pSurr->normalOrientation == PointEnv::RANDOM_NORMAL &&
        pSurr->normal.dot(dir) < 0) pSurr->normal.negate();

    if (pSurr->mask & ENV_HAVE_TRANSFORMATION) {
        shader.setRenderedShape(pSurr->pVisitableObj, &(pSurr->trMat));
        pEnergy = shader.illuminatePoint(pSurr->intersection,
                                         pSurr->normal,
                                         dir, 0, &nv,
                                         &(pSurr->trMat));
    } else {
        shader.setRenderedShape(pSurr->pVisitableObj, NULL);
        pEnergy = shader.illuminatePoint(pSurr->intersection,
                                         pSurr->normal,
                                         dir, 0, &nv, NULL);
    }
    
    delete pSurr;
                    
    if (pEnergy) {
        pixelColor.set(*pEnergy);
        delete pEnergy;
    }
}

unsigned RTRender::_render_pixel_centroid(RayIntExplorer&   explorer,
                                          SceneGraphObject& scene,
                                          Shader&           shader,
                                          Camera&           camera,
                                          const Vector3&    centroid,
                                          unsigned          row,
                                          unsigned          col,
                                          unsigned          resX,
                                          unsigned          resY,
                                          Color3f&          pixelColor)
{
    Color3f c;
    _render_pixel_point(explorer, scene, shader, centroid,
                        camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_CENTROID)), c);
    pixelColor.add(c);
    return 1;
}

unsigned RTRender::_render_pixel_corners(RayIntExplorer&   explorer,
                                         SceneGraphObject& scene,
                                         Shader&           shader,
                                         Camera&           camera,
                                         const Vector3d&   point,
                                         const Vector3d&   xDir,
                                         const Vector3d&   yDir,
                                         unsigned          row,
                                         unsigned          col,
                                         unsigned          resX,
                                         unsigned          resY,
                                         Color3f*          cRow,
                                         Color3f&          cCol,
                                         Color3f&          pixelColor)
{
    Vector3d p(point);
    Color3f  c00(0,0,0);
    unsigned numRays = 0;

    if (row == 0 && col == 0) {
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_UPPER_LEFT_CORNER)),
                            c00);
        p.add(xDir);
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_UPPER_RIGHT_CORNER)),
                            cRow[col+1]);
        p.set(point);
        p.add(yDir);
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_LOWER_LEFT_CORNER)),
                            cRow[col]);
        p.add(xDir);
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_LOWER_RIGHT_CORNER)),
                            cCol);
        numRays = 4;
    }

    if (row == 0 && col > 0) {
        c00.set(cRow[col]);
        cRow[col].set(cCol);
        p.add(xDir);
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_UPPER_RIGHT_CORNER)),
                            cRow[col+1]);
        p.add(yDir);
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_LOWER_RIGHT_CORNER)),
                            cCol);
        numRays = 2;
    }

    if (row > 0 && col == 0) {
        c00.set(cRow[col]);
        p.add(yDir);
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_LOWER_LEFT_CORNER)),
                            cRow[col]);
        p.add(xDir);
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_LOWER_RIGHT_CORNER)),
                            cCol);
        numRays = 2;
    }

    if (row > 0 && col > 0) {
        c00.set(cRow[col]);
        cRow[col].set(cCol);
        p.add(yDir);
        p.add(xDir);
        _render_pixel_point(explorer, scene, shader, p,
                            camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_LOWER_RIGHT_CORNER)),
                            cCol);
        numRays = 1;
    }

    c00.add(cRow[col]);
    c00.add(cRow[col+1]);
    c00.add(cCol);
    c00.scale(.25);
    pixelColor.add(c00);

    return numRays;
}

unsigned RTRender::_render_pixel_randomly(RayIntExplorer&   explorer,
                                          SceneGraphObject& scene,
                                          Shader&           shader,
                                          Camera&           camera,
                                          const Vector3&    centroid,
                                          unsigned          row,
                                          unsigned          col,
                                          unsigned          resX,
                                          unsigned          resY,
                                          Color3f&          pixelColor)
{
    Color3f c;
    _render_pixel_point(explorer, scene, shader, centroid,
                        camera.getProjectionDirection(camera.mapPixelToProjPlane(col, row, resX, resY, Camera::PS_RANDOM)), c);
    pixelColor.add(c);
    return 1;
}

unsigned RTRender::_render_pixel_stratified(RayIntExplorer&   explorer,
                                            SceneGraphObject& scene,
                                            Shader&           shader,
                                            Camera&           camera,
                                            const Vector3d&   point,
                                            const Vector3d&   xDir,
                                            const Vector3d&   yDir,
                                            double            xDirLength,
                                            double            yDirLength,
                                            Color3f&          pixelColor)
{
    Color3f color(0,0,0);
    Color3f c(0,0,0);

    if (_raysPerPixel <= 0) return 0;

    unsigned m  = (unsigned) sqrt((float)_raysPerPixel);
    double   xd = xDirLength / (double) m;
    double   yd = yDirLength / (double) m;
    
    for (unsigned i = 0; i < m; i++) {
        for (unsigned j = 0; j < m; j++) {
            Vector3d u(xDir);
            u.scale(i * xd + ESG_DBL_RAND * xd);
            Vector3d p(yDir);
            p.scale(j * yd + ESG_DBL_RAND * yd);
            p.add(u);
            p.add(point);
            _render_pixel_point(explorer, scene, shader, p,
                                camera.getProjectionDirection(camera.project(p)),
                                c);
            color.add(c);
        }
    }

    // Store averadge pixel color:
    if (m > 1) color.scale(1. / (double) (m * m));
    pixelColor.add(color);

    return m * m;
}

void RTRender::_render(Shader&      shader,
                       FrameBuffer& fb,
                       Camera&      camera,
                       Scene&       scene)
{
    unsigned   resX = fb.getWidth();
    unsigned   resY = fb.getHeight();
    Color3f*   pixelColors;
    unsigned   pcIndex = 0;
    unsigned   pcX = 0;
    unsigned   pcY = resY - 1;
    int        raycounter = 0;
    Vector3    top_left, bottom_right;
    Vector3    down_vec, right_vec, dir, centroid, point;
    Vector2    step(camera.getPixelSize(resX, resY));
    float      xPixelSize, yPixelSize;
    Color3f*   cRow = NULL;
    Color3f    cCol;

    RayIntExplorer explorer(Vector3(0,0,0), Vector3(0,0,0), _pIntersector);

    if (!_pIntersector) return;

    camera.getProjectionPlane(down_vec, top_left, right_vec, bottom_right);

    //fprintf(stderr,"%f %f %f\n",down_vec.x,down_vec.y,down_vec.z);
    //fprintf(stderr,"%f %f %f\n",top_left.x,top_left.y,top_left.z);

    down_vec.sub(top_left);
    right_vec.sub(top_left);
    down_vec.normalize();
    right_vec.normalize();
    down_vec.scale(step.y);
    right_vec.scale(step.x);

    xPixelSize = right_vec.length();
    yPixelSize = down_vec.length();

    // set to the center of pixels
    if (_pixelRendering == CENTROID) {
        top_left.add(right_vec * .5);
        top_left.sub(down_vec * .5);
    }

    switch (_fbWriteMode) {
    case PER_LINE:
        pixelColors = new Color3f[resX * _fbWriteElements];
        break;
    case PER_PIXEL:
    default:
        pixelColors = new Color3f[_fbWriteElements];
        break;
    }

#ifdef ESG_STATISTICS
    ((Stopwatch*)Statistics::instance()->get(Statistics::OID_RENDERING_TIME)->receptor())->start();
    ((Stopwatch*)Statistics::instance()->get(Statistics::OID_CPU_RENDERING_TIME)->receptor())->start();
#endif // ESG_STATISTICS

    for (int i = (int) resY - 1; i >= 0; i--) {
        centroid.set(top_left); // get first pixel of actual scanline

        for (int j = 0; j < (int) resX; j++) {
            if (_pStopFlag != NULL && *_pStopFlag) return;

            pixelColors[pcIndex].set(0,0,0); // init to black

            /* compute intersection with primary ray(s) */
            switch (_pixelRendering) {
            case CENTROID:
                raycounter += _render_pixel_centroid(explorer,
                                                     *(scene.root()),
                                                     shader,
                                                     camera,
                                                     centroid,
                                                     i, j,
                                                     resX, resY,
                                                     pixelColors[pcIndex]);
                break;
            case CORNERS:
                if (cRow == NULL) cRow = new Color3f [resX + 1];
                raycounter += _render_pixel_corners(explorer, *(scene.root()),
                                                    shader, camera, centroid,
                                                    right_vec, down_vec,
                                                    i, j,
                                                    resX, resY,
                                                    cRow, cCol,
                                                    pixelColors[pcIndex]);
                if (j == (int)(resX - 1)) cRow[j+1].set(cCol);
                break;
            case RANDOM:
                raycounter += _render_pixel_centroid(explorer,
                                                     *(scene.root()),
                                                     shader,
                                                     camera,
                                                     centroid,
                                                     i, j,
                                                     resX, resY,
                                                     pixelColors[pcIndex]);
#if 0
                raycounter += _render_pixel_randomly(explorer, *(scene.root()),
                                                     shader, camera, centroid,
                                                     right_vec, down_vec, 
                                                     xPixelSize, yPixelSize,
                                                     pixelColors[pcIndex]);
#endif
                break;
            case STRATIFIED_SAMPLING:
                raycounter += _render_pixel_stratified(explorer,
                                                       *(scene.root()), shader,
                                                       camera, centroid,
                                                       right_vec, down_vec,
                                                       xPixelSize, yPixelSize,
                                                       pixelColors[pcIndex]);
                break;
            case CENTROID_AND_CORNERS:
                // to do
                break;
            }

            //exit(0);
            //return;

            if (_fbWriteMode == PER_PIXEL && _fbWriteElements <= (pcIndex+1)) {
                fb.setColor(camera, pcX, pcY, pixelColors[pcIndex]);
                //fb.showContent();
                //fb.setColors(camera, pcX, pcY, pixelColors, pcIndex+1);
                pcIndex = 0;
                pcX = (j + 1) % resX;
                pcY = (pcX) ? i : i - 1;
            } else {
                pcIndex++;
            }
            
            centroid.add(right_vec); // next pixel of actual scanline
        } // for all columns

        if (_fbWriteMode == PER_LINE) {
            if (_fbWriteElements <= (pcY - i + 1)) {
                fb.setColors(camera, pcX, pcY, pixelColors, resX * (pcY-i+1));
                //fb.showContent();
                pcIndex = 0;
                pcX = 0;
                pcY = i - 1;
            } else {
                pcIndex++;
            }
        }
        
        top_left.add(down_vec); // next scanline
    } // for all lines

    
#ifdef ESG_STATISTICS
    ((Stopwatch*)Statistics::instance()->get(Statistics::OID_RENDERING_TIME)->receptor())->stop();
    ((Stopwatch*)Statistics::instance()->get(Statistics::OID_CPU_RENDERING_TIME)->receptor())->stop();
    ((Counter*)Statistics::instance()->get(Statistics::OID_PRIMARY_RAYS)->receptor())->set(raycounter);
#endif // ESG_STATISTICS


    if (cRow) delete [] cRow;
    delete [] pixelColors;
}

---