drawType/main.cpp

Go to the documentation of this file.

/*
 * main.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Simple program to demonstrate the gamepad-vgfx library (using the vgfx
 * vector graphics engine + OpenGL drawer to draw gamepad types).
 */

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

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


static const int s_border       = 100;

static const char * s_defaultLocale             = "en_US.UTF-8";


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

class Host : public glut::DemoHost {
public:
        // constructor, destructor ---------------------------------------------
        ~Host(void) throw() { }

        // public class methods ------------------------------------------------

        // glut::DemoHost class interface methods ------------------------------

        bool displayAxes(void) { return false; }
        bool displayQueuedPolys(void) { return false; }

        void onInit(void) {
                        this->initialize(m_dataDir.c_str(), m_typeName.c_str());
                }

        void display2D(int width, int height) {
                        m_counter++;
                        if (m_counter > 200) {
                                m_counter = 0;
                                ++m_iter;
                                if (m_logical.end() == m_iter) {
                                        m_iter = m_logical.begin();
                                }
                        }

                        // update current logical control
                        const char * logical = m_iter->c_str();
                        float intensity = 0.005 * m_counter;
                        m_renderer->setIntensity(logical, intensity);
                        m_renderer->setPosition(logical, 0.5, intensity);

                        int xBorder = s_border;
                        int yBorder = s_border;

                        // show name
                        glut::Font * font = glut::getDefaultFont();
                        const int bufsize = 1024;
                        char buffer[bufsize];
                        snprintf(buffer, bufsize, "Current control: %s",
                            logical);
                        glColor4f(1, 1, 1, 1);
                        font->display(xBorder + 2, height - yBorder + 16, 0,
                            buffer);

                        // show pretty (localized) name
                        const char * pretty = m_i18nMgr->getString(logical);
                        snprintf(buffer, bufsize, "Localized name: \"%s\"",
                            pretty);
                        font->display(xBorder + 2, height - yBorder + 30, 0,
                            buffer);

                        m_renderer->draw(xBorder, yBorder,
                            width - 2 * xBorder, height - 2 * yBorder);
                }

        // static factory method -----------------------------------------------
        static smart_ptr<Host> create(IN const char * dataDir,
                                IN const char * typeName) {
                        ASSERT(dataDir, "null");
                        ASSERT(typeName, "null");

                        smart_ptr<Host> local = new Host;
                        ASSERT(local, "out of memory");
                        local->m_dataDir = dataDir;
                        local->m_typeName = typeName;

                        return local;
                }

private:
        // private methods -----------------------------------------------------
        Host(void) throw() { }
        void initialize(IN const char * dataDir,
                                IN const char * typeName) {
                        ASSERT(dataDir, "null");
                        ASSERT(typeName, "null");

                        // open up the filesystem mgr
                        smart_ptr<nstream::Manager> fsMgr =
                            nstream::getFilesystemManager(dataDir);
                        ASSERT_THROW(fsMgr,
                            "Failed to create filesystem manager for data dir: "
                            << dataDir);
                        smart_ptr<nstream::Folder> folder = fsMgr->getRoot();
                        ASSERT(folder, "null");

                        // create the gamepad manager
                        m_gamepadMgr = gamepad::Manager::create(folder);
                        ASSERT_THROW(m_gamepadMgr, "failed to create");

                        // find our type
                        int nTypes = m_gamepadMgr->getTypeCount();
                        smart_ptr<gamepad::Type> type;
                        for (int i = 0; i < nTypes; ++i) {
                                type = m_gamepadMgr->getType(i);
                                if (!type) {
                                        DPRINTF("Manager returned null type?");
                                        continue;
                                }

                                DPRINTF("Is '%s' what we're looking for?",
                                    type->getName());
                                if (!strcmp(typeName, type->getName())) {
                                        break;  // yes!
                                }
                                type = NULL;    // no
                        }

                        // did we find it?
                        ASSERT_THROW(type,
                            "Failed to find a type with name: " << typeName);

                        // create vector graphics drawer
                        smart_ptr<vgfx::Drawer> drawer =
                            vgfx::createOpenGLDrawer();
                        ASSERT(drawer, "null");

                        m_renderer =
                            gamepad::TypeVgfxRenderer::create(type, drawer);
                        ASSERT(m_renderer, "null");

                        // get our localization manager
                        const char * locale = i18n::getHostLocale();
                        m_i18nMgr = gamepad::getTypeLocaleMgr(type, locale,
                            s_defaultLocale, folder);
                        ASSERT_THROW(m_i18nMgr,
                            "failed to create localization mgr");

                        // initialize
                        m_counter = 0;
                        type->getAllInputs(m_logical);
                        DPRINTF("Found %d total logical controls on gamepad",
                            (int) m_logical.size());
                        m_iter = m_logical.begin();
                }
        
        // private member data -------------------------------------------------
        smart_ptr<gamepad::Manager>     m_gamepadMgr;
        smart_ptr<gamepad::TypeVgfxRenderer> m_renderer;
        smart_ptr<i18n::Manager>        m_i18nMgr;
        VecString                       m_logical;
        VecString::iterator             m_iter;
        std::string                     m_dataDir;
        std::string                     m_typeName;
        int                             m_counter;
};


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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        ASSERT(3 == argc, "Usage: drawType <data-directory> <type-name>");
        const char * dataDir = argv[1];
        DPRINTF("Using data directory: '%s'", dataDir);
        const char * typeName = argv[2];
        DPRINTF("Using type name: '%s'", typeName);

        try {

                const char * title = "Gamepad Type vgfx Drawer Demo";

                smart_ptr<glut::DemoHost> host =
                    Host::create(dataDir, typeName);
                ASSERT(host, "failed to create demo host");

                glut::startDemo(argc, argv, title, host);

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

        perf::dumpTimingSummary(std::cerr);

        return retval;
}