// based on http://nemerle.org/svn/nemerle/trunk/snippets/opengl/sdlopengl4.n , Ben Humphrey, [email protected] public static int LoadBitmapToOpenGl(Bitmap bitmap) { // the following lines extract R,G and B values from any bitmap const int channels = 4; byte[] data = new byte[channels * bitmap.Width * bitmap.Height]; for (int i = 0; i < bitmap.Height; i++) { for (int j = 0; j < bitmap.Width; j++) { System.Drawing.Color pixel = bitmap.GetPixel(j, i); int offset = (i * bitmap.Width + j) * channels; data[offset + 0] = pixel.R; // in our tImage classes we store r first data[offset + 1] = pixel.G; // then g data[offset + 2] = pixel.B; data[offset + 3] = pixel.B; } } int iTextureReference; Gl.glGenTextures(1, out iTextureReference); Gl.glBindTexture(Gl.GL_TEXTURE_2D, iTextureReference); Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA8, bitmap.Width, bitmap.Height, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, data); Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR); return(iTextureReference); }
/// <summary>
/// Loads textures from files.
/// </summary>
/// <param name="filesNames">
/// File paths of texture image files.
/// </param>
private uint[] LoadTextureFromImage(string[] filesNames)
{
int numOfPic = filesNames.Length;
uint[] texture = new uint[numOfPic];
Bitmap[] bitmap = new Bitmap[numOfPic];
BitmapData[] bitmapdata = new BitmapData[numOfPic];
for (int im = 0; im < numOfPic; im++)
{
if (File.Exists(filesNames[im]))
{
bitmap[im] = new Bitmap(filesNames[im]);
}
}
Gl.glGenTextures(numOfPic, texture);
for (int i = 0; i < numOfPic; i++)
{
bitmap[i].RotateFlip(RotateFlipType.RotateNoneFlipY);
Rectangle rect = new Rectangle(0, 0, bitmap[i].Width, bitmap[i].Height);
bitmapdata[i] = bitmap[i].LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[i]);
Gl.glTexEnvf(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_MODULATE);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_NEAREST);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, (int)Gl.GL_RGB, bitmap[i].Width, bitmap[i].Height, Gl.GL_BGR_EXT, Gl.GL_UNSIGNED_BYTE, bitmapdata[i].Scan0);
bitmap[i].UnlockBits(bitmapdata[i]);
bitmap[i].Dispose();
}
return(texture);
}
//public void BindTexture ( int width, int height, byte [,,] data )
public void BindTexture(int width, int height, IntPtr data)
{
Gl.glEnable(Gl.GL_TEXTURE_2D);
int[] textures = new int [1];
Gl.glGenTextures(1, textures);
textureid = textures[0];
//Console.WriteLine ( "GL Texture number: {0}", textures [0] );
Gl.glBindTexture(Gl.GL_TEXTURE_2D, textureid);
// repeat texture if neccessary
//Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_CLAMP);
//Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_CLAMP);
//Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
//Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_NEAREST);
//Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST);
Gl.glTexEnvf(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_REPLACE);
// Finally we define the 2d texture
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA, width, height, 0, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, data);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA8, width, height, 0, Gl.GL_BGRA_EXT, Gl.GL_UNSIGNED_BYTE, data );
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA8, width, height, 0, Gl.GL_BGRA_EXT, Gl.GL_UNSIGNED_BYTE, data);
// And create 2d mipmaps for the minifying function
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, 4, width, height, Gl.GL_BGRA_EXT, Gl.GL_UNSIGNED_BYTE, data);
Gl.glDisable(Gl.GL_TEXTURE_2D);
}
/// <summary>
/// Load bitmaps and convert to textures.
/// </summary>
/// <returns>
/// <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
protected bool LoadGLTextures(ref int texture, Bitmap textureImage)
{
bool status = false; // Status Indicator
// Check For Errors, If Bitmap's Not Found, Quit
if (textureImage != null)
{
status = true; // Set The Status To True
// Rectangle For Locking The Bitmap In Memory
Rectangle rectangle = new Rectangle(0, 0, textureImage.Width, textureImage.Height);
// Get The Bitmap's Pixel Data From The Locked Bitmap
BitmapData bitmapData = textureImage.LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
// Typical Texture Generation Using Data From The Bitmap
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, textureImage[0].Width, textureImage[0].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
// これを使うと2のｎ乗でないサイズの画像も読める
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA, textureImage.Width, textureImage.Height, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
if (textureImage != null)
{ // If Texture Exists
textureImage.UnlockBits(bitmapData); // Unlock The Pixel Data From Memory
}
}
return(status); // Return The Status
}
public static void LoadTexture()
{
Bitmap bitmap = null;
BitmapData bitmapData = null;
string[] tx = { "relojes.bmp", "ford1.bmp", "benz1.jpg", "motor.bmp", "acelera.bmp", "papel1.jpg", "piso.jpg", "madera2.jpg", "madera3.jpg", "papel1.jpg", "Focus.jpg", "fordrunner.jpg", "mbne.jpg", "particle.bmp", "benz.jpg" };
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glEnable(Gl.GL_DEPTH_TEST);
// Gl.gl.Gl.glEnable(Gl.gl.Gl.gl_BLEND);
// Gl.gl.Gl.glBlendFunc(Gl.gl.Gl.gl_SRC_ALPHA,Gl.gl.Gl.gl_ONE_MINUS_SRC_ALPHA);
Rectangle rect;
texture = new int[tx.Length];
Gl.glGenTextures(tx.Length, texture);
for (int i = 0; i < tx.Length; i++)
{
bitmap = new Bitmap(Application.StartupPath + "\\" + "Textures\\" + tx[i]);
rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
bitmapData = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[i]);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, (int)Gl.GL_RGB8, bitmap.Width, bitmap.Height, Gl.GL_BGR_EXT, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
}
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexEnvf(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_DECAL);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
bitmap.UnlockBits(bitmapData);
bitmap.Dispose();
}
public static int LoadTexture2D(
Surface surface,
bool flip,
TextureOptions options)
{
if (surface == null)
{
throw new ArgumentNullException("surface");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
int textureID;
using (Surface textureSurface = TransformSurface(surface, flip))
{
Gl.glGenTextures(1, out textureID);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, textureID);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, (int)options.MinifyingFilter);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, (int)options.MagnificationFilter);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, (int)options.WrapS);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, (int)options.WrapT);
if (options.MinifyingFilter == MinifyingOption.Linear ||
options.MinifyingFilter == MinifyingOption.Nearest)
{
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, textureSurface.BytesPerPixel, textureSurface.Width, textureSurface.Height, 0, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, textureSurface.Pixels);
}
else
{
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, textureSurface.BytesPerPixel, textureSurface.Width, textureSurface.Height, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, textureSurface.Pixels);
}
}
return(textureID);
}
//------------------------------------------------------------------------------
// read texture
public void read()
{
Gl.glGenTextures(1, out _texture);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, _texture);
if (Gl.glIsTexture(_texture) == 0)
{
throw new Exception("Error : Failed texture creation");
}
Bitmap bitmap = new Bitmap(_filename, true);
bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
// Rectangle For Locking The Bitmap In Memory
Rectangle rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
// Get The Bitmap's Pixel Data From The Locked Bitmap
BitmapData bitmapData = bitmap.LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, bitmap.Width, bitmap.Height, 0,
Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB8, bitmap.Width, bitmap.Height,
Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
if (_mipmap)
{
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
}
else
{
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
}
}
void TextureLoad(string url, ref uint texture)
{
// создаём изображение с идентификатором imageId
Il.ilGenImages(1, out imageId);
// делаем изображение текущим
Il.ilBindImage(imageId);
// пробуем загрузить изображение
if (Il.ilLoadImage(url))
{
// Convert To An Easy-To-Use Format/Type
Il.ilConvertImage(Il.IL_BGR, Il.IL_UNSIGNED_BYTE);
Gl.glGenTextures(1, out texture);
// Create MipMapped Texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Il.ilGetInteger(Il.IL_IMAGE_BPP), Il.ilGetInteger(Il.IL_IMAGE_WIDTH),
Il.ilGetInteger(Il.IL_IMAGE_HEIGHT), Il.IL_BGR, Il.ilGetInteger(Il.IL_IMAGE_TYPE), Il.ilGetData());
Il.ilDeleteImages(1, ref imageId);
}
}
private void loadTextures()
{
Gl.glGenTextures(textureCount, textureId);
for (int i = 0; i < textureCount; ++i)
{
Gl.glBindTexture(Gl.GL_TEXTURE_2D, textureId[i]);
// Ucitaj sliku i podesi parametre teksture
Bitmap image = new Bitmap(textureFiles[i]);
image.RotateFlip(RotateFlipType.RotateNoneFlipY);
Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
BitmapData imageData = image.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, (int)Gl.GL_RGBA8, image.Width, image.Height, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, imageData.Scan0);
// Podesi parametre teksture
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
image.UnlockBits(imageData);
image.Dispose();
}
}
public static int CreateTexture(string filename)
{
int res;
PBitmap pBitmap = new PBitmap("textures\\" + filename); // Load the bitmap and store the data
Gl.glGenTextures(1, out res);
// This sets the alignment requirements for the start of each pixel row in memory.
Gl.glPixelStorei(Gl.GL_UNPACK_ALIGNMENT, 1);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, res);
// Build Mipmaps (builds different versions of the picture for distances - looks better)
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, 3, pBitmap.Width, pBitmap.Height, Gl.GL_RGB, Gl.GL_UNSIGNED_BYTE, pBitmap.data);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
// The default GL_TEXTURE_WRAP_S and ""_WRAP_T property is GL_REPEAT.
// We need to turn this to GL_CLAMP_TO_EDGE, otherwise it creates ugly seems
// in our sky box. GL_CLAMP_TO_EDGE does not repeat when bound to an object.
// Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_CLAMP_TO_EDGE);
// Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_CLAMP_TO_EDGE);
pBitmap = null;
return(res);
}
public static void LoadVideoTextures()
{
//Loaded Bitmaps
BitmapData[] videoTextureFileData = new BitmapData[MAX_NUMBER_OF_TEXTURES];
Bitmap[] videoTextureImages = new Bitmap[MAX_NUMBER_OF_TEXTURES];
List <string> videoTextureFilesPath = null; //Texture file paths
m_actualNumberOfVideoTexturesLoaded = 0;
Gl.glGenTextures(MAX_NUMBER_OF_TEXTURES, m_videoTextures);
videoTextureFilesPath = new List <string>(GetVideoTextureFiles());
//load bitmaps into array for OpenGl.
foreach (string currentVideoTexture in videoTextureFilesPath)
{
videoTextureImages[m_actualNumberOfVideoTexturesLoaded] = new Bitmap(currentVideoTexture);
m_actualNumberOfVideoTexturesLoaded++;
}
//generate textures from all bitmaps
for (int i = 0; i < videoTextureFilesPath.Count; i++)
{
Rectangle rectangle = new Rectangle(0, 0, videoTextureImages[i].Width, videoTextureImages[i].Height);
videoTextureFileData[i] = videoTextureImages[i].LockBits(rectangle, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
//Enable hardware generation of all mipmap levels
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_GENERATE_MIPMAP, Gl.GL_TRUE);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, m_videoTextures[i]);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_R, Gl.GL_REPEAT);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 10, Gl.GL_RGB, videoTextureImages[i].Width, videoTextureImages[i].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, videoTextureFileData[i].Scan0);
//Use maximum Anisotropic filtering if available
if (((string)Gl.glGetString(Gl.GL_EXTENSIONS)).Contains("GL_EXT_texture_filter_anisotropic"))
{
float maxAnisotropy;
Gl.glGetFloatv(Gl.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, out maxAnisotropy);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
}
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB, videoTextureImages[i].Width, videoTextureImages[i].Height, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, videoTextureFileData[i].Scan0);
if (videoTextureImages[i] != null)
{
videoTextureImages[i].UnlockBits(videoTextureFileData[i]);
videoTextureImages[i].Dispose();
}
}
}
/// <summary>
/// Load bitmaps and convert to textures.
/// </summary>
/// <returns>
/// <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
protected virtual void LoadGLFilteredTextures()
{
if (File.Exists(Path.Combine(this.DataDirectory, this.GetTextureName()[0])))
{
this.FilePath = "";
}
// Status Indicator
Bitmap[] textureImage = new Bitmap[this.GetTextureName().Length];
// Create Storage Space For The Texture
for (int i = 0; i < this.GetTextureName().Length; i++)
{
textureImage[i] = new Bitmap(Path.Combine(this.FilePath, Path.Combine(this.DataDirectory, this.GetTextureName()[i])));
}
// Load The Bitmap
// Check For Errors, If Bitmap's Not Found, Quit
if (textureImage[0] != null)
{
// Create The Texture
Gl.glGenTextures(this.GetTexture().Length, this.GetTexture());
for (int i = 0; i < textureImage.Length; i++)
{
textureImage[i].RotateFlip(RotateFlipType.RotateNoneFlipY);
// Flip The Bitmap Along The Y-Axis
// Rectangle For Locking The Bitmap In Memory
Rectangle rectangle = new Rectangle(0, 0, textureImage[i].Width, textureImage[i].Height);
// Get The Bitmap's Pixel Data From The Locked Bitmap
BitmapData bitmapData = textureImage[i].LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
// Create Nearest Filtered Texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, this.GetTexture()[i]);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_NEAREST);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, textureImage[i].Width, textureImage[i].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
// Create Linear Filtered Texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, this.GetTexture()[i + 1]);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, textureImage[i].Width, textureImage[i].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
// Create MipMapped Texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, this.GetTexture()[i + 2]);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB8, textureImage[i].Width, textureImage[i].Height, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
if (textureImage[i] != null)
{
// If Texture Exists
textureImage[i].UnlockBits(bitmapData);
// Unlock The Pixel Data From Memory
textureImage[i].Dispose();
// Dispose The Bitmap
}
}
}
}
protected void GenerateMipMaps(byte[] data, bool useSoftware, bool isCompressed, int faceNum)
{
// use regular type, unless cubemap, then specify which face of the cubemap we
// are dealing with here
int type = (TextureType == TextureType.CubeMap) ? Gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceNum : GLTextureType;
if (useSoftware && MipmapCount > 0)
{
if (TextureType == TextureType.OneD)
{
Glu.gluBuild1DMipmaps(type, HasAlpha ? Gl.GL_RGBA8 : Gl.GL_RGB8, Width, GLFormat, Gl.GL_UNSIGNED_BYTE, data);
}
else if (TextureType == TextureType.ThreeD)
{
// TODO: Tao needs glTexImage3D
Gl.glTexImage3DEXT(type, 0, HasAlpha ? Gl.GL_RGBA8 : Gl.GL_RGB8, SrcWidth, SrcHeight, Depth, 0, GLFormat,
Gl.GL_UNSIGNED_BYTE, data);
}
else
{
// build the mipmaps
Glu.gluBuild2DMipmaps(type, HasAlpha ? Gl.GL_RGBA8 : Gl.GL_RGB8, Width, Height, GLFormat, Gl.GL_UNSIGNED_BYTE,
data);
}
}
else
{
if (TextureType == TextureType.OneD)
{
Gl.glTexImage1D(type, 0, HasAlpha ? Gl.GL_RGBA8 : Gl.GL_RGB8, Width, 0, GLFormat, Gl.GL_UNSIGNED_BYTE, data);
}
else if (TextureType == TextureType.ThreeD)
{
// TODO: Tao needs glTexImage3D
Gl.glTexImage3DEXT(type, 0, HasAlpha ? Gl.GL_RGBA8 : Gl.GL_RGB8, SrcWidth, SrcHeight, Depth, 0, GLFormat,
Gl.GL_UNSIGNED_BYTE, data);
}
else
{
if (isCompressed && Root.Instance.RenderSystem.Capabilities.HasCapability(Capabilities.TextureCompressionDXT))
{
int blockSize = (Format == PixelFormat.DXT1) ? 8 : 16;
int size = ((Width + 3) / 4) * ((Height + 3) / 4) * blockSize;
// load compressed image data
Gl.glCompressedTexImage2DARB(type, 0, GLFormat, SrcWidth, SrcHeight, 0, size, data);
}
else
{
Gl.glTexImage2D(type, 0, HasAlpha ? Gl.GL_RGBA8 : Gl.GL_RGB8, Width, Height, 0, GLFormat, Gl.GL_UNSIGNED_BYTE,
data);
}
}
}
}
private void loadTexture(String t, int index)
{
String s = "textures/" + t;
Bitmap bitmap = new Bitmap(s);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, textures[index]);
BitmapData data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA, bitmap.Width, bitmap.Height, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, data.Scan0);
bitmap.UnlockBits(data);
}
/// <summary>
/// Load bitmaps and convert to textures.
/// </summary>
/// <returns>
/// <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
private static bool LoadGLTextures()
{
bool status = false; // Status Indicator
Bitmap[] textureImage = new Bitmap[2]; // Create Storage Space For The Texture
textureImage[0] = LoadBMP("NeHe.Lesson23.BG.bmp");
textureImage[1] = LoadBMP("NeHe.Lesson23.Reflect.bmp");
// Check For Errors, If Bitmap's Not Found, Quit
if (textureImage[0] != null && textureImage[1] != null)
{
status = true; // Set The Status To True
Gl.glGenTextures(6, texture); // Create Three Textures
for (int loop = 0; loop <= 1; loop++) // Loop Through All 3 Textures
// Flip The Bitmap Along The Y-Axis
{
textureImage[loop].RotateFlip(RotateFlipType.RotateNoneFlipY);
// Rectangle For Locking The Bitmap In Memory
Rectangle rectangle = new Rectangle(0, 0, textureImage[loop].Width, textureImage[loop].Height);
// Get The Bitmap's Pixel Data From The Locked Bitmap
BitmapData bitmapData = textureImage[loop].LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
// Create Nearest Filtered Texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[loop]); // Gen Tex 0 and 1
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_NEAREST);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, textureImage[loop].Width, textureImage[loop].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
// Create Linear Filtered Texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[loop + 2]); // Gen Tex 2 and 3
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, textureImage[loop].Width, textureImage[loop].Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
// Create MipMapped Texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[loop + 4]); // Gen Tex 4 and 5
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB8, textureImage[loop].Width, textureImage[loop].Height, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
if (textureImage[loop] != null) // If Texture Exists
{
textureImage[loop].UnlockBits(bitmapData); // Unlock The Pixel Data From Memory
textureImage[loop].Dispose(); // Dispose The Bitmap
}
}
}
return(status); // Return The Status
}
private Textura CargarTexturaDeArchivo(string nombreArchivo)
{
Gl.glEnable(Gl.GL_BLEND);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
if (!System.IO.File.Exists(nombreArchivo))
{
throw new System.IO.FileNotFoundException("No se encontro el archivo", nombreArchivo);
}
Bitmap image = new Bitmap(nombreArchivo);
int[] textureId = new int[1];
Gl.glGenTextures(1, textureId);
image.RotateFlip(RotateFlipType.RotateNoneFlipY);
Rectangle rectangle = new Rectangle(0, 0, image.Width, image.Height);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, textureId[0]);
BitmapData bitmapData;
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_CLAMP);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_CLAMP);
//Gl.glTexParameterfv(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_BORDER_COLOR, new float[] { 0, 0, 0, 0 });
if (image.PixelFormat == PixelFormat.Format32bppArgb)
{
bitmapData = image.LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA8, image.Width, image.Height, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA8, image.Width, image.Height, 0, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
}
else
{
bitmapData = image.LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB8, image.Width, image.Height, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB8, image.Width, image.Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
}
image.UnlockBits(bitmapData);
return(new Textura(textureId[0], nombreArchivo, image));;
}
/// <summary>
/// This method performs a low level load of a texture
/// </summary>
static int TextureOne(string s, int i, int[] texture)
{
Bitmap bitmap = new Bitmap(s);
Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
BitmapData bitmapData = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
//esto es para asegurar que no se mueva del lugar de memoria el bitmap.
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[i]);
if (ContentManager.IsAnisotropic(s) && maximumAnisotropy > 0)
{
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_ANISOTROPY_EXT, maximumAnisotropy); // anisotropic Filtered
}
else
{
EnableFiltering(textFiltering, TexureSize.NPOT);
}
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, 3, bitmap.Width, bitmap.Height, Gl.GL_BGR_EXT, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
// este codigo es si quiero diferenciar que las texturas NPOT se
//cargen con mimapping y las POT(Power Of Two) normalmente
/*
* if (bitmap.Width != bitmap.Height || Math.Log(bitmap.Width, 2) - (int)Math.Log(bitmap.Width, 2) != 0)
* {
* if (EngineContent.IsAnisotropic(s) && maximumAnisotropy > 0)
* Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_ANISOTROPY_EXT, maximumAnisotropy); // anisotropic Filtered
* else
* EnableFiltering(textFiltering, TexureSize.NPOT);
*
* Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, (int)Gl.GL_RGB8, bitmap.Width, bitmap.Height, Gl.GL_BGR_EXT, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
* }
* else
* {
* if (EngineContent.IsAnisotropic(s) && maximumAnisotropy > 0)
* Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_ANISOTROPY_EXT, maximumAnisotropy); // anisotropic Filtered
* else
* EnableFiltering(textFiltering, TexureSize.POT);
*
* Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, 3, bitmap.Width, bitmap.Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
* }
*/
bitmap.UnlockBits(bitmapData);
bitmap.Dispose();
return(texture[i]);
}
public BasicTexture(Pixmap pixmap, TextureFilter textureFilter)
{
int[] TempGL = new int[1];
Gl.glGenTextures(1, TempGL);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, TempGL[0]);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, pixmap.Bpp, pixmap.Width, pixmap.Height, pixmap.getFormat(), Gl.GL_UNSIGNED_BYTE, pixmap.Data);
textureID = TempGL[0];
this.textureFilter = textureFilter;
width = pixmap.Width;
height = pixmap.Height;
}
public TextureObject(string bitmapFilepath, int textureNumberToOverwrite)
{
m_filepath = Path.GetFileName(bitmapFilepath);
System.Diagnostics.Debug.WriteLine("Currently generating texture from file: " + bitmapFilepath);
//Load the bitmap into memory
Bitmap currentBitmap = new Bitmap(bitmapFilepath);
currentBitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
//Create locked storage space for image data
Rectangle imageStorageSpace = new Rectangle(0, 0, currentBitmap.Width, currentBitmap.Height);
//Populate storage space
BitmapData currentBitmapData = new BitmapData();
currentBitmapData = currentBitmap.LockBits(imageStorageSpace, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
//Overwrite current texture ID
m_textureID = textureNumberToOverwrite;
Gl.glBindTexture(Gl.GL_TEXTURE_2D, m_textureID);
//Enable hardware generation of all mipmap levels
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_GENERATE_MIPMAP, Gl.GL_TRUE);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_R, Gl.GL_REPEAT);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 10, Gl.GL_RGB, currentBitmap.Width, currentBitmap.Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, currentBitmapData.Scan0);
//Use maximum Anisotropic filtering if available
if (((string)Gl.glGetString(Gl.GL_EXTENSIONS)).Contains("GL_EXT_texture_filter_anisotropic"))
{
float maxAnisotropy;
Gl.glGetFloatv(Gl.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, out maxAnisotropy);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
}
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB, currentBitmap.Width, currentBitmap.Height, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, currentBitmapData.Scan0);
currentBitmap.UnlockBits(currentBitmapData);
currentBitmap.Dispose();
}
public static void MakeTexture()
{
int i, j;
if (!texturesBuilt)
{
texturesBuilt = true;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
if (i == 7 && j == 7)
{
AverageLastAndFirstTextures();
}
else
{
MakeSmallTexture();
}
CopySmallTextureToBigTexture(i * 32, j * 32);
}
}
}
//example http://nemerle.org/svn/nemerle/trunk/snippets/opengl/sdlopengl4.n
Gl.glPixelStorei(Gl.GL_UNPACK_ALIGNMENT, 1);
Gl.glGenTextures(1, theTexture); //TODO Check if it's alright
Gl.glBindTexture(Gl.GL_TEXTURE_2D, theTexture[0]);
// Set the tiling mode (this is generally always GL_REPEAT).
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
// Set the filtering.
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, 2, 256, 256, Gl.GL_LUMINANCE_ALPHA, Gl.GL_UNSIGNED_BYTE, bigTextureArray);
Gl.glTexEnvf(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_MODULATE);
}
public LightMapTexture(List <Light> lights, Vector3f center, Vector3f frontVector, Vector3f rightVector, int textureSize, float realSize)
{
size = textureSize;
int halfSize = size / 2;
float halfRealSize = realSize / 2.0f;
System.Collections.Generic.List <float> data = new System.Collections.Generic.List <float>();
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
float x = halfRealSize * ((float)(halfSize - i) / (float)halfSize);
float y = halfRealSize * ((float)(halfSize - j) / (float)halfSize);
Vector3f v = frontVector * y + rightVector * x;
v.add(center);
float r, g, b;
r = g = b = 0.0f;
for (int l = 0; l < lights.Count; l++)
{
Color4f color = lights[l].calculateColor(v);
r += color.r;
g += color.g;
b += color.b;
}
r = r > 1.0f ? 1.0f : r;
g = g > 1.0f ? 1.0f : g;
b = b > 1.0f ? 1.0f : b;
data.Add(r);
data.Add(g);
data.Add(b);
}
}
int[] TempGL = new int[1];
Gl.glGenTextures(1, TempGL);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, TempGL[0]);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, 3, size, size, Gl.GL_RGB, Gl.GL_FLOAT, data.ToArray());
textureID = TempGL[0];
}
public void BindTexture()
{
if (texId == 0)
{
//Gl.glGenTextures(1, new int[] { texId });
int[] textureAr = new int[1];
Gl.glGenTextures(1, textureAr);
texId = textureAr[0];
}
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texId);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
int err = Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB, 128, 128, Gl.GL_RGB, Gl.GL_UNSIGNED_BYTE, map);
if (err != 0)
{
EngineLog.Get().Error("Error binding texture (" + texId + "): " + Glu.gluErrorString(err), ToString());
}
}
public static int CreateTexture(string filename)
{
int res;
PBitmap pBitmap = new PBitmap("textures\\" + filename);
Gl.glGenTextures(1, out res);
Gl.glPixelStorei(Gl.GL_UNPACK_ALIGNMENT, 1);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, res);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, 3, pBitmap.Width, pBitmap.Height, Gl.GL_RGB, Gl.GL_UNSIGNED_BYTE, pBitmap.data);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
pBitmap = null;
return(res);
}
int LoadImageToOpenGl(Image image)
{
width = image.Width;
height = image.Height;
LogFile.GetInstance().WriteLine("loading texture " + filename + " width: " + width + " height: " + height);
alphadata = new byte[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
alphadata[x, y] = image.GetAlpha(x, y);
}
}
//int m_TextureWidth = NextPowerOfTwo(m_Width);
//int m_TextureHeight = NextPowerOfTwo(m_Height);
//if ((m_TextureWidth != m_Width) || (m_TextureHeight != m_Height))
// Ilu.iluEnlargeCanvas(m_TextureWidth, m_TextureHeight, m_Depth);
//Ilu.iluFlipImage();
int m_TextureID;
Gl.glGenTextures(1, out m_TextureID);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, m_TextureID);
//Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST);
//Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_NEAREST);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, m_BytesPerPixel, m_TextureWidth,
// m_TextureHeight, 0, m_Format, Gl.GL_UNSIGNED_BYTE, dataptr );
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA8, width, height,
Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, image.data);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
return(m_TextureID);
// from devil.net version of this function:
//Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA8, bitmap.Width, bitmap.Height, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, data);
//Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
}
public void LoadTexture(string filename, TextureName name)
{
var texture = new TextureImage();
if (!Il.ilLoadImage(filename))
{
throw new Exception("Cann't load texture image!");
}
texture.Width = Il.ilGetInteger(Il.IL_IMAGE_WIDTH);
texture.Height = Il.ilGetInteger(Il.IL_IMAGE_HEIGHT);
texture.BitePerPixel = Il.ilGetInteger(Il.IL_IMAGE_BYTES_PER_PIXEL);
texture.Image = Il.ilGetData();
Il.ilEnable(Il.IL_CONV_PAL);
int type = Il.ilGetInteger(Il.IL_IMAGE_FORMAT);
int imageId;
Gl.glGenTextures(1, out imageId);
texture.Id = imageId;
Gl.glBindTexture(Gl.GL_TEXTURE_2D, imageId);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, texture.BitePerPixel, texture.Width, texture.Height, type,
Gl.GL_UNSIGNED_BYTE, texture.Image);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB, texture.Width, texture.Height, 0,
// texture.BitePerPixel == 24 ? Gl.GL_RGB : Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE,
// texture.Image);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
TextureImages.Add(name, texture);
Il.ilDeleteImages(1, ref imageId);
}
private void formTextures()
{
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glTexEnvi(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_DECAL); // nacin stapanja
// Ucitaj slike i kreiraj teksture
Gl.glGenTextures(m_textureCount, m_textures);
for (int i = 0; i < m_textureCount; ++i)
{
// Pridruzi teksturu odgovarajucem identifikatoru
Gl.glBindTexture(Gl.GL_TEXTURE_2D, m_textures[i]);
// Ucitaj sliku i podesi parametre teksture
Bitmap image = new Bitmap(RootDirectory + m_textureFiles[i]);
// rotiramo sliku zbog koordinantog sistema opengl-a
image.RotateFlip(RotateFlipType.RotateNoneFlipY);
Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
// RGBA format (dozvoljena providnost slike tj. alfa kanal)
BitmapData imageData = image.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly,
System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, (int)Gl.GL_RGBA8, image.Width, image.Height, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, imageData.Scan0);
// nacin filtrianja NEAREST
//Gl.glTexParameteri((int)Gl.GL_TEXTURE_2D, (int)Gl.GL_TEXTURE_MIN_FILTER, (int)Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri((int)Gl.GL_TEXTURE_2D, (int)Gl.GL_TEXTURE_MIN_FILTER, (int)Gl.GL_NEAREST_MIPMAP_NEAREST);
Gl.glTexParameteri((int)Gl.GL_TEXTURE_2D, (int)Gl.GL_TEXTURE_MAG_FILTER, (int)Gl.GL_NEAREST_MIPMAP_NEAREST);
// wrapping GL_REPEAT po obema osama
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
image.UnlockBits(imageData);
image.Dispose();
}
m_terrain.Textures = m_textures; // prosledi u ostale klase nove teksture...
m_hangar.Textures = m_textures;
}
protected void LoadGLTextures(ref int texture, Bitmap textureImage)
{
// Rectangle For Locking The Bitmap In Memory
Rectangle rectangle = new Rectangle(0, 0, textureImage.Width, textureImage.Height);
// Get The Bitmap's Pixel Data From The Locked Bitmap
//BitmapData bitmapData = textureImage.LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
BitmapData bitmapData = textureImage.LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
// Create Linear Filtered Texture
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGB, textureImage.Width, textureImage.Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
//Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA, textureImage.Width, textureImage.Height, 0, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
// これを使うと2のｎ乗でないサイズの画像も読める
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGBA, textureImage.Width, textureImage.Height, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
if (textureImage != null)
{ // If Texture Exists
textureImage.UnlockBits(bitmapData); // Unlock The Pixel Data From Memory
}
}
private void textureToolStripMenuItem_Click(object sender, EventArgs e)
{
picTexture.Image = null;
TexturePointers[0] = 0;
OpenFileDialog dialog = new OpenFileDialog();
if (dialog.ShowDialog() == DialogResult.OK)
{
try
{
picTexture.Image = System.Drawing.Image.FromFile(dialog.FileName);
Bitmap bitmap = new Bitmap(picTexture.Image);
bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
// Create the GL texture space
Gl.glGenTextures(1, TexturePointers);
Rectangle rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
BitmapData bitmapData = bitmap.LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, TexturePointers[0]);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_CLAMP_TO_EDGE);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_CLAMP_TO_EDGE);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_GENERATE_MIPMAP, Gl.GL_TRUE);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB8, bitmap.Width, bitmap.Height, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
bitmap.UnlockBits(bitmapData);
bitmap.Dispose();
}
catch (Exception ex)
{
MessageBox.Show("Failed to load image from file " + dialog.FileName + ": " + ex.Message);
}
}
}
/// <summary>
/// Load bitmaps and convert to textures.
/// </summary>
/// <returns>
/// <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
private static bool LoadGLTextures()
{
bool status = false; // Status Indicator
Bitmap[] textureImage = new Bitmap[1]; // Create Storage Space For The Texture
textureImage[0] = LoadBMP("NeHe.Lesson15.Lights.bmp"); // Load The Bitmap
// Check For Errors, If Bitmap's Not Found, Quit
if (textureImage[0] != null)
{
status = true; // Set The Status To True
Gl.glGenTextures(1, texture); // Create The Texture
textureImage[0].RotateFlip(RotateFlipType.RotateNoneFlipY); // Flip The Bitmap Along The Y-Axis
// Rectangle For Locking The Bitmap In Memory
Rectangle rectangle = new Rectangle(0, 0, textureImage[0].Width, textureImage[0].Height);
// Get The Bitmap's Pixel Data From The Locked Bitmap
BitmapData bitmapData = textureImage[0].LockBits(rectangle, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
// Typical Texture Generation Using Data From The Bitmap
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[0]);
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB8, textureImage[0].Width, textureImage[0].Height, Gl.GL_RGB, Gl.GL_UNSIGNED_BYTE, bitmapData.Scan0);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST);
Gl.glTexGeni(Gl.GL_S, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_OBJECT_LINEAR);
Gl.glTexGeni(Gl.GL_T, Gl.GL_TEXTURE_GEN_MODE, Gl.GL_OBJECT_LINEAR);
Gl.glEnable(Gl.GL_TEXTURE_GEN_S);
Gl.glEnable(Gl.GL_TEXTURE_GEN_T);
if (textureImage[0] != null) // If Texture Exists
{
textureImage[0].UnlockBits(bitmapData); // Unlock The Pixel Data From Memory
textureImage[0].Dispose(); // Dispose The Bitmap
}
}
return(status); // Return The Status
}
public static void loadRings()
{
int ringsWidth = 0;
//System.IO.FileInfo FileProps = new System.IO.FileInfo("C:\\Documents and Settings\\rprasad\\My Documents\\Visual Studio 2005\\Projects\\WISP Demo Application\\rings.dat");
System.IO.FileInfo FileProps = new System.IO.FileInfo("rings.dat");
//System.IO.BinaryReader reader = new System.IO.BinaryReader(System.IO.File.OpenRead("rings.dat"));
System.IO.BinaryReader reader = null;
try
{
reader = new System.IO.BinaryReader(System.IO.File.OpenRead("rings.dat"));
}
catch (Exception e)
{
Trace.WriteLine("couldn't find graphics files");
MessageBox.Show("Couldn't find rings.dat or saturn.jpg", "Saturn Stage",
MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
}
if (reader == null)
{
return;
}
//Open App.Path & "\rings.dat" For Binary As #1
ringsWidth = (int)FileProps.Length / 2; //half of data is alpha info
// ReDim rings((ringsWidth*2)-1) As Byte
byte[] rings = new byte[(ringsWidth * 2)];
// Get #1, , rings()
rings = reader.ReadBytes((ringsWidth * 2) - 1);
reader.Close();
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, 4, ringsWidth, 1, Gl.GL_LUMINANCE_ALPHA, Gl.GL_UNSIGNED_BYTE, rings);
}
