Initial commit

1 files changed, 2228 insertions, 0 deletions

diff --git a/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d.cpp b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d.cpp
new file mode 100644
index 00000000..50dabfc3
--- /dev/null
+++ b/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d.cpp
@@ -0,0 +1,2228 @@
+// gdraw_d3d.cpp - author: Sean Barrett - copyright 2009-2011 RAD Game Tools
+//
+// This implements the Iggy graphics driver layer for Direct3D 9.
+
+// GDraw consists of several components that interact fairly loosely with each other;
+// e.g. the resource management, drawing and filtering parts are all fairly independent
+// of each other. If you want to modify some aspect of GDraw - say the texture allocation
+// logic - your best bet is usually to just look for one of the related entry points,
+// e.g. MakeTextureBegin, and take it from there. There's a bunch of code in this file,
+// but none of it is really complicated.
+//
+// The one bit you might want to change that's not that localized is to integrate
+// GDraw with an existing state caching system. The following bits all modify D3D state
+// in some way:
+// - The rendering helpers (set_viewport_raw, set_projection_raw, set_*_renderstate)
+// - RenderTile*/TextureDrawBuffer* may change the active rendertarget and depth/stencil surface,
+//   as do D3D_NoMoreGDrawThisFrame and set_render_target
+// - set_texture
+// - set_renderstate and set_renderstate_full. These are the main places where render state changes occur;
+//   you should probably start here.
+// - DrawIndexedTriangles sets the active vertex/index buffers and vertex declaration
+// - Most of the functions in the "filter effects" section modify D3D state, mostly
+//   pixel shader constants and textures
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <d3d9.h>
+#include <string.h>
+#include <math.h>
+
+// We temporarily disable this warning for the shared interface portions
+#pragma warning (push)
+#pragma warning (disable: 4201) // nonstandard extension used : nameless struct/union
+
+#include "gdraw.h"
+#include "iggy.h"
+#include "gdraw_d3d.h"
+
+// The native handle type holds resource handles and a coarse description.
+typedef union {
+   // handle that is a texture
+   struct {
+      IDirect3DTexture9 *d3d;
+      IDirect3DTexture9 *d3d_msaa;
+      U32 w, h;
+   } tex;
+
+   // handle that is a vertex buffer
+   struct {
+      IDirect3DVertexBuffer9 *base;
+      IDirect3DIndexBuffer9 *indices;
+   } vbuf;
+} GDrawNativeHandle;
+
+#define GDRAW_D3D // this controls the next include so the cache gets declared with the correct types, which makes it typesafe
+#include "gdraw_shared.inl"
+
+#pragma warning (pop)
+
+// max rendertarget stack depth. this depends on the extent to which you
+// use filters and non-standard blend modes, and how nested they are.
+#define MAX_RENDER_STACK_DEPTH             8         // Iggy is hardcoded to a limit of 16... probably 1-3 is realistic
+#define AATEX_SAMPLER                      7         // sampler that aa_tex gets set in
+#define QUAD_IB_COUNT                      2048      // quad index buffer has indices for this many quads
+
+#define ASSERT_COUNT(a,b)                  ((a) == (b) ? (b) : -1)
+
+static GDrawFunctions gdraw_funcs;
+
+// render target state
+typedef struct
+{
+   GDrawHandle *color_buffer;
+   S32 base_x, base_y, width, height;
+   U32 flags;
+   rrbool cached;
+} GDrawFramebufferState;
+
+struct ProgramWithCachedVariableLocations
+{
+   DWORD *bytecode;
+   union {
+      IDirect3DPixelShader9  *pshader;
+      IDirect3DVertexShader9 *vshader;
+   };
+   int vars[MAX_VARS]; // it's unsigned in d3d, but we want an 'undefined' value
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//     GDraw data structure
+//
+//
+// This is the primary rendering abstraction, which hides all
+// the platform-specific rendering behavior from Iggy. It is
+// full of platform-specific graphics state, and also general
+// graphics state so that it doesn't have to callback into Iggy
+// to get at that graphics state.
+
+typedef struct
+{
+   IDirect3DDevice9 *d3d_device;
+
+   // fragment shaders
+   ProgramWithCachedVariableLocations fprog[GDRAW_TEXTURE__count][3];
+   ProgramWithCachedVariableLocations exceptional_blend[GDRAW_BLENDSPECIAL__count];
+   ProgramWithCachedVariableLocations filter_prog[2][16];
+   ProgramWithCachedVariableLocations blur_prog[MAX_TAPS+1];
+   ProgramWithCachedVariableLocations colormatrix;
+   ProgramWithCachedVariableLocations manual_clear;
+
+   // vertex declarations
+   IDirect3DVertexDeclaration9 *vdec[GDRAW_vformat__count];
+
+   // vertex shaders
+   ProgramWithCachedVariableLocations vert[GDRAW_vformat__count]; // [format]
+
+   // render targets
+   GDrawHandleCache rendertargets;
+   GDrawHandle rendertarget_handles[MAX_RENDER_STACK_DEPTH]; // not -1, because we use +1 to initialize
+
+   gswf_recti rt_valid[MAX_RENDER_STACK_DEPTH+1]; // valid rect for texture clamping
+
+   // size of our render targets
+   S32 frametex_width, frametex_height;
+
+   // viewport setting (in pixels) for current frame
+   S32 vx,vy;
+   S32 fw,fh; // full width/height of virtual display
+   S32 tw,th; // actual width/height of current tile
+   S32 tpw,tph; // width/height of padded version of tile
+
+   S32 tx0,ty0;
+   S32 tx0p,ty0p;
+   rrbool in_blur;
+
+   F32 projection[4]; // scalex,scaley,transx,transy
+   rrbool use_3d;
+   F32 xform_3d[3][4];
+
+   IDirect3DSurface9 *main_framebuffer;
+   IDirect3DSurface9 *main_depthbuffer;
+   IDirect3DSurface9 *rt_depthbuffer; // non-multisampled rendertarget depth buffer. only used when MSAA is on!
+   rrbool main_msaa; // does main framebuffer have MSAA enabled?
+
+   IDirect3DTexture9 *aa_tex;
+
+   // scale factors converting worldspace to viewspace <0,0>..<w,h>
+   F32 world_to_pixel[2];
+
+   // cached state
+   U32 scissor_state;      // ~0 if unknown, otherwise 0 or 1
+   int blend_mode;         // -1 if unknown, otherwise GDRAW_BLEND_*
+   U32 stencil_key;        // field built from stencil test flags. 0=no stencil, ~0 is used for "unknown state"
+   U32 z_key;              // same for z-writes/z-test
+   rrbool last_was_3d;
+
+   // render-state stack described above for 'temporary' rendering
+   GDrawFramebufferState frame[MAX_RENDER_STACK_DEPTH];
+   GDrawFramebufferState *cur;
+
+   // texture and vertex buffer pools
+   GDrawHandleCache *texturecache;
+   GDrawHandleCache *vbufcache;
+
+   // mipmapping
+   GDrawMipmapContext mipmap;
+   rrbool conditional_nonpow2;
+
+   // stat tracking
+   rrbool frame_done;
+   U64 frame_counter;
+
+   // error reporting
+   void (__cdecl *error_handler)(HRESULT hr);
+} GDraw;
+
+static GDraw *gdraw;
+
+// not a real index buffer because we only get quads via user pointer
+static U16 quad_ib[QUAD_IB_COUNT*6];
+
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Error handling
+//
+
+static void report_d3d_error(HRESULT hr, char *call, char *context)
+{
+   if (hr == E_OUTOFMEMORY)
+      IggyGDrawSendWarning(NULL, "GDraw D3D out of memory in %s%s", call, context);
+   else
+      IggyGDrawSendWarning(NULL, "GDraw D3D error in %s%s: 0x%08x", call, context, hr);
+}
+
+
+////////////////////////////////////////////////////////////////////////
+//
+//   General resource management for both textures and vertex buffers
+//
+
+template<typename T>
+static void safe_release(T *&p)
+{
+   if (p) {
+      p->Release();
+      p = NULL;
+   }
+}
+
+static void unbind_resources(void)
+{
+   IDirect3DDevice9 *d3d = gdraw->d3d_device;
+   S32 i;
+
+   // unset active textures and vertex/index buffers,
+   // to make sure there are no dangling refs
+   for (i=0; i < 3; ++i)
+      d3d->SetTexture(i, NULL);
+
+   d3d->SetStreamSource(0, NULL, 0, 0);
+   d3d->SetIndices(NULL);
+}
+
+static void api_free_resource(GDrawHandle *r)
+{
+   unbind_resources();
+   if (r->state != GDRAW_HANDLE_STATE_user_owned) {
+      if (!r->cache->is_vertex) {
+         safe_release(r->handle.tex.d3d);
+      } else {
+         safe_release(r->handle.vbuf.base);
+         safe_release(r->handle.vbuf.indices);
+      }
+   }
+}
+
+static void RADLINK gdraw_UnlockHandles(GDrawStats * /*stats*/)
+{
+   gdraw_HandleCacheUnlockAll(gdraw->texturecache);
+   gdraw_HandleCacheUnlockAll(gdraw->vbufcache);
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Texture creation/updating/deletion
+//
+
+extern GDrawTexture *gdraw_D3D_WrappedTextureCreate(IDirect3DTexture9 *texhandle)
+{
+   GDrawStats stats={0};
+   GDrawHandle *p = gdraw_res_alloc_begin(gdraw->texturecache, 0, &stats); // it may need to free one item to give us a handle
+   p->handle.tex.d3d = texhandle;
+   p->handle.tex.w = 1;
+   p->handle.tex.h = 1;
+   gdraw_HandleCacheAllocateEnd(p, 0, NULL, GDRAW_HANDLE_STATE_user_owned);
+   return (GDrawTexture *) p;
+}
+
+extern void gdraw_D3D_WrappedTextureChange(GDrawTexture *tex, IDirect3DTexture9 *texhandle)
+{
+   GDrawHandle *p = (GDrawHandle *) tex;
+   p->handle.tex.d3d = texhandle;
+}
+
+extern void gdraw_D3D_WrappedTextureDestroy(GDrawTexture *tex)
+{
+   GDrawStats stats={0};
+   gdraw_res_free((GDrawHandle *) tex, &stats);
+}
+
+static void RADLINK gdraw_SetTextureUniqueID(GDrawTexture *tex, void *old_id, void *new_id)
+{
+   GDrawHandle *p = (GDrawHandle *) tex;
+   // if this is still the handle it's thought to be, change the owner;
+   // if the owner *doesn't* match, then they're changing a stale handle, so ignore
+   if (p->owner == old_id)
+      p->owner = new_id;
+}
+
+
+static rrbool RADLINK gdraw_MakeTextureBegin(void *owner, S32 width, S32 height, gdraw_texture_format format, U32 flags, GDraw_MakeTexture_ProcessingInfo *p, GDrawStats *stats)
+{
+   GDrawHandle *t = NULL;
+   D3DFORMAT d3dfmt;
+   S32 bpp;
+
+   if (format == GDRAW_TEXTURE_FORMAT_rgba32) {
+      d3dfmt = D3DFMT_A8R8G8B8;
+      bpp = 4;
+   } else {
+      d3dfmt = D3DFMT_A8;
+      bpp = 1;
+   }
+
+   // compute estimated size of texture in video memory
+   S32 size = width*height*bpp;
+   if (flags & GDRAW_MAKETEXTURE_FLAGS_mipmap)
+      size = size*4/3; // not correct for non-square
+
+   // allocate a handle and make room in the cache for this much data
+   t = gdraw_res_alloc_begin(gdraw->texturecache, size, stats);
+   if (!t) 
+      return NULL;
+
+   HRESULT hr = gdraw->d3d_device->CreateTexture(width, height, (flags & GDRAW_MAKETEXTURE_FLAGS_mipmap) ? 0 : 1,
+                                         0, d3dfmt, D3DPOOL_MANAGED, &t->handle.tex.d3d, NULL);
+
+   if (FAILED(hr)) {
+      gdraw_HandleCacheAllocateFail(t);
+      IggyGDrawSendWarning(NULL, "GDraw CreateTexture() call failed with error code 0x%08x", hr);
+      return false;
+   }
+
+   t->handle.tex.w = width;
+   t->handle.tex.h = height;
+
+   gdraw_HandleCacheAllocateEnd(t, size, owner, (flags & GDRAW_MAKETEXTURE_FLAGS_never_flush) ? GDRAW_HANDLE_STATE_pinned : GDRAW_HANDLE_STATE_locked);
+   stats->nonzero_flags |= GDRAW_STATS_alloc_tex;
+   stats->alloc_tex += 1;
+   stats->alloc_tex_bytes += size;
+
+   p->texture_type = GDRAW_TEXTURE_TYPE_bgra;
+   p->p0 = t;
+
+   if (flags & GDRAW_MAKETEXTURE_FLAGS_mipmap) {
+      rrbool ok;
+      assert(p->temp_buffer != NULL);
+      ok = gdraw_MipmapBegin(&gdraw->mipmap, width, height, t->handle.tex.d3d->GetLevelCount(), bpp, p->temp_buffer, p->temp_buffer_bytes);
+      assert(ok); // this should never trigger unless the temp_buffer is way too small
+
+      p->p1 = &gdraw->mipmap;
+      p->texture_data = gdraw->mipmap.pixels[0];
+      p->num_rows = gdraw->mipmap.bheight;
+      p->stride_in_bytes = gdraw->mipmap.pitch[0];
+      p->i0 = 0; // current output y
+      p->i1 = bpp;
+   } else {
+      D3DLOCKED_RECT z;
+      hr = t->handle.tex.d3d->LockRect(0, &z, NULL, 0);
+      if (FAILED(hr)) {
+         t->handle.tex.d3d->Release();
+         gdraw_HandleCacheAllocateFail(t);
+
+         if (hr == E_OUTOFMEMORY) {
+            IggyGDrawSendWarning(NULL, "GDraw out of texture memory allocating %dx%d (%dbpp) texture", width, height, 8*bpp);
+            return false;
+         } else {
+            IggyGDrawSendWarning(NULL, "GDraw LockRect for texture allocation failed, D3D error 0x%08x\n", hr);
+            return false;
+         }
+      }
+      
+      p->p1 = NULL;
+      p->texture_data = (U8 *) z.pBits;
+      p->num_rows = height;
+      p->stride_in_bytes = z.Pitch;
+   }
+
+   return true;
+}
+
+static rrbool RADLINK gdraw_MakeTextureMore(GDraw_MakeTexture_ProcessingInfo *p)
+{
+   GDrawHandle *t = (GDrawHandle *) p->p0;
+   
+   if (p->p1) {
+      GDrawMipmapContext *c = (GDrawMipmapContext *) p->p1;
+      U32 outy = p->i0;
+      U32 bpp = p->i1;
+      U32 width = c->width;
+      U32 height = c->height;
+      U32 bheight = c->bheight;
+      U32 level = 0;
+
+      if (outy >= c->height)
+         return false;
+
+      do {
+         // upload data for this miplevel
+         D3DLOCKED_RECT z;
+         HRESULT hr = t->handle.tex.d3d->LockRect(level, &z, NULL, 0);
+         if (FAILED(hr))
+            return false;
+
+         for (U32 y=0; y < bheight; ++y)
+            memcpy((U8 *) z.pBits + ((outy >> level) + y) * z.Pitch, c->pixels[level] + y * c->pitch[level], width * bpp);
+         t->handle.tex.d3d->UnlockRect(level);
+
+         // prepare next miplevel
+         width = RR_MAX(width >> 1, 1);
+         height = RR_MAX(height >> 1, 1);
+         bheight = RR_MAX(bheight >> 1, 1);
+      } while (gdraw_MipmapAddLines(c, ++level));
+
+      // prepare next chunk
+      p->i0 += p->num_rows;
+      p->texture_data = c->pixels[0];
+      p->num_rows = c->bheight = RR_MIN(c->bheight, c->height - p->i0);
+      return true;
+   } else
+      return false;
+}
+
+static GDrawTexture * RADLINK gdraw_MakeTextureEnd(GDraw_MakeTexture_ProcessingInfo *p, GDrawStats * /*stats*/)
+{
+   GDrawHandle *t = (GDrawHandle *) p->p0;
+   if (p->p1)
+      gdraw_MakeTextureMore(p); // use more to upload the last batch of data
+   else
+      t->handle.tex.d3d->UnlockRect(0);
+
+   return (GDrawTexture *) t;
+}
+
+
+static rrbool RADLINK gdraw_UpdateTextureBegin(GDrawTexture *t, void *unique_id, GDrawStats * /*stats*/)
+{
+   return gdraw_HandleCacheLock((GDrawHandle *) t, unique_id);
+}
+
+static void RADLINK gdraw_UpdateTextureRect(GDrawTexture *t, void * /*unique_id*/, S32 x, S32 y, S32 stride, S32 w, S32 h, U8 *samples, gdraw_texture_format format)
+{
+   GDrawHandle *s = (GDrawHandle *) t;
+   RECT rdest = { x, y, x+w, y+h };
+   S32 i, bpl = (format == GDRAW_TEXTURE_FORMAT_font ? 1 : 4) * w;
+   D3DLOCKED_RECT lr;
+
+   HRESULT hr = s->handle.tex.d3d->LockRect(0, &lr, &rdest, 0);
+   if (FAILED(hr)) {
+      IggyGDrawSendWarning(0, "GDraw LockRect() for texture update failed; D3D error 0x%08x", hr);
+      return;
+   }
+
+   for (i=0; i < h; i++)
+      memcpy((U8 *) lr.pBits + i * lr.Pitch, samples + i*stride, bpl);
+
+   s->handle.tex.d3d->UnlockRect(0);
+}
+
+static void RADLINK gdraw_UpdateTextureEnd(GDrawTexture *t, void * /*unique_id*/, GDrawStats * /*stats*/)
+{
+   gdraw_HandleCacheUnlock((GDrawHandle *) t);
+}
+
+static void RADLINK gdraw_FreeTexture(GDrawTexture *tt, void *unique_id, GDrawStats *stats)
+{
+   GDrawHandle *t = (GDrawHandle *) tt;
+   assert(t != NULL); // @GDRAW_ASSERT
+   if (t->owner == unique_id || unique_id == NULL) {
+      if (t->cache == &gdraw->rendertargets) {
+         gdraw_HandleCacheUnlock(t);
+         // cache it by simply not freeing it
+         return;
+      }
+
+      gdraw_res_free(t, stats);
+   }
+}
+
+static rrbool RADLINK gdraw_TryToLockTexture(GDrawTexture *t, void *unique_id, GDrawStats * /*stats*/)
+{
+   return gdraw_HandleCacheLock((GDrawHandle *) t, unique_id);
+}
+
+static void RADLINK gdraw_DescribeTexture(GDrawTexture *tex, GDraw_Texture_Description *desc)
+{
+   GDrawHandle *p = (GDrawHandle *) tex;
+   desc->width = p->handle.tex.w;
+   desc->height = p->handle.tex.h;
+   desc->size_in_bytes = p->bytes;
+}
+
+static void RADLINK gdraw_SetAntialiasTexture(S32 width, U8 *rgba)
+{
+   HRESULT hr;
+   D3DLOCKED_RECT lr;
+   S32 i;
+   U8 *d;
+
+   safe_release(gdraw->aa_tex); // release the old texture, if any.
+
+   hr = gdraw->d3d_device->CreateTexture(width, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &gdraw->aa_tex, NULL);
+   if (FAILED(hr)) {
+      IggyGDrawSendWarning(0, "GDraw D3D error in CreateTexture 0x%08x", hr);
+      return;
+   }
+
+   hr = gdraw->aa_tex->LockRect(0, &lr, NULL, 0);
+   if (!FAILED(hr)) {
+      d = (U8 *) lr.pBits;
+      for (i=0; i < width; i++) {
+         d[i*4+0] = rgba[i*4+2];
+         d[i*4+1] = rgba[i*4+1];
+         d[i*4+2] = rgba[i*4+0];
+         d[i*4+3] = rgba[i*4+3];
+      }
+
+      gdraw->aa_tex->UnlockRect(0);
+   } else
+      IggyGDrawSendWarning(0, "GDraw D3D error in LockRect for texture creation: 0x%08x", hr);
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Vertex buffer creation/deletion
+//
+
+static rrbool RADLINK gdraw_MakeVertexBufferBegin(void *unique_id, gdraw_vformat /*vformat*/, S32 vbuf_size, S32 ibuf_size, GDraw_MakeVertexBuffer_ProcessingInfo *p, GDrawStats *stats)
+{
+   char *failed_call;
+   GDrawHandle *vb = gdraw_res_alloc_begin(gdraw->vbufcache, vbuf_size + ibuf_size, stats);
+   if (!vb)
+      return false;
+
+   vb->handle.vbuf.base = NULL;
+   vb->handle.vbuf.indices = NULL;
+
+   HRESULT hr;
+   hr = gdraw->d3d_device->CreateVertexBuffer(vbuf_size, D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &vb->handle.vbuf.base, NULL);
+   failed_call = "CreateVertexBuffer";
+   if (!FAILED(hr)) {
+      hr = gdraw->d3d_device->CreateIndexBuffer(ibuf_size, D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &vb->handle.vbuf.indices, NULL);
+      failed_call = "CreateIndexBuffer";
+   }
+   if (!FAILED(hr)) {
+      hr = vb->handle.vbuf.base->Lock(0, vbuf_size, (void **) &p->vertex_data, 0);
+      failed_call = "Lock";
+   }
+   if (!FAILED(hr))
+      hr = vb->handle.vbuf.indices->Lock(0, ibuf_size, (void **) &p->index_data, 0);
+
+   if (FAILED(hr)) {
+      if (vb->handle.vbuf.base)
+         vb->handle.vbuf.base->Unlock(); // does nothing if we didn't actually lock
+
+      safe_release(vb->handle.vbuf.base);
+      safe_release(vb->handle.vbuf.indices);
+
+      gdraw_HandleCacheAllocateFail(vb);
+
+      report_d3d_error(hr, failed_call, " creating vertex buffer");
+      return false;
+   }
+
+   p->vertex_data_length = vbuf_size;
+   p->index_data_length = ibuf_size;
+   p->p0 = vb;
+
+   gdraw_HandleCacheAllocateEnd(vb, vbuf_size + ibuf_size, unique_id, GDRAW_HANDLE_STATE_locked);
+   return true;
+}
+
+static rrbool RADLINK gdraw_MakeVertexBufferMore(GDraw_MakeVertexBuffer_ProcessingInfo * /*p*/)
+{
+   assert(0);
+   return false;
+}
+
+static GDrawVertexBuffer * RADLINK gdraw_MakeVertexBufferEnd(GDraw_MakeVertexBuffer_ProcessingInfo *p, GDrawStats * /*stats*/)
+{
+   GDrawHandle *vb = (GDrawHandle *) p->p0;
+   vb->handle.vbuf.base->Unlock();
+   vb->handle.vbuf.indices->Unlock();
+   return (GDrawVertexBuffer *) vb;
+}
+
+static rrbool RADLINK gdraw_TryLockVertexBuffer(GDrawVertexBuffer *vb, void *unique_id, GDrawStats * /*stats*/)
+{
+   return gdraw_HandleCacheLock((GDrawHandle *) vb, unique_id);
+}
+
+static void RADLINK gdraw_FreeVertexBuffer(GDrawVertexBuffer *vb, void *unique_id, GDrawStats *stats)
+{
+   GDrawHandle *h = (GDrawHandle *) vb;
+   assert(h != NULL); // @GDRAW_ASSERT
+   if (h->owner == unique_id)
+      gdraw_res_free(h, stats);
+}
+
+static void RADLINK gdraw_DescribeVertexBuffer(GDrawVertexBuffer *vbuf, GDraw_VertexBuffer_Description *desc)
+{
+   GDrawHandle *p = (GDrawHandle *) vbuf;
+   desc->size_in_bytes = p->bytes;
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Create/free (or cache) render targets
+//
+
+static GDrawHandle *get_color_rendertarget(GDrawStats *stats)
+{
+   // try to recycle LRU rendertarget
+   GDrawHandle *t = gdraw_HandleCacheGetLRU(&gdraw->rendertargets);
+   if (t) {
+      gdraw_HandleCacheLock(t, (void *) 1);
+      return t;
+   }
+
+   // ran out of RTs, allocate a new one
+   S32 size = gdraw->frametex_width * gdraw->frametex_height * 4;
+   if (gdraw->rendertargets.bytes_free < size) {
+      IggyGDrawSendWarning(NULL, "GDraw rendertarget allocation failed: hit size limit of %d bytes", gdraw->rendertargets.total_bytes);
+      return NULL;
+   }
+
+   t = gdraw_HandleCacheAllocateBegin(&gdraw->rendertargets);
+   if (!t) {
+      IggyGDrawSendWarning(NULL, "GDraw rendertarget allocation failed: hit handle limit");
+      return t;
+   }
+
+   HRESULT hr = gdraw->d3d_device->CreateTexture(gdraw->frametex_width, gdraw->frametex_height, 1, D3DUSAGE_RENDERTARGET,
+      D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &t->handle.tex.d3d, NULL);
+   if (FAILED(hr)) {
+      report_d3d_error(hr, "CreateTexture", " creating rendertarget");
+      gdraw_HandleCacheAllocateFail(t);
+      return NULL;
+   }
+
+   gdraw_HandleCacheAllocateEnd(t, size, (void *) 1, GDRAW_HANDLE_STATE_locked);
+   stats->nonzero_flags |= GDRAW_STATS_alloc_tex;
+   stats->alloc_tex += 1;
+   stats->alloc_tex_bytes += size;
+
+   return t;
+}
+
+static IDirect3DSurface9 *get_rendertarget_depthbuffer(GDrawStats *stats)
+{
+   if (!gdraw->rt_depthbuffer) {
+      HRESULT hr = gdraw->d3d_device->CreateDepthStencilSurface(gdraw->frametex_width, gdraw->frametex_height, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, TRUE, &gdraw->rt_depthbuffer, NULL);
+      if (FAILED(hr))
+         IggyGDrawSendWarning(NULL, "GDraw D3D error in CreateDepthStencilSurface: 0x%08x", hr);
+      else {
+         stats->nonzero_flags |= GDRAW_STATS_alloc_tex;
+         stats->alloc_tex += 1;
+         stats->alloc_tex_bytes += gdraw->frametex_width * gdraw->frametex_height * 4;
+      }
+   }
+
+   return gdraw->rt_depthbuffer;
+}
+
+static void flush_rendertargets(GDrawStats *stats)
+{
+   gdraw_res_flush(&gdraw->rendertargets, stats);
+   safe_release(gdraw->rt_depthbuffer);
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Vertex shader constants
+//
+
+#define VVAR_world0           0
+#define VVAR_world1           1
+#define VVAR_count_worldonly  2 // number of constants to send if you only changed world matrix
+
+#define VVAR_x_off            2
+#define VVAR_count_world_xoff 3 // number of constants to send if you changed world+x_off
+
+#define VVAR_texgen_s         3
+#define VVAR_texgen_t         4
+#define VVAR_count            5 // number of constants to send if you changed all per-batch state
+
+#define VVAR_x3d              5
+#define VVAR_y3d              6
+#define VVAR_z3d              7
+#define VVAR_count3d          8
+
+// Fixed-location pixel shader constants
+#define PVAR_cmul             0
+#define PVAR_cadd             1
+#define PVAR_focal            2
+#define PVAR_rescale1         3
+
+struct VertexVars
+{
+   F32 world[2][4];
+   F32 x_off[4];
+   F32 texgen_s[4];
+   F32 texgen_t[4];
+   F32 viewproj[3][4];
+};
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Rendering helpers
+//
+
+static void set_d3d_texture(U32 sampler, IDirect3DTexture9 *tex, U32 wrap, U32 nearest)
+{
+   static const int addrmodes[ASSERT_COUNT(GDRAW_WRAP__count, 4)] = {
+      D3DTADDRESS_CLAMP,   // GDRAW_WRAP_clamp
+      D3DTADDRESS_WRAP,    // GDRAW_WRAP_repeat
+      D3DTADDRESS_MIRROR,  // GDRAW_WRAP_mirror
+      D3DTADDRESS_CLAMP,   // GDRAW_WRAP_clamp_to_border (never used by client code!)
+   };
+
+   static const int filtermodes[2] = {
+      D3DTEXF_LINEAR,      // !nearest
+      D3DTEXF_POINT,       // nearest
+   };
+
+   assert(wrap < sizeof(addrmodes) / sizeof(addrmodes[0]));
+   assert(nearest < sizeof(filtermodes) / sizeof(filtermodes[0]));
+   IDirect3DDevice9 *d3d = gdraw->d3d_device;
+
+   d3d->SetTexture(sampler, tex);
+   d3d->SetSamplerState(sampler, D3DSAMP_MAGFILTER, filtermodes[nearest]);
+   d3d->SetSamplerState(sampler, D3DSAMP_ADDRESSU, addrmodes[wrap]);
+   d3d->SetSamplerState(sampler, D3DSAMP_ADDRESSV, addrmodes[wrap]);
+}
+
+static void set_viewport_raw(S32 x, S32 y, S32 w, S32 h)
+{
+   D3DVIEWPORT9 vp = { x, y, w, h, 0.0f, 1.0f };
+   gdraw->d3d_device->SetViewport(&vp);
+}
+
+static void set_projection_base(void)
+{
+   F32 m[3][4] = { 0 };
+
+   //    x3d = < viewproj.x, 0, 0, 0 >
+   //    y3d = < 0, viewproj.y, 0, 0 >
+   //    w3d = < viewproj.z, viewproj.w, 1.0, 1.0 >
+
+   m[0][0] = gdraw->projection[0];
+   m[1][1] = gdraw->projection[1];
+   m[2][0] = gdraw->projection[2];
+   m[2][1] = gdraw->projection[3];
+
+   m[2][2] = 1.0;
+   m[2][3] = 1.0;
+
+   gdraw->d3d_device->SetVertexShaderConstantF(VVAR_x3d, m[0], 3);
+}
+
+static void set_projection_raw(S32 x0, S32 x1, S32 y0, S32 y1)
+{
+   gdraw->projection[0] = 2.0f / (x1-x0);
+   gdraw->projection[1] = 2.0f / (y1-y0);
+   gdraw->projection[2] = (x1+x0)/(F32)(x0-x1) - 0.5f * gdraw->projection[0]; // -0.5f: convert from D3D9 to GL/D3D10 pixel coordinates
+   gdraw->projection[3] = (y1+y0)/(F32)(y0-y1) - 0.5f * gdraw->projection[1];
+
+   set_projection_base();
+}
+
+static void set_viewport(void)
+{
+   if (gdraw->in_blur) {
+      set_viewport_raw(0, 0, gdraw->tpw, gdraw->tph);
+      return;
+   }
+
+   if (gdraw->cur == gdraw->frame) // if the rendering stack is empty
+      // render a tile-sized region to the user-request tile location
+      set_viewport_raw(gdraw->vx, gdraw->vy, gdraw->tw, gdraw->th);
+   else if (gdraw->cur->cached)
+      set_viewport_raw(0, 0, gdraw->cur->width, gdraw->cur->height);
+   else
+      // if on the render stack, draw a padded-tile-sized region at the origin
+      set_viewport_raw(0, 0, gdraw->tpw, gdraw->tph);
+}
+
+static void set_projection(void)
+{
+   if (gdraw->in_blur) return;
+   if (gdraw->cur == gdraw->frame) // if the render stack is empty
+      set_projection_raw(gdraw->tx0, gdraw->tx0+gdraw->tw, gdraw->ty0+gdraw->th, gdraw->ty0);
+   else if (gdraw->cur->cached)
+      set_projection_raw(gdraw->cur->base_x, gdraw->cur->base_x+gdraw->cur->width, gdraw->cur->base_y, gdraw->cur->base_y+gdraw->cur->height);
+   else
+      set_projection_raw(gdraw->tx0p, gdraw->tx0p+gdraw->tpw, gdraw->ty0p+gdraw->tph, gdraw->ty0p);
+}
+
+static void set_common_renderstate()
+{
+   IDirect3DDevice9 *d3d = gdraw->d3d_device;
+   S32 i;
+
+   // all the render states we never change while drawing
+   d3d->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+   d3d->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
+   d3d->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
+   d3d->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
+   d3d->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_EQUAL);
+   d3d->SetRenderState(D3DRS_STENCILREF,  255);
+   d3d->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, 0 ); 
+   d3d->SetRenderState(D3DRS_DEPTHBIAS, 0 );
+   d3d->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
+   d3d->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
+
+   for (i=0; i < 3; i++) {
+      d3d->SetTextureStageState(i, D3DTSS_TEXCOORDINDEX, i);
+      d3d->SetTextureStageState(i, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
+      d3d->SetSamplerState(i, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
+      d3d->SetSamplerState(i, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
+      d3d->SetSamplerState(i, D3DSAMP_MIPMAPLODBIAS, 0);
+      d3d->SetSamplerState(i, D3DSAMP_MAXMIPLEVEL, 0);
+   }
+
+   d3d->SetTextureStageState(AATEX_SAMPLER, D3DTSS_TEXCOORDINDEX, AATEX_SAMPLER);
+
+   d3d->SetTexture(AATEX_SAMPLER, gdraw->aa_tex);
+   d3d->SetSamplerState(AATEX_SAMPLER, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
+   d3d->SetSamplerState(AATEX_SAMPLER, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
+   d3d->SetSamplerState(AATEX_SAMPLER, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
+   d3d->SetSamplerState(AATEX_SAMPLER, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
+   d3d->SetSamplerState(AATEX_SAMPLER, D3DSAMP_MIPMAPLODBIAS, 0);
+   d3d->SetSamplerState(AATEX_SAMPLER, D3DSAMP_MAXMIPLEVEL, 0);
+
+   // reset our state caching
+   gdraw->scissor_state = ~0u;
+   gdraw->blend_mode = -1;
+   gdraw->stencil_key = ~0u;
+   gdraw->z_key = ~0u;
+
+   VertexVars vvars = { 0 };
+   d3d->SetVertexShaderConstantF(0, vvars.world[0], VVAR_count);
+}
+
+static void clear_renderstate(void)
+{
+   IDirect3DDevice9 *d3d = gdraw->d3d_device;
+
+   d3d->SetTexture(0, NULL);
+   d3d->SetTexture(1, NULL);
+   d3d->SetTexture(2, NULL);
+   d3d->SetTexture(AATEX_SAMPLER, NULL);
+   d3d->SetStreamSource(0, NULL, 0, 0);
+   d3d->SetIndices(NULL);
+
+   d3d->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
+   d3d->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
+   d3d->SetRenderState(D3DRS_COLORWRITEENABLE, 0xf);
+   d3d->SetRenderState(D3DRS_STENCILENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
+
+   d3d->SetVertexShader(0);
+   d3d->SetPixelShader(0);
+   d3d->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+   d3d->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
+}
+
+static void clear_zbuffer(IDirect3DSurface9 *surf, U32 flags)
+{
+   IDirect3DDevice9 *d3d = gdraw->d3d_device;
+   IDirect3DSurface9 *target;
+   D3DSURFACE_DESC desc;
+   surf->GetDesc(&desc);
+
+   // here's where it gets stupid: we need a rendertarget that's
+   // big enough so we can actually clear the full z-buffer.
+   // we don't actually render to it or anything, we just need to
+   // set it...
+   target = gdraw->main_framebuffer;
+   if (surf != gdraw->main_depthbuffer) {
+      // tile surface could, in theory, be larger than main framebuffer, so
+      // check if we have at least one rendertarget matching the rt depth
+      // buffer created and use that while clearing if possible
+      S32 i;
+      for (i=0; i < MAX_RENDER_STACK_DEPTH; ++i)
+         if (gdraw->rendertargets.handle[i].handle.tex.d3d) {
+            gdraw->rendertargets.handle[i].handle.tex.d3d->GetSurfaceLevel(0, &target);
+            break;
+         }
+   }
+
+   D3DVIEWPORT9 vp = { 0, 0, desc.Width, desc.Height, 0.0f, 1.0f };
+   d3d->SetRenderTarget(0, target);
+   d3d->SetDepthStencilSurface(surf);
+   d3d->SetViewport(&vp);
+   d3d->Clear(0, NULL, flags, 0, 1.0f, 0);
+
+   if (target != gdraw->main_framebuffer)
+      target->Release();
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Begin/end rendering of a tile and per-frame processing
+//
+
+void gdraw_D3D_SetTileOrigin(IDirect3DSurface9 *rt, IDirect3DSurface9 *depth, S32 x, S32 y)
+{
+   D3DSURFACE_DESC desc;
+
+   if (gdraw->frame_done) {
+      ++gdraw->frame_counter;
+      gdraw->frame_done = false;
+   }
+
+   rt->GetDesc(&desc);
+
+   gdraw->main_framebuffer = rt;
+   gdraw->main_depthbuffer = depth;
+   gdraw->main_msaa = (desc.MultiSampleType != D3DMULTISAMPLE_NONE);
+   gdraw->vx = x;
+   gdraw->vy = y;
+}
+
+static void RADLINK gdraw_SetViewSizeAndWorldScale(S32 w, S32 h, F32 scale_x, F32 scale_y)
+{
+   memset(gdraw->frame, 0, sizeof(gdraw->frame));
+   gdraw->cur = gdraw->frame;
+   gdraw->fw = w;
+   gdraw->fh = h;
+   gdraw->tw = w;
+   gdraw->th = h;
+   gdraw->world_to_pixel[0] = scale_x;
+   gdraw->world_to_pixel[1] = scale_y;
+
+   set_viewport();
+}
+
+static void RADLINK gdraw_Set3DTransform(F32 *mat)
+{
+   if (mat == NULL)
+      gdraw->use_3d = 0;
+   else {
+      gdraw->use_3d = 1;
+      memcpy(gdraw->xform_3d, mat, sizeof(gdraw->xform_3d));
+   }
+}
+
+
+// must include anything necessary for texture creation/update
+static void RADLINK gdraw_RenderingBegin(void)
+{
+}
+static void RADLINK gdraw_RenderingEnd(void)
+{
+}
+
+static void RADLINK gdraw_RenderTileBegin(S32 x0, S32 y0, S32 x1, S32 y1, S32 pad, GDrawStats *stats)
+{
+   if (x0 == 0 && y0 == 0 && x1 == gdraw->fw && y1 == gdraw->fh)
+      pad = 0;
+
+   gdraw->tx0 = x0;
+   gdraw->ty0 = y0;
+   gdraw->tw = x1-x0;
+   gdraw->th = y1-y0;
+
+   // padded region
+   gdraw->tx0p = RR_MAX(x0 - pad, 0);
+   gdraw->ty0p = RR_MAX(y0 - pad, 0);
+   gdraw->tpw = RR_MIN(x1 + pad, gdraw->fw) - gdraw->tx0p;
+   gdraw->tph = RR_MIN(y1 + pad, gdraw->fh) - gdraw->ty0p;
+
+   // just record the max, but then when we texture from, we have to use
+   // sub-regions -- alternatively, each gdraw gets its own rendertargets
+   if (gdraw->tpw > gdraw->frametex_width || gdraw->tph > gdraw->frametex_height) {
+      gdraw->frametex_width  = RR_MAX(gdraw->tpw, gdraw->frametex_width);
+      gdraw->frametex_height = RR_MAX(gdraw->tph, gdraw->frametex_height);
+
+      flush_rendertargets(stats);
+   }
+
+   // clear our depth buffers
+   clear_zbuffer(gdraw->main_depthbuffer, D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER);
+   if (gdraw->rt_depthbuffer)
+      clear_zbuffer(gdraw->rt_depthbuffer, D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER);
+
+   // set our rendertarget
+   gdraw->d3d_device->SetRenderTarget(0, gdraw->main_framebuffer);
+   gdraw->d3d_device->SetDepthStencilSurface(gdraw->main_depthbuffer);
+   set_viewport();
+   set_projection();
+   set_common_renderstate();
+}
+
+static void RADLINK gdraw_RenderTileEnd(GDrawStats * /*stats*/)
+{
+}
+
+void gdraw_D3D_SetRendertargetSize(S32 w, S32 h)
+{
+   if (gdraw && (w != gdraw->frametex_width || h != gdraw->frametex_height)) {
+      GDrawStats stats = { 0 };
+      gdraw->frametex_width = w;
+      gdraw->frametex_height = h;
+      flush_rendertargets(&stats);
+   }
+}
+
+void gdraw_D3D_NoMoreGDrawThisFrame(void)
+{
+   clear_renderstate();
+   if (gdraw->main_framebuffer)
+      gdraw->d3d_device->SetRenderTarget(0, gdraw->main_framebuffer);
+   if (gdraw->main_depthbuffer)
+      gdraw->d3d_device->SetDepthStencilSurface(gdraw->main_depthbuffer);
+   gdraw->frame_done = true;
+
+   GDrawFence now = { gdraw->frame_counter };
+   gdraw_HandleCacheTick(gdraw->texturecache, now);
+   gdraw_HandleCacheTick(gdraw->vbufcache, now);
+}
+
+#define MAX_DEPTH_VALUE   (1 << 13)
+
+static void RADLINK gdraw_GetInfo(GDrawInfo *d)
+{
+   D3DCAPS9 caps;
+   gdraw->d3d_device->GetDeviceCaps(&caps);
+
+   d->num_stencil_bits = 8;
+   d->max_id = MAX_DEPTH_VALUE-2;
+   // for floating point depth, just use mantissa, e.g. 16-20 bits
+   d->max_texture_size = RR_MIN(caps.MaxTextureWidth, caps.MaxTextureHeight);
+   d->buffer_format = GDRAW_BFORMAT_vbib;
+   d->shared_depth_stencil = 1;
+   d->always_mipmap = 1;
+   d->conditional_nonpow2 = (caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) != 0;
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Enable/disable rendertargets in stack fashion
+//
+
+static void set_render_target(GDrawStats *stats)
+{
+   IDirect3DSurface9 *target = NULL, *depth = NULL;
+
+   if (gdraw->cur->color_buffer) {
+      S32 need_depth;
+      need_depth = (gdraw->cur->flags & (GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_id | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_stencil));
+
+      unbind_resources(); // to make sure this RT isn't accidentally set as a texture (avoid D3D warnings)
+      gdraw->cur->color_buffer->handle.tex.d3d->GetSurfaceLevel(0, &target);  // if this fails, there's nothing to be done
+      if (need_depth) {
+         if (gdraw->main_msaa)
+            depth = get_rendertarget_depthbuffer(stats); // @TODO: is this right? get_rt_depthbuffer doesn't seem to do MSAA
+         else {
+            // if tile is smaller than frametex, then trying to use the tile's zbuffer may not work
+            if (gdraw->tw < gdraw->frametex_width || gdraw->th < gdraw->frametex_height)
+               depth = get_rendertarget_depthbuffer(stats);
+            else
+               depth = gdraw->main_depthbuffer;
+         }
+      }
+   } else {
+      target = gdraw->main_framebuffer;
+      depth = gdraw->main_depthbuffer;
+   }
+
+   gdraw->d3d_device->SetRenderTarget(0, target);
+   gdraw->d3d_device->SetDepthStencilSurface(depth);
+   if (target != gdraw->main_framebuffer)
+      target->Release();
+
+   stats->nonzero_flags |= GDRAW_STATS_rendtarg;
+   stats->rendertarget_changes += 1;
+}
+
+static rrbool RADLINK gdraw_TextureDrawBufferBegin(gswf_recti *region, gdraw_texture_format /*format*/, U32 flags, void *owner, GDrawStats *stats)
+{
+   GDrawFramebufferState *n = gdraw->cur+1;
+   GDrawHandle *t;
+   if (gdraw->tw == 0 || gdraw->th == 0)
+      return false;
+
+   if (n >= &gdraw->frame[MAX_RENDER_STACK_DEPTH]) {
+      IggyGDrawSendWarning(NULL, "GDraw rendertarget nesting exceeds MAX_RENDER_STACK_DEPTH");
+      return false;
+   }
+
+   if (owner) {
+      S32 w = region->x1 - region->x0;
+      S32 h = region->y1 - region->y0;
+
+      // allocate a texture handle and free enough texture space
+      t = gdraw_res_alloc_begin(gdraw->texturecache, w*h*4, stats);
+      if (!t)
+         return false;
+      else {
+         IDirect3DTexture9 * tex;
+         HRESULT hr = gdraw->d3d_device->CreateTexture(w,h,1,
+                                         D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8,
+                                             D3DPOOL_DEFAULT, &tex, NULL);
+
+         if (FAILED(hr)) {
+            if (t)
+               gdraw_HandleCacheAllocateFail(t);
+            IggyGDrawSendWarning(NULL, "GDraw D3D error for CreateTexture for cacheAsBitmap rendertarget: 0x%08x", hr);
+            return false;
+         }
+
+         stats->nonzero_flags |= GDRAW_STATS_alloc_tex;
+         stats->alloc_tex += 1;
+         stats->alloc_tex_bytes += w*h*4;
+
+         gdraw_HandleCacheAllocateEnd(t, w*h*4, (void *) 1, GDRAW_HANDLE_STATE_locked);
+      }
+   } else {
+      t = get_color_rendertarget(stats);
+      if (!t)
+         return false;
+   }
+
+   n->flags = flags;
+   n->color_buffer = t;
+   assert(n->color_buffer != NULL); // @GDRAW_ASSERT
+
+   ++gdraw->cur;
+   gdraw->cur->cached = owner != NULL;
+   if (owner) {
+      gdraw->cur->base_x = region->x0;
+      gdraw->cur->base_y = region->y0;
+      gdraw->cur->width  = region->x1 - region->x0;
+      gdraw->cur->height = region->y1 - region->y0;
+   }
+
+   set_render_target(stats);
+   assert(gdraw->frametex_width >= gdraw->tw && gdraw->frametex_height >= gdraw->th); // @GDRAW_ASSERT
+   set_viewport();
+   set_projection();
+
+   int k = (int) (t - gdraw->rendertargets.handle);
+
+   if (region) {
+      D3DRECT r;
+      S32 ox, oy, pad = 2; // 2 pixels of border on all sides
+      // 1 pixel turns out to be not quite enough with the interpolator precision we get.
+
+      if (gdraw->in_blur)
+         ox = oy = 0;
+      else
+         ox = gdraw->tx0p, oy = gdraw->ty0p;
+
+      // clamp region to tile
+      S32 xt0 = RR_MAX(region->x0 - ox, 0);
+      S32 yt0 = RR_MAX(region->y0 - oy, 0);
+      S32 xt1 = RR_MIN(region->x1 - ox, gdraw->tpw);
+      S32 yt1 = RR_MIN(region->y1 - oy, gdraw->tph);
+
+      // but the padding needs to clamp to render target bounds
+      r.x1 = RR_MAX(xt0 - pad, 0);
+      r.y1 = RR_MAX(yt0 - pad, 0);
+      r.x2 = RR_MIN(xt1 + pad, gdraw->frametex_width);
+      r.y2 = RR_MIN(yt1 + pad, gdraw->frametex_height);
+
+      if (r.x2 <= r.x1 || r.y2 <= r.y1) { // region doesn't intersect with current tile
+         --gdraw->cur;
+         gdraw_FreeTexture((GDrawTexture *) t, 0, stats);
+         // note: don't send a warning since this will happen during regular tiled rendering
+         return false;
+      }
+
+      gdraw->d3d_device->Clear(1, &r, D3DCLEAR_TARGET, 0, 1, 0);
+      gdraw->rt_valid[k].x0 = xt0;
+      gdraw->rt_valid[k].y0 = yt0;
+      gdraw->rt_valid[k].x1 = xt1;
+      gdraw->rt_valid[k].y1 = yt1;
+   } else {
+      gdraw->d3d_device->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1, 0); 
+      gdraw->rt_valid[k].x0 = 0;
+      gdraw->rt_valid[k].y0 = 0;
+      gdraw->rt_valid[k].x1 = gdraw->frametex_width;
+      gdraw->rt_valid[k].y1 = gdraw->frametex_height;
+   }
+
+   return true;
+}
+
+static GDrawTexture *RADLINK gdraw_TextureDrawBufferEnd(GDrawStats *stats)
+{
+   GDrawFramebufferState *n =   gdraw->cur;
+   GDrawFramebufferState *m = --gdraw->cur;
+
+   if (gdraw->tw == 0 || gdraw->th == 0) return 0;
+
+   if (n >= &gdraw->frame[MAX_RENDER_STACK_DEPTH])
+      return 0; // already returned a warning in Begin
+
+   assert(m >= gdraw->frame);  // bug in Iggy -- unbalanced
+
+   if (m != gdraw->frame) {
+      assert(m->color_buffer != NULL); // @GDRAW_ASSERT
+   }
+   assert(n->color_buffer != NULL); // @GDRAW_ASSERT
+
+   // switch back to old render target
+   set_render_target(stats);
+
+   // if we're at the root, set the viewport back
+   set_viewport();
+   set_projection();
+
+   return (GDrawTexture *) n->color_buffer;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Clear stencil/depth buffers
+//
+// Open question whether we'd be better off finding bounding boxes
+// and only clearing those; it depends exactly how fast clearing works.
+//
+
+static void clear_renderstate_acceleration_cache(void)
+{
+   gdraw->last_was_3d = false;
+   gdraw->scissor_state = ~0u;
+   gdraw->stencil_key = 0;
+   gdraw->blend_mode = ~0u;
+}
+
+static void do_screen_quad(gswf_recti *s, F32 *tc, GDrawStats *stats);
+
+static void RADLINK gdraw_ClearStencilBits(U32 bits)
+{
+   IDirect3DDevice9 *d3d = gdraw->d3d_device;
+   F32 texcoord[8] = { 0 };
+   GDrawStats stats = { 0 };
+   gswf_recti region;
+
+   region.x0 = 0;
+   region.y0 = 0;
+   region.x1 = gdraw->frametex_width;
+   region.y1 = gdraw->frametex_height;
+
+   d3d->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_STENCILWRITEMASK, bits);
+   d3d->SetRenderState(D3DRS_STENCILENABLE, TRUE);
+   // fewest states to force it to always write: make the stencil test always fail
+   d3d->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_NEVER);
+   d3d->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_REPLACE);
+   d3d->SetRenderState(D3DRS_STENCILREF,  0);
+   d3d->SetRenderState(D3DRS_COLORWRITEENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_ZENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_ZFUNC, FALSE);
+   d3d->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
+
+   d3d->SetPixelShader(gdraw->manual_clear.pshader);
+   do_screen_quad(&region, texcoord, &stats);
+
+   // restore state from set_common_renderstate
+   d3d->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
+   d3d->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_EQUAL);
+   d3d->SetRenderState(D3DRS_STENCILREF,  255);
+
+   // make next renderstate reset other state
+   clear_renderstate_acceleration_cache();
+
+   // reset matrices et al
+   set_render_target(&stats);
+   set_viewport();
+   set_projection();
+}
+
+// this only happens rarely (hopefully never) if we use the depth buffer,
+// so we can just clear the whole thing
+static void RADLINK gdraw_ClearID(void)
+{
+   GDrawStats stats = { 0 };
+
+   clear_zbuffer(gdraw->main_depthbuffer, D3DCLEAR_ZBUFFER);
+   set_render_target(&stats);
+   set_viewport();
+   set_projection();
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Set all the render state from GDrawRenderState
+//
+// This also is responsible for getting the framebuffer into a texture
+// if the read-modify-write blend operation can't be expressed with
+// the native blend operators. (E.g. "screen")
+//
+
+// convert an ID request to a value suitable for the depth buffer,
+// assuming the depth buffer has been mappped to 0..1
+static F32 depth_from_id(S32 id)
+{
+   return 1.0f - ((F32) id + 1.0f) / MAX_DEPTH_VALUE;
+}
+
+static void set_texture(S32 texunit, GDrawTexture *tex)
+{
+   if (texunit >= 0)
+      set_d3d_texture(texunit, ((GDrawHandle *) tex)->handle.tex.d3d, GDRAW_WRAP_clamp, 0);
+}
+
+static int set_renderstate_full(S32 vertex_format, GDrawRenderState *r, GDrawStats * /*stats*/)
+{
+   IDirect3DDevice9 *d3d = gdraw->d3d_device;
+   U32 stencil_key, z_key;
+   F32 depth = depth_from_id(r->id);
+   VertexVars vvars;
+   int vvarcount = VVAR_count_world_xoff;
+
+   // set vertex shader
+   d3d->SetVertexShader(gdraw->vert[vertex_format].vshader);
+   
+   // set vertex shader constants
+   if (!r->use_world_space)
+      gdraw_ObjectSpace(vvars.world[0], r->o2w, depth, 0.0f);
+   else
+      gdraw_WorldSpace(vvars.world[0], gdraw->world_to_pixel, depth, 0.0f);
+
+   memcpy(&vvars.x_off, r->edge_matrix, 4*sizeof(F32));
+
+   if (r->texgen0_enabled) {
+      memcpy(&vvars.texgen_s, r->s0_texgen, 4*sizeof(F32));
+      memcpy(&vvars.texgen_t, r->t0_texgen, 4*sizeof(F32));
+      vvarcount = VVAR_count;
+   }
+
+   if (gdraw->use_3d || gdraw->last_was_3d) {
+      if (gdraw->use_3d) {
+         vvarcount = VVAR_count3d;
+         memcpy(&vvars.viewproj, gdraw->xform_3d, 12*sizeof(F32));
+      } else
+         set_projection_base();
+      gdraw->last_was_3d = gdraw->use_3d;
+   }  
+
+   d3d->SetVertexShaderConstantF(0, vvars.world[0], vvarcount);
+
+   // set the blend mode
+   int blend_mode = r->blend_mode;
+   int tex0mode = r->tex0_mode;
+
+   static struct gdraw_d3d_blendspec {
+      BOOL enable;
+      D3DBLEND src;
+      D3DBLEND dest;
+   } blends[ASSERT_COUNT(GDRAW_BLEND__count, 6)] = {
+      FALSE,   D3DBLEND_ONE,        D3DBLEND_ZERO,          // GDRAW_BLEND_none
+      TRUE,    D3DBLEND_ONE,        D3DBLEND_INVSRCALPHA,   // GDRAW_BLEND_alpha
+      TRUE,    D3DBLEND_DESTCOLOR,  D3DBLEND_INVSRCALPHA,   // GDRAW_BLEND_multiply
+      TRUE,    D3DBLEND_ONE,        D3DBLEND_ONE,           // GDRAW_BLEND_add
+
+      FALSE,   D3DBLEND_ONE,        D3DBLEND_ZERO,          // GDRAW_BLEND_filter
+      FALSE,   D3DBLEND_ONE,        D3DBLEND_ZERO,          // GDRAW_BLEND_special
+   };
+   assert(blend_mode >= 0 && blend_mode < sizeof(blends)/sizeof(*blends));
+   
+   if (blend_mode != gdraw->blend_mode) {
+      gdraw->blend_mode = blend_mode;
+      if (blends[blend_mode].enable) {
+         d3d->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
+         d3d->SetRenderState(D3DRS_SRCBLEND, blends[blend_mode].src);
+         d3d->SetRenderState(D3DRS_DESTBLEND, blends[blend_mode].dest);
+      } else
+         d3d->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
+   }
+
+   // set the pixel shader
+   IDirect3DPixelShader9 *pshader;
+   if (blend_mode != GDRAW_BLEND_special) {
+      assert(tex0mode >= 0 && tex0mode < sizeof(gdraw->fprog) / sizeof(*gdraw->fprog));
+
+      int additive = 0;
+      if (r->cxf_add) {
+         additive = 1;
+         if (r->cxf_add[3]) additive = 2;
+      }
+
+      pshader = gdraw->fprog[tex0mode][additive].pshader;
+   } else
+      pshader = gdraw->exceptional_blend[r->special_blend].pshader;
+
+   d3d->SetPixelShader(pshader);
+
+   // set textures
+   if (tex0mode != GDRAW_TEXTURE_none) {
+      if (!r->tex[0]) return 0;
+      set_d3d_texture(0, ((GDrawHandle *) r->tex[0])->handle.tex.d3d, r->wrap0, r->nearest0);
+   }
+
+   // set pixel shader constants
+   d3d->SetPixelShaderConstantF(PVAR_cmul, r->color, 1);
+   
+   if (r->cxf_add) {
+      F32 temp[4] = { r->cxf_add[0]/255.0f, r->cxf_add[1]/255.0f, r->cxf_add[2]/255.0f, r->cxf_add[3]/255.0f };
+      d3d->SetPixelShaderConstantF(PVAR_cadd, temp, 1);
+   }
+
+   if (tex0mode == GDRAW_TEXTURE_focal_gradient)
+      d3d->SetPixelShaderConstantF(PVAR_focal, r->focal_point, 1);
+
+   // Set pixel operation states
+   gdraw->scissor_state = ~0u;
+   if (r->scissor) {
+      RECT s;
+      gdraw->scissor_state = r->scissor;
+      if (gdraw->cur == gdraw->frame) {
+         s.left = r->scissor_rect.x0 + gdraw->vx - gdraw->tx0;
+         s.top  = r->scissor_rect.y0 + gdraw->vy - gdraw->ty0;
+         s.right = r->scissor_rect.x1 + gdraw->vx - gdraw->tx0;
+         s.bottom = r->scissor_rect.y1 + gdraw->vy - gdraw->ty0;
+      } else {
+         s.left = r->scissor_rect.x0 - gdraw->tx0p;
+         s.top  = r->scissor_rect.y0 - gdraw->ty0p;
+         s.right = r->scissor_rect.x1 - gdraw->tx0p;
+         s.bottom = r->scissor_rect.y1 - gdraw->ty0p;
+      }
+      d3d->SetScissorRect(&s);
+      d3d->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
+   } else {
+      if (r->scissor != gdraw->scissor_state) {
+         gdraw->scissor_state = r->scissor;
+         d3d->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
+      }
+   }
+
+   // stencil changed?
+   stencil_key = r->stencil_test | (r->stencil_set << 8);
+   if (stencil_key != gdraw->stencil_key) {
+      gdraw->stencil_key = stencil_key;
+
+      d3d->SetRenderState(D3DRS_STENCILMASK, r->stencil_test);
+      d3d->SetRenderState(D3DRS_STENCILWRITEMASK, r->stencil_set);
+      d3d->SetRenderState(D3DRS_STENCILENABLE, (r->stencil_set | r->stencil_test) != 0);
+      d3d->SetRenderState(D3DRS_COLORWRITEENABLE, r->stencil_set ? 0x0 : 0xf);
+   }
+
+   // z key
+   z_key = r->set_id | (r->test_id << 1);
+   if (z_key != gdraw->z_key) {
+      gdraw->z_key = z_key;
+      d3d->SetRenderState(D3DRS_ZENABLE, (r->test_id | r->set_id) ? D3DZB_TRUE : D3DZB_FALSE);
+      d3d->SetRenderState(D3DRS_ZFUNC, r->test_id ? D3DCMP_LESS : D3DCMP_ALWAYS);
+      d3d->SetRenderState(D3DRS_ZWRITEENABLE, r->set_id);
+   }
+   
+   return 1;
+}
+
+static RADINLINE int set_renderstate(S32 vertex_format, GDrawRenderState *r, GDrawStats *stats)
+{
+   if (r->identical_state) {
+      // fast path: only need to change vertex shader, other state is the same
+      gdraw->d3d_device->SetVertexShader(gdraw->vert[vertex_format].vshader);
+      return 1;
+   } else
+      return set_renderstate_full(vertex_format, r, stats);
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Vertex formats
+//
+
+static D3DVERTEXELEMENT9 vformat_v2[] =
+{
+   { 0,0, D3DDECLTYPE_FLOAT2, 0, D3DDECLUSAGE_POSITION, 0 },
+   D3DDECL_END()
+};
+
+static D3DVERTEXELEMENT9 vformat_v2aa[] =
+{
+   { 0,0, D3DDECLTYPE_FLOAT2, 0, D3DDECLUSAGE_POSITION, 0 },
+   { 0,8, D3DDECLTYPE_SHORT4, 0, D3DDECLUSAGE_TEXCOORD, 0 },
+   D3DDECL_END()
+};
+
+static D3DVERTEXELEMENT9 vformat_v2tc2[] =
+{
+   { 0,0, D3DDECLTYPE_FLOAT2, 0, D3DDECLUSAGE_POSITION, 0 },
+   { 0,8, D3DDECLTYPE_FLOAT2, 0, D3DDECLUSAGE_TEXCOORD, 0 }, 
+   D3DDECL_END()
+};
+
+static D3DVERTEXELEMENT9 *vformats[ASSERT_COUNT(GDRAW_vformat__count, 3)] = {
+   vformat_v2,    // GDRAW_vformat_v2
+   vformat_v2aa,  // GDRAW_vformat_v2aa
+   vformat_v2tc2, // GDRAW_vformat_v2tc2
+};
+
+static int vertsize[ASSERT_COUNT(GDRAW_vformat__count, 3)] = {
+   8,    // GDRAW_vformat_v2
+   16,   // GDRAW_vformat_v2aa
+   16,   // GDRAW_vformat_v2tc2
+};
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Draw triangles with a given renderstate
+//
+
+static void tag_resources(void *r1, void *r2=NULL, void *r3=NULL, void *r4=NULL)
+{
+   U64 now = gdraw->frame_counter;
+   if (r1) ((GDrawHandle *) r1)->fence.value = now;
+   if (r2) ((GDrawHandle *) r2)->fence.value = now;
+   if (r3) ((GDrawHandle *) r3)->fence.value = now;
+   if (r4) ((GDrawHandle *) r4)->fence.value = now;
+}
+
+static void RADLINK gdraw_DrawIndexedTriangles(GDrawRenderState *r, GDrawPrimitive *p, GDrawVertexBuffer *buf, GDrawStats *stats)
+{
+   GDrawHandle *vb = (GDrawHandle *) buf;
+   int vfmt = p->vertex_format;
+   assert(vfmt >= 0 && vfmt < GDRAW_vformat__count);
+
+   if (!set_renderstate(vfmt, r, stats))
+      return;
+
+
+   gdraw->d3d_device->SetVertexDeclaration(gdraw->vdec[vfmt]);
+
+   if (vb) {
+      gdraw->d3d_device->SetIndices(vb->handle.vbuf.indices);
+      gdraw->d3d_device->SetStreamSource(0, vb->handle.vbuf.base, (U32) (UINTa) p->vertices, vertsize[vfmt]);
+
+      gdraw->d3d_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, p->num_vertices, (U32) ((UINTa) p->indices) >> 1, p->num_indices/3);
+
+      gdraw->d3d_device->SetStreamSource(0,0,0,0);
+      gdraw->d3d_device->SetIndices(0);
+   } else if (p->indices) {
+      gdraw->d3d_device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, p->num_vertices, p->num_indices/3, p->indices, D3DFMT_INDEX16, p->vertices, vertsize[vfmt]);
+   } else { // dynamic quads
+      assert(p->num_vertices % 4 == 0);
+      UINT stride = vertsize[vfmt];
+      S32 pos = 0;
+      while (pos < p->num_vertices) {
+         S32 vert_count = RR_MIN(p->num_vertices - pos, QUAD_IB_COUNT * 4);
+         gdraw->d3d_device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, vert_count, (vert_count/4)*2, quad_ib, D3DFMT_INDEX16, (U8 *)p->vertices + pos * stride, stride);
+         pos += vert_count;
+      }
+   }
+
+   tag_resources(vb, r->tex[0], r->tex[1]);
+
+   stats->nonzero_flags |= GDRAW_STATS_batches;
+   stats->num_batches += 1;
+   stats->drawn_indices += p->num_indices;
+   stats->drawn_vertices += p->num_vertices;
+}
+
+///////////////////////////////////////////////////////////////////////
+//
+//   Flash 8 filter effects
+//
+
+static void set_pixel_constant(S32 constant, F32 x, F32 y, F32 z, F32 w)
+{
+   if (constant >= 0) {
+      F32 value[4] = { x,y,z,w };
+      gdraw->d3d_device->SetPixelShaderConstantF(constant, value, 1);
+   }
+}
+
+// caller sets up texture coordinates
+static void do_screen_quad(gswf_recti *s, F32 *tc, GDrawStats *stats)
+{
+   F32 px0 = (F32) s->x0, py0 = (F32) s->y0, px1 = (F32) s->x1, py1 = (F32) s->y1;
+   gswf_vertex_xyst vert[4];
+   VertexVars vvars;
+
+   // interleave the data so we can use UP
+   vert[0].x = px0; vert[0].y = py0; vert[0].s = tc[0]; vert[0].t = tc[1];
+   vert[1].x = px1; vert[1].y = py0; vert[1].s = tc[2]; vert[1].t = tc[1];
+   vert[2].x = px1; vert[2].y = py1; vert[2].s = tc[2]; vert[2].t = tc[3];
+   vert[3].x = px0; vert[3].y = py1; vert[3].s = tc[0]; vert[3].t = tc[3];
+
+   gdraw_PixelSpace(vvars.world[0]);
+
+   gdraw->d3d_device->SetVertexDeclaration(gdraw->vdec[GDRAW_vformat_v2tc2]);
+   gdraw->d3d_device->SetVertexShader(gdraw->vert[GDRAW_vformat_v2tc2].vshader);
+   gdraw->d3d_device->SetVertexShaderConstantF(0, vvars.world[0], VVAR_count_worldonly);
+   gdraw->d3d_device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, vert, 16);
+
+   stats->nonzero_flags |= GDRAW_STATS_batches;
+   stats->num_batches += 1;
+   stats->drawn_indices += 6;
+   stats->drawn_vertices += 4;
+}
+
+static void gdraw_DriverBlurPass(GDrawRenderState *r, int taps,  float *data, gswf_recti *s, float *tc, float /*height_max*/, float *clamp, GDrawStats *gstats)
+{
+   ProgramWithCachedVariableLocations *prg = &gdraw->blur_prog[taps];
+   gdraw->d3d_device->SetPixelShader(prg->pshader);
+   set_texture(prg->vars[VAR_blur_tex0], r->tex[0]);
+
+   assert(prg->vars[VAR_blur_tap] >= 0);
+   gdraw->d3d_device->SetPixelShaderConstantF(prg->vars[VAR_blur_tap], data, taps);
+   gdraw->d3d_device->SetPixelShaderConstantF(prg->vars[VAR_blur_clampv], clamp, 1);
+
+   do_screen_quad(s, tc, gstats);
+   tag_resources(r->tex[0]);
+}
+
+static void gdraw_Colormatrix(GDrawRenderState *r, gswf_recti *s, float *tc, GDrawStats *stats)
+{
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, 0, stats))
+      return;
+
+   gdraw->d3d_device->SetPixelShader(gdraw->colormatrix.pshader);
+   set_texture(gdraw->colormatrix.vars[VAR_colormatrix_tex0], r->tex[0]);
+   gdraw->d3d_device->SetPixelShaderConstantF(gdraw->colormatrix.vars[VAR_colormatrix_data], r->shader_data, 5);
+   do_screen_quad(s, tc, stats);
+   tag_resources(r->tex[0]);
+   r->tex[0] = gdraw_TextureDrawBufferEnd(stats);
+}
+
+static gswf_recti *get_valid_rect(GDrawTexture *tex)
+{
+   GDrawHandle *h = (GDrawHandle *) tex;
+   S32 n = (S32) (h - gdraw->rendertargets.handle);
+   assert(n >= 0 && n <= MAX_RENDER_STACK_DEPTH+1);
+   return &gdraw->rt_valid[n];
+}
+
+static void set_clamp_constant(int constant, GDrawTexture *tex)
+{
+   gswf_recti *s = get_valid_rect(tex);
+   // when we make the valid data, we make sure there is an extra empty pixel at the border
+   set_pixel_constant(constant,
+      (s->x0-0.5f) / gdraw->frametex_width,
+      (s->y0-0.5f) / gdraw->frametex_height,
+      (s->x1+0.5f) / gdraw->frametex_width,
+      (s->y1+0.5f) / gdraw->frametex_height);
+}
+
+static void gdraw_Filter(GDrawRenderState *r, gswf_recti *s, float *tc, int isbevel, GDrawStats *stats)
+{
+   ProgramWithCachedVariableLocations *prg = &gdraw->filter_prog[isbevel][r->filter_mode];
+   
+   if (!gdraw_TextureDrawBufferBegin(s, GDRAW_TEXTURE_FORMAT_rgba32, GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color | GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha, NULL, stats))
+      return;
+
+   gdraw->d3d_device->SetPixelShader(prg->pshader);
+   set_texture(prg->vars[VAR_filter_tex0], r->tex[0]);
+   set_texture(prg->vars[VAR_filter_tex1], r->tex[1]);
+   set_texture(prg->vars[VAR_filter_tex2], r->tex[2]);
+
+   set_pixel_constant(prg->vars[VAR_filter_color], r->shader_data[0], r->shader_data[1], r->shader_data[2], r->shader_data[3]);
+   set_pixel_constant(prg->vars[VAR_filter_tc_off], -r->shader_data[4] / (F32)gdraw->frametex_width, -r->shader_data[5] / (F32)gdraw->frametex_height, r->shader_data[6], 0);
+   set_pixel_constant(prg->vars[VAR_filter_color2], r->shader_data[8], r->shader_data[9], r->shader_data[10], r->shader_data[11]);
+   set_clamp_constant(prg->vars[VAR_filter_clamp0], r->tex[0]);
+   set_clamp_constant(prg->vars[VAR_filter_clamp1], r->tex[1]);
+
+   do_screen_quad(s, tc, stats);
+   tag_resources(r->tex[0], r->tex[1], r->tex[2]);
+   r->tex[0] = gdraw_TextureDrawBufferEnd(stats);
+}
+
+static void RADLINK gdraw_FilterQuad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1, S32 y1, GDrawStats *stats)
+{
+   IDirect3DDevice9 *d3d = gdraw->d3d_device;
+   F32 tc[4];
+   gswf_recti s;
+
+   // clip to tile boundaries
+   s.x0 = RR_MAX(x0, gdraw->tx0p);
+   s.y0 = RR_MAX(y0, gdraw->ty0p);
+   s.x1 = RR_MIN(x1, gdraw->tx0p + gdraw->tpw);
+   s.y1 = RR_MIN(y1, gdraw->ty0p + gdraw->tph);
+   if (s.x1 < s.x0 || s.y1 < s.y0)
+      return;
+
+   tc[0] = (s.x0 - gdraw->tx0p) / (F32) gdraw->frametex_width;    
+   tc[1] = (s.y0 - gdraw->ty0p) / (F32) gdraw->frametex_height;   
+   tc[2] = (s.x1 - gdraw->tx0p) / (F32) gdraw->frametex_width;    
+   tc[3] = (s.y1 - gdraw->ty0p) / (F32) gdraw->frametex_height;   
+
+   // clear to known render state
+   d3d->SetRenderState(D3DRS_STENCILENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_COLORWRITEENABLE, 0xf);
+
+   d3d->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
+   d3d->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);
+   d3d->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
+   
+   d3d->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
+   d3d->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
+
+   gdraw->scissor_state = 0;
+   gdraw->blend_mode = GDRAW_BLEND_none;
+   gdraw->stencil_key = 0;
+   gdraw->z_key = 0;
+
+   if (r->blend_mode == GDRAW_BLEND_filter) {
+      switch (r->filter) {
+         case GDRAW_FILTER_blur: {
+            GDrawBlurInfo b;
+            gswf_recti bounds = *get_valid_rect(r->tex[0]);
+            gdraw_ShiftRect(&s, &s, -gdraw->tx0p, -gdraw->ty0p); // blur uses physical rendertarget coordinates
+
+            b.BlurPass = gdraw_DriverBlurPass;
+            b.w = gdraw->tpw;
+            b.h = gdraw->tph;
+            b.frametex_width = gdraw->frametex_width;
+            b.frametex_height = gdraw->frametex_height;
+
+            // blur needs to draw with multiple passes, so set up special state
+            gdraw->in_blur = true;
+            set_viewport_raw(0, 0, gdraw->tpw, gdraw->tph);
+            set_projection_raw(0, gdraw->tpw, gdraw->tph, 0);
+
+            // do the blur
+            gdraw_Blur(&gdraw_funcs, &b,r, &s, &bounds, stats);
+
+            // restore the normal state
+            gdraw->in_blur = false;
+            set_viewport();
+            set_projection();
+            break;
+         }
+
+         case GDRAW_FILTER_colormatrix:
+            gdraw_Colormatrix(r, &s, tc, stats);
+            break;
+
+         case GDRAW_FILTER_dropshadow:
+            gdraw_Filter(r, &s, tc, 0, stats);
+            break;
+
+         case GDRAW_FILTER_bevel:
+            gdraw_Filter(r, &s, tc, 1, stats);
+            break;
+
+         default:
+            assert(0);
+      }
+   } else {
+      GDrawHandle *blend_tex = NULL;
+      static S16 zero[4] = { 0, 0, 0, 0 };
+
+      // for crazy blend modes, we need to read back from the framebuffer
+      // and do the blending in the pixel shader. we do this with StretchRect
+      // rather than trying to render-to-texture-all-along, because we want
+      // to be able to render over the user's existing framebuffer, which might
+      // not be a texture. note that this causes MSAA issues!
+      if (r->blend_mode == GDRAW_BLEND_special &&
+          (blend_tex = get_color_rendertarget(stats)) != NULL) {
+
+         IDirect3DSurface9 *src;
+         HRESULT hr = d3d->GetRenderTarget(0, &src);
+         if (!FAILED(hr)) {
+            IDirect3DSurface9 *dest;
+            hr = blend_tex->handle.tex.d3d->GetSurfaceLevel(0, &dest);
+            if (!FAILED(hr)) {
+               RECT drect = { 0, 0, gdraw->tpw, gdraw->tph };
+               RECT srect;
+
+               if (gdraw->cur != gdraw->frame)
+                  srect = drect;
+               else {
+                  srect.left   = gdraw->vx;
+                  srect.top    = gdraw->vy;
+                  srect.right  = gdraw->vx + gdraw->tw;
+                  srect.bottom = gdraw->vy + gdraw->th;
+                  drect.left   = gdraw->tx0 - gdraw->tx0p;
+                  drect.top    = gdraw->ty0 - gdraw->ty0p;
+                  drect.right  = drect.left + gdraw->tw;
+                  drect.bottom = drect.top + gdraw->th;
+               }
+
+               d3d->StretchRect(src, &srect, dest, &drect, D3DTEXF_POINT);
+               dest->Release();
+
+               stats->nonzero_flags |= GDRAW_STATS_blits;
+               stats->num_blits += 1;
+               stats->num_blit_pixels += (srect.right - srect.left) * (srect.bottom - srect.top);
+            }
+
+            src->Release();
+         }
+
+         set_texture(1, (GDrawTexture *) blend_tex);
+         // make sure we set color_add, because the shader reads it
+         if (!r->cxf_add)
+            r->cxf_add = zero;
+      }
+
+      if (!set_renderstate(GDRAW_vformat_v2tc2, r, stats))
+         return;
+
+      do_screen_quad(&s, tc, stats);
+      tag_resources(r->tex[0], r->tex[1]);
+      if (blend_tex)
+         gdraw_FreeTexture((GDrawTexture *) blend_tex, 0, stats);
+   }
+}
+
+///////////////////////////////////////////////////////////////////////
+//
+//   Shaders
+//
+
+#include "gdraw_d3d9_shaders.inl"
+
+static void create_pixel_shader(ProgramWithCachedVariableLocations *p, ProgramWithCachedVariableLocations *src)
+{
+   *p = *src;
+   if(p->bytecode) {
+      HRESULT hr = gdraw->d3d_device->CreatePixelShader(p->bytecode, &p->pshader);
+      if (FAILED(hr)) {
+         IggyGDrawSendWarning(NULL, "GDraw D3D error creating pixel shader: 0x%08x", hr);
+         p->pshader = NULL;
+      }
+   }
+}
+
+static void create_vertex_shader(ProgramWithCachedVariableLocations *p, ProgramWithCachedVariableLocations *src)
+{
+   *p = *src;
+   if(p->bytecode) {
+      HRESULT hr = gdraw->d3d_device->CreateVertexShader(p->bytecode, &p->vshader);
+      if (FAILED(hr)) {
+         IggyGDrawSendWarning(NULL, "GDraw D3D error creating vertex shader: 0x%08x", hr);
+         p->vshader = NULL;
+      }
+   }
+}
+
+static void destroy_shader(ProgramWithCachedVariableLocations *p)
+{
+   safe_release(p->pshader);
+}
+
+static void create_all_shaders(void)
+{
+   S32 i;
+
+   for (i=0; i < GDRAW_TEXTURE__count*3; ++i)       create_pixel_shader(&gdraw->fprog[0][i], pshader_basic_arr + i);
+   for (i=0; i < GDRAW_BLENDSPECIAL__count; ++i)    create_pixel_shader(&gdraw->exceptional_blend[i], pshader_exceptional_blend_arr + i);
+   for (i=0; i < 32; ++i)                           create_pixel_shader(&gdraw->filter_prog[0][i], pshader_filter_arr + i);
+   for (i=0; i < MAX_TAPS+1; ++i)                   create_pixel_shader(&gdraw->blur_prog[i], pshader_blur_arr + i);
+   create_pixel_shader(&gdraw->colormatrix, pshader_color_matrix_arr);
+   create_pixel_shader(&gdraw->manual_clear, pshader_manual_clear_arr);
+
+   for (i=0; i < GDRAW_vformat__count; i++) {
+      HRESULT hr = gdraw->d3d_device->CreateVertexDeclaration(vformats[i], &gdraw->vdec[i]);
+      if (FAILED(hr))
+         IggyGDrawSendWarning(NULL, "GDraw D3D error in CreateVertexDeclaration: 0x%08x", hr);
+
+      create_vertex_shader(&gdraw->vert[i], vshader_vsd3d9_arr + i);
+   }
+}
+
+static void destroy_all_shaders()
+{
+   S32 i;
+
+   for (i=0; i < GDRAW_TEXTURE__count*3; ++i)       destroy_shader(&gdraw->fprog[0][i]);
+   for (i=0; i < GDRAW_BLENDSPECIAL__count; ++i)    destroy_shader(&gdraw->exceptional_blend[i]);
+   for (i=0; i < 32; ++i)                           destroy_shader(&gdraw->filter_prog[0][i]);
+   for (i=0; i < MAX_TAPS+1; ++i)                   destroy_shader(&gdraw->blur_prog[i]);
+   destroy_shader(&gdraw->colormatrix);
+
+   for (i=0; i < GDRAW_vformat__count; i++) {
+      if (gdraw->vdec[i]) { gdraw->vdec[i]->Release(); gdraw->vdec[i] = 0; }
+      destroy_shader(&gdraw->vert[i]);
+   }
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+//   Create and tear-down the state
+//
+
+typedef struct
+{
+   S32 num_handles;
+   S32 num_bytes;
+} GDrawResourceLimit;
+
+// These are the defaults limits used by GDraw unless the user specifies something else.
+static GDrawResourceLimit gdraw_limits[ASSERT_COUNT(GDRAW_D3D_RESOURCE__count, 3)] = {
+   MAX_RENDER_STACK_DEPTH + 1, 16*1024*1024,  // GDRAW_D3D_RESOURCE_rendertarget
+    500,                       16*1024*1024,  // GDRAW_D3D_RESOURCE_texture
+   1000,                        2*1024*1024,  // GDRAW_D3D_RESOURCE_vertexbuffer
+};
+
+static GDrawHandleCache *make_handle_cache(gdraw_d3d_resourcetype type)
+{
+   S32 num_handles = gdraw_limits[type].num_handles;
+   S32 num_bytes = gdraw_limits[type].num_bytes;
+   GDrawHandleCache *cache = (GDrawHandleCache *) IggyGDrawMalloc(sizeof(GDrawHandleCache) + (num_handles - 1) * sizeof(GDrawHandle));
+   if (cache) {
+      gdraw_HandleCacheInit(cache, num_handles, num_bytes);
+      cache->is_vertex = (type == GDRAW_D3D_RESOURCE_vertexbuffer);
+   }
+
+   return cache;
+}
+
+static void free_gdraw()
+{
+   if (!gdraw) return;
+   if (gdraw->texturecache) IggyGDrawFree(gdraw->texturecache);
+   if (gdraw->vbufcache) IggyGDrawFree(gdraw->vbufcache);
+   IggyGDrawFree(gdraw);
+   gdraw = NULL;
+}
+
+int gdraw_D3D_SetResourceLimits(gdraw_d3d_resourcetype type, S32 num_handles, S32 num_bytes)
+{
+   GDrawStats stats={0};
+
+   if (type == GDRAW_D3D_RESOURCE_rendertarget) // RT count is small and space is preallocated
+      num_handles = MAX_RENDER_STACK_DEPTH + 1;
+
+   assert(type >= GDRAW_D3D_RESOURCE_rendertarget && type < GDRAW_D3D_RESOURCE__count);
+   assert(num_handles >= 0);
+   assert(num_bytes >= 0);
+
+   // nothing to do if the values are unchanged
+   if (gdraw_limits[type].num_handles == num_handles &&
+      gdraw_limits[type].num_bytes == num_bytes)
+      return 1;
+
+   gdraw_limits[type].num_handles = num_handles;
+   gdraw_limits[type].num_bytes = num_bytes;
+
+   // if no gdraw context created, there's nothing to worry about
+   if (!gdraw)
+      return 1;
+
+   // resize the appropriate pool
+   switch (type) {
+      case GDRAW_D3D_RESOURCE_rendertarget:
+         flush_rendertargets(&stats);
+         gdraw_HandleCacheInit(&gdraw->rendertargets, num_handles, num_bytes);
+         return 1;
+         
+      case GDRAW_D3D_RESOURCE_texture:
+         if (gdraw->texturecache) {
+            gdraw_res_flush(gdraw->texturecache, &stats);
+            IggyGDrawFree(gdraw->texturecache);
+         }
+         gdraw->texturecache = make_handle_cache(GDRAW_D3D_RESOURCE_texture);
+         return gdraw->texturecache != NULL;
+
+      case GDRAW_D3D_RESOURCE_vertexbuffer:
+         if (gdraw->vbufcache) {
+            gdraw_res_flush(gdraw->vbufcache, &stats);
+            IggyGDrawFree(gdraw->vbufcache);
+         }
+         gdraw->vbufcache = make_handle_cache(GDRAW_D3D_RESOURCE_vertexbuffer);
+         return gdraw->vbufcache != NULL;
+
+      default:
+         return 0;
+   }
+}
+
+GDrawFunctions *gdraw_D3D_CreateContext(IDirect3DDevice9 *dev, S32 w, S32 h)
+{
+   gdraw = (GDraw *) IggyGDrawMalloc(sizeof(*gdraw));
+   if (!gdraw) return NULL;
+
+   memset(gdraw, 0, sizeof(*gdraw));
+
+   gdraw->frametex_width = w;
+   gdraw->frametex_height = h;
+
+   gdraw->texturecache = make_handle_cache(GDRAW_D3D_RESOURCE_texture);
+   gdraw->vbufcache = make_handle_cache(GDRAW_D3D_RESOURCE_vertexbuffer);
+   gdraw_HandleCacheInit(&gdraw->rendertargets, gdraw_limits[GDRAW_D3D_RESOURCE_rendertarget].num_handles, gdraw_limits[GDRAW_D3D_RESOURCE_rendertarget].num_bytes);
+
+   if (!gdraw->texturecache || !gdraw->vbufcache) {
+      free_gdraw();
+      return NULL;
+   }
+
+   if (!quad_ib[1]) {
+      // initialize quad index buffer
+      for (U16 i=0; i < QUAD_IB_COUNT; i++) {
+         quad_ib[i*6 + 0] = i*4 + 0;
+         quad_ib[i*6 + 1] = i*4 + 1;
+         quad_ib[i*6 + 2] = i*4 + 2;
+         quad_ib[i*6 + 3] = i*4 + 0;
+         quad_ib[i*6 + 4] = i*4 + 2;
+         quad_ib[i*6 + 5] = i*4 + 3;
+      }
+   }
+
+   #if 1
+   D3DCAPS9 caps;
+   dev->GetDeviceCaps(&caps);
+   gdraw->conditional_nonpow2 = ((caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) != 0);
+   #endif
+
+   gdraw->d3d_device = dev;
+   create_all_shaders();
+
+   gdraw_funcs.SetViewSizeAndWorldScale = gdraw_SetViewSizeAndWorldScale;
+   gdraw_funcs.GetInfo       = gdraw_GetInfo;
+
+   gdraw_funcs.DescribeTexture = gdraw_DescribeTexture;
+   gdraw_funcs.DescribeVertexBuffer = gdraw_DescribeVertexBuffer;
+
+   gdraw_funcs.RenderingBegin  = gdraw_RenderingBegin;
+   gdraw_funcs.RenderingEnd    = gdraw_RenderingEnd;
+   gdraw_funcs.RenderTileBegin = gdraw_RenderTileBegin;
+   gdraw_funcs.RenderTileEnd = gdraw_RenderTileEnd;
+
+   gdraw_funcs.TextureDrawBufferBegin = gdraw_TextureDrawBufferBegin;
+   gdraw_funcs.TextureDrawBufferEnd = gdraw_TextureDrawBufferEnd;
+
+   gdraw_funcs.DrawIndexedTriangles = gdraw_DrawIndexedTriangles;
+   gdraw_funcs.FilterQuad = gdraw_FilterQuad;
+
+   gdraw_funcs.SetAntialiasTexture = gdraw_SetAntialiasTexture;
+
+   gdraw_funcs.ClearStencilBits = gdraw_ClearStencilBits;
+   gdraw_funcs.ClearID = gdraw_ClearID;
+
+   gdraw_funcs.MakeTextureBegin = gdraw_MakeTextureBegin;
+   gdraw_funcs.MakeTextureMore  = gdraw_MakeTextureMore;
+   gdraw_funcs.MakeTextureEnd   = gdraw_MakeTextureEnd;
+
+   gdraw_funcs.UpdateTextureBegin = gdraw_UpdateTextureBegin;
+   gdraw_funcs.UpdateTextureRect  = gdraw_UpdateTextureRect;
+   gdraw_funcs.UpdateTextureEnd   = gdraw_UpdateTextureEnd;
+
+   gdraw_funcs.FreeTexture = gdraw_FreeTexture;
+   gdraw_funcs.TryToLockTexture = gdraw_TryToLockTexture;
+
+   gdraw_funcs.MakeTextureFromResource = (gdraw_make_texture_from_resource *) gdraw_D3D_MakeTextureFromResource;
+   gdraw_funcs.FreeTextureFromResource = gdraw_D3D_DestroyTextureFromResource;
+
+   gdraw_funcs.MakeVertexBufferBegin = gdraw_MakeVertexBufferBegin;
+   gdraw_funcs.MakeVertexBufferMore  = gdraw_MakeVertexBufferMore;
+   gdraw_funcs.MakeVertexBufferEnd   = gdraw_MakeVertexBufferEnd;
+   gdraw_funcs.TryToLockVertexBuffer = gdraw_TryLockVertexBuffer;
+   gdraw_funcs.FreeVertexBuffer = gdraw_FreeVertexBuffer;
+
+   gdraw_funcs.UnlockHandles = gdraw_UnlockHandles;
+   gdraw_funcs.SetTextureUniqueID = gdraw_SetTextureUniqueID;
+   gdraw_funcs.Set3DTransform = gdraw_Set3DTransform;
+
+   return &gdraw_funcs;
+}
+
+void gdraw_D3D_DestroyContext(void)
+{
+   if (gdraw && gdraw->d3d_device) {
+      GDrawStats stats={0};
+      destroy_all_shaders();
+      gdraw_res_flush(gdraw->texturecache, &stats);
+      gdraw_res_flush(gdraw->vbufcache, &stats);
+      flush_rendertargets(&stats);
+
+      safe_release(gdraw->aa_tex);
+      gdraw->d3d_device = NULL;
+   }
+
+   free_gdraw();
+}
+
+void gdraw_D3D_SetErrorHandler(void (__cdecl *error_handler)(HRESULT hr))
+{
+   if (gdraw)
+      gdraw->error_handler = error_handler;
+}
+
+void gdraw_D3D_PreReset(void)
+{
+   if (!gdraw) return;
+
+   GDrawStats stats={0};
+   flush_rendertargets(&stats);
+
+   // we may end up resizing the frame buffer
+   gdraw->frametex_width = 0;
+   gdraw->frametex_height = 0;
+}
+
+void gdraw_D3D_PostReset(void)
+{
+   // maybe re-create rendertargets right now?
+}
+
+void RADLINK gdraw_D3D_BeginCustomDraw(IggyCustomDrawCallbackRegion *region, D3DMATRIX *mat)
+{
+   clear_renderstate();
+   gdraw_GetObjectSpaceMatrix(mat->m[0], region->o2w, gdraw->projection, 0, 0);
+}
+
+void RADLINK gdraw_D3D_EndCustomDraw(IggyCustomDrawCallbackRegion * /*region*/)
+{
+   set_common_renderstate();
+   set_projection();
+}
+
+void RADLINK gdraw_D3D_GetResourceUsageStats(gdraw_d3d_resourcetype type, S32 *handles_used, S32 *bytes_used)
+{
+   GDrawHandleCache *cache;
+
+   switch (type) {
+      case GDRAW_D3D_RESOURCE_rendertarget:  cache = &gdraw->rendertargets; break;
+      case GDRAW_D3D_RESOURCE_texture:       cache = gdraw->texturecache; break;
+      case GDRAW_D3D_RESOURCE_vertexbuffer:  cache = gdraw->vbufcache; break;
+      default:                               cache = NULL; break;
+   }
+
+   *handles_used = *bytes_used = 0;
+
+   if (cache) {
+      S32 i;
+      U64 frame = gdraw->frame_counter;
+
+      for (i=0; i < cache->max_handles; ++i)
+         if (cache->handle[i].bytes && cache->handle[i].owner && cache->handle[i].fence.value == frame) {
+            *handles_used += 1;
+            *bytes_used += cache->handle[i].bytes;
+         }
+   }
+}
+
+GDrawTexture * RADLINK gdraw_D3D_MakeTextureFromResource(U8 *resource_file, S32 /*len*/, IggyFileTextureRaw *texture)
+{
+   GDrawTexture *h;
+   S32 width, height, mipmaps, size;
+   IDirect3DTexture9 *tex;
+   D3DFORMAT d3dfmt;
+   width = texture->w;
+   height = texture->h;
+   mipmaps = texture->mipmaps;
+
+   // discard mipmaps on non-pow-of-2 if the hardware doesn't support
+   if (gdraw->conditional_nonpow2) {
+      if ((width & (width-1)) || (height & (height-1)))
+         mipmaps = 1;
+   }
+
+   switch (texture->format) {
+      case IFT_FORMAT_rgba_8888   : size= 4; d3dfmt = D3DFMT_A8R8G8B8; break;
+      case IFT_FORMAT_rgba_4444_LE: size= 2; d3dfmt = D3DFMT_A4R4G4B4; break;
+      case IFT_FORMAT_rgba_5551_LE: size= 2; d3dfmt = D3DFMT_A1R5G5B5; break;
+      case IFT_FORMAT_la_88       : size= 2; d3dfmt = D3DFMT_A8L8; break;
+      case IFT_FORMAT_la_44       : size= 1; d3dfmt = D3DFMT_A4L4; break;
+      case IFT_FORMAT_i_8         :  
+      case IFT_FORMAT_i_4         : size= 2; d3dfmt = D3DFMT_A8L8; break;
+      case IFT_FORMAT_l_8         : size= 1; 
+      case IFT_FORMAT_l_4         : size= 1; d3dfmt = D3DFMT_L8; break;
+      case IFT_FORMAT_DXT1        : size= 8; d3dfmt = D3DFMT_DXT1; break;
+      case IFT_FORMAT_DXT3        : size=16; d3dfmt = D3DFMT_DXT3; break;
+      case IFT_FORMAT_DXT5        : size=16; d3dfmt = D3DFMT_DXT5; break;
+      default: size=0; d3dfmt=D3DFMT_UNKNOWN; break;
+   }
+
+   HRESULT hr = gdraw->d3d_device->CreateTexture(width, height, mipmaps,
+                                         0, d3dfmt, D3DPOOL_MANAGED, &tex, NULL);
+   if (FAILED(hr)) {
+      if (size >= 8 && ((width & 3) || (height & 3)))
+         IggyGDrawSendWarning(NULL, "GDraw D3D error, dxtc texture dimensions must be multiples of 4");
+      else 
+         report_d3d_error(hr, "CreateTexture", "");
+      return NULL;
+   }
+
+   U8 *data = resource_file + texture->file_offset;
+
+   for (int level=0; level < mipmaps; ++level) {
+      S32 dxt_width = (width+3)/4;
+      S32 effective_height;
+      if (size >= 8)
+         effective_height = (height+3)/4;
+      else
+         effective_height = height;
+
+      D3DLOCKED_RECT z;
+      hr = tex->LockRect(level, &z, NULL, 0);
+      if (FAILED(hr)) {
+         report_d3d_error(hr, "LockRect", " while creating texture");
+         tex->Release();
+         return NULL;
+      }
+      U8 *pixels = (U8*) z.pBits;
+      for (S32 j=0; j < effective_height; ++j) {
+         switch (texture->format) {
+            default:
+               memcpy(pixels + z.Pitch*j, data + j*width*size, width*size);
+               break;
+            case IFT_FORMAT_rgba_8888: {
+               for (S32 i=0; i < width; ++i) {
+                  pixels[z.Pitch*j + i*4 + 0] = data[j*width*4 + i*4 + 2];
+                  pixels[z.Pitch*j + i*4 + 1] = data[j*width*4 + i*4 + 1];
+                  pixels[z.Pitch*j + i*4 + 2] = data[j*width*4 + i*4 + 0];
+                  pixels[z.Pitch*j + i*4 + 3] = data[j*width*4 + i*4 + 3];
+               }
+               break;
+            }
+            case IFT_FORMAT_DXT1:
+            case IFT_FORMAT_DXT3:
+            case IFT_FORMAT_DXT5:
+               memcpy(pixels + z.Pitch*j, data + j*dxt_width*size, dxt_width*size);
+               break;
+            case IFT_FORMAT_i_8:  
+            case IFT_FORMAT_i_4: {
+               // convert from intensity to luminance-alpha by replicating all the pixels
+               for (S32 i=0; i < width; ++i)
+                  pixels[z.Pitch*j + i*2 + 0] = 
+                  pixels[z.Pitch*j + i*2 + 1] = data[j*width + i];
+               break;
+            }
+         }
+      }
+      tex->UnlockRect(level);
+
+      data += (size<8) ? width*height*size : ((width+3)/4)*((height+3)/4)*size;
+      width  = width >>1; width  += !width ;
+      height = height>>1; height += !height;
+   }
+   
+   h = gdraw_D3D_WrappedTextureCreate(tex);
+   if (!h) tex->Release();
+   return h;
+}
+
+void RADLINK gdraw_D3D_DestroyTextureFromResource(GDrawTexture *tex)
+{
+   GDrawHandle *h = (GDrawHandle *) tex;
+   h->handle.tex.d3d->Release();
+   gdraw_D3D_WrappedTextureDestroy(tex);
+}
+