/// <summary> /// Constructor. /// </summary> /// <param name="displaySize"> /// Size object describing the initial display resolution. /// </param> protected OpenGLRendererBase(Sizef displaySize) { d_displaySize = displaySize; Init(); d_defaultTarget = new OpenGLViewportTarget(this); }
/// <summary> /// Updates the rendering state for the specified \a item using the specified /// \a index as the data source. /// </summary> /// <param name="item"></param> /// <param name="index"></param> /// <param name="maxWidth"></param> /// <param name="totalHeight"></param> private void UpdateItem(ListViewItemRenderingState item, ModelIndex index, ref float maxWidth, ref float totalHeight) { var text = d_itemModel.GetData(index); var isSelected = IsIndexSelected(index); var initialColours = isSelected ? _selectionTextColourRect : d_textColourRect; var renderedString = GetRenderedStringParser().Parse(text, GetFont(), initialColours); item.d_string = renderedString; item.d_index = index; item.d_text = text; item.d_icon = d_itemModel.GetData(index, ItemDataRole.IDR_Icon); var iconSize = Sizef.Zero; if (!String.IsNullOrEmpty(item.d_icon)) { iconSize = ImageManager.GetSingleton().Get(item.d_icon).GetRenderedSize(); } var textSize = new Sizef(renderedString.GetHorizontalExtent(this), renderedString.GetVerticalExtent(this)); item.d_size = new Sizef(iconSize.Width + textSize.Width, Math.Max(iconSize.Height, textSize.Height)); maxWidth = Math.Max(item.d_size.Width, maxWidth); totalHeight += item.d_size.Height; item.d_isSelected = isSelected;//IsIndexSelected(index); }
/// <summary> /// Constructor that wraps an existing GL texture. /// </summary> /// <param name="tex"></param> /// <param name="size"></param> protected internal void Initialise(int /*GLuint*/ tex, Sizef size) { d_ogltexture = tex; d_size = size; d_dataSize = size; InitInternalPixelFormatFields(PixelFormat.RGBA); UpdateCachedScaleValues(); }
/// <summary> /// set the size of the internal texture. /// </summary> /// <param name="sz"> /// size for the internal texture, in pixels. /// </param> /// <remarks> /// Depending upon the hardware capabilities, the actual final size of the /// texture may be larger than what is specified when calling this function. /// The texture will never be smaller than what you request here. To /// discover the actual size, call getSize. /// </remarks> /// <exception cref="InvalidOperationException"> /// thrown if the hardware is unable to support a texture large enough to /// fulfill the requested size. /// </exception> public void SetTextureSize(Sizef sz) { InitInternalPixelFormatFields(PixelFormat.RGBA); SetTextureSizeImpl(sz); d_dataSize = d_size; UpdateCachedScaleValues(); }
/// <summary> /// helper to set display size with current viewport size. /// </summary> protected void InitialiseDisplaySizeWithViewportSize() { ThrowIfDisposed(); var vp = new int[4]; OpenGL.GL.GetInteger(OpenGL.GetPName.Viewport, vp); d_displaySize = new Sizef((float)vp[2], (float)vp[3]); }
public override void AutoPositionSize(Lunatics.Mathematics.Vector2 position, Sizef ownerSize) { var view = GetView(); var totalArea = view.GetUnclippedOuterRect().Get(); var contentArea = _itemViewRenderer.GetViewRenderArea(view, false, false); var withScrollContentArea = _itemViewRenderer.GetViewRenderArea(view, true, true); var frameSize = totalArea.Size - contentArea.Size; var withScrollFrameSize = totalArea.Size - withScrollContentArea.Size; var contentSize = new Sizef(view.GetRenderedMaxWidth(), view.GetRenderedTotalHeight()); var parentSize = view.GetParentPixelSize(); var maxSize = new Sizef(ownerSize.Width /*parentSize.Width - CoordConverter.AsAbsolute(view.GetXPosition(), parentSize.Width)*/, 0.8f * parentSize.Height /*CoordConverter.AsAbsolute(view.GetYPosition(), parentSize.Height)*/); var requiredSize = frameSize + contentSize + new Sizef(1, 1); if (requiredSize.Height > maxSize.Height) { requiredSize.Height = maxSize.Height; requiredSize.Width = Math.Min(maxSize.Width, requiredSize.Width - frameSize.Width + withScrollFrameSize.Width); view.SetVertScrollbarDisplayMode(ScrollbarDisplayMode.Shown); } else { view.SetVertScrollbarDisplayMode(ScrollbarDisplayMode.Hidden); } requiredSize.Width = ownerSize.Width; if (requiredSize.Width > maxSize.Width) { requiredSize.Width = maxSize.Width; requiredSize.Height = Math.Min(maxSize.Height, requiredSize.Height - frameSize.Height + withScrollFrameSize.Height); view.SetHorzScrollbarDisplayMode(ScrollbarDisplayMode.Shown); } else { view.SetHorzScrollbarDisplayMode(ScrollbarDisplayMode.Hidden); } var posY = position.Y + (ownerSize.Height - requiredSize.Height) / 2f; posY = posY < 0f ? 0f : posY; posY -= posY + requiredSize.Height > parentSize.Height //? parentSize.Height - (posY + requiredSize.Height + 1f) ? (posY + requiredSize.Height) - parentSize.Height : 0f; view.SetPosition(new UVector2(UDim.Absolute(position.X), UDim.Absolute(posY))); view.SetHeight(new UDim(0, requiredSize.Height)); view.SetWidth(new UDim(0, requiredSize.Width)); }
public TreeViewItemRenderingState(TreeView attached_tree_view) { d_totalChildCount = 0; d_size = Sizef.Zero; d_isSelected = false; d_childId = 0; d_subtreeIsExpanded = false; d_nestedLevel = 0; d_attachedTreeView = attached_tree_view; }
public virtual Sizef getSize() { Sizef ret = new Sizef(solar_api_input_filesPINVOKE.IMarker2DSquared_getSize(swigCPtr), false); if (solar_api_input_filesPINVOKE.SWIGPendingException.Pending) { throw solar_api_input_filesPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public override void ResizeListToContent(bool fitWidth, bool fitHeight) { var lb = (Listbox)Window; var totalArea = lb.GetUnclippedOuterRect().Get(); var contentArea = GetItemRenderingArea(!fitWidth && lb.GetHorzScrollbar().IsVisible(), !fitHeight && lb.GetVertScrollbar().IsVisible()); var withScrollContentArea = GetItemRenderingArea(true, true); var frameSize = totalArea.Size - contentArea.Size; var withScrollFrameSize = totalArea.Size - withScrollContentArea.Size; var contentSize = new Sizef(lb.GetWidestItemWidth(), lb.GetTotalItemsHeight()); var parentSize = lb.GetParentPixelSize(); var maxSize = new Sizef(parentSize.Width - CoordConverter.AsAbsolute(lb.GetXPosition(), parentSize.Width), parentSize.Height - CoordConverter.AsAbsolute(lb.GetYPosition(), parentSize.Height)); var requiredSize = frameSize + contentSize + new Sizef(1, 1); if (fitHeight) { if (requiredSize.Height > maxSize.Height) { requiredSize.Height = maxSize.Height; requiredSize.Width = Math.Min(maxSize.Width, requiredSize.Width - frameSize.Width + withScrollFrameSize.Width); } } if (fitWidth) { if (requiredSize.Width > maxSize.Width) { requiredSize.Width = maxSize.Width; requiredSize.Height = Math.Min(maxSize.Height, requiredSize.Height - frameSize.Height + withScrollFrameSize.Height); } } if (fitHeight) { lb.SetHeight(new UDim(0, requiredSize.Height)); } if (fitWidth) { lb.SetWidth(new UDim(0, requiredSize.Width)); } }
/// <summary> /// Constructor for OpenGL Renderer objects. /// </summary> /// <param name="displaySize"> /// Size object describing the initial display resolution. /// </param> protected OpenGL3Renderer(Sizef displaySize) : base(displaySize) { d_shaderWrapperTextured = null; d_openGLStateChanger = null; d_shaderManager = null; InitialiseRendererIDString(); d_openGLStateChanger = new OpenGL3StateChangeWrapper(); InitialiseTextureTargetFactory(); InitialiseOpenGLShaders(); }
protected override int GetCompressedTextureSize(Sizef pixelSize) { var blocksize = 16; if (d_format == (OpenGL.PixelFormat) 0x83F0 /*GL_COMPRESSED_RGB_S3TC_DXT1_EXT*/ || d_format == (OpenGL.PixelFormat) 0x83F1 /*GL_COMPRESSED_RGBA_S3TC_DXT1_EXT*/) { blocksize = 8; } return((int)(Math.Ceiling(pixelSize.Width / 4) * Math.Ceiling(pixelSize.Height / 4) * blocksize)); }
protected override void SetTextureSizeImpl(Sizef sz) { var size = _owner.GetAdjustedTextureSize(sz); d_size = size; // make sure size is within boundaries float /*GLfloat*/ maxSize; OpenGL.GL.GetFloat(OpenGL.GetPName.MaxTextureSize, out maxSize); if ((size.Width > maxSize) || (size.Height > maxSize)) { throw new InvalidOperationException("size too big"); } // save old texture binding int /*GLuint*/ oldTex; OpenGL.GL.GetInteger(OpenGL.GetPName.TextureBinding2D, out oldTex); // set texture to required size OpenGL.GL.BindTexture(OpenGL.TextureTarget.Texture2D, d_ogltexture); if (d_isCompressed) { var imageSize = GetCompressedTextureSize(size); OpenGL.GL.CompressedTexImage2D(OpenGL.TextureTarget.Texture2D, 0, (OpenGL.PixelInternalFormat)d_format, (int)size.Width, (int)d_size.Height, 0, imageSize, IntPtr.Zero); } else { OpenGL.GL.TexImage2D(OpenGL.TextureTarget.Texture2D, 0, OpenGL.PixelInternalFormat.Rgba8, (int)size.Width, (int)d_size.Height, 0, OpenGL.PixelFormat.Rgba, OpenGL.PixelType.UnsignedByte, IntPtr.Zero);; } // restore previous texture binding. OpenGL.GL.BindTexture(OpenGL.TextureTarget.Texture2D, oldTex); }
public override Sizef GetAdjustedTextureSize(Sizef sz) { var @out = sz; // if we can't support non power of two sizes, get appropriate POT values. if (!GLEW_ARB_texture_non_power_of_two) { @out.Width = GetNextPowerOfTwoSize(@out.Width); @out.Height = GetNextPowerOfTwoSize(@out.Height); } return(@out); }
/// <summary> /// set the openGL texture that this Texture is based on to the specifiedSystem.Runtime.InteropServices. /// texture, with the specified size. /// </summary> /// <param name="tex"></param> /// <param name="size"></param> public void SetOpenGLTexture(int tex, Sizef size) { if (d_ogltexture != tex) { // cleanup the current state first. CleanupOpenGLTexture(); d_ogltexture = tex; } d_dataSize = d_size = size; UpdateCachedScaleValues(); }
/// <summary> /// internal texture resize function (does not reset format or other fields) /// </summary> /// <param name="sz"></param> protected virtual void SetTextureSizeImpl(Sizef sz) { var size = _owner.GetAdjustedTextureSize(sz); d_size = size; // make sure size is within boundaries float maxSize; OpenGL.GL.GetFloat(OpenGL.GetPName.MaxTextureSize, out maxSize); if ((size.Width > maxSize) || (size.Height > maxSize)) { throw new InvalidOperationException("size too big"); } // save old texture binding int old_tex; OpenGL.GL.GetInteger(OpenGL.GetPName.TextureBinding2D, out old_tex); // set texture to required size OpenGL.GL.BindTexture(OpenGL.TextureTarget.Texture2D, d_ogltexture); if (d_isCompressed) { var image_size = GetCompressedTextureSize(size); OpenGL.GL.CompressedTexImage2D(OpenGL.TextureTarget.Texture2D, 0, (Lunatics.SDLGL.OpenGL.PixelInternalFormat)d_format, (int)(size.Width), (int)(size.Height), 0, image_size, IntPtr.Zero); } else { OpenGL.GL.TexImage2D(OpenGL.TextureTarget.Texture2D, 0, (Lunatics.SDLGL.OpenGL.PixelInternalFormat)d_format, (int)(size.Width), (int)(size.Height), 0, d_format, d_subpixelFormat, IntPtr.Zero); } // restore previous texture binding. OpenGL.GL.BindTexture(OpenGL.TextureTarget.Texture2D, old_tex); }
public override void SetDisplaySize(Sizef size) { ThrowIfDisposed(); if (size != d_displaySize) { d_displaySize = size; // update the default target's area var area = d_defaultTarget.GetArea(); area.Size = size; d_defaultTarget.SetArea(area); } }
/*! * \brief * Create a texture that uses an existing OpenGL texture with the specified * size. Note that it is your responsibility to ensure that the OpenGL * texture is valid and that the specified size is accurate. * * \param sz * Size object that describes the pixel size of the OpenGL texture * identified by \a tex. * * \param name * String holding the name for the new texture. Texture names must be * unique within the Renderer. * * \return * Texture object that wraps the OpenGL texture \a tex, and whose size is * specified to be \a sz. * * \exceptions * - AlreadyExistsException - thrown if a Texture object named \a name * already exists within the system. */ public Texture CreateTexture(string name, int tex, Sizef sz) { ThrowIfDisposed(); ThrowIfTextureExists(name); var t = CreateTextureImpl(name); t.Initialise(tex, sz); d_textures[name] = t; LogTextureCreation(name); return(t); }
public override Texture CreateTexture(string name, Sizef size) { ThrowIfDisposed(); ThrowIfTextureExists(name); var tex = CreateTextureImpl(name); tex.Initialise(size); d_textures[name] = tex; LogTextureCreation(name); return(tex); }
/*! * \brief * Convenience function that creates the required objects to initialise the * CEGUI system. * * The created Renderer will use the current OpenGL viewport as it's * default surface size. * * This will create and initialise the following objects for you: * - CEGUI::OpenGLRenderer * - CEGUI::DefaultResourceProvider * - CEGUI::System * * \param display_size * Size object describing the initial display resolution. * * \param tt_type * Specifies one of the TextureTargetType enumerated values indicating the * desired TextureTarget type to be used. Defaults to TTT_AUTO. * * \param abi * This must be set to CEGUI_VERSION_ABI * * \return * Reference to the CEGUI::OpenGLRenderer object that was created. */ public static OpenGLRenderer BootstrapSystem(Sizef displaySize, TextureTargetType textureTargetType = TextureTargetType.TTT_AUTO /*, int abi = CEGUI_VERSION_ABI*/) { // TODO: System::performVersionTest(CEGUI_VERSION_ABI, abi, CEGUI_FUNCTION_NAME); if (Base.System.GetSingleton() != null) { throw new InvalidRequestException("CEGUI::System object is already initialised."); } var renderer = Create(displaySize, textureTargetType); Base.System.Create(renderer, new DefaultResourceProvider()); return(renderer); }
public override void LoadFromMemory(byte[] buffer, Sizef bufferSize, PixelFormat pixelFormat) { if (!IsPixelFormatSupported(pixelFormat)) { throw new InvalidRequestException("Data was supplied in an unsupported pixel format."); } InitInternalPixelFormatFields(pixelFormat); SetTextureSizeImpl(bufferSize); // store size of original data we are loading d_dataSize = bufferSize; UpdateCachedScaleValues(); BlitFromMemory(buffer, new Rectf(Vector2.Zero, bufferSize)); }
/// <summary> /// Constructor for OpenGL Renderer objects. /// </summary> /// <param name="displaySize"> /// Size object describing the initial display resolution. /// </param> /// <param name="textureTargetType"> /// Specifies one of the TextureTargetType enumerated values indicating the /// desired TextureTarget type to be used. /// </param> private OpenGLRenderer(Sizef displaySize, TextureTargetType textureTargetType) : base(displaySize) { InitialiseRendererIDString(); InitialiseGLExtensions(); InitialiseTextureTargetFactory(textureTargetType); InitialiseShaderWrappers(); // we _really_ need separate rgb/alpha blend modes, if this support is not // available, add a note to the renderer ID string so that this fact is // logged. if (!GLEW_VERSION_1_4 && !GLEW_EXT_blend_func_separate) { d_rendererID += " No glBlendFuncSeparate(EXT) support."; } }
//! resize the texture private void ResizeRenderTexture() { // save old texture binding OpenGL.GL.GetInteger(OpenGL.GetPName.TextureBinding2D, out var old_tex); // Some drivers (hint: Intel) segfault when glTexImage2D is called with // any of the dimensions being 0. The downside of this workaround is very // small. We waste a tiny bit of VRAM on cards with sane drivers and // prevent insane drivers from crashing CEGUI. Sizef sz = d_area.Size; if (sz.Width < 1.0f || sz.Height < 1.0f) { sz.Width = 1.0f; sz.Height = 1.0f; } // set the texture to the required size d_glStateChanger.BindTexture(OpenGL.TextureTarget.Texture2D, d_texture); OpenGL.GL.TexImage2D(OpenGL.TextureTarget.Texture2D, 0, OpenGL.PixelInternalFormat.Rgba8, //OpenGLInfo::getSingleton().isSizedInternalFormatSupported() ? GL_RGBA8 : GL_RGBA, (int)sz.Width, (int)sz.Height, 0, OpenGL.PixelFormat.Rgba, OpenGL.PixelType.UnsignedByte, IntPtr.Zero); if (d_usesStencil) { OpenGL.GL.BindRenderbuffer(OpenGL.RenderbufferTarget.Renderbuffer, d_stencilBufferRBO); OpenGL.GL.RenderbufferStorage(OpenGL.RenderbufferTarget.Renderbuffer, OpenGL.RenderbufferStorage.StencilIndex8, (int)sz.Width, (int)sz.Height); } Clear(); // ensure the CEGUI::Texture is wrapping the gl texture and has correct size d_CEGUITexture.SetOpenGLTexture(d_texture, sz); // restore previous texture binding. d_glStateChanger.BindTexture(OpenGL.TextureTarget.Texture2D, old_tex); }
/// <summary> /// update string formatting using given area size. /// </summary> /// <param name="sz"></param> protected void UpdateFormatting(Sizef sz) { if (Window == null) { return; } if (_formattedRenderedString == null) { SetupStringFormatter(); } // 'touch' the window's rendered string to ensure it's re-parsed if needed. _formattedRenderedString.SetRenderedString(Window.GetRenderedString()); _formattedRenderedString.Format(Window, sz); _formatValid = true; }
public void ResizeViewToContent(ItemView view, bool fitWidth, bool fitHeight) { var totalArea = view.GetUnclippedOuterRect().Get(); var contentArea = GetViewRenderArea(view, !fitWidth && view.GetHorzScrollbar().IsVisible(), !fitHeight && view.GetVertScrollbar().IsVisible()); var withScrollContentArea = GetViewRenderArea(view, true, true); var frameSize = totalArea.Size - contentArea.Size; var withScrollFrameSize = totalArea.Size - withScrollContentArea.Size; var contentSize = new Sizef(view.GetRenderedMaxWidth(), view.GetRenderedTotalHeight()); var parentSize = view.GetParentPixelSize(); var maxSize = new Sizef(parentSize.Width - CoordConverter.AsAbsolute(view.GetXPosition(), parentSize.Width), parentSize.Height - CoordConverter.AsAbsolute(view.GetYPosition(), parentSize.Height)); var requiredSize = frameSize + contentSize + new Sizef(1, 1); if (fitHeight && requiredSize.Height > maxSize.Height) { requiredSize.Height = maxSize.Height; requiredSize.Width = Math.Min(maxSize.Width, requiredSize.Width - frameSize.Width + withScrollFrameSize.Width); } if (fitWidth && requiredSize.Width > maxSize.Width) { requiredSize.Width = maxSize.Width; requiredSize.Height = Math.Min(maxSize.Height, requiredSize.Height - frameSize.Height + withScrollFrameSize.Height); } if (fitHeight) { view.SetHeight(new UDim(0, requiredSize.Height)); } if (fitWidth) { view.SetWidth(new UDim(0, requiredSize.Width)); } }
/// <summary> /// initialise method that creates a Texture with a given size. /// </summary> /// <param name="size"></param> protected internal void Initialise(Sizef size) { InitInternalPixelFormatFields(PixelFormat.RGBA); GenerateOpenGLTexture(); SetTextureSize(size); }
public virtual void AutoPositionSize(Lunatics.Mathematics.Vector2 position, Sizef size) { }
protected virtual int /*GLsizei*/ GetCompressedTextureSize(Sizef pixelSize) { const int blocksize = 16; return((int)(Math.Ceiling(pixelSize.Width / 4f) * Math.Ceiling(pixelSize.Height / 4f) * blocksize)); }
/// <summary> /// Configure scrollbars /// </summary> /// <param name="docSize"></param> protected void ConfigureScrollbars(Sizef docSize) { var v = GetVertScrollbar(); var h = GetHorzScrollbar(); var oldVertVisible = v.IsVisible(); var oldHorzVisible = h.IsVisible(); var renderAreaSize = GetItemRenderArea().Size; // setup the pane size var paneSizeWidth = Math.Max(docSize.Width, renderAreaSize.Width); var paneSize = new USize(UDim.Absolute(paneSizeWidth), UDim.Absolute(docSize.Height)); Pane.SetMinSize(paneSize); Pane.SetMaxSize(paneSize); // "fix" scrollbar visibility if (_forceVScroll || docSize.Height > renderAreaSize.Height) { v.Show(); } else { v.Hide(); } if (_forceHScroll || docSize.Width > renderAreaSize.Width) { h.Show(); } else { h.Hide(); } // if some change occurred, invalidate the inner rect area caches. if ((oldVertVisible != v.IsVisible()) || (oldHorzVisible != h.IsVisible())) { d_unclippedInnerRect.InvalidateCache(); d_innerRectClipperValid = false; } // get a fresh item render area var renderArea = GetItemRenderArea(); renderAreaSize = renderArea.Size; // update the pane clipper area ((ClippedContainer)Pane).SetClipArea(renderArea); // setup vertical scrollbar v.SetDocumentSize(docSize.Height); v.SetPageSize(renderAreaSize.Height); v.SetStepSize(Math.Max(1.0f, renderAreaSize.Height / 10.0f)); v.SetScrollPosition(v.GetScrollPosition()); // setup horizontal scrollbar h.SetDocumentSize(docSize.Width); h.SetPageSize(renderAreaSize.Width); h.SetStepSize(Math.Max(1.0f, renderAreaSize.Width / 10.0f)); h.SetScrollPosition(h.GetScrollPosition()); }
public static Mesh CreatePlane(Vector2f location, Sizef size) { Vector3f[] vertices = new Vector3f[] { new Vector3f(location.X, 0, location.Y), new Vector3f(location.X + size.Width, 0, location.Y), new Vector3f(location.X + size.Width, 0, location.Y + size.Height), new Vector3f(location.X, 0, location.Y + size.Height) }; Vector2f[] uvs = new Vector2f[] { new Vector2f(0, 0), new Vector2f(1, 0), new Vector2f(1, 1), new Vector2f(0, 1) }; int[] indices = new int[] { 2, 1, 0, 0, 3, 2 }; Vector3f[] normals = CalculateNormals(vertices, indices); MeshEntry plane = new MeshEntry(); plane.BaseIndex = 0; plane.BaseVertex = 0; plane.NumIndices = indices.Length; plane.Name = "Plane"; // Create the VAO uint _vao = GL.GenVertexArray(); GL.BindVertexArray(_vao); VBO <Vector3f> vertex = new VBO <Vector3f>(vertices); VBO <Vector2f> texture = new VBO <Vector2f>(uvs); VBO <Vector3f> normal = new VBO <Vector3f>(normals); VBO <int> element = new VBO <int>(indices, BufferTarget.ElementArrayBuffer, BufferUsageHint.StaticRead); GL.BindBuffer(vertex.BufferTarget, vertex.ID); GL.EnableVertexAttribArray(GL.VERTEX_POSITION_LOCATION); GL.VertexAttribPointer(GL.VERTEX_POSITION_LOCATION, vertex.Size, vertex.PointerType, false, 0, 0); GL.BindBuffer(texture.BufferTarget, texture.ID); GL.EnableVertexAttribArray(GL.VERTEX_NORMAL_LOCATION); GL.VertexAttribPointer(GL.VERTEX_NORMAL_LOCATION, texture.Size, texture.PointerType, false, 0, 0); GL.BindBuffer(normal.BufferTarget, normal.ID); GL.EnableVertexAttribArray(GL.VERTEX_NORMAL_LOCATION); GL.VertexAttribPointer(GL.VERTEX_NORMAL_LOCATION, normal.Size, normal.PointerType, false, 0, 0); GL.BindBuffer(element.BufferTarget, element.ID); // Make sure this VAO is not modified from the outside GL.BindVertexArray(0); // Add a dispose event to delete the generated VAO Resources.ResourcesManager.AddOnDisposeEvent(() => GL.DeleteVertexArrays(1, _vao)); return(new Mesh(_vao, plane)); }
public override void DeclareRenderSize(Sizef sz) { SetArea(new Rectf(d_area.Position, Owner.GetAdjustedTextureSize(sz))); ResizeRenderTexture(); }