--- deliantra/Deliantra-Client/Client.xs	2007/04/04 02:43:29	1.173
+++ deliantra/Deliantra-Client/Client.xs	2007/12/26 21:03:21	1.242
@@ -8,12 +8,22 @@
 # pragma warning(disable:4761)
 #endif
 
+//#define DEBUG 1
+#if DEBUG
+# include <valgrind/memcheck.h>
+#endif
+
 #include "EXTERN.h"
 #include "perl.h"
 #include "XSUB.h"
 
 #ifdef _WIN32
 # undef pipe
+// microsoft vs. C
+# define sqrtf(x) sqrt(x)
+# define roundf(x) (int)(x)
+# define atan2f(x,y) atan2(x,y)
+# define M_PI 3.14159265f
 #endif
 
 #include <assert.h>
@@ -22,7 +32,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
+
 #include <SDL.h>
+#include <SDL_thread.h>
 #include <SDL_endian.h>
 #include <SDL_image.h>
 #include <SDL_mixer.h>
@@ -58,6 +71,8 @@
 # define PARACHUTE 0
 #endif
 
+static AV *texture_av;
+
 static struct
 {
 #define GL_FUNC(ptr,name) ptr name;
@@ -65,7 +80,8 @@
 #undef GL_FUNC
 } gl;
 
-static void gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
+static void
+gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
 {
   if (gl.BlendFuncSeparate)
     gl.BlendFuncSeparate (sa, da, saa, daa);
@@ -75,16 +91,43 @@
     glBlendFunc (sa, da);
 }
 
+static GLuint
+gen_texture ()
+{
+  GLuint name;
+
+  if (AvFILL (texture_av) >= 0)
+    name = (GLuint)(size_t)av_pop (texture_av);
+  else
+    glGenTextures (1, &name);
+
+  return name;
+}
+
+static void
+del_texture (GLuint name)
+{
+  /* make a half-assed attempt at returning the memory used by the texture */
+  /* textures are frequently being reused by cfplus anyway */
+  /*glBindTexture (GL_TEXTURE_2D, name);*/
+  /*glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, 0, 0, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);*/
+  av_push (texture_av, (SV *)(size_t)name);
+  glDeleteTextures (1, &name);
+}
+
 #include "texcache.c"
+#include "rendercache.c"
 
 #include "pango-font.c"
 #include "pango-fontmap.c"
 #include "pango-render.c"
 
-typedef Mix_Chunk *CFPlus__MixChunk;
-typedef Mix_Music *CFPlus__MixMusic;
+typedef IV         DC__Channel;
+typedef SDL_RWops *DC__RW;
+typedef Mix_Chunk *DC__MixChunk;
+typedef Mix_Music *DC__MixMusic;
 
-typedef PangoFontDescription *CFPlus__Font;
+typedef PangoFontDescription *DC__Font;
 
 static int
 shape_attr_p (PangoLayoutRun *run)
@@ -108,10 +151,11 @@
   PangoLayout *pl;
   float r, g, b, a; // default color for rgba mode
   int base_height;
-  CFPlus__Font font;
-} *CFPlus__Layout;
+  DC__Font font;
+  rc_t *rc;
+} *DC__Layout;
 
-static CFPlus__Font default_font;
+static DC__Font default_font;
 static PangoContext *opengl_context;
 static PangoFontMap *opengl_fontmap;
 
@@ -126,7 +170,7 @@
 }
 
 static void
-layout_update_font (CFPlus__Layout self)
+layout_update_font (DC__Layout self)
 {
   /* use a random scale factor to account for unknown descenders, 0.8 works
    * reasonably well with bitstream vera
@@ -140,7 +184,7 @@
 }
 
 static void
-layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)
+layout_get_pixel_size (DC__Layout self, int *w, int *h)
 {
   PangoRectangle rect;
 
@@ -157,20 +201,23 @@
   *h = rect.height;
 }
 
-typedef uint16_t mapface;
+typedef uint16_t tileid;
+typedef uint16_t faceid;
 
 typedef struct {
-  GLint name;
+  GLuint name;
   int w, h;
   float s, t;
   uint8_t r, g, b, a;
+  tileid smoothtile;
+  uint8_t smoothlevel;
 } maptex;
 
 typedef struct {
   uint32_t player;
-  mapface face[3];
+  tileid tile[3];
   uint16_t darkness;
-  uint8_t stat_width, stat_hp, flags;
+  uint8_t stat_width, stat_hp, flags, smoothmax;
 } mapcell;
 
 typedef struct {
@@ -181,15 +228,12 @@
 typedef struct map {
   int x, y, w, h;
   int ox, oy; /* offset to virtual global coordinate system */
-  int faces;
-  mapface *face;
-
-  int texs;
-  maptex *tex;
+  int faces; tileid *face2tile; // [faceid]
+  int texs;  maptex *tex;       // [tileid]
 
   int32_t rows;
   maprow *row;
-} *CFPlus__Map;
+} *DC__Map;
 
 static char *
 prepend (char *ptr, int sze, int inc)
@@ -216,8 +260,28 @@
 #define Append(type,ptr,sze,inc)  (ptr) = (type *)append  ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
 #define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
 
+static void
+need_facenum (struct map *self, faceid face)
+{
+  while (self->faces <= face)
+    {
+      Append (tileid, self->face2tile, self->faces, self->faces);
+      self->faces *= 2;
+    }
+}
+
+static void
+need_texid (struct map *self, int texid)
+{
+  while (self->texs <= texid)
+    {
+      Append (maptex, self->tex, self->texs, self->texs);
+      self->texs *= 2;
+    }
+}
+
 static maprow *
-map_get_row (CFPlus__Map self, int y)
+map_get_row (DC__Map self, int y)
 {
   if (0 > y)
     {
@@ -265,13 +329,13 @@
 }
 
 static mapcell *
-map_get_cell (CFPlus__Map self, int x, int y)
+map_get_cell (DC__Map self, int x, int y)
 {
   return row_get_cell (map_get_row (self, y), x);
 }
 
 static void
-map_clear (CFPlus__Map self)
+map_clear (DC__Map self)
 {
   int r;
 
@@ -289,7 +353,7 @@
 }
 
 static void
-map_blank (CFPlus__Map self, int x0, int y0, int w, int h)
+map_blank (DC__Map self, int x0, int y0, int w, int h)
 {
   int x, y;
   maprow *row;
@@ -319,6 +383,22 @@
       }
 }
 
+typedef struct  {
+  tileid tile;
+  uint8_t x, y, level;
+} smooth_key;
+
+static void
+smooth_or_bits (HV *hv, smooth_key *key, IV bits)
+{
+  SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
+
+  if (SvIOK (*sv))
+    SvIV_set (*sv, SvIVX (*sv) | bits);
+  else
+    sv_setiv (*sv, bits);
+}
+
 static void
 music_finished (void)
 {
@@ -362,17 +442,71 @@
   return n + 1;
 }
 
+static unsigned int
+popcount (unsigned int n)
+{
+  n -=  (n >> 1) & 0x55555555U;
+  n  = ((n >> 2) & 0x33333333U) + (n & 0x33333333U);
+  n  = ((n >> 4) + n) & 0x0f0f0f0fU;
+  n *= 0x01010101U;
+
+  return n >> 24;
+}
+
 /* SDL should provide this, really. */
 #define SDLK_MODIFIER_MIN 300
 #define SDLK_MODIFIER_MAX 314
 
