test/testintersections.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 25 Apr 2013 00:26:17 -0700
changeset 7110 2a98852fd58d
parent 6785 c094c438c0a6
child 7191 75360622e65f
permissions -rw-r--r--
Fixed bug 1582 - Allow disabling SDL_VIDEO_DRIVER_WINDOWS

Marcus von Appen

Trying to build SDL 2.x (HG) on Win32 platforms with either VS.NET or MinGW requires one to have the video subsystem and SDL_VIDEO_DRIVER_WINDOWS flag enabled due to the helper window creation routines.

The attached patch changes the helper window creation behaviour, so that one can build SDL2 without the video subsystem or Windows video drivers on Win32 platforms.
     1 /*
     2   Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
     3 
     4   This software is provided 'as-is', without any express or implied
     5   warranty.  In no event will the authors be held liable for any damages
     6   arising from the use of this software.
     7 
     8   Permission is granted to anyone to use this software for any purpose,
     9   including commercial applications, and to alter it and redistribute it
    10   freely.
    11 */
    12 
    13 /* Simple program:  draw as many random objects on the screen as possible */
    14 
    15 #include <stdlib.h>
    16 #include <stdio.h>
    17 #include <time.h>
    18 
    19 #include "SDL_test_common.h"
    20 
    21 #define SWAP(typ,a,b) do{typ t=a;a=b;b=t;}while(0)
    22 #define NUM_OBJECTS	100
    23 
    24 static SDLTest_CommonState *state;
    25 static int num_objects;
    26 static SDL_bool cycle_color;
    27 static SDL_bool cycle_alpha;
    28 static int cycle_direction = 1;
    29 static int current_alpha = 255;
    30 static int current_color = 255;
    31 static SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
    32 
    33 void
    34 DrawPoints(SDL_Renderer * renderer)
    35 {
    36     int i;
    37     int x, y;
    38     SDL_Rect viewport;
    39 
    40     /* Query the sizes */
    41     SDL_RenderGetViewport(renderer, &viewport);
    42 
    43     for (i = 0; i < num_objects * 4; ++i) {
    44         /* Cycle the color and alpha, if desired */
    45         if (cycle_color) {
    46             current_color += cycle_direction;
    47             if (current_color < 0) {
    48                 current_color = 0;
    49                 cycle_direction = -cycle_direction;
    50             }
    51             if (current_color > 255) {
    52                 current_color = 255;
    53                 cycle_direction = -cycle_direction;
    54             }
    55         }
    56         if (cycle_alpha) {
    57             current_alpha += cycle_direction;
    58             if (current_alpha < 0) {
    59                 current_alpha = 0;
    60                 cycle_direction = -cycle_direction;
    61             }
    62             if (current_alpha > 255) {
    63                 current_alpha = 255;
    64                 cycle_direction = -cycle_direction;
    65             }
    66         }
    67         SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
    68                                (Uint8) current_color, (Uint8) current_alpha);
    69 
    70         x = rand() % viewport.w;
    71         y = rand() % viewport.h;
    72         SDL_RenderDrawPoint(renderer, x, y);
    73     }
    74 }
    75 
    76 #define MAX_LINES 16
    77 int num_lines = 0;
    78 SDL_Rect lines[MAX_LINES];
    79 static int
    80 add_line(int x1, int y1, int x2, int y2)
    81 {
    82     if (num_lines >= MAX_LINES)
    83         return 0;
    84     if ((x1 == x2) && (y1 == y2))
    85         return 0;
    86 
    87     printf("adding line (%d, %d), (%d, %d)\n", x1, y1, x2, y2);
    88     lines[num_lines].x = x1;
    89     lines[num_lines].y = y1;
    90     lines[num_lines].w = x2;
    91     lines[num_lines].h = y2;
    92 
    93     return ++num_lines;
    94 }
    95 
    96 
    97 void
    98 DrawLines(SDL_Renderer * renderer)
    99 {
   100     int i;
   101     int x1, y1, x2, y2;
   102     SDL_Rect viewport;
   103 
   104     /* Query the sizes */
   105     SDL_RenderGetViewport(renderer, &viewport);
   106 
   107     SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
   108 
   109     for (i = 0; i < num_lines; ++i) {
   110         if (i == -1) {
   111             SDL_RenderDrawLine(renderer, 0, 0, viewport.w - 1, viewport.h - 1);
   112             SDL_RenderDrawLine(renderer, 0, viewport.h - 1, viewport.w - 1, 0);
   113             SDL_RenderDrawLine(renderer, 0, viewport.h / 2, viewport.w - 1, viewport.h / 2);
   114             SDL_RenderDrawLine(renderer, viewport.w / 2, 0, viewport.w / 2, viewport.h - 1);
   115         } else {
   116             SDL_RenderDrawLine(renderer, lines[i].x, lines[i].y, lines[i].w, lines[i].h);
   117         }
   118     }
   119 }
   120 
   121 #define MAX_RECTS 16
   122 int num_rects = 0;
   123 SDL_Rect rects[MAX_RECTS];
   124 static int
   125 add_rect(int x1, int y1, int x2, int y2)
   126 {
   127     if (num_rects >= MAX_RECTS)
   128         return 0;
   129     if ((x1 == x2) || (y1 == y2))
   130         return 0;
   131 
   132     if (x1 > x2)
   133         SWAP(int, x1, x2);
   134     if (y1 > y2)
   135         SWAP(int, y1, y2);
   136 
   137     printf("adding rect (%d, %d), (%d, %d) [%dx%d]\n", x1, y1, x2, y2,
   138            x2 - x1, y2 - y1);
   139 
   140     rects[num_rects].x = x1;
   141     rects[num_rects].y = y1;
   142     rects[num_rects].w = x2 - x1;
   143     rects[num_rects].h = y2 - y1;
   144 
   145     return ++num_rects;
   146 }
   147 
   148 static void
   149 DrawRects(SDL_Renderer * renderer)
   150 {
   151     SDL_SetRenderDrawColor(renderer, 255, 127, 0, 255);
   152     SDL_RenderFillRects(renderer, rects, num_rects);
   153 }
   154 
   155 static void
   156 DrawRectLineIntersections(SDL_Renderer * renderer)
   157 {
   158     int i, j;
   159 
   160     SDL_SetRenderDrawColor(renderer, 0, 255, 55, 255);
   161 
   162     for (i = 0; i < num_rects; i++)
   163         for (j = 0; j < num_lines; j++) {
   164             int x1, y1, x2, y2;
   165             SDL_Rect r;
   166 
   167             r = rects[i];
   168             x1 = lines[j].x;
   169             y1 = lines[j].y;
   170             x2 = lines[j].w;
   171             y2 = lines[j].h;
   172 
   173             if (SDL_IntersectRectAndLine(&r, &x1, &y1, &x2, &y2)) {
   174                 SDL_RenderDrawLine(renderer, x1, y1, x2, y2);
   175             }
   176         }
   177 }
   178 
   179 static void
   180 DrawRectRectIntersections(SDL_Renderer * renderer)
   181 {
   182     int i, j;
   183 
   184     SDL_SetRenderDrawColor(renderer, 255, 200, 0, 255);
   185 
   186     for (i = 0; i < num_rects; i++)
   187         for (j = i + 1; j < num_rects; j++) {
   188             SDL_Rect r;
   189             if (SDL_IntersectRect(&rects[i], &rects[j], &r)) {
   190                 SDL_RenderFillRect(renderer, &r);
   191             }
   192         }
   193 }
   194 
   195 int
   196 main(int argc, char *argv[])
   197 {
   198     int mouse_begin_x = -1, mouse_begin_y = -1;
   199     int i, done;
   200     SDL_Event event;
   201     Uint32 then, now, frames;
   202 
   203     /* Initialize parameters */
   204     num_objects = NUM_OBJECTS;
   205 
   206     /* Initialize test framework */
   207     state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
   208     if (!state) {
   209         return 1;
   210     }
   211     for (i = 1; i < argc;) {
   212         int consumed;
   213 
   214         consumed = SDLTest_CommonArg(state, i);
   215         if (consumed == 0) {
   216             consumed = -1;
   217             if (SDL_strcasecmp(argv[i], "--blend") == 0) {
   218                 if (argv[i + 1]) {
   219                     if (SDL_strcasecmp(argv[i + 1], "none") == 0) {
   220                         blendMode = SDL_BLENDMODE_NONE;
   221                         consumed = 2;
   222                     } else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) {
   223                         blendMode = SDL_BLENDMODE_BLEND;
   224                         consumed = 2;
   225                     } else if (SDL_strcasecmp(argv[i + 1], "add") == 0) {
   226                         blendMode = SDL_BLENDMODE_ADD;
   227                         consumed = 2;
   228                     } else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) {
   229                         blendMode = SDL_BLENDMODE_MOD;
   230                         consumed = 2;
   231                     }
   232                 }
   233             } else if (SDL_strcasecmp(argv[i], "--cyclecolor") == 0) {
   234                 cycle_color = SDL_TRUE;
   235                 consumed = 1;
   236             } else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) {
   237                 cycle_alpha = SDL_TRUE;
   238                 consumed = 1;
   239             } else if (SDL_isdigit(*argv[i])) {
   240                 num_objects = SDL_atoi(argv[i]);
   241                 consumed = 1;
   242             }
   243         }
   244         if (consumed < 0) {
   245             fprintf(stderr,
   246                     "Usage: %s %s [--blend none|blend|add|mod] [--cyclecolor] [--cyclealpha]\n",
   247                     argv[0], SDLTest_CommonUsage(state));
   248             return 1;
   249         }
   250         i += consumed;
   251     }
   252     if (!SDLTest_CommonInit(state)) {
   253         return 2;
   254     }
   255 
   256     /* Create the windows and initialize the renderers */
   257     for (i = 0; i < state->num_windows; ++i) {
   258         SDL_Renderer *renderer = state->renderers[i];
   259         SDL_SetRenderDrawBlendMode(renderer, blendMode);
   260         SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
   261         SDL_RenderClear(renderer);
   262     }
   263 
   264     srand(time(NULL));
   265 
   266     /* Main render loop */
   267     frames = 0;
   268     then = SDL_GetTicks();
   269     done = 0;
   270     while (!done) {
   271         /* Check for events */
   272         ++frames;
   273         while (SDL_PollEvent(&event)) {
   274             SDLTest_CommonEvent(state, &event, &done);
   275             switch (event.type) {
   276             case SDL_MOUSEBUTTONDOWN:
   277                 mouse_begin_x = event.button.x;
   278                 mouse_begin_y = event.button.y;
   279                 break;
   280             case SDL_MOUSEBUTTONUP:
   281                 if (event.button.button == 3)
   282                     add_line(mouse_begin_x, mouse_begin_y, event.button.x,
   283                              event.button.y);
   284                 if (event.button.button == 1)
   285                     add_rect(mouse_begin_x, mouse_begin_y, event.button.x,
   286                              event.button.y);
   287                 break;
   288             case SDL_KEYDOWN:
   289                 switch (event.key.keysym.sym) {
   290                 case 'l':
   291                     if (event.key.keysym.mod & KMOD_SHIFT)
   292                         num_lines = 0;
   293                     else
   294                         add_line(rand() % 640, rand() % 480, rand() % 640,
   295                                  rand() % 480);
   296                     break;
   297                 case 'r':
   298                     if (event.key.keysym.mod & KMOD_SHIFT)
   299                         num_rects = 0;
   300                     else
   301                         add_rect(rand() % 640, rand() % 480, rand() % 640,
   302                                  rand() % 480);
   303                     break;
   304                 }
   305                 break;
   306             default:
   307                 break;
   308             }
   309         }
   310         for (i = 0; i < state->num_windows; ++i) {
   311             SDL_Renderer *renderer = state->renderers[i];
   312             SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
   313             SDL_RenderClear(renderer);
   314 
   315             DrawRects(renderer);
   316             DrawPoints(renderer);
   317             DrawRectRectIntersections(renderer);
   318             DrawLines(renderer);
   319             DrawRectLineIntersections(renderer);
   320 
   321             SDL_RenderPresent(renderer);
   322         }
   323     }
   324 
   325     SDLTest_CommonQuit(state);
   326 
   327     /* Print out some timing information */
   328     now = SDL_GetTicks();
   329     if (now > then) {
   330         double fps = ((double) frames * 1000) / (now - then);
   331         printf("%2.2f frames per second\n", fps);
   332     }
   333     return 0;
   334 }
   335 
   336 /* vi: set ts=4 sw=4 expandtab: */