public void BindAsImage(int unit, bool read, bool write)
{
SizedInternalFormat format = SizedInternalFormat.Rgba32f;
if (InternalFormat == PixelInternalFormat.Rgba16f || InternalFormat == PixelInternalFormat.Rgb16f)
{
format = SizedInternalFormat.Rgba16f;
}
else if (InternalFormat == PixelInternalFormat.Rgb || InternalFormat == PixelInternalFormat.Rgba ||
InternalFormat == PixelInternalFormat.Rgb8 || InternalFormat == PixelInternalFormat.Rgba8)
{
format = SizedInternalFormat.Rgba8;
}
else if (InternalFormat == PixelInternalFormat.R32f)
{
format = SizedInternalFormat.R32f;
}
else if (InternalFormat == PixelInternalFormat.R16f)
{
format = SizedInternalFormat.R16f;
}
TextureAccess access = TextureAccess.ReadWrite;
if (read && !write)
{
access = TextureAccess.ReadOnly;
}
else if (write && !read)
{
access = TextureAccess.WriteOnly;
}
IGL.Primary.BindImageTexture(unit, Id, 0, false, 0, (int)access, (int)format);
}
public static extern Texture SDL_CreateTexture(
Renderer renderer,
UInt32 format,
TextureAccess access,
int w,
int h
);
public void bindImageUnit(int texture_uniform, int index, TextureAccess access, int level, int layer)
{
bool layered = false;
switch (_target)
{
case TextureTarget.Texture2DArray:
case TextureTarget.TextureCubeMap:
case TextureTarget.TextureCubeMapArray:
case TextureTarget.Texture3D:
layered = true;
break;
}
GL.ActiveTexture(TextureUnit.Texture0 + index);
GL.BindImageTexture(
index,
_id,
level,
layered,
layer,
access,
(SizedInternalFormat)_pif);
GL.Uniform1(texture_uniform, index);
}
public BindImagebufferCommand(int bufferId, int location, TextureAccess access, SizedInternalFormat format) : base()
{
myBufferId = bufferId;
myLocation = location;
myAccess = access;
myFormat = format;
}
public ImageTextureBinding(Texture source, TextureUnit textureSlot, TextureAccess access, SizedInternalFormat format)
{
texture = source;
textureUnit = textureSlot;
bindingAccess = access;
bindingFormat = format;
}
public static void UnbindAsImage(int unit)
{
SizedInternalFormat format = SizedInternalFormat.Rgba32f;
TextureAccess access = TextureAccess.ReadWrite;
IGL.Primary.BindImageTexture(unit, 0, 0, false, 0, (int)access, (int)format);
}
public void createShaderAccessPoint(uint bindPoint, TextureAccess access)
{
OgrePINVOKE.TexturePtr_createShaderAccessPoint__SWIG_3(swigCPtr, bindPoint, (int)access);
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void createShaderAccessPoint(uint bindPoint, TextureAccess access, int mipmapLevel)
{
OgrePINVOKE.Texture_createShaderAccessPoint__SWIG_2(swigCPtr, bindPoint, (int)access, mipmapLevel);
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void createShaderAccessPoint(uint bindPoint, TextureAccess access, int mipmapLevel, int textureArrayIndex, PixelFormat format)
{
OgrePINVOKE.Texture_createShaderAccessPoint__SWIG_0(swigCPtr, bindPoint, (int)access, mipmapLevel, textureArrayIndex, (int)format);
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public void createShaderAccessPoint(uint bindPoint, TextureAccess access, int mipmapLevel, int textureArrayIndex)
{
OgrePINVOKE.TexturePtr_createShaderAccessPoint__SWIG_1(swigCPtr, bindPoint, (int)access, mipmapLevel, textureArrayIndex);
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
public void setImageBuffer(int id, int location, TextureAccess access, SizedInternalFormat format)
{
currentImageBuffer++;
ImageInfo ii;
ii.id = id;
ii.location = location;
ii.access = access;
ii.format = format;
myImageBuffers[currentImageBuffer] = ii;
}
public SdlTexture(IRenderWindow window, IBuffer source, bool isPrimary = false, uint? pixelFormat = null)
{
Initialize(window, isPrimary);
Initialize(source.Width, source.Height);
Renderer = SdlFactory.GetRenderer(window.Handle);
textureAccess = TextureAccess.Static;
this.pixelFormat = pixelFormat;
if (Renderer == IntPtr.Zero)
Renderer = SdlFactory.CreateRenderer(window.Handle, -1, window.RendererFlags);
Handle = SdlFactory.CreateTexture(Renderer, source);
SdlFactory.SetTextureBlendMod(Handle, BlendMode.None);
}
public SdlTexture(IRenderWindow window, int? w = null, int? h = null, bool isPrimary = false, uint? pixelFormat = null)
{
Initialize(window, isPrimary);
Initialize(w ?? window.Width, window.Height);
Renderer = SdlFactory.GetRenderer(window.Handle);
this.pixelFormat = pixelFormat;
textureAccess = TextureAccess.Streaming;
if (Renderer == IntPtr.Zero)
Renderer = SdlFactory.CreateRenderer(window.Handle, -1, window.RendererFlags);
Handle = SdlFactory.CreateTexture(Renderer,
pixelFormat ?? Factory.PixelFormat, textureAccess, Width, Height);
SdlFactory.SetTextureBlendMod(Handle, BlendMode.None);
}
public void ShouldCreateTexturesWithSpecifiedParameters(
TextureAccess access,
PixelFormat format
)
{
var width = 20;
var height = 10;
var texture = graphics.CreateTexture(width, height,
format: format, access: access);
texture.Width.Should().Be(width);
texture.Height.Should().Be(height);
texture.Format.Should().Be(format);
texture.Access.Should().Be(access);
}
/// <summary>
/// Creates a texture with the specified dimensions, format and access
/// type.
/// </summary>
/// <param name="w">Width in pixels</param>
/// <param name="h">Height in pixels</param>
/// <param name="quality">Filtering quality when texture is scaled</param>
/// <param name="format">Pixel format</param>
/// <param name="access">Texture access type</param>
public Texture CreateTexture(int w, int h,
TextureScalingQuality quality = TextureScalingQuality.Nearest,
PixelFormat format = PixelFormat.Format_ARGB8888,
TextureAccess access = TextureAccess.Static)
{
Try(() =>
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, quality.AsHint()),
"SDL_SetHint");
var texture = SDL_CreateTexture(Handle, (uint)format, (int)access, w, h);
if (texture == IntPtr.Zero)
{
throw new ImaginiException($"Could not create texture: {SDL_GetError()}");
}
return(new Texture(texture, this));
}
public void bindImageBuffer(int bufferId, int location, TextureAccess access, SizedInternalFormat format)
{
if (access == 0)
{
access = TextureAccess.ReadOnly;
}
if (format == 0)
{
format = SizedInternalFormat.R32f;
}
if (myBoundImageBuffers[location] != bufferId)
{
GL.BindImageTexture(location, bufferId, 0, false, 0, access, format);
myBoundImageBuffers[location] = bufferId;
}
}
public void ShouldNotAllowLockingNonStreamingTextures(TextureAccess access)
{
var texture = graphics.CreateTexture(1, 1, access: access);
Assert.ThrowsAny <ImaginiException>(() => texture.Lock(out _, out _));
}
/// <summary>
/// Binds a Image3D for use in shaders using image load store.
/// </summary>
/// <param name="unit">Image unit to bind the texture to</param>
/// <param name="texture">The texture object to bind, can be null to unbind a texture</param>
/// <param name="access">Texture access mode</param>
/// <param name="level">The mip level of the texture to bind</param>
public void BindImage3D(int unit, Texture texture, TextureAccess access, int level = 0)
{
BindImage(unit, texture, access, true, level, 0);
}
private void BindImage(int unit, Texture texture, TextureAccess access, bool layered, int level, int layer)
{
GL.BindImageTexture(unit, texture?.Handle ?? 0, level, layered, layer, access, (SizedInternalFormat)(texture != null ? texture.Format : SizedInternalFormatGlob.R32UI));
}
/// <summary>
/// Bind image/texture to image load/store unit.
/// </summary>
/// <param name="unit">binding unit</param>
/// <param name="level">level of the texture/image to be bound</param>
/// <param name="layered">is the texture layered (e.g. like a cube map is)</param>
/// <param name="layer">layer of the layered texture to be bound</param>
/// <param name="access">how shaders can access the texture resource</param>
/// <param name="format">texture format of the texture</param>
/// <param name="glname">texture/image to be bound</param>
public static void BindImg(int unit, int level, bool layered, int layer,
TextureAccess access, GpuFormat format, int glname)
{
// bind image to image load/store unit
if ((imgUnits[unit].glname = glname) > 0)
{
imgUnits[unit].access = access;
imgUnits[unit].format = (SizedInternalFormat)format;
}
GL.BindImageTexture(unit, glname, level, layered, Math.Max(layer, 0),
imgUnits[unit].access, imgUnits[unit].format);
}
/// <summary>
/// Binds a Image2D for use in shaders using image load store.
/// </summary>
/// <param name="unit">Image unit to bind the texture to</param>
/// <param name="texture">The texture object to bind, can be null to unbind a texture</param>
/// <param name="access">Texture access mode</param>
/// <param name="level">The mip level of the texture to bind</param>
/// <param name="layer">The layer of the texture to bind - only relevant when binding a single layer of a 2D array or 3D texture as a 2D image.</param>
public void BindImage2D(int unit, Texture texture, TextureAccess access, int level = 0, int layer = 0)
{
BindImage(unit, texture, access, false, level, layer);
}
/// <summary>
/// Binds a single face of the given texture level to an image unit.<br/>
/// Calculates the index of the layer-face as 6 * arrayLayer + face.
/// </summary>
/// <param name="imageUnit">The image unit to use.</param>
/// <param name="texture">The texture to bind.</param>
/// <param name="level">The mipmap level to bind.</param>
/// <param name="arrayLayer">The layer of the texture to bind.</param>
/// <param name="face">The cube map face to bind.</param>
/// <param name="access">Specifies the type of access allowed on the image.</param>
public void Bind(int imageUnit, TextureCubemapArray texture, int level, int arrayLayer, int face, TextureAccess access)
{
// note: the layer parameter indexes the layer-faces, hence the multiplication of the array-layer by 6
Bind(imageUnit, texture, level, false, 6 * arrayLayer + face, access);
}
/// <summary>
/// Bind texture to compute-image unit.
/// </summary>
/// <param name="unit">Image unit.</param>
/// <param name="tex">Texture object.</param>
/// <param name="level">Texture mipmap level.</param>
/// <param name="layer">Texture array index or texture depth.</param>
/// <param name="access">How the texture will be accessed by the shader.</param>
/// <param name="format">Pixel format of texture pixels.</param>
public static void BindImg(int unit, GLTexture tex, int level = 0, int layer = 0,
TextureAccess access = TextureAccess.ReadOnly, GpuFormat format = GpuFormat.Rgba8)
=> FxDebugger.BindImg(unit, level, tex?.glImg?.Length > 0, layer, access, format, tex?.glname ?? 0);
public void addImage(Texture t, TextureAccess access, int bindPoint)
{
renderState.setImageBuffer((int)t.id(), bindPoint, access, (SizedInternalFormat)t.pixelFormat);
}
/// <summary>
/// Binds an entire level of the given texture to an image unit.<br/>
/// The mipmap level defaults to zero.
/// </summary>
/// <param name="imageUnit">The image unit to use.</param>
/// <param name="texture">The texture to bind.</param>
/// <param name="access">Specifies the type of access allowed on the image.</param>
public void Bind(int imageUnit, Texture texture, TextureAccess access)
{
Bind(imageUnit, texture, 0, true, 0, access);
}
public void BindImageUnit(int unit, TextureAccess access, SizedInternalFormat format)
{
Generate();
GL.BindImageTexture(unit, Handle, 0, true, 0, access, format);
}
public Texture(Renderer renderer, PixelFormat format,
TextureAccess access, int w, int h)
: base(SDL_CreateTexture(renderer.handle, format, access, w, h))
{
}
private static extern IntPtr SDL_CreateTexture(
IntPtr renderer, PixelFormat format, TextureAccess access,
int w, int h);
/// <summary>
/// Binds a single face of the given texture level to an image unit.
/// </summary>
/// <param name="imageUnit">The image unit to use.</param>
/// <param name="texture">The texture to bind.</param>
/// <param name="level">The mipmap level to bind.</param>
/// <param name="face">The cube map face to bind.</param>
/// <param name="access">Specifies the type of access allowed on the image.</param>
public void Bind(int imageUnit, TextureCubemap texture, int level, int face, TextureAccess access)
{
Bind(imageUnit, texture, level, false, face, access);
}
/// <summary>
/// Binds a single layer of the given texture level to an image unit.<br/>
/// Note that for cube maps and cube map arrays the <paramref name="layer"/> parameter actually indexes the layer-faces.<br/>
/// Thus for cube maps the layer parameter equals the face to be bound.<br/>
/// For cube map arrays the layer parameter can be calculated as 6 * arrayLayer + face, which is done automatically when using
/// the corresponding overload <see cref="Bind(int,TextureCubemapArray,int,int,int,OpenTK.Graphics.OpenGL.TextureAccess)"/>.
/// </summary>
/// <param name="imageUnit">The image unit to use.</param>
/// <param name="texture">The texture to bind.</param>
/// <param name="level">The mipmap level to bind.</param>
/// <param name="layer">The layer of the texture to bind.</param>
/// <param name="access">Specifies the type of access allowed on the image.</param>
public void Bind(int imageUnit, LayeredTexture texture, int level, int layer, TextureAccess access)
{
Bind(imageUnit, texture, level, false, layer, access);
}
public void bindImageUnit(int texture_uniform, int index, TextureAccess access, int level)
{
bindImageUnit(texture_uniform, index, access, level, 0);
}
public void Bind(int location, TextureAccess access)
{
texture.BindImage(location, access, SizedInternalFormat.Rgba16f);
}
