VRS - The Virtual Rendering System

version 3.3

enginegl.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2007 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 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 Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: enginegl.h 6136 2007-11-14 11:56:35Z Konstantin_Baumann $

#ifndef VRS_OPENGL_ENGINEGL_H
#define VRS_OPENGL_ENGINEGL_H

#include <vrs/opengl/openglconfig.h>
#include <vrs/engine.h>
#include <vrs/callback.h>
#include <vector>
#include <vrs/opengl/gl2/shadertextureunitselector.h>

namespace VRS {

class GLCanvas;
class Light;
class PBufferManagerGL;
class SharedContextGL;
class TextureUnitSelectorPainterGL;
template<typename T> class HashTable;
template<typename T> class IDHashTable;
template<typename T> class Array;

namespace GL2
{
    class ShaderTextureUnitSelectorPainter;
}

class VRS_CORE_API EngineGL : public Engine {
public:
    EngineGL();
    virtual ~EngineGL();

    virtual void initialize();
    virtual void pushMonoAttribute(const ID& category, MonoAttribute* attr);
    virtual void popMonoAttribute(const ID& category);
    virtual MonoAttribute* getMonoAttribute(const ID& category) const;

    virtual void pushTf(Engine::TFType category = Engine::modelviewMatrix);
    virtual void popTf(Engine::TFType category = Engine::modelviewMatrix);
    virtual void multTf(const Matrix& matrix, Engine::TFType category = Engine::modelviewMatrix);
    virtual void loadTf(const Matrix& matrix, Engine::TFType category = Engine::modelviewMatrix);
    virtual Matrix currentTf(Engine::TFType category = Engine::modelviewMatrix) const;
        // Redirected to OpenGL calls.

    friend class GLCanvas; // only for this method!!!
    virtual Matrix currentNormalizedDeviceCoordsTf() const;
    virtual Matrix currentPureProjectionTf() const;
    virtual Matrix currentPureProjectionTfInv() const;

    PBufferManagerGL* pbufferManager() const;
    SharedContextGL* sharedContext() const;
    void setSharedContext(SharedContextGL* sctx);
    GLuint getDisplayList(SharedObj* obj);
    GLuint newDisplayList(SharedObj* obj);
    GLuint getTextureObject(SharedObj* obj, GLenum target);
    GLuint newTextureObject(SharedObj* obj, GLenum target);
    unsigned int maxTextureUnits() const;
    unsigned int maxVertexTextureUnits() const;
    unsigned int maxFragmentTextureUnits() const;
    unsigned int maxCombinedTextureUnits() const;
    void cleanUp();
    static bool registerHandler(Handler* handler);

    enum { GLVersion = 1, GLUVersion = 2, Buffers = 4, BufferBits = 8,
           StackDepths = 16, PointLineInfo = 32, MiscInfo = 64, All = 127 };
    std::string glInfo(int info) const;

    int majorVersion() const;
    int minorVersion() const;
    int version() const;
    bool isVersion(int major, int minor) const;
    bool hasExtension(const ID& extensionID) const;
    bool disableExtension(const ID& extensionID);
    SO<const HashTable<ID> > enabledExtensions() const;
    SO<const HashTable<ID> > disabledExtensions() const;

    void allowSoftwareEmulation(bool onOff);
    bool isSoftwareEmulationAllowed() const;

    static std::string ErrorString(GLenum glErrorCode);

    virtual GLenum lightNumber(Light*) const;
    void registerCleanUpCallback(SO<Callback1<SO<EngineGL> > > callback);
    void unregisterCleanUpCallback(SO<Callback1<SO<EngineGL> > > callback);
    VRS_TYPEINFO(EngineGL, Engine);

private:
    bool initialized_;
    bool allowSWEmu_;
    int major_;
    int minor_;
    SO<HashTable<ID> > extensions_;
    SO<HashTable<ID> > disabledExtensions_;
    SO<SharedContextGL> sharedCtx_;

#ifndef NDEBUG
public:
    // only for debuging
    virtual void push(Attribute* attr);
    virtual void push(MonoAttribute* attr);
    virtual void push(PolyAttribute* attr);
    virtual void push(Handler* hdl);

    virtual void pop(Attribute* attr);
    virtual void pop(MonoAttribute* attr);
    virtual void pop(PolyAttribute* attr);
    virtual void pop(Handler* hdl);
    virtual void pop(const ID& rid);

    virtual void eval(const Shape* shape);
#endif // NDEBUG

private:
    // for handling of several texture units
    friend class TextureUnitSelectorPainterGL;
    friend class GL2::ShaderTextureUnitSelectorPainter;
    std::vector<SO<IDHashTable<Stack<SO<MonoAttribute> > > > > monoAttributesPerTextureUnit_;
    unsigned int maxTextureUnits_;
    unsigned int maxVertexTextureUnits_;
    unsigned int maxFragmentTextureUnits_;
    unsigned int maxCombinedTextureUnits_;

    unsigned int activeTextureUnit_;
    SO<Array<SO<Callback1<SO<EngineGL> > > > > cleanUpCallbacks_;
    Matrix ndcTf_;
    mutable Matrix cleanProjectionTf_;
    mutable Matrix invCleanProjectionTf_;

    void setNDCTf(const Matrix &ndc);

}; // class EngineGL

} // namespace VRS

#endif // VRS_OPENGL_ENGINEGL_H

---

Generated on Wed May 23 06:00:12 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact