viewport.cpp

Go to the documentation of this file.

/*
 * viewport.cpp
 *
 * Copyright (C) 2008,2009,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.
 *
 *
 * Viewport management.  See viewport.h
 */

// includes --------------------------------------------------------------------
#include "viewport.h"                   // always include our own header first!

#include <math.h>

#include "geometry/geometry_2d.h"

#include "perf/perf.h"
#include "wave-glut/glut_2d.h"
#include "wave-glut/wave-glut.h"


namespace view {


// interface destructor implementations
Host::~Host(void) throw() { }
Manager::~Manager(void) throw() { }


typedef rect2d_t<float> rectf_t;
//typedef rect2d_t<int> recti_t;


struct viewport_record_t {
        // constructor, manipulators
        viewport_record_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        id = -1;
                        normalizedRect.clear();
                        pixelRect.clear();
                        renderInfo.clear();
                        host = NULL;
                }

        // data fields
        int                     id;
        rectf_t                 normalizedRect;
        recti_t                 pixelRect;
        render_info_t           renderInfo;
        smart_ptr<Host>         host;
};


typedef std::vector<viewport_record_t> view_vec_t;


// need a small nonzero epsilon to account for slight floating point errors
static const float s_epsilon                    = 1.0e-8;


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

static void
getPixelRectFromNormalized
(
IN int width,
IN int height,
IN const rectf_t& rf,
OUT recti_t& ri
)
{
        ASSERT(width > 0, "bad width: %d", width);
        ASSERT(height > 0, "bad height: %d", height);
        ASSERT(rf.isValid(), "invalid?");
        ASSERT(rf.left >= -s_epsilon && rf.top >= -s_epsilon &&
               rf.right <= 1.0 + s_epsilon && rf.bottom <= 1.0 + s_epsilon,
            "Malformed input");

        ri.left = (int) (rf.left * width + 0.5);
        ri.top = (int) (rf.top * height + 0.5);
        ri.right = (int) (rf.right * width + 0.5);
        ri.bottom = (int) (rf.bottom * height + 0.5);

        ASSERT(ri.isValid(), "invalid?");
        ASSERT(ri.left >= 0 && ri.right <= width &&
               ri.top >= 0 && ri.bottom <= height,
            "Malformed output");
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- class that implements the view::Manager interface
//
////////////////////////////////////////////////////////////////////////////////

class Mgr : public Manager {
public:
        ~Mgr(void) throw() { }

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

        // view::Manager class interface methods -------------------------------
        int getViewportCount(void) const { return m_viewports.size(); }
        int getOwnerOfCoordinate(IN int x, IN int y,
                                IN int width, IN int height,
                                OUT int& ownerX, OUT int& ownerY);
        void render(IN int width, IN int height);
        bool createViewport(IN int id, IN smart_ptr<Host> host);
        bool removeViewport(IN int id);

private:
        // private helper methods-----------------------------------------------
        void updateGeometries(void);
        view_vec_t::iterator findViewport(IN int id);

        // private member data -------------------------------------------------
        view_vec_t              m_viewports;
};



void
Mgr::initialize
(
void
)
{
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- view::Manager class interface methods
//
////////////////////////////////////////////////////////////////////////////////

void
Mgr::render
(
IN int width,
IN int height
)
{
        perf::Timer timer("view::Manager::render");

        ASSERT(width > 0, "bad width: %d", width);
        ASSERT(height > 0, "bad height: %d", height);
        //DPRINTF("Manager: %d x %d", width, height);

        // save current OpenGL viewport
        int oldVP[4];
        glGetIntegerv(GL_VIEWPORT, (GLint *) oldVP);

        // first pass: update each viewport's render_info
        for (view_vec_t::iterator i = m_viewports.begin();
             i != m_viewports.end(); ++i) {

                viewport_record_t& vr = *i;
                render_info_t& ri = vr.renderInfo;
                recti_t& rc = vr.pixelRect;

                getPixelRectFromNormalized(width, height, vr.normalizedRect,
                    rc);
                //rc.dump("  Drawing/viewport rect");

                ri.width = rc.right - rc.left + 1;
                ri.height = rc.bottom - rc.top + 1;
                ASSERT(ri.width > 0, "bad viewport width: %d", ri.width);
                ASSERT(ri.height > 0, "bad viewport height: %d", ri.height);
        }

        // second pass: all viewports get a shot at 3D drawing
        for (view_vec_t::iterator i = m_viewports.begin();
             i != m_viewports.end(); ++i) {

                viewport_record_t& vr = *i;
                render_info_t& ri = vr.renderInfo;
                recti_t& rc = vr.pixelRect;

                // tell OpenGL to clip to this viewport
                //  remember: 0,0 is LOWER LEFT corner for OpenGL
                int oglY = height - rc.bottom;
                //DPRINTF("    OpenGL Y: %d", oglY);
                glViewport(rc.left, oglY, ri.width, ri.height);

                // ask the host to render scene then dialogs
                ASSERT(vr.host, "null host");
                vr.host->render3D(vr.id, vr.renderInfo);
        }

        // third pass: all viewports get a shot at 2D drawing
        glut::push2D(width, height);
        for (view_vec_t::iterator i = m_viewports.begin();
             i != m_viewports.end(); ++i) {

                viewport_record_t& vr = *i;
                rectf_t& nr = vr.normalizedRect;
                render_info_t& ri = vr.renderInfo;
                recti_t& rc = vr.pixelRect;

                // tell OpenGL to clip to this viewport
                int oglY = height - rc.bottom;
                glViewport(rc.left, oglY, ri.width, ri.height);

                // make the 2D coordinate system relative to this viewport.
                // Note: this is funky!  Because we've specified an OpenGL
                //      viewport (above), we don't need to worry about
                //      translating the origin.  However, glViewport() will
                //      apply scaling automatically!  glViewport() assumes that
                //      we're still using screen coordinates, whereas we'd like
                //      to use window coordinates.  So we add inverse scaling to
                //      account for this, so clients can use window-relative
                //      coordinates.
                glMatrixMode(GL_MODELVIEW);
                glPushMatrix();

                float xScale = 1.0 / (nr.right - nr.left);
                float yScale = 1.0 / (nr.bottom - nr.top);
                glScalef(xScale, yScale, 1);

                // call viewport
                ASSERT(vr.host, "null host");
                vr.host->render2D(vr.id, vr.renderInfo);

                // restore matrix (undo scaling factors)
                glMatrixMode(GL_MODELVIEW);
                glPopMatrix();
        }
        glut::pop2D();

        // restore original OpenGL viewport
        glViewport(oldVP[0], oldVP[1], oldVP[2], oldVP[3]);
}



int
Mgr::getOwnerOfCoordinate
(
IN int x,
IN int y,
IN int width,
IN int height,
OUT int& ownerX,
OUT int& ownerY
)
{
        //ASSERT(x >= 0, "bad x: %d", x);
        //ASSERT(y >= 0, "bad y: %d", y);
        ASSERT(width > 0, "bad width: %d", width);
        ASSERT(height > 0, "bad height: %d", height);
        //DPRINTF("Looking for owner of (%d, %d)...", x, y);

        // loop through and check each viewport
        for (view_vec_t::iterator i = m_viewports.begin();
             i != m_viewports.end(); ++i) {

                viewport_record_t& vr = *i;

                recti_t rc;             // pixel rect
                getPixelRectFromNormalized(width, height, vr.normalizedRect,
                    rc);

                if (rc.contains(x, y)) {
                        //rc.dump("  Contains mouse!");
                        //DPRINTF("  id = %d", vr.id);
                        ownerX = x - rc.left;
                        ownerY = y - rc.top;
                        //DPRINTF("    new xy = (%d, %d)", ownerX, ownerY);
                        return vr.id;
                }
        }

        // no one claimed!
        //DPRINTF("  No owner!");
        return -1;
}



bool
Mgr::createViewport
(
IN int id,
IN smart_ptr<Host> host
)
{
        ASSERT(host, "null");

        //DPRINTF("creating viewport...");

        // valid ID?
        if (id < 1) {
                DPRINTF("Invalid id: %d", id);
                return false;
        }

        // is this an available ID?
        view_vec_t::iterator i = this->findViewport(id);
        if (m_viewports.end() != i) {
                DPRINTF("Viewport with id already exists: %d", id);
                return false;
        }

        // create a new record
        viewport_record_t vr;
        vr.id = id;
        vr.host = host;

        // add to vector
        m_viewports.push_back(vr);

        // update all geometries
        this->updateGeometries();

        // that's it!
        return true;
}



bool
Mgr::removeViewport
(
IN int id
)
{
        view_vec_t::iterator i = this->findViewport(id);
        if (m_viewports.end() == i) {
                DPRINTF("Viewport ID not found? %d", id);
                return false;
        }

        m_viewports.erase(i);
        this->updateGeometries();
        return true;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
Mgr::updateGeometries
(
void
)
{
        // this is called whenever we need to reset the normalized rects
        // Typically this is because a viewport has been added/removed and
        // we need to resize viewport sizes etc.

        // TODO: allow for rich customization of viewport geometries
        //      (read from config file, etc)
        // For now, we just use a rough heuristic
        int N = m_viewports.size();
        if (!N)
                return;         // nothing to do!

        // how many viewports do we put across the screen?
        int width = (int) (sqrt(1.0 * N) + 0.5);        // heuristic!
        ASSERT(width > 0, "bad width: %d", width);

        // how many viewports running down the screen?
        int height = N / width;
        if (width * height < N) {
                ++height;
        }
        ASSERT(height > 0, "bad height: %d", height);

        //DPRINTF("Requested %d viewports", N);
        //DPRINTF("  Determined %d viewports across screen", width);
        //DPRINTF("  Determined %d viewports down screen", height);
        //DPRINTF("  %d x %d = %d", width, height, width * height);

        // validate
        if (width * height < N ||
            width * (height - 1) >= N) {
                ASSERT(false, "bad layout");
        }

        // how much space each normalized viewport gets
        float dx = 1.0 / width;
        float dy = 1.0 / height;

        // run through and give each viewport its normalized coordinates
        view_vec_t::iterator iv = m_viewports.begin();
        for (int j = 0; j < height; ++j) {
                for (int i = 0; i < width; ++i) {
                        if (m_viewports.end() == iv) {
                                break;  // skip
                        }

                        viewport_record_t& vr = *iv;
                        vr.normalizedRect.left = i * dx;
                        vr.normalizedRect.top = j * dy;
                        vr.normalizedRect.right = (i + 1) * dx;
                        vr.normalizedRect.bottom = (j + 1) * dy;

                        //DPRINTF("Viewport %d:", vr.id);
                        //vr.normalizedRect.dump("  normalized");

                        ++iv;
                }
        }
}



view_vec_t::iterator
Mgr::findViewport
(
IN int id
)
{
        ASSERT(id > 0, "Bad id: %d", id);

        for (view_vec_t::iterator i = m_viewports.begin();
             i != m_viewports.end(); ++i) {
                const viewport_record_t& vr = *i;
                if (vr.id == id) {
                        return i;
                }
        }

        // id not found!
        return m_viewports.end();
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API (Manager factory methods)
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Manager>
Manager::create
(
void
)
{
        smart_ptr<Mgr> local = new Mgr;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}


};      // view namespace