/// <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;
}
}
/// <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);
}
/// <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);
}
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>
/// 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 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 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 void setMinMagFilters(TextureMinFilter min, TextureMagFilter mag)
{
bind();
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)min);
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)mag);
unbind();
}
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();
}
/// <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);
}
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>
/// 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 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);
}
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);
}
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 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 SetMagFilter(TextureMagFilter textureMagFilter)
{
magFilter = textureMagFilter;
GL.BindTexture(TextureTarget.Texture2D, handle);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)textureMagFilter);
GL.BindTexture(TextureTarget.Texture2D, 0);
}
//------------------------------------------------------
// 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 Animation(
TextureMinFilter minFilter, TextureMagFilter magFilter, string firstPath, params string[] paths)
{
m_MinFilter = minFilter;
m_MagFilter = magFilter;
totalPaths = new[] { firstPath }.Concat(paths);
}
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 SetMagFilter(TextureMagFilter filter)
{
if (magFilter == filter)
{
return;
}
GL.SamplerParameter(handle, (int)All.TextureMagFilter, (int)filter);
magFilter = filter;
}
protected static Dictionary <string, Texture> texture_info = new Dictionary <string, Texture>(); //the Textures contained herein are used only to store index/height/width
///<param name="filename">Note that filename is required even if passing a byte[], because filename is used as the key to identify duplicate textures</param>
///<param name="textureBytes">Used only if source == TextureLoadSource.FromByteArray</param>
public static Texture Create(string filename, string filenameOfTextureToReplace = null, TextureMinFilter minFilter = TextureMinFilter.Nearest,
TextureMagFilter magFilter = TextureMagFilter.Nearest, TextureLoadSource source = TextureLoadSource.FromFilePath, byte[] textureBytes = null)
{
Texture t = new Texture();
t.Sprite = new List <SpriteType>();
t.LoadTexture(filename, filenameOfTextureToReplace, minFilter, magFilter, source, textureBytes);
return(t);
}
public void SetFilter(TextureMagFilter mag)
{
m_MagFilter = mag;
if (m_Id != 0)
{
Bind();
GL.TexParameter(m_TextureType, TextureParamName.TextureMagFilter, (int)mag);
}
}
public void SetMagFilter(TextureMagFilter filter)
{
magFilter = filter;
if (handle != 0)
{
GL.BindTexture(TextureTarget.Texture2D, handle);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter);
GL.BindTexture(TextureTarget.Texture2D, 0);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TextureData"/> struct.
/// </summary>
/// <param name="format">The format.</param>
/// <param name="minFilter">The min filter.</param>
/// <param name="magFilter">The mag filter.</param>
/// <param name="wrapMode">The wrap mode.</param>
public TextureData(
TextureFormat format,
TextureMinFilter minFilter, TextureMagFilter magFilter,
TextureWrapMode wrapMode)
{
Format = format;
MinFilter = minFilter;
MagFilter = magFilter;
WrapMode = wrapMode;
}
/// <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 GLTexture2D(Image image,
TextureMagFilter magFilter = TextureMagFilter.Nearest,
TextureMinFilter minFilter = TextureMinFilter.Nearest,
int wrapX = (int)TextureWrapMode.Repeat,
int wrapY = (int)TextureWrapMode.Repeat)
: this(image.Width, image.Height, image.ComponentCount,
magFilter, minFilter, wrapX, wrapY)
{
SetData(image.data);
}
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 SamplerState(TextureMinFilter minFilter, TextureMagFilter magFilter, TextureWrapMode wrapModeS, TextureWrapMode wrapModeT,
float lodBias = 0.0f, float maxAniso = 0.0f)
{
this.MinFilter = minFilter;
this.MagFilter = magFilter;
this.WrapModeS = wrapModeS;
this.WrapModeT = wrapModeT;
this.LodBias = lodBias;
this.MaxAniso = maxAniso;
}
/// <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>
/// 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>
private void SetParametersBound(
TextureMinFilter minFilter,
TextureMagFilter magFilter,
TextureWrapMode wrapS,
TextureWrapMode wrapT)
{
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);
}
private SamplerState(GraphicsDevice device, SamplerStateDescription samplerStateDescription) : base(device)
{
Description = samplerStateDescription;
textureWrapS = samplerStateDescription.AddressU.ToOpenGL();
textureWrapT = samplerStateDescription.AddressV.ToOpenGL();
#if !SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES
textureWrapR = samplerStateDescription.AddressW.ToOpenGL();
#endif
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
}
private static void setParameters(
TextureMinFilter minFilter,
TextureMagFilter magFilter,
TextureWrapMode wrapS,
TextureWrapMode wrapT)
{
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMinFilter, (int)minFilter);
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMagFilter, (int)magFilter);
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapS, (int)wrapS);
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapT, (int)wrapT);
}
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 Texture(Bitmap bitmap, TextureMagFilter minMagFilter = TextureMagFilter.Linear,
TextureWrapMode wrapMode = TextureWrapMode.ClampToEdge)
{
GL.GenTextures(1, out _object);
GL.BindTexture(TextureTarget.Texture2D, _object);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minMagFilter);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)minMagFilter);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)wrapMode);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)wrapMode);
GL.TexImage2D(TextureTarget.Texture2D,
0,
TextureFormatForBitmapFormat(bitmap.Format),
(int)bitmap.Width,
(int)bitmap.Height,
0,
PixelFormatForBitmap(bitmap.Format),
PixelType.UnsignedByte,
bitmap.PixelBuffer);
GL.BindTexture(TextureTarget.Texture2D, 0);
bitmap.Unlock();
}
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>
/// 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>
/// 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;
}
public extern void TexParameteri(TextureTarget target, TextureParameterName pname, TextureMagFilter param);
public static void TexParameter(TextureParameterTarget target, TextureParameterName pname, TextureMagFilter param)
{
gl.glTexParameteri((int)target, (int)pname, (int)param);
}
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;
}
}
internal void GLBlitFramebufferApple(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, ClearBufferMask mask, TextureMagFilter filter)
{
GLResolveMultisampleFramebufferApple();
}
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 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 TexParameter(TextureParameterTarget target, TextureParameterName pname, TextureMagFilter param)
{
gl.glTexParameteri((int)target, (int)pname, (int)param);
CheckException();
}
/// <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);
}
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
}
/// <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 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 void SetMagFilter(TextureMagFilter magFilter)
{
Owner.BindTexture2d(this);
Owner.TexParameter2d(TextureParameterName.TextureMagFilter, (int)magFilter);
}
public static void SetTextureFilters(TextureMinFilter min, TextureMagFilter mag)
{
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)min);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)mag);
}
/// <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();
}
/// <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);
}
