Bitmap laden ohne GLAUX

[TS++]

Hallo zusammen!

Welche Routinen verwendet Ihr denn beim Laden von Bitmaps bzw. bei der Generierung von Texturen unter OpenGL, wenn man den BCB verwendet und demzufolge lieber auf GLAUX und GLUT verzichtet?
(viele Bücher beschränken sich auf VisualC++)

Danke!

Grüße,
TS++

[SnorreDev]

Hi

Möchtest du eine Library, oder die Funktion selber schreiben?
Wenn Lib, dann probier mal DevIL bzw. OpenIL

[TS++]

Servus SnorreDev!

Danke für den Tipp.
Ich bin aber lediglich an der Implementierung einer einzelnen Methode zum Laden von Bitmaps interessiert.
In etwa wie der folgende Codeauszug:

void CreateTexture(UINT textureArray[], LPSTR strFileName, int textureID)
{
	AUX_RGBImageRec *pBitmap = NULL;
	if(!strFileName)return;

	pBitmap = auxDIBImageLoad(strFileName);   
	if(pBitmap == NULL)exit(0);

	glGenTextures(1, &textureArray[textureID]);
	glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
	glBindTexture(GL_TEXTURE_2D, textureArray[textureID]);
	gluBuild2DMipmaps(GL_TEXTURE_2D, 3, pBitmap->sizeX, pBitmap->sizeY,  GL_RGB, GL_UNSIGNED_BYTE, pBitmap->data);

	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);	

	if (pBitmap)
      {											
		if (pBitmap->data)								
		{
			free(pBitmap->data);						
		}
		free(pBitmap);	
      }								
}

Nur nach Möglichkeit eben ohne GLUT. Eine ganze Bibliothek zu verwenden wäre glaub ich "mit Kanonen auf Spatzen geschossen". Gibt's noch einen anderen Standardansatz?

Danke!

Grüße,
TS++

[SnorreDev]

Hi nochmal

Also - wir hatten es vor der Devil zufuß gemacht.
Entsprechende Infos zu dem Fileformat findest du hier:
http://www.wotsit.org/search.asp?s=graphics

Du könntest, da BCB eh nur unter Windows ist auch auf WinAPI Funcs zugreifen, und die Bilder als HBITMAP laden. Andere Möglichkeit, hab zwar BCB schon lange nicht mehr gesehen, aber die haben doch eine Image Component oder? Lade es doch mit der, und laß dir die Daten zum erstellen von der Component liefern.

Hope this helps a little bit more
Cya
Sven

[TheTester]

AUX_RGBImageRec *pBitmap = NULL;

das da ist kein glut...das ist die glaux...glut bietet glaub ich gar keine möglichkeit ein bmp zu laden...

bye

[TS++]

Danke für eure Hilfe!

Hab's hingekriegt!

Grüße,
TS++

[Gast]

Und wie hast du es nun gemacht?

[geeky]

Hab mich in letzter Zeit auch mal nen bisschen mit OpenGL befasst und mir ne Funktion zusammengefuckelt, die Bitmaps, Jpegs, ... laden kann und als Textur anlegt.
Hab die gerade fürs Board noch ein bisschen geändert - könnten sich Fehler reingeschlichen haben - vielleicht interessiert das hier ja wen...
hlp_debug ist bei mir ne Funktion die mir was in ein log-file oder in das Debugger-Fenster schreibt, kann man also weglassen...
Alpha-Werte werden hier einfach auf 0 gesetzt, hab ich aber in der struct mal drin gelassen, falls ich das später mal erweiter oder so...

typedef struct gine_pixel
{
	unsigned char r;
	unsigned char g;
	unsigned char b;
	unsigned char alpha;
} gine_pixel;

