GLPCDisplayList.h

Go to the documentation of this file.

//# GLPCDisplayList.h: this defines GLPCDisplayList, which acts as a wrapper
//# around OpenGL display lists for the GLPixelCanvas.
//# Copyright (C) 2001
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id$

// <summary>
//      Display list support for GLPixelCanvas.
// </summary>
// <use visibility=local>
//
// <synopsis>
// These classes are used to implement display list support for GLPixelCanvas.
// Execution tracing is supported. The variable 'nspaces' gives the number
// of spaces to indent the printout. All of these classes are used internally
// by GLPixelCanvas and wouldn't be useful elsewhere.
// </synopsis>
//
// <prerequisite>
//   <li> None
// </prerequisite>
//
// <thrown>
//  None
// </thrown>
//
// <todo asof="2001/10/9">
// 
// </todo>

#ifndef TRIALDISPLAY_GLPCDISPLAYLIST_H
#define TRIALDISPLAY_GLPCDISPLAYLIST_H

#include <string.h>
#include <GL/gl.h>
#include <casa/aips.h>
#include <casa/BasicSL/String.h>

namespace casa { //# NAMESPACE CASA - BEGIN

// <summary>
// Base class for the various display list subclasses.
// </summary>
class GLPCDisplayListElement {
  public:
        // Draw element unless disabled or force is True.
        virtual void call(Bool force=False, const uInt nspaces=0);

        // enable/disable
        // <group>
        Bool enabled()const {return enabled_;}
        Bool disabled()const {return !enabled_;}
        virtual void disable();
        virtual void enable();
        // </group>

        // Each element has a name which is printed out when tracing.
        // <group>
        const char *name()const{return name_.chars();}
        void name(const char *);
        // </group>
        // Enable/disable tracing.
        // <group>
        Bool trace()const{return trace_;}
        void trace(const Bool t){ trace_ = t;}
        // </group>
        // Begin recording commands.
        // Recording is a one shot deal. After stop is called, recording
        // can not be reenabled.
        virtual void start();   //# Start recording.
        // Stop display list recording. Ignored if not already recording.
        virtual void stop();
        // Each element is reference counted.
        uLong useCount()const {return usage_;}
        void ref();
        void unref();
  protected:
        GLPCDisplayListElement(const char *name=NULL);
        // Elements self delete when the reference count goes to 0.
        virtual ~GLPCDisplayListElement();
        void traceCheck(uInt spaces=0, const char *str=NULL,
                        const char *name=NULL);
  private:
        uLong   usage_;
        Bool    enabled_;
        Bool    trace_;
        String  name_;
};

// <summary>
// Returns a Display List Element for recording GL commands.
// </summary>
// <synopsis>
// Returns a Display List Element for recording GL commands.
// Commands are recorded until stop is called by creating an OpenGL
// display list and letting OpenGL do the actual recording. Calling
// stop ends the list. Typically, these OpenGL lists are very short,
// containing just one or two commands. eg. draw a rectangle.
// </synopsis>
class GLPCDisplayListEntry : public GLPCDisplayListElement {
  public:
        enum RECORDSTATE { INITED, RECORDING, STOPPED};

        GLPCDisplayListEntry::GLPCDisplayListEntry(
                                        const char *name=NULL,
                                        GLenum mode=GL_COMPILE_AND_EXECUTE);
        virtual ~GLPCDisplayListEntry();
        //# Draw list.
        virtual void call(Bool force, const uInt spaces);
        //# Recording is a one shot deal. After stop is called, recording
        //# can not be reenabled.
        virtual void start();   //# Start recording.
        //# Stop display list recording. Ignored if not already recording.
        virtual void stop();
  protected:
  private:
        GLenum          mode_;
        GLuint          id_;    
        RECORDSTATE     recording_;
};

//#////////////////////////////////////////////////////////////////

// <summary>
// DisplayListElement that can contain lists of other DisplayListElements.
// </summary>
// <synopsis>
// When GLPixelCanvas::newList() is called, a GLPCDisplayList is created
// to hold all the GLPCDisplayListEntrys that are created. A GLPCDisplayList
// can also hold other GLPCDisplayLists (drawList called inside a list).
// </synopsis>
class GLPCDisplayList : public GLPCDisplayListElement {
  public:
        // Amount by which to increment the list of display lists when
        // it fills up.
        enum {DefaultSizeIncrement=16};

        GLPCDisplayList(const char *name=NULL,
                        uInt sizeincr=GLPCDisplayList::DefaultSizeIncrement);

        // Copy a display list's list.
        GLPCDisplayList(const GLPCDisplayList &list);
        ~GLPCDisplayList();

        // Append another element to list.
        void add(GLPCDisplayListElement *);

        // Run the current list.
        virtual void call(Bool force=False, uInt spaces=0);

        // Translate the list.
        // Set translation values. New values are added to current.
        void translate(Float xt, Float yt, Float zt=0.0);

        //# Miscellaneous

        // Return current translation
        void  translation(Float &xo, Float &yo)const;
        void  translation(Float &xo, Float &yo, Float &zo)const;
        // Return/Set amount to increase id list by.
        uInt sizeincrement()const{return sizeincr_;}
        void sizeincrement(const uInt sizeincr) { sizeincr_ = sizeincr;}
  protected:
  private:
        void resize();
        void unrefall();

        GLfloat xt_, yt_, zt_;  //# Amount to translate display list.
        uInt    sizeincr_;      //# Amount to increase listids_ when it's full.
        uInt    numentries_;    //# # of entries & index to next free.
        uInt    listSize_;      //# # of slots in list.
        GLPCDisplayListElement **list_;
};


} //# NAMESPACE CASA - END

#endif