Mercurial > sdl-ios-xcode

comparison src/video/nds/SDL_ndsrender.c @ 2672:74ac057679d5 gsoc2008_nds

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
NDS video driver is now functional, using software rendering and framebuffer.
author Darren Alton <dalton@stevens.edu>
date Tue, 17 Jun 2008 08:26:36 +0000
parents c3e7c0698cbb
children 24a6b3588eac
comparison
equal deleted inserted replaced
2671:c3e7c0698cbb 2672:74ac057679d5
59 int current_screen; 59 int current_screen;
60 SDL_Surface *screens[3]; 60 SDL_Surface *screens[3];
61 int ultimate_answer; 61 int ultimate_answer;
62 } SDL_NDS_RenderData; 62 } SDL_NDS_RenderData;
63 63
64
65
66 /* this is mainly hackish testing/debugging stuff to get cleaned up soon
67 anything named sdlds_blah shouldn't make it into the stable version
68 */
69
70 u16
71 sdlds_rgb2bgr(u16 c) {
72 /* hack to get the colors right until I actually add BGR555 to the headers */
73 u16 Rmask = 0x7C00, Bmask = 0x001F, GAmask = 0x83E0, r, b;
74 r = (c & Rmask) >> 10;
75 b = (c & Bmask) << 10;
76 return (c & GAmask) | r | b;
77 }
78
79 void
80 sdlds_surf2vram(SDL_Surface * s)
81 {
82
83 int i;
84 /*for (i = 0; i < 30; ++i) swiWaitForVBlank();*/
85 for (i = 0; i < 256 * 192; ++i) {
86 ((u16 *) VRAM_A)[i] = sdlds_rgb2bgr(((u16 *) (s->pixels))[i+160]);
87 }
88 }
89
90 void
91 sdlds_print_pixfmt_info(SDL_PixelFormat *f) {
92 if(!f) return;
93 printf("bpp: %d\nRGBA: %x %x %x %x\n",
94 f->BitsPerPixel, f->Rmask, f->Gmask, f->Bmask, f->Amask);
95 }
96
97 void
98 sdlds_print_surface_info(SDL_Surface *s) {
99 if(!s) return;
100 printf("flags: %x\nsize: %dx%d, pitch: %d\nlocked: %d, refcount: %d\n",
101 s->flags, s->w, s->h, s->pitch, s->locked, s->refcount);
102 sdlds_print_pixfmt_info(s->format);
103 }
104
105
106
64 SDL_Renderer * 107 SDL_Renderer *
65 SDL_NDS_CreateRenderer(SDL_Window * window, Uint32 flags) 108 SDL_NDS_CreateRenderer(SDL_Window * window, Uint32 flags)
66 { 109 {
67 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); 110 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
68 SDL_DisplayMode *displayMode = &display->current_mode; 111 SDL_DisplayMode *displayMode = &display->current_mode;
69 SDL_Renderer *renderer; 112 SDL_Renderer *renderer;
70 SDL_NDS_RenderData *data; 113 SDL_NDS_RenderData *data;
71 int i, n; 114 int i, n;
72 int bpp = 16; 115 int bpp = 15;
116 /*/
73 Uint32 Rmask = 0x7C00, Gmask = 0x03E0, Bmask = 0x001F, Amask = 0x8000; 117 Uint32 Rmask = 0x7C00, Gmask = 0x03E0, Bmask = 0x001F, Amask = 0x8000;
74 118 /*/
119 Uint32 Rmask = 0x001F, Gmask = 0x03E0, Bmask = 0x7C00, Amask = 0x8000;
120 //*/
121
122 #if 0
75 printf("SDL_NDS_CreateRenderer(window, 0x%x)\n", flags); 123 printf("SDL_NDS_CreateRenderer(window, 0x%x)\n", flags);
76 printf(" window: (%d,%d), %dx%d\n", window->x, window->y, window->w, 124 printf(" window: (%d,%d), %dx%d\n",
77 window->h); 125 window->x, window->y, window->w, window->h);
126 #endif
78 127
79 /* hard coded this to ARGB1555 for now 128 /* hard coded this to ARGB1555 for now
80 if (!SDL_PixelFormatEnumToMasks 129 if (!SDL_PixelFormatEnumToMasks
81 (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { 130 (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
82 SDL_SetError("Unknown display format"); 131 SDL_SetError("Unknown display format");
117 renderer->info.flags |= SDL_RENDERER_PRESENTCOPY; 166 renderer->info.flags |= SDL_RENDERER_PRESENTCOPY;
118 n = 1; 167 n = 1;
119 } 168 }
120 for (i = 0; i < n; ++i) { 169 for (i = 0; i < n; ++i) {
121 data->screens[i] = 170 data->screens[i] =
122 SDL_CreateRGBSurface(0, 256, 192, bpp, Rmask, Gmask, Bmask, 171 SDL_CreateRGBSurface(0, 256, 192, bpp, Rmask, Gmask, Bmask, Amask);
123 Amask);
124 if (!data->screens[i]) { 172 if (!data->screens[i]) {
125 SDL_NDS_DestroyRenderer(renderer); 173 SDL_NDS_DestroyRenderer(renderer);
126 return NULL; 174 return NULL;
127 } 175 }
128 SDL_SetSurfacePalette(data->screens[i], display->palette); 176 SDL_SetSurfacePalette(data->screens[i], display->palette);
129 } 177 }
130 178
131 data->current_screen = 0; 179 data->current_screen = 0;
132 data->ultimate_answer = 42; 180 data->ultimate_answer = 42;
133 #if 0 181
134 #define blarg (data->screens[0])
135 printf("hello?\n");
136 if (!data || !(data->screens) || !blarg) {
137 printf("they're null.\n");
138 } else {
139 printf("not null.\n");
140 printf("%d\n%d\n%d\n%d\n%x\n%x\n%x\n%x\n", blarg->w, blarg->h, blarg->pitch, blarg->format->BitsPerPixel, blarg->format->Rmask, blarg->format->Gmask, blarg->format->Bmask, (u32) (blarg->pixels)); /* ARGH WHY DOESN'T THIS PRINT AT ALL? */
141 printf("hurr\n");
142 }
143 #undef blarg
144 #endif
145 return renderer; 182 return renderer;
146 } 183 }
147 184
148 static int 185 static int
149 SDL_NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b, 186 SDL_NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b,
157 color = SDL_MapRGBA(target->format, r, g, b, a); 194 color = SDL_MapRGBA(target->format, r, g, b, a);
158 195
159 return SDL_FillRect(target, &real_rect, color); 196 return SDL_FillRect(target, &real_rect, color);
160 } 197 }
161 198
162 /* this is mainly for testing stuff to put a surface where I can see it */
163 void
164 sdlds_surf2vram(SDL_Surface * s)
165 {
166 int i;
167 for (i = 0; i < 256 * 192; ++i) {
168 ((u16 *) VRAM_A)[i] = ((u16 *) (s->pixels))[i];
169 }
170 }
171
172 static int 199 static int
173 SDL_NDS_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, 200 SDL_NDS_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
174 const SDL_Rect * srcrect, const SDL_Rect * dstrect) 201 const SDL_Rect * srcrect, const SDL_Rect * dstrect)
175 { 202 {
176 SDL_NDS_RenderData *data = (SDL_NDS_RenderData *) renderer->driverdata; 203 SDL_NDS_RenderData *data = (SDL_NDS_RenderData *) renderer->driverdata;
177 SDL_Window *window = SDL_GetWindowFromID(renderer->window); 204 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
178 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); 205 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
206 #if 0
179 printf("SDL_NDS_RenderCopy(renderer, texture, srcrect, dstrect)\n"); 207 printf("SDL_NDS_RenderCopy(renderer, texture, srcrect, dstrect)\n");
180 printf(" renderer: %s\n", renderer->info.name); 208 printf(" renderer: %s\n", renderer->info.name);
181 printf(" texture: %dx%d\n", texture->w, texture->h); 209 printf(" texture: %dx%d\n", texture->w, texture->h);
182 printf(" srcrect: (%d,%d), %dx%d\n", srcrect->x, srcrect->y, srcrect->w, 210 printf(" srcrect: (%d,%d), %dx%d\n", srcrect->x, srcrect->y, srcrect->w,
183 srcrect->h); 211 srcrect->h);
184 printf(" dstrect: (%d,%d), %dx%d\n", dstrect->x, dstrect->y, dstrect->w, 212 printf(" dstrect: (%d,%d), %dx%d\n", dstrect->x, dstrect->y, dstrect->w,
185 dstrect->h); 213 dstrect->h);
186 214 #endif
187 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 215 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
188 SDL_Surface *target = data->screens[data->current_screen]; 216 SDL_Surface *target = data->screens[data->current_screen];
189 void *pixels = 217 void *pixels =
190 (Uint8 *) target->pixels + dstrect->y * target->pitch + 218 (Uint8 *) target->pixels + dstrect->y * target->pitch +
191 dstrect->x * target->format->BytesPerPixel; 219 dstrect->x * target->format->BytesPerPixel;
196 } else { 224 } else {
197 SDL_Surface *surface = (SDL_Surface *) texture->driverdata; 225 SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
198 SDL_Surface *target = data->screens[data->current_screen]; 226 SDL_Surface *target = data->screens[data->current_screen];
199 SDL_Rect real_srcrect = *srcrect; 227 SDL_Rect real_srcrect = *srcrect;
200 SDL_Rect real_dstrect = *dstrect; 228 SDL_Rect real_dstrect = *dstrect;
201 printf("Rmask %x Gmask %x Bmask %x Amask %x\n" 229 /*sdlds_print_surface_info(surface);
202 "width %d, height %d, pitch %d\nbpp %d, pixels %x\n", 230 sdlds_print_surface_info(target);*/
203 surface->format->Rmask, surface->format->Gmask,
204 surface->format->Bmask, surface->format->Amask,
205 surface->w, surface->h, surface->pitch,
206 surface->format->BitsPerPixel, (u32) (surface->pixels));
207 sdlds_surf2vram(surface); 231 sdlds_surf2vram(surface);
208 return SDL_LowerBlit(surface, &real_srcrect, target, &real_dstrect); 232 return SDL_LowerBlit(surface, &real_srcrect, target, &real_dstrect);
209 } 233 }
210 #if 0 234 #if 0
211 /* previous attempt to copy it directly to vram */ 235 /* copy it directly to vram */
212 SDL_Surface *surface = (SDL_Surface *) texture->driverdata; 236 SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
213 int sx = srcrect->x, sy = srcrect->y, sw = srcrect->w, sh = srcrect->h; 237 int sx = srcrect->x, sy = srcrect->y, sw = srcrect->w, sh = srcrect->h;
214 int dx = dstrect->x, dy = dstrect->y, dw = dstrect->w, dh = dstrect->h; 238 int dx = dstrect->x, dy = dstrect->y, dw = dstrect->w, dh = dstrect->h;
215 int si, sj, di, dj; 239 int si, sj, di, dj;
216 /*printf("DEBUG: still alive!\n"); */
217 for (sj = 0, dj = 0; sj < sh && dj < dh; ++sj, ++dj) { 240 for (sj = 0, dj = 0; sj < sh && dj < dh; ++sj, ++dj) {
218 for (si = 0, di = 0; si < sw && di < dw; ++si, ++di) { 241 for (si = 0, di = 0; si < sw && di < dw; ++si, ++di) {
219 ((uint16 *) VRAM_A)[(dj + dy) * 256 + di + dx] 242 VRAM_A[(dj + dy) * 256 + di + dx] =
220 = ((Uint16 *) surface->pixels)[(sj + sy) * (surface->w) + si + 243 ((Uint16 *) surface->pixels)[(sj + sy) * (surface->w) + si + sx];
221 sx];
222 } 244 }
223 } 245 }
224 /*printf("DEBUG: still alive!\n"); */ 246 return 0;
225 } 247 #endif
226 248 }
227 return 0; 249
228 #endif
229 }
230 250
231 static void 251 static void
232 SDL_NDS_RenderPresent(SDL_Renderer * renderer) 252 SDL_NDS_RenderPresent(SDL_Renderer * renderer)
233 { 253 {
234 SDL_NDS_RenderData *data = (SDL_NDS_RenderData *) renderer->driverdata; 254 SDL_NDS_RenderData *data = (SDL_NDS_RenderData *) renderer->driverdata;
235 255 #if 0
236 printf("SDL_NDS_RenderPresent(renderer)\n"); 256 printf("SDL_NDS_RenderPresent(renderer)\n");
237 printf(" renderer: %s\n", renderer->info.name); 257 printf(" renderer: %s\n", renderer->info.name);
258 #endif
238 /* Send the data to the display */ 259 /* Send the data to the display */
239 260 /*sdlds_surf2vram(data->screens[data->current_screen]);*/
240 #if 0
241 /*testing to see if rectangles drawn get copied right*/
242 {
243 SDL_Rect ra;
244 ra.x = 0;
245 ra.y = 0;
246 ra.w = 256;
247 ra.h = 192;
248
249 SDL_FillRect(data->screens[data->current_screen], &ra, 0x250);
250 ra.x = 32;
251 ra.y = 32;
252 ra.w = 192;
253 ra.h = 128;
254
255 SDL_FillRect(data->screens[data->current_screen], &ra,
256 SDL_MapRGBA(data->screens[data->current_screen]->format,
257 255, 255, 255, 255));
258 }
259 /*okay so this works but why not when I do it in the main()?
260 for some reason the screen I get from screen=SDL_SetVideoMode(...)
261 doesn't get copied to renderer->driverdata? */
262 for (i = 0; i < 30; ++i)
263 swiWaitForVBlank(); /* delay for debug purpose */
264 #endif
265 sdlds_surf2vram(data->screens[data->current_screen]);
266 261
267 /* Update the flipping chain, if any */ 262 /* Update the flipping chain, if any */
268 if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) { 263 if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) {
269 data->current_screen = (data->current_screen + 1) % 2; 264 data->current_screen = (data->current_screen + 1) % 2;
270 } else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) { 265 } else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) {