first commit

Minecraft.Client/Orbis/Iggy/gdraw/gdraw_orbis.h

@@ -0,0 +1,196 @@
+#pragma once // 4J
+
+// gdraw_orbis.h - author: Fabian Giesen - copyright 2012 RAD Game Tools
+//
+// Interface for creating an Orbis GDraw driver.
+
+#include "gdraw.h"
+
+#define IDOC
+//idoc(parent,GDraw_orbis)
+
+// Size and alignment requirements of GDraw context memory.
+#define GDRAW_ORBIS_CONTEXT_MEM_SIZE            (64*1024)
+
+// Alignment requirements for different resource types
+#define GDRAW_ORBIS_TEXTURE_ALIGNMENT           256  // NOTE this may change in the future!
+#define GDRAW_ORBIS_VERTEXBUFFER_ALIGNMENT      256  // NOTE this may change in the future!
+
+typedef enum gdraw_orbis_resourcetype
+{
+   GDRAW_ORBIS_RESOURCE_rendertarget,        // put in video private memory if possible, must be GPU visible
+   GDRAW_ORBIS_RESOURCE_texture,             // put in video private memory if possible, must be GPU visible
+   GDRAW_ORBIS_RESOURCE_vertexbuffer,        // put in any GPU visible memory
+
+   GDRAW_ORBIS_RESOURCE__count,
+} gdraw_orbis_resourcetype;
+
+typedef struct
+{
+   U32 allocs_attempted;         // number of allocations attempted from the staging buffer
+   U32 allocs_succeeded;         // number of allocations that succeeded
+   U32 bytes_attempted;          // number of bytes attempted to allocate
+   U32 bytes_succeeded;          // number of bytes successfully allocated
+   U32 largest_bytes_attempted;  // number of bytes in largest attempted alloc
+   U32 largest_bytes_succeeded;  // number of bytes in lagrest successful alloc
+} gdraw_orbis_staging_stats;
+
+IDOC extern int gdraw_orbis_SetResourceMemory(gdraw_orbis_resourcetype type, S32 num_handles, void *ptr, S32 num_bytes);
+/* Sets up the resource pools that GDraw uses for its video memory management.
+   
+   It sets both the number of handles and the address and size of memory to use.
+   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. It will
+   also automatically defragment memory if necessary to fulfill an allocation
+   request.
+
+   You need to set up all of the resource pools before you can start rendering.
+   If you modify this at runtime, you need to call IggyPlayerFlushAll on all
+   active Iggys (if any) since this call invalidates all resource handles they
+   currently hold.
+
+   SetResourceMemory takes a void* argument for the address of the resource pool.
+   Pass in NULL and zero bytes to reset a specific pool.
+
+   Resource pool memory has certain alignment requirements - see the #defines
+   above. If you pass in an unaligned pointer, GDraw will automatically clip off
+   some bytes at the front to make the buffer aligned - in other words, you get
+   somewhat less usable bytes, but it should work fine.
+
+   "rendertarget" memory is only used during Iggy rendering. In other words, you
+   are free to use that memory for other purposes such as your own render targets
+   or depth buffers as long as it doesn't need to be preserved across IggyPlayerDraw*
+   calls. 
+
+   If any Iggy draw calls are in flight, this call will block waiting for
+   those calls to finish (i.e. for the resource memory to become
+   unused).
+*/
+
+IDOC extern void gdraw_orbis_ResetAllResourceMemory();
+/* Frees all resource pools managed by GDraw.
+
+   Use this as a quick way of freeing (nearly) all memory allocated by GDraw
+   without shutting it down completely. For example, you might want to use this
+   to quickly flush all memory allocated by GDraw when transitioning between the
+   main menu and the game proper. Like with SetResourceMemory, you need to call
+   IggyPlayerFlushAll on all currently active Iggy players if you do this - although
+   we recommend that you only use this function when there aren't any. */
+
+IDOC extern GDrawFunctions * gdraw_orbis_CreateContext(S32 w, S32 h, void *context_mem);
+/* Creates a GDraw context for rendering using GNM. You need to pass in the width/height
+   of the Iggy content for use by internal render targets. context_mem must point to an
+   area in video shared memory that is GDRAW_ORBIS_CONTEXT_MEM_SIZE bytes big - this is
+   used by GDraw to store labels and shaders in.
+
+   There can only be one 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_orbis_DestroyContext(void);
+/* Destroys the current GDraw context, if any.
+
+   If any Iggy draw calls are in flight, this call will block waiting for
+   those calls to finish (i.e. for the resource memory to become
+   unused).
+*/
+
+IDOC extern void gdraw_orbis_Begin(sce::Gnmx::GfxContext *context, void *staging_buffer, U32 staging_buf_bytes);
+/* This sets the GfxContext that GDraw writes its commands to. It also sets the
+   address and size of the staging buffer used for dynamic vertex data and in-frame
+   resource uploads. Any GDraw / Iggy rendering calls outside a Begin / End bracket
+   are an error and will be treated as such. The GfxContext must be live during the
+   entire Begin / End bracket.
+
+   GDraw maintains a persistent resource cache shared across all Iggys. Because of this,
+   it is *vital* that all GfxContexts generated from GDraw be kicked in the order
+   they were generated, or the resource pools might get corrupted. Hence it's recommended
+   to use only one GfxContext for all Iggy rendering during a frame.
+
+   The staging buffer should be allocated in write-combined memory. If it is of insufficient
+   size, GDraw will not be able to allocate dynamic vertex data or upload new texture/vertex
+   buffer data during some frames, resulting in glitching! (When this happens, it will be
+   reported as a warning, so make sure to install a warning callback).
+
+   The user is expected to handle GfxContext and staging buffer synchronization; there are
+   no safeguards on the GDraw side to prevent CPU-GPU race conditions. Please make sure that
+   the GPU is finished with a GfxContext / staging buffer before reusing its memory!
+   Typically, this would be accomplished by double buffering everything. */
+
+IDOC extern void gdraw_orbis_End(gdraw_orbis_staging_stats *staging_stats);
+/* This marks the end of GDraw rendering for a frame. It also triggers end-of-frame processing,
+   which is important for GDraw's internal resource management. GDraw will not touch the GfxContext
+   or staging buffer after this call, so you are free to append other rendering commands after
+   this call returns.
+   
+   staging_stats will be filled with stats for the staging buffer, denoting how much memory
+   was actually used and which allocations were attempted. If you're not interested, just
+   pass NULL. */
+
+IDOC extern void gdraw_orbis_SetTileOrigin(sce::Gnm::RenderTarget *color, sce::Gnm::DepthRenderTarget *depth, S32 x, S32 y);
+/* This sets the main color and depth buffers that GDraw should render to and the
+   x/y position of the output location of the top-left pixel of the current tile
+   (to be used for tiled rendering).
+   
+   You should call this inside a gdraw_orbis_Begin / gdraw_orbis_End bracket, before
+   any Iggy / GDraw rendering takes place. */
+
+IDOC extern void gdraw_orbis_ClearWholeRenderTarget(const F32 clear_color_rgba[4]);
+/* You typically need to clear the render target before you start Iggy rendering.
+
+   This is a convenience function, if you don't want to do the clear yourself. Fast clears
+   will be used if the render target has them enabled. Note that if fast clears are enabled,
+   you also need to call gdraw_orbis_EliminateFastClears once you're done with the render target
+   to make sure the clears are actually properly completed.
+
+   This counts as a rendering operation, so it must be called inside a
+   gdraw_orbis_Begin / gdraw_orbis_End bracket, after gdraw_orbis_SetTileOrigin has been called. */
+
+IDOC extern void gdraw_orbis_EliminateFastClears(void);
+/* If the render target specified in gdraw_orbis_SetTileOrigin has fast clears enabled, you
+   need to do a post-process step to make sure the clears get properly computed. This function
+   performs that step. If your render target doesn't have fast clears enabled, it simply does
+   nothing.
+
+   This counts as a rendering operation, so it must be called inside a
+   gdraw_orbis_Begin / gdraw_orbis_End bracket, after gdraw_orbis_SetTileOrigin has been called. */
+
+IDOC extern void RADLINK gdraw_orbis_CalculateCustomDraw_4J(IggyCustomDrawCallbackRegion *region, float matrix[16]);
+IDOC extern void RADLINK gdraw_orbis_BeginCustomDraw(IggyCustomDrawCallbackRegion *region, float matrix[16]);
+/* Call at the beginning of Iggy custom draw callback to clear any odd render states GDraw has
+   set, and to get the current 2D object-to-world transformation. */
+
+IDOC extern void RADLINK gdraw_orbis_EndCustomDraw(IggyCustomDrawCallbackRegion *region);
+/* Call at the end of Iggy custom draw callback so GDraw can restore its render states. */
+
+IDOC extern GDrawTexture *gdraw_orbis_WrappedTextureCreate(sce::Gnm::Texture *tex);
+/* Create a wrapped texture from a GNM texture.
+   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.
+   GDraw makes a copy of the contents of the Gnm::Texture (the contents of the struct
+   that is, not the data it points to). If you later modify the fields of "tex", you
+   need to call $gdraw_orbis_WrappedTextureChange.
+   */
+
+IDOC extern void gdraw_orbis_WrappedTextureChange(GDrawTexture *handle, sce::Gnm::Texture *tex);
+/* Switch an existing GDrawTexture * that represents a wrapped texture to use
+   a new underlying GNM texture. 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_orbis_WrappedTextureDestroy(GDrawTexture *handle);
+/* Destroys the GDraw wrapper for a wrapped texture object. This will free up
+   a GDraw texture handle but not release the associated GNM texture; that is
+   up to you. */
+
+IDOC extern GDrawTexture * RADLINK gdraw_orbis_MakeTextureFromResource(U8 *file_in_memory, S32 length, IggyFileTexturePS4 *tex);
+/* Sets up a texture loaded from a .sekrit2.iggytex file. */
+
+extern void RADLINK gdraw_orbis_DestroyTextureFromResource(GDrawTexture *tex);
+
+// 4J added
+extern void RADLINK gdraw_orbis_setViewport_4J();

