test-tex-sphere.cpp

Go to the documentation of this file.

/*
 * test-tex-sphere.cpp
 *
 * Copyright (C) 2011  Thomas A. Vaughan
 * All rights reserved.
 *
 * Quick program to test the opengl-effects texture mapped sphere
 */

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

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


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

class TestHost : public glut::DemoHost {
public:
        // constructor, destructor ---------------------------------------------
        TestHost(IN const char * texfile) {
                        ASSERT(texfile, "NULL");
                        m_texfile = texfile;
                }
        ~TestHost(void) throw() { }

        // glut::DemoHost class interface methods ------------------------------
        void onInit(void) {
                        // break path into parent directory and file
                        std::string parentDir;
                        GetParentDirectory(m_texfile.c_str(), parentDir);
                        const char * file = GetFilename(m_texfile.c_str());

                        // get the filesystem manager
                        smart_ptr<nstream::Manager> mgr =
                            nstream::getFilesystemManager(parentDir.c_str());
                        ASSERT(mgr, "failed to create filesystem manager");

                        // load requested texture image
                        media::image_t img;
                        ASSERT_THROW(media::loadImage(mgr, file, img),
                            "Failed to load texture image: " << m_texfile);
                        //ASSERT(img.isValid(), "invalid texture image?");
                        img.dump("Texture Image");

                        // create texture from image
                        glut::tex_sphere_t ts;
                        ts.radius = 3.0;
                        ts.textureId = glut::createTextureFromImage(img);
                        DPRINTF("Created texture: %d", ts.textureId);

                        m_sphere = glut::createMappedSphere(ts);
                        ASSERT(m_sphere, "null");

                        // initial rotation angle
                        m_angle = 0.0;
                }

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

                        m_angle += 0.5;

                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();
        //              glTranslatef(2, 2, 15);

                        glRotatef(m_angle, 0, 1, 0);

                        m_sphere->render(rc, rq);

                        glPopMatrix();
                }

private:
        // private member data -------------------------------------------------
        smart_ptr<glut::Renderable>     m_sphere;
        std::string                     m_texfile;
        float                           m_angle;
};



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc,
            "usage: test-tex-sphere <texture-file>");

        const char * texfile = argv[1];
        DPRINTF("Using texture file: '%s'", texfile);

        int retval = 0;
        try {
                perf::Timer timer("overall timer");

                std::string title = "Texture Mapped Sphere: ";
                title += texfile;

                // create host
                TestHost host(texfile);

                // start demo
                glut::startDemo(argc, argv, title.c_str(), &host);

        } catch (std::exception& e) {
                DPRINTF("EXCEPTION: %s", e.what());
                retval = 1;
        }

        perf::dumpTimingSummary(std::cerr);

        return retval;
}