/// <summary> /// Creates a openTk texture /// </summary> /// <param name="text">Texture bitmap</param> /// <param name="min">OpenGL Texture filtering tipe (Nearest for blocky, linear for fuzzy)</param> /// <param name="mag">OpenGL Texture filtering tipe (Nearest for blocky, linear for fuzzy)</param> public Texture(Image text, TextureMinFilter min, TextureMagFilter mag) { Handle = GL.GenTexture(); Use(); using (var image = new Bitmap(text)) { var data = image.LockBits( new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, image.Width, image.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0); } GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)min); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)mag); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); GL.GenerateMipmap(GenerateMipmapTarget.Texture2D); }
/// <summary> /// Loads an image. /// </summary> /// <returns>The OpenGL ID representing the image.</returns> /// <param name="bmp">The Bitmap representing the image.</param> /// <param name="square">A value indicating whether the image is a power of two texture.</param> /// <param name="tmin">The required minimization filter.</param> /// <param name="tmag">The required maximalization filter.</param> public static int LoadImage(Bitmap bmp, bool square, TextureMinFilter tmin, TextureMagFilter tmag) { BitmapData bmpData = bmp.LockBits( new System.Drawing.Rectangle(Point.Empty, bmp.Size), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb ); int result; TextureTarget target = (square ? TextureTarget.Texture2D : TextureTarget.TextureRectangle); try { GL.GenTextures(1, out result); GL.BindTexture(target, result); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)tmag); GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)tmin); GL.TexImage2D( target, 0, PixelInternalFormat.Rgba, bmp.Width, bmp.Height, 0, Pencil.Gaming.Graphics.PixelFormat.Bgra, PixelType.UnsignedByte, bmpData.Scan0 ); GL.BindTexture(target, 0); } finally { bmp.UnlockBits(bmpData); } return(result); }
public Texture(Bitmap bmp, int xTiles, int yTiles, TextureMinFilter minFilter, TextureMagFilter magFilter, TextureWrapMode wrapS, TextureWrapMode wrapT) { this.bmp = bmp; this.xSize = bmp.Width; this.ySize = bmp.Height; this.xTiles = xTiles; this.yTiles = yTiles; if (xTiles == 0 || yTiles == 0) { this.xPixels = xSize; this.yPixels = ySize; } else { this.xPixels = xSize / xTiles; this.yPixels = ySize / yTiles; } this.minFilter = minFilter; this.magFilter = magFilter; this.wrapS = wrapS; this.wrapT = wrapT; offsetX = 1.0f / (float)(2 * xSize); offsetY = 1.0f / (float)(2 * ySize); Load(); }
/// <summary> /// Creates a texture on the GPU with the chosen parameters /// </summary> /// <param name="bitmapBlock"></param> /// <param name="textureMagFilter"></param> /// <param name="textureMinFilter"></param> public void Load(BitmapDataBlock bitmapBlock, TextureMagFilter textureMagFilter = TextureMagFilter.Linear, TextureMinFilter textureMinFilter = TextureMinFilter.Linear) { var buffer = bitmapBlock.GetResourceData( ); if (buffer == null) { return; } var width = bitmapBlock.Width; var height = bitmapBlock.Height; var bytesPerPixel = GetBitSize(bitmapBlock.Format) / 8.0f; if (bitmapBlock.BitmapDataFlags.HasFlag(BitmapDataBlock.Flags.Palettized)) { LoadPalettedTexture(bitmapBlock, P8ColourBytes, textureMagFilter, textureMinFilter); return; } if (bitmapBlock.BitmapDataFlags.HasFlag(BitmapDataBlock.Flags.Swizzled)) { buffer = Swizzler.Swizzle(buffer, ( int )bytesPerPixel, width, height); } var pixelInternalFormat = GetPixelInternalFormat(bitmapBlock.Format); switch (bitmapBlock.Type) { case BitmapDataBlock.TypeEnum.Texture2D: { LoadTexture2D(textureMagFilter, textureMinFilter, bytesPerPixel, width, height, buffer, bitmapBlock, pixelInternalFormat); } break; case BitmapDataBlock.TypeEnum.Cubemap: { LoadCubemap(textureMagFilter, textureMinFilter, bytesPerPixel, width, height, buffer, bitmapBlock, pixelInternalFormat); } break; case BitmapDataBlock.TypeEnum.Texture3D: { LoadTexture2D(textureMagFilter, textureMinFilter, bytesPerPixel, width, height, buffer, bitmapBlock, pixelInternalFormat); } break; default: { GL.DeleteTexture(_handle); } break; } }
public Texture2D(TextureNativeSectionData tex) : base(TextureTarget.Texture2D) { Width = tex.Width; Height = tex.Height; WrapModeU = FindWrapMode(tex.WrapU); WrapModeV = FindWrapMode(tex.WrapV); InternalFormat = FindInternalFormat(tex.Compression, tex.Format); ExternalFormat = FindExternalFormat(tex.Compression, tex.Format); Compressed = tex.Compression != TextureNativeSectionData.CompressionMode.None; Alpha = tex.Alpha; MinFilter = FindMinFilter(tex.FilterFlags); MipMapCount = 1; // tex.MipMapCount; ContainsMipMaps = (tex.Format & TextureNativeSectionData.RasterFormat.ExtMipMap) != 0; GenerateMipMaps = true; // ( tex.Format & TextureNativeSectionData.RasterFormat.ExtAutoMipMap ) != 0; ImageLevelSizes = new int[MipMapCount]; for (int i = 0; i < MipMapCount; ++i) { ImageLevelSizes[i] = FindImageDataSize(Width >> i, Height >> i, tex.Compression, tex.Format); } ImageLevelData = new byte[MipMapCount][]; for (int i = 0; i < MipMapCount; ++i) { ImageLevelData[i] = tex.ImageLevelData[i]; } }
public Texture(Bitmap bitmap, TextureMinFilter minFilter = TextureMinFilter.Linear, TextureMagFilter magFilter = TextureMagFilter.Nearest, TextureWrapMode wrapS = TextureWrapMode.ClampToBorderSgis, TextureWrapMode wrapT = TextureWrapMode.ClampToBorderSgis) { int textureID; GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest); GL.GenTextures(1, out textureID); GL.BindTexture(TextureTarget.Texture2D, textureID); GL.Ext.GenerateMipmap(GenerateMipmapTarget.Texture2D); BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, data.Width, data.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0); bitmap.UnlockBits(data); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)wrapS); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)wrapT); GL.BindTexture(TextureTarget.Texture2D, 0); this.textureID = textureID; Width = bitmap.Width; Height = bitmap.Height; }
/// <summary> /// Initializes a new instance of the Texture class. Generates and stores a bitmap in VRAM. /// </summary> /// <param name="bmp">The bitmap to be copied to VRAM.</param> /// <param name="minFilter">A filter applied when the rendered texture is smaller than the texture at 100%.</param> /// <param name="magFilter">A filter applied when the rendered texture is larger than the texture at 100%.</param> /// <param name="wrapS">The way OpenGL will handle texture coordinates larger than <c>1.0f</c> on the S axis (X axis).</param> /// <param name="wrapT">The way OpenGL will handle texture coordinates larger than <c>1.0f</c> on the T axis (Y axis).</param> public Texture(Bitmap bmp, TextureMinFilter minFilter, TextureMagFilter magFilter, TextureWrapMode wrapS, TextureWrapMode wrapT) { this.Size = bmp.Size; //Generate a new texture ID ID = GL.GenTexture(); //Texture parameters MinFilter = minFilter; MagFilter = magFilter; WrapS = wrapS; WrapT = wrapT; //Bind texture GL.BindTexture(TextureTarget.Texture2D, ID); //Send bitmap data up to VRAM bmp.RotateFlip(RotateFlipType.RotateNoneFlipY); BitmapData bmpData = bmp.LockBits(new Rectangle(new Point(0, 0), Size), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, Size.Width, Size.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, bmpData.Scan0); bmp.UnlockBits(bmpData); //unbind texture GL.BindTexture(TextureTarget.Texture2D, 0); }
//Create texture from bitmap. public Texture(Bitmap bitmap, TextureUnit unit = TextureUnit.Texture0, TextureMinFilter minFilter = TextureMinFilter.Linear, TextureMagFilter magFilter = TextureMagFilter.Nearest) { //Generate handle this.Handle = GL.GenTexture(); //Bind the handle this.Use(unit); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); byte[] pixelData; var image = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); this.Size = new Size(image.Width, image.Height); pixelData = new byte[Math.Abs(image.Stride * image.Height)]; Marshal.Copy(image.Scan0, pixelData, 0, pixelData.Length); bitmap.UnlockBits(image); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, this.Width, this.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, pixelData); this.Loaded = true; }
public Texture Find(string file, TextureMagFilter magFilter, TextureMinFilter minFilter, TextureWrapMode wrapModeS, TextureWrapMode wrapModeT) { try { string key = string.Format("{0}:{1}:{2}:{3}:{4}", file, magFilter, minFilter, wrapModeS, wrapModeT); Texture texture; if(textures.TryGetValue(key, out texture))return texture; TextureLoaderParameters.MagnificationFilter = magFilter; TextureLoaderParameters.MinificationFilter = minFilter; TextureLoaderParameters.WrapModeS = wrapModeS; TextureLoaderParameters.WrapModeT = wrapModeT; uint handle; TextureTarget dimension; ImageDDS.LoadFromDisk(file, out handle, out dimension); texture = new Texture(handle); textures[key]=texture; return texture; } catch { Console.WriteLine(string.Format("TextureManager: Failed to load texture {0}", file)); return new Texture(0); // TODO remove } }
public TextureParamPack() { MagFilter = TextureMagFilter.Nearest; MinFilter = TextureMinFilter.Nearest; WrapS = TextureWrapMode.ClampToEdge; WrapT = TextureWrapMode.ClampToEdge; }
/// <summary> /// Load an image file to GPU memory. /// </summary> /// <param name="name">New texture name</param> /// <param name="path">Path of the image source</param> /// <param name="textureMinFilter">Texture filtering: min</param> /// <param name="textureMagFilter">Texture filtering: max</param> public static void AddTexture(string name, string path, TextureMinFilter textureMinFilter, TextureMagFilter textureMagFilter) { try { if(String.IsNullOrEmpty(path)) { throw new ArgumentException("Invalid path"); } if(String.IsNullOrEmpty(name)) { throw new ArgumentException("Invalid name"); } int mTexBuffer = GL.GenTexture(); GL.BindTexture(TextureTarget.Texture2D, mTexBuffer); Bitmap image = new Bitmap(path); BitmapData imageData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, imageData.Width, imageData.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, imageData.Scan0); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)textureMinFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)textureMagFilter); image.UnlockBits(imageData); mTexCache.Add(name, mTexBuffer); } catch(Exception exception) { Console.WriteLine("WARNING: failed to load texture " + name + " at " + path + ": " + exception.Message); } }
public void SetFilter(TextureMagFilter magFilter, TextureMinFilter minFilter) { Bind(); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter); Unbind(); }
public static int CreateGLTexture(Bitmap texture, int mipMapLevel, int inTextureNum = 0, TextureMagFilter magFilter = TextureMagFilter.Nearest, TextureMinFilter minFilter = TextureMinFilter.Nearest) { var bitmapData = texture.LockBits(new Rectangle(0, 0, texture.Width, texture.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); int textureNum; if (mipMapLevel == 0) { GL.GenTextures(1, out textureNum); } else { textureNum = inTextureNum; } GL.BindTexture(TextureTarget.Texture2D, textureNum); GL.TexImage2D(TextureTarget.Texture2D, mipMapLevel, PixelInternalFormat.Rgba, bitmapData.Width, bitmapData.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, bitmapData.Scan0); if (mipMapLevel == 0) { GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter); } texture.UnlockBits(bitmapData); return(textureNum); }
public void setMinMagFilters(TextureMinFilter min, TextureMagFilter mag) { bind(); GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)min); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)mag); unbind(); }
private void LoadBitmap(Bitmap bitmap, bool disposeBitmap, TextureMinFilter minFilter, TextureMagFilter magFilter) { int texId; GL.GenTextures(1, out texId); Id = texId; GL.BindTexture(TextureTarget.Texture2D, Id); Width = bitmap.Width; Height = bitmap.Height; var data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, data.Width, data.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0); bitmap.UnlockBits(data); if (disposeBitmap) { bitmap.Dispose(); } bitmap = null; GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); GL.BindTexture(TextureTarget.Texture2D, 0); }
/// <summary> /// This method ensures that only 1 sampler id is created for each needed combination of parameters. /// </summary> /// <param name="texture"></param> /// <param name="borderColor"></param> /// <param name="minFilter"></param> /// <param name="magFilter"></param> /// <param name="lodMin"></param> /// <param name="lodMax"></param> /// <param name="lodBias"></param> /// <param name="wrapS"></param> /// <param name="wrapT"></param> /// <param name="wrapR"></param> /// <returns></returns> public static Sampler Create(Texture texture = null, Color4 borderColor = default(Color4), TextureMinFilter minFilter = TextureMinFilter.NearestMipmapLinear, TextureMagFilter magFilter = TextureMagFilter.Linear, float lodMin = -1000, float lodMax = 1000, float lodBias = 0, TextureWrapMode wrapS = TextureWrapMode.Repeat, TextureWrapMode wrapT = TextureWrapMode.Repeat, TextureWrapMode wrapR = TextureWrapMode.Repeat) { Sampler sampler = FindOrCreateSampler(borderColor, minFilter, magFilter, lodMin, lodMax, lodBias, wrapS, wrapT, wrapR); sampler.Texture = texture; return(sampler); }
public Texture2D( TextureNativeSectionData tex ) : base(TextureTarget.Texture2D) { Width = tex.Width; Height = tex.Height; WrapModeU = FindWrapMode( tex.WrapU ); WrapModeV = FindWrapMode( tex.WrapV ); InternalFormat = FindInternalFormat( tex.Compression, tex.Format ); ExternalFormat = FindExternalFormat( tex.Compression, tex.Format ); Compressed = tex.Compression != TextureNativeSectionData.CompressionMode.None; Alpha = tex.Alpha; MinFilter = FindMinFilter( tex.FilterFlags ); MipMapCount = 1; // tex.MipMapCount; ContainsMipMaps = ( tex.Format & TextureNativeSectionData.RasterFormat.ExtMipMap ) != 0; GenerateMipMaps = true; // ( tex.Format & TextureNativeSectionData.RasterFormat.ExtAutoMipMap ) != 0; ImageLevelSizes = new int[ MipMapCount ]; for ( int i = 0; i < MipMapCount; ++i ) ImageLevelSizes[ i ] = FindImageDataSize( Width >> i, Height >> i, tex.Compression, tex.Format ); ImageLevelData = new byte[ MipMapCount ][]; for ( int i = 0; i < MipMapCount; ++i ) ImageLevelData[ i ] = tex.ImageLevelData[ i ]; }
internal Sampler(GraphicsDevice graphicsDevice, SamplerInfo info) : base(graphicsDevice, new System.Diagnostics.StackTrace(1)) { Info = info; if ((Info.MagFilter == TextureFilter.Anisotropic || Info.MinFilter == TextureFilter.Anisotropic) && (!graphicsDevice.OpenGLCapabilities.SupportsAnisotropicFiltering || Info.MaximumAnisotropy > graphicsDevice.OpenGLCapabilities.MaxAnisotropicFiltering)) { throw new PlatformNotSupportedException("Anisotropic filtering is not supported at that level or at all."); } if (Info.MaximumAnisotropy == 0 && (Info.MagFilter == TextureFilter.Anisotropic || Info.MinFilter == TextureFilter.Anisotropic)) { throw new ArgumentException("MaximumAnisotropy must not be 0"); } if (Info.MipLodBias > graphicsDevice.OpenGLCapabilities.MaxTextureLoDBias) { throw new PlatformNotSupportedException("MipLoDBias is higher than max lod bias."); } SamplerID = GL.GenSampler(); //AddressMode GL.SamplerParameter(SamplerID, SamplerParameterName.TextureWrapS, (float)EnumConverter.Convert(Info.AddressU)); GL.SamplerParameter(SamplerID, SamplerParameterName.TextureWrapT, (float)EnumConverter.Convert(Info.AddressV)); GL.SamplerParameter(SamplerID, SamplerParameterName.TextureWrapR, (float)EnumConverter.Convert(Info.AddressW)); graphicsDevice.CheckGLError(); //Filtering Tuple <TextureMinFilter, TextureMagFilter> filter = EnumConverter.Convert(Info.MinFilter, Info.MagFilter, Info.MipFilter); TextureMinFilter min = (TextureMinFilter)filter.Item1; TextureMagFilter mag = (TextureMagFilter)filter.Item2; GL.SamplerParameter(SamplerID, SamplerParameterName.TextureMinFilter, (float)min); GL.SamplerParameter(SamplerID, SamplerParameterName.TextureMagFilter, (float)mag); GL.SamplerParameter(SamplerID, SamplerParameterName.TextureMaxAnisotropyExt, Info.MaximumAnisotropy); //Border color GL.SamplerParameter(SamplerID, SamplerParameterName.TextureBorderColor, new float[] { Info.BorderColor.R, Info.BorderColor.G, Info.BorderColor.B, Info.BorderColor.A }); //Compare modes if (Info.Type == SamplerType.Comparison) { GL.SamplerParameter(SamplerID, SamplerParameterName.TextureCompareMode, (float)TextureCompareMode.CompareRefToTexture); GL.SamplerParameter(SamplerID, SamplerParameterName.TextureCompareFunc, (float)EnumConverter.Convert(Info.ComparisonFunction)); } else { GL.SamplerParameter(SamplerID, SamplerParameterName.TextureCompareMode, (float)TextureCompareMode.None); } //LoD GL.SamplerParameter(SamplerID, SamplerParameterName.TextureMinLod, Info.MinimumLod); GL.SamplerParameter(SamplerID, SamplerParameterName.TextureMaxLod, Info.MaximumLod); GL.SamplerParameter(SamplerID, SamplerParameterName.TextureLodBias, Info.MipLodBias); graphicsDevice.CheckGLError(); }
public TextureParamPack(TextureMagFilter magFilter, TextureMinFilter minFilter, TextureWrapMode wrapS, TextureWrapMode wrapT) { MagFilter = magFilter; MinFilter = minFilter; WrapS = wrapS; WrapT = wrapT; }
public Texture(TextureMinFilter minFiler, TextureMagFilter magFilter) { GL.Enable(EnableCap.Texture2D); this.Location = GL.GenTexture(); SetTextureParameters(minFiler, magFilter); Other.Fixes.ApplyTextureBugFix(); }
/// <summary> /// Sets the texture min/mag filters /// </summary> /// <param name="minFilter">Min filter</param> /// <param name="magFilter">Mag filter</param> public void SetFilter(TextureMinFilter minFilter, TextureMagFilter magFilter) { this.Assert(); Bind(TextureTarget.Texture2D); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter); }
//------------------------------------------------------ // Constructor //------------------------------------------------------ public Texture(TextureTarget target, int width, int height, int depth, bool enable_mipmap, bool enable_aniso, PixelInternalFormat pif, PixelFormat pf, PixelType pt, TextureMinFilter min_filter, TextureMagFilter mag_filter, TextureWrapMode wrap_mode) : this(target, width, height, depth, enable_mipmap, enable_aniso, pif, pf, pt, min_filter, mag_filter, wrap_mode, Vector4.Zero) { }
public void SetMinMag(TextureMinFilter minFilter, TextureMagFilter magFilter) { CheckBind(); // Setup texture paramters GL.TexParameteri(TextureTarget.TextureCubeMap, TextureParameterName.TextureMinFilter, (int)minFilter); GL.TexParameteri(TextureTarget.TextureCubeMap, TextureParameterName.TextureMagFilter, (int)magFilter); }
public void SetMinFilter(TextureMinFilter textureMinFilter) { minFilter = textureMinFilter; GL.BindTexture(TextureTarget.Texture2D, handle); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)textureMinFilter); GL.BindTexture(TextureTarget.Texture2D, 0); }
public static Texture2D LoadTexture(Bitmap image, TextureMinFilter minFilter, TextureMagFilter magFilter, TextureWrapMode wrapMode) { BitmapTexture.CreateCompatible(image, out Texture2D tex, 1); tex.LoadBitmap(image, 0); tex.SetFilter(minFilter, magFilter); tex.SetWrapMode(wrapMode); return(tex); }
public void SetTextureSamplerState(bool disableLinearFiltering = false, bool allowTiling = false) { TextureMinFilter minFilter = disableLinearFiltering ? TextureMinFilter.Nearest : TextureMinFilter.Linear; TextureMagFilter magFilter = disableLinearFiltering ? TextureMagFilter.Nearest : TextureMagFilter.Linear; TextureWrapMode clampMode = allowTiling ? TextureWrapMode.Repeat : TextureWrapMode.ClampToEdge; SetSamplerState((int)minFilter, (int)magFilter, (int)clampMode); }
public Animation( TextureMinFilter minFilter, TextureMagFilter magFilter, string firstPath, params string[] paths) { m_MinFilter = minFilter; m_MagFilter = magFilter; totalPaths = new[] { firstPath }.Concat(paths); }
protected void Init(Bitmap bmp, bool mipmapped, TextureTarget target, TextureMinFilter min_filter = TextureMinFilter.Nearest, TextureMagFilter mag_filter = TextureMagFilter.Nearest) { using (new Bind(this)) { OpenTK.Graphics.OpenGL.PixelInternalFormat bmp_if; OpenTK.Graphics.OpenGL.PixelFormat bmp_pf; OpenTK.Graphics.OpenGL.PixelType bmp_pt; switch (bmp.PixelFormat) { case System.Drawing.Imaging.PixelFormat.Format24bppRgb: bmp_if = OpenTK.Graphics.OpenGL.PixelInternalFormat.Rgb8; bmp_pf = OpenTK.Graphics.OpenGL.PixelFormat.Bgr; bmp_pt = OpenTK.Graphics.OpenGL.PixelType.UnsignedByte; break; case System.Drawing.Imaging.PixelFormat.Format32bppArgb: bmp_if = OpenTK.Graphics.OpenGL.PixelInternalFormat.Rgba; bmp_pf = OpenTK.Graphics.OpenGL.PixelFormat.Bgra; bmp_pt = OpenTK.Graphics.OpenGL.PixelType.UnsignedByte; break; default: throw new NotImplementedException(); } BitmapData bmp_data = bmp.LockBits(new Rectangle(Point.Empty, bmp.Size), ImageLockMode.ReadOnly, bmp.PixelFormat); switch (target) { case TextureTarget.Texture2D: GL.TexImage2D(target, 0, bmp_if, bmp_data.Width, bmp_data.Height, 0, bmp_pf, bmp_pt, bmp_data.Scan0); break; case TextureTarget.TextureCubeMap: GL.TexImage2D(TextureTarget.TextureCubeMapPositiveX, 0, bmp_if, bmp_data.Width, bmp_data.Height, 0, bmp_pf, bmp_pt, bmp_data.Scan0); GL.TexImage2D(TextureTarget.TextureCubeMapNegativeX, 0, bmp_if, bmp_data.Width, bmp_data.Height, 0, bmp_pf, bmp_pt, bmp_data.Scan0); GL.TexImage2D(TextureTarget.TextureCubeMapPositiveY, 0, bmp_if, bmp_data.Width, bmp_data.Height, 0, bmp_pf, bmp_pt, bmp_data.Scan0); GL.TexImage2D(TextureTarget.TextureCubeMapNegativeY, 0, bmp_if, bmp_data.Width, bmp_data.Height, 0, bmp_pf, bmp_pt, bmp_data.Scan0); GL.TexImage2D(TextureTarget.TextureCubeMapPositiveZ, 0, bmp_if, bmp_data.Width, bmp_data.Height, 0, bmp_pf, bmp_pt, bmp_data.Scan0); GL.TexImage2D(TextureTarget.TextureCubeMapNegativeZ, 0, bmp_if, bmp_data.Width, bmp_data.Height, 0, bmp_pf, bmp_pt, bmp_data.Scan0); break; default: throw new NotImplementedException(); } bmp.UnlockBits(bmp_data); if (mipmapped) { GL.GenerateMipmap(GenerateMipmapTarget.Texture2D); } GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)min_filter); GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)mag_filter); GL.TexParameter(target, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge); GL.TexParameter(target, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge); GL.TexParameter(target, TextureParameterName.TextureWrapR, (int)TextureWrapMode.ClampToEdge); } }
public void SetFilter(TextureMinFilter min) { m_MinFilter = min; if (m_Id != 0) { Bind(); GL.TexParameter(m_TextureType, TextureParamName.TextureMinFilter, (int)min); } }
public Texture(MemoryStream stream, TextureMinFilter minFilter = TextureMinFilter.Linear, TextureMagFilter magFilter = TextureMagFilter.Linear) { Image <Rgba32> image = (Image <Rgba32>)Image.Load(stream.ToArray()); _minFilter = minFilter; _magFilter = magFilter; MakeTexture(image); }
public void SetParameters(TextureMinFilter minFilter = TextureMinFilter.Linear, TextureMagFilter magFilter = TextureMagFilter.Linear, TextureWrapMode wrapMode = TextureWrapMode.MirroredRepeat) { Bind(); GL.TexParameter(m_target, TextureParameterName.TextureMinFilter, (int)minFilter); GL.TexParameter(m_target, TextureParameterName.TextureMagFilter, (int)magFilter); GL.TexParameter(m_target, TextureParameterName.TextureWrapS, (int)wrapMode); GL.TexParameter(m_target, TextureParameterName.TextureWrapT, (int)wrapMode); }
public void SetMinFilter(TextureMinFilter filter) { if (minFilter == filter) { return; } GL.SamplerParameter(handle, (int)All.TextureMinFilter, (int)filter); minFilter = filter; }
/// <summary> /// Loads the texture from a file. /// </summary> /// <param name="path">The path of the texture.</param> public Texture(string path, TextureMinFilter minFilter, TextureMagFilter magFilter) { GL.Enable(EnableCap.Texture2D); this.Location = GL.GenTexture(); SetTextureParameters(minFilter, magFilter); SelectTexture(); LoadTextureFromFile(path); Other.Fixes.ApplyTextureBugFix(); }
/// <summary> /// Initializes an empty texture.. /// </summary> /// <param name="magFilter">The magnification filter.</param> /// <param name="minFiler">The min filter.</param> /// <param name="width">The width of the texture.</param> /// <param name="height">The height of the texture</param> public Texture(TextureMinFilter minFiler, TextureMagFilter magFilter, int width, int height) { GL.Enable(EnableCap.Texture2D); this.Location = GL.GenTexture(); SetTextureParameters(minFiler, magFilter); GL.BindTexture(TextureTarget.Texture2D, this.Location); EmptyTexture(width, height); Other.Fixes.ApplyTextureBugFix(); }
public Texture(IntPtr data, int width, int height, TextureMinFilter minFilter = TextureMinFilter.Linear, TextureMagFilter magFilter = TextureMagFilter.Linear) { Width = width; Height = height; _minFilter = minFilter; _magFilter = magFilter; Load(data, width, height); }
public void SetMinFilter(TextureMinFilter filter) { minFilter = filter; if (handle != 0) { GL.BindTexture(TextureTarget.Texture2D, handle); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter); GL.BindTexture(TextureTarget.Texture2D, 0); } }
public void Load(IDataNode dataNode, IResourceManager resourceManager) { _name = dataNode.ReadParameter("key"); _path = dataNode.ReadParameter("path"); _minFilter = TextureMinFilter.Linear; if (dataNode.HasParameter("minFilter")) _minFilter = (TextureMinFilter)Enum.Parse(typeof(TextureMinFilter), dataNode.ReadParameter("minFilter")); _magFilter = TextureMagFilter.Linear; if (dataNode.HasParameter("magFilter")) _magFilter = (TextureMagFilter)Enum.Parse(typeof(TextureMagFilter), dataNode.ReadParameter("magFilter")); _image = (Bitmap) System.Drawing.Image.FromFile(_path); _index = resourceManager.GetTextures().Count(); }
private SamplerState(GraphicsDevice device, SamplerStateDescription samplerStateDescription) : base(device) { Description = samplerStateDescription; textureWrapS = samplerStateDescription.AddressU.ToOpenGL(); textureWrapT = samplerStateDescription.AddressV.ToOpenGL(); textureWrapR = samplerStateDescription.AddressW.ToOpenGL(); compareFunc = samplerStateDescription.CompareFunction.ToOpenGLDepthFunction(); borderColor = samplerStateDescription.BorderColor.ToArray(); // TODO: How to do MipLinear vs MipPoint? switch (samplerStateDescription.Filter) { case TextureFilter.ComparisonMinMagLinearMipPoint: case TextureFilter.MinMagLinearMipPoint: minFilter = TextureMinFilter.Linear; magFilter = TextureMagFilter.Linear; break; case TextureFilter.Anisotropic: case TextureFilter.Linear: minFilter = TextureMinFilter.LinearMipmapLinear; magFilter = TextureMagFilter.Linear; break; case TextureFilter.MinPointMagMipLinear: case TextureFilter.ComparisonMinPointMagMipLinear: minFilter = TextureMinFilter.NearestMipmapLinear; magFilter = TextureMagFilter.Linear; break; case TextureFilter.Point: minFilter = TextureMinFilter.Nearest; magFilter = TextureMagFilter.Nearest; break; default: throw new NotImplementedException(); } #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES // On OpenGL ES, we need to choose the appropriate min filter ourself if the texture doesn't contain mipmaps (done at PreDraw) minFilterNoMipmap = minFilter; if (minFilterNoMipmap == TextureMinFilter.LinearMipmapLinear) minFilterNoMipmap = TextureMinFilter.Linear; else if (minFilterNoMipmap == TextureMinFilter.NearestMipmapLinear) minFilterNoMipmap = TextureMinFilter.Nearest; #endif }
public Texture2D( int width, int height, byte[] data ) : base(TextureTarget.Texture2D) { Width = width; Height = height; WrapModeU = TextureWrapMode.Repeat; WrapModeV = TextureWrapMode.Repeat; InternalFormat = PixelInternalFormat.Rgba; ExternalFormat = PixelFormat.Bgra; Compressed = false; Alpha = true; MinFilter = TextureMinFilter.Linear; MipMapCount = 1; ContainsMipMaps = false; GenerateMipMaps = false; ImageLevelSizes = new int[] { ( width * height ) << 2 }; ImageLevelData = new byte[][] { data }; }
/// <summary> /// Sets the filter mode for the currently-bound texture. /// </summary> public static void SetFilterMode(TextureMinFilter Min, TextureMagFilter Mag) { GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)Min); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)Mag); }
/// <summary> /// Load a texture to graphic memory /// </summary> /// <param name="filename">The filepath to the file to load</param> /// <param name="MinFilter">What filter to use</param> /// <param name="MagFilter">What filter to use</param> /// <param name="WrapS">Wrap it X?</param> /// <param name="WrapT">Wrap it Y?</param> /// <param name="Transparant">Do we have a transparant colour in the image?</param> /// <returns>TextureID from OpenGL</returns> public static int LoadTexture(string filename, TextureMinFilter MinFilter = TextureMinFilter.Nearest, TextureMagFilter MagFilter = TextureMagFilter.Linear, TextureWrapMode WrapS = TextureWrapMode.Clamp, TextureWrapMode WrapT = TextureWrapMode.Clamp, Color Transparant = new Color()) { Bitmap bitmap = null; if (File.Exists(filename)) { //Console.WriteLine("-----> " + filename); bitmap = new Bitmap(filename, false); if (bitmap.Width >= Util.MaxTexturesSizeWidth || bitmap.Height >= Util.MaxTexturesSizeWidth) { throw new Exception("GFX/Texture is to large it excides the allowed size by your hardware (" + Util.MaxTexturesSizeWidth + " x " + Util.MaxTexturesSizeWidth + "), " + filename); } } else { throw new Exception("Missing Bitmap-file!"); } return LoadTexture(bitmap, MinFilter, MagFilter, WrapS, WrapT, Transparant); }
/// <summary> /// Load a texture to graphic memory /// </summary> /// <param name="bitmap">Bitmap data</param> /// <param name="MinFilter">What filter to use</param> /// <param name="MagFilter">What filter to use</param> /// <param name="WrapS">Wrap it X?</param> /// <param name="WrapT">Wrap it Y?</param> /// <param name="Transparant">Do we have a transparant colour in the image?</param> /// <returns>TextureID from OpenGL</returns> public static int LoadTexture(Bitmap bitmap, TextureMinFilter MinFilter = TextureMinFilter.Nearest, TextureMagFilter MagFilter = TextureMagFilter.Linear, TextureWrapMode WrapS = TextureWrapMode.Clamp, TextureWrapMode WrapT = TextureWrapMode.Clamp, Color Transparant = new Color()) { if (bitmap == null) { throw new Exception("Bitmap is null, texture is not loading!"); } int tex; GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest); if (!Transparant.IsEmpty) { bitmap.MakeTransparent(Transparant); } if (bitmap.Width >= Util.MaxTexturesSizeWidth || bitmap.Height >= Util.MaxTexturesSizeWidth) { throw new Exception("GFX/Texture is to large it excides the allowed size by your hardware (" + Util.MaxTexturesSizeWidth + " x " + Util.MaxTexturesSizeWidth + ")"); } //GL.GenTextures(1, out tex); //currentTextureBuffers++; GenTextureID(out tex); GL.BindTexture(TextureTarget.Texture2D, tex); BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb/*bitmap.PixelFormat*/); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, data.Width, data.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0); bitmap.UnlockBits(data); bitmap.Dispose(); bitmap = null; GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)MinFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)MagFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)WrapS); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)WrapT); return tex; }
/// <summary> /// Load a texture to graphic memory /// </summary> /// <param name="filename">The filepath to the file to load</param> /// <param name="Width">How wide is the image</param> /// <param name="Height">How highe is the image</param> /// <param name="MinFilter">What filter to use</param> /// <param name="MagFilter">What filter to use</param> /// <param name="WrapS">Wrap it X?</param> /// <param name="WrapT">Wrap it Y?</param> /// <param name="Transparant">Do we have a transparant colour in the image?</param> /// <returns>TextureID from OpenGL</returns> public static int LoadTexture(string filename, out float Width, out float Height, TextureMinFilter MinFilter = TextureMinFilter.Linear, TextureMagFilter MagFilter = TextureMagFilter.Linear, TextureWrapMode WrapS = TextureWrapMode.Clamp, TextureWrapMode WrapT = TextureWrapMode.Clamp, Color Transparant = new Color()) { Bitmap bitmap = null; if (File.Exists(filename)) { bitmap = new Bitmap(filename, false); Width = bitmap.Width; Height = bitmap.Height; } else { throw new Exception("Missing Bitmap-file!"); } return LoadTexture(bitmap, MinFilter, MagFilter, WrapS, WrapT, Transparant); }
/// <summary> /// Sets the interpolation used by the texture. /// </summary> public void SetInterpolation2D(TextureMinFilter Min, TextureMagFilter Mag) { this.Bind2D(); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)Min); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)Mag); }
public void TexParameter(TextureParameterTarget target, TextureParameterName pname, TextureMinFilter param) { gl.glTexParameteri((int)target, (int)pname, (int)param); CheckException(); }
private SamplerState(GraphicsDevice device, SamplerStateDescription samplerStateDescription) : base(device) { Description = samplerStateDescription; textureWrapS = samplerStateDescription.AddressU.ToOpenGL(); textureWrapT = samplerStateDescription.AddressV.ToOpenGL(); textureWrapR = samplerStateDescription.AddressW.ToOpenGL(); compareMode = TextureCompareMode.None; // ComparisonPoint can act as a mask for Comparison filters (0x80) if ((samplerStateDescription.Filter & ComparisonMask) != 0) compareMode = TextureCompareMode.CompareRefToTexture; compareFunc = samplerStateDescription.CompareFunction.ToOpenGLDepthFunction(); borderColor = samplerStateDescription.BorderColor.ToArray(); // TODO: How to do MipLinear vs MipPoint? switch (samplerStateDescription.Filter & ~(ComparisonMask | AnisotropicMask)) // Ignore comparison (128) and anisotropic (64) part { case TextureFilter.MinMagLinearMipPoint: minFilter = TextureMinFilter.LinearMipmapNearest; magFilter = TextureMagFilter.Linear; break; case TextureFilter.Linear: minFilter = TextureMinFilter.LinearMipmapLinear; magFilter = TextureMagFilter.Linear; break; case TextureFilter.MinPointMagMipLinear: minFilter = TextureMinFilter.NearestMipmapLinear; magFilter = TextureMagFilter.Linear; break; case TextureFilter.Point: minFilter = TextureMinFilter.NearestMipmapNearest; magFilter = TextureMagFilter.Nearest; break; case TextureFilter.MinPointMagLinearMipPoint: minFilter = TextureMinFilter.NearestMipmapNearest; magFilter = TextureMagFilter.Linear; break; case TextureFilter.MinLinearMagMipPoint: minFilter = TextureMinFilter.LinearMipmapNearest; magFilter = TextureMagFilter.Nearest; break; case TextureFilter.MinMagPointMipLinear: minFilter = TextureMinFilter.NearestMipmapLinear; magFilter = TextureMagFilter.Nearest; break; case TextureFilter.MinLinearMagPointMipLinear: minFilter = TextureMinFilter.LinearMipmapLinear; magFilter = TextureMagFilter.Nearest; break; default: throw new NotImplementedException(); } maxAnisotropy = ((samplerStateDescription.Filter & AnisotropicMask) != 0) ? Description.MaxAnisotropy : 1; #if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES // On OpenGL ES, we need to choose the appropriate min filter ourself if the texture doesn't contain mipmaps (done at PreDraw) minFilterNoMipmap = minFilter; if (minFilterNoMipmap == TextureMinFilter.LinearMipmapLinear) minFilterNoMipmap = TextureMinFilter.Linear; else if (minFilterNoMipmap == TextureMinFilter.NearestMipmapLinear) minFilterNoMipmap = TextureMinFilter.Nearest; #endif }
public static void SetTextureFilters(TextureMinFilter min, TextureMagFilter mag) { GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)min); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)mag); }
public glmode_t(string name, TextureMinFilter minFilter, TextureMagFilter magFilter) { this.name = name; this.minimize = minFilter; this.maximize = magFilter; }
/// <summary> /// Draw_TextureMode_f /// </summary> static void TextureMode_f() { int i; if (Cmd.Argc == 1) { for (i = 0; i < 6; i++) if (_MinFilter == _Modes[i].minimize) { Con.Print("{0}\n", _Modes[i].name); return; } Con.Print("current filter is unknown???\n"); return; } for (i = 0; i < _Modes.Length; i++) { if (Common.SameText(_Modes[i].name, Cmd.Argv(1))) break; } if (i == _Modes.Length) { Con.Print("bad filter name!\n"); return; } _MinFilter = _Modes[i].minimize; _MagFilter = _Modes[i].maximize; // change all the existing mipmap texture objects for (i = 0; i < _NumTextures; i++) { gltexture_t glt = _glTextures[i]; if (glt.mipmap) { Bind(glt.texnum); SetTextureFilters(_MinFilter, _MagFilter); } } }
public static void LoadFromDisk(string filename, out uint texturehandle, out TextureTarget dimension, TextureMinFilter minFilter, TextureMagFilter magFilter, TextureWrapMode wrapS, TextureWrapMode wrapT) { dimension = (TextureTarget)0; texturehandle = TextureLoaderParameters.OpenGLDefaultTexture; ErrorCode GLError = ErrorCode.NoError; Bitmap CurrentBitmap = null; try // Exceptions will be thrown if any Problem occurs while working on the file. { CurrentBitmap = new Bitmap(filename); if (TextureLoaderParameters.FlipImages) CurrentBitmap.RotateFlip(RotateFlipType.RotateNoneFlipY); if (CurrentBitmap.Height > 1) dimension = TextureTarget.Texture2D; else dimension = TextureTarget.Texture1D; GL.GenTextures(1, out texturehandle); GL.BindTexture(dimension, texturehandle); #region Load Texture OpenTK.Graphics.OpenGL.PixelInternalFormat pif; OpenTK.Graphics.OpenGL.PixelFormat pf; OpenTK.Graphics.OpenGL.PixelType pt; if (TextureLoaderParameters.Verbose) Trace.WriteLine("File: " + filename + " Format: " + CurrentBitmap.PixelFormat); switch (CurrentBitmap.PixelFormat) { case System.Drawing.Imaging.PixelFormat.Format8bppIndexed: // misses glColorTable setup pif = OpenTK.Graphics.OpenGL.PixelInternalFormat.Rgb8; pf = OpenTK.Graphics.OpenGL.PixelFormat.ColorIndex; pt = OpenTK.Graphics.OpenGL.PixelType.Bitmap; break; case System.Drawing.Imaging.PixelFormat.Format16bppArgb1555: case System.Drawing.Imaging.PixelFormat.Format16bppRgb555: // does not work pif = OpenTK.Graphics.OpenGL.PixelInternalFormat.Rgb5A1; pf = OpenTK.Graphics.OpenGL.PixelFormat.Bgr; pt = OpenTK.Graphics.OpenGL.PixelType.UnsignedShort5551Ext; break; case System.Drawing.Imaging.PixelFormat.Format24bppRgb: // works pif = OpenTK.Graphics.OpenGL.PixelInternalFormat.Rgb8; pf = OpenTK.Graphics.OpenGL.PixelFormat.Bgr; pt = OpenTK.Graphics.OpenGL.PixelType.UnsignedByte; break; case System.Drawing.Imaging.PixelFormat.Format32bppRgb: // has alpha too? wtf? case System.Drawing.Imaging.PixelFormat.Canonical: case System.Drawing.Imaging.PixelFormat.Format32bppArgb: // works pif = OpenTK.Graphics.OpenGL.PixelInternalFormat.Rgba; pf = OpenTK.Graphics.OpenGL.PixelFormat.Bgra; pt = OpenTK.Graphics.OpenGL.PixelType.UnsignedByte; break; default: throw new ArgumentException("ERROR: Unsupported Pixel Format " + CurrentBitmap.PixelFormat); } BitmapData Data = CurrentBitmap.LockBits(new Rectangle(0, 0, CurrentBitmap.Width, CurrentBitmap.Height), ImageLockMode.ReadOnly, CurrentBitmap.PixelFormat); // tarkista onko texturen koko oikeanlainen (64, 128, 256, jne) int test = 1; bool wOK = false, hOK = false; for (int q = 0; q < 20; q++) { test *= 2; if (test == Data.Width) wOK = true; if (test == Data.Height) hOK = true; if (wOK && hOK) break; } if (wOK == false || hOK == false) throw new Exception("Use power of 2 size texture maps only!"); // --- // TODO: muuta kokoa jos tarvis // TODO: mipmapit if (Data.Height > 1) { // image is 2D //if (TextureLoaderParameters.BuildMipmapsForUncompressed) // Glu.Build2DMipmap(dimension, (int)pif, Data.Width, Data.Height, pf, pt, Data.Scan0); //else GL.TexImage2D(dimension, 0, pif, Data.Width, Data.Height, TextureLoaderParameters.Border, pf, pt, Data.Scan0); } else { // image is 1D //if (TextureLoaderParameters.BuildMipmapsForUncompressed) // Glu.Build1DMipmap(dimension, (int)pif, Data.Width, pf, pt, Data.Scan0); //else GL.TexImage1D(dimension, 0, pif, Data.Width, TextureLoaderParameters.Border, pf, pt, Data.Scan0); } GL.Finish(); GLError = GL.GetError(); if (GLError != ErrorCode.NoError) { throw new ArgumentException("Error building TexImage. GL Error: " + GLError); } CurrentBitmap.UnlockBits(Data); #endregion Load Texture #region Set Texture Parameters GL.TexParameter(dimension, TextureParameterName.TextureMinFilter, (int)minFilter); //(int)TextureLoaderParameters.MinificationFilter); GL.TexParameter(dimension, TextureParameterName.TextureMagFilter, (int)magFilter); //(int)TextureLoaderParameters.MagnificationFilter); GL.TexParameter(dimension, TextureParameterName.TextureWrapS, (int)wrapS); //(int)TextureLoaderParameters.WrapModeS); GL.TexParameter(dimension, TextureParameterName.TextureWrapT, (int)wrapT); //(int)TextureLoaderParameters.WrapModeT); GL.TexEnv(TextureEnvTarget.TextureEnv, TextureEnvParameter.TextureEnvMode, (int)TextureLoaderParameters.EnvMode); GLError = GL.GetError(); if (GLError != ErrorCode.NoError) { throw new ArgumentException("Error setting Texture Parameters. GL Error: " + GLError); } #endregion Set Texture Parameters return; // success } catch (Exception e) { dimension = (TextureTarget)0; texturehandle = TextureLoaderParameters.OpenGLDefaultTexture; throw new ArgumentException("Texture Loading Error: Failed to read file " + filename + ".\n" + e); // return; // failure } finally { CurrentBitmap = null; } }
/// <summary> /// Sets the texture filtering parameters. /// </summary> /// <param name="minFilter">The <see cref="TextureMinFilter"/>.</param> /// <param name="magFilter">The <see cref="TextureMagFilter"/>.</param> /// <param name="wrapS">The horizontal <see cref="TextureWrapMode"/>.</param> /// <param name="wrapT">The vertical <see cref="TextureWrapMode"/>.</param> public void SetParameters(TextureMinFilter minFilter, TextureMagFilter magFilter, TextureWrapMode wrapS, TextureWrapMode wrapT) { GL.BindTexture(TextureTarget.Texture2D, this.Handle); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)wrapS); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)wrapT); GL.BindTexture(TextureTarget.Texture2D, 0); }
public extern void TexParameteri(TextureTarget target, TextureParameterName pname, TextureMinFilter param);
/// <summary> /// Creates a new Texture based on a <see cref="Duality.Resources.Pixmap"/>. /// </summary> /// <param name="basePixmap">The <see cref="Duality.Resources.Pixmap"/> to use as source for pixel data.</param> /// <param name="sizeMode">Specifies behaviour in case the source data has non-power-of-two dimensions.</param> /// <param name="filterMag">The OpenGL filter mode for drawing the Texture bigger than it is.</param> /// <param name="filterMin">The OpenGL fitler mode for drawing the Texture smaller than it is.</param> /// <param name="wrapX">The OpenGL wrap mode on the texel x axis.</param> /// <param name="wrapY">The OpenGL wrap mode on the texel y axis.</param> /// <param name="format">The format in which OpenGL stores the pixel data.</param> public Texture(ContentRef<Pixmap> basePixmap, SizeMode sizeMode = SizeMode.Default, TextureMagFilter filterMag = TextureMagFilter.Linear, TextureMinFilter filterMin = TextureMinFilter.LinearMipmapLinear, TextureWrapMode wrapX = TextureWrapMode.ClampToEdge, TextureWrapMode wrapY = TextureWrapMode.ClampToEdge, PixelInternalFormat format = PixelInternalFormat.Rgba) { this.filterMag = filterMag; this.filterMin = filterMin; this.wrapX = wrapX; this.wrapY = wrapY; this.pixelformat = format; this.LoadData(basePixmap, sizeMode); }
public void SetMinFilter(TextureMinFilter minFilter) { Owner.BindTexture2d(this); Owner.TexParameter2d(TextureParameterName.TextureMinFilter, (int)minFilter); }
public Texture(string fileName, TextureMinFilter minFilter = TextureMinFilter.Linear, TextureMagFilter magFilter = TextureMagFilter.Nearest, TextureWrapMode wrapS = TextureWrapMode.ClampToBorderSgis, TextureWrapMode wrapT = TextureWrapMode.ClampToBorderSgis) : this(new Bitmap(fileName), minFilter, magFilter, wrapS, wrapT) { }
/// <summary> /// Creates a new empty Texture with the specified size. /// </summary> /// <param name="width">The Textures width.</param> /// <param name="height">The Textures height</param> /// <param name="sizeMode">Specifies behaviour in case the specified size has non-power-of-two dimensions.</param> /// <param name="filterMag">The OpenGL filter mode for drawing the Texture bigger than it is.</param> /// <param name="filterMin">The OpenGL fitler mode for drawing the Texture smaller than it is.</param> /// <param name="wrapX">The OpenGL wrap mode on the texel x axis.</param> /// <param name="wrapY">The OpenGL wrap mode on the texel y axis.</param> /// <param name="format">The format in which OpenGL stores the pixel data.</param> public Texture(int width, int height, SizeMode sizeMode = SizeMode.Default, TextureMagFilter filterMag = TextureMagFilter.Linear, TextureMinFilter filterMin = TextureMinFilter.LinearMipmapLinear, TextureWrapMode wrapX = TextureWrapMode.ClampToEdge, TextureWrapMode wrapY = TextureWrapMode.ClampToEdge, PixelInternalFormat format = PixelInternalFormat.Rgba) { this.filterMag = filterMag; this.filterMin = filterMin; this.wrapX = wrapX; this.wrapY = wrapY; this.pixelformat = format; this.texSizeMode = sizeMode; this.AdjustSize(width, height); this.SetupOpenGLRes(); }
public static void TexParameter(TextureParameterTarget target, TextureParameterName pname, TextureMinFilter param) { gl.glTexParameteri((int)target, (int)pname, (int)param); }