Karutoh/MinecraftConsoles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d31d261ffd707aabfd8715d3bc2cbf2e6fbc3fcd
MinecraftConsoles/Minecraft.Client/Windows64/Iggy/gdraw/gdraw_d3d.cpp
daoge_cmd b691c43c44 Initial commit
2026-03-01 12:16:08 +08:00

2229 lines
74 KiB
C++
Raw Blame History

// 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);
}
Reference in New Issue View Git Blame Copy Permalink