Minecraft.Client/Orbis/Iggy/include/gdraw.h

@@ -0,0 +1,726 @@
+// gdraw.h - author: Sean Barrett - copyright 2009 RAD Game Tools
+//
+// This is the graphics rendering abstraction that Iggy is implemented
+// on top of.
+
+#ifndef __RAD_INCLUDE_GDRAW_H__
+#define __RAD_INCLUDE_GDRAW_H__
+
+#include "rrcore.h"
+
+#define IDOC
+
+RADDEFSTART
+
+//idoc(parent,GDrawAPI_Buffers) 
+
+#ifndef IGGY_GDRAW_SHARED_TYPEDEF
+
+   #define IGGY_GDRAW_SHARED_TYPEDEF
+   typedef struct GDrawFunctions GDrawFunctions;
+
+   typedef struct GDrawTexture GDrawTexture;
+
+#endif//IGGY_GDRAW_SHARED_TYPEDEF
+
+
+
+IDOC typedef struct GDrawVertexBuffer GDrawVertexBuffer;
+/* An opaque handle to an internal GDraw vertex buffer. */
+
+//idoc(parent,GDrawAPI_Base)
+
+IDOC typedef struct gswf_recti
+{
+   S32 x0,y0; // Minimum corner of the rectangle
+   S32 x1,y1; // Maximum corner of the rectangle
+} gswf_recti;
+/* A 2D rectangle with integer coordinates specifying its minimum and maximum corners. */
+
+IDOC typedef struct gswf_rectf
+{
+   F32 x0,y0; // Minimum corner of the rectangle
+   F32 x1,y1; // Maximum corner of the rectangle
+} gswf_rectf;
+/* A 2D rectangle with floating-point coordinates specifying its minimum and maximum corners. */
+
+IDOC typedef struct gswf_matrix
+{
+   union {
+      F32 m[2][2]; // 2x2 transform matrix 
+      struct {
+          F32 m00; // Alternate name for m[0][0], for coding convenience
+          F32 m01; // Alternate name for m[0][1], for coding convenience
+          F32 m10; // Alternate name for m[1][0], for coding convenience
+          F32 m11; // Alternate name for m[1][1], for coding convenience
+      };
+   };
+   F32 trans[2]; // 2D translation vector (the affine component of the matrix)
+} gswf_matrix;
+/* A 2D transform matrix plus a translation offset. */
+
+#define GDRAW_STATS_batches    1
+#define GDRAW_STATS_blits      2
+#define GDRAW_STATS_alloc_tex  4
+#define GDRAW_STATS_frees      8
+#define GDRAW_STATS_defrag     16
+#define GDRAW_STATS_rendtarg   32
+#define GDRAW_STATS_clears     64
+IDOC typedef struct GDrawStats
+{
+   S16 nonzero_flags;  // which of the fields below are non-zero
+
+   U16 num_batches;    // number of batches, e.g. DrawPrim, DrawPrimUP
+   U16 num_blits;      // number of blit operations (resolve, msaa resolve, blend readback)
+   U16 freed_objects;  // number of cached objects freed
+   U16 defrag_objects; // number of cached objects defragmented
+   U16 alloc_tex;      // number of textures/buffers allocated
+   U16 rendertarget_changes; // number of rendertarget changes
+   U16 num_clears;
+                                 //0 mod 8
+
+   U32 drawn_indices;  // number of indices drawn (3 times number of triangles)
+   U32 drawn_vertices; // number of unique vertices referenced
+   U32 num_blit_pixels;// number of pixels in blit operations
+   U32 alloc_tex_bytes;// number of bytes in textures/buffers allocated
+   U32 freed_bytes;    // number of bytes in freed cached objects
+   U32 defrag_bytes;   // number of bytes in defragmented cached objects
+   U32 cleared_pixels; // number of pixels cleared by clear operation
+   U32 reserved;
+                                 //0 mod 8
+} GDrawStats;
+/* A structure with statistics information to show in resource browser/Telemetry */
+
+////////////////////////////////////////////////////////////
+//
+// Queries
+//
+//idoc(parent,GDrawAPI_Queries)
+
+IDOC typedef enum gdraw_bformat
+{
+   GDRAW_BFORMAT_vbib, // Platform uses vertex and index buffers
+   GDRAW_BFORMAT_wii_dlist, // Platform uses Wii-style display lists
+   GDRAW_BFORMAT_vbib_single_format, // Platform uses vertex and index buffers, but doesn't support multiple vertex formats in a single VB
+
+   GDRAW_BFORMAT__count,
+} gdraw_bformat;
+/* Specifies what data format GDraw expects in MakeVertexBuffer_* and DrawIndexedTriangles.
+
+   Most supported platforms prefer Vertex and Index buffers so that's what we use,
+   but this format turns out to be somewhat awkward for Wii, so we use the native
+   graphics processor display list format on that platform. */
+
+IDOC typedef struct GDrawInfo
+{
+   S32 num_stencil_bits;        // number of (possibly emulated) stencil buffer bits
+   U32 max_id;                  // number of unique values that can be easily encoded in zbuffer
+   U32 max_texture_size;        // edge length of largest square texture supported by hardware
+   U32 buffer_format;           // one of $gdraw_bformat
+   rrbool shared_depth_stencil; // does 0'th framebuffer share depth & stencil with others? (on GL it can't?)
+   rrbool always_mipmap;        // if GDraw can generate mipmaps nearly for free, then set this flag
+   rrbool conditional_nonpow2;  // non-pow2 textures supported, but only using clamp and without mipmaps
+   rrbool has_rendertargets;    // if true, then there is no rendertarget stack support
+   rrbool no_nonpow2;           // non-pow2 textures aren't supported at all
+} GDrawInfo; // must be a multiple of 8
+/* $GDrawInfo contains the information that Iggy needs to know about
+   what a GDraw implementation supports and what limits it places on
+   certain important values. */
+
+IDOC typedef void RADLINK gdraw_get_info(GDrawInfo *d);
+/* Iggy queries this at the beginning of rendering to get information
+   about the viewport and the device capabilities. */
+
+////////////////////////////////////////////////////////////
+//
+// Drawing State
+//
+//idoc(parent,GDrawAPI_DrawingState)
+
+IDOC typedef enum gdraw_blend
+{
+   GDRAW_BLEND_none, // Directly copy
+   GDRAW_BLEND_alpha, // Use the source alpha channel to modulate its contribution
+   GDRAW_BLEND_multiply, // Multiply colors componentwise
+   GDRAW_BLEND_add, // Add the source and destination together
+
+   GDRAW_BLEND_filter, // Uses a secondary $gdraw_filter specification to determine how to blend
+   GDRAW_BLEND_special, // Uses a secondary $gdraw_blendspecial specification to determine how to blend
+
+   GDRAW_BLEND__count,
+} gdraw_blend;
+/* Identifier indicating the type of blending operation to use when rendering.*/
+
+IDOC typedef enum gdraw_blendspecial
+{
+   GDRAW_BLENDSPECIAL_layer, // s
+   GDRAW_BLENDSPECIAL_multiply, // s*d
+   GDRAW_BLENDSPECIAL_screen, // sa*da - (da-d)*(sa-s)
+   GDRAW_BLENDSPECIAL_lighten, // max(sa*d,s*da)
+   GDRAW_BLENDSPECIAL_darken, // min(sa*d,s*da)
+   GDRAW_BLENDSPECIAL_add, // min(d+s,1.0)
+   GDRAW_BLENDSPECIAL_subtract, // max(d-s,0.0)
+   GDRAW_BLENDSPECIAL_difference, // abs(sa*d-s*da)
+   GDRAW_BLENDSPECIAL_invert, // sa*(da-d)
+   GDRAW_BLENDSPECIAL_overlay, // d < da/2.0 ? (2.0*s*d) : (sa*da - 2.0*(da-d)*(sa-s))
+   GDRAW_BLENDSPECIAL_hardlight, // s < sa/2.0 ? (2.0*s*d) : (sa*da - 2.0*(da-d)*(sa-s))
+
+   // these do extra-special math on the output alpha
+   GDRAW_BLENDSPECIAL_erase, // d*(1.0-sa)
+   GDRAW_BLENDSPECIAL_alpha_special, // d*sa
+
+   GDRAW_BLENDSPECIAL__count,
+} gdraw_blendspecial;
+/* Specifies a type of "special" blend mode, which is defined as one
+   that has to read from the framebuffer to compute its effect.
+
+   These modes are only used with a 1-to-1 textured quad containing
+   the exact output data in premultiplied alpha.  They all need to
+   read from the framebuffer to compute their effect, so a GDraw
+   implementation will usually need a custom path to handle that.
+   Users will not warn in advance whether you're going to need this
+   operation, so implementations either need to always render to a
+   texture in case it happens, or copy the framebuffer to a texture
+   when it does.
+
+   Note that $(gdraw_blendspecial::GDRAW_BLENDSPECIAL_erase) and
+   $(gdraw_blendspecial::GDRAW_BLENDSPECIAL_alpha_special) are unique
+   among $gdraw_blendspecial modes in that they may not actually need
+   to be implemented with the destination input as a texture if
+   the destination buffer doesn't have an alpha channel. */
+
+// (@OPTIMIZE: the last filter in each chain could be combined with
+// the final blend, although only worth doing if the final blend is
+// ALPHA/ADD/MULTIPLY--it's usually ALPHA though so worth doing!)
+IDOC typedef enum gdraw_filter
+{
+   GDRAW_FILTER_blur, // Blurs the source image
+   GDRAW_FILTER_colormatrix, // Transform RGB pixel values by a matrix
+   GDRAW_FILTER_bevel, // Bevels the source image
+   GDRAW_FILTER_dropshadow, // Adds a dropshadow underneath the source image
+
+   GDRAW_FILTER__count,
+} gdraw_filter;
+/* Specifies a type of post-processing graphics filter.
+
+   These modes are only used to implement filter effects, and will
+   always be blending from a temporary buffer to another temporary
+   buffer with no blending, so in general they should not require
+   any additional input.
+*/
+
+IDOC typedef enum gdraw_texture
+{
+   GDRAW_TEXTURE_none,     // No texture applied
+   GDRAW_TEXTURE_normal,   // Texture is bitmap or linear gradient
+   GDRAW_TEXTURE_alpha,    // Texture is an alpha-only font bitmap
+   GDRAW_TEXTURE_radial,   // Texture is a radial gradient
+   GDRAW_TEXTURE_focal_gradient, // Texture is a "focal" radial gradient
+   GDRAW_TEXTURE_alpha_test,  // Texture is an alpha-only font bitmap, alpha test for alpha >= 0.5
+
+   GDRAW_TEXTURE__count,
+} gdraw_texture;
+/* Specifies how to apply a texture while rendering. */
+
+IDOC typedef enum gdraw_wrap
+{
+   GDRAW_WRAP_clamp, // Texture coordinates clamped to edges
+   GDRAW_WRAP_repeat, // Texture repeats periodically
+   GDRAW_WRAP_mirror, // Repeat periodically, mirror on odd repetititions
+   GDRAW_WRAP_clamp_to_border, // only used internally by some GDraws
+
+   GDRAW_WRAP__count,
+} gdraw_wrap;
+/* Specifies what to do with texture coordinates outside [0,1]. */
+
+typedef struct GDrawRenderState
+{
+   S32 id;                  // Object "identifier" used for high-quality AA mode
+   U32 test_id:1;           // Whether to test zbuffer == id
+   U32 set_id:1;            // Whether to set zbuffer == id
+   U32 use_world_space:1;   // Whether primitive is defined in object space or world space
+   U32 scissor:1;           // Whether rendering will be clipped to $(GDrawRenderState::scissor_rect)
+   U32 identical_state:1;   // Whether state is identical to the one used for the previous draw call
+   U32 unused:27;
+                                       //aligned 0 mod 8
+
+   U8 texgen0_enabled;      // Whether to use texgen for tex0
+   U8 tex0_mode;            // One of $gdraw_texture
+   U8 wrap0;                // One of $gdraw_wrap
+   U8 nearest0;             // Whether to sample texture 0 nearest neighbor
+
+   U8 blend_mode;       // One of $gdraw_blend 
+   U8 special_blend;    // One of $gdraw_blendspecial (used only if $(GDrawRenderState::blend_mode) == $(gdraw_blend::GDRAW_BLEND_special)
+   U8 filter;           // One of $gdraw_filter (used only if $(GDrawRenderState::blend_mode) == $(gdraw_blend::GDRAW_BLEND_filter)
+   U8 filter_mode;      // Used to select the right compositing operation for the $(gdraw_filter::GDRAW_FILTER_bevel) and $(gdraw_filter::GDRAW_FILTER_dropshadow) modes
+                                       //aligned 0 mod 8
+   U8 stencil_test;     // Only draw if these stencil bits are "set"
+   U8 stencil_set;      // "Set" these stencil bits (note that actual implementation initializes stencil to 1, and "set" makes them 0)
+
+   U8 reserved[2];      // Currently unused (used to make padding to 4/8-byte boundary for following pointer explicit)
+   S32 blur_passes;     // For filters that include blurring, this is the number of box filter passes to run
+                                       //align 0 mod 8
+
+   S16 *cxf_add;        // Color transform addition (discourage additive alpha!)
+
+   GDrawTexture *tex[3]; // One or more textures to apply -- need 3 for gradient dropshadow.
+                                       //0 mod 8
+   F32 *edge_matrix;     // Screen to object space matrix (for edge antialiasing)
+   gswf_matrix *o2w;     // Object-to-world matrix
+
+   // --- Everything below this point must be manually initialized
+
+                                       //0 mod 8
+   F32 color[4];         // Color of the object
+
+                                       //0 mod 8
+   gswf_recti scissor_rect; // The rectangle to which rendering will be clipped if $(GDrawRenderState::scissor) is set 
+                                       //0 mod 8
+   // --- Everything below this point might be uninitialized if it's not used for this particular render state
+
+   F32 s0_texgen[4];     // "s" (x) row of texgen matrix
+   F32 t0_texgen[4];     // "t" (y) row of texgen matrix
+                                       //0 mod 8
+   F32 focal_point[4];  // Data used for $(gdraw_texgen_mode::GDRAW_TEXTURE_focal_gradient)
+                                       //0 mod 8
+   F32 blur_x,blur_y;   // The size of the box filter, where '1' is the identity and 2 adds half a pixel on each side
+                                       //0 mod 8
+   F32 shader_data[20]; // Various data that depends on filter (e.g. drop shadow direction, color)
+} GDrawRenderState;
+/* Encapsulation of the entire drawing state that affects a rendering command. */
+
+IDOC typedef void RADLINK gdraw_set_view_size_and_world_scale(S32 w, S32 h, F32 x_world_to_pixel, F32 y_world_to_pixel);
+/* Sets the size of the rendering viewport and the world to pixel scaling.
+
+   Iggy calls this function with the full size that the viewport would
+   be if it were rendered untiled, even if it will eventually be
+   rendered as a collection of smaller tiles.
+   
+   The world scale is used to compensate non-square pixel aspect ratios
+   when rendering wide lines. Both scale factors are 1 unless Iggy is
+   running on a display with non-square pixels. */
+
+typedef void RADLINK gdraw_set_3d_transform(F32 *mat); /* mat[3][4] */
+
+IDOC typedef void RADLINK gdraw_render_tile_begin(S32 tx0, S32 ty0, S32 tx1, S32 ty1, S32 pad, GDrawStats *stats);
+/* Begins rendering of a sub-region of the rendered image. */
+
+IDOC typedef void RADLINK gdraw_render_tile_end(GDrawStats *stats);
+/* Ends rendering of a sub-region of the rendered image. */
+
+IDOC typedef void RADLINK gdraw_rendering_begin(void);
+/* Begins rendering; takes control of the graphics API. */
+
+IDOC typedef void RADLINK gdraw_rendering_end(void);
+/* Ends rendering; gives up control of the graphics API.  */
+
+
+////////////////////////////////////////////////////////////
+//
+// Drawing
+//
+//idoc(parent,GDrawAPI_Drawing)
+
+IDOC typedef void RADLINK gdraw_clear_stencil_bits(U32 bits);
+/* Clears the 'bits' parts of the stencil value in the entire framebuffer to the default value. */
+
+IDOC typedef void RADLINK gdraw_clear_id(void);
+/* Clears the 'id' buffer, which is typically the z-buffer but can also be the stencil buffer. */
+
+IDOC typedef void RADLINK gdraw_filter_quad(GDrawRenderState *r, S32 x0, S32 y0, S32 x1, S32 y1, GDrawStats *stats);
+/* Draws a special quad in viewport-relative pixel space.
+
+   May be normal, may be displaced by filters, etc. and require multiple passes,
+   may apply special blending (and require extra resolves/rendertargets)
+   for filter/blend.,
+
+   The x0,y0,x1,y1 always describes the "input" box. */
+
+IDOC typedef struct GDrawPrimitive
+{
+   F32 *vertices; // Pointer to an array of $gswf_vertex_xy, $gswf_vertex_xyst, or $gswf_vertex_xyoffs
+   U16 *indices; // Pointer to an array of 16-bit indices into $(GDrawPrimitive::vertices)
+
+   S32 num_vertices; // Count of elements in $(GDrawPrimitive::vertices)
+   S32 num_indices; // Count of elements in $(GDrawPrimitive::indices)
+
+   S32 vertex_format; // One of $gdraw_vformat, specifying the type of element in $(GDrawPrimitive::vertices)
+
+   U32  uniform_count;
+   F32 *uniforms;
+
+   U8  drawprim_mode;
+} GDrawPrimitive;
+/* Specifies the vertex and index data necessary to draw a batch of graphics primitives. */
+
+IDOC typedef void RADLINK gdraw_draw_indexed_triangles(GDrawRenderState *r, GDrawPrimitive *prim, GDrawVertexBuffer *buf, GDrawStats *stats);
+/* Draws a collection of indexed triangles, ignoring special filters or blend modes.
+
+   If buf is NULL, then the pointers in 'prim' are machine pointers, and
+   you need to make a copy of the data (note currently all triangles
+   implementing strokes (wide lines) go this path).
+   
+   If buf is non-NULL, then use the appropriate vertex buffer, and the
+   pointers in prim are actually offsets from the beginning of the
+   vertex buffer -- i.e. offset = (char*) prim->whatever - (char*) NULL;
+   (note there are separate spaces for vertices and indices; e.g. the
+   first mesh in a given vertex buffer will normally have a 0 offset
+   for the vertices and a 0 offset for the indices)
+*/
+
+IDOC typedef void RADLINK gdraw_set_antialias_texture(S32 width, U8 *rgba);
+/* Specifies the 1D texture data to be used for the antialiasing gradients.
+
+   'rgba' specifies the pixel values in rgba byte order. This will only be called
+   once during initialization. */
+
+////////////////////////////////////////////////////////////
+//
+// Texture and Vertex Buffers
+//
+//idoc(parent,GDrawAPI_Buffers)
+
+IDOC typedef enum gdraw_texture_format
+{
+   // Platform-independent formats
+   GDRAW_TEXTURE_FORMAT_rgba32,  // 32bpp RGBA data in platform-preferred byte order (returned by $gdraw_make_texture_begin as $gdraw_texture_type)
+   GDRAW_TEXTURE_FORMAT_font,    // Alpha-only data with at least 4 bits/pixel. Data is submitted as 8 bits/pixel, conversion (if necessary) done by GDraw.
+
+   // First platform-specific format index (for reference)
+   GDRAW_TEXTURE_FORMAT__platform = 16,
+
+   // In the future, we will support platform-specific formats and add them to this list.
+} gdraw_texture_format;
+/* Describes the format of a texture submitted to GDraw. */
+
+IDOC typedef enum gdraw_texture_type
+{
+   GDRAW_TEXTURE_TYPE_rgba, // Raw 4-channel packed texels, in OpenGL-standard order
+   GDRAW_TEXTURE_TYPE_bgra, // Raw 4-channel packed texels, in Direct3D-standard order
+   GDRAW_TEXTURE_TYPE_argb, // Raw 4-channel packed texels, in Flash native order
+
+   GDRAW_TEXTURE_TYPE__count,
+} gdraw_texture_type;
+/* Describes the channel layout of a RGBA texture submitted to GDraw. */
+
+IDOC typedef struct GDraw_MakeTexture_ProcessingInfo
+{
+   U8   *texture_data; // Pointer to the texture image bits
+   S32   num_rows; // Number of rows to upload in the current chunk
+   S32   stride_in_bytes;  // Distance between a given pixel and the first pixel in the next row
+   S32   texture_type; // One of $gdraw_texture_type
+
+   U32   temp_buffer_bytes; // Size of temp buffer in bytes
+   U8   *temp_buffer; // Temp buffer for GDraw to work in (used during mipmap creation)
+  
+   void *p0,*p1,*p2,*p3,*p4,*p5,*p6,*p7; // Pointers for GDraw to store data across "passes" (never touched by Iggy)
+   U32   i0, i1, i2, i3, i4, i5, i6, i7; // Integers for GDraw to store data across "passes" (never touched by Iggy)
+} GDraw_MakeTexture_ProcessingInfo;
+/* $GDraw_MakeTexture_ProcessingInfo is used when building a texture. */
+
+IDOC typedef struct GDraw_Texture_Description {
+   S32   width; // Width of the texture in pixels
+   S32   height; // Height of the texture in pixels
+   U32   size_in_bytes; // Size of the texture in bytes
+} GDraw_Texture_Description;
+/* $GDraw_Texture_Description contains information about a texture. */
+
+IDOC typedef U32 gdraw_maketexture_flags;
+#define GDRAW_MAKETEXTURE_FLAGS_mipmap             1 IDOC // Generates mip-maps for the texture
+#define GDRAW_MAKETEXTURE_FLAGS_updatable          2 IDOC // Set if the texture might be updated subsequent to its initial submission
+#define GDRAW_MAKETEXTURE_FLAGS_never_flush        4 IDOC // Set to request that the texture never be flushed from the GDraw cache
+
+/* Flags that control the submission and management of GDraw textures. */
+
+IDOC typedef void RADLINK gdraw_set_texture_unique_id(GDrawTexture *tex, void *old_unique_id, void *new_unique_id);
+/* Changes unique id of a texture, only used for TextureSubstitution */
+
+IDOC typedef rrbool RADLINK gdraw_make_texture_begin(void *unique_id,
+                                                   S32 width, S32 height, gdraw_texture_format format, gdraw_maketexture_flags flags,
+                                                   GDraw_MakeTexture_ProcessingInfo *output_info, GDrawStats *stats);
+/* Begins specifying a new texture.
+
+   $:unique_id Unique value specified by Iggy that you can use to identify a reference to the same texture even if its handle has been discarded
+   $:return Error code if there was a problem, IGGY_RESULT_OK otherwise
+*/
+
+IDOC typedef rrbool RADLINK gdraw_make_texture_more(GDraw_MakeTexture_ProcessingInfo *info);
+/* Continues specifying a new texture.
+
+   $:info The same handle initially passed to $gdraw_make_texture_begin
+   $:return True if specification can continue, false if specification must be aborted
+*/
+
+IDOC typedef GDrawTexture * RADLINK gdraw_make_texture_end(GDraw_MakeTexture_ProcessingInfo *info, GDrawStats *stats);
+/* Ends specification of a new texture.
+   
+   $:info The same handle initially passed to $gdraw_make_texture_begin
+   $:return Handle for the newly created texture, or NULL if an error occured
+*/
+
+IDOC typedef rrbool RADLINK gdraw_update_texture_begin(GDrawTexture *tex, void *unique_id, GDrawStats *stats);
+/* Begins updating a previously submitted texture.
+
+   $:unique_id Must be the same value initially passed to $gdraw_make_texture_begin
+   $:return True on success, false otherwise and the texture must be recreated
+*/
+
+IDOC typedef void RADLINK gdraw_update_texture_rect(GDrawTexture *tex, void *unique_id, S32 x, S32 y, S32 stride, S32 w, S32 h, U8 *data, gdraw_texture_format format);
+/* Updates a rectangle in a previously submitted texture.
+   
+   $:format Must be the $gdraw_texture_format that was originally passed to $gdraw_make_texture_begin for this texture.
+*/
+
+IDOC typedef void RADLINK gdraw_update_texture_end(GDrawTexture *tex, void *unique_id, GDrawStats *stats);
+/* Ends an update to a previously submitted texture.
+
+   $:unique_id Must be the same value initially passed to $gdraw_make_texture_begin (and hence $gdraw_update_texture_begin)
+*/
+
+IDOC typedef void RADLINK gdraw_describe_texture(GDrawTexture *tex, GDraw_Texture_Description *desc);
+/* Returns a texture description for a given GDraw texture. */
+
+IDOC typedef GDrawTexture * RADLINK gdraw_make_texture_from_resource(U8 *resource_file, S32 file_len, void *texture);
+/* Loads a texture from a resource file and returns a wrapped pointer. */
+
+IDOC typedef void RADLINK gdraw_free_texture_from_resource(GDrawTexture *tex);
+/* Frees a texture created with gdraw_make_texture_from_resource. */
+
+
+IDOC typedef struct gswf_vertex_xy
+{
+   F32 x,y; // Position of the vertex
+} gswf_vertex_xy;
+/* A 2D point with floating-point position. */
+
+IDOC typedef struct gswf_vertex_xyoffs
+{
+   F32 x,y; // Position of the vertex
+
+   S16 aa; // Stroke/aa texcoord
+   S16 dx, dy; // Vector offset from the position, used for anti-aliasing (signed 11.5 fixed point)
+   S16 unused;
+} gswf_vertex_xyoffs;
+/* A 2D point with floating-point position, additional integer parameter, and integer anti-aliasing offset vector. */
+
+IDOC typedef struct gswf_vertex_xyst
+{
+   F32 x,y; // Position of the vertex
+   F32 s,t; // Explicit texture coordinates for rectangles
+} gswf_vertex_xyst;
+/* A 2D point with floating-point position and texture coordinates. */
+
+typedef int gdraw_verify_size_xy    [sizeof(gswf_vertex_xy    ) ==  8 ? 1 : -1];
+typedef int gdraw_verify_size_xyoffs[sizeof(gswf_vertex_xyoffs) == 16 ? 1 : -1];
+typedef int gdraw_verify_size_xyst  [sizeof(gswf_vertex_xyst  ) == 16 ? 1 : -1];
+  
+IDOC typedef enum gdraw_vformat
+{
+   GDRAW_vformat_v2,    // Indicates vertices of type $gswf_vertex_xy (8 bytes per vertex)
+   GDRAW_vformat_v2aa,  // Indicates vertices of type $gswf_vertex_xyoffs (16 bytes per vertex)
+   GDRAW_vformat_v2tc2, // Indicates vertices of type $gswf_vertex_xyst (16 bytes per vertex)
+
+   GDRAW_vformat__basic_count,
+   GDRAW_vformat_ihud1 = GDRAW_vformat__basic_count, // primary format for ihud, currently v2tc2mat4 (20 bytes per vertex)
+
+   GDRAW_vformat__count,
+   GDRAW_vformat_mixed, // Special value that denotes a VB containing data in multiple vertex formats. Never used when drawing!
+} gdraw_vformat;
+/* Identifies one of the vertex data types. */
+
+IDOC typedef struct GDraw_MakeVertexBuffer_ProcessingInfo
+{
+   U8  *vertex_data;         // location to write vertex data
+   U8  *index_data;          // location to write index data
+
+   S32  vertex_data_length;  // size of buffer to write vertex data
+   S32  index_data_length;   // size of buffer to write index data
+
+   void *p0,*p1,*p2,*p3,*p4,*p5,*p6,*p7; // Pointers for GDraw to store data across "passes" (never touched by Iggy)
+   U32   i0, i1, i2, i3, i4, i5, i6, i7; // Integers for GDraw to store data across "passes" (never touched by Iggy)
+} GDraw_MakeVertexBuffer_ProcessingInfo;
+/* $GDraw_MakeVertexBuffer_ProcessingInfo is used when building a vertex buffer. */
+
+IDOC typedef struct GDraw_VertexBuffer_Description {
+   S32  size_in_bytes; // Size of the vertex buffer in bytes
+} GDraw_VertexBuffer_Description;
+/* $GDraw_VertexBuffer_Description contains information about a vertex buffer. */
+
+IDOC typedef rrbool RADLINK gdraw_make_vertex_buffer_begin(void *unique_id, gdraw_vformat vformat, S32 vdata_len_in_bytes, S32 idata_len_in_bytes, GDraw_MakeVertexBuffer_ProcessingInfo *info, GDrawStats *stats);
+/* Begins specifying a new vertex buffer.
+
+   $:unique_id Unique value that identifies this texture, across potentially multiple flushes and re-creations of its $GDrawTexture handle in GDraw
+   $:vformat One of $gdraw_vformat, denoting the format of the vertex data submitted
+   $:return false if there was a problem, true if ok
+*/
+
+IDOC typedef rrbool RADLINK gdraw_make_vertex_buffer_more(GDraw_MakeVertexBuffer_ProcessingInfo *info);
+/* Continues specifying a new vertex buffer.
+
+   $:info The same handle initially passed to $gdraw_make_vertex_buffer_begin
+   $:return True if specification can continue, false if specification must be aborted
+*/   
+
+IDOC typedef GDrawVertexBuffer * RADLINK gdraw_make_vertex_buffer_end(GDraw_MakeVertexBuffer_ProcessingInfo *info, GDrawStats *stats);
+/* Ends specification of a new vertex buffer.
+
+   $:info The same handle initially passed to $gdraw_make_texture_begin
+   $:return Handle for the newly created vertex buffer
+*/
+
+IDOC typedef void RADLINK gdraw_describe_vertex_buffer(GDrawVertexBuffer *buffer, GDraw_VertexBuffer_Description *desc);
+/* Returns a description for a given GDrawVertexBuffer */
+
+
+IDOC typedef rrbool RADLINK gdraw_try_to_lock_texture(GDrawTexture *tex, void *unique_id, GDrawStats *stats);
+/* Tells GDraw that a $GDrawTexture is going to be referenced.
+
+   $:unique_id Must be the same value initially passed to $gdraw_make_texture_begin
+*/
+
+IDOC typedef rrbool RADLINK gdraw_try_to_lock_vertex_buffer(GDrawVertexBuffer *vb, void *unique_id, GDrawStats *stats);
+/* Tells GDraw that a $GDrawVertexBuffer is going to be referenced.
+
+   $:unique_id Must be the same value initially passed to $gdraw_make_vertex_buffer_begin
+*/
+
+IDOC typedef void RADLINK gdraw_unlock_handles(GDrawStats *stats);
+/* Indicates that the user of GDraw will not try to reference anything without locking it again.
+
+   Note that although a call to $gdraw_unlock_handles indicates that
+   all $GDrawTexture and $GDrawVertexBuffer handles that have had a
+   "unique_id" specified will no longer be referenced by the user of
+   GDraw, it does not affect those $GDrawTexture handles that were
+   created by $gdraw_start_texture_draw_buffer with a unique_id of 0.
+*/
+
+IDOC typedef void RADLINK gdraw_free_vertex_buffer(GDrawVertexBuffer *vb, void *unique_id, GDrawStats *stats);
+/* Free a vertex buffer and invalidate the handle
+
+   $:unique_id Must be the same value initially passed to $gdraw_make_vertex_buffer_begin
+*/
+
+IDOC typedef void RADLINK gdraw_free_texture(GDrawTexture *t, void *unique_id, GDrawStats *stats);
+/* Free a texture and invalidate the handle.
+
+   $:unique_id Must be the same value initially passed to $gdraw_make_texture_begin, or 0 for a texture created by $gdraw_end_texture_draw_buffer
+*/
+
+////////////////////////////////////////////////////////////
+//
+// Render targets
+//
+//idoc(parent,GDrawAPI_Targets)
+
+IDOC typedef U32 gdraw_texturedrawbuffer_flags;
+#define GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_color    1 IDOC // Tells GDraw that you will need the color channel when rendering a texture
+#define GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_alpha    2 IDOC // Tells GDraw that you will need the alpha channel when rendering a texture
+#define GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_stencil  4 IDOC // Tells GDraw that you will need the stencil channel when rendering a texture
+#define GDRAW_TEXTUREDRAWBUFFER_FLAGS_needs_id       8 IDOC // Tells GDraw that you will need the id channel when rendering a texture
+
+/* Flags that control rendering to a texture. */
+
+IDOC typedef rrbool RADLINK gdraw_texture_draw_buffer_begin(gswf_recti *region, gdraw_texture_format format, gdraw_texturedrawbuffer_flags flags, void *unique_id, GDrawStats *stats);
+/* Starts rendering all GDraw commands to a new texture.
+
+   Creates a rendertarget with destination alpha, initializes to all 0s and prepares to render into it
+*/
+
+
+IDOC typedef GDrawTexture * RADLINK gdraw_texture_draw_buffer_end(GDrawStats *stats);
+/* Ends rendering GDraw commands to a texture, and returns the texture created.
+
+   You can get the size of the resulting texture with $gdraw_query_texture_size.
+*/
+
+////////////////////////////////////////////////////////////
+//
+// Masking
+//
+//idoc(parent,GDrawAPI_Masking)
+
+IDOC typedef void RADLINK gdraw_draw_mask_begin(gswf_recti *region, S32 mask_bit, GDrawStats *stats);
+/* Start a masking operation on the given region for the specified mask bit.
+
+   For most drivers, no special preparation is necessary to start masking, so this is a no-op.
+*/
+
+IDOC typedef void RADLINK gdraw_draw_mask_end(gswf_recti *region, S32 mask_bit, GDrawStats *stats);
+/* End a masking operation on the given region for the specified mask bit.
+
+   For most drivers, no special preparation is necessary to end masking, so this is a no-op.
+*/
+
+////////////////////////////////////////////////////////////
+//
+// GDraw API Function table
+//
+//idoc(parent,GDrawAPI_Base)
+
+IDOC struct GDrawFunctions
+{
+    // queries
+    gdraw_get_info *GetInfo;
+
+    // drawing state
+    gdraw_set_view_size_and_world_scale   * SetViewSizeAndWorldScale;
+    gdraw_render_tile_begin               * RenderTileBegin;
+    gdraw_render_tile_end                 * RenderTileEnd;
+    gdraw_set_antialias_texture           * SetAntialiasTexture;
+
+    // drawing
+    gdraw_clear_stencil_bits              * ClearStencilBits;
+    gdraw_clear_id                        * ClearID;
+    gdraw_filter_quad                     * FilterQuad;
+    gdraw_draw_indexed_triangles          * DrawIndexedTriangles;
+    gdraw_make_texture_begin              * MakeTextureBegin;
+    gdraw_make_texture_more               * MakeTextureMore;
+    gdraw_make_texture_end                * MakeTextureEnd;
+    gdraw_make_vertex_buffer_begin        * MakeVertexBufferBegin;
+    gdraw_make_vertex_buffer_more         * MakeVertexBufferMore;
+    gdraw_make_vertex_buffer_end          * MakeVertexBufferEnd;
+    gdraw_try_to_lock_texture             * TryToLockTexture;
+    gdraw_try_to_lock_vertex_buffer       * TryToLockVertexBuffer;
+    gdraw_unlock_handles                  * UnlockHandles;
+    gdraw_free_texture                    * FreeTexture;
+    gdraw_free_vertex_buffer              * FreeVertexBuffer;
+    gdraw_update_texture_begin            * UpdateTextureBegin;
+    gdraw_update_texture_rect             * UpdateTextureRect;
+    gdraw_update_texture_end              * UpdateTextureEnd;
+
+    // rendertargets
+    gdraw_texture_draw_buffer_begin       * TextureDrawBufferBegin;
+    gdraw_texture_draw_buffer_end         * TextureDrawBufferEnd;
+
+    gdraw_describe_texture                * DescribeTexture;
+    gdraw_describe_vertex_buffer          * DescribeVertexBuffer;
+
+    // new functions are always added at the end, so these have no structure
+    gdraw_set_texture_unique_id           * SetTextureUniqueID;
+
+    gdraw_draw_mask_begin                 * DrawMaskBegin;
+    gdraw_draw_mask_end                   * DrawMaskEnd;
+
+    gdraw_rendering_begin                 * RenderingBegin;
+    gdraw_rendering_end                   * RenderingEnd;
+
+    gdraw_make_texture_from_resource      * MakeTextureFromResource;
+    gdraw_free_texture_from_resource      * FreeTextureFromResource;
+
+    gdraw_set_3d_transform                * Set3DTransform;
+};
+/* The function interface called by Iggy to render graphics on all
+   platforms.
+
+   So that Iggy can integrate with the widest possible variety of
+   rendering scenarios, all of its renderer-specific drawing calls
+   go through this table of function pointers.  This allows you
+   to dynamically configure which of RAD's supplied drawing layers
+   you wish to use, or to integrate it directly into your own
+   renderer by implementing your own versions of the drawing
+   functions Iggy requires.
+*/
+
+RADDEFEND
+
+#endif