-MODULE = CFPlus	PACKAGE = CFPlus
+/******************************************************************************/
+
+static GV *draw_x_gv, *draw_y_gv, *draw_w_gv, *draw_h_gv;
+static GV *hover_gv;
+
+static int
+within_widget (SV *widget, NV x, NV y)
+{
+  HV *self;
+  SV **svp;
+  NV wx, ww, wy, wh;
+
+  if (!SvROK (widget))
+    return 0;
+
+  self = (HV *)SvRV (widget);
+
+  if (SvTYPE (self) != SVt_PVHV)
+    return 0;
+
+  svp = hv_fetch (self, "y", 1, 0); wy = svp ? SvNV (*svp) : 0.;
+  if (y < wy)
+    return 0;
+
+  svp = hv_fetch (self, "h", 1, 0); wh = svp ? SvNV (*svp) : 0.;
+  if (y >= wy + wh)
+    return 0;
+
+  svp = hv_fetch (self, "x", 1, 0); wx = svp ? SvNV (*svp) : 0.;
+  if (x < wx)
+    return 0;
+
+  svp = hv_fetch (self, "w", 1, 0); ww = svp ? SvNV (*svp) : 0.;
+  if (x >= wx + ww)
+    return 0;
+
+  svp = hv_fetch (self, "can_events", sizeof ("can_events") - 1, 0);
+  if (!svp || !SvTRUE (*svp))
+    return 0;
+
+  return 1;
+}
+
+MODULE = Deliantra::Client	PACKAGE = DC
 
 PROTOTYPES: ENABLE
 
 BOOT:
 {
-  HV *stash = gv_stashpv ("CFPlus", 1);
+  HV *stash = gv_stashpv ("DC", 1);
   static const struct {
     const char *name;
     IV iv;
@@ -404,6 +538,8 @@
         const_iv (SDL_APPMOUSEFOCUS),
         const_iv (SDL_APPACTIVE),
 
+	const_iv (SDLK_FIRST),
+	const_iv (SDLK_LAST),
 	const_iv (SDLK_KP0),
 	const_iv (SDLK_KP1),
 	const_iv (SDLK_KP2),
@@ -485,6 +621,8 @@
 	const_iv (KMOD_NUM),
 	const_iv (KMOD_CAPS),
 	const_iv (KMOD_MODE),
+
+        const_iv (MIX_DEFAULT_FORMAT),
 #	undef const_iv
   };
     
@@ -512,6 +650,10 @@
 
 NV ceil (NV x)
 
+IV minpot (UV n)
+
+IV popcount (UV n)
+
 void
 pango_init ()
 	CODE:
@@ -521,6 +663,9 @@
         opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
 }
 
+char *
+SDL_GetError ()
+
 int
 SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
 
@@ -528,22 +673,22 @@
 SDL_Quit ()
 
 void
-SDL_ListModes ()
+SDL_ListModes (int rgb, int alpha)
 	PPCODE:
 {
 	SDL_Rect **m;
 	
-        SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
-        SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
-        SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
-        SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1);
+        SDL_GL_SetAttribute (SDL_GL_RED_SIZE  , rgb);
+        SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
+        SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
+        SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
 
         SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
-        SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0);
+        SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE ,  0);
 
-        SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0);
+        SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE  , 0);
         SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
-        SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0);
+        SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
         SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
 
         SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
@@ -552,39 +697,51 @@
         SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
 #endif
 
-        SDL_EnableUNICODE (1);
-        SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
-
 	m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
 
         if (m && m != (SDL_Rect **)-1)
           while (*m)
             {
-              AV *av = newAV ();
-              av_push (av, newSViv ((*m)->w));
-              av_push (av, newSViv ((*m)->h));
-              XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
+              if ((*m)->w >= 800 && (*m)->h >= 600)
+                {
+                  AV *av = newAV ();
+                  av_push (av, newSViv ((*m)->w));
+                  av_push (av, newSViv ((*m)->h));
+                  av_push (av, newSViv (rgb));
+                  av_push (av, newSViv (alpha));
+                  XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
+                }
 
               ++m;
             }
 }
 
-char *
-SDL_GetError ()
-
 int
-SDL_SetVideoMode (int w, int h, int fullscreen)
+SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
 	CODE:
+{
+        SDL_EnableUNICODE (1);
+        SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
+
+        SDL_GL_SetAttribute (SDL_GL_RED_SIZE  , rgb);
+        SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
+        SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
+        SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
+
         RETVAL = !!SDL_SetVideoMode (
           w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
         );
+
         if (RETVAL)
           {
-            SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
-#           define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
-#           include "glfunc.h"
-#           undef GL_FUNC
+            av_clear (texture_av);
+
+            SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
+#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
+#include "glfunc.h"
+#undef GL_FUNC
           }
+}
 	OUTPUT:
         RETVAL
 
@@ -594,13 +751,17 @@
 char *
 SDL_GetKeyName (int sym)
 
+int
+SDL_GetAppState ()
+
 void
-SDL_PollEvent ()
+poll_events ()
 	PPCODE:
 {
 	SDL_Event ev;
 
-        while (SDL_PollEvent (&ev))
+        SDL_PumpEvents ();
+        while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
           {
             HV *hv = newHV ();
             hv_store (hv, "type", 4, newSViv (ev.type), 0);
@@ -622,13 +783,31 @@
                   break;
 
                 case SDL_MOUSEMOTION:
-                  hv_store (hv, "mod",    3, newSViv (SDL_GetModState ()), 0);
+                  {
+                    int state = ev.motion.state;
+                    int x     = ev.motion.x;
+                    int y     = ev.motion.y;
+                    int xrel  = ev.motion.xrel;
+                    int yrel  = ev.motion.yrel;
+
+                    /* do simplistic event compression */
+                    while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
+                           && state == ev.motion.state)
+                      {
+                        xrel += ev.motion.xrel;
+                        yrel += ev.motion.yrel;
+                        x     = ev.motion.x;
+                        y     = ev.motion.y;
+                        SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
+                      }
 
-                  hv_store (hv, "state",  5, newSViv (ev.motion.state), 0);
-                  hv_store (hv, "x",      1, newSViv (ev.motion.x), 0);
-                  hv_store (hv, "y",      1, newSViv (ev.motion.y), 0);
-                  hv_store (hv, "xrel",   4, newSViv (ev.motion.xrel), 0);
-                  hv_store (hv, "yrel",   4, newSViv (ev.motion.yrel), 0);
+                    hv_store (hv, "mod",    3, newSViv (SDL_GetModState ()), 0);
+                    hv_store (hv, "state",  5, newSViv (state), 0);
+                    hv_store (hv, "x",      1, newSViv (x), 0);
+                    hv_store (hv, "y",      1, newSViv (y), 0);
+                    hv_store (hv, "xrel",   4, newSViv (xrel), 0);
+                    hv_store (hv, "yrel",   4, newSViv (yrel), 0);
+                  }
                   break;
 
                 case SDL_MOUSEBUTTONDOWN:
@@ -648,28 +827,45 @@
                   break;
               }
 
-            XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1))));
+            XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
           }
 }
 
 int
-Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048)
+Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
   	POSTCALL:
         Mix_HookMusicFinished (music_finished);
         Mix_ChannelFinished (channel_finished);
 
 void
+Mix_QuerySpec ()
+	PPCODE:
+{
+	int freq, channels;
+        Uint16 format;
+
+        if (Mix_QuerySpec (&freq, &format, &channels))
+          {
+            EXTEND (SP, 3);
+            PUSHs (sv_2mortal (newSViv (freq)));
+            PUSHs (sv_2mortal (newSViv (format)));
+            PUSHs (sv_2mortal (newSViv (channels)));
+          }
+}
+
+void
 Mix_CloseAudio ()
 
 int
 Mix_AllocateChannels (int numchans = -1)
 
+const char *
+Mix_GetError ()
+
 void
 lowdelay (int fd, int val = 1)
 	CODE:
-#ifndef _WIN32
-        setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val));
-#endif
+        setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
 
 void
 win32_proxy_info ()
@@ -716,7 +912,7 @@
         SDL_Surface *surface, *surface2;
         SDL_PixelFormat fmt;
 	SDL_RWops *rw = ix
-          ? SDL_RWFromFile (image, "r")
+          ? SDL_RWFromFile (image, "rb")
           : SDL_RWFromConstMem (image, image_len);
 
         if (!rw)
@@ -799,7 +995,7 @@
 	CODE:
         fprintf (stderr, "ERROR: %s\n", message);
 #ifdef _WIN32
-        MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR);
+        MessageBox (0, message, "Deliantra Client Error", MB_OK | MB_ICONERROR);
 #endif
 
 void
@@ -807,7 +1003,7 @@
 	CODE:
         fprintf (stderr, "FATAL: %s\n", message);
 #ifdef _WIN32
-        MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR);
+        MessageBox (0, message, "Deliantra Client Fatal Error", MB_OK | MB_ICONERROR);
 #endif
         _exit (1);
 
@@ -820,9 +1016,20 @@
         _exit (retval);
 #endif
 
-MODULE = CFPlus	PACKAGE = CFPlus::Font
+void
+debug ()
+	CODE:
+{
+#if DEBUG
+	VALGRIND_DO_LEAK_CHECK;
+#endif
+}
 
