mirror of
https://github.com/4jcraft/4jcraft.git
synced 2026-07-28 09:42:26 +00:00
153 lines
7.4 KiB
C
153 lines
7.4 KiB
C
#pragma once
|
|
// gdraw_d3d10.h - author: Fabian Giesen - copyright 2011 RAD Game Tools
|
|
//
|
|
// Interface for creating a D3D10 GDraw driver.
|
|
|
|
#define IDOC
|
|
// idoc(parent,GDraw_d3d10)
|
|
|
|
typedef enum gdraw_d3d10_resourcetype {
|
|
GDRAW_D3D10_RESOURCE_rendertarget,
|
|
GDRAW_D3D10_RESOURCE_texture,
|
|
GDRAW_D3D10_RESOURCE_vertexbuffer,
|
|
GDRAW_D3D10_RESOURCE_dynbuffer, // Streaming buffer for dynamic
|
|
// vertex/index data (handle count ignored)
|
|
|
|
GDRAW_D3D10_RESOURCE__count,
|
|
} gdraw_d3d10_resourcetype;
|
|
|
|
IDOC extern int gdraw_D3D10_SetResourceLimits(gdraw_d3d10_resourcetype type,
|
|
S32 num_handles, S32 num_bytes);
|
|
/* This sets how large the memory pool for a given resource types is, and how
|
|
many handles GDraw should allocate for it. GDraw keeps track of allocations
|
|
in each pool, and will free old resources in a LRU manner to make space if
|
|
one of the limits is about to be exceeded.
|
|
|
|
Returns 1 if value successfully changed, 0 on error.
|
|
You need to call IggyPlayerFlushAll on all active Iggys before you do this to
|
|
make them flush their resources since changing the resource limits
|
|
invalidates all handles. You also need to call IggyFlushInstalledFonts if you
|
|
have any installed fonts.
|
|
*/
|
|
|
|
IDOC extern GDrawFunctions* gdraw_D3D10_CreateContext(ID3D10Device* dev, S32 w,
|
|
S32 h);
|
|
/* Creates a GDraw context for rendering using D3D. You need to pass in the D3D
|
|
device and the width/height of render target textures.
|
|
|
|
The width/height is used solely for sizing internal rendertargets. They will
|
|
be allocated to the larger of this size and the size of any rendered tiles
|
|
(with padding). In other words, you can pass in (0,0) and the rendertargets
|
|
will be allocated to the right size. However, if you draw multiple Iggy files
|
|
or tiles of different sizes, they might first be allocated too small; it's
|
|
best to pass in the correct size initially to avoid unnecessary
|
|
allocation/deallocation of too-small rendertargets.
|
|
|
|
There can only be one D3D GDraw context active at any one time.
|
|
|
|
If initialization fails for some reason (the main reason would be an out of
|
|
memory condition), NULL is returned. Otherwise, you can pass the return value
|
|
to IggySetGDraw. */
|
|
|
|
IDOC extern void gdraw_D3D10_DestroyContext(void);
|
|
/* Destroys the current GDraw context, if any. */
|
|
|
|
IDOC extern void gdraw_D3D10_SetErrorHandler(
|
|
void(__cdecl* error_handler)(HRESULT hr));
|
|
/* Sets the GDraw D3D error handler.
|
|
|
|
This will get called with the respective D3D error code if GDraw encounters
|
|
an error that it can't handle by itself (e.g. running out of state objects).
|
|
*/
|
|
|
|
IDOC extern void gdraw_D3D10_SetRendertargetSize(S32 w, S32 h);
|
|
/* Changes the current render target size (and recreates all rendertargets if
|
|
necessary). This allows you to shrink the rendertargets if the new needed
|
|
size is smaller than it was previously. As with $gdraw_D3D10_CreateContext,
|
|
the width and height specified here are only minimums; GDraw will reallocate
|
|
larger rendertargets as needed. */
|
|
|
|
IDOC extern void gdraw_D3D10_SetTileOrigin(
|
|
ID3D10RenderTargetView* main_rt, ID3D10DepthStencilView* main_ds,
|
|
ID3D10ShaderResourceView* non_msaa_rt, S32 x, S32 y);
|
|
/* This sets the main rendertarget and matching depth/stencil buffer that GDraw
|
|
should render to and the x/y position of the output location of the top-left
|
|
of the current tile (allowing you to finely-position content, or to do tiled
|
|
rendering).
|
|
|
|
If your rendertarget uses multisampling, you also need to specify a shader
|
|
resource view for a non-MSAA rendertarget texture (identically sized to
|
|
main_rt) in non_msaa_rt. This is only used if the Flash content includes
|
|
non-standard blend modes which have to use a special blend shader, so you can
|
|
leave it NULL if you forbid such content.
|
|
|
|
You need to call this before Iggy calls any rendering functions. */
|
|
|
|
IDOC extern void gdraw_D3D10_NoMoreGDrawThisFrame(void);
|
|
/* Tells GDraw that no more rendering operations will occur this frame. This
|
|
triggers some end-of-frame processing; most importantly, GDraw uses this call
|
|
as a marker to detect thrashing (and react accordingly), so please do not
|
|
forget to call this every frame! (As long as Iggy does any rendering, that
|
|
is) */
|
|
|
|
IDOC extern void gdraw_D3D10_PreReset(void);
|
|
/* Call this before D3D device Reset(); it will free all default pool resources
|
|
allocated by GDraw. */
|
|
|
|
IDOC extern void gdraw_D3D10_PostReset(void);
|
|
/* Call after D3D device Reset(). */
|
|
|
|
IDOC extern void RADLINK gdraw_D3D10_BeginCustomDraw(
|
|
IggyCustomDrawCallbackRegion* Region, F32 mat[4][4]);
|
|
/* Call at the beginning of Iggy custom draw callback to clear any odd render
|
|
states GDraw has set on the D3D device, and to get the current 2D
|
|
object-to-world transformation. */
|
|
|
|
IDOC extern void RADLINK
|
|
gdraw_D3D10_EndCustomDraw(IggyCustomDrawCallbackRegion* Region);
|
|
/* Call at the end of Iggy custom draw callback so GDraw can restore its render
|
|
* states. */
|
|
|
|
IDOC extern void RADLINK gdraw_D3D10_GetResourceUsageStats(
|
|
gdraw_d3d10_resourcetype type, S32* handles_used, S32* bytes_used);
|
|
/* D3D only: Get resource usage stats for last frame.
|
|
This can be used to get an estimate of how much graphics memory got used by
|
|
GDraw during the last frame.
|
|
|
|
For the dynbuffer, this always returns 0 in handles_used and the *size of the
|
|
largest single allocation* in bytes_used. It needs to be sized so that this
|
|
allocation fits; make it smaller and it won't work, but if you make it much
|
|
larger (say more than 2x as big), it's just a waste of memory. That said, we
|
|
still recommend to make it no smaller than 64k, and the default is 256k.
|
|
|
|
Caveat: This counts the number of bytes that GDraw knows about. 3D hardware
|
|
usually has its own management overhead, alignment requirements, allocation
|
|
granularity and so on. In short, this is not an accurate estimate of how much
|
|
memory is actually used by the GPU - it is a lower bound, though, and makes
|
|
for a useful ballpark estimate. */
|
|
|
|
IDOC extern GDrawTexture* gdraw_D3D10_WrappedTextureCreate(
|
|
ID3D10ShaderResourceView* tex_view);
|
|
/* Create a wrapped texture from a shader resource view.
|
|
A wrapped texture can be used to let Iggy draw using the contents of a
|
|
texture you create and manage on your own. For example, you might render to
|
|
this texture, or stream video into it. Wrapped textures take up a handle.
|
|
They will never be freed or otherwise modified by GDraw; nor will GDraw
|
|
change any reference counts. All this is up to the application. */
|
|
|
|
IDOC extern void gdraw_D3D10_WrappedTextureChange(
|
|
GDrawTexture* tex, ID3D10ShaderResourceView* tex_view);
|
|
/* Switch an existing GDrawTexture * that represents a wrapped texture to use
|
|
a new underlying D3D view. For example, you might internally double-buffer
|
|
a dynamically updated texture. As above, GDraw will leave this texture alone
|
|
and not touch any reference counts. */
|
|
|
|
IDOC extern void gdraw_D3D10_WrappedTextureDestroy(GDrawTexture* tex);
|
|
/* Destroys the GDraw wrapper for a wrapped texture object. This will free up
|
|
a GDraw texture handle but not release the associated D3D texture; that is
|
|
up to you. */
|
|
|
|
extern GDrawTexture* RADLINK gdraw_D3D10_MakeTextureFromResource(
|
|
U8* resource_file, S32 length, IggyFileTextureRaw* texture);
|
|
extern void RADLINK gdraw_D3D10_DestroyTextureFromResource(GDrawTexture* tex);
|