Minecraft.Client/Orbis/Iggy/include/iggyexpruntime.h

@@ -0,0 +1,49 @@
+#ifndef __RAD_INCLUDE_IGGYEXPRUNTIME_H__
+#define __RAD_INCLUDE_IGGYEXPRUNTIME_H__
+
+#include "rrCore.h"
+
+#define IDOC
+
+RADDEFSTART
+
+#ifndef __RAD_HIGGYEXP_
+#define __RAD_HIGGYEXP_
+typedef void * HIGGYEXP;
+#endif
+
+//idoc(parent,IggyExpRuntime_API)
+
+#define IGGYEXP_MIN_STORAGE  1024   IDOC
+/* The minimum-sized block you must provide to $IggyExpCreate */
+
+IDOC RADEXPFUNC HIGGYEXP RADEXPLINK IggyExpCreate(char *ip_address, S32 port, void *storage, S32 storage_size_in_bytes);
+/* Opens a connection to $IggyExplorer and returns an $HIGGYEXP wrapping the connection.
+
+   $:ip_address The address of the machine running Iggy Explorer (can be numeric with dots, or textual, including "localhost")
+   $:port The port number on which Iggy Explorer is listening for a network connection (the default is 9190)
+   $:storage A small block of storage that needed to store the $HIGGYEXP, must be at least $IGGYEXP_MIN_STORAGE
+   $:storage_size_in_bytes The size of the block pointer to by <tt>storage</tt>
+
+Returns a NULL HIGGYEXP if the IP address/hostname can't be resolved, or no Iggy Explorer
+can be contacted at the specified address/port. Otherwise returns a non-NULL $HIGGYEXP
+which you can pass to $IggyUseExplorer. */
+
+IDOC RADEXPFUNC void  RADEXPLINK IggyExpDestroy(HIGGYEXP p);
+/* Closes and destroys a connection to $IggyExplorer */
+
+IDOC RADEXPFUNC rrbool RADEXPLINK IggyExpCheckValidity(HIGGYEXP p);
+/* Checks if the connection represented by an $HIGGYEXP is still valid, i.e.
+still connected to $IggyExplorer.
+
+Returns true if the connection is still valid; returns false if it is not valid.
+
+This might happen if someone closes Iggy Explorer, Iggy Explorer crashes, or
+the network fails. You can this to poll and detect these conditions and do
+something in response, such as trying to open a new connection.
+
+An invalid $HIGGYEXP must still be shutdown with $IggyExpDestroy. */
+
+RADDEFEND
+
+#endif//__RAD_INCLUDE_IGGYEXPRUNTIME_H__

