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 v2

tranform_v2.diff (text/plain), 20.62 KB, created by Guillaume Laforie on 2013-11-24 20:16:01 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Guillaume Laforie

Created: 2013-11-24 20:16:01 UTC

Size: 20.62 KB

patch

obsolete

>diff --git a/include/SDL_render.h b/include/SDL_render.h
>--- a/include/SDL_render.h
>+++ b/include/SDL_render.h
>@@ -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
>+                                                     transform */
> } SDL_RendererFlags;
> 
> /**
>@@ -796,6 +798,84 @@
>                                            const SDL_RendererFlip flip);
> 
> /**
>+ *  \brief push a rotation to the transform stack
>+ *
>+ *  \param renderer The renderer affected by this transform.
>+ *  \param angle    An angle in degrees that indicates the rotation that will be applied to next drawing operations
>+ *  \param center   A pointer to a point indicating rotation center
>+ *
>+ *  Each renderer has a tranform stack in order to change the destination of next drawing operation.
>+ *  It doesn't chage the viewport so after a transform "push", it doesn't reflect the entire drawing area.
>+ *  Each "push" are cumulative, see SDL_RenderPopTransform for undoing the transform.
>+ *
>+ *  This particular function introduce a rotation for next drawing operation.
>+ *
>+ *  This function will fail if renderer doesn't support SDL_RENDERER_TRANSFORM in flags.
>+ *
>+ *  \return 0 on success, or -1 on error
>+ */
>+extern DECLSPEC int SDLCALL SDL_RenderPushTransformRotation(SDL_Renderer * renderer,
>+															const double angle,
>+                                                            const SDL_Point *center);
>+
>+/**
>+ *  \brief push a rotation to the transform stack
>+ *
>+ *  \param renderer The renderer affected by this transform.
>+ *  \param offsetx   the scaling factor for the X axis
>+ *  \param offsety   the scaling factor for the Y axis
>+ *
>+ *  Each renderer has a tranform stack in order to change the destination of next drawing operation.
>+ *  It doesn't chage the viewport so after a transform "push", it doesn't reflect the entire drawing area.
>+ *  Each "push" are cumulative, see SDL_RenderPopTransform for undoing the transform.
>+ *
>+ *  This particular function introduce a translation for next drawing operation.
>+ *
>+ *  This function will fail if renderer doesn't support SDL_RENDERER_TRANSFORM in flags.
>+ *
>+ *  \return 0 on success, or -1 on error
>+ */
>+extern DECLSPEC int SDLCALL SDL_RenderPushTransformTranslation(SDL_Renderer * renderer,
>+															   int offsetx, int offsety);
>+
>+/**
>+ *  \brief push a rotation to the transform stack
>+ *
>+ *  \param renderer The renderer affected by this transform.
>+ *  \param scalex   the scaling factor for the X axis
>+ *  \param scaley   the scaling factor for the Y axis
>+ *
>+ *  Each renderer has a tranform stack in order to change the destination of next drawing operation.
>+ *  It doesn't chage the viewport so after a transform "push", it doesn't reflect the entire drawing area.
>+ *  Each "push" are cumulative, see SDL_RenderPopTransform for undoing the transform.
>+ *
>+ *  This particular function introduce a scale for next drawing operation.
>+ *
>+ *  This function will fail if renderer doesn't support SDL_RENDERER_TRANSFORM in flags.
>+ *
>+ *  \return 0 on success, or -1 on error
>+ */
>+extern DECLSPEC int SDLCALL SDL_RenderPushTransformScale(SDL_Renderer * renderer,
>+												         float scalex, float scaley);
>+
>+/**
>+ *  \brief push a rotation to the transform stack
>+ *
>+ *  \param renderer The renderer affected by this transform.
>+ *
>+ *  Each renderer has a tranform stack in order to change the destination of next drawing operation.
>+ *  It doesn't chage the viewport so after a transform "push", it doesn't reflect the entire drawing area.
>+ *  Each "push" are cumulative, see SDL_RenderPopTransform for undoing the transform.
>+ *
>+ *  This particular function pop one transform from the stack (ie it undo the last tranform push).
>+ *
>+ *  This function will fail if renderer doesn't support SDL_RENDERER_TRANSFORM in flags.
>+ *
>+ *  \return 0 on success, or -1 on error
>+ */
>+extern DECLSPEC int SDLCALL SDL_RenderPopTransform(SDL_Renderer * renderer);
>+
>+/**
>  *  \brief Read pixels from the current rendering target.
>  *
>  *  \param renderer The renderer from which pixels should be read.
>diff --git a/src/render/SDL_render.c b/src/render/SDL_render.c
>--- a/src/render/SDL_render.c
>+++ b/src/render/SDL_render.c
>@@ -44,6 +44,10 @@
>         return retval; \
>     }
> 
>+#define CHECK_TRANSFORM(renderer) \
>+    if ((renderer->info.flags & SDL_RENDERER_TRANSFORM) == 0) { \
>+        return SDL_SetError("Renderer doesn't support transform"); \
>+    } 
> 
> #if !SDL_RENDER_DISABLED
> static const SDL_RenderDriver *render_drivers[] = {
>@@ -1748,6 +1752,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 --git a/src/render/SDL_sysrender.h b/src/render/SDL_sysrender.h
>--- a/src/render/SDL_sysrender.h
>+++ b/src/render/SDL_sysrender.h
>@@ -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 --git a/src/render/direct3d/SDL_render_d3d.c b/src/render/direct3d/SDL_render_d3d.c
>--- a/src/render/direct3d/SDL_render_d3d.c
>+++ b/src/render/direct3d/SDL_render_d3d.c
>@@ -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::SetTransform()", 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::SetTransform()", result);
>+    }
>+    return 0;
>+}
>+
> static int
> D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
>                      Uint32 format, void * pixels, int pitch)
>diff --git a/src/render/opengl/SDL_glfuncs.h b/src/render/opengl/SDL_glfuncs.h
>--- a/src/render/opengl/SDL_glfuncs.h
>+++ b/src/render/opengl/SDL_glfuncs.h
>@@ -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 --git a/src/render/opengl/SDL_render_gl.c b/src/render/opengl/SDL_render_gl.c
>--- a/src/render/opengl/SDL_render_gl.c
>+++ b/src/render/opengl/SDL_render_gl.c
>@@ -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 --git a/src/test/SDL_test_common.c b/src/test/SDL_test_common.c
>--- a/src/test/SDL_test_common.c
>+++ b/src/test/SDL_test_common.c
>@@ -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 --git a/test/testdraw2.c b/test/testdraw2.c
>--- a/test/testdraw2.c
>+++ b/test/testdraw2.c
>@@ -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.