-CFPlus::Font
+MODULE = Deliantra::Client	PACKAGE = DC::Font
+
+PROTOTYPES: DISABLE
+
+DC::Font
 new_from_file (SV *class, char *path, int id = 0)
 	CODE:
 {
@@ -835,23 +1042,33 @@
         RETVAL
 
 void
-DESTROY (CFPlus::Font self)
+DESTROY (DC::Font self)
 	CODE:
         pango_font_description_free (self);
 
 void
-make_default (CFPlus::Font self)
+make_default (DC::Font self)
+	PROTOTYPE: $
 	CODE:
         default_font = self;
 
-MODULE = CFPlus	PACKAGE = CFPlus::Layout
+MODULE = Deliantra::Client	PACKAGE = DC::Layout
+
+PROTOTYPES: DISABLE
+
+void
+glyph_cache_backup ()
+	PROTOTYPE:
+	CODE:
+        tc_backup ();
 
 void
-reset_glyph_cache ()
+glyph_cache_restore ()
+	PROTOTYPE:
 	CODE:
-        tc_clear ();
+        tc_restore ();
 
-CFPlus::Layout
+DC::Layout
 new (SV *class)
 	CODE:
         New (0, RETVAL, 1, struct cf_layout);
@@ -863,6 +1080,7 @@
         RETVAL->a           = 1.;
         RETVAL->base_height = MIN_FONT_HEIGHT;
         RETVAL->font        = 0;
+        RETVAL->rc          = rc_alloc ();
 
         pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
         layout_update_font (RETVAL);
@@ -870,13 +1088,14 @@
         RETVAL
 
 void
-DESTROY (CFPlus::Layout self)
+DESTROY (DC::Layout self)
 	CODE:
         g_object_unref (self->pl);
+        rc_free (self->rc);
         Safefree (self);
 
 void
-set_text (CFPlus::Layout self, SV *text_)
+set_text (DC::Layout self, SV *text_)
 	CODE:
 {
 	STRLEN textlen;
@@ -886,7 +1105,7 @@
 }
 
 void
-set_markup (CFPlus::Layout self, SV *text_)
+set_markup (DC::Layout self, SV *text_)
 	CODE:
 {
 	STRLEN textlen;
@@ -896,7 +1115,7 @@
 }
 
 void
-set_shapes (CFPlus::Layout self, ...)
+set_shapes (DC::Layout self, ...)
 	CODE:
 {
         PangoAttrList *attrs = 0;
@@ -941,7 +1160,7 @@
 }
 
 void
-get_shapes (CFPlus::Layout self)
+get_shapes (DC::Layout self)
 	PPCODE:
 {
         PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
@@ -966,7 +1185,7 @@
 }
 
 int
-has_wrapped (CFPlus::Layout self)
+has_wrapped (DC::Layout self)
 	CODE:
 {
 	int lines = 1;
@@ -981,7 +1200,7 @@
         RETVAL
 
 SV *
-get_text (CFPlus::Layout self)
+get_text (DC::Layout self)
 	CODE:
         RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
         sv_utf8_decode (RETVAL);
@@ -989,7 +1208,7 @@
         RETVAL
 
 void
-set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.)
+set_foreground (DC::Layout self, float r, float g, float b, float a = 1.)
 	CODE:
         self->r = r;
         self->g = g;
@@ -997,7 +1216,7 @@
         self->a = a;
 
 void
-set_font (CFPlus::Layout self, CFPlus::Font font = 0)
+set_font (DC::Layout self, DC::Font font = 0)
 	CODE:
         if (self->font != font)
 	  {
@@ -1006,7 +1225,7 @@
           }
 
 void
-set_height (CFPlus::Layout self, int base_height)
+set_height (DC::Layout self, int base_height)
 	CODE:
         if (self->base_height != base_height)
   	  {
@@ -1015,22 +1234,22 @@
           }
 
 void
-set_width (CFPlus::Layout self, int max_width = -1)
+set_width (DC::Layout self, int max_width = -1)
 	CODE:
         pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
 
 void
-set_indent (CFPlus::Layout self, int indent)
+set_indent (DC::Layout self, int indent)
 	CODE:
         pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
 
 void
-set_spacing (CFPlus::Layout self, int spacing)
+set_spacing (DC::Layout self, int spacing)
 	CODE:
         pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
 
 void
-set_ellipsise (CFPlus::Layout self, int ellipsise)
+set_ellipsise (DC::Layout self, int ellipsise)
 	CODE:
         pango_layout_set_ellipsize (self->pl,
             ellipsise == 1 ? PANGO_ELLIPSIZE_START
@@ -1040,12 +1259,12 @@
         );
 
 void
-set_single_paragraph_mode (CFPlus::Layout self, int spm)
+set_single_paragraph_mode (DC::Layout self, int spm)
 	CODE:
         pango_layout_set_single_paragraph_mode (self->pl, !!spm);
 
 void
-size (CFPlus::Layout self)
+size (DC::Layout self)
 	PPCODE:
 {
 	int w, h;
@@ -1058,7 +1277,7 @@
 }
 
 int
-descent (CFPlus::Layout self)
+descent (DC::Layout self)
 	CODE:
 {
 	PangoRectangle rect;
@@ -1070,7 +1289,7 @@
         RETVAL
 
 int
-xy_to_index (CFPlus::Layout self, int x, int y)
+xy_to_index (DC::Layout self, int x, int y)
 	CODE:
 {
 	int index, trailing;
@@ -1081,7 +1300,7 @@
         RETVAL
 
 void
-cursor_pos (CFPlus::Layout self, int index)
+cursor_pos (DC::Layout self, int index)
 	PPCODE:
 {
 	PangoRectangle strong_pos;
@@ -1094,7 +1313,7 @@
 }
 
 void
-index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
+index_to_line_x (DC::Layout self, int index, int trailing = 0)
 	PPCODE:
 {
 	int line, x;
@@ -1108,7 +1327,7 @@
 }
 
 void
-line_x_to_index (CFPlus::Layout self, int line, int x)
+line_x_to_index (DC::Layout self, int line, int x)
 	PPCODE:
 {
 	PangoLayoutLine *lp;
@@ -1133,51 +1352,62 @@
 }
 
 void
-render (CFPlus::Layout self, float x, float y, int flags = 0)
-	PPCODE:
+render (DC::Layout self, float x, float y, int flags = 0)
+	CODE:
+        rc_clear (self->rc);
         pango_opengl_render_layout_subpixel (
           self->pl,
+          self->rc,
           x * PANGO_SCALE, y * PANGO_SCALE,
           self->r, self->g, self->b, self->a,
           flags
         );
-
-MODULE = CFPlus	PACKAGE = CFPlus::Texture
+        // we assume that context_change actually clears/frees stuff
+        // and does not do any recomputation...
+        pango_layout_context_changed (self->pl);
 
 void
-pad2pot (SV *data_, SV *w_, SV *h_)
+draw (DC::Layout self)
 	CODE:
 {
-        int ow = SvIV (w_);
-        int oh = SvIV (h_);
+        glEnable (GL_TEXTURE_2D);
+        glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+        glEnable (GL_BLEND);
+        gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
+                              GL_ONE      , GL_ONE_MINUS_SRC_ALPHA);
+        glEnable (GL_ALPHA_TEST);
+        glAlphaFunc (GL_GREATER, 7.f / 255.f);
 
-        if (ow && oh)
-          {
-            int nw = minpot (ow);
-            int nh = minpot (oh);
+        rc_draw (self->rc);
 
-            if (nw != ow || nh != oh)
-              {
-                if (SvOK (data_))
-                  {
-                    STRLEN datalen;
-                    char *data = SvPVbyte (data_, datalen);
-                    int bpp = datalen / (ow * oh);
-                    SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
-
-                    SvPOK_only (result_);
-                    SvCUR_set (result_, nw * nh * bpp);
-
-                    memset (SvPVX (result_), 0, nw * nh * bpp);
-                    while (oh--)
-                      memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
+        glDisable (GL_ALPHA_TEST);
+        glDisable (GL_BLEND);
+        glDisable (GL_TEXTURE_2D);
+}
 
-                    sv_setsv (data_, result_);
-                  }
+MODULE = Deliantra::Client	PACKAGE = DC::Texture
 
-                sv_setiv (w_, nw);
-                sv_setiv (h_, nh);
-              }
+PROTOTYPES: ENABLE
+
+void
+pad (SV *data_, int ow, int oh, int nw, int nh)
+	CODE:
+{
+        if ((nw != ow || nh != oh) && SvOK (data_))
+          {
+            STRLEN datalen;
+            char *data = SvPVbyte (data_, datalen);
+            int bpp = datalen / (ow * oh);
+            SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
+
+            SvPOK_only (result_);
+            SvCUR_set (result_, nw * nh * bpp);
+
+            memset (SvPVX (result_), 0, nw * nh * bpp);
+            while (oh--)
+              memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
+
+            sv_setsv (data_, result_);
           }
 }
 
@@ -1194,6 +1424,9 @@
 	float t = SvNV (*hv_fetch (hv, "t", 1, 1));
         int name = SvIV (*hv_fetch (hv, "name", 4, 1));
 
+        if (name <= 0)
+          XSRETURN_EMPTY;
+
         if (items < 5)
           {
             w = SvNV (*hv_fetch (hv, "w", 1, 1));
@@ -1230,9 +1463,22 @@
           }
 }
 
-MODULE = CFPlus	PACKAGE = CFPlus::Map
+IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
+	CODE:
+{
+        GLint width;
+        glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
+        glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
+        RETVAL = width > 0;
+}
+	OUTPUT:
+        RETVAL
+
+MODULE = Deliantra::Client	PACKAGE = DC::Map
 
-CFPlus::Map
+PROTOTYPES: DISABLE
+
+DC::Map
 new (SV *class)
 	CODE:
         New (0, RETVAL, 1, struct map);
@@ -1242,58 +1488,70 @@
         RETVAL->h  = 0;
         RETVAL->ox = 0;
         RETVAL->oy = 0;
-        RETVAL->faces = 8192;
-        Newz (0, RETVAL->face, RETVAL->faces, mapface);
-        RETVAL->texs = 8192;
-        Newz (0, RETVAL->tex, RETVAL->texs, maptex);
+        RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
+        RETVAL->texs  = 8192; Newz (0, RETVAL->tex      , RETVAL->texs , maptex);
         RETVAL->rows = 0;
         RETVAL->row = 0;
 	OUTPUT:
         RETVAL
 
 void
-DESTROY (CFPlus::Map self)
+DESTROY (DC::Map self)
 	CODE:
 {
         map_clear (self);
-        Safefree (self->face);
+        Safefree (self->face2tile);
         Safefree (self->tex);
         Safefree (self);
 }
 
 void
-resize (CFPlus::Map self, int map_width, int map_height)
+resize (DC::Map self, int map_width, int map_height)
 	CODE:
         self->w = map_width;
         self->h = map_height;
 
 void
-clear (CFPlus::Map self)
+clear (DC::Map self)
 	CODE:
         map_clear (self);
 
 void
-set_face (CFPlus::Map self, int face, int texid)
+set_tileid (DC::Map self, int face, int tile)
 	CODE:
 {
-        while (self->faces <= face)
-          {
-            Append (mapface, self->face, self->faces, self->faces);
-            self->faces *= 2;
-          }
+	need_facenum (self, face); self->face2tile [face] = tile;
+        need_texid   (self, tile);
+}
 
-        self->face [face] = texid;
+void
+set_smooth (DC::Map self, int face, int smooth, int level)
+	CODE:
+{
+  	tileid texid;
+        maptex *tex;
+
+        if (face < 0 || face >= self->faces)
+          return;
+
+        if (smooth < 0 || smooth >= self->faces)
+          return;
+
+  	texid = self->face2tile [face];
+
+        if (!texid)
+          return;
+
+        tex = self->tex + texid;
+        tex->smoothtile  = self->face2tile [smooth];
+        tex->smoothlevel = level;
 }
 
 void
-set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
+set_texture (DC::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
 	CODE:
 {
-        while (self->texs <= texid)
-          {
-            Append (maptex, self->tex, self->texs, self->texs);
-            self->texs *= 2;
-          }
+	need_texid (self, texid);
 
         {
           maptex *tex = self->tex + texid;
@@ -1320,7 +1578,7 @@
 }
 
 int
-ox (CFPlus::Map self)
+ox (DC::Map self)
 	ALIAS:
            oy = 1
            x  = 2
@@ -1341,18 +1599,18 @@
         RETVAL
 
 void
-scroll (CFPlus::Map self, int dx, int dy)
+scroll (DC::Map self, int dx, int dy)
 	CODE:
 {
         if (dx > 0)
           map_blank (self, self->x, self->y, dx, self->h);
         else if (dx < 0)
-          map_blank (self, self->x + self->w + dx + 1, self->y, -dx, self->h);
+          map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
 
         if (dy > 0)
           map_blank (self, self->x, self->y, self->w, dy);
         else if (dy < 0)
-          map_blank (self, self->x, self->y + self->h + dy + 1, self->w, -dy);
+          map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
 
 	self->ox += dx; self->x += dx;
 	self->oy += dy; self->y += dy;
@@ -1366,14 +1624,16 @@
           }
 }
 
-void
-map1a_update (CFPlus::Map self, SV *data_, int extmap)
+SV *
+map1a_update (DC::Map self, SV *data_, int extmap)
 	CODE:
 {
         uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
         uint8_t *data_end = (uint8_t *)SvEND (data_);
         mapcell *cell;
-        int x, y, flags;
+        int x, y, z, flags;
+        AV *missing = newAV ();
+        RETVAL = newRV_noinc ((SV *)missing);
 
         while (data < data_end - 1)
           {
@@ -1416,8 +1676,8 @@
                               cell->stat_width = *data++ + 1;
                             else if (cmd == 0x47)
                               {
-                                if (*data == 8)
-                                  ; // decode player uuid
+                                if (*data == 4)
+                                  ; // decode player count
 
                                 data += *data + 1;
                               }
@@ -1434,28 +1694,37 @@
                       cell->darkness = *data++ + 1;
                   }
 
-                if (flags & 4)
-                  {
-                    cell->face [0] = self->face [(data [0] << 8) + data [1]]; data += 2;
-                  }
+                for (z = 0; z <= 2; ++z)
+                  if (flags & (4 >> z))
+                    {
+                      faceid face = (data [0] << 8) + data [1]; data += 2;
+                      need_facenum (self, face);
+                      cell->tile [z] = self->face2tile [face];
 
-                if (flags & 2)
-                  {
-                    cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2;
-                  }
+                      if (cell->tile [z])
+                        {
+                          maptex *tex = self->tex + cell->tile [z];
+                          if (!tex->name)
+                            av_push (missing, newSViv (cell->tile [z]));
 
-                if (flags & 1)
-                  {
-                    cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2;
-                  }
+                          if (tex->smoothtile)
+                            {
+                              maptex *smooth = self->tex + tex->smoothtile;
+                              if (!smooth->name)
+                                av_push (missing, newSViv (tex->smoothtile));
+                            }
+                        }
+                    }
               }
             else
               cell->darkness = 0;
           }
 }
+	OUTPUT:
+        RETVAL
 
 SV *
-mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
+mapmap (DC::Map self, int x0, int y0, int w, int h)
 	CODE:
 {
 	int x1, x;
@@ -1486,19 +1755,14 @@
 
                     for (z = 0; z <= 0; z++)
                       {
-                        mapface face = cell->face [z];
-
-                        if (face > 0 && face < self->texs)
-                          {
-                            maptex tex = self->tex [face];
-                            int a0 = 255 - tex.a;
-                            int a1 = tex.a;
-
-                            r = (r * a0 + tex.r * a1) / 255;
-                            g = (g * a0 + tex.g * a1) / 255;
-                            b = (b * a0 + tex.b * a1) / 255;
-                            a = (a * a0 + tex.a * a1) / 255;
-                          }
+                        maptex tex = self->tex [cell->tile [z]];
+                        int a0 = 255 - tex.a;
+                        int a1 = tex.a;
+
+                        r = (r * a0 + tex.r * a1) / 255;
+                        g = (g * a0 + tex.g * a1) / 255;
+                        b = (b * a0 + tex.b * a1) / 255;
+                        a = (a * a0 + tex.a * a1) / 255;
                       }
                   }
 
@@ -1515,84 +1779,253 @@
         RETVAL
 
 void
-draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
+draw (DC::Map self, int mx, int my, int sw, int sh, int T)
 	CODE:
 {
         int x, y, z;
-        int last_name;
-        mapface face;
 
-        glColor4ub (255, 255, 255, 255);
+  	HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
+        uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
+        static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k)
+        smooth_key skey;
+
+        rc_t *rc = rc_alloc ();
+        rc_key_t key;
+        rc_array_t *arr;
+
+        // thats current max. sorry.
+        if (sw > 255) sw = 255;
+        if (sh > 255) sh = 255;
+
+        // clear key, in case of extra padding
+        memset (&skey, 0, sizeof (skey));
+
+        memset (&key, 0, sizeof (key));
+        key.r       = 255;
+        key.g       = 255;
+        key.b       = 255;
+        key.a       = 255;
+        key.mode    = GL_QUADS;
+        key.format  = GL_T2F_V3F;
+        key.texname = -1;
+
+        mx += self->x;
+        my += self->y;
+
+        // first pass: determine smooth_max
+        // rather ugly, if you ask me
+        // could also be stored inside mapcell and updated on change
+        memset (smooth_max, 0, sizeof (smooth_max));
+
+        for (y = 0; y < sh; y++)
+          if (0 <= y + my && y + my < self->rows)
+            {
+              maprow *row = self->row + (y + my);
+
+              for (x = 0; x < sw; x++)
+                if (row->c0 <= x + mx && x + mx < row->c1)
+                  {
+                    mapcell *cell = row->col + (x + mx - row->c0);
+
+                    smooth_max[x + 1][y + 1] =
+                      MAX (self->tex [cell->tile [0]].smoothlevel,
+                        MAX (self->tex [cell->tile [1]].smoothlevel,
+                          self->tex [cell->tile [2]].smoothlevel));
+                  }
+            }
 
         glEnable (GL_BLEND);
         glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-        glEnable (GL_TEXTURE_2D);
         glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 
-        glBegin (GL_QUADS);
+        for (z = 0; z <= 2; z++)
+          {
+            memset (smooth_level, 0, sizeof (smooth_level));
 
-        last_name = 0;
+            for (y = 0; y < sh; y++)
+              if (0 <= y + my && y + my < self->rows)
+                {
+                  maprow *row = self->row + (y + my);
 
-        mx += self->x;
-        my += self->y;
+                  for (x = 0; x < sw; x++)
+                    if (row->c0 <= x + mx && x + mx < row->c1)
+                      {
+                        mapcell *cell = row->col + (x + mx - row->c0);
+                        tileid tile = cell->tile [z];
+                        
+                        if (tile)
+                          {
+                            maptex tex = self->tex [tile];
+                            int px, py;
 
-        for (z = 0; z < 3; z++)
-          for (y = 0; y < sh; y++)
-            if (0 <= y + my && y + my < self->rows)
-              {
-                maprow *row = self->row + (y + my);
+                            if (key.texname != tex.name)
+                              {
+                                if (!tex.name)
+                                  tex = self->tex [2]; /* missing, replace by noface */
 
-                for (x = 0; x < sw; x++)
-                  if (row->c0 <= x + mx && x + mx < row->c1)
-                    {
-                      mapcell *cell = row->col + (x + mx - row->c0);
+                                key.texname = tex.name;
+                                arr = rc_array (rc, &key);
+                              }
 
-                      face = cell->face [z];
+                            px = (x + 1) * T - tex.w;
+                            py = (y + 1) * T - tex.h;
 
-                      if (face > 0 && face < self->texs)
-                        {
-                          maptex tex = self->tex [face];
-                          int px = (x + 1) * T - tex.w;
-                          int py = (y + 1) * T - tex.h;
+                            rc_t2f_v3f (arr, 0    , 0    , px        , py        , 0);
+                            rc_t2f_v3f (arr, 0    , tex.t, px        , py + tex.h, 0);
+                            rc_t2f_v3f (arr, tex.s, tex.t, px + tex.w, py + tex.h, 0);
+                            rc_t2f_v3f (arr, tex.s, 0    , px + tex.w, py        , 0);
 
-                          if (last_name != tex.name)
-                            {
-                              glEnd ();
-                              glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
-                              glBegin (GL_QUADS);
-                            }
+                            if (cell->flags && z == 2)
+                              {
+                                // overlays such as the speech bubble, probably more to come
+                                if (cell->flags & 1)
+                                  {
+                                    maptex tex = self->tex [1];
+                                    int px = x * T + T * 2 / 32;
+                                    int py = y * T - T * 6 / 32;
+
+                                    if (tex.name)
+                                      {
+                                        if (key.texname != tex.name)
+                                          {
+                                            key.texname = tex.name;
+                                            arr = rc_array (rc, &key);
+                                          }
+
+                                        rc_t2f_v3f (arr, 0    , 0    , px    , py    , 0);
+                                        rc_t2f_v3f (arr, 0    , tex.t, px    , py + T, 0);
+                                        rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0);
+                                        rc_t2f_v3f (arr, tex.s, 0    , px + T, py    , 0);
+                                      }
+                                  }
+                              }
 
-                          glTexCoord2f (0    , 0    ); glVertex2f (px        , py        );
-                          glTexCoord2f (0    , tex.t); glVertex2f (px        , py + tex.h);
-                          glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
-                          glTexCoord2f (tex.s, 0    ); glVertex2f (px + tex.w, py        );
-                        }
+                            // update smooth hash
+                            if (tex.smoothtile)
+                              {
+                                skey.tile  = tex.smoothtile;
+                                skey.level = tex.smoothlevel;
+
+                                smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
+
+                                // add bits to current tile and all neighbours. skey.x|y is
+                                // shifted +1|+1 so we always stay positive.
+
+                                // bits is ___n cccc CCCC bbbb
+                                // n  do not draw borders&corners
+                                // c  draw these corners, but...
+                                // C  ... not these
+                                // b  draw these borders
+
+                                // borders: 1 ┃·  2 ━━  4 ·┃  8 ··
+                                //            ┃·    ··    ·┃    ━━
+                                
+                                // corners: 1 ┛·  2 ·┗  4 ··  8 ··
+                                //            ··    ··    ·┏    ┓·
+
+                                // full tile
+                                skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
+
+                                // borders
+                                skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
+                                skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
+                                skey.x = x    ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
+                                skey.x = x + 1; skey.y = y    ; smooth_or_bits (smooth, &skey, 0x00c8);
+
+                                // corners
+                                skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
+                                skey.x = x    ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
+                                skey.x = x    ; skey.y = y    ; smooth_or_bits (smooth, &skey, 0x0400);
+                                skey.x = x + 2; skey.y = y    ; smooth_or_bits (smooth, &skey, 0x0800);
+                              }
+                          }
+                      }
+              }
+
+            rc_draw (rc);
+            rc_clear (rc);
+
+            // go through all smoothlevels, lowest to highest, then draw.
+            // this is basically counting sort
+            {
+              int w, b;
 
-                      if (cell->flags && z == 2)
+              glEnable (GL_TEXTURE_2D);
+              glBegin (GL_QUADS);
+              for (w = 0; w < 256 / 32; ++w)
+                {
+                  uint32_t smask = smooth_level [w];
+                  if (smask)
+                    for (b = 0; b < 32; ++b)
+                      if (smask & (((uint32_t)1) << b))
                         {
-                          if (cell->flags & 1)
+                          int level = (w << 5) | b;
+                          HE *he;
+
+                          hv_iterinit (smooth);
+                          while ((he = hv_iternext (smooth)))
                             {
-                              maptex tex = self->tex [1];
-                              int px = (x + 1) * T - tex.w + 2;
-                              int py = (y + 1) * T - tex.h - 6;
-
-                              glEnd ();
-                              glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
-                              glBegin (GL_QUADS);
-
-                              glTexCoord2f (0    , 0    ); glVertex2f (px        , py        );
-                              glTexCoord2f (0    , tex.t); glVertex2f (px        , py + tex.h);
-                              glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
-                              glTexCoord2f (tex.s, 0    ); glVertex2f (px + tex.w, py        );
+                              smooth_key *skey = (smooth_key *)HeKEY (he);
+                              IV bits = SvIVX (HeVAL (he));
+
+                              if (!(bits & 0x1000)
+                                  && skey->level == level
+                                  && level > smooth_max [skey->x][skey->y])
+                                {
+                                  maptex tex = self->tex [skey->tile];
+                                  int px = (((int)skey->x) - 1) * T;
+                                  int py = (((int)skey->y) - 1) * T;
+                                  int border = bits & 15;
+                                  int corner = (bits >> 8) & ~(bits >> 4) & 15;
+                                  float dx = tex.s * .0625f; // 16 images/row
+                                  float dy = tex.t * .5f   ; // 2 images/column
+
+                                  if (tex.name)
+                                    {
+                                      // this time avoiding texture state changes
+                                      // save gobs of state changes.
+                                      if (key.texname != tex.name)
+                                        {
+                                          glEnd ();
+                                          glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
+                                          glBegin (GL_QUADS);
+                                        }
+
+                                      if (border)
+                                        {
+                                          float ox = border * dx;
+
+                                          glTexCoord2f (ox     , 0.f     ); glVertex2i (px    , py    );
+                                          glTexCoord2f (ox     , dy      ); glVertex2i (px    , py + T);
+                                          glTexCoord2f (ox + dx, dy      ); glVertex2i (px + T, py + T);
+                                          glTexCoord2f (ox + dx, 0.f     ); glVertex2i (px + T, py    );
+                                        }
+
+                                      if (corner)
+                                        {
+                                          float ox = corner * dx;
+
+                                          glTexCoord2f (ox     , dy      ); glVertex2i (px    , py    );
+                                          glTexCoord2f (ox     , dy * 2.f); glVertex2i (px    , py + T);
+                                          glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T);
+                                          glTexCoord2f (ox + dx, dy      ); glVertex2i (px + T, py    );
+                                        }
+                                    }
+                                }
                             }
                         }
-                    }
-              }
+                }
 
-	glEnd ();
+              glEnd ();
+              glDisable (GL_TEXTURE_2D);
+              key.texname = -1;
+            }
+
+            hv_clear (smooth);
+          }
 