Minecraft.Client/Orbis/Iggy/include/iggyperfmon.h

@@ -0,0 +1,89 @@
+// $$COPYRIGHT$$
+
+#ifndef __RAD_INCLUDE_IGGYPERFMON_H__
+#define __RAD_INCLUDE_IGGYPERFMON_H__
+
+#include "rrCore.h"
+
+#define IDOC
+
+RADDEFSTART
+
+#ifndef __RAD_HIGGYPERFMON_
+#define __RAD_HIGGYPERFMON_
+typedef void * HIGGYPERFMON;
+#endif
+
+//idoc(parent,IggyPerfmon_API)
+
+typedef void * RADLINK iggyperfmon_malloc(void *handle, U32 size);
+typedef void RADLINK iggyperfmon_free(void *handle, void *ptr);
+
+IDOC RADEXPFUNC HIGGYPERFMON RADEXPLINK IggyPerfmonCreate(iggyperfmon_malloc *perf_malloc, iggyperfmon_free *perf_free, void *callback_handle);
+/* Creates an IggyPerfmon.
+
+You must supply allocator functions. The amount allocated depends on the complexity
+of the Iggys being profiled. */
+
+typedef struct Iggy Iggy;
+typedef struct GDrawFunctions GDrawFunctions;
+
+IDOC typedef union {
+   U32 bits;
+   struct {
+      U32 dpad_up             :1;
+      U32 dpad_down           :1;
+      U32 dpad_left           :1;
+      U32 dpad_right          :1;
+      U32 button_up           :1;      // XBox Y, PS3 tri
+      U32 button_down         :1;      // XBox A, PS3 X
+      U32 button_left         :1;      // XBox X, PS3 square
+      U32 button_right        :1;      // XBox B, PS3 circle
+      U32 shoulder_left_hi    :1;      // LB/L1
+      U32 shoulder_right_hi   :1;      // RB/R1
+      U32 trigger_left_low    :1;
+      U32 trigger_right_low   :1;
+   } field;
+} IggyPerfmonPad;
+
+#define IggyPerfmonPadFromXInputStatePointer(pad, xis)                                       \
+   (pad).bits = 0,                                                                           \
+   (pad).field.dpad_up           = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_UP),        \
+   (pad).field.dpad_down         = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN),      \
+   (pad).field.dpad_left         = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_LEFT),      \
+   (pad).field.dpad_right        = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_RIGHT),     \
+   (pad).field.button_up         = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_Y),              \
+   (pad).field.button_down       = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_A),              \
+   (pad).field.button_left       = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_X),              \
+   (pad).field.button_right      = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_B),              \
+   (pad).field.shoulder_left_hi  = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER),  \
+   (pad).field.shoulder_right_hi = 0 != ((xis)->Gamepad.wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER), \
+   (pad).field.trigger_left_low  = 0 != ((xis)->Gamepad.bLeftTrigger  >= XINPUT_GAMEPAD_TRIGGER_THRESHOLD), \
+   (pad).field.trigger_right_low = 0 != ((xis)->Gamepad.bRightTrigger >= XINPUT_GAMEPAD_TRIGGER_THRESHOLD)
+
+// All positions in window coords
+IDOC RADEXPFUNC void RADEXPLINK IggyPerfmonTickAndDraw(HIGGYPERFMON p, GDrawFunctions* gdraw_funcs,
+                    const IggyPerfmonPad* pad,
+                    int pm_tile_ul_x, int pm_tile_ul_y, int pm_tile_lr_x, int pm_tile_lr_y);
+/* Draw and tick an IggyPerfmon.
+
+$:p A perfmon context previously created with IggyPerfmonCreate
+$:gdraw_functions The same GDraw handle used for rendering Iggy
+$:pad An abstracted gamepad state structure. iggyperfmon.h
+includes an example that initializes the abstract gamepad from a 360 controller
+as defined by XInput; this will work on both Windows and the Xbox 360.
+$:pm_tile_ul_x The left coordinate of the rectangle where the perfmon display should be drawn
+$:pm_tile_ul_y The top coordinate of the rectangle where the perfmon display should be drawn
+$:pm_tile_lr_x The right coordinate of the rectangle where the perfmon display should be drawn
+$:pm_tile_lr_y The bottom coordinate of the rectangle where the perfmon display should be drawn
+
+You should only call this function when you want Iggy Perfmon to be visible.
+See $IggyPerfmon for more information. */
+
+IDOC RADEXPFUNC void  RADEXPLINK IggyPerfmonDestroy(HIGGYPERFMON p, GDrawFunctions* iggy_draw);
+/* Closes and destroys an IggyPerfmon */
+
+
+RADDEFEND
+
+#endif//__RAD_INCLUDE_IGGYPERFMON_H__

