Mercurial > repos > blastem

comparison render_sdl.c @ 719:019d27995e32

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Upgrade to SDL 2.0 and drop support for the non-OpenGL render path
author Michael Pavone <pavone@retrodev.com>
date Wed, 20 May 2015 19:05:11 -0700
parents 38006d43f5a3
children fc68992cf18d
comparison
equal deleted inserted replaced
718:eaba6789f316 719:019d27995e32
9 #include "render.h" 9 #include "render.h"
10 #include "blastem.h" 10 #include "blastem.h"
11 #include "io.h" 11 #include "io.h"
12 #include "util.h" 12 #include "util.h"
13 13
14 #ifndef DISABLE_OPENGL
15 #include <GL/glew.h> 14 #include <GL/glew.h>
16 #endif 15
17 16 SDL_Window *main_window;
18 SDL_Surface *screen; 17 SDL_GLContext *main_context;
19 uint8_t render_dbg = 0; 18 uint8_t render_dbg = 0;
20 uint8_t debug_pal = 0; 19 uint8_t debug_pal = 0;
21 uint8_t render_gl = 1;
22 20
23 uint32_t last_frame = 0; 21 uint32_t last_frame = 0;
24 22
25 uint32_t min_delay; 23 uint32_t min_delay;
26 uint32_t frame_delay = 1000/60; 24 uint32_t frame_delay = 1000/60;
90 return num_joysticks; 88 return num_joysticks;
91 } 89 }
92 90
93 uint32_t render_map_color(uint8_t r, uint8_t g, uint8_t b) 91 uint32_t render_map_color(uint8_t r, uint8_t g, uint8_t b)
94 { 92 {
95 if (render_gl) { 93 return 255 << 24 | r << 16 | g << 8 | b;
96 return 255 << 24 | r << 16 | g << 8 | b; 94 }
97 } else { 95
98 return SDL_MapRGB(screen->format, r, g, b);
99 }
100 }
101
102 #ifndef DISABLE_OPENGL
103 GLuint textures[3], buffers[2], vshader, fshader, program, un_textures[2], un_width, at_pos; 96 GLuint textures[3], buffers[2], vshader, fshader, program, un_textures[2], un_width, at_pos;
104 97
105 GLfloat vertex_data[] = { 98 GLfloat vertex_data[] = {
106 -1.0f, -1.0f, 99 -1.0f, -1.0f,
107 1.0f, -1.0f, 100 1.0f, -1.0f,
151 glDeleteShader(ret); 144 glDeleteShader(ret);
152 return 0; 145 return 0;
153 } 146 }
154 return ret; 147 return ret;
155 } 148 }
156 #endif
157 149
158 void render_alloc_surfaces(vdp_context * context) 150 void render_alloc_surfaces(vdp_context * context)
159 { 151 {
160 #ifndef DISABLE_OPENGL 152 context->oddbuf = context->framebuf = malloc(512 * 256 * 4 * 2);
161 if (render_gl) { 153 memset(context->oddbuf, 0, 512 * 256 * 4 * 2);
162 context->oddbuf = context->framebuf = malloc(512 * 256 * 4 * 2); 154 context->evenbuf = ((char *)context->oddbuf) + 512 * 256 * 4;
163 memset(context->oddbuf, 0, 512 * 256 * 4 * 2); 155 glGenTextures(3, textures);
164 context->evenbuf = ((char *)context->oddbuf) + 512 * 256 * 4; 156 for (int i = 0; i < 3; i++)
165 glGenTextures(3, textures); 157 {
166 for (int i = 0; i < 3; i++) 158 glBindTexture(GL_TEXTURE_2D, textures[i]);
167 { 159 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
168 glBindTexture(GL_TEXTURE_2D, textures[i]); 160 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
169 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 161 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
170 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 162 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
171 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 163 if (i < 2) {
172 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 164 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 512, 256, 0, GL_BGRA, GL_UNSIGNED_BYTE, i ? context->evenbuf : context->oddbuf);
173 if (i < 2) { 165 } else {
174 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 512, 256, 0, GL_BGRA, GL_UNSIGNED_BYTE, i ? context->evenbuf : context->oddbuf); 166 uint32_t blank = 255 << 24;
175 } else { 167 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0, GL_BGRA, GL_UNSIGNED_BYTE, &blank);
176 uint32_t blank = 255 << 24; 168 }
177 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0, GL_BGRA, GL_UNSIGNED_BYTE, &blank); 169 }
178 } 170 glGenBuffers(2, buffers);
179 } 171 glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
180 glGenBuffers(2, buffers); 172 glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
181 glBindBuffer(GL_ARRAY_BUFFER, buffers[0]); 173 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
182 glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW); 174 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(element_data), element_data, GL_STATIC_DRAW);
183 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]); 175 vshader = load_shader(tern_find_ptr_default(config, "videovertex_shader", "default.v.glsl"), GL_VERTEX_SHADER);
184 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(element_data), element_data, GL_STATIC_DRAW); 176 fshader = load_shader(tern_find_ptr_default(config, "videofragment_shader", "default.f.glsl"), GL_FRAGMENT_SHADER);
185 vshader = load_shader(tern_find_ptr_default(config, "videovertex_shader", "default.v.glsl"), GL_VERTEX_SHADER); 177 program = glCreateProgram();
186 fshader = load_shader(tern_find_ptr_default(config, "videofragment_shader", "default.f.glsl"), GL_FRAGMENT_SHADER); 178 glAttachShader(program, vshader);
187 program = glCreateProgram(); 179 glAttachShader(program, fshader);
188 glAttachShader(program, vshader); 180 glLinkProgram(program);
189 glAttachShader(program, fshader); 181 GLint link_status;
190 glLinkProgram(program); 182 glGetProgramiv(program, GL_LINK_STATUS, &link_status);
191 GLint link_status; 183 if (!link_status) {
192 glGetProgramiv(program, GL_LINK_STATUS, &link_status); 184 fputs("Failed to link shader program\n", stderr);
193 if (!link_status) { 185 exit(1);
194 fputs("Failed to link shader program\n", stderr); 186 }
195 exit(1); 187 un_textures[0] = glGetUniformLocation(program, "textures[0]");
196 } 188 un_textures[1] = glGetUniformLocation(program, "textures[1]");
197 un_textures[0] = glGetUniformLocation(program, "textures[0]"); 189 un_width = glGetUniformLocation(program, "width");
198 un_textures[1] = glGetUniformLocation(program, "textures[1]"); 190 at_pos = glGetAttribLocation(program, "pos");
199 un_width = glGetUniformLocation(program, "width");
200 at_pos = glGetAttribLocation(program, "pos");
201 } else {
202 #endif
203 context->oddbuf = context->framebuf = malloc(320 * 240 * screen->format->BytesPerPixel * 2);
204 context->evenbuf = ((char *)context->oddbuf) + 320 * 240 * screen->format->BytesPerPixel;
205 #ifndef DISABLE_OPENGL
206 }
207 #endif
208 }
209
210 uint8_t render_depth()
211 {
212 return screen->format->BytesPerPixel * 8;
213 } 191 }
214 192
215 char * caption = NULL; 193 char * caption = NULL;
216 194
217 void render_init(int width, int height, char * title, uint32_t fps, uint8_t fullscreen, uint8_t use_gl) 195 void render_init(int width, int height, char * title, uint32_t fps, uint8_t fullscreen)
218 { 196 {
219 if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK) < 0) { 197 if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK) < 0) {
220 fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError()); 198 fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
221 exit(1); 199 exit(1);
222 } 200 }
223 printf("width: %d, height: %d\n", width, height); 201 printf("width: %d, height: %d\n", width, height);
224 uint32_t flags = SDL_ANYFORMAT; 202 uint32_t flags = SDL_WINDOW_OPENGL;
225 203
226 #ifndef DISABLE_OPENGL 204
227 if (use_gl) 205 SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
228 { 206 SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
229 SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5); 207 SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
230 SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5); 208 SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
231 SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5); 209 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
232 SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0); 210 if (fullscreen) {
233 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); 211 flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
234 flags = SDL_OPENGL; 212 SDL_DisplayMode mode;
235 if (fullscreen) { 213 //TODO: Multiple monitor support
236 flags |= SDL_FULLSCREEN; 214 SDL_GetCurrentDisplayMode(0, &mode);
237 } 215 //the SDL2 migration guide suggests setting width and height to 0 when using SDL_WINDOW_FULLSCREEN_DESKTOP
238 } else { 216 //but that doesn't seem to work right when using OpenGL, at least on Linux anyway
239 #else 217 width = mode.w;
240 { 218 height = mode.h;
241 #endif 219 }
242 if (fullscreen) { 220 main_window = SDL_CreateWindow(title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, flags);
243 flags |= SDL_FULLSCREEN | SDL_HWSURFACE | SDL_DOUBLEBUF; 221 if (!main_window) {
244 } else { 222 fprintf(stderr, "Unable to create SDL window: %s\n", SDL_GetError());
245 flags |= SDL_SWSURFACE;
246 }
247 }
248 screen = SDL_SetVideoMode(width, height, 32, flags);
249 if (!screen) {
250 fprintf(stderr, "Unable to get SDL surface: %s\n", SDL_GetError());
251 SDL_Quit(); 223 SDL_Quit();
252 exit(1); 224 exit(1);
253 } 225 }
254 if (!use_gl && screen->format->BytesPerPixel != 2 && screen->format->BytesPerPixel != 4) { 226 SDL_GetWindowSize(main_window, &width, &height);
255 fprintf(stderr, "BlastEm requires a 16-bit or 32-bit surface, SDL returned a %d-bit surface\n", screen->format->BytesPerPixel * 8); 227 printf("Window created with size: %d x %d\n", width, height);
228 main_context = SDL_GL_CreateContext(main_window);
229 GLenum res = glewInit();
230 if (res != GLEW_OK) {
231 fprintf(stderr, "Initialization of GLEW failed with code %d\n", res);
256 SDL_Quit(); 232 SDL_Quit();
257 exit(1); 233 exit(1);
258 } 234 }
259 #ifndef DISABLE_OPENGL 235 if (!GLEW_VERSION_2_0) {
260 //TODO: fallback on standard rendering if OpenGL 2.0 is unavailable or if init fails 236 fputs("BlastEm requires at least OpenGL 2.0, but it is unavailable\n", stderr);
261 if (use_gl) 237 SDL_Quit();
262 { 238 exit(1);
263 GLenum res = glewInit(); 239 }
264 if (res != GLEW_OK) { 240 float aspect = (float)width / height;
265 fprintf(stderr, "Initialization of GLEW failed with code %d\n", res); 241 if (fabs(aspect - 4.0/3.0) > 0.01 && strcmp(tern_find_ptr_default(config, "videoaspect", "normal"), "stretch")) {
266 SDL_Quit(); 242 for (int i = 0; i < 4; i++)
267 exit(1); 243 {
268 } 244 if (aspect > 4.0/3.0) {
269 if (!GLEW_VERSION_2_0) { 245 vertex_data[i*2] *= (4.0/3.0)/aspect;
270 fputs("OpenGL 2.0 is unable, falling back to standard SDL rendering\n", stderr); 246 } else {
271 SDL_Quit(); 247 vertex_data[i*2+1] *= aspect/(4.0/3.0);
272 exit(1); 248 }
273 } 249 }
274 float aspect = (float)width / height; 250 }
275 if (fabs(aspect - 4.0/3.0) > 0.01 && strcmp(tern_find_ptr_default(config, "videoaspect", "normal"), "stretch")) {
276 for (int i = 0; i < 4; i++)
277 {
278 if (aspect > 4.0/3.0) {
279 vertex_data[i*2] *= (4.0/3.0)/aspect;
280 } else {
281 vertex_data[i*2+1] *= aspect/(4.0/3.0);
282 }
283 }
284 }
285 }
286 render_gl = use_gl;
287 #endif
288 SDL_WM_SetCaption(title, title);
289 caption = title; 251 caption = title;
290 min_delay = 0; 252 min_delay = 0;
291 for (int i = 0; i < 100; i++) { 253 for (int i = 0; i < 100; i++) {
292 uint32_t start = SDL_GetTicks(); 254 uint32_t start = SDL_GetTicks();
293 SDL_Delay(1); 255 SDL_Delay(1);
339 num_joysticks = SDL_NumJoysticks(); 301 num_joysticks = SDL_NumJoysticks();
340 if (num_joysticks > MAX_JOYSTICKS) { 302 if (num_joysticks > MAX_JOYSTICKS) {
341 num_joysticks = MAX_JOYSTICKS; 303 num_joysticks = MAX_JOYSTICKS;
342 } 304 }
343 for (int i = 0; i < num_joysticks; i++) { 305 for (int i = 0; i < num_joysticks; i++) {
344 printf("Joystick %d: %s\n", i, SDL_JoystickName(i));
345 SDL_Joystick * joy = joysticks[i] = SDL_JoystickOpen(i); 306 SDL_Joystick * joy = joysticks[i] = SDL_JoystickOpen(i);
307 printf("Joystick %d: %s\n", i, SDL_JoystickName(joy));
346 if (joy) { 308 if (joy) {
347 printf("\tNum Axes: %d\n\tNum Buttons: %d\n\tNum Hats: %d\n", SDL_JoystickNumAxes(joy), SDL_JoystickNumButtons(joy), SDL_JoystickNumHats(joy)); 309 printf("\tNum Axes: %d\n\tNum Buttons: %d\n\tNum Hats: %d\n", SDL_JoystickNumAxes(joy), SDL_JoystickNumButtons(joy), SDL_JoystickNumHats(joy));
348 } 310 }
349 } 311 }
350 SDL_JoystickEventState(SDL_ENABLE); 312 SDL_JoystickEventState(SDL_ENABLE);
351 313
352 atexit(SDL_Quit); 314 atexit(SDL_Quit);
353 atexit(render_close_audio); 315 atexit(render_close_audio);
354 } 316 }
355 #ifndef DISABLE_OPENGL 317
356 void render_context_gl(vdp_context * context) 318 void render_context(vdp_context * context)
357 { 319 {
320 last_frame = SDL_GetTicks();
321
358 glBindTexture(GL_TEXTURE_2D, textures[context->framebuf == context->oddbuf ? 0 : 1]); 322 glBindTexture(GL_TEXTURE_2D, textures[context->framebuf == context->oddbuf ? 0 : 1]);
359 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 320, 240, GL_BGRA, GL_UNSIGNED_BYTE, context->framebuf);; 323 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 320, 240, GL_BGRA, GL_UNSIGNED_BYTE, context->framebuf);;
360 324
361 glClearColor(0.0f, 0.0f, 0.0f, 1.0f); 325 glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
362 glClear(GL_COLOR_BUFFER_BIT); 326 glClear(GL_COLOR_BUFFER_BIT);
379 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]); 343 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
380 glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, (void *)0); 344 glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, (void *)0);
381 345
382 glDisableVertexAttribArray(at_pos); 346 glDisableVertexAttribArray(at_pos);
383 347
384 SDL_GL_SwapBuffers(); 348 SDL_GL_SwapWindow(main_window);
385 if (context->regs[REG_MODE_4] & BIT_INTERLACE)
386 {
387 context->framebuf = context->framebuf == context->oddbuf ? context->evenbuf : context->oddbuf;
388 }
389 }
390 #endif
391
392 uint32_t blankbuf[320*240];
393
394 void render_context(vdp_context * context)
395 {
396 uint16_t *buf_16;
397 uint32_t *buf_32;
398 uint8_t b,g,r;
399 last_frame = SDL_GetTicks();
400 #ifndef DISABLE_OPENGL
401 if (render_gl)
402 {
403 render_context_gl(context);
404 return;
405 }
406 #endif
407 if (SDL_MUSTLOCK(screen)) {
408 if (SDL_LockSurface(screen) < 0) {
409 return;
410 }
411 }
412 uint16_t repeat_x = screen->clip_rect.w / 320;
413 uint16_t repeat_y = screen->clip_rect.h / 240;
414 if (repeat_x > repeat_y) {
415 repeat_x = repeat_y;
416 } else {
417 repeat_y = repeat_x;
418 }
419 int othermask = repeat_y >> 1;
420
421 if (screen->format->BytesPerPixel == 2) {
422 uint16_t *otherbuf = (context->regs[REG_MODE_4] & BIT_INTERLACE) ? context->evenbuf : (uint16_t *)blankbuf;
423 uint16_t * oddbuf = context->oddbuf;
424 buf_16 = (uint16_t *)screen->pixels;
425 for (int y = 0; y < 240; y++) {
426 for (int i = 0; i < repeat_y; i++,buf_16 += screen->pitch/2) {
427 uint16_t *line = buf_16;
428 uint16_t *src_line = (i & othermask ? otherbuf : oddbuf) + y * 320;
429 for (int x = 0; x < 320; x++) {
430 uint16_t color = *(src_line++);
431 for (int j = 0; j < repeat_x; j++) {
432 *(line++) = color;
433 }
434 }
435 }
436 }
437 } else {
438 uint32_t *otherbuf = (context->regs[REG_MODE_4] & BIT_INTERLACE) ? context->evenbuf : (uint32_t *)blankbuf;
439 uint32_t * oddbuf = context->oddbuf;
440 buf_32 = (uint32_t *)screen->pixels;
441 for (int y = 0; y < 240; y++) {
442 for (int i = 0; i < repeat_y; i++,buf_32 += screen->pitch/4) {
443 uint32_t *line = buf_32;
444 uint32_t *src_line = (i & othermask ? otherbuf : oddbuf) + y * 320;
445 for (int x = 0; x < 320; x++) {
446 uint32_t color = *(src_line++);
447 for (int j = 0; j < repeat_x; j++) {
448 *(line++) = color;
449 }
450 }
451 }
452 }
453 }
454 if ( SDL_MUSTLOCK(screen) ) {
455 SDL_UnlockSurface(screen);
456 }
457 //SDL_UpdateRect(screen, 0, 0, screen->clip_rect.w, screen->clip_rect.h);
458 SDL_Flip(screen);
459 if (context->regs[REG_MODE_4] & BIT_INTERLACE) 349 if (context->regs[REG_MODE_4] & BIT_INTERLACE)
460 { 350 {
461 context->framebuf = context->framebuf == context->oddbuf ? context->evenbuf : context->oddbuf; 351 context->framebuf = context->framebuf == context->oddbuf ? context->evenbuf : context->oddbuf;
462 } 352 }
463 } 353 }
566 } 456 }
567 } 457 }
568 } 458 }
569 render_context(context); 459 render_context(context);
570 460
571
572 //TODO: Figure out why this causes segfaults
573 frame_counter++; 461 frame_counter++;
574 if ((last_frame - start) > 1000) { 462 if ((last_frame - start) > 1000) {
575 if (start && (last_frame-start)) { 463 if (start && (last_frame-start)) {
576 if (!fps_caption) { 464 if (!fps_caption) {
577 fps_caption = malloc(strlen(caption) + strlen(" - 1000.1 fps") + 1); 465 fps_caption = malloc(strlen(caption) + strlen(" - 1000.1 fps") + 1);
578 } 466 }
579 sprintf(fps_caption, "%s - %.1f fps", caption, ((float)frame_counter) / (((float)(last_frame-start)) / 1000.0)); 467 sprintf(fps_caption, "%s - %.1f fps", caption, ((float)frame_counter) / (((float)(last_frame-start)) / 1000.0));
580 SDL_WM_SetCaption(fps_caption, caption); 468 SDL_SetWindowTitle(main_window, fps_caption);
581 fflush(stdout);
582 } 469 }
583 start = last_frame; 470 start = last_frame;
584 frame_counter = 0; 471 frame_counter = 0;
585 } 472 }
586 return ret; 473 return ret;