-        glDisable (GL_TEXTURE_2D);
         glDisable (GL_BLEND);
+        rc_free (rc);
 
         // top layer: overlays such as the health bar
         for (y = 0; y < sh; y++)
@@ -1611,7 +2044,7 @@
                     if (cell->stat_hp)
                       {
                         int width = cell->stat_width * T;
-                        int thick = (sh * T / 32) / 28 + 1 + cell->stat_width;
+                        int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
 
                         glColor3ub (0,  0,  0);
                         glRectf (px + 1, py - thick - 2,
@@ -1627,7 +2060,7 @@
 }
 
 void
-draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
+draw_magicmap (DC::Map self, int dx, int dy, int w, int h, unsigned char *data)
 	CODE:
 {
 	static float color[16][3] = {
@@ -1687,45 +2120,88 @@
 }
 
 void
-fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)
+fow_texture (DC::Map self, int mx, int my, int sw, int sh)
 	PPCODE:
 {
         int x, y;
-        int sw4 = (sw + 3) & ~3;
-	SV *darkness_sv = sv_2mortal (newSV (sw4 * sh));
-        uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv);
-
-        memset (darkness, 255, sw4 * sh);
-        SvPOK_only (darkness_sv);
-        SvCUR_set (darkness_sv, sw4 * sh);
+        int sw1  = sw + 2;
+        int sh1  = sh + 2;
+        int sh3  = sh * 3;
+        int sw34 = (sw * 3 + 3) & ~3;
+        uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
+        SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
+        uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
+
+        SvPOK_only (darkness3_sv);
+        SvCUR_set (darkness3_sv, sw34 * sh3);
 
-        mx += self->x;
-        my += self->y;
+        mx += self->x - 1;
+        my += self->y - 1;
 
-        for (y = 0; y < sh; y++)
+        memset (darkness1, 255, sw1 * sh1);
+
+        for (y = 0; y < sh1; y++)
           if (0 <= y + my && y + my < self->rows)
             {
               maprow *row = self->row + (y + my);
 
-              for (x = 0; x < sw; x++)
+              for (x = 0; x < sw1; x++)
                 if (row->c0 <= x + mx && x + mx < row->c1)
                   {
                     mapcell *cell = row->col + (x + mx - row->c0);
 
-                    darkness[y * sw4 + x] = cell->darkness
+                    darkness1 [y * sw1 + x] = cell->darkness
                       ? 255 - (cell->darkness - 1)
                       : 255 - FOW_DARKNESS;
                   }
             }
 
+        for (y = 0; y < sh; ++y)
+          for (x = 0; x < sw; ++x)
+            {
+              uint8_t d11 = darkness1 [(y    ) * sw1 + x    ];
+              uint8_t d21 = darkness1 [(y    ) * sw1 + x + 1];
+              uint8_t d31 = darkness1 [(y    ) * sw1 + x + 2];
+              uint8_t d12 = darkness1 [(y + 1) * sw1 + x    ];
+              uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
+              uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
+              uint8_t d13 = darkness1 [(y + 2) * sw1 + x    ];
+              uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
+              uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
+
+              uint8_t r11 = (d11 + d21 + d12) / 3;
+              uint8_t r21 = d21;
+              uint8_t r31 = (d21 + d31 + d32) / 3;
+
+              uint8_t r12 = d12;
+              uint8_t r22 = d22;
+              uint8_t r32 = d32;
+
+              uint8_t r13 = (d13 + d23 + d12) / 3;
+              uint8_t r23 = d23;
+              uint8_t r33 = (d23 + d33 + d32) / 3;
+
+              darkness3 [(y * 3    ) * sw34 + (x * 3    )] = MAX (d22, r11);
+              darkness3 [(y * 3    ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);
+              darkness3 [(y * 3    ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);
+              darkness3 [(y * 3 + 1) * sw34 + (x * 3    )] = MAX (d22, r12);
+              darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);
+              darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);
+              darkness3 [(y * 3 + 2) * sw34 + (x * 3    )] = MAX (d22, r13);
+              darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);
+              darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);
+            }
+
+        free (darkness1);
+
         EXTEND (SP, 3);
