Mercurial > sdl-ios-xcode

comparison src/video/qnxgf/SDL_gf_render.c @ 3139:7f684f249ec9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
indent
author Sam Lantinga <slouken@libsdl.org>
date Sat, 23 May 2009 22:41:08 +0000
parents 7b3a09fb9c8b
children 4b594623401b
comparison
equal deleted inserted replaced
3125:d71d8ceda8b3 3139:7f684f249ec9
32 #include "SDL_video.h" 32 #include "SDL_video.h"
33 33
34 #include "SDL_gf_render.h" 34 #include "SDL_gf_render.h"
35 #include "SDL_qnxgf.h" 35 #include "SDL_qnxgf.h"
36 36
37 static SDL_Renderer* gf_createrenderer(SDL_Window* window, Uint32 flags); 37 static SDL_Renderer *gf_createrenderer(SDL_Window * window, Uint32 flags);
38 static int gf_displaymodechanged(SDL_Renderer* renderer); 38 static int gf_displaymodechanged(SDL_Renderer * renderer);
39 static int gf_activaterenderer(SDL_Renderer* renderer); 39 static int gf_activaterenderer(SDL_Renderer * renderer);
40 static int gf_createtexture(SDL_Renderer* renderer, SDL_Texture* texture); 40 static int gf_createtexture(SDL_Renderer * renderer, SDL_Texture * texture);
41 static int gf_querytexturepixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch); 41 static int gf_querytexturepixels(SDL_Renderer * renderer,
42 static int gf_settexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color* colors, int firstcolor, int ncolors); 42 SDL_Texture * texture, void **pixels,
43 static int gf_gettexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Color* colors, int firstcolor, int ncolors); 43 int *pitch);
44 static int gf_settexturecolormod(SDL_Renderer* renderer, SDL_Texture* texture); 44 static int gf_settexturepalette(SDL_Renderer * renderer,
45 static int gf_settexturealphamod(SDL_Renderer* renderer, SDL_Texture* texture); 45 SDL_Texture * texture,
46 static int gf_settextureblendmode(SDL_Renderer* renderer, SDL_Texture* texture); 46 const SDL_Color * colors, int firstcolor,
47 static int gf_settexturescalemode(SDL_Renderer* renderer, SDL_Texture* texture); 47 int ncolors);
48 static int gf_updatetexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch); 48 static int gf_gettexturepalette(SDL_Renderer * renderer,
49 static int gf_locktexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int markDirty, void** pixels, int* pitch); 49 SDL_Texture * texture, SDL_Color * colors,
50 static void gf_unlocktexture(SDL_Renderer* renderer, SDL_Texture* texture); 50 int firstcolor, int ncolors);
51 static void gf_dirtytexture(SDL_Renderer* renderer, SDL_Texture* texture, int numrects, const SDL_Rect* rects); 51 static int gf_settexturecolormod(SDL_Renderer * renderer,
52 static int gf_renderpoint(SDL_Renderer* renderer, int x, int y); 52 SDL_Texture * texture);
53 static int gf_renderline(SDL_Renderer* renderer, int x1, int y1, int x2, int y2); 53 static int gf_settexturealphamod(SDL_Renderer * renderer,
54 static int gf_renderfill(SDL_Renderer* renderer, const SDL_Rect* rect); 54 SDL_Texture * texture);
55 static int gf_rendercopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srcrect, const SDL_Rect* dstrect); 55 static int gf_settextureblendmode(SDL_Renderer * renderer,
56 static void gf_renderpresent(SDL_Renderer* renderer); 56 SDL_Texture * texture);
57 static void gf_destroytexture(SDL_Renderer* renderer, SDL_Texture* texture); 57 static int gf_settexturescalemode(SDL_Renderer * renderer,
58 static void gf_destroyrenderer(SDL_Renderer* renderer); 58 SDL_Texture * texture);
59 59 static int gf_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,
60 SDL_RenderDriver gf_renderdriver= 60 const SDL_Rect * rect, const void *pixels,
61 { 61 int pitch);
62 static int gf_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,
63 const SDL_Rect * rect, int markDirty, void **pixels,
64 int *pitch);
65 static void gf_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture);
66 static void gf_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture,
67 int numrects, const SDL_Rect * rects);
68 static int gf_renderpoint(SDL_Renderer * renderer, int x, int y);
69 static int gf_renderline(SDL_Renderer * renderer, int x1, int y1, int x2,
70 int y2);
71 static int gf_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect);
72 static int gf_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
73 const SDL_Rect * srcrect, const SDL_Rect * dstrect);
74 static void gf_renderpresent(SDL_Renderer * renderer);
75 static void gf_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture);
76 static void gf_destroyrenderer(SDL_Renderer * renderer);
77
78 SDL_RenderDriver gf_renderdriver = {
62 gf_createrenderer, 79 gf_createrenderer,
63 { 80 {
64 "qnxgf", 81 "qnxgf",
65 (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | 82 (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
66 SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 | 83 SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
67 SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD | 84 SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |
68 SDL_RENDERER_ACCELERATED), 85 SDL_RENDERER_ACCELERATED),
69 (SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR | 86 (SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
70 SDL_TEXTUREMODULATE_ALPHA), 87 SDL_TEXTUREMODULATE_ALPHA),
71 (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK | 88 (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |
72 SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD), 89 SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
73 (SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_SLOW), 90 (SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_SLOW),
74 13, 91 13,
75 { 92 {
76 SDL_PIXELFORMAT_INDEX8, 93 SDL_PIXELFORMAT_INDEX8,
77 SDL_PIXELFORMAT_RGB555, 94 SDL_PIXELFORMAT_RGB555,
78 SDL_PIXELFORMAT_RGB565, 95 SDL_PIXELFORMAT_RGB565,
79 SDL_PIXELFORMAT_RGB888, 96 SDL_PIXELFORMAT_RGB888,
80 SDL_PIXELFORMAT_BGR888, 97 SDL_PIXELFORMAT_BGR888,
81 SDL_PIXELFORMAT_ARGB8888, 98 SDL_PIXELFORMAT_ARGB8888,
82 SDL_PIXELFORMAT_RGBA8888, 99 SDL_PIXELFORMAT_RGBA8888,
83 SDL_PIXELFORMAT_ABGR8888, 100 SDL_PIXELFORMAT_ABGR8888,
84 SDL_PIXELFORMAT_BGRA8888, 101 SDL_PIXELFORMAT_BGRA8888,
85 SDL_PIXELFORMAT_YV12, 102 SDL_PIXELFORMAT_YV12,
86 SDL_PIXELFORMAT_YUY2, 103 SDL_PIXELFORMAT_YUY2,
87 SDL_PIXELFORMAT_UYVY, 104 SDL_PIXELFORMAT_UYVY,
88 SDL_PIXELFORMAT_YVYU 105 SDL_PIXELFORMAT_YVYU},
89 }, 106 0,
90 0, 107 0}
91 0
92 }
93 }; 108 };
94 109
95 static SDL_Renderer* gf_createrenderer(SDL_Window* window, Uint32 flags) 110 static SDL_Renderer *
96 { 111 gf_createrenderer(SDL_Window * window, Uint32 flags)
97 SDL_VideoDisplay* display = SDL_GetDisplayFromWindow(window); 112 {
98 SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata; 113 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
99 SDL_WindowData* wdata = (SDL_WindowData*)window->driverdata; 114 SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
100 SDL_Renderer* renderer = NULL; 115 SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
101 SDL_RenderData* rdata = NULL; 116 SDL_Renderer *renderer = NULL;
102 uint32_t it; 117 SDL_RenderData *rdata = NULL;
103 int32_t jt; 118 uint32_t it;
104 int32_t status; 119 int32_t jt;
105 120 int32_t status;
106 /* Check if it is OpenGL ES window */ 121
107 if ((window->flags & SDL_WINDOW_OPENGL)==SDL_WINDOW_OPENGL) 122 /* Check if it is OpenGL ES window */
108 { 123 if ((window->flags & SDL_WINDOW_OPENGL) == SDL_WINDOW_OPENGL) {
109 /* No error, just no need to create 2D renderer for OpenGL ES window */ 124 /* No error, just no need to create 2D renderer for OpenGL ES window */
110 return NULL; 125 return NULL;
111 } 126 }
112 127
113 /* Allocate new renderer structure */ 128 /* Allocate new renderer structure */
114 renderer=(SDL_Renderer*)SDL_calloc(1, sizeof(SDL_Renderer)); 129 renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(SDL_Renderer));
115 if (renderer==NULL) 130 if (renderer == NULL) {
116 { 131 SDL_OutOfMemory();
117 SDL_OutOfMemory(); 132 return NULL;
118 return NULL; 133 }
119 } 134
120 135 /* Allocate renderer data */
121 /* Allocate renderer data */ 136 rdata = (SDL_RenderData *) SDL_calloc(1, sizeof(SDL_RenderData));
122 rdata=(SDL_RenderData*)SDL_calloc(1, sizeof(SDL_RenderData)); 137 if (rdata == NULL) {
123 if (rdata==NULL) 138 SDL_free(renderer);
124 { 139 SDL_OutOfMemory();
125 SDL_free(renderer); 140 return NULL;
126 SDL_OutOfMemory(); 141 }
127 return NULL; 142
128 } 143 renderer->DisplayModeChanged = gf_displaymodechanged;
129 144 renderer->ActivateRenderer = gf_activaterenderer;
130 renderer->DisplayModeChanged=gf_displaymodechanged; 145 renderer->CreateTexture = gf_createtexture;
131 renderer->ActivateRenderer=gf_activaterenderer; 146 renderer->QueryTexturePixels = gf_querytexturepixels;
132 renderer->CreateTexture=gf_createtexture; 147 renderer->SetTexturePalette = gf_settexturepalette;
133 renderer->QueryTexturePixels=gf_querytexturepixels; 148 renderer->GetTexturePalette = gf_gettexturepalette;
134 renderer->SetTexturePalette=gf_settexturepalette; 149 renderer->SetTextureAlphaMod = gf_settexturealphamod;
135 renderer->GetTexturePalette=gf_gettexturepalette; 150 renderer->SetTextureColorMod = gf_settexturecolormod;
136 renderer->SetTextureAlphaMod=gf_settexturealphamod; 151 renderer->SetTextureBlendMode = gf_settextureblendmode;
137 renderer->SetTextureColorMod=gf_settexturecolormod; 152 renderer->SetTextureScaleMode = gf_settexturescalemode;
138 renderer->SetTextureBlendMode=gf_settextureblendmode; 153 renderer->UpdateTexture = gf_updatetexture;
139 renderer->SetTextureScaleMode=gf_settexturescalemode; 154 renderer->LockTexture = gf_locktexture;
140 renderer->UpdateTexture=gf_updatetexture; 155 renderer->UnlockTexture = gf_unlocktexture;
141 renderer->LockTexture=gf_locktexture; 156 renderer->DirtyTexture = gf_dirtytexture;
142 renderer->UnlockTexture=gf_unlocktexture; 157 renderer->RenderPoint = gf_renderpoint;
143 renderer->DirtyTexture=gf_dirtytexture; 158 renderer->RenderLine = gf_renderline;
144 renderer->RenderPoint=gf_renderpoint; 159 renderer->RenderFill = gf_renderfill;
145 renderer->RenderLine=gf_renderline; 160 renderer->RenderCopy = gf_rendercopy;
146 renderer->RenderFill=gf_renderfill; 161 renderer->RenderPresent = gf_renderpresent;
147 renderer->RenderCopy=gf_rendercopy; 162 renderer->DestroyTexture = gf_destroytexture;
148 renderer->RenderPresent = gf_renderpresent; 163 renderer->DestroyRenderer = gf_destroyrenderer;
149 renderer->DestroyTexture = gf_destroytexture; 164 renderer->info = gf_renderdriver.info;
150 renderer->DestroyRenderer = gf_destroyrenderer; 165 renderer->window = window->id;
151 renderer->info = gf_renderdriver.info; 166 renderer->driverdata = rdata;
152 renderer->window = window->id; 167
153 renderer->driverdata = rdata; 168 /* Set render acceleration flag in case it is accelerated */
154 169 if ((didata->caps & SDL_GF_ACCELERATED) == SDL_GF_ACCELERATED) {
155 /* Set render acceleration flag in case it is accelerated */ 170 renderer->info.flags = SDL_RENDERER_ACCELERATED;
156 if ((didata->caps & SDL_GF_ACCELERATED)==SDL_GF_ACCELERATED) 171 } else {
157 { 172 renderer->info.flags &= ~(SDL_RENDERER_ACCELERATED);
158 renderer->info.flags=SDL_RENDERER_ACCELERATED; 173 }
159 } 174
160 else 175 rdata->window = window;
161 { 176
162 renderer->info.flags&=~(SDL_RENDERER_ACCELERATED); 177 /* Check if upper level requested synchronization on vsync signal */
163 } 178 if ((flags & SDL_RENDERER_PRESENTVSYNC) == SDL_RENDERER_PRESENTVSYNC) {
164 179 rdata->enable_vsync = SDL_TRUE;
165 rdata->window=window; 180 } else {
166 181 rdata->enable_vsync = SDL_FALSE;
167 /* Check if upper level requested synchronization on vsync signal */ 182 }
168 if ((flags & SDL_RENDERER_PRESENTVSYNC)==SDL_RENDERER_PRESENTVSYNC) 183
169 { 184 /* Check what buffer copy/flip scheme is requested */
170 rdata->enable_vsync=SDL_TRUE; 185 rdata->surfaces_count = 0;
171 } 186 if ((flags & SDL_RENDERER_SINGLEBUFFER) == SDL_RENDERER_SINGLEBUFFER) {
172 else 187 if ((flags & SDL_RENDERER_PRESENTDISCARD) ==
173 { 188 SDL_RENDERER_PRESENTDISCARD) {
174 rdata->enable_vsync=SDL_FALSE; 189 renderer->info.flags |=
175 } 190 SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD;
176 191 } else {
177 /* Check what buffer copy/flip scheme is requested */ 192 renderer->info.flags |=
178 rdata->surfaces_count=0; 193 SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
179 if ((flags & SDL_RENDERER_SINGLEBUFFER)==SDL_RENDERER_SINGLEBUFFER) 194 }
180 { 195 rdata->surfaces_count = 1;
181 if ((flags & SDL_RENDERER_PRESENTDISCARD)==SDL_RENDERER_PRESENTDISCARD) 196 rdata->surface_visible_idx = 0;
182 { 197 rdata->surface_render_idx = 0;
183 renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD; 198 } else {
184 } 199 if ((flags & SDL_RENDERER_PRESENTFLIP2) == SDL_RENDERER_PRESENTFLIP2) {
185 else 200 renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
186 { 201 rdata->surfaces_count = 2;
187 renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY; 202 rdata->surface_visible_idx = 0;
188 } 203 rdata->surface_render_idx = 1;
189 rdata->surfaces_count=1; 204 } else {
190 rdata->surface_visible_idx=0; 205 if ((flags & SDL_RENDERER_PRESENTFLIP3) ==
191 rdata->surface_render_idx=0; 206 SDL_RENDERER_PRESENTFLIP3) {
192 } 207 renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
193 else 208 rdata->surfaces_count = 3;
194 { 209 rdata->surface_visible_idx = 0;
195 if ((flags & SDL_RENDERER_PRESENTFLIP2)==SDL_RENDERER_PRESENTFLIP2) 210 rdata->surface_render_idx = 1;
196 { 211 } else {
197 renderer->info.flags|=SDL_RENDERER_PRESENTFLIP2; 212 renderer->info.flags |=
198 rdata->surfaces_count=2; 213 SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
199 rdata->surface_visible_idx=0; 214 rdata->surfaces_count = 1;
200 rdata->surface_render_idx=1; 215 rdata->surface_visible_idx = 0;
201 } 216 rdata->surface_render_idx = 0;
202 else 217 }
203 { 218 }
204 if ((flags & SDL_RENDERER_PRESENTFLIP3)==SDL_RENDERER_PRESENTFLIP3) 219 }
205 { 220
206 renderer->info.flags|=SDL_RENDERER_PRESENTFLIP3; 221 /* Create layer surfaces, which could be visible */
207 rdata->surfaces_count=3; 222 for (it = 0; it < rdata->surfaces_count; it++) {
208 rdata->surface_visible_idx=0; 223 /* TODO: add palette creation */
209 rdata->surface_render_idx=1; 224
210 } 225 /* Create displayable surfaces */
211 else 226 status =
212 { 227 gf_surface_create_layer(&rdata->surface[it], &didata->layer, 1, 0,
213 renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY; 228 didata->current_mode.w,
214 rdata->surfaces_count=1; 229 didata->current_mode.h,
215 rdata->surface_visible_idx=0; 230 qnxgf_sdl_to_gf_pixelformat(didata->
216 rdata->surface_render_idx=0; 231 current_mode.
217 } 232 format), NULL,
218 } 233 GF_SURFACE_CREATE_2D_ACCESSIBLE);
219 } 234
220 235 if (status != GF_ERR_OK) {
221 /* Create layer surfaces, which could be visible */ 236 /* Free already allocated surfaces */
222 for (it=0; it<rdata->surfaces_count; it++) 237 for (jt = it - 1; jt > 0; jt--) {
223 { 238 gf_surface_free(rdata->surface[jt]);
224 /* TODO: add palette creation */ 239 rdata->surface[jt] = NULL;
225 240 }
226 /* Create displayable surfaces */ 241 SDL_free(rdata);
227 status=gf_surface_create_layer(&rdata->surface[it], &didata->layer, 1, 0, 242 SDL_free(renderer);
228 didata->current_mode.w, didata->current_mode.h, 243 if (status == GF_ERR_MEM) {
229 qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format), NULL, 244 SDL_SetError("unsufficient free video memory");
230 GF_SURFACE_CREATE_2D_ACCESSIBLE); 245 } else {
231 246 SDL_SetError("error during displayable surface creation");
232 if (status!=GF_ERR_OK) 247 }
233 { 248 return NULL;
234 /* Free already allocated surfaces */ 249 }
235 for (jt=it-1; jt>0; jt--) 250
236 { 251 /* Get detailed information about allocated surface */
237 gf_surface_free(rdata->surface[jt]); 252 gf_surface_get_info(rdata->surface[it], &rdata->surface_info[it]);
238 rdata->surface[jt]=NULL; 253 }
239 } 254
240 SDL_free(rdata); 255 return renderer;
241 SDL_free(renderer); 256 }
242 if (status==GF_ERR_MEM) 257
243 { 258 void
244 SDL_SetError("unsufficient free video memory"); 259 gf_addrenderdriver(_THIS)
245 } 260 {
246 else 261 uint32_t it;
247 { 262
248 SDL_SetError("error during displayable surface creation"); 263 for (it = 0; it < _this->num_displays; it++) {
249 } 264 SDL_AddRenderDriver(it, &gf_renderdriver);
250 return NULL; 265 }
251 }
252
253 /* Get detailed information about allocated surface */
254 gf_surface_get_info(rdata->surface[it], &rdata->surface_info[it]);
255 }
256
257 return renderer;
258 }
259
260 void gf_addrenderdriver(_THIS)
261 {
262 uint32_t it;
263
264 for (it=0; it<_this->num_displays; it++)
265 {
266 SDL_AddRenderDriver(it, &gf_renderdriver);
267 }
268 } 266 }
269 267
270 /****************************************************************************/ 268 /****************************************************************************/
271 /* SDL render interface */ 269 /* SDL render interface */
272 /****************************************************************************/ 270 /****************************************************************************/
273 static int gf_displaymodechanged(SDL_Renderer* renderer) 271 static int
274 { 272 gf_displaymodechanged(SDL_Renderer * renderer)
275 SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata; 273 {
276 274 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
277 /* Remove all allocated surfaces, they are no more valid */ 275
278 276 /* Remove all allocated surfaces, they are no more valid */
279 /* TODO: Add video mode change detection and new parameters detection */ 277
280 278 /* TODO: Add video mode change detection and new parameters detection */
281 return 0; 279
282 } 280 return 0;
283 281 }
284 static int gf_activaterenderer(SDL_Renderer* renderer) 282
285 { 283 static int
286 SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata; 284 gf_activaterenderer(SDL_Renderer * renderer)
287 SDL_VideoDisplay* display = SDL_GetDisplayFromWindow(rdata->window); 285 {
288 SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata; 286 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
289 287 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(rdata->window);
290 /* Setup current surface as visible */ 288 SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
289
290 /* Setup current surface as visible */
291 // gf_layer_set_surfaces(didata->layer, &rdata->surface[rdata->surface_visible_idx], 1); 291 // gf_layer_set_surfaces(didata->layer, &rdata->surface[rdata->surface_visible_idx], 1);
292 292
293 /* Set visible surface when hardware in idle state */ 293 /* Set visible surface when hardware in idle state */
294 // gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE); 294 // gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);
295 295
296 return 0; 296 return 0;
297 } 297 }
298 298
299 static int gf_createtexture(SDL_Renderer* renderer, SDL_Texture* texture) 299 static int
300 { 300 gf_createtexture(SDL_Renderer * renderer, SDL_Texture * texture)
301 SDL_RenderData* renderdata=(SDL_RenderData*)renderer->driverdata; 301 {
302 SDL_Window* window=SDL_GetWindowFromID(renderer->window); 302 SDL_RenderData *renderdata = (SDL_RenderData *) renderer->driverdata;
303 SDL_VideoDisplay* display=SDL_GetDisplayFromWindow(window); 303 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
304 SDL_TextureData* tdata=NULL; 304 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
305 305 SDL_TextureData *tdata = NULL;
306 /* Allocate texture driver data */ 306
307 tdata=(SDL_TextureData*)SDL_calloc(1, sizeof(SDL_TextureData)); 307 /* Allocate texture driver data */
308 if (tdata==NULL) 308 tdata = (SDL_TextureData *) SDL_calloc(1, sizeof(SDL_TextureData));
309 { 309 if (tdata == NULL) {
310 SDL_OutOfMemory(); 310 SDL_OutOfMemory();
311 return -1; 311 return -1;
312 } 312 }
313 313
314 /* Set texture driver data */ 314 /* Set texture driver data */
315 texture->driverdata=tdata; 315 texture->driverdata = tdata;
316 316
317 } 317 }
318 318
319 static int gf_querytexturepixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch) 319 static int
320 { 320 gf_querytexturepixels(SDL_Renderer * renderer, SDL_Texture * texture,
321 } 321 void **pixels, int *pitch)
322 322 {
323 static int gf_settexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color* colors, int firstcolor, int ncolors) 323 }
324 { 324
325 } 325 static int
326 326 gf_settexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,
327 static int gf_gettexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Color* colors, int firstcolor, int ncolors) 327 const SDL_Color * colors, int firstcolor, int ncolors)
328 { 328 {
329 } 329 }
330 330
331 static int gf_settexturecolormod(SDL_Renderer* renderer, SDL_Texture* texture) 331 static int
332 { 332 gf_gettexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,
333 } 333 SDL_Color * colors, int firstcolor, int ncolors)
334 334 {
335 static int gf_settexturealphamod(SDL_Renderer* renderer, SDL_Texture* texture) 335 }
336 { 336
337 } 337 static int
338 338 gf_settexturecolormod(SDL_Renderer * renderer, SDL_Texture * texture)
339 static int gf_settextureblendmode(SDL_Renderer* renderer, SDL_Texture* texture) 339 {
340 { 340 }
341 } 341
342 342 static int
343 static int gf_settexturescalemode(SDL_Renderer* renderer, SDL_Texture* texture) 343 gf_settexturealphamod(SDL_Renderer * renderer, SDL_Texture * texture)
344 { 344 {
345 } 345 }
346 346
347 static int gf_updatetexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch) 347 static int
348 { 348 gf_settextureblendmode(SDL_Renderer * renderer, SDL_Texture * texture)
349 } 349 {
350 350 }
351 static int gf_locktexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int markDirty, void** pixels, int* pitch) 351
352 { 352 static int
353 } 353 gf_settexturescalemode(SDL_Renderer * renderer, SDL_Texture * texture)
354 354 {
355 static void gf_unlocktexture(SDL_Renderer* renderer, SDL_Texture* texture) 355 }
356 { 356
357 } 357 static int
358 358 gf_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,
359 static void gf_dirtytexture(SDL_Renderer* renderer, SDL_Texture* texture, int numrects, const SDL_Rect* rects) 359 const SDL_Rect * rect, const void *pixels, int pitch)
360 { 360 {
361 } 361 }
362 362
363 static int gf_renderpoint(SDL_Renderer* renderer, int x, int y) 363 static int
364 { 364 gf_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,
365 } 365 const SDL_Rect * rect, int markDirty, void **pixels,
366 366 int *pitch)
367 static int gf_renderline(SDL_Renderer* renderer, int x1, int y1, int x2, int y2) 367 {
368 { 368 }
369 } 369
370 370 static void
371 static int gf_renderfill(SDL_Renderer* renderer, const SDL_Rect* rect) 371 gf_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture)
372 { 372 {
373 } 373 }
374 374
375 static int gf_rendercopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srcrect, const SDL_Rect* dstrect) 375 static void
376 { 376 gf_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects,
377 } 377 const SDL_Rect * rects)
378 378 {
379 static void gf_renderpresent(SDL_Renderer* renderer) 379 }
380 { 380
381 } 381 static int
382 382 gf_renderpoint(SDL_Renderer * renderer, int x, int y)
383 static void gf_destroytexture(SDL_Renderer* renderer, SDL_Texture* texture) 383 {
384 { 384 }
385 } 385
386 386 static int
387 static void gf_destroyrenderer(SDL_Renderer* renderer) 387 gf_renderline(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
388 { 388 {
389 SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata; 389 }
390 uint32_t it; 390
391 391 static int
392 for (it=0; it<rdata->surfaces_count; it++) 392 gf_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect)
393 { 393 {
394 if (rdata->surface[it]!=NULL) 394 }
395 { 395
396 gf_surface_free(rdata->surface[it]); 396 static int
397 } 397 gf_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
398 } 398 const SDL_Rect * srcrect, const SDL_Rect * dstrect)
399 {
400 }
401
402 static void
403 gf_renderpresent(SDL_Renderer * renderer)
404 {
405 }
406
407 static void
408 gf_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture)
409 {
410 }
411
412 static void
413 gf_destroyrenderer(SDL_Renderer * renderer)
414 {
415 SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
416 uint32_t it;
417
418 for (it = 0; it < rdata->surfaces_count; it++) {
419 if (rdata->surface[it] != NULL) {
420 gf_surface_free(rdata->surface[it]);
421 }
422 }
399 } 423 }
400 424
401 /* vi: set ts=4 sw=4 expandtab: */ 425 /* vi: set ts=4 sw=4 expandtab: */