-
Notifications
You must be signed in to change notification settings - Fork 0
/
si_Textures.cpp
527 lines (424 loc) · 19.2 KB
/
si_Textures.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
// si_Textures.cpp - space invaders opengl
#include "si_Main.h"
#include "si_Textures.h"
#include "glpng.h" // Header File For Loading PNG Images (must be link with glpng.lib)
//////////////////////////////////////////////////////////////////////////////////////
//
// TEXTURES => JPG, GIF ou BMP (à partir d'une ressource ou d'un fichier)
//
//
BOOL LoadTexture(char* file, USHORT resource_id, int num_texture)
{
//
// IMAGE GIF OU JPG
//
if (FindResource(NULL, MAKEINTRESOURCE(resource_id), "JPG") != NULL
|| FindResource(NULL, MAKEINTRESOURCE(resource_id), "GIF") != NULL)
LoadTextureJPG_GIF(file, resource_id, num_texture);
//
// IMAGE BMP
//
else if (FindResource(NULL, MAKEINTRESOURCE(resource_id), RT_BITMAP) != NULL)
LoadTextureBMP(file, resource_id, num_texture);
//
// IMAGE TGA
//
else if (FindResource(NULL, MAKEINTRESOURCE(resource_id), "TGA") != NULL)
LoadTextureTGA(file, resource_id, num_texture);
//
// IMAGE PNG
//
else if (FindResource(NULL, MAKEINTRESOURCE(resource_id), "PNG") != NULL)
LoadTexturePNG(file, resource_id, num_texture);
else return FALSE;
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////////////
//
// LOAD TEXTURE (JPG, GIF) Attention, la couleur rose (255,0,255) est réservée pour le
// transparent (l'alpha est mis à 0)
//
BOOL LoadTextureJPG_GIF(char* file, USHORT resource_id, int num_texture)
{
HDC hdcTemp; // The DC To Hold Our Bitmap
HBITMAP hbmpTemp; // Holds The Bitmap Temporarily
IPicture *pPicture; // IPicture Interface
OLECHAR wszPath[MAX_PATH+1]; // Full Path To Picture (WCHAR)
char szPath[MAX_PATH+1]; // Full Path To Picture
long lWidth; // Width In Logical Units
long lHeight; // Height In Logical Units
long lWidthPixels; // Width In Pixels
long lHeightPixels; // Height In Pixels
GLint glMaxTexDim ; // Holds Maximum Texture Size
HRESULT hr;
// from disk
if (file != NULL)
{
if (strstr(file, "http://")) // If PathName Contains http:// Then...
strcpy(szPath, file); // Append The PathName To szPath
else // Otherwise... We Are Loading From A File
{
GetCurrentDirectory(MAX_PATH, szPath); // Get Our Working Directory
strcat(szPath, "\\"); // Append "\" After The Working Directory
strcat(szPath, file); // Append The PathName
}
MultiByteToWideChar(CP_ACP, 0, szPath, -1, wszPath, MAX_PATH); // Convert From ASCII To Unicode
hr = OleLoadPicturePath(wszPath, 0, 0, 0, IID_IPicture, (void**)&pPicture);
}
// from resource
else
{
HRSRC hRes = FindResource(NULL, MAKEINTRESOURCE(resource_id), "JPG");
if (hRes == NULL)
hRes = FindResource(NULL, MAKEINTRESOURCE(resource_id), "GIF");
DWORD dwDataSize = SizeofResource(NULL,hRes);
HGLOBAL hGlob = LoadResource(NULL,hRes);
LPVOID pData = LockResource(hGlob);
HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, dwDataSize);
void* pData2 = GlobalLock(hGlobal);
memcpy(pData2, pData, dwDataSize);
GlobalUnlock(hGlobal);
UnlockResource(hGlob);
FreeResource(hGlob);
IStream* pStream = NULL;
pPicture = NULL;
if (CreateStreamOnHGlobal(hGlobal, TRUE, &pStream) == S_OK)
{
hr = OleLoadPicture(pStream, 0, 0, IID_IPicture, (void**)&pPicture);
pStream->Release();
}
}
if(FAILED(hr)) // If Loading Failed
return FALSE; // Return False
hdcTemp = CreateCompatibleDC(GetDC(0)); // Create The Windows Compatible Device Context
if(!hdcTemp) // Did Creation Fail?
{
pPicture->Release(); // Decrements IPicture Reference Count
return FALSE; // Return False (Failure)
}
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &glMaxTexDim); // Get Maximum Texture Size Supported
pPicture->get_Width(&lWidth); // Get IPicture Width (Convert To Pixels)
lWidthPixels = MulDiv(lWidth, GetDeviceCaps(hdcTemp, LOGPIXELSX), 2540);
pPicture->get_Height(&lHeight); // Get IPicture Height (Convert To Pixels)
lHeightPixels = MulDiv(lHeight, GetDeviceCaps(hdcTemp, LOGPIXELSY), 2540);
// Resize Image To Closest Power Of Two
if (lWidthPixels <= glMaxTexDim) // Is Image Width Less Than Or Equal To Cards Limit
lWidthPixels = 1 << (int)floor((log((double)lWidthPixels)/log(2.0f)) + 0.5f);
else // Otherwise Set Width To "Max Power Of Two" That The Card Can Handle
lWidthPixels = glMaxTexDim;
if (lHeightPixels <= glMaxTexDim) // Is Image Height Greater Than Cards Limit
lHeightPixels = 1 << (int)floor((log((double)lHeightPixels)/log(2.0f)) + 0.5f);
else // Otherwise Set Height To "Max Power Of Two" That The Card Can Handle
lHeightPixels = glMaxTexDim;
// Create A Temporary Bitmap
BITMAPINFO bi = {0}; // The Type Of Bitmap We Request
DWORD *pBits = 0; // Pointer To The Bitmap Bits
bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); // Set Structure Size
bi.bmiHeader.biBitCount = 32; // 32 Bit
bi.bmiHeader.biWidth = lWidthPixels; // Power Of Two Width
bi.bmiHeader.biHeight = lHeightPixels; // Make Image Top Up (Positive Y-Axis)
bi.bmiHeader.biCompression = BI_RGB; // RGB Encoding
bi.bmiHeader.biPlanes = 1; // 1 Bitplane
// Creating A Bitmap This Way Allows Us To Specify Color Depth And Gives Us Imediate Access To The Bits
hbmpTemp = CreateDIBSection(hdcTemp, &bi, DIB_RGB_COLORS, (void**)&pBits, 0, 0);
if(!hbmpTemp) // Did Creation Fail?
{
DeleteDC(hdcTemp); // Delete The Device Context
pPicture->Release(); // Decrements IPicture Reference Count
return FALSE; // Return False (Failure)
}
SelectObject(hdcTemp, hbmpTemp); // Select Handle To Our Temp DC And Our Temp Bitmap Object
// Render The IPicture On To The Bitmap
pPicture->Render(hdcTemp, 0, 0, lWidthPixels, lHeightPixels, 0, lHeight, lWidth, -lHeight, 0);
// Convert from bgr to rgb format and add an alpha value of 255 (opaque)
// Also set the pink color transparent (see below)
for(long i = 0; i < lWidthPixels * lHeightPixels; i++) // Loop Through All Of The Pixels
{
BYTE* pPixel = (BYTE*)(&pBits[i]); // Grab The Current Pixel
BYTE temp = pPixel[0]; // Store 1st Color In Temp Variable (Blue)
pPixel[0] = pPixel[2]; // Move Red Value To Correct Position (1st)
pPixel[2] = temp; // Move Temp Value To Correct Blue Position (3rd)
pPixel[3] = 255; // Set The Alpha Value To 255
// Set pink pixel (RGB = 255,0,255) an alpha value of 0 (transparent)
// so be careful to not use this color otherwise delete the lines below !
if (pPixel[0] == 255) // si le pixel est rose (255,0,255)...
if (pPixel[1] == 0)
if (pPixel[2] == 255)
{
pPixel[0] = 0;
pPixel[1] = 0;
pPixel[2] = 0;
pPixel[3] = 0; // ...on met l'apha à zéro
}
}
glGenTextures(1, &texture[num_texture]); // Create The Texture
// Typical Texture Generation Using Data From The Bitmap
glBindTexture(GL_TEXTURE_2D, texture[num_texture]); // Bind To The Texture ID
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S ,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T ,GL_CLAMP);
// customization du filtre pour certaines textures du jeu
if (!game_option_mipmap || num_texture == 35 || num_texture == 36) // pour l'equalizer (35 et 36), pas de mipmap => image brute
{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR );// Bilinear Filtering
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Bilinear filtering
glTexImage2D(GL_TEXTURE_2D, 0, 4, lWidthPixels, lHeightPixels, 0, GL_RGBA, GL_UNSIGNED_BYTE, pBits);
}
else
{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR );// Trilinear filtering (évite le scintillement des petites textures)
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Bilinear filtering
gluBuild2DMipmaps(GL_TEXTURE_2D, 4, lWidthPixels, lHeightPixels, GL_RGBA, GL_UNSIGNED_BYTE, pBits);
}
DeleteObject(hbmpTemp); // Delete The Object
DeleteDC(hdcTemp); // Delete The Device Context
pPicture->Release(); // Decrements IPicture Reference Count
return TRUE; // Return True (All Good)
}
//////////////////////////////////////////////////////////////////////////////////////
//
// LOAD TEXTURE (BMP) Attention, les dimensions doivent être des puissances de 2.
//
//
BOOL LoadTextureBMP(char* file, USHORT resource_id, int num_texture)
{
HBITMAP hBMP; // Handle Of The Bitmap
BITMAP BMP; // Bitmap Structure
hBMP=(HBITMAP)LoadImage(GetModuleHandle(NULL),MAKEINTRESOURCE(resource_id), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
if (hBMP) // Does The Bitmap Exist?
{ // If So...
GetObject(hBMP,sizeof(BMP), &BMP); // Get The Object
glPixelStorei(GL_UNPACK_ALIGNMENT,4); // Pixel Storage Mode (Word Alignment / 4 Bytes)
glBindTexture(GL_TEXTURE_2D, texture[num_texture]); // Bind Our Texture
// customization pour le jeu -> texture avec mipmap
if (
(num_texture >= 0 && num_texture <= 5) || (num_texture >= 9 && num_texture <= 30) || (num_texture >= 37 && num_texture <= 100)
&& game_option_mipmap
)
{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); // Trilinear filtering
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Bilinear filtering
}
// customization pour le jeu -> texture sans mipmap
else
{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Bilinear filtering
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Bilinear filtering
}
// customization pour le jeu -> clamp
if ((num_texture >= 31 && num_texture <= 34))
{
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S ,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T ,GL_CLAMP);
}
// créé la texture
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, BMP.bmWidth, BMP.bmHeight, GL_BGR_EXT, GL_UNSIGNED_BYTE, BMP.bmBits);
DeleteObject(hBMP); // Delete The Bitmap Object
return TRUE;
}
else return FALSE;
}
//////////////////////////////////////////////////////////////////////////////////////
//
// LOAD TEXTURE (TGA)
//
//
BOOL LoadTextureTGA(char* file, USHORT resource_id, int num_texture)
{
// struct to cast the resource into
struct TGAstruct {
GLubyte TGAcompare[12]; // Used to compare TGA header
GLubyte header[6]; // First 6 useful bytes of the header
};
GLubyte TGAheader[12] = {0,0,2,0,0,0,0,0,0,0,0,0};// Uncompressed TGA header
GLuint bytesPerPixel; // Holds the number of bytes per pixel used
GLuint imageSize; // Used to store the image size
GLuint temp; // Temporary variable
GLuint type = GL_RGBA; // Set the default type to RBGA (32 BPP)
GLubyte *imageData; // Image data (up to 32 Bits)
GLuint bpp; // Image color depth in bits per pixel.
// Find the targa in the "TGA" resources
HRSRC hrsrc = FindResource(0, MAKEINTRESOURCE(resource_id), "TGA");
// If you can't find it then return
if (hrsrc == NULL)
return FALSE;
// Load the targa
HGLOBAL resource = LoadResource(0, hrsrc);
// If you can't load it then return
if (resource == NULL)
return FALSE;
// Load it into the buffer
void *buffer = LockResource(resource);
// Cast it into the targa struct
TGAstruct *top = (TGAstruct*)buffer;
// Make sure it checks out against our comparison header
if (memcmp(TGAheader,top,sizeof(TGAheader)) != 0)
return FALSE;
// Determine the TGA width and height (highbyte*256+lowbyte)
int width = top->header[1] * 256 + top->header[0];
int height = top->header[3] * 256 + top->header[2];
// Check to make sure the targa is valid and is 24 bit or 32 bit
if (width <=0 || // Is the width less than or equal to zero
height <=0 || // Is the height less than or equal to zero
(top->header[4] != 24 && top->header[4] != 32)) // Is it 24 or 32 bit?
{
// If anything didn't check out then close the file and return
return FALSE;
}
bpp = top->header[4]; // Grab the bits per pixel
bytesPerPixel = bpp / 8; // Divide by 8 to get the bytes per pixel
imageSize = width * height * bytesPerPixel; // Calculate the memory required for the data
// Allocate the memory for the image data
imageData = new GLubyte[imageSize];
// Load the data in
memcpy(imageData, (GLubyte*)buffer+18, imageSize);
// Loop through the image data and swap the 1st and 3rd bytes (red and blue)
for(GLuint i = 0; i < int(imageSize); i += bytesPerPixel)
{
temp = imageData[i];
imageData[i] = imageData[i + 2];
imageData[i + 2] = temp;
}
// Set the type if 24 bits (8x3), in place of 32 bits (8x3 + alpha)
if (bpp == 24)
type = GL_RGB;
// Generate the OpenGL texture id
glGenTextures(1, &texture[num_texture]);
// Bind this texture to its id
glBindTexture(GL_TEXTURE_2D, texture[num_texture]);
// Use mipmapping filter
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S ,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T ,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); // Trilinear filtering
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Bilinear filtering
// Generate the mipmaps
gluBuild2DMipmaps(GL_TEXTURE_2D, type, width, height, type, GL_UNSIGNED_BYTE, imageData);
// Cleanup
free(imageData);
// free(buffer);
// free(top);
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////////////
//
// LOAD TEXTURE (TGA) FROM FILE
//
//
/*
bool LoadTextureTGA_fromFile(char *filename, USHORT resource_id, int num_texture)
{
texture[i] = &texture[0]
GLubyte TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0}; // Uncompressed TGA Header
GLubyte TGAcompare[12]; // Used To Compare TGA Header
GLubyte header[6]; // First 6 Useful Bytes From The Header
GLuint bytesPerPixel; // Holds Number Of Bytes Per Pixel Used In The TGA File
GLuint imageSize; // Used To Store The Image Size When Setting Aside Ram
GLuint temp; // Temporary Variable
GLuint type=GL_RGBA; // Set The Default GL Mode To RBGA (32 BPP)
FILE *file = fopen(filename, "rb"); // Open The TGA File
if( file==NULL || // Does File Even Exist?
fread(TGAcompare,1,sizeof(TGAcompare),file)!=sizeof(TGAcompare) || // Are There 12 Bytes To Read?
memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0 || // Does The Header Match What We Want?
fread(header,1,sizeof(header),file)!=sizeof(header)) // If So Read Next 6 Header Bytes
{
if (file == NULL) // Did The File Even Exist? *Added Jim Strong*
return false; // Return False
else
{
fclose(file); // If Anything Failed, Close The File
return false; // Return False
}
}
texture->width = header[1] * 256 + header[0]; // Determine The TGA Width (highbyte*256+lowbyte)
texture->height = header[3] * 256 + header[2]; // Determine The TGA Height (highbyte*256+lowbyte)
if( texture->width <=0 || // Is The Width Less Than Or Equal To Zero
texture->height <=0 || // Is The Height Less Than Or Equal To Zero
(header[4]!=24 && header[4]!=32)) // Is The TGA 24 or 32 Bit?
{
fclose(file); // If Anything Failed, Close The File
return false; // Return False
}
texture->bpp = header[4]; // Grab The TGA's Bits Per Pixel (24 or 32)
bytesPerPixel = texture->bpp/8; // Divide By 8 To Get The Bytes Per Pixel
imageSize = texture->width*texture->height*bytesPerPixel; // Calculate The Memory Required For The TGA Data
texture->imageData=(GLubyte *)malloc(imageSize); // Reserve Memory To Hold The TGA Data
if( texture->imageData==NULL || // Does The Storage Memory Exist?
fread(texture->imageData, 1, imageSize, file)!=imageSize) // Does The Image Size Match The Memory Reserved?
{
if(texture->imageData!=NULL) // Was Image Data Loaded
free(texture->imageData); // If So, Release The Image Data
fclose(file); // Close The File
return false; // Return False
}
for(GLuint i=0; i<int(imageSize); i+=bytesPerPixel) // Loop Through The Image Data
{ // Swaps The 1st And 3rd Bytes ('R'ed and 'B'lue)
temp=texture->imageData[i]; // Temporarily Store The Value At Image Data 'i'
texture->imageData[i] = texture->imageData[i + 2]; // Set The 1st Byte To The Value Of The 3rd Byte
texture->imageData[i + 2] = temp; // Set The 3rd Byte To The Value In 'temp' (1st Byte Value)
}
fclose (file); // Close The File
// Build A Texture From The Data
glGenTextures(1, &texture[0].texID); // Generate OpenGL texture IDs
glBindTexture(GL_TEXTURE_2D, texture[0].texID); // Bind Our Texture
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Linear Filtered
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Filtered
if (texture[0].bpp==24) // Was The TGA 24 Bits
{
type=GL_RGB; // If So Set The 'type' To GL_RGB
}
glTexImage2D(GL_TEXTURE_2D, 0, type, texture[0].width, texture[0].height, 0, type, GL_UNSIGNED_BYTE, texture[0].imageData);
return true; // Texture Building Went Ok, Return True
}
*/
//////////////////////////////////////////////////////////////////////////////////////
//
// LOAD TEXTURE (PNG) Ce format supporte la composante alpha : 255 valeurs par couleur
// en 24 bits (RGBA) alors que le GIF ne supporte que 2 valeurs
// (transparent ou opaque).
//
// A utiliser pour l'antialiasing des contours de textures, différents
// degrés de transparence dans une même texture, des effets d'ombres...
//
// Les dimensions en puissances de 2 évitent le redimensionnement
// si vous utilisez la texure pour de la 2D orthogonale (on-screen
// display, HUD) Pour ceci mettez votre graphique en bas à gauche de
// la texture et ce qui est en trop en transparent.
//
// Voir la fonction display_energy() pour un exemple d'affichage.
//
BOOL LoadTexturePNG(char* file, USHORT resource_id, int num_texture)
{
// from resource
if (file == NULL && resource_id != NULL)
{
// find it
HRSRC hRes = FindResource(NULL, MAKEINTRESOURCE(resource_id), "PNG");
if (hRes == NULL) return FALSE;
// open it
DWORD rsize = SizeofResource(NULL, hRes);
HGLOBAL hMem = LoadResource(NULL, hRes);
if (hMem == NULL) return FALSE;
LPVOID lp = LockResource(hMem);
if (lp == NULL) return FALSE;
// create a temporary file
FILE * pFile;
pFile = tmpfile();
if (pFile == NULL) return FALSE;
// copy the resource in the temporary file
fwrite(lp, rsize, 1, pFile);
fseek(pFile, 0, SEEK_SET);
// load the temporary file as a normal PNG image
texture[num_texture] = pngBindF(pFile, PNG_NOMIPMAP, PNG_ALPHA, NULL, GL_CLAMP, GL_LINEAR, GL_LINEAR);
if (texture[num_texture] == 0)
BOX("erreur loading png");
fclose (pFile);
}
// from file
else if (file != NULL)
{
// load it
texture[num_texture] = pngBind(file, PNG_NOMIPMAP, PNG_ALPHA, NULL, GL_CLAMP, GL_LINEAR, GL_LINEAR);
if (texture[num_texture] == 0)
BOX("erreur loading png");
}
return TRUE;
}