renderable.cpp

Go to the documentation of this file.

/*
 * renderable.cpp
 *
 * Copyright (C) 2008,2009  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.
 *
 *
 */

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


namespace glut {


// interface destructor
Renderable::~Renderable(void) throw() { }
RenderQueue::~RenderQueue(void) throw() { }


////////////////////////////////////////////////////////////////////////////////
//
//      RQImpl -- class that implements the glut::RenderQueue interface
//
////////////////////////////////////////////////////////////////////////////////

class RQImpl : public RenderQueue {
public:
        // constructor, destructor ---------------------------------------------
        RQImpl(void) throw();
        ~RQImpl(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN int nSlots);

        // glut::RenderQueue class interface methods ---------------------------
        poly_request_t * grabRequestSlot(void) throw();
        poly_request_t * popRequest(void) throw();

private:
        // private member data -------------------------------------------------
        int                     m_nMax;     // max number of requests (slots)
        int                     m_nCurr;    // current number of requests taken
        poly_request_t *        m_polys;    // array of polygon requests
};



RQImpl::RQImpl
(
void
)
throw()
{
        m_nMax = 0;
        m_nCurr = 0;
        m_polys = NULL;
}



RQImpl::~RQImpl
(
void
)
throw()
{
        if (m_polys) {
                delete[] m_polys;
        }
}



void
RQImpl::initialize
(
IN int nSlots
)
{
        ASSERT(nSlots > 0, "bad slot count: %d", nSlots);

        m_nMax = nSlots;
        m_nCurr = 0;

        ASSERT(!m_polys, "already have polygon array?");
        m_polys = new poly_request_t[m_nMax];
        ASSERT(m_polys, "out of memory");
}



poly_request_t *
RQImpl::grabRequestSlot
(
void
)
throw()
{
        ASSERT(m_polys, "null");
        ASSERT(m_nMax >  0, "Bad max size: %d", m_nMax);
        ASSERT(m_nCurr >= 0 && m_nCurr <= m_nMax, "Bad current size: %d",
            m_nCurr);
        if (m_nCurr >= m_nMax) {
                return NULL;    // no more empty slots
        }

        // we have an open slot!  Hand it over
        poly_request_t * ptr = m_polys + m_nCurr;
        ++m_nCurr;
        ptr->clear();   // reset before returning
        return ptr;
}



poly_request_t *
RQImpl::popRequest
(
void
)
throw()
{
        ASSERT(m_polys, "null");
        ASSERT(m_nMax >  0, "Bad max size: %d", m_nMax);
        ASSERT(m_nCurr >= 0 && m_nCurr <= m_nMax, "Bad current size: %d",
            m_nCurr);
        if (m_nCurr < 1) {
                return NULL;    // queue is empty!
        }

        --m_nCurr;
        return m_polys + m_nCurr;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Renderable -- default interface method implementations
//
////////////////////////////////////////////////////////////////////////////////

bool
Renderable::isAnimateable
(
void
)
const
throw()
{
        return false;
}



void
Renderable::getAnimationState
(
OUT std::string& state
)
{
        state.clear();
}



bool
Renderable::setAnimationState
(
IN const char * state
)
{
        ASSERT(state, "null");

        return false;
}



void
Renderable::getAnimationVerbs
(
OUT VecString& verbs
)
{
        verbs.clear();
}



bool
Renderable::setAnimation
(
IN const char * verb
)
{
        return false;
}



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

smart_ptr<RenderQueue>
RenderQueue::create
(
IN int nSlots
)
{
        ASSERT(nSlots > 0, "Bad queue slot count: %d", nSlots);

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

        local->initialize(nSlots);

        return local;
}



};      // glut namespace