Mercurial > sdl-ios-xcode

comparison src/video/nds/SDL_ndsrender.c @ 2735:204be4fc2726

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Final merge of Google Summer of Code 2008 work... Port SDL 1.3 to the Nintendo DS by Darren Alton, mentored by Sam Lantinga
author Sam Lantinga <slouken@libsdl.org>
date Wed, 27 Aug 2008 15:10:03 +0000
parents
children 27cb878a278e
comparison
equal deleted inserted replaced
2734:dd25eabe441c 2735:204be4fc2726
1 /*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2006 Sam Lantinga
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19 Sam Lantinga
20 slouken@libsdl.org
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <nds.h>
26 #include <nds/arm9/video.h>
27 #include <nds/arm9/sprite.h>
28 #include <nds/arm9/trig_lut.h>
29
30 #include "SDL_config.h"
31
32 #include "SDL_video.h"
33 #include "../SDL_sysvideo.h"
34 #include "../SDL_yuv_sw_c.h"
35 #include "../SDL_renderer_sw.h"
36
37 /* NDS sprite-related functions */
38 #define SPRITE_DMA_CHANNEL 3
39 #define SPRITE_ANGLE_MASK 0x01FF
40
41 void
42 NDS_OAM_Update(tOAM * oam, int sub)
43 {
44 DC_FlushAll();
45 dmaCopyHalfWords(SPRITE_DMA_CHANNEL, oam->spriteBuffer,
46 sub ? OAM_SUB : OAM, SPRITE_COUNT * sizeof(SpriteEntry));
47 }
48
49 void
50 NDS_OAM_RotateSprite(SpriteRotation * spriteRotation, u16 angle)
51 {
52 s16 s = SIN[angle & SPRITE_ANGLE_MASK] >> 4;
53 s16 c = COS[angle & SPRITE_ANGLE_MASK] >> 4;
54
55 spriteRotation->hdx = c;
56 spriteRotation->hdy = s;
57 spriteRotation->vdx = -s;
58 spriteRotation->vdy = c;
59 }
60
61 void
62 NDS_OAM_Init(tOAM * oam, int sub)
63 {
64 int i;
65 for (i = 0; i < SPRITE_COUNT; i++) {
66 oam->spriteBuffer[i].attribute[0] = ATTR0_DISABLED;
67 oam->spriteBuffer[i].attribute[1] = 0;
68 oam->spriteBuffer[i].attribute[2] = 0;
69 }
70 for (i = 0; i < MATRIX_COUNT; i++) {
71 NDS_OAM_RotateSprite(&(oam->matrixBuffer[i]), 0);
72 }
73 swiWaitForVBlank();
74 NDS_OAM_Update(oam, sub);
75 }
76
77 void
78 NDS_OAM_HideSprite(SpriteEntry * spriteEntry)
79 {
80 spriteEntry->isRotoscale = 0;
81 spriteEntry->isHidden = 1;
82 }
83
84 void
85 NDS_OAM_ShowSprite(SpriteEntry * spriteEntry, int affine, int double_bound)
86 {
87 if (affine) {
88 spriteEntry->isRotoscale = 1;
89 spriteEntry->rsDouble = double_bound;
90 } else {
91 spriteEntry->isHidden = 0;
92 }
93 }
94
95
96 /* SDL NDS renderer implementation */
97
98 static SDL_Renderer *NDS_CreateRenderer(SDL_Window * window, Uint32 flags);
99 static int NDS_ActivateRenderer(SDL_Renderer * renderer);
100 static int NDS_DisplayModeChanged(SDL_Renderer * renderer);
101 static int NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
102 static int NDS_QueryTexturePixels(SDL_Renderer * renderer,
103 SDL_Texture * texture, void **pixels,
104 int *pitch);
105 static int NDS_SetTexturePalette(SDL_Renderer * renderer,
106 SDL_Texture * texture,
107 const SDL_Color * colors, int firstcolor,
108 int ncolors);
109 static int NDS_GetTexturePalette(SDL_Renderer * renderer,
110 SDL_Texture * texture, SDL_Color * colors,
111 int firstcolor, int ncolors);
112 static int NDS_SetTextureColorMod(SDL_Renderer * renderer,
113 SDL_Texture * texture);
114 static int NDS_SetTextureAlphaMod(SDL_Renderer * renderer,
115 SDL_Texture * texture);
116 static int NDS_SetTextureBlendMode(SDL_Renderer * renderer,
117 SDL_Texture * texture);
118 static int NDS_SetTextureScaleMode(SDL_Renderer * renderer,
119 SDL_Texture * texture);
120 static int NDS_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
121 const SDL_Rect * rect, const void *pixels,
122 int pitch);
123 static int NDS_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
124 const SDL_Rect * rect, int markDirty,
125 void **pixels, int *pitch);
126 static void NDS_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
127 static void NDS_DirtyTexture(SDL_Renderer * renderer,
128 SDL_Texture * texture, int numrects,
129 const SDL_Rect * rects);
130 static int NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g,
131 Uint8 b, Uint8 a, const SDL_Rect * rect);
132 static int NDS_RenderCopy(SDL_Renderer * renderer,
133 SDL_Texture * texture,
134 const SDL_Rect * srcrect, const SDL_Rect * dstrect);
135 static void NDS_RenderPresent(SDL_Renderer * renderer);
136 static void NDS_DestroyTexture(SDL_Renderer * renderer,
137 SDL_Texture * texture);
138 static void NDS_DestroyRenderer(SDL_Renderer * renderer);
139
140
141 SDL_RenderDriver NDS_RenderDriver = {
142 NDS_CreateRenderer,
143 {"nds", /* char* name */
144 (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_PRESENTVSYNC), /* u32 flags */
145 (SDL_TEXTUREMODULATE_NONE), /* u32 mod_modes */
146 (SDL_TEXTUREBLENDMODE_MASK), /* u32 blend_modes */
147 (SDL_TEXTURESCALEMODE_FAST), /* u32 scale_modes */
148 3, /* u32 num_texture_formats */
149 {
150 SDL_PIXELFORMAT_INDEX8,
151 SDL_PIXELFORMAT_ABGR1555,
152 SDL_PIXELFORMAT_BGR555,
153 }, /* u32 texture_formats[20] */
154 (256), /* int max_texture_width */
155 (256), /* int max_texture_height */
156 }
157 };
158
159 typedef struct
160 {
161 bg_attribute *bg; /* backgrounds */
162 tOAM oam_copy; /* sprites */
163 u8 bg_taken[4];
164 int sub;
165 } NDS_RenderData;
166
167 typedef struct
168 {
169 enum
170 { NDSTX_BG, NDSTX_SPR } type; /* represented in a bg or sprite. */
171 int hw_index; /* sprite: index in the OAM. / bg: 2 or 3. */
172 struct
173 {
174 int hdx, hdy, vdx, vdy; /* affine transformation, used for scaling. */
175 int pitch, bpp; /* some useful info */
176 } dim;
177 u16 *vram_pixels; /* where the pixel data is stored (a pointer into VRAM) */
178 u16 *vram_palette; /* where the palette data is stored if it's indexed. */
179 /*int size; */
180 } NDS_TextureData;
181
182
183
184 SDL_Renderer *
185 NDS_CreateRenderer(SDL_Window * window, Uint32 flags)
186 {
187 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
188 SDL_DisplayMode *displayMode = &display->current_mode;
189 SDL_Renderer *renderer;
190 NDS_RenderData *data;
191 int i, n;
192 int bpp;
193 Uint32 Rmask, Gmask, Bmask, Amask;
194
195 if (!SDL_PixelFormatEnumToMasks(displayMode->format, &bpp,
196 &Rmask, &Gmask, &Bmask, &Amask)) {
197 SDL_SetError("Unknown display format");
198 return NULL;
199 }
200 switch (displayMode->format) {
201 case SDL_PIXELFORMAT_INDEX8:
202 case SDL_PIXELFORMAT_ABGR1555:
203 case SDL_PIXELFORMAT_BGR555:
204 /* okay */
205 break;
206 case SDL_PIXELFORMAT_RGB555:
207 case SDL_PIXELFORMAT_RGB565:
208 case SDL_PIXELFORMAT_ARGB1555:
209 /* we'll take these too for now */
210 break;
211 default:
212 SDL_SetError("Warning: wrong display format for NDS!\n");
213 break;
214 }
215
216 renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
217 if (!renderer) {
218 SDL_OutOfMemory();
219 return NULL;
220 }
221
222 data = (NDS_RenderData *) SDL_malloc(sizeof(*data));
223 if (!data) {
224 NDS_DestroyRenderer(renderer);
225 SDL_OutOfMemory();
226 return NULL;
227 }
228 SDL_zerop(data);
229
230 renderer->RenderFill = NDS_RenderFill;
231 renderer->RenderCopy = NDS_RenderCopy;
232 renderer->RenderPresent = NDS_RenderPresent;
233 renderer->DestroyRenderer = NDS_DestroyRenderer;
234 renderer->info.name = NDS_RenderDriver.info.name;
235 renderer->info.flags = 0;
236 renderer->window = window->id;
237 renderer->driverdata = data;
238 renderer->CreateTexture = NDS_CreateTexture;
239 renderer->QueryTexturePixels = NDS_QueryTexturePixels;
240 renderer->SetTexturePalette = NDS_SetTexturePalette;
241 renderer->GetTexturePalette = NDS_GetTexturePalette;
242 renderer->SetTextureColorMod = NDS_SetTextureColorMod;
243 renderer->SetTextureAlphaMod = NDS_SetTextureAlphaMod;
244 renderer->SetTextureBlendMode = NDS_SetTextureBlendMode;
245 renderer->SetTextureScaleMode = NDS_SetTextureScaleMode;
246 renderer->UpdateTexture = NDS_UpdateTexture;
247 renderer->LockTexture = NDS_LockTexture;
248 renderer->UnlockTexture = NDS_UnlockTexture;
249 renderer->DirtyTexture = NDS_DirtyTexture;
250 renderer->DestroyTexture = NDS_DestroyTexture;
251
252 renderer->info.mod_modes = NDS_RenderDriver.info.mod_modes;
253 renderer->info.blend_modes = NDS_RenderDriver.info.blend_modes;
254 renderer->info.scale_modes = NDS_RenderDriver.info.scale_modes;
255 renderer->info.num_texture_formats =
256 NDS_RenderDriver.info.num_texture_formats;
257 SDL_memcpy(renderer->info.texture_formats,
258 NDS_RenderDriver.info.texture_formats,
259 sizeof(renderer->info.texture_formats));
260 renderer->info.max_texture_width =
261 NDS_RenderDriver.info.max_texture_width;
262 renderer->info.max_texture_height =
263 NDS_RenderDriver.info.max_texture_height;
264
265 data->sub = 0; /* TODO: this is hard-coded to the "main" screen.
266 figure out how to detect whether to set it to
267 "sub" screen. window->id, perhaps? */
268 if (!data->sub) {
269 data->bg = &BACKGROUND;
270 } else {
271 data->bg = &BACKGROUND_SUB;
272 }
273 data->bg_taken[2] = data->bg_taken[3] = 0;
274
275 NDS_OAM_Init(&(data->oam_copy), data->sub); /* init sprites. */
276
277 return renderer;
278 }
279
280 static int
281 NDS_ActivateRenderer(SDL_Renderer * renderer)
282 {
283 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
284
285 return 0;
286 }
287
288 static int
289 NDS_DisplayModeChanged(SDL_Renderer * renderer)
290 {
291 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
292
293 return 0;
294 }
295
296 static int
297 NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
298 {
299 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
300 NDS_TextureData *txdat = NULL;
301 int i;
302 int bpp;
303 Uint32 Rmask, Gmask, Bmask, Amask;
304
305 if (!SDL_PixelFormatEnumToMasks
306 (texture->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
307 SDL_SetError("Unknown texture format");
308 return -1;
309 }
310
311 /* conditional statements on w/h to place it as bg/sprite
312 depending on which one it fits. */
313 if (texture->w <= 64 && texture->h <= 64) {
314 int whichspr = -1;
315 printf("Tried to make a sprite.\n");
316 txdat->type = NDSTX_SPR;
317 for (i = 0; i < SPRITE_COUNT; ++i) {
318 if (data->oam_copy.spriteBuffer[i].attribute[0] & ATTR0_DISABLED) {
319 whichspr = i;
320 break;
321 }
322 }
323 if (whichspr >= 0) {
324 SpriteEntry *sprent = &(data->oam_copy.spriteBuffer[whichspr]);
325 int maxside = texture->w > texture->h ? texture->w : texture->h;
326 int pitch;
327
328 texture->driverdata = SDL_calloc(1, sizeof(NDS_TextureData));
329 txdat = (NDS_TextureData *) texture->driverdata;
330 if (!txdat) {
331 SDL_OutOfMemory();
332 return -1;
333 }
334
335 sprent->objMode = OBJMODE_BITMAP;
336 sprent->posX = 0;
337 sprent->posY = 0;
338 sprent->colMode = OBJCOLOR_16; /* OBJCOLOR_256 for INDEX8 */
339
340 /* the first 32 sprites get transformation matrices.
341 first come, first served */
342 if (whichspr < MATRIX_COUNT) {
343 sprent->isRotoscale = 1;
344 sprent->rsMatrixIdx = whichspr;
345 }
346
347 /* containing shape (square or 2:1 rectangles) */
348 sprent->objShape = OBJSHAPE_SQUARE;
349 if (texture->w / 2 >= texture->h) {
350 sprent->objShape = OBJSHAPE_WIDE;
351 } else if (texture->h / 2 >= texture->w) {
352 sprent->objShape = OBJSHAPE_TALL;
353 }
354
355 /* size in pixels */
356 /* FIXME: "pitch" is hardcoded for 2bytes per pixel. */
357 sprent->objSize = OBJSIZE_64;
358 pitch = 128;
359 if (maxside <= 8) {
360 sprent->objSize = OBJSIZE_8;
361 pitch = 16;
362 } else if (maxside <= 16) {
363 sprent->objSize = OBJSIZE_16;
364 pitch = 32;
365 } else if (maxside <= 32) {
366 sprent->objSize = OBJSIZE_32;
367 pitch = 64;
368 }
369
370 /* FIXME: this is hard-coded and will obviously only work for one
371 sprite-texture. tells it to look at the beginning of SPRITE_GFX
372 for its pixels. */
373 sprent->tileIdx = 0;
374
375 /* now for the texture data */
376 txdat->type = NDSTX_SPR;
377 txdat->hw_index = whichspr;
378 txdat->dim.hdx = 0x100;
379 txdat->dim.hdy = 0;
380 txdat->dim.vdx = 0;
381 txdat->dim.vdy = 0x100;
382 txdat->dim.pitch = pitch;
383 txdat->dim.bpp = bpp;
384 txdat->vram_pixels = (u16 *) (data->sub ? SPRITE_GFX_SUB : SPRITE_GFX); /* FIXME: use tileIdx*boundary
385 to point to proper location */
386 } else {
387 SDL_SetError("Out of NDS sprites.");
388 }
389 } else if (texture->w <= 256 && texture->h <= 256) {
390 int whichbg = -1, base = 0;
391 if (!data->bg_taken[2]) {
392 whichbg = 2;
393 } else if (!data->bg_taken[3]) {
394 whichbg = 3;
395 base = 4;
396 }
397 if (whichbg >= 0) {
398 texture->driverdata = SDL_calloc(1, sizeof(NDS_TextureData));
399 txdat = (NDS_TextureData *) texture->driverdata;
400 if (!txdat) {
401 SDL_OutOfMemory();
402 return -1;
403 }
404
405 /* this is hard-coded to being 256x256 ABGR1555 for now. */
406 data->bg->control[whichbg] = (bpp == 8) ?
407 BG_BMP8_256x256 : BG_BMP16_256x256;
408
409 data->bg->control[whichbg] |= BG_BMP_BASE(base);
410
411 data->bg->scroll[whichbg].x = 0;
412 data->bg->scroll[whichbg].y = 0;
413
414 txdat->type = NDSTX_BG;
415 txdat->hw_index = whichbg;
416 txdat->dim.hdx = 0x100;
417 txdat->dim.hdy = 0;
418 txdat->dim.vdx = 0;
419 txdat->dim.vdy = 0x100;
420 txdat->dim.pitch = 512;
421 txdat->dim.bpp = bpp;
422 txdat->vram_pixels = (u16 *) (data->sub ?
423 BG_BMP_RAM_SUB(base) :
424 BG_BMP_RAM(base));
425
426 /*txdat->size = txdat->dim.pitch * texture->h; */
427 } else {
428 SDL_SetError("Out of NDS backgrounds.");
429 }
430 } else {
431 SDL_SetError("Texture too big for NDS hardware.");
432 }
433
434 if (!texture->driverdata) {
435 return -1;
436 }
437
438 return 0;
439 }
440
441 static int
442 NDS_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
443 void **pixels, int *pitch)
444 {
445 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
446 *pixels = txdat->vram_pixels;
447 *pitch = txdat->dim.pitch;
448 return 0;
449 }
450
451 static int
452 NDS_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
453 const SDL_Rect * rect, const void *pixels, int pitch)
454 {
455 NDS_TextureData *txdat;
456 Uint8 *src, *dst;
457 int row;
458 size_t length;
459
460 txdat = (NDS_TextureData *) texture->driverdata;
461
462 src = (Uint8 *) pixels;
463 dst =
464 (Uint8 *) txdat->vram_pixels + rect->y * txdat->dim.pitch +
465 rect->x * ((txdat->dim.bpp + 1) / 8);
466 length = rect->w * ((txdat->dim.bpp + 1) / 8);
467
468 if (rect->w == texture->w) {
469 dmaCopy(src, dst, length * rect->h);
470 } else {
471 for (row = 0; row < rect->h; ++row) {
472 dmaCopy(src, dst, length);
473 src += pitch;
474 dst += txdat->dim.pitch;
475 }
476 }
477
478 return 0;
479 }
480
481 static int
482 NDS_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
483 const SDL_Rect * rect, int markDirty, void **pixels,
484 int *pitch)
485 {
486 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
487
488 *pixels = (void *) ((u8 *) txdat->vram_pixels + rect->y
489 * txdat->dim.pitch +
490 rect->x * ((txdat->dim.bpp + 1) / 8));
491 *pitch = txdat->dim.pitch;
492
493 return 0;
494 }
495
496 static void
497 NDS_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
498 {
499 /* stub! */
500 }
501
502 static void
503 NDS_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
504 int numrects, const SDL_Rect * rects)
505 {
506 /* stub! */
507 }
508
509 static int
510 NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b,
511 Uint8 a, const SDL_Rect * rect)
512 {
513 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
514 SDL_Rect real_rect = *rect;
515 u16 color;
516 int i, j;
517
518 color = RGB8(r, g, b); /* <-- macro in libnds that makes an ARGB1555 pixel */
519 /* TODO: make a single-color sprite and stretch it.
520 calculate the "HDX" width modifier of the sprite by:
521 let S be the actual sprite's width (like, 32 pixels for example)
522 let R be the rectangle's width (maybe 50 pixels)
523 HDX = (R<<8) / S;
524 (it's fixed point, hence the bit shift. same goes for vertical.
525 be sure to use 32-bit int's for the bit shift before the division!)
526 */
527
528 return 0;
529 }
530
531 static int
532 NDS_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
533 const SDL_Rect * srcrect, const SDL_Rect * dstrect)
534 {
535 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
536 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
537 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
538 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
539 int i;
540 int bpp = SDL_BYTESPERPIXEL(texture->format);
541 int pitch = txdat->dim.pitch;
542
543 if (txdat->type == NDSTX_BG) {
544 bg_rotation *bgrot = (txdat->hw_index == 2) ?
545 &(data->bg->bg2_rotation) : &(data->bg->bg3_rotation);
546 bgrot->xdx = txdat->dim.hdx;
547 bgrot->xdy = txdat->dim.hdy;
548 bgrot->ydx = txdat->dim.vdx;
549 bgrot->ydy = txdat->dim.vdy;
550 bgrot->centerX = 0;
551 bgrot->centerY = 0;
552
553 data->bg->scroll[txdat->hw_index].x = dstrect->x;
554 data->bg->scroll[txdat->hw_index].y = dstrect->y;
555 } else {
556 /* sprites not fully implemented yet */
557 SpriteEntry *spr = &(data->oam_copy.spriteBuffer[txdat->hw_index]);
558 spr->posX = dstrect->x;
559 spr->posY = dstrect->y;
560 if (txdat->hw_index < MATRIX_COUNT && spr->isRotoscale) {
561 SpriteRotation *sprot =
562 &(data->oam_copy.matrixBuffer[txdat->hw_index]);
563 sprot->hdx = txdat->dim.hdx;
564 sprot->hdy = txdat->dim.hdy;
565 sprot->vdx = txdat->dim.vdx;
566 sprot->vdy = txdat->dim.vdy;
567 }
568 }
569
570 return 0;
571 }
572
573
574 static void
575 NDS_RenderPresent(SDL_Renderer * renderer)
576 {
577 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
578 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
579 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
580
581 /* update sprites */
582 NDS_OAM_Update(&(data->oam_copy), data->sub);
583 /* vsync for NDS */
584 if (renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) {
585 swiWaitForVBlank();
586 }
587 }
588
589 static void
590 NDS_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
591 {
592 NDS_TextureData *txdat = texture->driverdata;
593 /* free anything else allocated for texture */
594 SDL_free(txdat);
595 }
596
597 static void
598 NDS_DestroyRenderer(SDL_Renderer * renderer)
599 {
600 NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
601 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
602 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
603 int i;
604
605 if (data) {
606 /* free anything else relevant if anything else is allocated. */
607 SDL_free(data);
608 }
609 SDL_free(renderer);
610 }
611
612 static int
613 NDS_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
614 const SDL_Color * colors, int firstcolor, int ncolors)
615 {
616 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
617 /* set 8-bit modes in the background control registers
618 for backgrounds, BGn_CR |= BG_256_COLOR */
619
620 return 0;
621 }
622
623 static int
624 NDS_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
625 SDL_Color * colors, int firstcolor, int ncolors)
626 {
627 NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
628 /* stub! */
629 return 0;
630 }
631
632 static int
633 NDS_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
634 {
635 /* stub! */
636 return 0;
637 }
638
639 static int
640 NDS_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
641 {
642 /* stub! */
643 return 0;
644 }
645
646 static int
647 NDS_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
648 {
649 /* stub! */
650 return 0;
651 }
652
653 static int
654 NDS_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
655 {
656 /* stub! (note: NDS hardware scaling is nearest neighbor.) */
657 return 0;
658 }
659
660 /* vi: set ts=4 sw=4 expandtab: */