public static void Bind(int textureUnit, TextureTarget target, uint textureID) { GL.ActiveTexture(TextureUnit.Texture0 + textureUnit); if (BindedTextures[textureUnit] == textureID) return; // on jo bindattu BindedTextures[textureUnit] = textureID; GL.BindTexture(target, textureID); }
internal void Activate(TextureTarget target, bool useMipmaps = false) { switch (this.Filter) { case TextureFilter.Linear: GL.TexParameter(target, TextureParameterName.TextureMinFilter, useMipmaps ? 9987 : 9729); GL.TexParameter(target, TextureParameterName.TextureMagFilter, 9729); break; case TextureFilter.Point: GL.TexParameter(target, TextureParameterName.TextureMinFilter, useMipmaps ? 9984 : 9728); GL.TexParameter(target, TextureParameterName.TextureMagFilter, 9728); break; case TextureFilter.Anisotropic: GL.TexParameter(target, TextureParameterName.TextureMinFilter, useMipmaps ? 9987 : 9729); GL.TexParameter(target, TextureParameterName.TextureMagFilter, 9729); break; case TextureFilter.MinLinearMagPointMipLinear: GL.TexParameter(target, TextureParameterName.TextureMinFilter, useMipmaps ? 9987 : 9729); GL.TexParameter(target, TextureParameterName.TextureMagFilter, 9728); break; default: throw new NotImplementedException(); } GL.TexParameter(target, TextureParameterName.TextureWrapS, this.GetWrapMode(this.AddressU)); GL.TexParameter(target, TextureParameterName.TextureWrapT, this.GetWrapMode(this.AddressV)); }
public Texture( TextureTarget target ) { TextureTarget = target; myID = -1; myLoaded = false; }
public void Upload(TextureTarget target, Region2D region) { GL.TexImage3D(target, 0, InternalFormat, Size.Width, Size.Height, Depth, 0, Format, Type, IntPtr.Zero); }
protected TextureBase(TextureTarget target) { Target = target; Name = GL.GenTexture(); Utilities.CheckGL(); }
Int32 Build1DMipmapLevel(TextureTarget target, Int32 internalFormat, Int32 width, PixelFormat format, PixelType type, Int32 level, Int32 @base, Int32 max, IntPtr data) { unsafe { return Delegates.gluBuild1DMipmapLevels((TextureTarget)target, (Int32)internalFormat, (Int32)width, (PixelFormat)format, (PixelType)type, (Int32)level, (Int32)@base, (Int32)max, (IntPtr)data); } }
Int32 Build1DMipmap(TextureTarget target, Int32 internalFormat, Int32 width, PixelFormat format, PixelType type, IntPtr data) { unsafe { return Delegates.gluBuild1DMipmaps((TextureTarget)target, (Int32)internalFormat, (Int32)width, (PixelFormat)format, (PixelType)type, (IntPtr)data); } }
public static unsafe void TexImage2D( TextureTarget target, int level, int internalformat, int width, int height, int border, PixelFormat format, byte[] pixels ) { fixed (byte *pix = &pixels[0]) { OpenGLNative.TexImage2D( target, level, internalformat, width, height, border, format, PixelType.UnsignedByte, pix ); } }
public GLTexture(int id, int width, int height, PixelFormatDescriptor pixelFormat, TextureTarget dimension) { Id = id; Width = width; Height = height; PixelFormat = pixelFormat; Dimension = dimension; }
/// <summary> /// /// </summary> public void Initialize(uint unit, TextureTarget target) { if (!this.initialized) { this.DoInitialize(unit, target); this.initialized = true; } }
public void SwitchFace(TextureTarget face) { if(!Generated) Generate(); GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, face, TexColor, 0); GL.DrawBuffer(DrawBufferMode.ColorAttachment0); }
public static unsafe void TexImage2D( TextureTarget target, int level, int internalformat, int width, int height, int border, PixelFormat format, PixelType type, byte[] pixels ) { if (pixels == null) OpenGLNative.TexImage2D( target, level, internalformat, width, height, border, format, type, null ); else fixed (byte* bytes = &pixels[0]) { OpenGLNative.TexImage2D( target, level, internalformat, width, height, border, format, type, bytes ); } }
protected TextureBase(TextureTarget target) { // set texture target mTextureTarget = target; // generate texture id GL.GenTextures (1, out mTextureId); }
/// <summary> /// Texture. /// </summary> /// <param name="target"></param> /// <param name="imageBuilder"></param> /// <param name="parameters"></param> /// <param name="mipmapFiltering"></param> public Texture( TextureTarget target, ImageFiller imageBuilder, SamplerParameters parameters, MipmapFilter mipmapFiltering = MipmapFilter.LinearMipmapLinear) : this(target, imageBuilder, new FakeSampler(parameters, mipmapFiltering)) { }
/// <summary> /// Texture. /// </summary> /// <param name="target"></param> /// <param name="bitmap"></param> /// <param name="parameters"></param> /// <param name="mipmapFiltering"></param> /// <param name="maxLevel"></param> /// <param name="border"></param> public Texture( TextureTarget target, Bitmap bitmap, SamplerParameters parameters, MipmapFilter mipmapFiltering = MipmapFilter.LinearMipmapLinear, int maxLevel = 0, int border = 0) : this(target, new BitmapFiller(bitmap, maxLevel, OpenGL.GL_RGBA, border, OpenGL.GL_BGRA, OpenGL.GL_UNSIGNED_BYTE, target == TextureTarget.Texture2D), new FakeSampler(parameters, mipmapFiltering)) { }
public Texture(int id, int width, int height, TextureTarget target, PixelInternalFormat format) { Width = width; Height = height; ID = id; TextureTarget = target; PixelInternalFormat = format; }
public void SwitchCamera(TextureTarget face) { if(!Generated) Generate(); var proj = FacesCameras[face].GetProjectionMatrix(); FacesCameras[face].Transformation.SetPosition(Transformation.GetPosition()); FacesCameras[face].SetProjectionMatrix(proj); Camera.Current = FacesCameras[face]; }
public Texture2DGL3x(Texture2DDescription description, TextureTarget textureTarget) { if (description.Width <= 0) { throw new ArgumentOutOfRangeException("description.Width", "description.Width must be greater than zero."); } if (description.Height <= 0) { throw new ArgumentOutOfRangeException("description.Height", "description.Height must be greater than zero."); } if (description.GenerateMipmaps) { if (textureTarget == TextureTarget.TextureRectangle) { throw new ArgumentException("description.GenerateMipmaps cannot be true for texture rectangles.", "description"); } if (!TextureUtility.IsPowerOfTwo(Convert.ToUInt32(description.Width))) { throw new ArgumentException("When description.GenerateMipmaps is true, the width must be a power of two.", "description"); } if (!TextureUtility.IsPowerOfTwo(Convert.ToUInt32(description.Height))) { throw new ArgumentException("When description.GenerateMipmaps is true, the height must be a power of two.", "description"); } } _name = new TextureNameGL3x(); _target = textureTarget; _description = description; _lastTextureUnit = OpenTKTextureUnit.Texture0 + (Device.NumberOfTextureUnits - 1); // // TexImage2D is just used to allocate the texture so a PBO can't be bound. // WritePixelBufferGL3x.UnBind(); BindToLastTextureUnit(); GL.TexImage2D(_target, 0, TypeConverterGL3x.To(description.TextureFormat), description.Width, description.Height, 0, TypeConverterGL3x.TextureToPixelFormat(description.TextureFormat), TypeConverterGL3x.TextureToPixelType(description.TextureFormat), new IntPtr()); // // Default sampler, compatiable when attaching a non-mimapped // texture to a frame buffer object. // ApplySampler(Device.TextureSamplers.LinearClamp); GC.AddMemoryPressure(description.ApproximateSizeInBytes); }
protected Texture(TextureTarget type, PixelInternalFormat format, OpenTK.Graphics.OpenGL.PixelFormat format2, int num) { ID = GL.GenTexture(); Type = type; Format = format; Number = num; Activate(); }
protected Texture(IOpenGL30 gl, TextureTarget target) { var newHandle = gl.GenTexture(); if(newHandle == 0u) throw new NoHandleCreatedException(); Target = target; this._gl = gl; Handle = newHandle; }
/// <summary> /// Texture. /// </summary> /// <param name="target"></param> /// <param name="imageBuilder"></param> /// <param name="samplerBuilder"></param> public Texture( TextureTarget target, ImageFiller imageBuilder, SamplerBase samplerBuilder) { if (imageBuilder == null || samplerBuilder == null) { throw new ArgumentNullException(); } this.Target = target; this.ImageFiller = imageBuilder; this.Sampler = samplerBuilder; }
/// <summary> /// texture's settings. /// </summary> /// <param name="unit">OpenGL.GL_TEXTURE0 etc.</param> /// <param name="target"></param> public override void Bind(uint unit, TextureTarget target) { /* Clamping to edges is important to prevent artifacts when scaling */ OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_WRAP_R, (int)this.parameters.wrapR); OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_WRAP_S, (int)this.parameters.wrapS); OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_WRAP_T, (int)this.parameters.wrapT); /* Linear filtering usually looks best for text */ OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_MIN_FILTER, (int)this.parameters.minFilter); OpenGL.TexParameteri((uint)target, OpenGL.GL_TEXTURE_MAG_FILTER, (int)this.parameters.magFilter); // TODO: mipmap filter not working yet. }
/// <summary> /// Constructor to create a new Texture instance. /// </summary> /// <param name="target">Texture target type used by the texture</param> /// <param name="width">Width of the texture in pixels</param> /// <param name="height">Height of the texture in pixels</param> /// <param name="depth">Depth of the texture in pixels</param> protected Texture(TextureTarget target, int width, int height, int depth = 1) { TextureTarget = target; Width = width; Height = height; Depth = depth; _id = -1; _loaded = false; }
public GLTexture(string name, TextureTarget type, int width, int height) { #if ENABLE_PROFILING allocatedTextureCounter++; allocatedTextureNames.Add(this, name); #endif this.type = type; this.width = width; this.height = height; }
public static void GetTexFilterFuncSGIS(TextureTarget target, Int32 filter, [Out] float[] weights) { unsafe { fixed (float* p_weights = weights) { Debug.Assert(Delegates.pglGetTexFilterFuncSGIS != null, "pglGetTexFilterFuncSGIS not implemented"); Delegates.pglGetTexFilterFuncSGIS((Int32)target, filter, p_weights); LogFunction("glGetTexFilterFuncSGIS({0}, {1}, {2})", target, LogEnumName(filter), LogValue(weights)); } } DebugCheckErrors(null); }
public Texture(int width, int height, TextureTarget type, PixelInternalFormat format, OpenTK.Graphics.OpenGL.PixelFormat format2, int num) { ID = GL.GenTexture(); Type = type; Format = format; Number = num; Activate(); GL.TexImage2D(Type, 0, Format, width, height, 0, format2, PixelType.UnsignedByte, IntPtr.Zero); }
/// <summary> /// Creates a new managed 2D Texture with an explicitly specified format /// </summary> /// <param name="width">The width in Pixels of the Texture</param> /// <param name="height">The height in Pixels of the Texture</param> /// <param name="format">The format to use</param> /// <param name="target">The target this Texture will be bound to</param> public Texture2D(int width, int height, PixelInternalFormat format, TextureTarget target = TextureTarget.Texture2D) : base(target) { _internalFormat = format; Activate(); GL.TexParameter(Target, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge); // GL_REPEAT GL.TexParameter(Target, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge); // GL_REPEAT GL.TexParameter(Target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear); GL.TexParameter(Target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); Resize(width, height); }
public static void SharpenTexFuncSGIS(TextureTarget target, Int32 n, float[] points) { unsafe { fixed (float* p_points = points) { Debug.Assert(Delegates.pglSharpenTexFuncSGIS != null, "pglSharpenTexFuncSGIS not implemented"); Delegates.pglSharpenTexFuncSGIS((Int32)target, n, p_points); CallLog("glSharpenTexFuncSGIS({0}, {1}, {2})", target, n, points); } } DebugCheckErrors(); }
/// <summary> /// Creates the CL image from GL texture. This can be a platfor specific operation. /// On some platforms, some of the parameters may be ignored. /// </summary> /// <returns>The CL image from GL texture.</returns> /// <param name="context">Context.</param> /// <param name="memFlags">Mem flags.</param> /// <param name="target">Target.</param> /// <param name="mipLevel">Mip level.</param> /// <param name="texturePointer">Texture pointer.</param> /// <param name="error">Error.</param> public static IMem CreateCLImageFromGLTexture(Context context, MemFlags memFlags, TextureTarget target, int mipLevel, IntPtr texturePointer, out ErrorCode error){ #if UNITY_STANDALONE_OSX || UNITY_IPHONE //here, we use a function from apple (gcl) headers var ret = new Mem(gcl_gl_create_image_from_texture(target,new IntPtr(mipLevel),texturePointer)); error = ErrorCode.Success; return ret; #endif #if UNITY_STANDALONE_WIN || UNITY_STANDALONE_LINUX || UNITY_ANDROID //here we use the GL sharing extensions. return new Mem(clCreateFromGLTexture2D((context as IHandleData).Handle,memFlags,target,new IntPtr(mipLevel),texturePointer,out error)); #endif }
public static void GetTexFilterFuncSGIS(TextureTarget target, Int32 filter, [Out] float[] weights) { unsafe { fixed (float* p_weights = weights) { Debug.Assert(Delegates.pglGetTexFilterFuncSGIS != null, "pglGetTexFilterFuncSGIS not implemented"); Delegates.pglGetTexFilterFuncSGIS((Int32)target, filter, p_weights); CallLog("glGetTexFilterFuncSGIS({0}, {1}, {2})", target, filter, weights); } } DebugCheckErrors(); }
internal static TextureTarget3d GetTextureTargetForDataSet3D(TextureTarget target) { return((TextureTarget3d)target); }
public unsafe partial void GetnCompressedTexImage([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] int lod, [Flow(FlowDirection.In)] uint bufSize, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] void *img);
public partial void GetnCompressedTexImage <T0>([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] int lod, [Flow(FlowDirection.In)] uint bufSize, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out T0 img) where T0 : unmanaged;
private void ReadFrom2D(IntPtr data, int layer, int level, int width, int height) { TextureTarget target = Target.Convert(); int mipSize = Info.GetMipSize2D(level); Bind(target, 0); FormatInfo format = FormatTable.GetFormatInfo(Info.Format); switch (Target) { case Target.Texture1D: if (format.IsCompressed) { GL.CompressedTexSubImage1D( target, level, 0, width, format.PixelFormat, mipSize, data); } else { GL.TexSubImage1D( target, level, 0, width, format.PixelFormat, format.PixelType, data); } break; case Target.Texture1DArray: if (format.IsCompressed) { GL.CompressedTexSubImage2D( target, level, 0, layer, width, 1, format.PixelFormat, mipSize, data); } else { GL.TexSubImage2D( target, level, 0, layer, width, 1, format.PixelFormat, format.PixelType, data); } break; case Target.Texture2D: if (format.IsCompressed) { GL.CompressedTexSubImage2D( target, level, 0, 0, width, height, format.PixelFormat, mipSize, data); } else { GL.TexSubImage2D( target, level, 0, 0, width, height, format.PixelFormat, format.PixelType, data); } break; case Target.Texture2DArray: case Target.Texture3D: case Target.CubemapArray: if (format.IsCompressed) { GL.CompressedTexSubImage3D( target, level, 0, 0, layer, width, height, 1, format.PixelFormat, mipSize, data); } else { GL.TexSubImage3D( target, level, 0, 0, layer, width, height, 1, format.PixelFormat, format.PixelType, data); } break; case Target.Cubemap: if (format.IsCompressed) { GL.CompressedTexSubImage2D( TextureTarget.TextureCubeMapPositiveX + layer, level, 0, 0, width, height, format.PixelFormat, mipSize, data); } else { GL.TexSubImage2D( TextureTarget.TextureCubeMapPositiveX + layer, level, 0, 0, width, height, format.PixelFormat, format.PixelType, data); } break; } }
private void ReadFrom(IntPtr data, int size) { TextureTarget target = Target.Convert(); Bind(target, 0); FormatInfo format = FormatTable.GetFormatInfo(Info.Format); int width = Info.Width; int height = Info.Height; int depth = Info.Depth; int offset = 0; for (int level = 0; level < Info.Levels; level++) { int mipSize = Info.GetMipSize(level); int endOffset = offset + mipSize; if ((uint)endOffset > (uint)size) { return; } switch (Info.Target) { case Target.Texture1D: if (format.IsCompressed) { GL.CompressedTexSubImage1D( target, level, 0, width, format.PixelFormat, mipSize, data); } else { GL.TexSubImage1D( target, level, 0, width, format.PixelFormat, format.PixelType, data); } break; case Target.Texture1DArray: case Target.Texture2D: if (format.IsCompressed) { GL.CompressedTexSubImage2D( target, level, 0, 0, width, height, format.PixelFormat, mipSize, data); } else { GL.TexSubImage2D( target, level, 0, 0, width, height, format.PixelFormat, format.PixelType, data); } break; case Target.Texture2DArray: case Target.Texture3D: case Target.CubemapArray: if (format.IsCompressed) { GL.CompressedTexSubImage3D( target, level, 0, 0, 0, width, height, depth, format.PixelFormat, mipSize, data); } else { GL.TexSubImage3D( target, level, 0, 0, 0, width, height, depth, format.PixelFormat, format.PixelType, data); } break; case Target.Cubemap: int faceOffset = 0; for (int face = 0; face < 6; face++, faceOffset += mipSize / 6) { if (format.IsCompressed) { GL.CompressedTexSubImage2D( TextureTarget.TextureCubeMapPositiveX + face, level, 0, 0, width, height, format.PixelFormat, mipSize / 6, data + faceOffset); } else { GL.TexSubImage2D( TextureTarget.TextureCubeMapPositiveX + face, level, 0, 0, width, height, format.PixelFormat, format.PixelType, data + faceOffset); } } break; } data += mipSize; offset += mipSize; width = Math.Max(1, width >> 1); height = Math.Max(1, height >> 1); if (Target == Target.Texture3D) { depth = Math.Max(1, depth >> 1); } } }
public unsafe partial void GetTexParameterI([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] EXT pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] uint * @params);
public abstract void TextureView([Flow(FlowDirection.In)] uint texture, [Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] uint origtexture, [Flow(FlowDirection.In)] InternalFormat internalformat, [Flow(FlowDirection.In)] uint minlevel, [Flow(FlowDirection.In)] uint numlevels, [Flow(FlowDirection.In)] uint minlayer, [Flow(FlowDirection.In)] uint numlayers);
public static void FramebufferTexture2DMultisampleEXT(FramebufferTarget target, FramebufferAttachment attachment, TextureTarget textarget, UInt32 texture, Int32 level, Int32 samples) { Debug.Assert(Delegates.pglFramebufferTexture2DMultisampleEXT != null, "pglFramebufferTexture2DMultisampleEXT not implemented"); Delegates.pglFramebufferTexture2DMultisampleEXT((Int32)target, (Int32)attachment, (Int32)textarget, texture, level, samples); LogCommand("glFramebufferTexture2DMultisampleEXT", null, target, attachment, textarget, texture, level, samples); DebugCheckErrors(null); }
public static unsafe void GetInternalformat(this ArbInternalformatQuery2 thisApi, [Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] InternalFormat internalformat, [Flow(FlowDirection.In)] InternalFormatPName pname, [Flow(FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(FlowDirection.Out)] Span <long> @params) { // SpanOverloader thisApi.GetInternalformat(target, internalformat, pname, count, out @params.GetPinnableReference()); }
public void LoadOpenGLTexture(STGenericTexture GenericTexture, int ArrayStartIndex = 0, bool LoadArrayLevels = false) { if (!Runtime.OpenTKInitialized || GLInitialized || IsFailedState) { return; } width = (int)GenericTexture.Width; height = (int)GenericTexture.Height; switch (GenericTexture.SurfaceType) { case STSurfaceType.Texture1D: TextureTarget = TextureTarget.Texture1D; break; case STSurfaceType.Texture2D: TextureTarget = TextureTarget.Texture2D; break; case STSurfaceType.Texture2D_Array: TextureTarget = TextureTarget.Texture2DArray; break; case STSurfaceType.Texture2D_Mulitsample: TextureTarget = TextureTarget.Texture2DMultisample; break; case STSurfaceType.Texture2D_Multisample_Array: TextureTarget = TextureTarget.Texture2DMultisampleArray; break; case STSurfaceType.Texture3D: TextureTarget = TextureTarget.Texture3D; break; case STSurfaceType.TextureCube: IsCubeMap = true; TextureTarget = TextureTarget.TextureCubeMap; break; case STSurfaceType.TextureCube_Array: IsCubeMap = true; TextureTarget = TextureTarget.TextureCubeMapArray; break; } if (GenericTexture.ArrayCount == 0) { GenericTexture.ArrayCount = 1; } List <STGenericTexture.Surface> Surfaces = new List <STGenericTexture.Surface>(); try { if (UseMipmaps && GenericTexture.ArrayCount == 1) { //Load surfaces with mip maps Surfaces = GenericTexture.GetSurfaces(ArrayStartIndex, false, 6); } else { //Only load first mip level. Will be generated after for (int i = 0; i < GenericTexture.ArrayCount; i++) { if (i >= ArrayStartIndex && i <= ArrayStartIndex + 6) //Only load up to 6 faces { Surfaces.Add(new STGenericTexture.Surface() { mipmaps = new List <byte[]>() { GenericTexture.GetImageData(i, 0) } }); } } } if (Surfaces.Count == 0 || Surfaces[0].mipmaps[0].Length == 0) { return; } IsCubeMap = Surfaces.Count == 6; ImageSize = Surfaces[0].mipmaps[0].Length; if (IsCubeMap) { TextureTarget = TextureTarget.TextureCubeMap; } //Force RGBA and use ST for decoding for weird width/heights //Open GL decoder has issues with certain width/heights Console.WriteLine($"width pow {width} {IsPow2(width)}"); Console.WriteLine($"height pow {height} {IsPow2(height)}"); if (!IsPow2(width) || !IsPow2(height)) { UseOpenGLDecoder = false; } pixelInternalFormat = PixelInternalFormat.Rgba; pixelFormat = OpenTK.Graphics.OpenGL.PixelFormat.Rgba; if (GenericTexture.Platform is Imaging.CTRSwizzle || GenericTexture.Platform is Imaging.GamecubeSwizzle || GenericTexture.Platform is Imaging.NitroSwizzle) { UseOpenGLDecoder = false; pixelFormat = OpenTK.Graphics.OpenGL.PixelFormat.Bgra; } if (UseOpenGLDecoder) { SetPixelFormats(GenericTexture.Platform.OutputFormat); } GLInitialized = true; for (int i = 0; i < Surfaces.Count; i++) { for (int MipLevel = 0; MipLevel < Surfaces[i].mipmaps.Count; MipLevel++) { uint width = Math.Max(1, GenericTexture.Width >> MipLevel); uint height = Math.Max(1, GenericTexture.Height >> MipLevel); if (!UseOpenGLDecoder) { Surfaces[i].mipmaps[MipLevel] = TryDecodeSurface(Surfaces[i].mipmaps[MipLevel], width, height, GenericTexture); } } } TexID = GenerateOpenGLTexture(this, Surfaces); if (IsCubeMap) { TextureWrapS = TextureWrapMode.Clamp; TextureWrapT = TextureWrapMode.Clamp; TextureWrapR = TextureWrapMode.Clamp; TextureMinFilter = TextureMinFilter.LinearMipmapLinear; TextureMagFilter = TextureMagFilter.Linear; } Surfaces.Clear(); } catch { IsFailedState = true; GLInitialized = false; return; } }
public unsafe static void GetnTexImage(TextureTarget target, int level, PixelFormat format, PixelType type, int bufSize, IntPtr pixels) => glGetnTexImage(target, level, format, type, bufSize, pixels);
/// <summary> /// Loads a compressed DDS file into an OpenGL texture. /// </summary> /// <param name="ResourceFile">The path to the DDS file.</param> private void LoadDDS(string ResourceFile) { using (BinaryReader stream = new BinaryReader(new FileStream(ResourceFile, FileMode.Open))) { string filecode = new string(stream.ReadChars(4)); if (filecode != "DDS ") // first 4 chars should be "DDS " { throw new Exception("File was not a DDS file format."); } DDS.DDSURFACEDESC2 imageData = DDS.DDSURFACEDESC2.FromBinaryReader(stream);//new DDS.DDSURFACEDESC2(stream); // read the DirectDraw surface descriptor this.Size = new Size((int)imageData.Width, (int)imageData.Height); if (imageData.LinearSize == 0) { throw new Exception("The linear scan line size was zero."); } bool compressed = true; int factor = 0, buffersize = 0, blocksize = 0; PixelInternalFormat format; switch (imageData.PixelFormat.FourCC) // check the compression type { case "DXT1": // DXT1 compression ratio is 8:1 format = PixelInternalFormat.CompressedRgbaS3tcDxt1Ext; factor = 2; blocksize = 8; break; case "DXT3": // DXT3 compression ratio is 4:1 format = PixelInternalFormat.CompressedRgbaS3tcDxt3Ext; factor = 4; blocksize = 16; break; case "DXT5": // DXT5 compression ratio is 4:1 format = PixelInternalFormat.CompressedRgbaS3tcDxt5Ext; factor = 4; blocksize = 16; break; default: compressed = false; if (imageData.PixelFormat.ABitMask == 0xf000 && imageData.PixelFormat.RBitMask == 0x0f00 && imageData.PixelFormat.GBitMask == 0x00f0 && imageData.PixelFormat.BBitMask == 0x000f && imageData.PixelFormat.RGBBitCount == 16) { format = PixelInternalFormat.Rgba; } else if (imageData.PixelFormat.ABitMask == unchecked ((int)0xff000000) && imageData.PixelFormat.RBitMask == 0x00ff0000 && imageData.PixelFormat.GBitMask == 0x0000ff00 && imageData.PixelFormat.BBitMask == 0x000000ff && imageData.PixelFormat.RGBBitCount == 32) { format = PixelInternalFormat.Rgba; } else { throw new Exception(string.Format("File compression \"{0}\" is not supported.", imageData.PixelFormat.FourCC)); } break; } if (imageData.LinearSize != 0) { buffersize = (int)((imageData.MipmapCount > 1) ? imageData.LinearSize * factor : imageData.LinearSize); } else { buffersize = (int)(stream.BaseStream.Length - stream.BaseStream.Position); } // read the pixel data and then pin it to memory so that the garbage collector // doesn't shuffle the data around while OpenGL is decompressing it byte[] pixels = stream.ReadBytes(buffersize); GCHandle pinned = GCHandle.Alloc(pixels, GCHandleType.Pinned); try { TextureTarget = (imageData.Height == 1 || imageData.Width == 1) ? TextureTarget.Texture1D : TextureTarget.Texture2D; TextureID = Gl.GenTexture(); Gl.BindTexture(TextureTarget, TextureID); Gl.TexParameteri(TextureTarget, TextureParameterName.TextureMinFilter, TextureParameter.Linear); Gl.TexParameteri(TextureTarget, TextureParameterName.TextureMagFilter, TextureParameter.Linear); int nOffset = 0, nWidth = (int)imageData.Width, nHeight = (int)imageData.Height; for (int i = 0; i < (imageData.MipmapCount == 0 ? 1 : imageData.MipmapCount); ++i) { if (nWidth == 0) { nWidth = 1; // smallest mipmap is 1x1 pixels } if (nHeight == 0) { nHeight = 1; } int nSize = 0; if (compressed) { nSize = ((nWidth + 3) / 4) * ((nHeight + 3) / 4) * blocksize; Gl.CompressedTexImage2D(TextureTarget, i, format, nWidth, nHeight, 0, nSize, (IntPtr)(pinned.AddrOfPinnedObject().ToInt64() + nOffset)); } else { PixelType pixelType = imageData.PixelFormat.RGBBitCount == 16 ? PixelType.UnsignedShort4444Reversed : PixelType.UnsignedInt8888Reversed; nSize = nWidth * nHeight * imageData.PixelFormat.RGBBitCount / 8; Gl.TexImage2D(TextureTarget, i, format, nWidth, nHeight, 0, PixelFormat.Bgra, pixelType, (IntPtr)(pinned.AddrOfPinnedObject().ToInt64() + nOffset)); } nOffset += nSize; nWidth /= 2; nHeight /= 2; } #if MEMORY_LOGGER MemoryLogger.AllocateTexture(TextureID, Size); #endif } catch (Exception) { // There was some sort of Dll related error, or the target GPU does not support glCompressedTexImage2DARB throw; } finally { pinned.Free(); } } }
internal void Apply(bool hasMipmap, SamplerState oldSamplerState, TextureTarget target) { if (Description.MinMipLevel != oldSamplerState.Description.MinMipLevel) { GL.TexParameter(target, TextureParameterName.TextureMinLod, Description.MinMipLevel); } if (Description.MaxMipLevel != oldSamplerState.Description.MaxMipLevel) { GL.TexParameter(target, TextureParameterName.TextureMaxLod, Description.MaxMipLevel); } if (textureWrapR != oldSamplerState.textureWrapR) { GL.TexParameter(target, TextureParameterName.TextureWrapR, (int)textureWrapR); } if (compareMode != oldSamplerState.compareMode) { GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int)compareMode); } if (compareFunc != oldSamplerState.compareFunc) { GL.TexParameter(target, TextureParameterName.TextureCompareFunc, (int)compareFunc); } #if !XENKO_GRAPHICS_API_OPENGLES if (borderColor != oldSamplerState.borderColor) { GL.TexParameter(target, TextureParameterName.TextureBorderColor, borderColor); } if (Description.MipMapLevelOfDetailBias != oldSamplerState.Description.MipMapLevelOfDetailBias) { GL.TexParameter(target, TextureParameterName.TextureLodBias, Description.MipMapLevelOfDetailBias); } if (minFilter != oldSamplerState.minFilter) { GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)minFilter); } #else // On OpenGL ES, we need to choose the appropriate min filter ourself if the texture doesn't contain mipmaps (done at PreDraw) if (minFilter != oldSamplerState.minFilter) { GL.TexParameter(target, TextureParameterName.TextureMinFilter, hasMipmap ? (int)minFilter : (int)minFilterNoMipmap); } #endif #if !XENKO_PLATFORM_IOS if (maxAnisotropy != oldSamplerState.maxAnisotropy && GraphicsDevice.HasAnisotropicFiltering) { GL.TexParameter(target, (TextureParameterName)OpenTK.Graphics.ES20.ExtTextureFilterAnisotropic.TextureMaxAnisotropyExt, Description.MaxAnisotropy); } #endif if (magFilter != oldSamplerState.magFilter) { GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)magFilter); } if (textureWrapS != oldSamplerState.textureWrapS) { GL.TexParameter(target, TextureParameterName.TextureWrapS, (int)textureWrapS); } if (textureWrapT != oldSamplerState.textureWrapT) { GL.TexParameter(target, TextureParameterName.TextureWrapT, (int)textureWrapT); } }
public unsafe static void GetnCompressedTexImage(TextureTarget target, int lod, int bufSize, IntPtr pixels) => glGetnCompressedTexImage(target, lod, bufSize, pixels);
/// <summary> /// Set a scalar texture parameter. /// </summary> /// <param name="target">Specificies the target for which the texture is bound.</param> /// <param name="pname">Specifies the name of a single-values texture parameter.</param> /// <param name="param">Specifies the value of pname.</param> public static void TexParameteri(TextureTarget target, TextureParameterName pname, TextureParameter param) { TexParameteri(target, pname, (int)param); }
public static uint CreateTexture(TextureTarget target) { uint[] textures = new uint[1]; glCreateTextures(target, 1, textures); return(textures[0]); }
public partial void GetTexParameterI([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] GetTextureParameter pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] out uint @params);
public static unsafe void CompressedTexSubImage1D <T0>(this ArbTextureCompression thisApi, [Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] int level, [Flow(FlowDirection.In)] int xoffset, [Flow(FlowDirection.In)] uint width, [Flow(FlowDirection.In)] InternalFormat format, [Flow(FlowDirection.In)] uint imageSize, [Count(Parameter = "imageSize"), Flow(FlowDirection.In)] ReadOnlySpan <T0> data) where T0 : unmanaged { // SpanOverloader thisApi.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, in data.GetPinnableReference()); }
public void FramebufferTexture2D(FramebufferTarget target, FramebufferAttachment attachment, TextureTarget face, int level) { GL.FramebufferTexture2D( target, attachment, face, textureObject, level ); }
public abstract void TexStorage3D([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] uint levels, [Flow(FlowDirection.In)] InternalFormat internalformat, [Flow(FlowDirection.In)] uint width, [Flow(FlowDirection.In)] uint height, [Flow(FlowDirection.In)] uint depth);
public unsafe static void GetTextureLevelParameter(TextureTarget texture, int level, uint pName, ref int parameters) => glGetTextureLevelParameteriv(texture, level, pName, ref parameters);
private void ReadFrom(IntPtr data, int size) { TextureTarget target = Target.Convert(); int baseLevel = 0; // glTexSubImage on cubemap views is broken on Intel, we have to use the storage instead. if (Target == Target.Cubemap && HwCapabilities.Vendor == HwCapabilities.GpuVendor.IntelWindows) { GL.ActiveTexture(TextureUnit.Texture0); GL.BindTexture(target, Storage.Handle); baseLevel = FirstLevel; } else { Bind(target, 0); } FormatInfo format = FormatTable.GetFormatInfo(Info.Format); int width = Info.Width; int height = Info.Height; int depth = Info.Depth; int offset = 0; for (int level = 0; level < Info.Levels; level++) { int mipSize = Info.GetMipSize(level); int endOffset = offset + mipSize; if ((uint)endOffset > (uint)size) { return; } switch (Target) { case Target.Texture1D: if (format.IsCompressed) { GL.CompressedTexSubImage1D( target, level, 0, width, format.PixelFormat, mipSize, data); } else { GL.TexSubImage1D( target, level, 0, width, format.PixelFormat, format.PixelType, data); } break; case Target.Texture1DArray: case Target.Texture2D: if (format.IsCompressed) { GL.CompressedTexSubImage2D( target, level, 0, 0, width, height, format.PixelFormat, mipSize, data); } else { GL.TexSubImage2D( target, level, 0, 0, width, height, format.PixelFormat, format.PixelType, data); } break; case Target.Texture2DArray: case Target.Texture3D: case Target.CubemapArray: if (format.IsCompressed) { GL.CompressedTexSubImage3D( target, level, 0, 0, 0, width, height, depth, format.PixelFormat, mipSize, data); } else { GL.TexSubImage3D( target, level, 0, 0, 0, width, height, depth, format.PixelFormat, format.PixelType, data); } break; case Target.Cubemap: int faceOffset = 0; for (int face = 0; face < 6; face++, faceOffset += mipSize / 6) { if (format.IsCompressed) { GL.CompressedTexSubImage2D( TextureTarget.TextureCubeMapPositiveX + face, baseLevel + level, 0, 0, width, height, format.PixelFormat, mipSize / 6, data + faceOffset); } else { GL.TexSubImage2D( TextureTarget.TextureCubeMapPositiveX + face, baseLevel + level, 0, 0, width, height, format.PixelFormat, format.PixelType, data + faceOffset); } } break; } data += mipSize; offset += mipSize; width = Math.Max(1, width >> 1); height = Math.Max(1, height >> 1); if (Target == Target.Texture3D) { depth = Math.Max(1, depth >> 1); } } }
public abstract unsafe void GetInternalformat([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] InternalFormat internalformat, [Flow(FlowDirection.In)] InternalFormatPName pname, [Flow(FlowDirection.In)] uint count, [Count(Parameter = "count"), Flow(FlowDirection.Out)] int * @params);
public unsafe static void CreateTextures(TextureTarget target, uint n, IntPtr textures) => glCreateTextures(target, n, textures);
public unsafe partial void GetnTexImage([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] int level, [Flow(FlowDirection.In)] PixelFormat format, [Flow(FlowDirection.In)] PixelType type, [Flow(FlowDirection.In)] uint bufSize, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] void *img);
public static void FramebufferTextureFaceARB(FramebufferTarget target, FramebufferAttachment attachment, uint texture, int level, TextureTarget face) { Debug.Assert(Delegates.pglFramebufferTextureFaceARB != null, "pglFramebufferTextureFaceARB not implemented"); Delegates.pglFramebufferTextureFaceARB((int)target, (int)attachment, texture, level, (int)face); LogCommand("glFramebufferTextureFaceARB", null, target, attachment, texture, level, face); DebugCheckErrors(null); }
public partial void TexBufferRange([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] SizedInternalFormat internalformat, [Flow(FlowDirection.In)] uint buffer, [Flow(FlowDirection.In)] nint offset, [Flow(FlowDirection.In)] nuint size);
public partial void GetnTexImage <T0>([Flow(FlowDirection.In)] TextureTarget target, [Flow(FlowDirection.In)] int level, [Flow(FlowDirection.In)] PixelFormat format, [Flow(FlowDirection.In)] PixelType type, [Flow(FlowDirection.In)] uint bufSize, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] out T0 img) where T0 : unmanaged;
private void CreateView() { TextureTarget target = Target.Convert(); FormatInfo format = FormatTable.GetFormatInfo(Info.Format); PixelInternalFormat pixelInternalFormat; if (format.IsCompressed) { pixelInternalFormat = (PixelInternalFormat)format.PixelFormat; } else { pixelInternalFormat = format.PixelInternalFormat; } int levels = Info.GetLevelsClamped(); GL.TextureView( Handle, target, _parent.Handle, pixelInternalFormat, FirstLevel, levels, FirstLayer, Info.GetLayers()); GL.ActiveTexture(TextureUnit.Texture0); GL.BindTexture(target, Handle); int[] swizzleRgba = new int[] { (int)Info.SwizzleR.Convert(), (int)Info.SwizzleG.Convert(), (int)Info.SwizzleB.Convert(), (int)Info.SwizzleA.Convert() }; if (Info.Format == Format.A1B5G5R5Unorm) { int temp = swizzleRgba[0]; int temp2 = swizzleRgba[1]; swizzleRgba[0] = swizzleRgba[3]; swizzleRgba[1] = swizzleRgba[2]; swizzleRgba[2] = temp2; swizzleRgba[3] = temp; } else if (Info.Format.IsBgr()) { // Swap B <-> R for BGRA formats, as OpenGL has no support for them // and we need to manually swap the components on read/write on the GPU. int temp = swizzleRgba[0]; swizzleRgba[0] = swizzleRgba[2]; swizzleRgba[2] = temp; } GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, swizzleRgba); int maxLevel = levels - 1; if (maxLevel < 0) { maxLevel = 0; } GL.TexParameter(target, TextureParameterName.TextureMaxLevel, maxLevel); GL.TexParameter(target, TextureParameterName.DepthStencilTextureMode, (int)Info.DepthStencilMode.Convert()); }
public abstract void FramebufferTexture2DMultisample([Flow(FlowDirection.In)] FramebufferTarget target, [Flow(FlowDirection.In)] FramebufferAttachment attachment, [Flow(FlowDirection.In)] TextureTarget textarget, [Flow(FlowDirection.In)] uint texture, [Flow(FlowDirection.In)] int level, [Flow(FlowDirection.In)] uint samples);