Minecraft.Client/Orbis/Iggy/include/iggyperfmon_orbis.h

@@ -0,0 +1,21 @@
+#ifndef __RAD_INCLUDE_IGGYPERFMON_ORBIS_H__
+#define __RAD_INCLUDE_IGGYPERFMON_ORBIS_H__
+
+// You still need to include regular iggyperfmon.h first. This is just for convenience.
+
+#define IggyPerfmonPadFromScePadData(pad, paddata) \
+   (pad).bits = 0,                                                                     \
+   (pad).field.dpad_up           = 0 != ((paddata).buttons & SCE_PAD_BUTTON_UP),       \
+   (pad).field.dpad_down         = 0 != ((paddata).buttons & SCE_PAD_BUTTON_DOWN),     \
+   (pad).field.dpad_left         = 0 != ((paddata).buttons & SCE_PAD_BUTTON_LEFT),     \
+   (pad).field.dpad_right        = 0 != ((paddata).buttons & SCE_PAD_BUTTON_RIGHT),    \
+   (pad).field.button_up         = 0 != ((paddata).buttons & SCE_PAD_BUTTON_TRIANGLE), \
+   (pad).field.button_down       = 0 != ((paddata).buttons & SCE_PAD_BUTTON_CROSS),    \
+   (pad).field.button_left       = 0 != ((paddata).buttons & SCE_PAD_BUTTON_SQUARE),   \
+   (pad).field.button_right      = 0 != ((paddata).buttons & SCE_PAD_BUTTON_CIRCLE),   \
+   (pad).field.shoulder_left_hi  = 0 != ((paddata).buttons & SCE_PAD_BUTTON_L1),       \
+   (pad).field.shoulder_right_hi = 0 != ((paddata).buttons & SCE_PAD_BUTTON_R1),       \
+   (pad).field.trigger_left_low  = 0 != ((paddata).buttons & SCE_PAD_BUTTON_L2),       \
+   (pad).field.trigger_right_low = 0 != ((paddata).buttons & SCE_PAD_BUTTON_R2)
+
+#endif//__RAD_INCLUDE_IGGYPERFMON_ORBIS_H__