-        PUSHs (sv_2mortal (newSViv (sw4)));
-        PUSHs (sv_2mortal (newSViv (sh)));
-        PUSHs (darkness_sv);
+        PUSHs (sv_2mortal (newSViv (sw34)));
+        PUSHs (sv_2mortal (newSViv (sh3)));
+        PUSHs (darkness3_sv);
 }
 
 SV *
-get_rect (CFPlus::Map self, int x0, int y0, int w, int h)
+get_rect (DC::Map self, int x0, int y0, int w, int h)
 	CODE:
 {
 	int x, y, x1, y1;
@@ -1760,28 +2236,31 @@
                     mapcell *cell = row->col + (x - row->c0);
                     uint8_t flags = 0;
 
-                    if (cell->face [0]) flags |= 1;
-                    if (cell->face [1]) flags |= 2;
-                    if (cell->face [2]) flags |= 4;
+                    if (cell->tile [0]) flags |= 1;
+                    if (cell->tile [1]) flags |= 2;
+                    if (cell->tile [2]) flags |= 4;
 
                     *data++ = flags;
 
                     if (flags & 1)
                       {
-                        *data++ = cell->face [0] >> 8;
-                        *data++ = cell->face [0];
+                        tileid tile = cell->tile [0];
+                        *data++ = tile >> 8;
+                        *data++ = tile;
                       }
 
                     if (flags & 2)
                       {
-                        *data++ = cell->face [1] >> 8;
-                        *data++ = cell->face [1];
+                        tileid tile = cell->tile [1];
+                        *data++ = tile >> 8;
+                        *data++ = tile;
                       }
 
                     if (flags & 4)
                       {
-                        *data++ = cell->face [2] >> 8;
-                        *data++ = cell->face [2];
+                        tileid tile = cell->tile [2];
+                        *data++ = tile >> 8;
+                        *data++ = tile;
                       }
                   }
                 else
