light-path.cpp

Go to the documentation of this file.

/*
 * light-path.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * See light-path.h
 */

// includes --------------------------------------------------------------------
#include "light-path.h"         // always include our own header first!

#include <math.h>

#include "perf/perf.h"


namespace glut {



static const float s_eps                = 1.0e-6;

struct sort_seg_t {
        int             index;
        float           d2;     // distance^2 from viewer
};


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
setSegment
(
IN const point3d_t& p0,         // starting point of ray
IN const point3d_t& p1,         // ending point of ray
IN const matrix4_t& T,          // transform to viewer coordinates
IN int genTextureId,            // generating texture ID
IN int outTextureId,            // destination for offscreen drawing
IN Framebuffer * framebuffer,   // for offscreen drawing
IN float size,                  // size along tangent
IN const glut::render_context_t& rc, // viewer information
OUT poly_request_t * pr         // output vertices here
)
{
        ASSERT(genTextureId, "null");
        ASSERT(outTextureId, "null");
        ASSERT(framebuffer, "null");
        ASSERT(size > 0, "bad size: %f", size);
        ASSERT(pr, "null");

        p0.dump("  ray p0");
        p1.dump("  ray p1");

        const point3d_t& pos = rc.viewer.getPosition();
        const point3d_t& facing = rc.viewer.getFacing();

        pos.dump("  viewer position");
        facing.dump("  viewer facing");

        point3d_t mid = 0.5 * (p0 + p1);
        point3d_t to = mid - pos;       // vector from viewer to midpoint
        normalize(to);
        mid.dump("  ray midpoint");
        to.dump("  from viewer to ray midpoint");

        point3d_t ray = p1 - p0;
        float ray2 = dotProduct(ray, ray);
        if (ray2 < s_eps) {
                DPRINTF("null ray?");
                return;
        }
        float rayLength = sqrt(ray2);
        DPRINTF("  rayLength = %f", rayLength);
        ray = (1.0 / rayLength) * ray;  //  normalize
        ray.dump("  ray");

        float delta = dotProduct(ray, to) - 1.0;
        if (delta > -s_eps && delta < s_eps) {
                // segment is exactly aligned with facing direction
                DPRINTF("Aligned?");
                return;
        }

        // determine the tangent to the ray, given the facing direction
        point3d_t tang = crossProduct(ray, to);
        normalize(tang);
        tang.dump("  tangent");

        // determine normal to plane: ray x tangent
        point3d_t norm = crossProduct(ray, tang);
        normalize(norm);
        norm.dump("  normal");

        // now draw to an offscreen buffer
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        {
                FramebufferContext fc(framebuffer, outTextureId, rc);

                Viewer viewer2 = rc.viewer;     // same orientation
                point3d_t newPos = mid - 5.0 * rayLength * facing;
                viewer2.setPosition(newPos);
                setOpenGLViewer(viewer2);
                viewer2.getPosition().dump("  temporary viewer position");

                glEnable(GL_BLEND);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE);
                glClearColor(0.0, 0.0, 0.0, 0.0);
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

                // here we use the generating texture
                glEnable(GL_TEXTURE_2D);
                glBindTexture(GL_TEXTURE_2D, genTextureId);
                glNormal3fv(&norm.x);
                glBegin(GL_POLYGON);

                        // top left corner
                        point3d_t vtx = p0 - size * ray + size * tang;
                        vtx.dump("  temp top left");
                        glTexCoord2f(0, 0);
                        glVertex3fv(&vtx.x);

                        // bottom left corner
                        vtx = p0 - size * ray - size * tang;
                        vtx.dump("  temp bottom left");
                        glTexCoord2f(0, 1);
                        glVertex3fv(&vtx.x);

                        // bottom right corner
                        vtx = p1 + size * ray - size * tang;
                        vtx.dump("  temp bottom right");
                        glTexCoord2f(1, 1);
                        glVertex3fv(&vtx.x);

                        // top right corner
                        vtx = p1 + size * ray + size * tang;
                        vtx.dump("  temp top right");
                        glTexCoord2f(1, 0);
                        glVertex3fv(&vtx.x);

                glEnd();

                glDisable(GL_BLEND);
                glDisable(GL_TEXTURE_2D);
        }
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        // now we set up a request to draw a polygon that is in the viewer's
        //   z-plane
        const point3d_t& up = rc.viewer.getUp();
        point3d_t right = crossProduct(facing, up);
        normalize(right);
        point3d_t realUp = crossProduct(right, facing);
        normalize(realUp);

        right.dump("  viewer right");
        realUp.dump("  viewer up");

