Mercurial > sdl-ios-xcode

comparison src/video/nds/SDL_ndsrender.c @ 2680:4135aa9c5645 gsoc2008_nds

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
More work on the accelerated 2D video driver, beginnings of sprite-based rendering support. Also some initial work on an audio driver.
author Darren Alton <dalton@stevens.edu>
date Sat, 19 Jul 2008 17:37:19 +0000
parents bc3e3e889f6d
children c15b6c758be5
comparison
equal deleted inserted replaced
2679:bc3e3e889f6d 2680:4135aa9c5645
157 int bpp = 15; 157 int bpp = 15;
158 Uint32 Rmask, Gmask, Bmask, Amask; 158 Uint32 Rmask, Gmask, Bmask, Amask;
159 /* Uint32 Rmask = 0x7C00, Gmask = 0x03E0, Bmask = 0x001F, Amask = 0x8000; 159 /* Uint32 Rmask = 0x7C00, Gmask = 0x03E0, Bmask = 0x001F, Amask = 0x8000;
160 Uint32 Rmask = 0x001F, Gmask = 0x03E0, Bmask = 0x7C00, Amask = 0x8000; 160 Uint32 Rmask = 0x001F, Gmask = 0x03E0, Bmask = 0x7C00, Amask = 0x8000;
161 */ 161 */
162 printf("+NDS_CreateRenderer\n");
162 163
163 /* hard coded this to BGR555 for now */ 164 /* hard coded this to BGR555 for now */
164 if (!SDL_PixelFormatEnumToMasks(SDL_PIXELFORMAT_BGR555, &bpp, 165 if (!SDL_PixelFormatEnumToMasks(SDL_PIXELFORMAT_BGR555, &bpp,
165 &Rmask, &Gmask, &Bmask, &Amask)) { 166 &Rmask, &Gmask, &Bmask, &Amask)) {
166 SDL_SetError("Unknown display format"); 167 SDL_SetError("Unknown display format");
218 /*data->fb = (u16*)0x06020000;*/ 219 /*data->fb = (u16*)0x06020000;*/
219 data->bg = &BACKGROUND; 220 data->bg = &BACKGROUND;
220 data->bg_taken[2] = data->bg_taken[3] = 0; 221 data->bg_taken[2] = data->bg_taken[3] = 0;
221 data->sub = 0; 222 data->sub = 0;
222 223
224 printf("-NDS_CreateRenderer\n");
223 return renderer; 225 return renderer;
224 } 226 }
225 227
226 static int 228 static int
227 NDS_ActivateRenderer(SDL_Renderer * renderer) 229 NDS_ActivateRenderer(SDL_Renderer * renderer)
228 { 230 {
229 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata; 231 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
230 /* stub. TODO: figure out what needs to be done, if anything. */ 232 /* stub. TODO: figure out what needs to be done, if anything. */
233 printf("!NDS_ActivateRenderer\n");
231 return 0; 234 return 0;
232 } 235 }
233 236
234 static int 237 static int
235 NDS_DisplayModeChanged(SDL_Renderer * renderer) 238 NDS_DisplayModeChanged(SDL_Renderer * renderer)
236 { 239 {
237 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata; 240 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
238 /* stub. TODO: figure out what needs to be done */ 241 /* stub. TODO: figure out what needs to be done */
242 printf("!NDS_DisplayModeChanged\n");
239 return 0; 243 return 0;
240 } 244 }
241 245
242 static int 246 static int
243 NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) 247 NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
244 { 248 {
245 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata; 249 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
246 NDS_TextureData *txdat = NULL; 250 NDS_TextureData *txdat = NULL;
251 printf("+NDS_CreateTexture\n");
247 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 252 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
248 SDL_SetError("Unsupported texture format"); 253 SDL_SetError("Unsupported texture format");
249 return -1; 254 return -1;
250 } else { 255 } else {
251 int bpp; 256 int bpp;
299 } else { 304 } else {
300 SDL_SetError("Texture too big for NDS hardware."); 305 SDL_SetError("Texture too big for NDS hardware.");
301 } 306 }
302 } 307 }
303 308
309 printf("-NDS_CreateTexture\n");
304 if (!texture->driverdata) { 310 if (!texture->driverdata) {
305 return -1; 311 return -1;
306 } 312 }
307 return 0; 313 return 0;
308 } 314 }
309 315
310 static int 316 static int
311 NDS_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, 317 NDS_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
312 void **pixels, int *pitch) 318 void **pixels, int *pitch)
313 { 319 {
320 printf("+NDS_QueryTexturePixels\n");
314 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 321 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
315 SDL_SetError("Unsupported texture format"); 322 SDL_SetError("Unsupported texture format");
316 return -1; 323 return -1;
317 } else { 324 } else {
318 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata; 325 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
319 326
320 *pixels = txdat->vram; 327 *pixels = txdat->vram;
321 *pitch = txdat->dim.pitch; 328 *pitch = txdat->dim.pitch;
329 printf("-NDS_QueryTexturePixels\n");
322 return 0; 330 return 0;
323 } 331 }
324 } 332 }
325 333
326 static int 334 static int
327 NDS_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, 335 NDS_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
328 const SDL_Color * colors, int firstcolor, int ncolors) 336 const SDL_Color * colors, int firstcolor, int ncolors)
329 { 337 {
338 printf("+NDS_SetTexturePalette\n");
330 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 339 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
331 SDL_SetError("YUV textures don't have a palette"); 340 SDL_SetError("YUV textures don't have a palette");
332 return -1; 341 return -1;
333 } else { 342 } else {
334 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata; 343 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
335 /* TODO: mess with 8-bit modes and/or 16-color palette modes */ 344 /* TODO: mess with 8-bit modes and/or 16-color palette modes */
345 printf("-NDS_SetTexturePalette\n");
336 return 0; 346 return 0;
337 } 347 }
338 } 348 }
339 349
340 static int 350 static int
341 NDS_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture, 351 NDS_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
342 SDL_Color * colors, int firstcolor, int ncolors) 352 SDL_Color * colors, int firstcolor, int ncolors)
343 { 353 {
354 printf("+NDS_GetTexturePalette\n");
344 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 355 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
345 SDL_SetError("YUV textures don't have a palette"); 356 SDL_SetError("YUV textures don't have a palette");
346 return -1; 357 return -1;
347 } else { 358 } else {
348 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata; 359 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
360 printf("-NDS_GetTexturePalette\n");
349 /* TODO: mess with 8-bit modes and/or 16-color palette modes */ 361 /* TODO: mess with 8-bit modes and/or 16-color palette modes */
350 return 0; 362 return 0;
351 } 363 }
352 } 364 }
353 365
354 static int 366 static int
355 NDS_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture) 367 NDS_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
356 { 368 {
369 printf("!NDS_SetTextureColorMod\n");
357 /* stub. TODO: figure out what needs to be done, if anything */ 370 /* stub. TODO: figure out what needs to be done, if anything */
358 return 0; 371 return 0;
359 } 372 }
360 373
361 static int 374 static int
362 NDS_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture) 375 NDS_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
363 { 376 {
377 printf("!NDS_SetTextureAlphaMod\n");
364 /* stub. TODO: figure out what needs to be done, if anything */ 378 /* stub. TODO: figure out what needs to be done, if anything */
365 return 0; 379 return 0;
366 } 380 }
367 381
368 static int 382 static int
369 NDS_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture) 383 NDS_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
370 { 384 {
385 printf("!NDS_SetTextureBlendMode\n");
371 /* stub. TODO: figure out what needs to be done, if anything */ 386 /* stub. TODO: figure out what needs to be done, if anything */
372 return 0; 387 return 0;
373 } 388 }
374 389
375 static int 390 static int
376 NDS_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture) 391 NDS_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
377 { 392 {
393 printf("!NDS_SetTextureScaleMode\n");
378 /* stub. TODO: figure out what needs to be done. 394 /* stub. TODO: figure out what needs to be done.
379 (NDS hardware scaling is nearest neighbor.) */ 395 (NDS hardware scaling is nearest neighbor.) */
380 return 0; 396 return 0;
381 } 397 }
382 398
383 static int 399 static int
384 NDS_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, 400 NDS_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
385 const SDL_Rect * rect, const void *pixels, int pitch) 401 const SDL_Rect * rect, const void *pixels, int pitch)
386 { 402 {
403 printf("+NDS_UpdateTexture\n");
387 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 404 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
388 SDL_SetError("Unsupported texture format"); 405 SDL_SetError("Unsupported texture format");
389 return -1; 406 return -1;
390 } else { 407 } else {
391 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata; 408 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
401 for (row = 0; row < rect->h; ++row) { 418 for (row = 0; row < rect->h; ++row) {
402 SDL_memcpy(dst, src, length); 419 SDL_memcpy(dst, src, length);
403 src += pitch; 420 src += pitch;
404 dst += txdat->dim.pitch; 421 dst += txdat->dim.pitch;
405 } 422 }
423 printf("-NDS_UpdateTexture\n");
406 return 0; 424 return 0;
407 } 425 }
408 } 426 }
409 427
410 static int 428 static int
411 NDS_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, 429 NDS_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
412 const SDL_Rect * rect, int markDirty, void **pixels, 430 const SDL_Rect * rect, int markDirty, void **pixels,
413 int *pitch) 431 int *pitch)
414 { 432 {
433 printf("+NDS_LockTexture\n");
415 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 434 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
416 SDL_SetError("Unsupported texture format"); 435 SDL_SetError("Unsupported texture format");
417 return -1; 436 return -1;
418 } else { 437 } else {
419 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata; 438 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
420 439
421 *pixels = (void *) ((u8 *)txdat->vram + rect->y * txdat->dim.pitch 440 *pixels = (void *) ((u8 *)txdat->vram + rect->y * txdat->dim.pitch
422 + rect->x * (txdat->dim.bpp/8)); 441 + rect->x * (txdat->dim.bpp/8));
423 *pitch = txdat->dim.pitch; 442 *pitch = txdat->dim.pitch;
443 printf("-NDS_LockTexture\n");
424 return 0; 444 return 0;
425 } 445 }
426 } 446 }
427 447
428 static void 448 static void
429 NDS_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture) 449 NDS_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
430 { 450 {
431 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 451 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
432 SDL_SetError("Unsupported texture format"); 452 SDL_SetError("Unsupported texture format");
433 } 453 }
454 printf("!NDS_UnlockTexture\n");
434 } 455 }
435 456
436 static void 457 static void
437 NDS_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, 458 NDS_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
438 int numrects, const SDL_Rect * rects) 459 int numrects, const SDL_Rect * rects)
439 { /* stub */ 460 { /* stub */
461 printf("!NDS_DirtyTexture\n");
440 } 462 }
441 463
442 static int 464 static int
443 NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b, 465 NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b,
444 Uint8 a, const SDL_Rect * rect) 466 Uint8 a, const SDL_Rect * rect)
446 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata; 468 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
447 SDL_Rect real_rect = *rect; 469 SDL_Rect real_rect = *rect;
448 u16 color; 470 u16 color;
449 int i, j; 471 int i, j;
450 472
473 printf("+NDS_RenderFill\n");
451 /* TODO: make a single-color sprite and stretch it. 474 /* TODO: make a single-color sprite and stretch it.
452 color = RGB15(r>>3,g>>3,b>>3); 475 color = RGB15(r>>3,g>>3,b>>3);
453 for (i = real_rect.x; i < real_rect.x+real_rect.w; ++i) { 476 for (i = real_rect.x; i < real_rect.x+real_rect.w; ++i) {
454 for (j = real_rect.y; j < real_rect.y+real_rect.h; ++j) { 477 for (j = real_rect.y; j < real_rect.y+real_rect.h; ++j) {
455 data->fb[(j + real_rect.y) * 256 + i + real_rect.x] = 478 data->fb[(j + real_rect.y) * 256 + i + real_rect.x] =
456 0x8000 | color; 479 0x8000 | color;
457 } 480 }
458 }*/ 481 }*/
482 printf("-NDS_RenderFill\n");
459 return 0; 483 return 0;
460 } 484 }
461 485
462 static int 486 static int
463 NDS_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, 487 NDS_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
465 { 489 {
466 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata; 490 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
467 SDL_Window *window = SDL_GetWindowFromID(renderer->window); 491 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
468 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); 492 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
469 493
494 printf("+NDS_RenderCopy\n");
470 #if 0 495 #if 0
471 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 496 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
472 SDL_Surface *target = data->screens[data->current_screen]; 497 SDL_Surface *target = data->screens[data->current_screen];
473 void *pixels = 498 void *pixels =
474 (Uint8 *) target->pixels + dstrect->y * target->pitch + 499 (Uint8 *) target->pixels + dstrect->y * target->pitch +
483 SDL_Rect real_srcrect = *srcrect; 508 SDL_Rect real_srcrect = *srcrect;
484 SDL_Rect real_dstrect = *dstrect; 509 SDL_Rect real_dstrect = *dstrect;
485 return SDL_LowerBlit(surface, &real_srcrect, target, &real_dstrect); 510 return SDL_LowerBlit(surface, &real_srcrect, target, &real_dstrect);
486 } 511 }
487 #endif 512 #endif
513 printf("-NDS_RenderCopy\n");
488 return 0; 514 return 0;
489 } 515 }
490 516
491 517
492 static void 518 static void
493 NDS_RenderPresent(SDL_Renderer * renderer) 519 NDS_RenderPresent(SDL_Renderer * renderer)
494 { 520 {
495 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata; 521 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
496 /* Send the data to the display TODO */ 522 /* Send the data to the display TODO */
497 523
524 printf("+NDS_RenderPresent\n");
498 /* Update the flipping chain, if any */ 525 /* Update the flipping chain, if any */
499 if (renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) { 526 if (renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) {
500 swiWaitForVBlank(); 527 swiWaitForVBlank();
501 } 528 }
529 printf("-NDS_RenderPresent\n");
502 } 530 }
503 531
504 static void 532 static void
505 NDS_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) 533 NDS_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
506 { 534 {
535 printf("+NDS_DestroyTexture\n");
507 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 536 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
508 SDL_SetError("Unsupported texture format"); 537 SDL_SetError("Unsupported texture format");
509 } else { 538 } else {
510 /* free anything else allocated for texture */ 539 /* free anything else allocated for texture */
511 SDL_free(texture->driverdata); 540 SDL_free(texture->driverdata);
512 } 541 }
542 printf("-NDS_DestroyTexture\n");
513 } 543 }
514 544
515 static void 545 static void
516 NDS_DestroyRenderer(SDL_Renderer * renderer) 546 NDS_DestroyRenderer(SDL_Renderer * renderer)
517 { 547 {
518 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata; 548 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
519 /*SDL_Window *window = SDL_GetWindowFromID(renderer->window); 549 /*SDL_Window *window = SDL_GetWindowFromID(renderer->window);
520 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);*/ 550 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);*/
521 int i; 551 int i;
522 552
553 printf("+NDS_DestroyRenderer\n");
523 if (data) { 554 if (data) {
524 /* TODO: free anything relevant. */ 555 /* TODO: free anything relevant. */
525 /*for (i = 0; i < SDL_arraysize(data->texture); ++i) { 556 /*for (i = 0; i < SDL_arraysize(data->texture); ++i) {
526 if (data->texture[i]) { 557 if (data->texture[i]) {
527 DestroyTexture(data->renderer, data->texture[i]); 558 DestroyTexture(data->renderer, data->texture[i]);
537 } 568 }
538 SDL_FreeDirtyRects(&data->dirty);*/ 569 SDL_FreeDirtyRects(&data->dirty);*/
539 SDL_free(data); 570 SDL_free(data);
540 } 571 }
541 SDL_free(renderer); 572 SDL_free(renderer);
573 printf("-NDS_DestroyRenderer\n");
542 } 574 }
543 575
544 /* vi: set ts=4 sw=4 expandtab: */ 576 /* vi: set ts=4 sw=4 expandtab: */