This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
testsprite2.c
1
2
3
/* Simple program: Move N sprites around on the screen as fast as possible */
#include <stdlib.h>
4
#include <stdio.h>
5
6
#include <time.h>
7
#include "common.h"
8
9
10
11
12
#define NUM_SPRITES 100
#define MAX_SPEED 1
#define BACKGROUND 0x00FFFFFF
13
static CommonState *state;
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
static int num_sprites;
static SDL_TextureID *sprites;
static SDL_Rect *positions;
static SDL_Rect *velocities;
static int sprite_w, sprite_h;
/* 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);
}
33
CommonQuit(state);
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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) {
SDL_SetColorKey(temp, SDL_SRCCOLORKEY, *(Uint8 *) temp->pixels);
}
/* Create textures from the image */
58
59
for (i = 0; i < state->num_windows; ++i) {
SDL_SelectRenderer(state->windows[i]);
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
sprites[i] =
SDL_CreateTextureFromSurface(0, SDL_TextureAccess_Remote, temp);
if (!sprites[i]) {
fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError());
SDL_FreeSurface(temp);
return (-1);
}
}
SDL_FreeSurface(temp);
/* We're ready to roll. :) */
return (0);
}
void
MoveSprites(SDL_WindowID window, SDL_TextureID sprite)
{
int i, n;
int window_w, window_h;
SDL_Rect area, *position, *velocity;
SDL_SelectRenderer(window);
/* Query the sizes */
SDL_GetWindowSize(window, &window_w, &window_h);
/* Move the sprite, bounce at the wall, and draw */
n = 0;
88
89
90
91
92
93
94
SDL_RenderFill(NULL, BACKGROUND);
/*
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
SDL_RenderFill(position, BACKGROUND);
}
*/
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
velocity = &velocities[i];
position->x += velocity->x;
if ((position->x < 0) || (position->x >= (window_w - sprite_w))) {
velocity->x = -velocity->x;
position->x += velocity->x;
}
position->y += velocity->y;
if ((position->y < 0) || (position->y >= (window_h - sprite_w))) {
velocity->y = -velocity->y;
position->y += velocity->y;
}
/* Blit the sprite onto the screen */
SDL_RenderCopy(sprite, NULL, position, SDL_TextureBlendMode_Mask,
SDL_TextureScaleMode_None);
}
/* Update the screen! */
SDL_RenderPresent();
}
int
main(int argc, char *argv[])
{
int i, done;
SDL_Event event;
Uint32 then, now, frames;
125
126
127
128
129
130
131
/* Initialize parameters */
num_sprites = NUM_SPRITES;
/* Initialize test framework */
state = CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return 1;
133
134
for (i = 1; i < argc;) {
int consumed;
136
137
138
139
140
consumed = CommonArg(state, i);
if (consumed == 0) {
num_sprites = SDL_atoi(argv[i]);
consumed = 1;
}
141
142
143
144
if (consumed < 0) {
fprintf(stderr, "Usage: %s %s", argv[0], CommonUsage(state));
quit(1);
}
145
i += consumed;
147
148
if (!CommonInit(state)) {
quit(2);
149
150
151
}
/* Create the windows, initialize the renderers, and load the textures */
152
153
154
sprites =
(SDL_TextureID *) SDL_malloc(state->num_windows * sizeof(*sprites));
if (!sprites) {
155
156
157
fprintf(stderr, "Out of memory!\n");
quit(2);
}
158
159
for (i = 0; i < state->num_windows; ++i) {
SDL_SelectRenderer(state->windows[i]);
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
SDL_RenderFill(NULL, BACKGROUND);
}
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);
}
srand(time(NULL));
for (i = 0; i < num_sprites; ++i) {
175
176
positions[i].x = rand() % (state->window_w - sprite_w);
positions[i].y = rand() % (state->window_h - sprite_h);
177
178
179
180
181
182
183
184
185
186
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;
}
}
187
/* Main render loop */
188
189
190
191
192
193
194
frames = 0;
then = SDL_GetTicks();
done = 0;
while (!done) {
/* Check for events */
++frames;
while (SDL_PollEvent(&event)) {
195
CommonEvent(state, &event, &done);
196
197
198
199
200
201
202
203
204
205
206
207
208
switch (event.type) {
case SDL_WINDOWEVENT:
switch (event.window.event) {
case SDL_WINDOWEVENT_EXPOSED:
SDL_SelectRenderer(event.window.windowID);
SDL_RenderFill(NULL, BACKGROUND);
break;
}
break;
default:
break;
}
}
209
210
for (i = 0; i < state->num_windows; ++i) {
MoveSprites(state->windows[i], sprites[i]);
211
212
213
214
215
216
217
218
219
220
221
222
223
}
}
/* Print out some timing information */
now = SDL_GetTicks();
if (now > then) {
printf("%2.2f frames per second\n",
((double) frames * 1000) / (now - then));
}
quit(0);
}
/* vi: set ts=4 sw=4 expandtab: */