Mercurial > sdl-ios-xcode
comparison src/video/qnxgf/SDL_gf_render.c @ 3139:7f684f249ec9
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: */ |