vgfx-opengl-draw/test/test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Demo program using the OpenGL vector graphics drawer.
 */

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

#include "glut-demo/glut-demo.h"
#include "vgfx-opengl-draw/vgfx-opengl-draw.h"


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

class TestHost : public glut::DemoHost {
public:
        // destructor ----------------------------------------------------------
        // public class methods ------------------------------------------------
        // glut::DemoHost class interface methods ------------------------------
        void display2D(IN int width, IN int height) {
                        ASSERT(m_root, "null");
                        ASSERT(m_drawer, "null");

                        // initialize OpenGL
                        glColor3f(1, 1, 1);

                        // actually draw
                        vgfx::rect_t drawRect(0, 0, width, height);
                        xform_2d_t T;
                        T.setTranslate(m_offset.x, m_offset.y);
                        T.scale(m_scale);
                        m_root->draw(m_drawer, drawRect, T);
                }

        // static factory methods ----------------------------------------------
        static smart_ptr<glut::DemoHost> create(IN std::istream& stream,
                                IN const char * rootId,
                                IN float scale) {
                        perf::Timer timer("TestHost::create()");
                        ASSERT_THROW(stream.good(), "bad stream?");
                        ASSERT(rootId, "null");
                        ASSERT(scale, "null?");

                        smart_ptr<TestHost> local = new TestHost;
                        ASSERT(local, "out of memory");

                        local->initialize(stream, rootId, scale);

                        return local;
                }
private:
        // constructor ---------------------------------------------------------
        TestHost(void) throw() {
                        m_root = NULL;
                        m_scale = 1.0;
                }

        // private helper methods ----------------------------------------------
        void initialize(IN std::istream& stream,
                                IN const char * rootId,
                                IN float scale) {
                        ASSERT_THROW(stream.good(), "bad stream?");
                        ASSERT(rootId, "null");
                        ASSERT(!m_root, "already have a root object?");
                        ASSERT(scale, "null scale?");

                        m_scale = scale;

                        // create vector graphics object map
                        m_objectMap = vgfx::ObjectMap::create();
                        ASSERT(m_objectMap, "null");

                        // process input request
                        bool want_undo = false;
                        std::string undo, diagnostic;
                        ASSERT_THROW(vgfx::processRequest(m_objectMap, stream,
                            want_undo, undo, diagnostic),
                            "Failed to process vgfx request!  Diagnostic: " <<
                            diagnostic);

                        DPRINTF("Object map contains %d objects",
                            (int) m_objectMap->size());

                        // should be able to find root object in map now
                        DPRINTF("Looking up object with id='%s'...", rootId);
                        m_root = m_objectMap->findObject(rootId);
                        ASSERT_THROW(m_root, "Failed to find object with id= '"
                            << rootId << "'");

                        // create an OpenGL-friendly drawer
                        m_drawer = vgfx::createOpenGLDrawer();
                        ASSERT(m_drawer, "null");

                        // recalculate bounding rects
                        xform_2d_t T;
                        T.setIdentity();
                        T.scale(m_scale);
                        m_root->recalcBoundingRect("*", m_drawer, T);

                        // get bounding rect
                        vgfx::rect_t r;
                        m_root->getBoundingRect(r);
                        r.dump("Bounding rect");
                        m_offset.x = -r.left;
                        m_offset.y = -r.top;
                }

        // private member data -------------------------------------------------
        smart_ptr<vgfx::ObjectMap>      m_objectMap;
        smart_ptr<vgfx::Drawer>         m_drawer;
        vgfx::Primitive *               m_root;
        float                           m_scale;
        vgfx::point_t                   m_offset;
};



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        ASSERT(4 == argc,
            "Usage: vgfx-draw-test <vgfx_input_file> <root_object_id> <scale>");
        const char * filename = argv[1];
        const char * rootId = argv[2];
        float scale = atof(argv[3]);
        DPRINTF("Using vgfx input file: '%s'", filename);
        DPRINTF("ID of root object in file: '%s'", rootId);
        DPRINTF("Using scale=%f (from '%s')", scale, argv[3]);

        try {
                // open file
                std::ifstream stream(filename);
                ASSERT_THROW(stream.good(), "problems opening file: " <<
                    filename);

                // create host
                smart_ptr<glut::DemoHost> host =
                    TestHost::create(stream, rootId, scale);
                ASSERT(host, "null");
                
                // start opengl
                std::string title = "OpenGL - Vector Graphics (vgfx) 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;
}