Commit | Line | Data |
---|---|---|
7fd59977 | 1 | /* |
2 | * Fonction | |
3 | * ~~~~~~~~ | |
4 | * Gestion des textures sous OpenGL | |
5 | * | |
6 | * | |
7 | * Notes | |
8 | * ~~~~~ | |
9 | * Les textures sont toujours initialisee avec des parametres par defaut | |
10 | * texture 1D: WRAP_S = CLAMP | |
11 | * MAG_FILTER = NEAREST | |
12 | * generation de texture automatique en OBJECT_LINEAR | |
13 | * rendu avec DECAL | |
14 | * | |
15 | * texture 2D: WRAP_S/T = REPEAT | |
16 | * MAG/MIN_FILTER = LINEAR | |
17 | * generation de texture automatique en OBJECT_LINEAR | |
18 | * rendu avec MODULATE | |
19 | * | |
20 | * texture 2D MipMap: WRAP_S/T = REPEAT | |
21 | * MAG_FILTER = LINEAR | |
22 | * MIN_FILTER = LINEAR_MIPMAP_NEAREST | |
23 | * generation de texture automatique en OBJECT_LINEAR | |
24 | * rendu avec MODULATE | |
25 | * | |
26 | * Remarques: | |
27 | * ~~~~~~~~~~~ | |
28 | * Pour utiliser le binding des textures il faut que les 2 extensions | |
29 | * | |
30 | * o GL_EXT_texture_object: | |
31 | * - glBindTextureEXT, glGenTexturesEXT, glDeleteTexturesEXT | |
32 | * | |
33 | * Attention: | |
34 | * ~~~~~~~~~~~ | |
35 | * Ce package a ete teste sur SGI, OSF, SUN, HP et WNT. | |
36 | * | |
37 | * | |
38 | * Historique des modifications | |
39 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
40 | * 22-05-97: PCT ; Creation | |
41 | * 18-06-97: FMN ; Ajout entete | |
42 | * 20-06-97: PCT ; Correction bug parametres par defaut texture 1D | |
43 | * 30-06-97: PCT ; Correction bug rechargement de la texture courante | |
44 | * 04-07-97: PCT ; suppression de l'utilisation de libimage.a de SGI | |
45 | * 01-08-97: PCT ; suppression InitializeTextureBox() | |
46 | * 04-08-97: FMN,PCT ; Portage WNT | |
47 | * 05-08-97: FMN ; ajout GetTextureData... | |
48 | * 10-09-97: PCT ; ajout commentaires. GetTexture() ne doit pas | |
49 | * etre utilisee dans Cas.Cade ( le chargement est | |
50 | * fait par Graphic3d ) | |
51 | * 06-10-97: FMN ; Portage HP | |
52 | * 14-10-97: FMN ; Ajout OpenGl_Extension | |
53 | * 22-10-97: FMN ; Meilleure gestion de l'extension glXGetCurrentDisplayEXT | |
54 | * 04-11-97: FMN ; Gestion des differentes versions GLX | |
55 | * 19-11-97: FMN ; Ajout GetCurrentDisplay plus simple que glXGetCurrentDisplayEXT | |
56 | * 04-12-97: FMN ; On suppose que l'on travaille en OpenGL1.1 (cf OpenGl_Extension) | |
57 | * 17-12-97: FMN ; Probleme compilation SGI | |
58 | * 17-12-97: FMN ; Probleme sur Optimisation sur MyBindTextureEXT() | |
59 | * Le test sur la texture courante doit tenir compte du contexte. | |
60 | * 22-07-98: FGU ; Ajout fonctions TransferTexture_To_Data() et TransferData_To_Texture() | |
61 | * | |
62 | */ | |
63 | /*----------------------------------------------------------------------*/ | |
64 | ||
65 | #define IMP141100 /*GG_Allocates and free texture block count | |
66 | // correctly | |
67 | */ | |
68 | ||
69 | /*----------------------------------------------------------------------*/ | |
70 | /* | |
71 | * Includes | |
72 | */ | |
73 | ||
74 | #include <stdio.h> | |
75 | #include <stdlib.h> | |
76 | #include <string.h> | |
77 | ||
78 | #include <OpenGl_tgl_all.hxx> | |
79 | #include <OpenGl_txgl.hxx> | |
80 | #include <OpenGl_Extension.hxx> | |
81 | #include <OpenGl_ImageBox.hxx> | |
82 | #include <OpenGl_TextureBox.hxx> | |
83 | #include <OpenGl_Memory.hxx> | |
161c4476 K |
84 | #include <OpenGl_ResourceCleaner.hxx> |
85 | #include <OpenGl_ResourceTexture.hxx> | |
7fd59977 | 86 | |
87 | ||
88 | /*----------------------------------------------------------------------*/ | |
89 | /* | |
90 | * Constantes | |
91 | */ | |
92 | ||
93 | #define XPRINT | |
94 | #define XEXTENSION | |
95 | ||
96 | #define GROW_TEXTURES 8 | |
97 | #define GROW_TEXTURES_DATA 8 | |
98 | #define GROW_CONTEXT 8 | |
99 | ||
100 | #ifdef __sgi | |
101 | #define glGenTextures glGenTexturesEXT | |
102 | #define glDeleteTextures glDeleteTexturesEXT | |
103 | #define glBindTexture glBindTextureEXT | |
104 | #endif /* IRIX */ | |
105 | ||
106 | #ifndef max | |
107 | #define max(a,b) ((a) > (b)) ? (a) : (b); | |
108 | #endif | |
109 | ||
110 | /*----------------------------------------------------------------------*/ | |
111 | /* | |
112 | * Types definis | |
113 | */ | |
114 | ||
115 | typedef enum {TEXDATA_NONE, TEXDATA_1D, TEXDATA_2D, TEXDATA_2DMM} texDataStatus; | |
116 | typedef enum {TEX_NONE, TEX_ALLOCATED} texStatus; | |
117 | ||
118 | typedef GLfloat SizeType[4]; | |
119 | ||
120 | typedef int TextureDataID; | |
121 | #define TEXTUREDATA_ERROR -1 | |
122 | ||
123 | struct texData | |
124 | { | |
125 | char imageFileName[128]; | |
126 | int imageWidth, imageHeight; | |
127 | GLubyte *image; | |
128 | texDataStatus status; | |
129 | GLint type; | |
130 | int share_count; | |
131 | IMPLEMENT_MEMORY_OPERATORS | |
132 | }; | |
133 | ||
134 | ||
135 | struct texDraw | |
136 | { | |
137 | TextureDataID data; | |
138 | GLuint *number; | |
139 | GLDRAWABLE *drawable; | |
140 | GLCONTEXT *context; | |
141 | char *use_bind_texture; | |
142 | int context_count; | |
143 | int context_size; | |
144 | texStatus status; | |
145 | ||
146 | GLint Gen; | |
147 | GLint Light; | |
148 | GLint Wrap; | |
149 | GLfloat Plane1[4]; | |
150 | GLfloat Plane2[4]; | |
151 | GLint Render; | |
152 | GLfloat scalex, scaley; | |
153 | GLfloat transx, transy; | |
154 | GLfloat angle; | |
155 | ||
156 | IMPLEMENT_MEMORY_OPERATORS | |
157 | }; | |
158 | ||
159 | ||
160 | /*----------------------------------------------------------------------*/ | |
161 | /* | |
162 | * Variables statiques | |
163 | */ | |
164 | ||
165 | static texDraw *textab = NULL; | |
166 | static int textures_count = 0; | |
167 | static int textures_size = 0; | |
168 | ||
169 | static texData *texdata = NULL; | |
170 | static int textures_data_count = 0; | |
171 | static int textures_data_size = 0; | |
172 | ||
173 | static TextureDataID current_texture_data = TEXTUREDATA_ERROR; | |
174 | static TextureID current_texture = TEXTUREBOX_ERROR; | |
175 | ||
176 | static GLfloat sgenparams[] = { 1.0 ,0.0 ,0.0 ,0.0}; | |
177 | static GLfloat tgenparams[] = { 0.0 ,1.0 ,0.0 ,0.0}; | |
178 | ||
179 | static GLenum status2type[] = { GL_NONE, GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_2D }; | |
180 | ||
181 | static GLboolean init_extension = GL_FALSE; | |
182 | static GLboolean use_bind_texture = GL_FALSE; | |
183 | ||
184 | /*----------------------------------------------------------------------*/ | |
185 | /* | |
186 | * Fonctions privees | |
187 | */ | |
188 | ||
7fd59977 | 189 | /*----------------------------------------------------------------------*/ |
190 | /* | |
191 | * recherche l'existence de datas de texture par son nom | |
192 | */ | |
193 | static TextureDataID FindTextureData(char *FileName) | |
194 | { | |
195 | int i; | |
196 | ||
197 | for (i=0; i<textures_data_size; i++) | |
198 | if ( texdata[i].status!=TEXDATA_NONE && strcmp(FileName, texdata[i].imageFileName)==0 ) | |
199 | return i; | |
200 | ||
201 | return TEXTUREDATA_ERROR; | |
202 | } | |
203 | ||
204 | /*----------------------------------------------------------------------*/ | |
205 | /* | |
206 | * recherche un emplacement de data texture libre | |
207 | */ | |
208 | static TextureDataID FindFreeTextureData(void) | |
209 | { | |
210 | int i; | |
211 | ||
212 | /* ya encore de la place ? */ | |
213 | if (textures_data_count == textures_data_size) | |
214 | { | |
215 | textures_data_size += GROW_TEXTURES_DATA; | |
216 | #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530) | |
217 | texdata = (texData*)realloc(texdata, textures_data_size*sizeof(texData)); | |
218 | #else | |
219 | texdata = cmn_resizemem<texData>(texdata, textures_data_size); | |
220 | #endif | |
221 | if (texdata == NULL) return TEXTUREDATA_ERROR; | |
222 | ||
223 | for (i=textures_data_count; i<textures_data_size; i++) | |
224 | texdata[i].status = TEXDATA_NONE; | |
225 | ||
226 | /* on a deja assez perdu de temps comme ca => retourne un ID rapidement... */ | |
227 | return textures_data_count++; | |
228 | } | |
229 | ||
230 | /* recherche d'un ID libre */ | |
231 | for (i=0; i<textures_data_size; i++) | |
232 | if (texdata[i].status == TEXDATA_NONE) | |
233 | { | |
234 | #ifndef IMP141100 | |
235 | textures_data_count++; | |
236 | #else | |
237 | textures_data_count = max(textures_data_count,i+1); | |
238 | #endif | |
239 | return i; | |
240 | } | |
241 | ||
242 | return TEXTUREDATA_ERROR; | |
243 | } | |
244 | ||
245 | /*----------------------------------------------------------------------*/ | |
246 | /* | |
247 | * recherche un emplacement de texture libre | |
248 | */ | |
249 | static TextureID FindFreeTexture(void) | |
250 | { | |
251 | int i; | |
252 | ||
253 | /* ya encore de la place ? */ | |
254 | if (textures_count == textures_size) | |
255 | { | |
256 | textures_size += GROW_TEXTURES; | |
257 | #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530) | |
258 | textab = (texDraw*)realloc(textab, textures_size*sizeof(texDraw)); | |
259 | #else | |
260 | textab = cmn_resizemem<texDraw>(textab, textures_size); | |
261 | #endif | |
262 | if (textab == NULL) return TEXTUREBOX_ERROR; | |
263 | ||
264 | for (i=textures_count; i<textures_size; i++) | |
265 | textab[i].status = TEX_NONE; | |
266 | ||
267 | /* on a deja assez perdu de temps comme ca => retourne un ID rapidement... */ | |
268 | return textures_count++; | |
269 | } | |
270 | ||
271 | for (i=0; i<textures_size; i++) | |
272 | if (textab[i].status == TEX_NONE) | |
273 | { | |
274 | #ifndef IMP141100 | |
275 | textures_count++; | |
276 | #else | |
277 | textures_count = max(textures_count,i+1); | |
278 | #endif | |
279 | return i; | |
280 | } | |
281 | ||
282 | return TEXTUREBOX_ERROR; | |
283 | } | |
284 | ||
285 | /*----------------------------------------------------------------------*/ | |
286 | /* | |
287 | * regarde si la texture a ete definie pour le contexte courant | |
288 | */ | |
289 | static int FindTextureContext(TextureID ID) | |
290 | { | |
291 | int i; | |
292 | ||
293 | GLCONTEXT cur = GET_GL_CONTEXT(); | |
294 | for (i=0; i<textab[ID].context_count; i++) | |
295 | if (textab[ID].context[i] == cur) | |
296 | return i; | |
297 | ||
298 | return TEXTUREBOX_ERROR; | |
299 | } | |
300 | ||
301 | /*----------------------------------------------------------------------*/ | |
302 | /* | |
303 | * chargement d'une texture suivant son type | |
304 | */ | |
305 | static void LoadTexture(TextureID ID) | |
306 | { | |
307 | TextureDataID data; | |
308 | ||
309 | data = textab[ID].data; | |
310 | switch (texdata[data].status) | |
311 | { | |
312 | case TEXDATA_1D: | |
313 | glTexImage1D(GL_TEXTURE_1D, 0, 4, | |
314 | texdata[data].imageWidth, 0, | |
315 | GL_RGBA, GL_UNSIGNED_BYTE, texdata[data].image); | |
316 | break; | |
317 | ||
318 | case TEXDATA_2D: | |
319 | glTexImage2D(GL_TEXTURE_2D, 0, 4, | |
320 | texdata[data].imageWidth, texdata[data].imageHeight, 0, | |
321 | GL_RGBA, GL_UNSIGNED_BYTE, texdata[data].image); | |
322 | break; | |
323 | ||
324 | case TEXDATA_2DMM: | |
325 | gluBuild2DMipmaps(GL_TEXTURE_2D, 4, | |
326 | texdata[data].imageWidth, | |
327 | texdata[data].imageHeight, | |
328 | GL_RGBA, GL_UNSIGNED_BYTE, texdata[data].image); | |
329 | break; | |
330 | default: | |
331 | break; | |
332 | } | |
333 | } | |
334 | ||
335 | /*----------------------------------------------------------------------*/ | |
336 | /* | |
337 | * les parametres d'initialisation d'une texture | |
338 | * NE PAS METTRE DANS UNE DISPLAY LIST POUR L'INSTANT ( pb avec les matrices ) | |
339 | */ | |
340 | static void SetTextureParam(TextureID ID) | |
341 | { | |
342 | GLint cur_matrix; | |
343 | TextureDataID data; | |
344 | ||
345 | ||
346 | data = textab[ID].data; | |
347 | glGetIntegerv(GL_MATRIX_MODE, &cur_matrix); | |
348 | ||
349 | /* | |
350 | * MISE EN PLACE DE LA MATRICE DE TEXTURE | |
351 | */ | |
352 | glMatrixMode(GL_TEXTURE); | |
353 | glLoadIdentity(); | |
354 | /* if (textab[ID].Gen != GL_SPHERE_MAP) | |
355 | {*/ | |
356 | glScalef(textab[ID].scalex, textab[ID].scaley, 1.0); | |
357 | glTranslatef(-textab[ID].transx, -textab[ID].transy, 0.0); | |
358 | glRotatef(-textab[ID].angle, 0.0, 0.0, 1.0); | |
359 | /*}*/ | |
360 | ||
361 | ||
362 | /* | |
363 | * GENERATION AUTOMATIQUE DE TEXTURE | |
364 | */ | |
365 | switch (textab[ID].Gen) | |
366 | { | |
367 | case GL_OBJECT_LINEAR: | |
368 | glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); | |
369 | glTexGenfv(GL_S, GL_OBJECT_PLANE, textab[ID].Plane1); | |
370 | if (texdata[data].status != TEXDATA_1D) | |
371 | { | |
372 | glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); | |
373 | glTexGenfv(GL_T, GL_OBJECT_PLANE, textab[ID].Plane2); | |
374 | } | |
375 | break; | |
376 | ||
377 | case GL_SPHERE_MAP: | |
378 | glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); | |
379 | if (texdata[data].status != TEXDATA_1D) | |
380 | glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); | |
381 | break; | |
382 | ||
383 | case GL_EYE_LINEAR: | |
384 | glMatrixMode(GL_MODELVIEW); | |
385 | glPushMatrix(); | |
386 | glLoadIdentity(); | |
387 | ||
388 | glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); | |
389 | glTexGenfv(GL_S, GL_EYE_PLANE, textab[ID].Plane1); | |
390 | ||
391 | if (texdata[data].status != TEXDATA_1D) | |
392 | { | |
393 | glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); | |
394 | glTexGenfv(GL_T, GL_EYE_PLANE, textab[ID].Plane2); | |
395 | } | |
396 | ||
397 | glPopMatrix(); | |
398 | break; | |
399 | } | |
400 | ||
401 | ||
402 | /* | |
403 | * RENDU DE LA TEXTURE AVEC LES LUMIERES | |
404 | */ | |
405 | glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, textab[ID].Light); | |
406 | ||
407 | ||
408 | /* | |
409 | * LISSAGE DE LA TEXTURE | |
410 | */ | |
411 | switch (texdata[data].status) | |
412 | { | |
413 | case TEXDATA_1D: | |
414 | case TEXDATA_2D: | |
415 | glTexParameteri(texdata[data].type, GL_TEXTURE_MAG_FILTER, textab[ID].Render); | |
416 | glTexParameteri(texdata[data].type, GL_TEXTURE_MIN_FILTER, textab[ID].Render); | |
417 | break; | |
418 | ||
419 | case TEXDATA_2DMM: | |
420 | if (textab[ID].Render == GL_NEAREST) | |
421 | { | |
422 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | |
423 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); | |
424 | } | |
425 | else | |
426 | { | |
427 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); | |
428 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); | |
429 | } | |
430 | break; | |
431 | default: | |
432 | break; | |
433 | } | |
434 | ||
435 | ||
436 | /* | |
437 | * WRAP DE LA TEXTURE | |
438 | */ | |
439 | switch (texdata[data].status) | |
440 | { | |
441 | case TEXDATA_1D: | |
442 | glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, textab[ID].Wrap); | |
443 | break; | |
444 | ||
445 | case TEXDATA_2D: | |
446 | case TEXDATA_2DMM: | |
447 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, textab[ID].Wrap); | |
448 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, textab[ID].Wrap); | |
449 | break; | |
450 | default: | |
451 | break; | |
452 | } | |
453 | ||
454 | glMatrixMode(cur_matrix); | |
455 | } | |
456 | ||
457 | /*----------------------------------------------------------------------*/ | |
458 | /* | |
459 | * simulation du glGenTexturesEXT pour un context | |
460 | */ | |
461 | static void MyGenTextureEXT(TextureID ID) | |
462 | { | |
463 | #if defined(GL_EXT_texture_object) | |
464 | ||
465 | int Context; | |
466 | TextureDataID data; | |
467 | ||
468 | Context = textab[ID].context_count; | |
469 | data = textab[ID].data; | |
470 | ||
471 | if (!init_extension) | |
472 | { | |
473 | use_bind_texture = QueryExtension("GL_EXT_texture_object"); | |
474 | ||
475 | init_extension = GL_TRUE; | |
476 | #ifdef EXTENSION | |
477 | printf("GL_EXT_texture_object %d\n", use_bind_texture); | |
478 | #endif | |
479 | } | |
480 | ||
481 | if (use_bind_texture) | |
482 | { | |
483 | #ifdef PRINT | |
484 | printf("MyGenTextureEXT::gen texture\n"); | |
485 | #endif | |
486 | ||
487 | textab[ID].context[Context] = GET_GL_CONTEXT(); | |
488 | textab[ID].drawable[Context] = GET_GLDEV_CONTEXT(); | |
489 | textab[ID].use_bind_texture[Context] = (char)use_bind_texture; | |
490 | glGenTextures(1, &textab[ID].number[Context]); | |
491 | glBindTexture(texdata[data].type, textab[ID].number[Context]); | |
492 | LoadTexture(ID); | |
493 | textab[ID].context_count++; | |
494 | } | |
495 | else | |
496 | #endif /* GL_EXT_texture_object */ | |
497 | if (current_texture_data != textab[ID].data) | |
498 | LoadTexture(ID); | |
499 | } | |
500 | ||
501 | /*----------------------------------------------------------------------*/ | |
502 | /* | |
503 | * simulation du glBindTextureEXT | |
504 | */ | |
505 | static void MyBindTextureEXT(TextureID ID, int Context) | |
506 | { | |
507 | /* si l'extension est presente, c'est facile */ | |
508 | #if defined(GL_EXT_texture_object) | |
509 | TextureDataID data; | |
510 | data = textab[ID].data; | |
511 | ||
512 | if (textab[ID].status == TEXDATA_NONE) | |
513 | return; | |
514 | ||
515 | #ifdef PRINT | |
516 | printf("MyBindTextureEXT::ID %d data %d context %d Current %d\n", ID, textab[ID].data, Context, current_texture_data); | |
517 | #endif | |
518 | ||
519 | if (textab[ID].use_bind_texture[Context]) | |
520 | { | |
521 | /* OCC11904 - make sure that the correct texture is bound before drawing */ | |
522 | GLenum aParamName = textab[ID].status == TEXDATA_1D ? | |
523 | GL_TEXTURE_BINDING_1D : GL_TEXTURE_BINDING_2D; | |
524 | GLint aCurrTex = -1; | |
525 | glGetIntegerv( aParamName, &aCurrTex ); | |
526 | if ( textab[ID].number[Context] != aCurrTex ) | |
527 | { | |
528 | #ifdef PRINT | |
529 | printf("MyBindTextureEXT::bind texture\n"); | |
530 | #endif | |
531 | glBindTexture( texdata[data].type, textab[ID].number[Context] ); | |
532 | } | |
533 | } | |
534 | /* sinon on reset tout */ | |
535 | else | |
536 | #endif /* GL_EXT_texture_object */ | |
537 | { | |
538 | /* OCC11904 - make sure that the correct texture is bound before drawing */ | |
539 | GLenum aParamName = textab[ID].status == TEXDATA_1D ? | |
540 | GL_TEXTURE_BINDING_1D : GL_TEXTURE_BINDING_2D; | |
541 | GLint aCurrTex = -1; | |
542 | glGetIntegerv( aParamName, &aCurrTex ); | |
543 | if ( textab[ID].number[Context] != aCurrTex ) | |
544 | { | |
545 | #ifdef PRINT | |
546 | printf("MyBindTextureEXT::chargement sans bind de la texture\n"); | |
547 | #endif | |
548 | LoadTexture(ID); | |
549 | } | |
550 | } | |
551 | } | |
552 | ||
553 | /*----------------------------------------------------------------------*/ | |
554 | /* | |
555 | * installation de la texture pour le dernier contexte | |
556 | */ | |
557 | static int InstallTextureInContext(TextureID ID) | |
558 | { | |
559 | #ifdef PRINT | |
560 | printf("InstallTextureInContext::installation de la texture dans le context\n"); | |
561 | #endif | |
562 | ||
563 | ||
564 | /* ya encore de la place dans le tableau de context ? */ | |
565 | if (textab[ID].context_count == textab[ID].context_size) | |
566 | { | |
567 | #ifdef PRINT | |
568 | printf("InstallTextureInContext::allocation dans le context\n"); | |
569 | #endif | |
570 | textab[ID].context_size += GROW_CONTEXT; | |
571 | #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530) | |
572 | textab[ID].number = | |
573 | (GLuint*)realloc(textab[ID].number, textab[ID].context_size*sizeof(GLuint)); | |
574 | textab[ID].context = | |
575 | (GLCONTEXT*)realloc(textab[ID].context, textab[ID].context_size*sizeof(GLCONTEXT)); | |
576 | textab[ID].drawable = | |
577 | (GLDRAWABLE*)realloc(textab[ID].drawable, textab[ID].context_size*sizeof(GLDRAWABLE)); | |
578 | textab[ID].use_bind_texture = | |
579 | (char*)realloc(textab[ID].use_bind_texture, textab[ID].context_size); | |
580 | #else | |
581 | textab[ID].number = | |
582 | cmn_resizemem<GLuint>(textab[ID].number, textab[ID].context_size); | |
583 | textab[ID].context = | |
584 | cmn_resizemem<GLCONTEXT>(textab[ID].context, textab[ID].context_size); | |
585 | textab[ID].drawable = | |
586 | cmn_resizemem<GLDRAWABLE>(textab[ID].drawable, textab[ID].context_size); | |
587 | textab[ID].use_bind_texture = | |
588 | cmn_resizemem<char>(textab[ID].use_bind_texture, textab[ID].context_size); | |
589 | #endif | |
590 | if ( (textab[ID].number == NULL) || | |
591 | (textab[ID].context == NULL) || | |
592 | (textab[ID].drawable == NULL) || | |
593 | (textab[ID].use_bind_texture == NULL) ) | |
594 | { | |
595 | /* erreur => libere tout */ | |
596 | free(textab[ID].number); | |
597 | free(textab[ID].context); | |
598 | free(textab[ID].drawable); | |
599 | free(textab[ID].use_bind_texture); | |
600 | textab[ID].context_size = 0; | |
601 | ||
602 | return TEXTUREBOX_ERROR; | |
603 | } | |
604 | } | |
605 | ||
606 | MyGenTextureEXT(ID); | |
607 | SetTextureParam(ID); | |
608 | #ifdef PRINT | |
609 | printf("InstallTextureInContext::context ok\n"); | |
610 | #endif | |
611 | return 0; | |
612 | } | |
613 | ||
614 | /*----------------------------------------------------------------------*/ | |
615 | static TextureID GetTexture(char *FileName, texDataStatus status) | |
616 | { | |
617 | TextureDataID i; | |
618 | TextureID j; | |
619 | int dummy; | |
620 | ||
621 | /* essait de trouver la texture */ | |
622 | i = FindTextureData(FileName); | |
623 | if (i == TEXTUREDATA_ERROR) | |
624 | { | |
625 | #ifdef PRINT | |
626 | printf("GetTexture::la texture %s n'existe pas => chargement\n", FileName); | |
627 | #endif | |
628 | /* creation d'une texture */ | |
629 | i = FindFreeTextureData(); | |
630 | if (i == TEXTUREDATA_ERROR) return TEXTUREBOX_ERROR; | |
631 | ||
632 | texdata[i].share_count = 0; | |
633 | strcpy(texdata[i].imageFileName, FileName); | |
634 | texdata[i].image = (GLubyte *)read_texture(FileName, | |
635 | &texdata[i].imageWidth, | |
636 | &texdata[i].imageHeight, | |
637 | &dummy); | |
638 | if (texdata[i].image == NULL) return TEXTUREBOX_ERROR; | |
639 | ||
640 | texdata[i].status = status; | |
641 | texdata[i].type = status2type[status]; | |
642 | } | |
643 | ||
644 | j = FindFreeTexture(); | |
645 | if (j != TEXTUREBOX_ERROR) | |
646 | { | |
647 | #ifdef PRINT | |
648 | printf("GetTexture::installation texture pour obj %d\n", j); | |
649 | #endif | |
650 | textab[j].context_count = 0; | |
651 | textab[j].context_size = 0; | |
652 | textab[j].number = NULL; | |
653 | textab[j].drawable = NULL; | |
654 | textab[j].context = NULL; | |
655 | textab[j].use_bind_texture = NULL; | |
656 | textab[j].data = i; | |
657 | textab[j].status = TEX_ALLOCATED; | |
658 | texdata[i].share_count++; | |
659 | ||
660 | SetTextureDefaultParams(j); | |
661 | ||
662 | #ifdef PRINT | |
663 | printf("GetTexture::texture %s(%d) texture %d count=%d\n", texdata[i].imageFileName, i, j, texdata[i].share_count); | |
664 | #endif | |
665 | } | |
666 | else | |
667 | if (texdata[i].share_count != 0) | |
668 | free(texdata[i].image); | |
669 | ||
670 | return j; | |
671 | } | |
672 | ||
673 | ||
674 | /*----------------------------------------------------------------------*/ | |
675 | static TextureID GetTextureData(char *FileName, texDataStatus status, const GLint width, const GLint height, const void *data) | |
676 | { | |
677 | TextureDataID i; | |
678 | TextureID j; | |
679 | ||
680 | /* essait de trouver la texture */ | |
681 | i = FindTextureData(FileName); | |
682 | if (i == TEXTUREDATA_ERROR) | |
683 | { | |
684 | #ifdef PRINT | |
685 | printf("GetTextureData::la texture %s n'existe pas => chargement\n", FileName); | |
686 | #endif | |
687 | /* creation d'une texture */ | |
688 | i = FindFreeTextureData(); | |
689 | if (i == TEXTUREDATA_ERROR) return TEXTUREBOX_ERROR; | |
690 | ||
691 | texdata[i].share_count = 0; | |
692 | strcpy(texdata[i].imageFileName, FileName); | |
693 | texdata[i].image = (GLubyte *)malloc(width*height*4*sizeof(GLubyte)); | |
694 | memcpy(texdata[i].image, data, (width*height*4)); | |
695 | texdata[i].imageWidth = width; | |
696 | texdata[i].imageHeight = height; | |
697 | ||
698 | if (texdata[i].image == NULL) return TEXTUREBOX_ERROR; | |
699 | ||
700 | texdata[i].status = status; | |
701 | texdata[i].type = status2type[status]; | |
702 | } | |
703 | ||
704 | j = FindFreeTexture(); | |
705 | if (j != TEXTUREBOX_ERROR) | |
706 | { | |
707 | #ifdef PRINT | |
708 | printf("GetTextureData::installation texture pour obj %d\n", j); | |
709 | #endif | |
710 | textab[j].context_count = 0; | |
711 | textab[j].context_size = 0; | |
712 | textab[j].number = NULL; | |
713 | textab[j].drawable = NULL; | |
714 | textab[j].context = NULL; | |
715 | textab[j].use_bind_texture = NULL; | |
716 | textab[j].data = i; | |
717 | textab[j].status = TEX_ALLOCATED; | |
718 | texdata[i].share_count++; | |
719 | ||
720 | SetTextureDefaultParams(j); | |
721 | ||
722 | #ifdef PRINT | |
723 | printf("GetTextureData::texture %s(%d) texture %d count=%d\n", texdata[i].imageFileName, i, j, texdata[i].share_count); | |
724 | #endif | |
725 | } | |
726 | else | |
727 | if (texdata[i].share_count != 0) | |
728 | free(texdata[i].image); | |
729 | ||
730 | return j; | |
731 | } | |
732 | ||
733 | /*----------------------------------------------------------------------*/ | |
734 | /* | |
735 | * Fonctions publiques | |
736 | */ | |
737 | ||
738 | ||
739 | /*----------------------------------------------------------------------*/ | |
740 | ||
741 | GLboolean IsTextureValid(TextureID ID) | |
742 | { | |
743 | if ((ID<0) | (ID>=textures_count)) | |
744 | return GL_FALSE; | |
745 | ||
746 | if (textab) | |
747 | return textab[ID].status == TEX_ALLOCATED; | |
748 | else | |
749 | return GL_TRUE; | |
750 | } | |
751 | ||
752 | /*----------------------------------------------------------------------*/ | |
753 | ||
754 | TextureID GetTexture1D(char *FileName) | |
755 | { | |
756 | #ifdef PRINT | |
757 | printf("GetTexture1D::loading 1d %s \n", FileName); | |
758 | #endif | |
759 | return GetTexture(FileName, TEXDATA_1D); | |
760 | } | |
761 | ||
762 | /*----------------------------------------------------------------------*/ | |
763 | ||
764 | TextureID GetTexture2D(char *FileName) | |
765 | { | |
766 | #ifdef PRINT | |
767 | printf("GetTexture2D::loading 2d %s \n", FileName); | |
768 | #endif | |
769 | return GetTexture(FileName, TEXDATA_2D); | |
770 | } | |
771 | ||
772 | /*----------------------------------------------------------------------*/ | |
773 | ||
774 | TextureID GetTexture2DMipMap(char *FileName) | |
775 | { | |
776 | #ifdef PRINT | |
777 | printf("GetTexture2DMipMap::loading 2dmm %s \n", FileName); | |
778 | #endif | |
779 | return GetTexture(FileName, TEXDATA_2DMM); | |
780 | } | |
781 | ||
782 | /*----------------------------------------------------------------------*/ | |
783 | ||
784 | TextureID GetTextureData1D(char *FileName, const GLint width, const GLint height, const void *data) | |
785 | { | |
786 | #ifdef PRINT | |
787 | printf("GetTextureData1D::loading 1d %s \n", FileName); | |
788 | #endif | |
789 | return GetTextureData(FileName, TEXDATA_1D, width, height, data); | |
790 | } | |
791 | ||
792 | /*----------------------------------------------------------------------*/ | |
793 | ||
794 | TextureID GetTextureData2D(char *FileName, const GLint width, const GLint height, const void *data) | |
795 | { | |
796 | #ifdef PRINT | |
797 | printf("GetTextureData2D::loading 2d %s \n", FileName); | |
798 | #endif | |
799 | return GetTextureData(FileName, TEXDATA_2D, width, height, data); | |
800 | } | |
801 | ||
802 | /*----------------------------------------------------------------------*/ | |
803 | ||
804 | TextureID GetTextureData2DMipMap(char *FileName, const GLint width, const GLint height, const void *data) | |
805 | { | |
806 | #ifdef PRINT | |
807 | printf("GetTextureData2DMipMap::loading 2dmm %s \n", FileName); | |
808 | #endif | |
809 | return GetTextureData(FileName, TEXDATA_2DMM, width, height, data); | |
810 | } | |
811 | ||
812 | ||
813 | /*----------------------------------------------------------------------*/ | |
814 | ||
815 | void SetCurrentTexture(TextureID ID) | |
816 | { | |
817 | int context; | |
818 | ||
819 | if (!IsTextureValid(ID)) return; | |
820 | ||
821 | context = FindTextureContext(ID); | |
822 | ||
823 | /* la texture n'existe pas dans ce contexte */ | |
824 | if (context == TEXTUREBOX_ERROR) | |
825 | { | |
826 | #ifdef PRINT | |
827 | printf("SetCurrentTexture::installation texture %d dans context\n", ID); | |
828 | #endif | |
829 | /* si on a une erreur pendant l'installation dans le context | |
830 | * alors on installe la texture sans bind */ | |
831 | if (InstallTextureInContext(ID) == TEXTUREBOX_ERROR) | |
832 | { | |
833 | LoadTexture(ID); | |
834 | SetTextureParam(ID); | |
835 | } | |
836 | } | |
837 | ||
838 | /*oui, alors on bind directement */ | |
839 | else | |
840 | { | |
841 | #ifdef PRINT | |
842 | printf("SetCurrentTexture: utilisation du bind %d\n", ID); | |
843 | #endif | |
844 | MyBindTextureEXT(ID, context); | |
845 | SetTextureParam(ID); | |
846 | } | |
847 | ||
848 | current_texture = ID; | |
849 | current_texture_data = textab[ID].data; | |
850 | } | |
851 | ||
852 | /*----------------------------------------------------------------------*/ | |
853 | ||
854 | void FreeTexture(TextureID ID) | |
855 | { | |
856 | TextureDataID data; | |
161c4476 | 857 | bool notResource = false; // if there old-style texture deletion |
7fd59977 | 858 | |
859 | #if defined(GL_EXT_texture_object) | |
860 | GLCONTEXT cur_context; | |
861 | GLDRAWABLE cur_drawable; | |
862 | int i; | |
863 | #endif /* GL_EXT_texture_object */ | |
864 | ||
865 | if (!IsTextureValid(ID)) return; | |
866 | ||
867 | data = textab[ID].data; | |
868 | texdata[data].share_count--; | |
869 | if (texdata[data].share_count == 0) | |
870 | { | |
871 | /* liberation des datas de la textures */ | |
872 | free(texdata[data].image); | |
873 | ||
874 | #if defined(GL_EXT_texture_object) | |
875 | if(use_bind_texture) | |
876 | { | |
877 | /* liberation de la texture dans tous les contextes */ | |
878 | cur_drawable = GET_GLDEV_CONTEXT(); | |
879 | for (i=0; i<textab[ID].context_count; i++) | |
880 | { | |
881 | #ifdef PRINT | |
882 | printf("FreeTexture::liberation de %d\n", ID); | |
883 | #endif | |
884 | cur_context = 0; | |
161c4476 K |
885 | bool isResource = false; |
886 | ||
7fd59977 | 887 | if (textab[ID].use_bind_texture[i]) |
888 | { | |
161c4476 K |
889 | if( !OpenGl_ResourceCleaner::GetInstance()->AddResource(textab[ID].context[i], |
890 | new OpenGl_ResourceTexture(textab[ID].number[i])) ) | |
891 | { | |
892 | GL_MAKE_CURRENT(GetCurrentDisplay(), | |
893 | textab[ID].drawable[i], | |
894 | textab[ID].context[i]); | |
895 | ||
896 | /*This check has been added to avoid exception, | |
897 | which is raised when trying to delete textures when no rendering context | |
898 | is available*/ | |
899 | cur_context = GET_GL_CONTEXT(); | |
900 | if( cur_context ) | |
901 | glDeleteTextures(1, &textab[ID].number[i]); | |
902 | notResource = true; | |
903 | } | |
904 | else | |
905 | isResource = true; | |
7fd59977 | 906 | } |
161c4476 K |
907 | |
908 | if( !isResource && cur_context ) | |
7fd59977 | 909 | glFinish(); |
910 | } | |
911 | ||
161c4476 K |
912 | if( notResource ) |
913 | GL_MAKE_CURRENT(GetCurrentDisplay(),cur_drawable,cur_context); | |
7fd59977 | 914 | |
915 | texdata[data].status = TEXDATA_NONE; | |
916 | #ifndef IMP141100 | |
917 | textures_data_count--; | |
918 | #else | |
919 | if( data+1 == textures_data_count ) textures_data_count--; | |
920 | #endif | |
921 | free(textab[ID].context); | |
922 | free(textab[ID].drawable); | |
923 | free(textab[ID].use_bind_texture); | |
924 | free(textab[ID].number); | |
925 | ||
926 | } /* use_bind_texture */ | |
927 | #endif /* GL_EXT_texture_object */ | |
928 | } | |
929 | ||
930 | textab[ID].status = TEX_NONE; | |
931 | #ifndef IMP141100 | |
932 | textures_count--; | |
933 | #else | |
934 | if( ID+1 == textures_count ) textures_count--; | |
935 | #endif | |
936 | ||
937 | current_texture_data = TEXTUREDATA_ERROR; | |
938 | } | |
939 | ||
940 | /*----------------------------------------------------------------------*/ | |
941 | ||
942 | void EnableTexture(void) | |
943 | { | |
944 | if (!IsTextureValid(current_texture)) return; | |
945 | ||
946 | switch (texdata[current_texture_data].status) | |
947 | { | |
948 | case TEXDATA_1D: | |
949 | if (textab[current_texture].Gen != GL_NONE) | |
950 | glEnable(GL_TEXTURE_GEN_S); | |
951 | glEnable(GL_TEXTURE_1D); | |
952 | break; | |
953 | ||
954 | case TEXDATA_2D: | |
955 | case TEXDATA_2DMM: | |
956 | if (textab[current_texture].Gen != GL_NONE) | |
957 | { | |
958 | glEnable(GL_TEXTURE_GEN_S); | |
959 | glEnable(GL_TEXTURE_GEN_T); | |
960 | } | |
961 | glEnable(GL_TEXTURE_2D); | |
962 | break; | |
963 | default: | |
964 | break; | |
965 | } | |
966 | } | |
967 | ||
968 | /*----------------------------------------------------------------------*/ | |
969 | ||
970 | void DisableTexture(void) | |
971 | { | |
972 | if ( !IsTextureEnabled() ) | |
973 | return; | |
974 | if ( !IsTextureValid( current_texture ) ) | |
975 | return; | |
976 | ||
977 | switch (texdata[current_texture_data].status) | |
978 | { | |
979 | case TEXDATA_1D: | |
980 | if (textab[current_texture].Gen != GL_NONE) | |
981 | glDisable(GL_TEXTURE_GEN_S); | |
982 | glDisable(GL_TEXTURE_1D); | |
983 | break; | |
984 | ||
985 | case TEXDATA_2D: | |
986 | case TEXDATA_2DMM: | |
987 | if (textab[current_texture].Gen != GL_NONE) | |
988 | { | |
989 | glDisable(GL_TEXTURE_GEN_S); | |
990 | glDisable(GL_TEXTURE_GEN_T); | |
991 | } | |
992 | glDisable(GL_TEXTURE_2D); | |
993 | break; | |
994 | default: | |
995 | break; | |
996 | } | |
997 | } | |
998 | ||
999 | /*----------------------------------------------------------------------*/ | |
1000 | ||
1001 | GLboolean IsTextureEnabled(void) | |
1002 | { | |
1003 | GLboolean isEnabled1D= GL_FALSE, isEnabled2D= GL_FALSE; | |
1004 | glGetBooleanv( GL_TEXTURE_1D, &isEnabled1D ); | |
1005 | glGetBooleanv( GL_TEXTURE_2D, &isEnabled2D ); | |
1006 | return isEnabled1D || isEnabled2D; | |
1007 | } | |
1008 | ||
1009 | /*----------------------------------------------------------------------*/ | |
1010 | ||
1011 | void SetTextureModulate(TextureID ID) | |
1012 | { | |
1013 | if (!IsTextureValid(ID)) return; | |
1014 | ||
1015 | textab[ID].Light = GL_MODULATE; | |
1016 | } | |
1017 | ||
1018 | /*----------------------------------------------------------------------*/ | |
1019 | ||
1020 | void SetTextureDecal(TextureID ID) | |
1021 | { | |
1022 | if (!IsTextureValid(ID)) return; | |
1023 | ||
1024 | textab[ID].Light = GL_DECAL; | |
1025 | } | |
1026 | ||
1027 | /*----------------------------------------------------------------------*/ | |
1028 | ||
1029 | void SetTextureClamp(TextureID ID) | |
1030 | { | |
1031 | if (!IsTextureValid(ID)) return; | |
1032 | ||
1033 | textab[ID].Wrap = GL_CLAMP; | |
1034 | } | |
1035 | ||
1036 | /*----------------------------------------------------------------------*/ | |
1037 | ||
1038 | void SetTextureRepeat(TextureID ID) | |
1039 | { | |
1040 | if (!IsTextureValid(ID)) return; | |
1041 | ||
1042 | textab[ID].Wrap = GL_REPEAT; | |
1043 | } | |
1044 | ||
1045 | /*----------------------------------------------------------------------*/ | |
1046 | ||
1047 | /* gestion de la facon d'appliquer la texture */ | |
1048 | void SetModeObject(TextureID ID, GLfloat sparams[4], GLfloat tparams[4]) | |
1049 | { | |
1050 | if (!IsTextureValid(ID)) return; | |
1051 | ||
1052 | textab[ID].Gen = GL_OBJECT_LINEAR; | |
1053 | if (sparams != NULL) memcpy(textab[ID].Plane1, sparams, sizeof(sgenparams)); | |
1054 | else memcpy(textab[ID].Plane1, sgenparams, sizeof(sgenparams)); | |
1055 | ||
1056 | if (texdata[textab[ID].data].status != TEXDATA_1D) { | |
1057 | if (tparams != NULL) memcpy(textab[ID].Plane2, tparams, sizeof(tgenparams)); | |
1058 | else memcpy(textab[ID].Plane2, tgenparams, sizeof(tgenparams)); | |
1059 | } | |
1060 | } | |
1061 | ||
1062 | /*----------------------------------------------------------------------*/ | |
1063 | ||
1064 | void SetModeSphere(TextureID ID) | |
1065 | { | |
1066 | if (!IsTextureValid(ID)) return; | |
1067 | ||
1068 | textab[ID].Gen = GL_SPHERE_MAP; | |
1069 | } | |
1070 | ||
1071 | /*----------------------------------------------------------------------*/ | |
1072 | ||
1073 | void SetModeEye(TextureID ID, GLfloat sparams[4], GLfloat tparams[4]) | |
1074 | { | |
1075 | if (!IsTextureValid(ID)) return; | |
1076 | ||
1077 | textab[ID].Gen = GL_EYE_LINEAR; | |
1078 | if (sparams != NULL) memcpy(textab[ID].Plane1, sparams, sizeof(sgenparams)); | |
1079 | else memcpy(textab[ID].Plane1, sgenparams, sizeof(sgenparams)); | |
1080 | ||
1081 | if (texdata[textab[ID].data].status != TEXDATA_1D) { | |
1082 | if (tparams != NULL) memcpy(textab[ID].Plane2, tparams, sizeof(tgenparams)); | |
1083 | else memcpy(textab[ID].Plane2, tgenparams, sizeof(tgenparams)); | |
1084 | } | |
1085 | } | |
1086 | ||
1087 | /*----------------------------------------------------------------------*/ | |
1088 | ||
1089 | void SetModeManual(TextureID ID) | |
1090 | { | |
1091 | if (!IsTextureValid(ID)) return; | |
1092 | ||
1093 | textab[ID].Gen = GL_NONE; | |
1094 | } | |
1095 | ||
1096 | /*----------------------------------------------------------------------*/ | |
1097 | ||
1098 | void SetRenderNearest(TextureID ID) | |
1099 | { | |
1100 | if (!IsTextureValid(ID)) return; | |
1101 | ||
1102 | textab[ID].Render = GL_NEAREST; | |
1103 | } | |
1104 | ||
1105 | /*----------------------------------------------------------------------*/ | |
1106 | ||
1107 | void SetRenderLinear(TextureID ID) | |
1108 | { | |
1109 | if (!IsTextureValid(ID)) return; | |
1110 | ||
1111 | textab[ID].Render = GL_LINEAR; | |
1112 | } | |
1113 | ||
1114 | /*----------------------------------------------------------------------*/ | |
1115 | ||
1116 | void SetTexturePosition(TextureID ID, | |
1117 | GLfloat scalex, GLfloat scaley, | |
1118 | GLfloat transx, GLfloat transy, | |
1119 | GLfloat angle) | |
1120 | { | |
1121 | textab[ID].scalex = scalex; | |
1122 | textab[ID].scaley = scaley; | |
1123 | textab[ID].transx = transx; | |
1124 | textab[ID].transy = transy; | |
1125 | textab[ID].angle = angle; | |
1126 | } | |
1127 | ||
1128 | /*----------------------------------------------------------------------*/ | |
1129 | ||
1130 | void SetTextureDefaultParams(TextureID ID) | |
1131 | { | |
1132 | if (!IsTextureValid(ID)) return; | |
1133 | ||
1134 | #ifdef PRINT | |
1135 | printf("SetTextureDefaultParams::set parm par defaut textures\n"); | |
1136 | #endif | |
1137 | ||
1138 | ||
1139 | textab[ID].scalex = 1.0; | |
1140 | textab[ID].scaley = 1.0; | |
1141 | textab[ID].transx = 0.0; | |
1142 | textab[ID].transy = 0.0; | |
1143 | textab[ID].angle = 0.0; | |
1144 | ||
1145 | textab[ID].Gen = GL_OBJECT_LINEAR; | |
1146 | textab[ID].Light = texdata[textab[ID].data].status == TEXDATA_1D ? GL_DECAL : GL_MODULATE; | |
1147 | textab[ID].Wrap = texdata[textab[ID].data].status == TEXDATA_1D ? GL_CLAMP : GL_REPEAT; | |
1148 | memcpy(textab[ID].Plane1, sgenparams, sizeof(sgenparams)); | |
1149 | memcpy(textab[ID].Plane2, tgenparams, sizeof(tgenparams)); | |
1150 | textab[ID].Render = texdata[textab[ID].data].status == TEXDATA_1D ? GL_NEAREST : GL_LINEAR; | |
1151 | } | |
1152 | ||
1153 | /*----------------------------------------------------------------------*/ | |
1154 | /* Transfere de donnee des donnees internes a la structure TransferData */ | |
1155 | void TransferTexture_To_Data(TextureID ID, TextureData *TransfDt) | |
1156 | { | |
1157 | /* affectations */ | |
1158 | strcpy(TransfDt->path, texdata[textab[ID].data].imageFileName); | |
1159 | TransfDt->gen = textab[ID].Gen; | |
1160 | TransfDt->wrap = textab[ID].Wrap; | |
1161 | TransfDt->render = textab[ID].Light; | |
1162 | TransfDt->scalex = textab[ID].scalex; | |
1163 | TransfDt->scaley = textab[ID].scaley; | |
1164 | TransfDt->transx = textab[ID].transx; | |
1165 | TransfDt->transy = textab[ID].transy; | |
1166 | TransfDt->angle = textab[ID].angle; | |
1167 | memcpy(TransfDt->plane1, textab[ID].Plane1, sizeof(SizeType)); | |
1168 | memcpy(TransfDt->plane2, textab[ID].Plane2, sizeof(SizeType)); | |
1169 | } | |
1170 | ||
1171 | /*----------------------------------------------------------------------*/ | |
1172 | /* Transfere de donnee de la structure TransferData aux donnees internes */ | |
1173 | void TransferData_To_Texture(TextureData *TransfDt, TextureID *newID) | |
1174 | { | |
1175 | TextureID ID; | |
1176 | ||
1177 | /* Affectations */ | |
1178 | FreeTexture(*newID); | |
1179 | ID = GetTexture2DMipMap(TransfDt->path); | |
1180 | ||
1181 | if(IsTextureValid(ID)) | |
1182 | { | |
1183 | /* Affectation de l id courant */ | |
1184 | *newID = ID; | |
1185 | ||
1186 | /* Donnees concernant les caracteristiques de la texture */ | |
1187 | strcpy(texdata[textab[ID].data].imageFileName, TransfDt->path); | |
1188 | textab[ID].Gen = TransfDt->gen; | |
1189 | textab[ID].Wrap = TransfDt->wrap; | |
1190 | textab[ID].Light = TransfDt->render; | |
1191 | textab[ID].scalex = TransfDt->scalex; | |
1192 | textab[ID].scaley = TransfDt->scaley; | |
1193 | textab[ID].transx = TransfDt->transx; | |
1194 | textab[ID].transy = TransfDt->transy; | |
1195 | textab[ID].angle = TransfDt->angle; | |
1196 | memcpy(textab[ID].Plane1, TransfDt->plane1, sizeof(SizeType)); | |
1197 | memcpy(textab[ID].Plane2, TransfDt->plane2, sizeof(SizeType)); | |
1198 | } | |
1199 | } |