int LoadTexturesFromResource(void)				// Load Image And Convert To A Texture
{
	
	IPicture	*ipic;
	HDC			hDCtemp;
	GLint		glMaxTexDim;
	long		pWidth;
	long		pHeight;
	long		pPixWidth;
	long		pPixHeight;
	HBITMAP		bmpTemp;


	byte	Texture[]={IDR_GRASS,IDR_FRONT};

	for(int l=0;l<sizeof(Texture);l++)
	{
		
		HMODULE hModule = GetModuleHandle(NULL);
		HRSRC resource = FindResource(hModule, MAKEINTRESOURCE(Texture[l]), "JPG");
		HGLOBAL r=LoadResource(hModule,resource);
		LPVOID lpData = (unsigned char*)LockResource(r);
		int size = SizeofResource(hModule, resource);
		if(size==0)return FALSE;
		FreeResource(resource);

		HGLOBAL global=GlobalAlloc(GMEM_MOVEABLE,size);
		LPVOID gdata=GlobalLock(global);
		memcpy(gdata,lpData,size);
		GlobalUnlock(global);
		LPSTREAM stream;
		HRESULT hr = CreateStreamOnHGlobal(global, TRUE, &stream);
		if(FAILED(hr))return FALSE;
		hr=OleLoadPicture(stream,0,TRUE,IID_IPicture,(void**)&ipic);
		if(FAILED(hr))return FALSE;

		hDCtemp=CreateCompatibleDC(GetDC(0));
		if(hDCtemp==NULL)
		{
			ipic->Release();
			return FALSE;
		}

		glGetIntegerv(GL_MAX_TEXTURE_SIZE, &glMaxTexDim);

		ipic->get_Width(&pWidth);
		pPixWidth=MulDiv(pWidth,GetDeviceCaps(hDCtemp,LOGPIXELSX),2540);
		ipic->get_Height(&pHeight);
		pPixHeight=MulDiv(pHeight,GetDeviceCaps(hDCtemp,LOGPIXELSY),2540);

		// Resize Image To Closest Power Of Two
		if (pPixWidth <= glMaxTexDim)					// Is Image Width Less Than Or Equal To Cards Limit
			pPixWidth = 1 << (int)floor((log((double)pPixWidth)/log(2.0f)) + 0.5f); 
		else									// Otherwise  Set Width To "Max Power Of Two" That The Card Can Handle
			pPixWidth = glMaxTexDim;
	 
		if (pPixHeight <= glMaxTexDim)				// Is Image Height Greater Than Cards Limit
			pPixHeight = 1 << (int)floor((log((double)pPixHeight)/log(2.0f)) + 0.5f);
		else									// Otherwise  Set Height To "Max Power Of Two" That The Card Can Handle
			pPixHeight = glMaxTexDim;

		BITMAPINFO bi={0};
		DWORD *pBits=0;

		bi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
		bi.bmiHeader.biBitCount=32;
		bi.bmiHeader.biPlanes=1;
		bi.bmiHeader.biWidth=pPixWidth;
		bi.bmiHeader.biHeight=pPixHeight;
		bi.bmiHeader.biCompression=BI_RGB;

		bmpTemp = CreateDIBSection(hDCtemp, &bi, DIB_RGB_COLORS, (void**)&pBits, 0, 0);
		if(!bmpTemp)
		{
			DeleteDC(hDCtemp);
			ipic->Release();
			return FALSE;
		}
		SelectObject(hDCtemp,bmpTemp);

		ipic->Render(hDCtemp,0,0,pPixWidth,pPixHeight,0,pHeight,pWidth,-pHeight,0);

		for(long i = 0; i < pPixWidth * pPixHeight; i++)			// Loop Through All Of The Pixels
		{
			BYTE* pPixel	= (BYTE*)(&pBits);				// 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
		}

		glGenTextures(1, &texture[l]);						// Create The Texture

		// Typical Texture Generation Using Data From The Bitmap
		glBindTexture(GL_TEXTURE_2D, texture[l]);					// Bind To The Texture ID
		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);		// (Modify This For The Type Of Filtering You Want)
		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);		// (Modify This For The Type Of Filtering You Want)

		// (Modify This If You Want Mipmaps)	
		glTexImage2D(GL_TEXTURE_2D, 0, 3, pPixWidth, pPixHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, pBits);

		DeleteObject(bmpTemp);							// Delete The Object
		DeleteDC(hDCtemp);							// Delete The Device Context

		ipic->Release();							// Decrements IPicture Reference Count				

	}
	return TRUE;
}