protected static void BuildMipmaps(PixelBox data) { int width = 0; int height = 0; int logW = 0; int logH = 0; int level = 0; PixelBox scaled = data; scaled.Data = data.Data; scaled.Left = data.Left; scaled.Right = data.Right; scaled.Top = data.Top; scaled.Bottom = data.Bottom; scaled.Front = data.Front; scaled.Back = data.Back; All format = GLESPixelUtil.GetGLOriginFormat(data.Format); All dataType = GLESPixelUtil.GetGLOriginDataType(data.Format); width = data.Width; height = data.Height; logW = ComputeLog(width); logH = ComputeLog(height); level = (logW > logH ? logW : logH); for (int mip = 0; mip <= level; mip++) { format = GLESPixelUtil.GetGLOriginFormat(scaled.Format); dataType = GLESPixelUtil.GetGLOriginDataType(scaled.Format); OpenGL.TexImage2D(All.Texture2D, mip, (int)format, width, height, 0, format, dataType, scaled.Data); GLESConfig.GlCheckError(null); if (mip != 0) { scaled.Data = IntPtr.Zero; } if (width > 1) { width = width / 2; } if (height > 1) { height = height / 2; } int sizeInBytes = PixelUtil.GetMemorySize(width, height, 1, data.Format); scaled = new PixelBox(width, height, 1, data.Format); var dataarr = new byte[sizeInBytes]; scaled.Data = Memory.PinObject(dataarr); Image.Scale(data, scaled, ImageFilter.Linear); } }
/// <summary> /// </summary> /// <param name="name"> </param> /// <param name="target"> </param> /// <param name="id"> </param> /// <param name="width"> </param> /// <param name="height"> </param> /// <param name="format"> </param> /// <param name="face"> </param> /// <param name="level"> </param> /// <param name="usage"> </param> /// <param name="crappyCard"> </param> /// <param name="writeGamma"> </param> /// <param name="fsaa"> </param> public GLESTextureBuffer(string basename, All targetfmt, int id, int width, int height, int format, int face, int level, BufferUsage usage, bool crappyCard, bool writeGamma, int fsaa) : base(0, 0, 0, Media.PixelFormat.Unknown, usage) { this._target = targetfmt; this._textureId = id; this._face = face; this._level = level; this._softwareMipmap = crappyCard; GLESConfig.GlCheckError(this); OpenGL.BindTexture(All.Texture2D, this._textureId); GLESConfig.GlCheckError(this); // Get face identifier this._faceTarget = this._target; // TODO verify who get this Width = width; Height = height; Depth = 1; _glInternalFormat = (All)format; Format = GLESPixelUtil.GetClosestAxiomFormat(_glInternalFormat); RowPitch = Width; SlicePitch = Height * Width; sizeInBytes = PixelUtil.GetMemorySize(Width, Height, Depth, Format); // Set up a pixel box _buffer = new PixelBox(Width, Height, Depth, Format); if (Width == 0 || Height == 0 || Depth == 0) { /// We are invalid, do not allocate a buffer return; } // Is this a render target? if (((int)Usage & (int)TextureUsage.RenderTarget) != 0) { // Create render target for each slice for (int zoffset = 0; zoffset < Depth; zoffset++) { string name = string.Empty; name = "rtt/" + GetHashCode() + "/" + basename; var target = new GLESSurfaceDescription(); target.Buffer = this; target.ZOffset = zoffset; RenderTexture trt = GLESRTTManager.Instance.CreateRenderTexture(name, target, writeGamma, fsaa); this._sliceTRT.Add(trt); Root.Instance.RenderSystem.AttachRenderTarget(this._sliceTRT[zoffset]); } } }
/// <summary> /// </summary> /// <param name="src"> </param> /// <param name="dstBox"> </param> public override void BlitFromMemory(PixelBox src, Media.BasicBox dstBox) { if (!this._buffer.Contains(dstBox)) { throw new ArgumentOutOfRangeException("Destination box out of range, GLESHardwarePixelBuffer.BlitToMemory"); } PixelBox scaled; if (src.Width != dstBox.Width || src.Height != dstBox.Height || src.Depth != dstBox.Depth) { LogManager.Instance.Write("[GLESHardwarePixelBuffer] Scale to destination size."); // Scale to destination size. Use DevIL and not iluScale because ILU screws up for // floating point textures and cannot cope with 3D images. // This also does pixel format conversion if needed AllocateBuffer(); scaled = this._buffer.GetSubVolume(dstBox); Image.Scale(src, scaled, ImageFilter.Bilinear); } else if ((src.Format != Format) || ((GLESPixelUtil.GetGLOriginFormat(src.Format) == 0) && (src.Format != PixelFormat.R8G8B8))) { LogManager.Instance.Write("[GLESHardwarePixelBuffer] Extents match, but format is not accepted as valid source format for GL."); LogManager.Instance.Write("[GLESHardwarePixelBuffer] Source.Format = {0}, Format = {1}, GLOriginFormat = {2}", src.Format, Format, GLESPixelUtil.GetGLOriginFormat(src.Format)); // Extents match, but format is not accepted as valid source format for GL // do conversion in temporary buffer AllocateBuffer(); scaled = this._buffer.GetSubVolume(dstBox); PixelConverter.BulkPixelConversion(src, scaled); } else { LogManager.Instance.Write("[GLESHardwarePixelBuffer] No scaling or conversion needed."); scaled = src; if (src.Format == PixelFormat.R8G8B8) { scaled.Format = PixelFormat.R8G8B8; PixelConverter.BulkPixelConversion(src, scaled); } // No scaling or conversion needed // Set extents for upload scaled.Left = dstBox.Left; scaled.Right = dstBox.Right; scaled.Top = dstBox.Top; scaled.Bottom = dstBox.Bottom; scaled.Front = dstBox.Front; scaled.Back = dstBox.Back; } Upload(scaled, dstBox); FreeBuffer(); }
/// <summary> /// </summary> /// <param name="format"> </param> /// <param name="width"> </param> /// <param name="height"> </param> /// <param name="numSamples"> </param> public GLESRenderBuffer(All format, int width, int height, int numSamples) : base(width, height, 1, GLESPixelUtil.GetClosestAxiomFormat(format), BufferUsage.WriteOnly) { _glInternalFormat = format; /// Generate renderbuffer OpenGLOES.GenRenderbuffers(1, ref this._renderbufferID); GLESConfig.GlCheckError(this); /// Bind it to FBO OpenGLOES.BindRenderbuffer(All.RenderbufferOes, this._renderbufferID); GLESConfig.GlCheckError(this); /// Allocate storage for depth buffer if (numSamples <= 0) { OpenGLOES.RenderbufferStorage(All.RenderbufferOes, format, width, height); GLESConfig.GlCheckError(this); } }
/// <summary> /// </summary> /// <param name="data"> </param> /// <param name="dest"> </param> protected override void Upload(PixelBox data, BasicBox dest) { OpenGL.BindTexture(this._target, this._textureId); GLESConfig.GlCheckError(this); if (PixelUtil.IsCompressed(data.Format)) { if (data.Format != Format || !data.IsConsecutive) { throw new AxiomException("Compressed images must be consecutive, in the source format"); } if (data.Format != Format || !data.IsConsecutive) { throw new AxiomException("Compressed images must be consecutive, in the source format."); } All format = GLESPixelUtil.GetClosestGLInternalFormat(Format); // Data must be consecutive and at beginning of buffer as PixelStorei not allowed // for compressed formats if (dest.Left == 0 && dest.Top == 0) { OpenGL.CompressedTexImage2D(All.Texture2D, this._level, format, dest.Width, dest.Height, 0, data.ConsecutiveSize, data.Data); } else { OpenGL.CompressedTexSubImage2D(All.Texture2D, this._level, dest.Left, dest.Top, dest.Width, dest.Height, format, data.ConsecutiveSize, data.Data); } GLESConfig.GlCheckError(this); } else if (this._softwareMipmap) { if (data.Width != data.RowPitch) { //TODO throw new AxiomException("Unsupported Texture format!"); } if (data.Height * data.Width != data.SlicePitch) { //TODO throw new AxiomException("Unsupported Texture format!"); } OpenGL.PixelStore(All.UnpackAlignment, 1); GLESConfig.GlCheckError(this); BuildMipmaps(data); } else { if (data.Width != data.RowPitch) { //TODO throw new AxiomException("Unsupported Texture format!"); } if (data.Height * data.Width != data.SlicePitch) { //TODO throw new AxiomException("Unsupported Texture format!"); } if (((data.Width * PixelUtil.GetNumElemBytes(data.Format)) & 3) != 0) { // Standard alignment of 4 is not right OpenGL.PixelStore(All.UnpackAlignment, 1); GLESConfig.GlCheckError(this); } All form = GLESPixelUtil.GetGLOriginFormat(data.Format); All pix = GLESPixelUtil.GetGLOriginDataType(data.Format); GLESConfig.GlCheckError(this); GL.TexSubImage2D(this._faceTarget, this._level, dest.Left, dest.Top, dest.Width, dest.Height, GLESPixelUtil.GetGLOriginFormat(data.Format), GLESPixelUtil.GetGLOriginDataType(data.Format), data.Data); GLESConfig.GlCheckError(this); } OpenGL.PixelStore(All.UnpackAlignment, 4); GLESConfig.GlCheckError(this); }
/// <summary> /// </summary> protected override void createInternalResources() { // Convert to nearest power-of-two size if required Width = GLESPixelUtil.OptionalPO2(Width); Height = GLESPixelUtil.OptionalPO2(Height); Depth = GLESPixelUtil.OptionalPO2(Depth); //adjust format if required Format = TextureManager.Instance.GetNativeFormat(Graphics.TextureType.TwoD, Format, Usage); // Check requested number of mipmaps int maxMips = GLESPixelUtil.GetMaxMipmaps(Width, Height, Depth, Format); if (PixelUtil.IsCompressed(Format) && _mipmapCount == 0) { RequestedMipmapCount = 0; } _mipmapCount = RequestedMipmapCount; if (_mipmapCount > maxMips) { _mipmapCount = maxMips; } // Generate texture name OpenGL.GenTextures(1, ref this._textureID); GLESConfig.GlCheckError(this); // Set texture type OpenGL.BindTexture(All.Texture2D, this._textureID); GLESConfig.GlCheckError(this); // Set some misc default parameters, these can of course be changed later OpenGL.TexParameter(All.Texture2D, All.TextureMinFilter, (int)All.LinearMipmapNearest); GLESConfig.GlCheckError(this); OpenGL.TexParameter(All.Texture2D, All.TextureMagFilter, (int)All.Nearest); GLESConfig.GlCheckError(this); OpenGL.TexParameter(All.Texture2D, All.TextureWrapS, (int)All.ClampToEdge); GLESConfig.GlCheckError(this); OpenGL.TexParameter(All.Texture2D, All.TextureWrapT, (int)All.ClampToEdge); GLESConfig.GlCheckError(this); // If we can do automip generation and the user desires this, do so MipmapsHardwareGenerated = Root.Instance.RenderSystem.HardwareCapabilities.HasCapability(Capabilities.HardwareMipMaps) && !PixelUtil.IsCompressed(Format); if ((Usage & TextureUsage.AutoMipMap) == TextureUsage.AutoMipMap && RequestedMipmapCount > 0 && MipmapsHardwareGenerated) { OpenGL.TexParameter(All.Texture2D, All.GenerateMipmap, (int)All.True); GLESConfig.GlCheckError(this); } // Allocate internal buffer so that TexSubImageXD can be used // Internal format All format = GLESPixelUtil.GetClosestGLInternalFormat(Format, HardwareGammaEnabled); int width = Width; int height = Height; int depth = Depth; if (PixelUtil.IsCompressed(Format)) { // Compressed formats int size = PixelUtil.GetMemorySize(Width, Height, Depth, Format); // Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not // accept a 0 pointer like normal glTexImageXD // Run through this process for every mipmap to pregenerate mipmap pyramid var tmpData = new byte[size]; IntPtr tmpDataptr = Memory.PinObject(tmpData); for (int mip = 0; mip <= MipmapCount; mip++) { size = PixelUtil.GetMemorySize(Width, Height, Depth, Format); OpenGL.CompressedTexImage2D(All.Texture2D, mip, format, width, height, 0, size, tmpDataptr); GLESConfig.GlCheckError(this); if (width > 1) { width = width / 2; } if (height > 1) { height = height / 2; } if (depth > 1) { depth = depth / 2; } } Memory.UnpinObject(tmpData); } else { // Run through this process to pregenerate mipmap pyramid for (int mip = 0; mip <= MipmapCount; mip++) { OpenGL.TexImage2D(All.Texture2D, mip, (int)format, width, height, 0, format, All.UnsignedByte, IntPtr.Zero); GLESConfig.GlCheckError(this); if (width > 1) { width = width / 2; } if (height > 1) { height = height / 2; } } } CreateSurfaceList(); // Get final internal format Format = GetBuffer(0, 0).Format; }
/// <summary> /// </summary> protected void CreateSurfaceList() { this._surfaceList.Clear(); // For all faces and mipmaps, store surfaces as HardwarePixelBufferSharedPtr bool wantGenerateMips = (Usage & TextureUsage.AutoMipMap) == TextureUsage.AutoMipMap; // Do mipmapping in software? (uses GLU) For some cards, this is still needed. Of course, // only when mipmap generation is desired. bool doSoftware = wantGenerateMips && !MipmapsHardwareGenerated && MipmapCount > 0; for (int face = 0; face < faceCount; face++) { int width = Width; int height = Height; for (int mip = 0; mip <= MipmapCount; mip++) { HardwarePixelBuffer buf = new GLESTextureBuffer(Name, GLESTextureTarget, this._textureID, width, height, (int)GLESPixelUtil.GetClosestGLInternalFormat(Format, HardwareGammaEnabled), face, mip, (BufferUsage)Usage, doSoftware && mip == 0, HardwareGammaEnabled, FSAA); this._surfaceList.Add(buf); // If format is PVRTC then every mipmap is a custom one so to allow the upload of the compressed data // provided by the file we need to adjust the current mip level's dimention #warning Compressed Textures are not yet supported by axiom /* * if (mFormat == PF_PVRTC_RGB2 || mFormat == PF_PVRTC_RGBA2 || * mFormat == PF_PVRTC_RGB4 || mFormat == PF_PVRTC_RGBA4) * { * if (width > 1) * { * width = width / 2; * } * if (height > 1) * { * height = height / 2; * } * }*/ /// Check for error if (buf.Width == 0 || buf.Height == 0 || buf.Depth == 0) { throw new AxiomException(string.Format("Zero sized texture surface on texture: {0} face: {1} mipmap : {2}. The GL driver probably refused to create the texture.", Name, face, mip)); } } } }
/// <summary> /// Detect which internal formats are allowed as RTT Also detect what combinations of stencil and depth are allowed with this internal format. /// </summary> private void DetectFBOFormats() { // Try all formats, and report which ones work as target int fb = 0, tid = 0; All target = All.Texture2D; for (int x = 0; x < (int)Media.PixelFormat.Count; x++) { LogManager.Instance.Write("[GLES] [DEBUG] testing PixelFormat : {0}", (Media.PixelFormat)x); this._props[x] = new FormatProperties(); this._props[x].Modes = new List <FormatProperties.Mode>(); this._props[x].IsValid = false; // Fetch GL format token All fmt = GLESPixelUtil.GetClosestGLInternalFormat((Media.PixelFormat)x); LogManager.Instance.Write("[GLES] [DEBUG] fmt={0}", fmt); if (fmt == All.Zero && x != 0) { continue; } // No test for compressed formats if (PixelUtil.IsCompressed((Media.PixelFormat)x)) { continue; } // Create and attach framebuffer OpenGLOES.GenRenderbuffers(1, ref fb); GLESConfig.GlCheckError(this); OpenGLOES.BindFramebuffer(All.FramebufferOes, fb); GLESConfig.GlCheckError(this); if (fmt != All.Zero) { // Create and attach texture OpenGL.GenTextures(1, ref tid); GLESConfig.GlCheckError(this); OpenGL.BindTexture(target, tid); GLESConfig.GlCheckError(this); // Set some default parameters OpenGL.TexParameterx(target, All.TextureMinFilter, (int)All.LinearMipmapNearest); GLESConfig.GlCheckError(this); OpenGL.TexParameterx(target, All.TextureMagFilter, (int)All.Nearest); GLESConfig.GlCheckError(this); OpenGL.TexParameterx(target, All.TextureWrapS, (int)All.ClampToEdge); GLESConfig.GlCheckError(this); OpenGL.TexParameterx(target, All.TextureWrapT, (int)All.ClampToEdge); GLESConfig.GlCheckError(this); OpenGL.TexImage2D(target, 0, (int)fmt, ProbeSize, ProbeSize, 0, fmt, All.UnsignedByte, IntPtr.Zero); GLESConfig.GlCheckError(this); OpenGLOES.FramebufferTexture2D(All.FramebufferOes, All.ColorAttachment0Oes, target, tid, 0); GLESConfig.GlCheckError(this); } // Check status All status = OpenGLOES.CheckFramebufferStatus(All.FramebufferOes); GLESConfig.GlCheckError(this); LogManager.Instance.Write("[GLES] [DEBUG] status={0}", status); // Ignore status in case of fmt==GL_NONE, because no implementation will accept // a buffer without *any* attachment. Buffers with only stencil and depth attachment // might still be supported, so we must continue probing. if (fmt == 0 || status == All.FramebufferCompleteOes) { this._props[x].IsValid = true; var str = new StringBuilder(); str.Append("FBO " + PixelUtil.GetFormatName((Media.PixelFormat)x) + " depth/stencil support: "); // For each depth/stencil formats for (int depth = 0; depth < DepthFormats.Length; ++depth) { if (DepthFormats[depth] != All.Depth24Stencil8Oes) { // General depth/stencil combination for (int stencil = 0; stencil < StencilFormats.Length; ++stencil) { if (TryFormat(DepthFormats[depth], StencilFormats[stencil])) { /// Add mode to allowed modes str.Append("D" + DepthBits[depth] + "S" + StencilBits[stencil] + " "); var mode = new FormatProperties.Mode(); mode.Depth = depth; mode.Stencil = stencil; this._props[x].Modes.Add(mode); } } //end for stencil } //end if else { // Packed depth/stencil format if (TryPacketFormat(DepthFormats[depth])) { /// Add mode to allowed modes str.Append("Packed-D" + DepthBits[depth] + "S8" + " "); var mode = new FormatProperties.Mode(); mode.Depth = depth; mode.Stencil = 0; //unused this._props[x].Modes.Add(mode); } } } //end for depth LogManager.Instance.Write(str.ToString()); } //end if // Delete texture and framebuffer #if AXIOM_PLATFORM_IPHONE // The screen buffer is 1 on iPhone OpenGLOES.BindFramebuffer(All.FramebufferOes, 1); #else OpenGLOES.BindFramebuffer(All.FramebufferOes, 0); #endif GLESConfig.GlCheckError(this); OpenGLOES.DeleteFramebuffers(1, ref fb); GLESConfig.GlCheckError(this); if (fmt != 0) { OpenGL.DeleteTextures(1, ref tid); } } //end for pixelformat count string fmtstring = string.Empty; for (int x = 0; x < (int)Media.PixelFormat.Count; x++) { if (this._props[x].IsValid) { fmtstring += PixelUtil.GetFormatName((Media.PixelFormat)x); } } LogManager.Instance.Write("[GLES] : Valid FBO targets " + fmtstring); }
/// <summary> /// </summary> /// <param name="srcBox"> </param> /// <param name="dst"> </param> public override void BlitToMemory(BasicBox srcBox, PixelBox dst) { if (!this._buffer.Contains(srcBox)) { throw new ArgumentOutOfRangeException("source boux out of range"); } if (srcBox.Left == 0 && srcBox.Right == Width && srcBox.Top == 0 && srcBox.Bottom == Height && srcBox.Front == 0 && srcBox.Back == Depth && dst.Width == Width && dst.Height == Height && dst.Depth == Depth && GLESPixelUtil.GetGLOriginFormat(dst.Format) != 0) { // The direct case: the user wants the entire texture in a format supported by GL // so we don't need an intermediate buffer Download(dst); } else { // Use buffer for intermediate copy AllocateBuffer(); //download entire buffer Download(this._buffer); if (srcBox.Width != dst.Width || srcBox.Height != dst.Height || srcBox.Depth != dst.Depth) { // we need scaling Image.Scale(this._buffer.GetSubVolume(srcBox), dst, ImageFilter.Bilinear); } else { // Just copy the bit that we need PixelConverter.BulkPixelConversion(this._buffer.GetSubVolume(srcBox), dst); } FreeBuffer(); } }