We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

[patch] add transform stack to the renderer api v1

tranform_v1.diff (text/plain), 18.09 KB, created by Guillaume Laforie on 2013-11-19 22:13:51 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Guillaume Laforie

Created: 2013-11-19 22:13:51 UTC

Size: 18.09 KB

patch

obsolete

>diff -r ffd65b452bd2 -r 84d5f294019d include/SDL_render.h
>--- a/include/SDL_render.h	Mon Nov 18 23:45:46 2013 +0100
>+++ b/include/SDL_render.h	Tue Nov 19 22:47:41 2013 +0100
>@@ -68,8 +68,10 @@
>                                                      acceleration */
>     SDL_RENDERER_PRESENTVSYNC = 0x00000004,     /**< Present is synchronized
>                                                      with the refresh rate */
>-    SDL_RENDERER_TARGETTEXTURE = 0x00000008     /**< The renderer supports
>+    SDL_RENDERER_TARGETTEXTURE = 0x00000008,     /**< The renderer supports
>                                                      rendering to texture */
>+    SDL_RENDERER_TRANSFORM = 0x00000010     /**< The renderer supports
>+                                                     tranform */
> } SDL_RendererFlags;
> 
> /**
>@@ -795,6 +797,18 @@
>                                            const SDL_Point *center,
>                                            const SDL_RendererFlip flip);
> 
>+extern DECLSPEC int SDLCALL SDL_RenderPushTransformRotation(SDL_Renderer * renderer,
>+															const double angle,
>+                                                            const SDL_Point *center);
>+
>+extern DECLSPEC int SDLCALL SDL_RenderPushTransformTranslation(SDL_Renderer * renderer,
>+															   int offsetx, int offsety);
>+
>+extern DECLSPEC int SDLCALL SDL_RenderPushTransformScale(SDL_Renderer * renderer,
>+												         float scaleX, float scaleY);
>+
>+extern DECLSPEC int SDLCALL SDL_RenderPopTransform(SDL_Renderer * renderer);
>+
> /**
>  *  \brief Read pixels from the current rendering target.
>  *
>diff -r ffd65b452bd2 -r 84d5f294019d src/render/SDL_render.c
>--- a/src/render/SDL_render.c	Mon Nov 18 23:45:46 2013 +0100
>+++ b/src/render/SDL_render.c	Tue Nov 19 22:47:41 2013 +0100
>@@ -44,6 +44,11 @@
>         return retval; \
>     }
> 
>+#define CHECK_TRANSFORM(renderer) \
>+    if ((renderer->info.flags & SDL_RENDERER_TRANSFORM) == 0) { \
>+        SDL_SetError("Renderer doesn't support transform"); \
>+        return -1; \
>+    } 
> 
> #if !SDL_RENDER_DISABLED
> static const SDL_RenderDriver *render_drivers[] = {
>@@ -1748,6 +1753,117 @@
>     return renderer->RenderCopyEx(renderer, texture, &real_srcrect, &frect, angle, &fcenter, flip);
> }
> 
>+
>+static void MatrixMultiply(SDL_FMatrix *result, const SDL_FMatrix *m2, const SDL_FMatrix *m1)
>+{
>+    int i,j;
>+    for (i=0; i<4; i++)
>+    {
>+        for (j=0; j<4; j++)
>+        {
>+            result->m[i][j] = m1->m[i][0] * m2->m[0][j] + m1->m[i][1] * m2->m[1][j] + m1->m[i][2] * m2->m[2][j] + m1->m[i][3] * m2->m[3][j];
>+        }
>+    }
>+}
>+
>+static void MatrixIdentity(SDL_FMatrix *result)
>+{
>+    result->m[0][0] = 1.0f;   result->m[0][1] = 0.0f;   result->m[0][2] = 0.0f;   result->m[0][3] = 0.0f;
>+	result->m[1][0] = 0.0f;   result->m[1][1] = 1.0f;   result->m[1][2] = 0.0f;   result->m[1][3] = 0.0f;
>+	result->m[2][0] = 0.0f;   result->m[2][1] = 0.0f;   result->m[2][2] = 1.0f;   result->m[2][3] = 0.0f;
>+	result->m[3][0] = 0.0f;   result->m[3][1] = 0.0f;   result->m[3][2] = 0.0f;   result->m[3][3] = 1.0f;
>+}
>+
>+static void MatrixRotate(SDL_FMatrix *result, const double angle)
>+{
>+    double radangle;
>+
>+    radangle = angle * (M_PI / 180.0);
>+
>+    MatrixIdentity(result);
>+    result->m[0][0] = SDL_cos(radangle);   result->m[0][1] = -SDL_sin(radangle);
>+	result->m[1][0] = SDL_sin(radangle);   result->m[1][1] = SDL_cos(radangle);     
>+}
>+
>+static void MatrixTranslate(SDL_FMatrix *result, int offsetx, int offsety)
>+{
>+    MatrixIdentity(result);
>+    result->m[0][3] = offsetx;
>+	result->m[1][3] = offsety;     
>+}
>+
>+static void MatrixScale(SDL_FMatrix *result,  float scaleX, float scaleY)
>+{
>+    MatrixIdentity(result);
>+    result->m[0][0] = scaleX;
>+	result->m[1][1] = scaleY;     
>+}
>+
>+int
>+SDL_RenderPushTransformRotation(SDL_Renderer * renderer, const double angle, const SDL_Point *center)
>+{
>+	SDL_FMatrix m;
>+	SDL_FMatrix m1;
>+	SDL_FMatrix m2;
>+
>+    SDL_Point real_center;
>+    SDL_Rect viewport;
>+    
>+    CHECK_RENDERER_MAGIC(renderer, -1);
>+    CHECK_TRANSFORM(renderer);
>+
>+    if (center) {
>+         real_center = *center;
>+    } else {
>+        SDL_RenderGetViewport(renderer, &viewport);
>+        real_center.x = viewport.w/2;
>+        real_center.y = viewport.h/2;
>+    }
>+    MatrixTranslate(&m1, -real_center.x, -real_center.y);
>+    MatrixRotate(&m2, angle);
>+    MatrixMultiply(&m, &m1, &m2);
>+    MatrixTranslate(&m1, real_center.x, real_center.y);
>+    MatrixMultiply(&m2, &m, &m1);
>+
>+    return renderer->PushTransformMatrix(renderer, &m2);
>+}
>+
>+int
>+SDL_RenderPushTransformTranslation(SDL_Renderer * renderer, int offsetx, int offsety)
>+{
>+    SDL_FMatrix m;
>+
>+	CHECK_RENDERER_MAGIC(renderer, -1);
>+    CHECK_TRANSFORM(renderer);
>+
>+    MatrixTranslate(&m, offsetx, offsety);
>+
>+    return renderer->PushTransformMatrix(renderer, &m);
>+}
>+
>+int
>+SDL_RenderPushTransformScale(SDL_Renderer * renderer, float scaleX, float scaleY)
>+{
>+    SDL_FMatrix m;
>+
>+    CHECK_RENDERER_MAGIC(renderer, -1);
>+    CHECK_TRANSFORM(renderer);
>+
>+    MatrixScale(&m, scaleX, scaleY);
>+
>+    return renderer->PushTransformMatrix(renderer, &m);
>+}
>+
>+int
>+SDL_RenderPopTransform(SDL_Renderer * renderer)
>+{
>+	CHECK_RENDERER_MAGIC(renderer, -1);
>+    CHECK_TRANSFORM(renderer);
>+
>+    return renderer->PopTransformMatrix(renderer);
>+}
>+
>+
> int
> SDL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
>                      Uint32 format, void * pixels, int pitch)
>diff -r ffd65b452bd2 -r 84d5f294019d src/render/SDL_sysrender.h
>--- a/src/render/SDL_sysrender.h	Mon Nov 18 23:45:46 2013 +0100
>+++ b/src/render/SDL_sysrender.h	Tue Nov 19 22:47:41 2013 +0100
>@@ -45,6 +45,11 @@
>     float h;
> } SDL_FRect;
> 
>+typedef struct
>+{
>+    float m[4][4]; //row first
>+} SDL_FMatrix;
>+
> /* Define the SDL texture structure */
> struct SDL_Texture
> {
>@@ -112,6 +117,8 @@
>     int (*RenderCopyEx) (SDL_Renderer * renderer, SDL_Texture * texture,
>                        const SDL_Rect * srcquad, const SDL_FRect * dstrect,
>                        const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip);
>+    int (*PushTransformMatrix)(SDL_Renderer * renderer, const SDL_FMatrix *matrix);
>+    int (*PopTransformMatrix)(SDL_Renderer * renderer);
>     int (*RenderReadPixels) (SDL_Renderer * renderer, const SDL_Rect * rect,
>                              Uint32 format, void * pixels, int pitch);
>     void (*RenderPresent) (SDL_Renderer * renderer);
>diff -r ffd65b452bd2 -r 84d5f294019d src/render/direct3d/SDL_render_d3d.c
>--- a/src/render/direct3d/SDL_render_d3d.c	Mon Nov 18 23:45:46 2013 +0100
>+++ b/src/render/direct3d/SDL_render_d3d.c	Tue Nov 19 22:47:41 2013 +0100
>@@ -230,6 +230,8 @@
> static int D3D_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
>                           const SDL_Rect * srcrect, const SDL_FRect * dstrect,
>                           const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip);
>+static int D3D_PushTransformMatrix(SDL_Renderer * renderer, const SDL_FMatrix *matrix);
>+static int D3D_PopTransformMatrix(SDL_Renderer * renderer);
> static int D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
>                                 Uint32 format, void * pixels, int pitch);
> static void D3D_RenderPresent(SDL_Renderer * renderer);
>@@ -242,7 +244,7 @@
>     D3D_CreateRenderer,
>     {
>      "direct3d",
>-     (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE),
>+     (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE | SDL_RENDERER_TRANSFORM),
>      1,
>      {SDL_PIXELFORMAT_ARGB8888},
>      0,
>@@ -612,6 +614,8 @@
>     renderer->RenderFillRects = D3D_RenderFillRects;
>     renderer->RenderCopy = D3D_RenderCopy;
>     renderer->RenderCopyEx = D3D_RenderCopyEx;
>+    renderer->PushTransformMatrix = D3D_PushTransformMatrix;
>+    renderer->PopTransformMatrix = D3D_PopTransformMatrix;
>     renderer->RenderReadPixels = D3D_RenderReadPixels;
>     renderer->RenderPresent = D3D_RenderPresent;
>     renderer->DestroyTexture = D3D_DestroyTexture;
>@@ -619,7 +623,7 @@
>     renderer->info = D3D_RenderDriver.info;
>     renderer->driverdata = data;
> 
>-    renderer->info.flags = SDL_RENDERER_ACCELERATED;
>+    renderer->info.flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_TRANSFORM;
> 
>     SDL_VERSION(&windowinfo.version);
>     SDL_GetWindowWMInfo(window, &windowinfo);
>@@ -1753,6 +1757,62 @@
>     return 0;
> }
> 
>+static int
>+D3D_PushTransformMatrix(SDL_Renderer * renderer, const SDL_FMatrix *matrix)
>+{
>+    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
>+    HRESULT result;
>+    D3DXMATRIX d3d_matrix;
>+    int i,j;
>+
>+    if (D3D_ActivateRenderer(renderer) < 0) {
>+        return -1;
>+    }
>+
>+    for(i=0;i<4;++i) {
>+        for(j=0;j<4;++j) {
>+            d3d_matrix.m[i][j]=matrix->m[j][i];
>+        }
>+    }
>+    result = ID3DXMatrixStack_Push(data->matrixStack);
>+    if (FAILED(result)) {
>+        return D3D_SetError("ID3DXMatrixStack::Push()", result);
>+    }
>+    result = ID3DXMatrixStack_MultMatrix(data->matrixStack,&d3d_matrix);
>+    if (FAILED(result)) {
>+        return D3D_SetError("ID3DXMatrixStack::MultMatrix()", result);
>+    }    
>+
>+    result = IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, ID3DXMatrixStack_GetTop(data->matrixStack));
>+    if (FAILED(result)) {
>+        return D3D_SetError("IDirect3DDevice9::SetTransformp()", result);
>+    }
>+
>+    return 0;
>+}
>+
>+static int
>+D3D_PopTransformMatrix(SDL_Renderer * renderer)
>+{
>+    D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
>+    HRESULT result;
>+
>+    if (D3D_ActivateRenderer(renderer) < 0) {
>+        return -1;
>+    }
>+
>+    result = ID3DXMatrixStack_Pop(data->matrixStack);
>+    if (FAILED(result)) {
>+        return D3D_SetError("ID3DXMatrixStack::Pop()", result);
>+    }
>+
>+    result = IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, ID3DXMatrixStack_GetTop(data->matrixStack));
>+    if (FAILED(result)) {
>+        return D3D_SetError("IDirect3DDevice9::SetTransformp()", result);
>+    }
>+    return 0;
>+}
>+
> static int
> D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
>                      Uint32 format, void * pixels, int pitch)
>diff -r ffd65b452bd2 -r 84d5f294019d src/render/opengl/SDL_glfuncs.h
>--- a/src/render/opengl/SDL_glfuncs.h	Mon Nov 18 23:45:46 2013 +0100
>+++ b/src/render/opengl/SDL_glfuncs.h	Tue Nov 19 22:47:41 2013 +0100
>@@ -137,7 +137,7 @@
> SDL_PROC_UNUSED(void, glGetClipPlane, (GLenum plane, GLdouble * equation))
> SDL_PROC_UNUSED(void, glGetDoublev, (GLenum pname, GLdouble * params))
> SDL_PROC(GLenum, glGetError, (void))
>-SDL_PROC_UNUSED(void, glGetFloatv, (GLenum pname, GLfloat * params))
>+SDL_PROC(void, glGetFloatv, (GLenum pname, GLfloat * params))
> SDL_PROC(void, glGetIntegerv, (GLenum pname, GLint * params))
> SDL_PROC_UNUSED(void, glGetLightfv,
>                 (GLenum light, GLenum pname, GLfloat * params))
>@@ -245,7 +245,7 @@
>                 (GLenum face, GLenum pname, const GLint * params))
> SDL_PROC(void, glMatrixMode, (GLenum mode))
> SDL_PROC_UNUSED(void, glMultMatrixd, (const GLdouble * m))
>-SDL_PROC_UNUSED(void, glMultMatrixf, (const GLfloat * m))
>+SDL_PROC(void, glMultMatrixf, (const GLfloat * m))
> SDL_PROC_UNUSED(void, glNewList, (GLuint list, GLenum mode))
> SDL_PROC_UNUSED(void, glNormal3b, (GLbyte nx, GLbyte ny, GLbyte nz))
> SDL_PROC_UNUSED(void, glNormal3bv, (const GLbyte * v))
>diff -r ffd65b452bd2 -r 84d5f294019d src/render/opengl/SDL_render_gl.c
>--- a/src/render/opengl/SDL_render_gl.c	Mon Nov 18 23:45:46 2013 +0100
>+++ b/src/render/opengl/SDL_render_gl.c	Tue Nov 19 22:47:41 2013 +0100
>@@ -75,6 +75,8 @@
> static int GL_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
>                          const SDL_Rect * srcrect, const SDL_FRect * dstrect,
>                          const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip);
>+static int GL_PushTransformMatrix(SDL_Renderer * renderer, const SDL_FMatrix *matrix);
>+static int GL_PopTransformMatrix(SDL_Renderer * renderer);
> static int GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
>                                Uint32 pixel_format, void * pixels, int pitch);
> static void GL_RenderPresent(SDL_Renderer * renderer);
>@@ -87,7 +89,7 @@
>     GL_CreateRenderer,
>     {
>      "opengl",
>-     (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE),
>+     (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE | SDL_RENDERER_TRANSFORM),
>      1,
>      {SDL_PIXELFORMAT_ARGB8888},
>      0,
>@@ -420,6 +422,8 @@
>     renderer->RenderFillRects = GL_RenderFillRects;
>     renderer->RenderCopy = GL_RenderCopy;
>     renderer->RenderCopyEx = GL_RenderCopyEx;
>+    renderer->PushTransformMatrix = GL_PushTransformMatrix;
>+    renderer->PopTransformMatrix = GL_PopTransformMatrix;
>     renderer->RenderReadPixels = GL_RenderReadPixels;
>     renderer->RenderPresent = GL_RenderPresent;
>     renderer->DestroyTexture = GL_DestroyTexture;
>@@ -427,7 +431,7 @@
>     renderer->GL_BindTexture = GL_BindTexture;
>     renderer->GL_UnbindTexture = GL_UnbindTexture;
>     renderer->info = GL_RenderDriver.info;
>-    renderer->info.flags = SDL_RENDERER_ACCELERATED;
>+    renderer->info.flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_TRANSFORM;
>     renderer->driverdata = data;
>     renderer->window = window;
> 
>@@ -1308,6 +1312,42 @@
> }
> 
> static int
>+GL_PushTransformMatrix(SDL_Renderer * renderer, const SDL_FMatrix *matrix)
>+{
>+    GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
>+    GLfloat gl_matrix[16];
>+    GLfloat gl_topmatrix[16];
>+    int i,j;
>+
>+    GL_ActivateRenderer(renderer);
>+
>+    for(i=0;i<4;++i) {
>+        for(j=0;j<4;++j) {
>+            gl_matrix[i+j*4]=matrix->m[i][j];
>+        }
>+    }
>+    data->glMatrixMode(GL_MODELVIEW);
>+    data->glPushMatrix();
>+    data->glGetFloatv(GL_MODELVIEW_MATRIX,gl_topmatrix);
>+    data->glLoadIdentity();
>+    data->glMultMatrixf(gl_matrix);
>+    data->glMultMatrixf(gl_topmatrix);
>+    return 0;
>+}
>+
>+static int
>+GL_PopTransformMatrix(SDL_Renderer * renderer)
>+{
>+    GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
>+
>+    GL_ActivateRenderer(renderer);
>+
>+    data->glMatrixMode(GL_MODELVIEW);
>+    data->glPopMatrix();
>+    return 0;
>+}
>+
>+static int
> GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
>                     Uint32 pixel_format, void * pixels, int pitch)
> {
>diff -r ffd65b452bd2 -r 84d5f294019d src/test/SDL_test_common.c
>--- a/src/test/SDL_test_common.c	Mon Nov 18 23:45:46 2013 +0100
>+++ b/src/test/SDL_test_common.c	Tue Nov 19 22:47:41 2013 +0100
>@@ -472,6 +472,12 @@
>     case SDL_RENDERER_ACCELERATED:
>         fprintf(stderr, "Accelerated");
>         break;
>+    case SDL_RENDERER_TARGETTEXTURE:
>+        fprintf(stderr, "TargetTexture");
>+        break;
>+    case SDL_RENDERER_TRANSFORM:
>+        fprintf(stderr, "Transform");
>+        break;    
>     default:
>         fprintf(stderr, "0x%8.8x", flag);
>         break;
>diff -r ffd65b452bd2 -r 84d5f294019d test/testdraw2.c
>--- a/test/testdraw2.c	Mon Nov 18 23:45:46 2013 +0100
>+++ b/test/testdraw2.c	Tue Nov 19 22:47:41 2013 +0100
>@@ -16,6 +16,7 @@
> #include <stdio.h>
> #include <time.h>
> 
>+#include "SDL_test.h"
> #include "SDL_test_common.h"
> 
> #define NUM_OBJECTS 100
>@@ -66,8 +67,8 @@
>         SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
>                                (Uint8) current_color, (Uint8) current_alpha);
> 
>-        x = rand() % viewport.w;
>-        y = rand() % viewport.h;
>+        x = SDLTest_RandomIntegerInRange(0,viewport.w);
>+        y = SDLTest_RandomIntegerInRange(0,viewport.h);
>         SDL_RenderDrawPoint(renderer, x, y);
>     }
> }
>@@ -115,10 +116,10 @@
>             SDL_RenderDrawLine(renderer, 0, viewport.h / 2, viewport.w - 1, viewport.h / 2);
>             SDL_RenderDrawLine(renderer, viewport.w / 2, 0, viewport.w / 2, viewport.h - 1);
>         } else {
>-            x1 = (rand() % (viewport.w*2)) - viewport.w;
>-            x2 = (rand() % (viewport.w*2)) - viewport.w;
>-            y1 = (rand() % (viewport.h*2)) - viewport.h;
>-            y2 = (rand() % (viewport.h*2)) - viewport.h;
>+            x1 = SDLTest_RandomIntegerInRange(0,viewport.w);
>+            x2 = SDLTest_RandomIntegerInRange(0,viewport.w);
>+            y1 = SDLTest_RandomIntegerInRange(0,viewport.h);
>+            y2 = SDLTest_RandomIntegerInRange(0,viewport.h);
>             SDL_RenderDrawLine(renderer, x1, y1, x2, y2);
>         }
>     }
>@@ -161,11 +162,12 @@
>         SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
>                                (Uint8) current_color, (Uint8) current_alpha);
> 
>-        rect.w = rand() % (viewport.h / 2);
>-        rect.h = rand() % (viewport.h / 2);
>-        rect.x = (rand() % (viewport.w*2) - viewport.w) - (rect.w / 2);
>-        rect.y = (rand() % (viewport.h*2) - viewport.h) - (rect.h / 2);
>+        rect.w = SDLTest_RandomIntegerInRange(0,viewport.w / 2);
>+        rect.h = SDLTest_RandomIntegerInRange(0,viewport.h / 2);
>+        rect.x = SDLTest_RandomIntegerInRange(0,viewport.w / 2);
>+        rect.y = SDLTest_RandomIntegerInRange(0,viewport.h / 2);
>         SDL_RenderFillRect(renderer, &rect);
>+        SDL_RenderDrawRect(renderer, &viewport);
>     }
> }
> 
>@@ -230,7 +232,7 @@
>     if (!SDLTest_CommonInit(state)) {
>         return 2;
>     }
>-
>+    SDLTest_FuzzerInit(0);
>     /* Create the windows and initialize the renderers */
>     for (i = 0; i < state->num_windows; ++i) {
>         SDL_Renderer *renderer = state->renderers[i];
>@@ -257,11 +259,21 @@
>                 continue;
>             SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
>             SDL_RenderClear(renderer);
>-
>+            {
>+                SDL_Rect viewport;
>+                SDL_Point center;
>+                float scale=1/1.0;
>+                SDL_RenderGetViewport(renderer, &viewport);
>+                center.x = viewport.w/2;
>+                center.y = viewport.h/2;
>+                SDL_RenderPushTransformRotation(renderer, 45, &center);
>+                SDL_RenderPushTransformScale(renderer,scale,scale);
>+            }
>             DrawRects(renderer);
>             DrawLines(renderer);
>             DrawPoints(renderer);
>-
>+            SDL_RenderPopTransform(renderer);
>+            SDL_RenderPopTransform(renderer);
>             SDL_RenderPresent(renderer);
>         }
>     }

Actions: View | Diff

Attachments on bug 2253: 1461 | 1474

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.