Leahnaya/SDL
1
0
Fork 0
mirror of https://github.com/yawut/SDL.git synced 2026-07-05 01:58:52 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

render/wiiu: first-draft conversion to 2.0.10 API

Browse Source
This commit is contained in:
Ash Logan 2020-01-05 16:33:01 +11:00
parent e3577aed1f
commit 5aa8fa2bfd
4 changed files with 153 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

258
src/render/wiiu/SDL_rdraw_wiiu.c
View File

@ -49,10 +49,8 @@
static void WIIU_SDL_SetGX2BlendMode(SDL_BlendMode mode);
int WIIU_SDL_QueueCopy(SDL_Renderer * renderer, SDL_Texture * texture,
int WIIU_SDL_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_FRect * dstrect) {
WIIU_RenderData *data = (WIIU_RenderData *) renderer->driverdata;
WIIU_TextureData *tdata = (WIIU_TextureData *) texture->driverdata;
WIIUVec2 *a_position_vals, *a_texCoord_vals;
float x_min, y_min, x_max, y_max;
@ -66,10 +64,10 @@ int WIIU_SDL_QueueCopy(SDL_Renderer * renderer, SDL_Texture * texture,
1 a_position vector, 1 a_texCoord vector, repeat.
SDL only lets us do one allocation per render command and interleaving
makes performance sense here */
cmd->data.draw.count = 4 /* corners */ * 2 /* attribte buffers */;
a_position_vals = (WIIUVec2*) SDL_AllocateRenderVertices(renderer,
sizeof(WIIUVec2) /* float x/y for each corner */
* 4 /* 4 corners */
* 2 /* 2 attribute buffers */,
* cmd->data.draw.count,
4, //TODO align? GX2R uses 256 (!)
&cmd->data.draw.first
);
@ -105,8 +103,6 @@ int WIIU_SDL_QueueCopy(SDL_Renderer * renderer, SDL_Texture * texture,
int WIIU_SDL_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
const SDL_Rect *srcrect, const SDL_FRect *dstrect,
const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip) {
WIIU_RenderData *data = (WIIU_RenderData *) renderer->driverdata;
WIIU_TextureData *tdata = (WIIU_TextureData *) texture->driverdata;
WIIUVec2 *a_position_vals, *a_texCoord_vals;
/* Compute real vertex points */
@ -140,10 +136,10 @@ int WIIU_SDL_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Tex
1 a_position vector, 1 a_texCoord vector, repeat.
SDL only lets us do one allocation per render command and interleaving
makes performance sense here */
cmd->data.draw.count = 4 /* corners */ * 2 /* attribte buffers */;
a_position_vals = (WIIUVec2*) SDL_AllocateRenderVertices(renderer,
sizeof(WIIUVec2) /* float x/y for each corner */
* 4 /* 4 corners */
* 2 /* 2 attribute buffers */,
* cmd->data.draw.count,
4, //TODO align? GX2R uses 256 (!)
&cmd->data.draw.first
);
@ -179,21 +175,20 @@ int WIIU_SDL_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Tex
}
/* This function is identical for Copy and CopyEx */
void WIIU_SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
void* vertexes, size_t vertex_count)
void WIIU_SDL_RenderCopy(SDL_Renderer * renderer, SDL_RenderCommand* cmd, void* vertexes)
{
WIIU_RenderData *data = (WIIU_RenderData *) renderer->driverdata;
WIIU_TextureData *tdata = (WIIU_TextureData *) texture->driverdata;
WIIU_TextureData *tdata = (WIIU_TextureData *) cmd->data.draw.texture->driverdata;
WIIUVec2 *a_position_vals, *a_texCoord_vals;
size_t count, stride;
/* Set up pointers for deinterleaving */
a_position_vals = (WIIUVec2*)vertexes;
a_texCoord_vals = a_position_vals + 1;
count = vertex_count / 2;
count = cmd->data.draw.count / 2;
stride = sizeof(a_position_vals[0]) * 2;
if (texture->access & SDL_TEXTUREACCESS_TARGET) {
if (cmd->data.draw.texture->access & SDL_TEXTUREACCESS_TARGET) {
GX2RInvalidateSurface(&tdata->texture.surface, 0, 0);
}
@ -216,177 +211,102 @@ void WIIU_SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
GX2SetVertexUniformReg(wiiuTextureShader.vertexShader->uniformVars[0].offset, 4, (uint32_t *)&data->u_viewSize);
GX2SetVertexUniformReg(wiiuTextureShader.vertexShader->uniformVars[1].offset, 4, (uint32_t *)&tdata->u_texSize);
GX2SetPixelUniformReg(wiiuTextureShader.pixelShader->uniformVars[0].offset, 4, (uint32_t *)&tdata->u_mod);
WIIU_SDL_SetGX2BlendMode(texture->blendMode);
WIIU_SDL_SetGX2BlendMode(cmd->data.draw.blend);
GX2DrawEx(GX2_PRIMITIVE_MODE_QUADS, 4, 0, 1);
}
int WIIU_SDL_RenderDrawPoints(SDL_Renderer * renderer, const SDL_FPoint * points,
int count)
{
WIIU_RenderData *data = (WIIU_RenderData *) renderer->driverdata;
GX2RBuffer *a_position;
int WIIU_SDL_QueueDrawPointsLines(SDL_Renderer* renderer, SDL_RenderCommand* cmd, const SDL_FPoint* points, int count) {
WIIUVec2 *a_position_vals;
/* Compute colours */
WIIUVec4 u_colour = {
.r = (float)renderer->r / 255.0f,
.g = (float)renderer->g / 255.0f,
.b = (float)renderer->b / 255.0f,
.a = (float)renderer->a / 255.0f,
};
cmd->data.draw.count = count;
a_position_vals = SDL_AllocateRenderVertices(renderer,
sizeof (WIIUVec2) /* float x/y for each point */
* cmd->data.draw.count,
4, //TODO align
&cmd->data.draw.first
);
/* Allocate attribute buffers */
a_position = WIIU_AllocRenderData(data, (GX2RBuffer) {
.flags =
GX2R_RESOURCE_BIND_VERTEX_BUFFER |
GX2R_RESOURCE_USAGE_CPU_WRITE,
.elemSize = sizeof(WIIUVec2), /* float x/y for each point */
.elemCount = count,
});
/* Compute vertex positions */
a_position_vals = GX2RLockBufferEx(a_position, 0);
for (int i = 0; i < count; ++i) {
a_position_vals[i] = (WIIUVec2) {
.x = (float)renderer->viewport.x + points[i].x,
.y = (float)renderer->viewport.y + points[i].y,
/* TODO this code used to add the viewport x/y, this is broken with
batching. Check if that behaviour was correct */
.x = points[i].x,
.y = points[i].y,
};
}
GX2RUnlockBufferEx(a_position, 0);
return 0;
}
int WIIU_SDL_QueueFillRects(SDL_Renderer* renderer, SDL_RenderCommand* cmd, const SDL_FRect* rects, int count) {
WIIUVec2 *a_position_vals;
cmd->data.draw.count = count * 4 /* 4 vertexes per rect */;
a_position_vals = SDL_AllocateRenderVertices(renderer,
sizeof (WIIUVec2) /* float x/y for each point */
* cmd->data.draw.count,
4, //TODO align
&cmd->data.draw.first
);
for (int i = 0; i < count; ++i) {
a_position_vals[i*4 + 0] = (WIIUVec2) {
/* TODO this code used to add the viewport x/y, this is broken with
batching. Check if that behaviour was correct */
.x = rects[i].x,
.y = rects[i].y,
};
a_position_vals[i*4 + 1] = (WIIUVec2) {
.x = rects[i].x + rects[i].w,
.y = rects[i].y,
};
a_position_vals[i*4 + 2] = (WIIUVec2) {
.x = rects[i].x + rects[i].w,
.y = rects[i].y + rects[i].h,
};
a_position_vals[i*4 + 3] = (WIIUVec2) {
.x = rects[i].x,
.y = rects[i].y + rects[i].h,
};
}
return 0;
}
void WIIU_SDL_RenderDrawPrimitive(SDL_Renderer * renderer, SDL_RenderCommand* cmd, void* vertexes) {
WIIU_RenderData *data = (WIIU_RenderData *) renderer->driverdata;
size_t count, stride;
WIIUVec4 u_colour = {
.r = (float)cmd->data.draw.r / 255.0f,
.g = (float)cmd->data.draw.g / 255.0f,
.b = (float)cmd->data.draw.b / 255.0f,
.a = (float)cmd->data.draw.a / 255.0f,
};
count = cmd->data.draw.count;
stride = sizeof(WIIUVec2);
/* Invalidate caches related to vertexes */
GX2Invalidate(
GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER,
vertexes,
count * stride
);
/* Render points */
wiiuSetColorShader();
GX2RSetAttributeBuffer(a_position, 0, a_position->elemSize, 0);
GX2SetAttribBuffer(0, count * stride, stride, vertexes);
GX2SetVertexUniformReg(wiiuColorShader.vertexShader->uniformVars[0].offset, 4, (uint32_t *)&data->u_viewSize);
GX2SetPixelUniformReg(wiiuColorShader.pixelShader->uniformVars[0].offset, 4, (uint32_t *)&u_colour);
WIIU_SDL_SetGX2BlendMode(renderer->blendMode);
GX2DrawEx(GX2_PRIMITIVE_MODE_POINTS, count, 0, 1);
return 0;
}
int WIIU_SDL_RenderDrawLines(SDL_Renderer * renderer, const SDL_FPoint * points,
int count)
{
WIIU_RenderData *data = (WIIU_RenderData *) renderer->driverdata;
GX2RBuffer *a_position;
WIIUVec2 *a_position_vals;
/* Compute colours */
WIIUVec4 u_colour = {
.r = (float)renderer->r / 255.0f,
.g = (float)renderer->g / 255.0f,
.b = (float)renderer->b / 255.0f,
.a = (float)renderer->a / 255.0f,
};
/* Allocate attribute buffers */
a_position = WIIU_AllocRenderData(data, (GX2RBuffer) {
.flags =
GX2R_RESOURCE_BIND_VERTEX_BUFFER |
GX2R_RESOURCE_USAGE_CPU_WRITE,
.elemSize = sizeof(WIIUVec2), /* float x/y for each point */
.elemCount = count,
});
/* Compute vertex positions */
a_position_vals = GX2RLockBufferEx(a_position, 0);
for (int i = 0; i < count; ++i) {
a_position_vals[i] = (WIIUVec2) {
.x = (float)renderer->viewport.x + points[i].x,
.y = (float)renderer->viewport.y + points[i].y,
};
WIIU_SDL_SetGX2BlendMode(cmd->data.draw.blend);
if (cmd->command == SDL_RENDERCMD_DRAW_POINTS) {
GX2DrawEx(GX2_PRIMITIVE_MODE_POINTS, count, 0, 1);
} else if (cmd->command == SDL_RENDERCMD_DRAW_LINES) {
GX2DrawEx(GX2_PRIMITIVE_MODE_LINE_STRIP, count, 0, 1);
} else if (cmd->command == SDL_RENDERCMD_FILL_RECTS) {
GX2DrawEx(GX2_PRIMITIVE_MODE_QUADS, count, 0, 1);
}
GX2RUnlockBufferEx(a_position, 0);
/* Render lines */
wiiuSetColorShader();
GX2RSetAttributeBuffer(a_position, 0, a_position->elemSize, 0);
GX2SetVertexUniformReg(wiiuColorShader.vertexShader->uniformVars[0].offset, 4, (uint32_t *)&data->u_viewSize);
GX2SetPixelUniformReg(wiiuColorShader.pixelShader->uniformVars[0].offset, 4, (uint32_t *)&u_colour);
WIIU_SDL_SetGX2BlendMode(renderer->blendMode);
GX2DrawEx(GX2_PRIMITIVE_MODE_LINE_STRIP, count, 0, 1);
return 0;
}
int WIIU_SDL_RenderFillRects(SDL_Renderer * renderer, const SDL_FRect * rects, int count)
{
WIIU_RenderData *data = (WIIU_RenderData *) renderer->driverdata;
GX2RBuffer *a_position;
WIIUVec2 *a_position_vals;
/* Compute colours */
WIIUVec4 u_colour = {
.r = (float)renderer->r / 255.0f,
.g = (float)renderer->g / 255.0f,
.b = (float)renderer->b / 255.0f,
.a = (float)renderer->a / 255.0f,
};
/* Compute vertex pos */
float vx = (float)renderer->viewport.x;
float vy = (float)renderer->viewport.y;
/* Allocate attribute buffers */
a_position = WIIU_AllocRenderData(data, (GX2RBuffer) {
.flags =
GX2R_RESOURCE_BIND_VERTEX_BUFFER |
GX2R_RESOURCE_USAGE_CPU_WRITE,
.elemSize = sizeof(WIIUVec2), // x/y float per corner
.elemCount = 4 * count, // 4 corners per square
});
/* Compute vertex positions */
a_position_vals = GX2RLockBufferEx(a_position, 0);
for (int i = 0; i < count; ++i) {
a_position_vals[i*4 + 0] = (WIIUVec2) {
.x = vx + rects[i].x,
.y = vy + rects[i].y,
};
a_position_vals[i*4 + 1] = (WIIUVec2) {
.x = vx + rects[i].x + rects[i].w,
.y = vy + rects[i].y,
};
a_position_vals[i*4 + 2] = (WIIUVec2) {
.x = vx + rects[i].x + rects[i].w,
.y = vy + rects[i].y + rects[i].h,
};
a_position_vals[i*4 + 3] = (WIIUVec2) {
.x = vx + rects[i].x,
.y = vy + rects[i].y + rects[i].h,
};
}
GX2RUnlockBufferEx(a_position, 0);
/* Render rects */
wiiuSetColorShader();
GX2RSetAttributeBuffer(a_position, 0, a_position->elemSize, 0);
GX2SetVertexUniformReg(wiiuColorShader.vertexShader->uniformVars[0].offset, 4, (uint32_t *)&data->u_viewSize);
GX2SetPixelUniformReg(wiiuColorShader.pixelShader->uniformVars[0].offset, 4, (uint32_t *)&u_colour);
WIIU_SDL_SetGX2BlendMode(renderer->blendMode);
GX2DrawEx(GX2_PRIMITIVE_MODE_QUADS, 4 * count, 0, 1);
return 0;
}
int WIIU_SDL_RenderClear(SDL_Renderer * renderer)
{
WIIU_RenderData* data = (WIIU_RenderData*) renderer->driverdata;
SDL_Texture* target = WIIU_GetRenderTarget(renderer);
WIIU_TextureData* tdata = (WIIU_TextureData*) target->driverdata;
GX2ClearColor(&tdata->cbuf,
(float)renderer->r / 255.0f,
(float)renderer->g / 255.0f,
(float)renderer->b / 255.0f,
(float)renderer->a / 255.0f);
/* Restore SDL context state */
GX2SetContextState(data->ctx);
return 0;
}
static void WIIU_SDL_SetGX2BlendMode(SDL_BlendMode mode)

65
src/render/wiiu/SDL_render_wiiu.c
View File

@ -32,11 +32,17 @@
#include <gx2/event.h>
#include <gx2/registers.h>
#include <gx2r/surface.h>
#include <gx2/clear.h>
#include <malloc.h>
SDL_RenderDriver WIIU_RenderDriver;
//TODO temp stubs
int WIIU_SDL_stub(SDL_Renderer * renderer, SDL_RenderCommand *cmd) {
return 0;
}
SDL_Renderer *WIIU_SDL_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
@ -59,20 +65,20 @@ SDL_Renderer *WIIU_SDL_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->WindowEvent = WIIU_SDL_WindowEvent;
renderer->GetOutputSize = WIIU_SDL_GetOutputSize;
renderer->CreateTexture = WIIU_SDL_CreateTexture;
renderer->SetTextureColorMod = WIIU_SDL_SetTextureColorMod;
renderer->SetTextureAlphaMod = WIIU_SDL_SetTextureAlphaMod;
renderer->UpdateTexture = WIIU_SDL_UpdateTexture;
renderer->LockTexture = WIIU_SDL_LockTexture;
renderer->UnlockTexture = WIIU_SDL_UnlockTexture;
renderer->SetRenderTarget = WIIU_SDL_SetRenderTarget;
renderer->UpdateViewport = WIIU_SDL_UpdateViewport;
renderer->UpdateClipRect = WIIU_SDL_UpdateClipRect;
renderer->RenderClear = WIIU_SDL_RenderClear;
renderer->RenderDrawPoints = WIIU_SDL_RenderDrawPoints;
renderer->RenderDrawLines = WIIU_SDL_RenderDrawLines;
renderer->RenderFillRects = WIIU_SDL_RenderFillRects;
renderer->RenderCopy = WIIU_SDL_RenderCopy;
renderer->RenderCopyEx = WIIU_SDL_RenderCopyEx;
renderer->RunCommandQueue = WIIU_SDL_RunCommandQueue;
renderer->QueueDrawPoints = WIIU_SDL_QueueDrawPointsLines;
renderer->QueueDrawLines = WIIU_SDL_QueueDrawPointsLines;
renderer->QueueCopy = WIIU_SDL_QueueCopy;
renderer->QueueCopyEx = WIIU_SDL_QueueCopyEx;
renderer->QueueSetViewport = WIIU_SDL_stub;
renderer->QueueSetDrawColor = WIIU_SDL_stub;
renderer->RenderReadPixels = WIIU_SDL_RenderReadPixels;
renderer->RenderPresent = WIIU_SDL_RenderPresent;
renderer->DestroyTexture = WIIU_SDL_DestroyTexture;
@ -151,6 +157,45 @@ void WIIU_SDL_CreateWindowTex(SDL_Renderer * renderer, SDL_Window * window)
WIIU_SDL_CreateTexture(renderer, &data->windowTex);
}
int WIIU_SDL_RunCommandQueue(SDL_Renderer* renderer, SDL_RenderCommand* cmd, void* vertexes, size_t vertsize) {
//todo set gpu context
while (cmd) {
switch (cmd->command) {
case SDL_RENDERCMD_CLEAR: {
WIIU_RenderData* data = (WIIU_RenderData*) renderer->driverdata;
SDL_Texture* target = WIIU_GetRenderTarget(renderer);
WIIU_TextureData* tdata = (WIIU_TextureData*) target->driverdata;
GX2ClearColor(&tdata->cbuf,
(float)cmd->data.color.r / 255.0f,
(float)cmd->data.color.g / 255.0f,
(float)cmd->data.color.b / 255.0f,
(float)cmd->data.color.a / 255.0f);
/* Restore SDL context state */
GX2SetContextState(data->ctx);
break;
}
case SDL_RENDERCMD_DRAW_POINTS:
case SDL_RENDERCMD_DRAW_LINES:
case SDL_RENDERCMD_FILL_RECTS: {
WIIU_SDL_RenderDrawPrimitive(renderer, cmd, vertexes + cmd->data.draw.first);
break;
}
case SDL_RENDERCMD_COPY:
case SDL_RENDERCMD_COPY_EX: {
WIIU_SDL_RenderCopy(renderer, cmd, vertexes + cmd->data.draw.first);
break;
}
case SDL_RENDERCMD_NO_OP: break;
default: break; //TODO temp
}
cmd = cmd->next;
}
return 0;
}
int WIIU_SDL_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
{
WIIU_RenderData *data = (WIIU_RenderData *) renderer->driverdata;

24
src/render/wiiu/SDL_render_wiiu.h
View File

@ -110,10 +110,6 @@ void WIIU_SDL_WindowEvent(SDL_Renderer * renderer,
const SDL_WindowEvent *event);
int WIIU_SDL_GetOutputSize(SDL_Renderer * renderer, int *w, int *h);
int WIIU_SDL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
int WIIU_SDL_SetTextureColorMod(SDL_Renderer * renderer,
SDL_Texture * texture);
int WIIU_SDL_SetTextureAlphaMod(SDL_Renderer * renderer,
SDL_Texture * texture);
int WIIU_SDL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels,
int pitch);
@ -123,20 +119,18 @@ void WIIU_SDL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
int WIIU_SDL_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture);
int WIIU_SDL_UpdateViewport(SDL_Renderer * renderer);
int WIIU_SDL_UpdateClipRect(SDL_Renderer * renderer);
int WIIU_SDL_RenderClear(SDL_Renderer * renderer);
int WIIU_SDL_RenderDrawPoints(SDL_Renderer * renderer,
const SDL_FPoint * points, int count);
int WIIU_SDL_RenderDrawLines(SDL_Renderer * renderer,
const SDL_FPoint * points, int count);
int WIIU_SDL_RenderFillRects(SDL_Renderer * renderer,
const SDL_FRect * rects, int count);
int WIIU_SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
int WIIU_SDL_RunCommandQueue(SDL_Renderer* renderer, SDL_RenderCommand* cmd, void* vertexes, size_t vertsize);
int WIIU_SDL_QueueDrawPointsLines(SDL_Renderer* renderer, SDL_RenderCommand* cmd, const SDL_FPoint* points, int count);
int WIIU_SDL_QueueFillRects(SDL_Renderer* renderer, SDL_RenderCommand* cmd, const SDL_FRect* rects, int count);
void WIIU_SDL_RenderDrawPrimitive(SDL_Renderer * renderer, SDL_RenderCommand* cmd, void* vertexes);
int WIIU_SDL_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_FRect * dstrect);
void WIIU_SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
void* vertexes, size_t vertex_count);
int WIIU_SDL_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
const SDL_Rect *srcrect, const SDL_FRect *dstrect,
const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip);
void WIIU_SDL_RenderCopy(SDL_Renderer * renderer, SDL_RenderCommand* cmd, void* vertexes);
int WIIU_SDL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch);
void WIIU_SDL_RenderPresent(SDL_Renderer * renderer);

22
src/render/wiiu/SDL_rtexture_wiiu.c
View File

@ -183,28 +183,6 @@ int WIIU_SDL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
return 0;
}
int WIIU_SDL_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
WIIU_TextureData *tdata = (WIIU_TextureData *) texture->driverdata;
/* Compute color mod */
tdata->u_mod.r = (float)texture->r / 255.0f;
tdata->u_mod.g = (float)texture->g / 255.0f;
tdata->u_mod.b = (float)texture->b / 255.0f;
return 0;
}
int WIIU_SDL_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
WIIU_TextureData *tdata = (WIIU_TextureData *) texture->driverdata;
/* Compute alpha mod */
tdata->u_mod.a = (float)texture->a / 255.0f;
return 0;
}
void WIIU_SDL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
WIIU_RenderData *data;