@@ -1797,7 +2276,7 @@
         RETVAL
 
 void
-set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
+set_rect (DC::Map self, int x0, int y0, uint8_t *data)
 	PPCODE:
 {
 	int x, y, z;
@@ -1805,7 +2284,7 @@
         int x1, y1;
 
         if (*data++ != 0)
-          return; /* version mismatch */
+          XSRETURN_EMPTY; /* version mismatch */
 
         w = *data++ << 8; w |= *data++;
         h = *data++ << 8; h |= *data++;
@@ -1831,13 +2310,12 @@
 
                 if (flags)
                   {
-                    mapface face[3] = { 0, 0, 0 };
-
                     mapcell *cell = row_get_cell (row, x);
+                    tileid tile[3] = { 0, 0, 0 };
 
-                    if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; }
-                    if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; }
-                    if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; }
+                    if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
+                    if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
+                    if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
 
                     if (cell->darkness == 0)
                       {
@@ -1845,10 +2323,15 @@
 
                         for (z = 0; z <= 2; z++)
                           {
-                            cell->face[z] = face[z];
+                            tileid t = tile [z];
+
+                            if (t >= self->texs || (t && !self->tex [t].name))
+                              {
+                                XPUSHs (sv_2mortal (newSViv (t)));
+                                need_texid (self, t);
+                              }
 
-                            if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name))
-                              XPUSHs (sv_2mortal (newSViv (face[z])));
+                            cell->tile [z] = t;
                           }
                       }
                   }
@@ -1856,72 +2339,221 @@
           }
 }
 
-MODULE = CFPlus	PACKAGE = CFPlus::MixChunk
+MODULE = Deliantra::Client	PACKAGE = DC::RW
+
+DC::RW
+new (SV *class, SV *data_sv)
+	CODE:
+{
+        STRLEN datalen;
+        char *data = SvPVbyte (data_sv, datalen);
+
+        RETVAL = SDL_RWFromConstMem (data, datalen);
+}
+	OUTPUT:
+        RETVAL
 
