Graphics and Media Lab CSL: Annotated Index

  GLRC glrc;
  // inside window creation
  glrc.Create(wnd);
  // before rendering into window
  glrc.MakeCurrent();
  // ... 
  // display in the screen (in case of double buffering)
  glrc.SwapBuffers();
  // ..
  // delete gl context (may be avoided, because called in destructor anyway)
  glrc.Destroy();

Image

Generic image class

ImageComposer

Produce single image from several reference images

ImageDecomposer

Decompose an image into several destination images

ImageFilter

Interface for generic image modifier

ImageLoader

Loading and saving bitmaps to files (base class)

IntelImage

Manipulates uncompressed device- and platform-independent bitmaps

IntelSurface

Generic image class

Math

A template class for precision related staff

Math2

Comparison of 2D vectors with a tolerance

Math3

Comparison of 2D vectors with a tolerance

Math4

Comparison of 4D vectors with a tolerance

PathString

Processing of the path to file

Ref

Smart pointer class Smart pointers provide automatic memory management, so that programmer never cares on freeing memory. Smart pointers mechanism frees an object when there are no any references to it. Smart pointers should be used instead of standard C pointers:

  Object* obj; // standard pointer, should be deleted after use
  gml::Ref<Object> obj; // smart pointer frees memory when necessary

Attention:

Smart pointers works only with objects that support AddRef() and Release() operations. It is assumed that object keeps a reference count (a number of smapt pointers pointing to it). This reference count is incremented in AddRef() command and decremented in Release(). Also Release() performs check whether reference count is 0 and calls 'delete this'. GML provides special base class for this: gml::SmartObject. If you want to use smart pointers either derive your object from this class or provide own implementation of AddRef() and Release() methods. 1) initialization Smart pointers are initiliazed just like the standard pointers:

  gml::Ref<Object> obj =  new Object(1,2,3);

Smart pointers must never be defined like this: gml::Rev<Object>* obj; !!! 2) use of smart pointers Smart pointers are dereferenced like normal pointers:

  gml::Ref<Object> obj =  new Object(1,2,3);
  obj->SomeMethod();
  (*obj).SomeMethod();

3) smart pointers as parameters Smart pointers are implicitly casted to normal pointers:

  gml::Ref<Object> obj =  new Object(1,2,3);
  Object* obj1 =  obj;

This operation is dangerous unless used properly. You should use it like follows. Smart pointers may be passed to functions and returned from functions like normal pointers.

  ...
  Object* SomeMethod(Object* obj);
  ...
  gml::Ref<Object> obj =  new Object(1,2,3);
  gml::Ref<Object> obj1 = SomeMethod(obj);

The general rule is this: Use ONLY smart pointers when storing objects. Use normals pointers when passing smart pointers as parameters or return values So the following is forbidden:

  class SomeClass
    {
    private:
      Object* obj;
    public:
      void CreateObject()
        {
        gml::Ref<Object> obj = new Object(1,2,3);
        m_obj = obj;
        } // at this point obj will be deleted, and m_obj will be undefined!!
    };

Correct use:

  class SomeClass
    {
    private:
      gml::Ref<Object> obj;
    public:
      void CreateObject()
        {
        gml::Ref<Object> obj = new Object(1,2,3);
        m_obj = obj;
        } 
    };

ReflectFilter

Creates a grayscale version of a color bitmap

SetRectFilter

Creates a grayscale version of a color bitmap

SimpleImage

Manipulates uncompressed device- and platform-independent bitmaps

SimpleImageLoader

Image loader based on FreeImage third-party library

SmartObject

Base class for objects with support for reference counting

Socket

A wrapper for Win32 stream socket