test/light-path.cpp

Go to the documentation of this file.

/*
 * light-path.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Program to test the opengl-effects library---light path routines.
 */

// includes --------------------------------------------------------------------
#include <iostream>
#include <fstream>

#include "glut-demo/glut-demo.h"
#include "opengl-effects/opengl-effects.h"
#include "perf/perf.h"
#include "wave-glut/texture.h"



static const int s_nSegments    = 3;
static const int s_nPoints      = s_nSegments + 1;


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

static float
deltaX
(
IN float dx
)
throw()
{
        float x = (2.0 * rand()) / RAND_MAX;
        return (x - 1) * dx;
}



static void
addRandomDelta
(
IO point3d_t& p,
IN float f
)
throw()
{
        p.x += deltaX(f);
        p.y += deltaX(f);
        p.z += deltaX(f);
}



static void
getPoint
(
IN int idx,
IN int nPoints,
IN float rho,
IN float phi,
OUT point3d_t& p
)
throw()
{
        ASSERT(nPoints > 1, "Bad nPoints");
        ASSERT(idx >= 0 && idx < nPoints, "bad idx");
        ASSERT(rho > 0, "Bad rho");

        p.x = -2 + 4 * idx;
        p.y = 1;
        p.z = -2 + 0.5 * idx;

//      phi += deltaX(0.05);
//      float theta = 2.0 * M_PI * idx / (nPoints - 3);
//      theta += deltaX(0.05);
//      float q = rho * sin(theta);

//      p.x = q * sin(phi);
//      p.y = q * cos(phi);
//      p.z = rho * cos(theta);

//      addRandomDelta(p, 0.02);
}



class Drawer : public glut::DemoHost {
public:
        Drawer(IN int size) throw() : m_size(size), m_textureId(0) { }
        ~Drawer(void) throw() { }

        // glut::Host class interface methods ----------------------------------
        void onInit(void) {
                        int width = 128;
                        // create density map
                        media::image_t img;
                        img_color_t color(200, 200, 255);
                        glut::createLineSegmentDensityMap(width, color, img);
                        img.dump("test image == horizontal density map");

                        // create texture (used for generating glow)
                        m_textureId = glut::createTextureFromImage(img);
                        DPRINTF("Texture ID: %d", m_textureId);

                        // create target textures, one per segment
                        for (int i = 0; i < s_nSegments; ++i) {
                                glGenTextures(1, &m_texture[i]);
                                DPRINTF("  output texture %d: %d", i, m_texture[i]);
                                glBindTexture(GL_TEXTURE_2D, m_texture[i]);
                                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
                                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
                                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,  width, width, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
                        }

                        // create framebuffer
                        m_framebuffer = glut::Framebuffer::create(width, width);
                        ASSERT(m_framebuffer, "failed to create framebuffer");
                }

        void display3D(IN const glut::render_context_t& rc,
                                IN glut::RenderQueue * rq) {
                        ASSERT(rq, "null");

                        // first, render a standard sphere at the origin
                        glutSolidSphere(1.5, 16, 16);

                        static float s_phi = 0.0;
                //      s_phi += 0.01;

                        for (int i = 0; i < s_nPoints; ++i) {
                                getPoint(i, s_nPoints, 2.0, s_phi, m_point[i]);
                        }
                        
                        glut::drawTransparentPath(m_point, (int *) m_texture,
                            s_nSegments, m_framebuffer, 0.4, m_textureId, rc,
                            rq);
                }

private:
        int             m_size;
        int             m_textureId;
        point3d_t       m_point[s_nPoints];
        GLuint          m_texture[s_nSegments];
        smart_ptr<glut::Framebuffer> m_framebuffer;
};



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "Usage: opengl-effects-test <size>\n");
        int size = atoi(argv[1]);
        ASSERT(size > 0, "Bad size: %d", size);

        try {
                // main loop
                smart_ptr<glut::DemoHost> host = new Drawer(size);
                ASSERT(host, "out of memory");
                glut::startDemo(argc, argv, "Light Path Test", host);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
        }

        // only reach here on error
        return -1;
}