-CFPlus::MixChunk
-new_from_file (SV *class, char *path)
+DC::RW
+new_from_file (SV *class, const char *path, const char *mode = "rb")
 	CODE:
-        RETVAL = Mix_LoadWAV (path);
+        RETVAL = SDL_RWFromFile (path, mode);
+	OUTPUT:
+        RETVAL
+
+# fails on win32:
+# dc.xs(2268) : error C2059: syntax error : '('
+#void
+#close (DC::RW self)
+#	CODE:
+#        (self->(close)) (self);
+
+MODULE = Deliantra::Client	PACKAGE = DC::Channel
+
+PROTOTYPES: DISABLE
+
+DC::Channel
+find ()
+	CODE:
+{
+        RETVAL = Mix_GroupAvailable (-1);
+
+        if (RETVAL < 0)
+          {
+            RETVAL = Mix_GroupOldest (-1);
+
+            if (RETVAL < 0)
+              XSRETURN_UNDEF;
+
+            Mix_HaltChannel (RETVAL);
+          }
+
+        Mix_UnregisterAllEffects (RETVAL);
+        Mix_Volume (RETVAL, 128);
+}
+	OUTPUT:
+        RETVAL
+
+void
+halt (DC::Channel self)
+	CODE:
+        Mix_HaltChannel (self);
+
+void
+expire (DC::Channel self, int ticks = -1)
+	CODE:
+        Mix_ExpireChannel (self, ticks);
+
+void
+fade_out (DC::Channel self, int ticks = -1)
+	CODE:
+        Mix_FadeOutChannel (self, ticks);
+
+int
+volume (DC::Channel self, int volume)
+	CODE:
+        RETVAL = Mix_Volume (self, CLAMP (volume, 0, 128));
+	OUTPUT:
+        RETVAL
+
+void
+unregister_all_effects (DC::Channel self)
+	CODE:
+        Mix_UnregisterAllEffects (self);
+
+void
+set_panning (DC::Channel self, int left, int right)
+	CODE:
+        left  = CLAMP (left , 0, 255);
+        right = CLAMP (right, 0, 255);
+        Mix_SetPanning (self, left, right);
+
+void
+set_distance (DC::Channel self, int distance)
+	CODE:
+        Mix_SetDistance (self, CLAMP (distance, 0, 255));
+
+void
+set_position (DC::Channel self, int angle, int distance)
+	CODE:
+
+void
+set_position_r (DC::Channel self, int dx, int dy, int maxdistance)
+	CODE:
+{
+	int distance = sqrtf (dx * dx + dy * dy) * (255.f / sqrtf (maxdistance * maxdistance));
+        int angle = 360 + (int)roundf (atan2f (dx, -dy) * 180.f / (float)M_PI);
+        Mix_SetPosition (self, angle, CLAMP (distance, 0, 255));
+}
+
+void
+set_reverse_stereo (DC::Channel self, int flip)
+	CODE:
+        Mix_SetReverseStereo (self, flip);
+
+MODULE = Deliantra::Client	PACKAGE = DC::MixChunk
+
+PROTOTYPES: DISABLE
+
+DC::MixChunk
+new (SV *class, DC::RW rwops)
+	CODE:
+        RETVAL = Mix_LoadWAV_RW (rwops, 1);
 	OUTPUT:
         RETVAL
 
 void
-DESTROY (CFPlus::MixChunk self)
+DESTROY (DC::MixChunk self)
 	CODE:
         Mix_FreeChunk (self);
 
 int
-volume (CFPlus::MixChunk self, int volume = -1)
+volume (DC::MixChunk self, int volume = -1)
 	CODE:
+        if (items > 1)
+          volume = CLAMP (volume, 0, 128);
         RETVAL = Mix_VolumeChunk (self, volume);
 	OUTPUT:
         RETVAL
 
-int
-play (CFPlus::MixChunk self, int channel = -1, int loops = 0, int ticks = -1)
+DC::Channel
+play (DC::MixChunk self, DC::Channel channel = -1, int loops = 0, int ticks = -1)
 	CODE:
+{
         RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
+
+        if (RETVAL < 0)
+          XSRETURN_UNDEF;
+
+        if (channel < 0)
+          {
+            Mix_UnregisterAllEffects (RETVAL);
+            Mix_Volume (RETVAL, 128);
+          }
+}
 	OUTPUT:
         RETVAL
 
-MODULE = CFPlus	PACKAGE = CFPlus::MixMusic
+MODULE = Deliantra::Client	PACKAGE = DC::MixMusic
 
 int
 volume (int volume = -1)
+	PROTOTYPE: ;$
 	CODE:
+        if (items > 0)
+          volume = CLAMP (volume, 0, 128);
         RETVAL = Mix_VolumeMusic (volume);
 	OUTPUT:
         RETVAL
 
-CFPlus::MixMusic
-new_from_file (SV *class, char *path)
+void
+fade_out (int ms)
 	CODE:
-        RETVAL = Mix_LoadMUS (path);
+        Mix_FadeOutMusic (ms);
+
+void
+halt ()
+	CODE:
+        Mix_HaltMusic ();
+
+DC::MixMusic
+new (SV *class, DC::RW rwops)
+	CODE:
+        RETVAL = Mix_LoadMUS_RW (rwops);
 	OUTPUT:
         RETVAL
 
 void
-DESTROY (CFPlus::MixMusic self)
+DESTROY (DC::MixMusic self)
 	CODE:
         Mix_FreeMusic (self);
 
 int
-play (CFPlus::MixMusic self, int loops = -1)
+play (DC::MixMusic self, int loops = -1)
 	CODE:
         RETVAL = Mix_PlayMusic (self, loops);
 	OUTPUT:
         RETVAL
 
-MODULE = CFPlus	PACKAGE = CFPlus::OpenGL
+void
+fade_in_pos (DC::MixMusic self, int loops, int ms, double position)
+	CODE:
+        Mix_FadeInMusicPos (self, loops, ms, position);
+
+MODULE = Deliantra::Client	PACKAGE = DC::OpenGL
+
+PROTOTYPES: ENABLE
 
 BOOT:
 {
-  HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);
+  HV *stash = gv_stashpv ("DC::OpenGL", 1);
   static const struct {
     const char *name;
     IV iv;
   } *civ, const_iv[] = {
 #	define const_iv(name) { # name, (IV)name }
+        const_iv (GL_VENDOR),
+        const_iv (GL_VERSION),
+        const_iv (GL_EXTENSIONS),
 	const_iv (GL_COLOR_MATERIAL),
 	const_iv (GL_SMOOTH),
 	const_iv (GL_FLAT),
@@ -1935,6 +2567,7 @@
 	const_iv (GL_RESCALE_NORMAL),
 	const_iv (GL_FRONT),
 	const_iv (GL_BACK),
+	const_iv (GL_AUX0),
         const_iv (GL_AND),
 	const_iv (GL_ONE),
 	const_iv (GL_ZERO),
@@ -1957,7 +2590,15 @@
 	const_iv (GL_LUMINANCE_ALPHA),
 	const_iv (GL_FLOAT),
 	const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
+        const_iv (GL_COMPRESSED_ALPHA_ARB),
+        const_iv (GL_COMPRESSED_LUMINANCE_ARB),
+        const_iv (GL_COMPRESSED_LUMINANCE_ALPHA_ARB),
+        const_iv (GL_COMPRESSED_INTENSITY_ARB),
+        const_iv (GL_COMPRESSED_RGB_ARB),
+        const_iv (GL_COMPRESSED_RGBA_ARB),
 	const_iv (GL_COMPILE),
+	const_iv (GL_PROXY_TEXTURE_1D),
+	const_iv (GL_PROXY_TEXTURE_2D),
 	const_iv (GL_TEXTURE_1D),
 	const_iv (GL_TEXTURE_2D),
 	const_iv (GL_TEXTURE_ENV),
@@ -1988,6 +2629,7 @@
 	const_iv (GL_CONVOLUTION_2D),
 	const_iv (GL_CONVOLUTION_BORDER_MODE),
 	const_iv (GL_CONSTANT_BORDER),
+	const_iv (GL_POINTS),
 	const_iv (GL_LINES),
 	const_iv (GL_LINE_STRIP),
 	const_iv (GL_LINE_LOOP),
@@ -1996,8 +2638,16 @@
 	const_iv (GL_TRIANGLES),
 	const_iv (GL_TRIANGLE_STRIP),
 	const_iv (GL_TRIANGLE_FAN),
+	const_iv (GL_POLYGON),
 	const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
+        const_iv (GL_POINT_SMOOTH_HINT),
+        const_iv (GL_LINE_SMOOTH_HINT),
+        const_iv (GL_POLYGON_SMOOTH_HINT),
+        const_iv (GL_GENERATE_MIPMAP_HINT),
+        const_iv (GL_TEXTURE_COMPRESSION_HINT),
         const_iv (GL_FASTEST),
+        const_iv (GL_DONT_CARE),
+        const_iv (GL_NICEST),
         const_iv (GL_V2F),
         const_iv (GL_V3F),
         const_iv (GL_T2F_V3F),
@@ -2007,8 +2657,17 @@
     
   for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
+
+  texture_av = newAV ();
+  AvREAL_off (texture_av);
 }
 
