This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
testsprite2.c
343 lines (309 loc) · 10.4 KB
1
2
3
4
5
6
7
8
9
10
11
/*
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely.
*/
12
13
14
/* Simple program: Move N sprites around on the screen as fast as possible */
#include <stdlib.h>
15
#include <stdio.h>
16
17
#include <time.h>
18
#include "common.h"
19
20
21
#define NUM_SPRITES 100
#define MAX_SPEED 1
22
23
static CommonState *state;
24
static int num_sprites;
25
static SDL_Texture **sprites;
26
27
28
29
30
static SDL_bool cycle_color;
static SDL_bool cycle_alpha;
static int cycle_direction = 1;
static int current_alpha = 0;
static int current_color = 0;
31
32
33
static SDL_Rect *positions;
static SDL_Rect *velocities;
static int sprite_w, sprite_h;
34
static SDL_BlendMode blendMode = SDL_BLENDMODE_BLEND;
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
static void
quit(int rc)
{
if (sprites) {
SDL_free(sprites);
}
if (positions) {
SDL_free(positions);
}
if (velocities) {
SDL_free(velocities);
}
49
CommonQuit(state);
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
exit(rc);
}
int
LoadSprite(char *file)
{
int i;
SDL_Surface *temp;
/* Load the sprite image */
temp = SDL_LoadBMP(file);
if (temp == NULL) {
fprintf(stderr, "Couldn't load %s: %s", file, SDL_GetError());
return (-1);
}
sprite_w = temp->w;
sprite_h = temp->h;
/* Set transparent pixel as the pixel at (0,0) */
if (temp->format->palette) {
70
SDL_SetColorKey(temp, 1, *(Uint8 *) temp->pixels);
71
72
73
} else {
switch (temp->format->BitsPerPixel) {
case 15:
74
SDL_SetColorKey(temp, 1, (*(Uint16 *) temp->pixels) & 0x00007FFF);
75
76
break;
case 16:
77
SDL_SetColorKey(temp, 1, *(Uint16 *) temp->pixels);
78
79
break;
case 24:
80
SDL_SetColorKey(temp, 1, (*(Uint32 *) temp->pixels) & 0x00FFFFFF);
81
82
break;
case 32:
83
SDL_SetColorKey(temp, 1, *(Uint32 *) temp->pixels);
84
85
break;
}
86
87
88
}
/* Create textures from the image */
89
for (i = 0; i < state->num_windows; ++i) {
90
SDL_Renderer *renderer = state->renderers[i];
91
sprites[i] = SDL_CreateTextureFromSurface(renderer, temp);
92
93
94
95
96
if (!sprites[i]) {
fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError());
SDL_FreeSurface(temp);
return (-1);
}
97
SDL_SetTextureBlendMode(sprites[i], blendMode);
98
99
100
101
102
103
104
105
}
SDL_FreeSurface(temp);
/* We're ready to roll. :) */
return (0);
}
void
106
MoveSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
107
108
{
int i, n;
109
SDL_Rect viewport, temp;
110
SDL_Rect *position, *velocity;
111
112
/* Query the sizes */
113
SDL_RenderGetViewport(renderer, &viewport);
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/* Cycle the color and alpha, if desired */
if (cycle_color) {
current_color += cycle_direction;
if (current_color < 0) {
current_color = 0;
cycle_direction = -cycle_direction;
}
if (current_color > 255) {
current_color = 255;
cycle_direction = -cycle_direction;
}
SDL_SetTextureColorMod(sprite, 255, (Uint8) current_color,
(Uint8) current_color);
}
if (cycle_alpha) {
current_alpha += cycle_direction;
if (current_alpha < 0) {
current_alpha = 0;
cycle_direction = -cycle_direction;
}
if (current_alpha > 255) {
current_alpha = 255;
cycle_direction = -cycle_direction;
}
SDL_SetTextureAlphaMod(sprite, (Uint8) current_alpha);
}
142
/* Draw a gray background */
143
144
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear(renderer);
145
146
/* Test points */
147
148
SDL_SetRenderDrawColor(renderer, 0xFF, 0x00, 0x00, 0xFF);
SDL_RenderDrawPoint(renderer, 0, 0);
149
150
151
SDL_RenderDrawPoint(renderer, viewport.w-1, 0);
SDL_RenderDrawPoint(renderer, 0, viewport.h-1);
SDL_RenderDrawPoint(renderer, viewport.w-1, viewport.h-1);
152
153
/* Test horizontal and vertical lines */
154
SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
155
156
157
158
SDL_RenderDrawLine(renderer, 1, 0, viewport.w-2, 0);
SDL_RenderDrawLine(renderer, 1, viewport.h-1, viewport.w-2, viewport.h-1);
SDL_RenderDrawLine(renderer, 0, 1, 0, viewport.h-2);
SDL_RenderDrawLine(renderer, viewport.w-1, 1, viewport.w-1, viewport.h-2);
159
160
/* Test fill and copy */
161
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
162
temp.x = 1;
163
164
165
temp.y = 1;
temp.w = sprite_w;
temp.h = sprite_h;
166
167
SDL_RenderFillRect(renderer, &temp);
SDL_RenderCopy(renderer, sprite, NULL, &temp);
168
temp.x = viewport.w-sprite_w-1;
169
temp.y = 1;
170
171
temp.w = sprite_w;
temp.h = sprite_h;
172
173
SDL_RenderFillRect(renderer, &temp);
SDL_RenderCopy(renderer, sprite, NULL, &temp);
174
temp.x = 1;
175
temp.y = viewport.h-sprite_h-1;
176
177
temp.w = sprite_w;
temp.h = sprite_h;
178
179
SDL_RenderFillRect(renderer, &temp);
SDL_RenderCopy(renderer, sprite, NULL, &temp);
180
181
temp.x = viewport.w-sprite_w-1;
temp.y = viewport.h-sprite_h-1;
182
183
temp.w = sprite_w;
temp.h = sprite_h;
184
185
SDL_RenderFillRect(renderer, &temp);
SDL_RenderCopy(renderer, sprite, NULL, &temp);
186
187
/* Test diagonal lines */
188
189
SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
SDL_RenderDrawLine(renderer, sprite_w, sprite_h,
190
191
192
viewport.w-sprite_w-2, viewport.h-sprite_h-2);
SDL_RenderDrawLine(renderer, viewport.w-sprite_w-2, sprite_h,
sprite_w, viewport.h-sprite_h-2);
193
194
195
/* Move the sprite, bounce at the wall, and draw */
n = 0;
196
197
198
199
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
velocity = &velocities[i];
position->x += velocity->x;
200
if ((position->x < 0) || (position->x >= (viewport.w - sprite_w))) {
201
202
203
204
velocity->x = -velocity->x;
position->x += velocity->x;
}
position->y += velocity->y;
205
if ((position->y < 0) || (position->y >= (viewport.h - sprite_h))) {
206
207
208
209
210
velocity->y = -velocity->y;
position->y += velocity->y;
}
/* Blit the sprite onto the screen */
211
SDL_RenderCopy(renderer, sprite, NULL, position);
212
213
214
}
/* Update the screen! */
215
SDL_RenderPresent(renderer);
216
217
218
219
220
221
222
223
224
}
int
main(int argc, char *argv[])
{
int i, done;
SDL_Event event;
Uint32 then, now, frames;
225
226
227
228
229
230
231
/* Initialize parameters */
num_sprites = NUM_SPRITES;
/* Initialize test framework */
state = CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return 1;
232
}
233
234
235
state->window_flags |= SDL_WINDOW_RESIZABLE;
236
237
for (i = 1; i < argc;) {
int consumed;
238
239
240
consumed = CommonArg(state, i);
if (consumed == 0) {
241
242
243
244
consumed = -1;
if (SDL_strcasecmp(argv[i], "--blend") == 0) {
if (argv[i + 1]) {
if (SDL_strcasecmp(argv[i + 1], "none") == 0) {
245
blendMode = SDL_BLENDMODE_NONE;
246
247
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) {
248
blendMode = SDL_BLENDMODE_BLEND;
249
250
consumed = 2;
} else if (SDL_strcasecmp(argv[i + 1], "add") == 0) {
251
blendMode = SDL_BLENDMODE_ADD;
252
consumed = 2;
253
254
255
} else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) {
blendMode = SDL_BLENDMODE_MOD;
consumed = 2;
256
257
}
}
258
259
260
261
262
263
} else if (SDL_strcasecmp(argv[i], "--cyclecolor") == 0) {
cycle_color = SDL_TRUE;
consumed = 1;
} else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) {
cycle_alpha = SDL_TRUE;
consumed = 1;
264
265
266
267
} else if (SDL_isdigit(*argv[i])) {
num_sprites = SDL_atoi(argv[i]);
consumed = 1;
}
268
}
269
if (consumed < 0) {
270
fprintf(stderr,
271
"Usage: %s %s [--blend none|blend|add|mod] [--cyclecolor] [--cyclealpha]\n",
272
argv[0], CommonUsage(state));
273
274
quit(1);
}
275
i += consumed;
276
}
277
278
if (!CommonInit(state)) {
quit(2);
279
280
281
}
/* Create the windows, initialize the renderers, and load the textures */
282
sprites =
283
(SDL_Texture **) SDL_malloc(state->num_windows * sizeof(*sprites));
284
if (!sprites) {
285
286
287
fprintf(stderr, "Out of memory!\n");
quit(2);
}
288
for (i = 0; i < state->num_windows; ++i) {
289
290
291
SDL_Renderer *renderer = state->renderers[i];
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear(renderer);
292
293
294
295
296
297
298
299
300
301
302
303
}
if (LoadSprite("icon.bmp") < 0) {
quit(2);
}
/* Allocate memory for the sprite info */
positions = (SDL_Rect *) SDL_malloc(num_sprites * sizeof(SDL_Rect));
velocities = (SDL_Rect *) SDL_malloc(num_sprites * sizeof(SDL_Rect));
if (!positions || !velocities) {
fprintf(stderr, "Out of memory!\n");
quit(2);
}
304
srand((unsigned int)time(NULL));
305
for (i = 0; i < num_sprites; ++i) {
306
307
positions[i].x = rand() % (state->window_w - sprite_w);
positions[i].y = rand() % (state->window_h - sprite_h);
308
309
310
311
312
313
314
315
316
317
positions[i].w = sprite_w;
positions[i].h = sprite_h;
velocities[i].x = 0;
velocities[i].y = 0;
while (!velocities[i].x && !velocities[i].y) {
velocities[i].x = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED;
velocities[i].y = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED;
}
}
318
/* Main render loop */
319
320
321
322
323
324
325
frames = 0;
then = SDL_GetTicks();
done = 0;
while (!done) {
/* Check for events */
++frames;
while (SDL_PollEvent(&event)) {
326
CommonEvent(state, &event, &done);
327
}
328
for (i = 0; i < state->num_windows; ++i) {
329
MoveSprites(state->renderers[i], sprites[i]);
330
331
332
333
334
335
}
}
/* Print out some timing information */
now = SDL_GetTicks();
if (now > then) {
336
double fps = ((double) frames * 1000) / (now - then);
337
printf("%2.2f frames per second\n", fps);
338
339
}
quit(0);
340
return 0;
341
342
343
}
/* vi: set ts=4 sw=4 expandtab: */