public void load(IntPtr data)
{
GL.BindTexture(_target, _id);
switch (_target)
{
case TextureTarget.Texture1D:
GL.TexImage1D(_target, 0, _pif, _width, 0, _pf, _pt, data);
break;
case TextureTarget.Texture2D:
GL.TexImage2D(_target, 0, _pif, _width, _height, 0, _pf, _pt, data);
break;
case TextureTarget.Texture2DArray:
GL.TexImage3D(_target, 0, _pif, _width, _height, _depth, 0, _pf, _pt, (IntPtr)0);
break;
case TextureTarget.TextureCubeMap:
for (int face = 0; face < _depth; face++)
{
GL.TexImage2D(TextureTarget.TextureCubeMapPositiveX + face, 0, _pif, _width, _height, 0, _pf, _pt, data);
}
break;
case TextureTarget.TextureCubeMapArray:
//GL.TexImage3D(_target, 0, pif, _width, _depth, _depth * 6, 0, _pf, _pt, data);
GL.TexStorage3D((TextureTarget3d)_target, _max_mipmap_levels + 1, (SizedInternalFormat)_pif, _width, _height, _depth * 6);
//for (int layer = 0; layer < _depth; layer++)
//{
// for (int face = 0; face < 6; face++)
// {
// GL.TexSubImage2D(TextureTarget.TextureCubeMapPositiveX + face, 0, 0, 0, _width, _height, _pf, _pt, data);
// //GL.TexImage2D(TextureTarget.TextureCubeMapPositiveX + face, layer, _pif, _width, _height, 0, _pf, _pt, data);
// }
//}
break;
case TextureTarget.Texture3D:
GL.TexImage3D(_target, 0, _pif, _width, _height, _depth, 0, _pf, _pt, data);
break;
default:
throw new Exception($"Load Texture: Unsupported Texture Target [ {_target.ToString()} ]");
}
setTextureParameters();
}
internal static void SaveDepthCubeMapToBitmap(TextureTarget target, int texId)
{
Bitmap b = new Bitmap(KWEngine.ShadowMapSize, KWEngine.ShadowMapSize, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
float[] depthData = new float[KWEngine.ShadowMapSize * KWEngine.ShadowMapSize];
GL.BindTexture(TextureTarget.TextureCubeMap, texId);
GL.GetTexImage(target, 0, OpenTK.Graphics.OpenGL4.PixelFormat.DepthComponent, PixelType.Float, depthData);
GL.BindTexture(TextureTarget.TextureCubeMap, 0);
HelperGeneral.ScaleToRange(0, 255, depthData);
int x = 0, y = KWEngine.ShadowMapSize - 1;
for (int i = 0; i < depthData.Length; i++)
{
int rgb = (int)(depthData[i]);
b.SetPixel(x, y, Color.FromArgb(rgb, rgb, rgb));
int prevX = x;
x = (x + 1) % KWEngine.ShadowMapSize;
if (prevX > 0 && x == 0)
{
y--;
}
}
b.Save("cube_" + target.ToString() + ".bmp", ImageFormat.Bmp);
b.Dispose();
}
/// <summary>
/// Generates mipmaps for this <see cref="Texture"/>.
/// </summary>
/// <exception cref="InvalidOperationException"/>
public void GenerateMipmaps()
{
if (isNotMipmappable)
{
throw new InvalidOperationException(string.Concat("This texture type is not mipmappable! Type: ", TextureType.ToString()));
}
GraphicsDevice.BindTextureSetActive(this);
GL.GenerateMipmap(TextureType);
IsMipmapped = true;
}
public static ActiveUniformType GetUniformType(TextureTarget target)
{
if (!uniformTypeByTextureTarget.ContainsKey(target))
{
throw new NotImplementedException($"{target.ToString()} is not supported");
}
else
{
return(uniformTypeByTextureTarget[target]);
}
}
private static GenerateMipmapTarget GetMipmapTarget(TextureTarget target)
{
// TODO: Support other types.
if (target == TextureTarget.Texture2D)
{
return(GenerateMipmapTarget.Texture2D);
}
if (target.ToString().ToLower().Contains("cubemap"))
{
return(GenerateMipmapTarget.TextureCubeMap);
}
throw new NotImplementedException($"{target} is not supported for mipmap generation.");
}
private static GenerateMipmapTarget MapMipmapTarget(TextureTarget target)
{
switch (target)
{
case TextureTarget.Texture2D:
return(GenerateMipmapTarget.Texture2D);
case TextureTarget.Texture2DArray:
return(GenerateMipmapTarget.Texture2DArray);
case TextureTarget.Texture2DMultisample:
return(GenerateMipmapTarget.Texture2DMultisample);
case TextureTarget.TextureCubeMap:
return(GenerateMipmapTarget.TextureCubeMap);
default:
throw new ArgumentException("Unsupported texture target: " + target.ToString(), "target");
}
}
private static GetPName MapTargetBindingPName(TextureTarget target)
{
switch (target)
{
case TextureTarget.Texture2D:
return(GetPName.TextureBinding2D);
case TextureTarget.Texture2DArray:
return(GetPName.TextureBinding2DArray);
case TextureTarget.Texture2DMultisample:
return(GetPName.TextureBinding2DMultisample);
case TextureTarget.TextureCubeMap:
case TextureTarget.TextureCubeMapArray:
return(GetPName.TextureBindingCubeMap);
default:
throw new ArgumentException("Unsupported texture target: " + target.ToString(), "target");
}
}
/// <summary>
/// Returns true if the target is a cube map target.
/// </summary>
/// <param name="target">The texture target</param>
/// <returns>True if the target is a cube map target</returns>
public static bool IsCubeMapTarget(TextureTarget target)
{
return(target.ToString().ToLower().Contains("cubemap"));
}
public void UploadImage <T>(TextureTarget target, T[] data) where T : struct
{
log.Trace("Texture.UploadImage ({0}) uploading to target {1}...", this.Name, target.ToString());
GL.TexImage2D <T>(target, 0, this.InternalFormat, this.Width, this.Height, 0, this.Format, this.Type, data);
log.Trace("Texture.UploadImage ({0}) uploaded {1} texels of {2}", this.Name, data.Length, data.GetType().Name);
}
/// <summary>
/// Update the texture quality settings for the currently bound texture
/// </summary>
/// <param name="target">The GL texture target</param>
public void Update(TextureTarget target)
{
if(mipmapsDirty)
{
mipmapsDirty = false;
if(mipmaps)
{
GL.TexParameter(target, TextureParameterName.TextureBaseLevel, 0);
int levels = mipmapLevels;
if (levels < 0)
{
levels = 1000;
}
//GL.TexParameter(target, TextureParameterName.TextureMaxLevel, levels);
if(!pregeneratedMipmaps)
{
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
switch (target)
{
case TextureTarget.Texture1D:
GL.GenerateMipmap(GenerateMipmapTarget.Texture1D);
break;
case TextureTarget.Texture2D:
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
break;
case TextureTarget.Texture3D:
GL.GenerateMipmap(GenerateMipmapTarget.Texture3D);
break;
case TextureTarget.Texture1DArray:
GL.GenerateMipmap(GenerateMipmapTarget.Texture1DArray);
break;
case TextureTarget.Texture2DArray:
GL.GenerateMipmap(GenerateMipmapTarget.Texture2DArray);
break;
case TextureTarget.TextureCubeMap:
GL.GenerateMipmap(GenerateMipmapTarget.TextureCubeMap);
break;
case TextureTarget.TextureCubeMapArray:
GL.GenerateMipmap(GenerateMipmapTarget.TextureCubeMapArray);
break;
case TextureTarget.Texture2DMultisample:
GL.GenerateMipmap(GenerateMipmapTarget.Texture2DMultisample);
break;
case TextureTarget.Texture2DMultisampleArray:
GL.GenerateMipmap(GenerateMipmapTarget.Texture2DMultisampleArray);
break;
default:
throw new NotImplementedException("Generating mipmaps not supported for TextureTarget." + target.ToString() + ". Currently supported mipmaps are: Texture1D, Texture2D, Texture3D, Texture1DArray, Texture2DArray, TextureCubeMap, TextureCubeMapArray, Texture2DMultisample, Texture2DMultisampleArray.");
}
}
}
}
if(textureFilteringDirty)
{
if(target == TextureTarget.Texture2D || target == TextureTarget.TextureCubeMap)
{
switch (textureFiltering)
{
case TextureFiltering.Nearest:
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
if (mipmaps)
{
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.NearestMipmapNearest);
}
else
{
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
}
break;
case TextureFiltering.Bilinear:
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
if (mipmaps)
{
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapNearest);
}
else
{
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
}
break;
case TextureFiltering.Trilinear:
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
if (mipmaps)
{
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
}
else
{
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
}
break;
}
}
textureFilteringDirty = false;
}
if (anisotrophyDirty)
{
if (GPUCapabilities.AnisotrophicFiltering && (target == TextureTarget.TextureCubeMap || target == TextureTarget.Texture2D))
{
if (GPUCapabilities.MaxAnisotrophyLevel < anisotrophy)
anisotrophy = GPUCapabilities.MaxAnisotrophyLevel;
if (anisotrophy < 1)
anisotrophy = 1;
GL.TexParameter(target, (TextureParameterName)ExtTextureFilterAnisotropic.TextureMaxAnisotropyExt, anisotrophy);
}
anisotrophyDirty = false;
}
if(textureWrapMode_SDirty)
{
if (target == TextureTarget.TextureCubeMap || target == TextureTarget.Texture2D)
{
GL.TexParameter(target, TextureParameterName.TextureWrapS, (int)textureWrapMode_S);
}
textureWrapMode_SDirty = false;
}
if (textureWrapMode_TDirty)
{
if (target == TextureTarget.TextureCubeMap || target == TextureTarget.Texture2D)
{
GL.TexParameter(target, TextureParameterName.TextureWrapT, (int)textureWrapMode_T);
}
textureWrapMode_TDirty = false;
}
}