+void
+disable_GL_EXT_blend_func_separate ()
+	CODE:
+        gl.BlendFuncSeparate    = 0;
+        gl.BlendFuncSeparateEXT = 0;
+
 char *
 gl_vendor ()
 	CODE:
@@ -2030,6 +2689,20 @@
 	OUTPUT:
         RETVAL
 
+const char *glGetString (GLenum pname)
+
+GLint glGetInteger (GLenum pname)
+	CODE:
+        glGetIntegerv (pname, &RETVAL);
+	OUTPUT:
+        RETVAL
+
+GLdouble glGetDouble (GLenum pname)
+	CODE:
+        glGetDoublev (pname, &RETVAL);
+	OUTPUT:
+        RETVAL
+
 int glGetError ()
 
 void glFinish ()
@@ -2077,6 +2750,8 @@
 # near_ and far_ are due to microsofts buggy "c" compiler
 void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
 
+PROTOTYPES: DISABLE
+
 void glViewport (int x, int y, int width, int height)
 
 void glScissor (int x, int y, int width, int height)
@@ -2093,12 +2768,7 @@
         CODE:
         glRotatef (angle, x, y, z);
 
-void glBegin (int mode)
-
-void glEnd ()
-
 void glColor (float r, float g, float b, float a = 1.0)
-	PROTOTYPE: @
         ALIAS:
            glColor_premultiply = 1
         CODE:
@@ -2111,12 +2781,6 @@
         // microsoft visual "c" rounds instead of truncating...
         glColor4f (r, g, b, a);
 
-void glInterleavedArrays (int format, int stride, char *data)
-
-void glDrawElements (int mode, int count, int type, char *indices)
-
-# 1.2 void glDrawRangeElements (int mode, int start, int end
-
 void glRasterPos (float x, float y, float z = 0.)
         CODE:
         glRasterPos3f (0, 0, z);
@@ -2130,6 +2794,35 @@
         CODE:
         glTexCoord2f (s, t);
 
+void glRect (float x1, float y1, float x2, float y2)
+	CODE:
+        glRectf (x1, y1, x2, y2);
+
+void glRect_lineloop (float x1, float y1, float x2, float y2)
+	CODE:
+	glBegin (GL_LINE_LOOP);
+	glVertex2f (x1, y1);
+	glVertex2f (x2, y1);
+	glVertex2f (x2, y2);
+	glVertex2f (x1, y2);
+	glEnd ();
+
+PROTOTYPES: ENABLE
+
+void glBegin (int mode)
+
+void glEnd ()
+
+void glPointSize (GLfloat size)
+
+void glLineWidth (GLfloat width)
+
+void glInterleavedArrays (int format, int stride, char *data)
+
+void glDrawElements (int mode, int count, int type, char *indices)
+
+# 1.2 void glDrawRangeElements (int mode, int start, int end
+
 void glTexEnv (int target, int pname, float param)
         CODE:
         glTexEnvf (target, pname, param);
@@ -2161,25 +2854,20 @@
 
 void glDrawPixels (int width, int height, int format, int type, char *pixels)
 
+void glPixelZoom (float x, float y)
+
 void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
 
 int glGenTexture ()
         CODE:
-{
-        GLuint name;
-        glGenTextures (1, &name);
-        RETVAL = name;
-}
+        RETVAL = gen_texture ();
 	OUTPUT:
         RETVAL
 
 void glDeleteTexture (int name)
 	CODE:
-{
-        GLuint name_ = name;
-        glDeleteTextures (1, &name_);
-}
-        
+        del_texture (name);
+
 int glGenList ()
 	CODE:
         RETVAL = glGenLists (1);
@@ -2196,3 +2884,111 @@
 
 void glCallList (int list)
 
+MODULE = Deliantra::Client	PACKAGE = DC::UI::Base
+
+PROTOTYPES: DISABLE
+
+void
+find_widget (SV *self, NV x, NV y)
+	PPCODE:
+{
+  	if (within_widget (self, x, y))
+          XPUSHs (self);
+}
+
+BOOT:
+{
+  hover_gv = gv_fetchpv ("DC::UI::HOVER", 1, SVt_NV);
+
+  draw_x_gv = gv_fetchpv ("DC::UI::Base::draw_x", 1, SVt_NV);
+  draw_y_gv = gv_fetchpv ("DC::UI::Base::draw_y", 1, SVt_NV);
+  draw_w_gv = gv_fetchpv ("DC::UI::Base::draw_w", 1, SVt_NV);
+  draw_h_gv = gv_fetchpv ("DC::UI::Base::draw_h", 1, SVt_NV);
+}
+
+void
+draw (SV *self)
+	CODE:
+{
+  	HV *hv;
+  	SV **svp;
+	NV x, y, w, h;
+        SV *draw_x_sv = GvSV (draw_x_gv);
+        SV *draw_y_sv = GvSV (draw_y_gv);
+        SV *draw_w_sv = GvSV (draw_w_gv);
+        SV *draw_h_sv = GvSV (draw_h_gv);
+        double draw_x, draw_y;
+
+        if (!SvROK (self))
+          croak ("DC::Base::draw: %s not a reference", SvPV_nolen (self));
+
+        hv = (HV *)SvRV (self);
+
+        if (SvTYPE (hv) != SVt_PVHV)
+          croak ("DC::Base::draw: %s not a hashref", SvPV_nolen (self));
+
+        svp = hv_fetch (hv, "w", 1, 0); w = svp ? SvNV (*svp) : 0.;
+        svp = hv_fetch (hv, "h", 1, 0); h = svp ? SvNV (*svp) : 0.;
+
+        if (!h || !w)
+          XSRETURN_EMPTY;
+
+        svp = hv_fetch (hv, "x", 1, 0); x = svp ? SvNV (*svp) : 0.;
+        svp = hv_fetch (hv, "y", 1, 0); y = svp ? SvNV (*svp) : 0.;
+
+        draw_x = SvNV (draw_x_sv) + x;
+        draw_y = SvNV (draw_y_sv) + y;
+
+        if (draw_x + w < 0 || draw_x >= SvNV (draw_w_sv)
+         || draw_y + h < 0 || draw_y >= SvNV (draw_h_sv))
+          XSRETURN_EMPTY;
+
+        sv_setnv (draw_x_sv, draw_x);
+        sv_setnv (draw_y_sv, draw_y);
+
+        glPushMatrix ();
+        glTranslated (x, y, 0);
+
+        if (SvROK (GvSV (hover_gv)) && SvRV (GvSV (hover_gv)) == (SV *)hv)
+          {
+            svp = hv_fetch (hv, "can_hover", sizeof ("can_hover") - 1, 0);
+
+            if (svp && SvTRUE (*svp))
+              {
+                glColor4f (1.0f * 0.2f, 0.8f * 0.2f, 0.5f * 0.2f, 0.2f);
+                glEnable (GL_BLEND);
+                glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+                glBegin (GL_QUADS);
+                glVertex2f (0, 0);
+                glVertex2f (w, 0);
+                glVertex2f (w, h);
+                glVertex2f (0, h);
+                glEnd ();
+                glDisable (GL_BLEND);
+              }
+          }
+#if 0
+        // draw borders, for debugging
+        glPushMatrix ();
+        glColor4f (1., 1., 0., 1.);
+        glTranslatef (.5, .5, 0.);
+        glBegin (GL_LINE_LOOP);
+        glVertex2f (0    , 0);
+        glVertex2f (w - 1, 0);
+        glVertex2f (w - 1, h - 1);
+        glVertex2f (0    , h - 1);
+        glEnd ();
+        glPopMatrix ();
+#endif
+	PUSHMARK (SP);
+        XPUSHs (self);
+        PUTBACK;
+        call_method ("_draw", G_VOID | G_DISCARD);
+        SPAGAIN;
+
+        glPopMatrix ();
+
+        draw_x = draw_x - x; sv_setnv (draw_x_sv, draw_x);
+        draw_y = draw_y - y; sv_setnv (draw_y_sv, draw_y);
+}
+