int texture_load(char *filename)
{
	int texture_id;
	int i;
	int k;
	gine_pixel *imagePixels;

	HANDLE fHandle;
	DWORD fSize;
	DWORD bytesRead;
	char fname[500];

	LPVOID mem;
	HGLOBAL mem_global;
	HLOCAL mem_local;
	LPSTREAM pStream;
	LPPICTURE pPic;
	HDC deskDC;
	HDC tDC;
	HGDIOBJ old;
	HBITMAP bmp;
	long cx;
	long cy;
	RECT renderRt;
	int x, y;
	COLORREF cr;

	char temp[500];

	// Open the file:
		strcpy(fname,filename);
		hlp_prePath(fname);
		fHandle=CreateFile(fname,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
		if (fHandle==INVALID_HANDLE_VALUE)
		{
			hlp_debug("texture_load","Error opening file!");
			return NULL;
		}

	// Get Filesize:
		fSize=GetFileSize(fHandle,NULL);
		if (fSize==INVALID_FILE_SIZE)
		{
			hlp_debug("texture_load","GetFileSize");
			return NULL;
		}

	// Allocate memory:
		mem_global=GlobalAlloc(GMEM_MOVEABLE,(fSize+1000));
		if (mem_global==NULL)
		{
			hlp_debug("texture_load","GlobalAlloc");
			return NULL;
		}
		mem=GlobalLock(mem_global);
		if (mem==NULL)
		{
			hlp_debug("texture_load","GlobalLock");
		}

	// Read the file:
		bytesRead=0;
		if (!ReadFile(fHandle,mem,fSize,&bytesRead,NULL))
		{
			hlp_debug("texture_load","ReadFile");
			GlobalUnlock(mem_global);
			GlobalFree(mem_global);
			return NULL;
		}
		GlobalUnlock(mem_global);

	// Close the file:
		CloseHandle(fHandle);

	// Create the stream:
		if (CreateStreamOnHGlobal(mem_global,TRUE,&pStream)!=S_OK)
		{
			GlobalFree(mem_global);
			hlp_debug("texture_load","CreateStreamOnHGlobal");
			return NULL;
		}

	// Load Image:
		if (OleLoadPicture(pStream, fSize, FALSE, IID_IPicture, (LPVOID *)&pPic)!=S_OK)
		{
			GlobalFree(mem_global);
			pStream->Release();
			hlp_debug("texture_load","OleLoadPicture");
			return NULL;
		}

	// Get Image Dimensions:
		deskDC=GetDC(NULL);
		pPic->get_Width(&cx);
		pPic->get_Height(&cy);
		renderRt.right=MulDiv(cx,GetDeviceCaps(deskDC,LOGPIXELSX),2540);
		renderRt.bottom=MulDiv(cy,GetDeviceCaps(deskDC,LOGPIXELSY),2540);

	// Render Image:
		tDC=CreateCompatibleDC(deskDC);
		bmp=CreateCompatibleBitmap(deskDC,renderRt.right,renderRt.bottom);
		if (!bmp)
		{
			hlp_debug("texture_load","CreateCompatibleBitmap() failed!");
		}
		old=SelectObject(tDC,bmp);
		renderRt.left=0;
		renderRt.top=0;
		GdiFlush();
		if (pPic->Render(tDC,0,0,renderRt.right,renderRt.bottom,0,cy,cx,-cy,&renderRt)!=S_OK)
		{
			hlp_debug("texture_load","pPic->Render() failed!");
			return 0;
		}
		GdiFlush();

	// Convert Pixels from RGB to RGBA:
		i=(renderRt.right*renderRt.bottom)*sizeof(gine_pixel);

		mem_local=LocalAlloc(LMEM_MOVEABLE,i);
		imagePixels=(gine_pixel*)LocalLock(mem_local);

		k=0;
		for (y=0; y<renderRt.bottom; y++) //y
		{
			for (x=0; x<renderRt.right; x++)
			{
				cr=GetPixel(tDC,x,y);

				imagePixels[k].r=GetRValue(cr);
				imagePixels[k].g=GetGValue(cr);
				imagePixels[k].b=GetBValue(cr);
				imagePixels[k].alpha=0;
				k++;
			}
		}
		LocalUnlock(mem_local);

	// Textur in OpenGL anlegen:
		glGenTextures(1, &texture_id );
		glBindTexture(GL_TEXTURE_2D, texture_id);
		glTexImage2D(GL_TEXTURE_2D, 0, 4, renderRt.right, renderRt.bottom, 0, GL_RGBA, GL_UNSIGNED_BYTE, imagePixels);
		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

	// Clean-up:
		GlobalFree(mem_global);
		LocalFree(mem_local);
		DeleteObject(SelectObject(tDC,old));
		DeleteDC(tDC);
		ReleaseDC(NULL,deskDC);
		pPic->Release();
		pPic=NULL;

	// Debug:
		hlp_debug("texture_load","Textur geladen:");

		wsprintf(temp," + Texture-Name: '%s'",filename);
		hlp_debug("texture_load",temp);

		wsprintf(temp," + Texture-ID: %u",(unsigned int)texture_id);
		hlp_debug("texture_load",temp);

		wsprintf(temp," + Dimensions: %i x %i",renderRt.right,renderRt.bottom);
		hlp_debug("texture_load",temp);

	return texture_id;
}

[TS++]

Hallo geeky!

Danke für deinen Beitrag!
Nur:
Welche Header includest du denn?

Danke!

Grüße,
TS++

[TS++]

Hab's!

<ocidl.h> für PICTURE (LPPICTURE) und <olectl.h> für OleLoadPicture!

Stimmts!

Grüße,
TS++

[geeky]

Ich hab nur windows.h und olectl.h inkludiert