Public API Reference

csplugincommon/opengl/glcommon2d.h

Go to the documentation of this file.

/*
    Copyright (C) 1998 by Jorrit Tyberghein

    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 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_GLCOMMON2D_H__
#define __CS_GLCOMMON2D_H__

#if defined(CS_OPENGL_PATH)
#include CS_HEADER_GLOBAL(CS_OPENGL_PATH,gl.h)
#else
#include <GL/gl.h>
#endif

#include "csextern_gl.h"
#include "csutil/scf.h"
#include "csplugincommon/canvas/graph2d.h"
#include "csplugincommon/iopengl/driverdb.h"
#include "glfontcache.h"
#include "glstates.h"
#include "glextmanager.h"
#include "glss.h"
#include "driverdb.h"
#include "glcanvascommon.h"

namespace CS
{
  namespace PluginCommon
  {
    namespace GL
    {
      class CS_CSPLUGINCOMMON_GL_EXPORT Graphics2DCommon :
        public virtual CS::PluginCommon::Graphics2DCommon,
        public virtual iOpenGLDriverDatabase
      {
      protected:
        friend class ::csGLScreenShot;
        friend class ::csGLFontCache;

        csGLStateCache* statecache;
        csGLStateCacheContext *statecontext;

        bool hasRenderTarget;

        void DecomposeColor (int iColor, GLubyte &oR, GLubyte &oG, GLubyte &oB, GLubyte &oA);
        void DecomposeColor (int iColor, float &oR, float &oG, float &oB, float &oA);
        void setGLColorfromint (int color);

        csGLScreenShot* ssPool;

        csGLScreenShot* GetScreenShot ();
        void RecycleScreenShot (csGLScreenShot* shot);

        csGLExtensionManager ext;
        //int multiSamples;
        bool multiFavorQuality;
        csGLDriverDatabase driverdb;
        bool useCombineTE;

        void Report (int severity, const char* msg, ...);

        void OpenDriverDB (const char* phase = 0);

        bool DrawLineNearClip (csVector3 & v1, csVector3 & v2);
      public:
        virtual const char* GetRendererString (const char* str);
        virtual const char* GetVersionString (const char* ver);

        virtual const char* GetHWRenderer();
        virtual const char* GetHWGLVersion();
        virtual const char* GetHWVendor();

        Graphics2DCommon ();

        virtual ~Graphics2DCommon ();

        /*
        * You must supply all the functions not supplied here, such as
        * SetMouseCursor etc. Note also that even though Initialize, Open,
        * and Close are supplied here, you must still override these functions
        * for your own subclass to make system-specific calls for creating and
        * showing windows, etc.
        */

        virtual bool Initialize (iObjectRegistry *object_reg);

        virtual bool Open ();

        virtual void Close ();

        virtual void SetClipRect (int xmin, int ymin, int xmax, int ymax);

        virtual bool BeginDraw ();
        virtual void FinishDraw ();

        virtual bool Resize (int width, int height);


        /*
        * the remaining functions here do not need to be overridden when
        * inheriting from this class
        */

        virtual void Clear (int color);

        virtual void DrawLine (float x1, float y1, float x2, float y2, int color);
        virtual void DrawLineProjected (const csVector3& v1, const csVector3& v2,
          float fov, int color);
        virtual void DrawLineProjected (const csVector3& v1, const csVector3& v2,
          const CS::Math::Matrix4& projection, int color);
        virtual void DrawBoxProjected (const csBox3& box, const csTransform& object2camera,
          const CS::Math::Matrix4& projection, int color);
        virtual void DrawBox (int x, int y, int w, int h, int color);
        virtual void DrawPixel (int x, int y, int color);
        virtual void DrawPixels (csPixelCoord const* pixels, int num_pixels,
          int color);
        virtual void Blit (int x, int y, int w, int h, unsigned char const* data);

        virtual void GetPixel (int x, int y, uint8 &oR, uint8 &oG, uint8 &oB);
        virtual void GetPixel (int x, int y, uint8 &oR, uint8 &oG, uint8 &oB, uint8 &oA);

        virtual csPtr<iImage> ScreenShot ();

        virtual bool GetDoubleBufferState ()
        { return false; }
        virtual bool DoubleBuffer (bool Enable)
        { return !Enable; }

        virtual bool PerformExtensionV (char const* command, va_list);

        virtual bool DebugCommand (const char* cmd);

        void SetViewport (int left, int top, int width, int height);

        void ReadDatabase (iDocumentNode* dbRoot,
          int configPriority = iConfigManager::ConfigPriorityPlugin + 20,
          const char* phase = 0)
        {
          driverdb.Open (this, dbRoot, phase, configPriority);
        }
      };
    } // namespace GL
  } // namespace PluginCommon
} // namespace CS

class CS_CSPLUGINCOMMON_GL_EXPORT csGraphics2DGLCommon :
  public scfImplementationExt2<csGraphics2DGLCommon,
      csGraphics2D,
      scfFakeInterface<iOpenGLDriverDatabase>,
      scfFakeInterface<iOpenGLCanvas> >,
  public virtual CS::PluginCommon::GL::Graphics2DCommon,
  public virtual CS::PluginCommon::GL::CanvasCommonBase
{
protected:
  iGraphicsCanvas* GetCanvas() { return this; }
public:
  csGraphics2DGLCommon (iBase *iParent);

  virtual ~csGraphics2DGLCommon ();

  /*
   * You must supply all the functions not supplied here, such as
   * SetMouseCursor etc. Note also that even though Initialize, Open,
   * and Close are supplied here, you must still override these functions
   * for your own subclass to make system-specific calls for creating and
   * showing windows, etc.
   */

  virtual bool Initialize (iObjectRegistry *object_reg);
};

#endif // __CS_GLCOMMON2D_H__

---