        // set up output request
        pr->nVertices = 4;
        pr->textureId = genTextureId;
        pr->normal = -facing;

/*
        // draw now!
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glBindTexture(GL_TEXTURE_2D, genTextureId);
        glBegin(GL_POLYGON);
*/
        // top left corner
        point3d_t vtx = mid + 0.5 * rayLength * (realUp - right);
        vtx.dump("  top left");
//      glTexCoord2f(0, 0);
//      glVertex3fv(&vtx.x);
        pr->vertex[0] = T * vtx;        // transformed vertex
        pr->u[0] = 0;
        pr->v[0] = 0;

        // bottom left corner
        vtx = mid + 0.5 * rayLength * (-realUp - right);
        vtx.dump("  bottom left");
//      glTexCoord2f(0, 1);
//      glVertex3fv(&vtx.x);
        pr->vertex[1] = T * vtx;
        pr->u[1] = 0;
        pr->v[1] = 1;

        // bottom right corner
        vtx = mid + 0.5 * rayLength * (-realUp + right);
        vtx.dump("  bottom right");
//      glTexCoord2f(1, 1);
//      glVertex3fv(&vtx.x);
        pr->vertex[2] = T * vtx;
        pr->u[2] = 1;
        pr->v[2] = 1;

        // top right corner
        vtx = mid + 0.5 * rayLength * (realUp + right);
        vtx.dump("  top right");
//      glTexCoord2f(1, 0);
//      glVertex3fv(&vtx.x);
        pr->vertex[3] = T * vtx;
        pr->u[3] = 1;
        pr->v[3] = 0;

//      glEnd();
//      glDisable(GL_TEXTURE_2D);

        for (int i = 0; i < pr->nVertices; ++i) {
                pr->vertex[i].dump("  transformed");
        }
}



static int
compareSegments
(
IN const void * p1,
IN const void * p2
)
throw()
{
        const sort_seg_t * pss1 = (const sort_seg_t *) p1;
        const sort_seg_t * pss2 = (const sort_seg_t *) p2;

        ASSERT(pss1 && pss2, "null");

        if (pss1->d2 > pss2->d2) {
                // sort segment 1 is farther: it should be later in the list
                return +1;
        } else if (pss1->d2 < pss2->d2) {
                // sort segment 2 is farther
                return -1;
        }

        // must be equidistant!
        return 0;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

void
drawTransparentPath
(
IN const point3d_t * pointArray,
IN int * textureArray,
IN int nSegments,
IN Framebuffer * framebuffer,
IN float size,
IN int textureId,
IN const render_context_t& rc,
IN RenderQueue * rq
)
{
        perf::Timer timer("drawTransparentPath");
        ASSERT(pointArray, "null");
        ASSERT(textureArray, "null");
        ASSERT(nSegments > 0, "bad segment count: %d", nSegments);
        ASSERT(framebuffer, "null");
        ASSERT(size > 0, "bad size: %f", size);
        ASSERT(textureId > 0, "Bad texture ID");
        ASSERT(rq, "null");

        // get basics for rendering
        point3d_t pos = rc.viewer.getPosition();

//      DPRINTF("Drawing light path");
//      pos.dump("  viewer position");
//      facing.dump("  viewer facing");

        matrix4_t T;
        getModelViewMatrix(T);
//      T.dump("  modelview");

        const int s_maxSegments = 64;
        if (nSegments > s_maxSegments) {
                DPRINTF("WARNING: support a max of %d segments", s_maxSegments);
                nSegments = s_maxSegments;
        }

        // first walk through segments: sort in order of closest to farthest
        sort_seg_t array[s_maxSegments];
        for (int i = 0; i < nSegments; ++i) {
                point3d_t mid = 0.5 * (pointArray[i] + pointArray[i + 1]);
                sort_seg_t& ss = array[i];
                ss.index = i;
                point3d_t diff = mid - pos; // distance from segement to viewer
                ss.d2 = dotProduct(diff, diff);
        }

        // sort from closest to farthest
        qsort(array, nSegments, sizeof(sort_seg_t), compareSegments);

        // walk through path segments from farthest to closest
        for (int i = 0; i < nSegments; ++i) {
                const sort_seg_t& ss = array[i];
                int idx = ss.index;
                poly_request_t * pr = rq->grabRequestSlot();
                if (!pr)
                        return; // can't draw anymore
                setSegment(pointArray[idx], pointArray[idx + 1], T,
                    textureId, textureArray[idx], framebuffer, size, rc, pr);
        }
}



};      // glut namespace