vgfx-opengl-draw.cpp

Go to the documentation of this file.

/*
 * vgfx-opengl-draw.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.
 *
 *
 * Implementation of an OpenGL-based vgfx drawer.  See vgfx-opengl-draw.h
 */

// includes --------------------------------------------------------------------
#include "vgfx-opengl-draw.h"           // always include our own header first!

#include "color/color.h"
#include "common/wave_ex.h"
#include "glut-font/glut-font.h"
#include "perf/perf.h"
#include "wave-glut/glut_2d.h"
#include "wave-glut/wave-glut.h"


namespace vgfx {


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

static void
getOpenGLColorFromString
(
IN const char * text,
OUT glut_color_t& color
)
{
        ASSERT(text, "null");
        color.clear();

        img_color_t img;
        getImgColorFromString(text, img);

//      DPRINTF("Color string: '%s'", text);
//      img.dump("  img color result");

        float inv = 1.0 / 255.0;
        color.set(inv * img.red, inv * img.green, inv * img.blue,
            inv * img.alpha);
//      color.dump("  glut color result");
}



////////////////////////////////////////////////////////////////////////////////
//
//      OGLDrawer -- implementation for the vgfx::Drawer interface
//
////////////////////////////////////////////////////////////////////////////////

class OGLDrawer : public Drawer {
public:
        ~OGLDrawer(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(void);

        // vgfx::Drawer class interface methods --------------------------------
        void pushBrush(IN dword_t key);
        void popBrush(IN dword_t key) throw();
        void endPath(void);
        void refreshBrush(void);
        void setTransform(IN const xform_2d_t& T) throw();
        void setBrushAttribute(IN eBrushAttribute attrib,
                                IN const char * value);
        void setClipRect(IN float left, IN float top,
                                IN float right, IN float bottom);
        void drawBezier(IN const bezier::curve_t& curve); 
        void drawQuadBezier(IN const bezier::quad_bezier_t& quad);
        void drawLine(IN const point_t& p0, IN const point_t& p1);
        void drawRect(IN const rect_t& r);
        void fillRect(IN const rect_t& r);
        void drawText(IN const rect_t& r,
                                IN const char * text);
        void getBoundingRect(IN const char * text,
                                OUT rect_t& r);
        void getRootTransform(OUT xform_2d_t& T) throw();
        bool isPrinter(void) const throw();

private:
        // private typedefs ----------------------------------------------------
        struct brush_data_t {
                dword_t         id;
                glut_color_t    color;
                float           lineWidth;
        };

        typedef std::vector<brush_data_t> brush_stack_t;

        // private helper methods ----------------------------------------------
        // private member data -------------------------------------------------
        xform_2d_t              m_T;    // current transform
        brush_stack_t           m_brushes;
};



void
OGLDrawer::initialize
(
void
)
{
}



////////////////////////////////////////////////////////////////////////////////
//
//      OGLDrawer -- vgfx::Drawer class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
OGLDrawer::pushBrush
(
IN dword_t key
)
{
//      DPRINTF("pushBrush: 0x%08x", key);

        brush_data_t bd;
        bd.id = key;

        glGetFloatv(GL_CURRENT_COLOR, (GLfloat *) &bd.color.red);
//      bd.color.dump("Just extracted glut color");

        glGetFloatv(GL_LINE_WIDTH, (GLfloat *) &bd.lineWidth);
//      DPRINTF("Just extracted line width: %f", bd.lineWidth);

        m_brushes.push_back(bd);
}



void
OGLDrawer::popBrush
(
IN dword_t key
)
throw()
{
//      DPRINTF("popBrush: 0x%08x", key);

        if (!m_brushes.size()) {
                DPRINTF("ERROR: calling popBrush() on empty brush stack?");
                return;
        }

        brush_data_t bd = m_brushes.back();
        m_brushes.pop_back();

        // now restore
        glut_color_t& gc = bd.color;
        glColor4f(gc.red, gc.green, gc.blue, gc.alpha);
        glLineWidth(bd.lineWidth);
}



void
OGLDrawer::endPath
(
void
)
{
//      DPRINTF("endPath() NYI");
}



void
OGLDrawer::refreshBrush
(
void
)
{
        DPRINTF("refreshBrush() NYI");
}



void
OGLDrawer::setTransform
(
IN const xform_2d_t& T
)
throw()
{
        m_T = T;
}



void
OGLDrawer::setBrushAttribute
(
IN eBrushAttribute attrib,
IN const char * value
)
{
//      DPRINTF("setBrushAttribute(%d) = '%s'", attrib, value);

        if (eBrush_PenColor == attrib) {
                glut_color_t color;
                getOpenGLColorFromString(value, color);
                glColor4f(color.red, color.green, color.blue, color.alpha);
        } else if (eBrush_PenThickness == attrib) {
                const float pixelsPerCM = 25.0; // using this for now!
                float cmWidth = atof(value);
                if (cmWidth <= 0) {
                        DPRINTF("Bad pen width: %f", cmWidth);
                        DPRINTF("From value: '%s'", value);
                        return;
                }
                float pixWidth = pixelsPerCM * cmWidth;
//              DPRINTF("Setting raster line width: %f", pixWidth);
                glLineWidth(pixWidth);
        } else {
                DPRINTF("Unknown attribute %d = '%s'", attrib, value);
        }
}



void
OGLDrawer::setClipRect
(
IN float left,
IN float top,
IN float right,
IN float bottom
)
{
        DPRINTF("setClipRect() NYI");
}



void
OGLDrawer::drawBezier
(
IN const bezier::curve_t& curve
)
{
        DPRINTF("drawBezier NYI");
}



void
OGLDrawer::drawQuadBezier
(
IN const bezier::quad_bezier_t& quad
)
{
        // dumb bezier drawing!  Draw as an n-element bezier!
        const int N = 1;
        const float dt = 1.0 / N;
        float t = 0;
        glBegin(GL_LINE_STRIP);
        for (int i = 0; i < N + 1; ++i, t += dt) {
                point_t p = quad.getPointAt(t);
//              DPRINTF("  pt[%f] = (%f, %f)", t, p.x, p.y);
                point_t q = m_T * p;
                glVertex2f(q.x, q.y);
        }
        glEnd();
}



void
OGLDrawer::drawLine
(
IN const point_t& p0,
IN const point_t& p1
)
{
        point_t q0, q1;

        // transform points
        q0 = m_T * p0;
        q1 = m_T * p1;

        // draw
//      DPRINTF("Drawing line: (%f, %f) - (%f, %f)", q0.x, q0.y, q1.x, q1.y);

        glBegin(GL_LINES);
                glVertex2f(q0.x, q0.y);
                glVertex2f(q1.x, q1.y);
        glEnd();
}



void
OGLDrawer::drawRect
(
IN const rect_t& r
)
{
        DPRINTF("drawRect NYI");
}



void
OGLDrawer::fillRect
(
IN const rect_t& r
)
{
        DPRINTF("fillRect NYI");
}



void
OGLDrawer::drawText
(
IN const rect_t& r,
IN const char * text
)
{
        DPRINTF("drawText('%s') NYI", text);
}



void
OGLDrawer::getBoundingRect
(
IN const char * text,
OUT rect_t& r
)
{
        DPRINTF("getBoundingRect('%s') NYI", text);
}



void
OGLDrawer::getRootTransform
(
OUT xform_2d_t& T
)
throw()
{
        DPRINTF("getRootTransform() NYI");
}



bool
OGLDrawer::isPrinter
(
void
)
const
throw()
{
        return false;
}



////////////////////////////////////////////////////////////////////////////////
//
//      OGLDrawer -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

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

smart_ptr<Drawer>
createOpenGLDrawer
(
void
)
{
        smart_ptr<OGLDrawer> local = new OGLDrawer;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



};      // vgfx namespace