///// <summary> ///// Create a new GeometryBuffer and return a reference to it. You should ///// remove the GeometryBuffer from any RenderQueues and call ///// destroyGeometryBuffer when you want to destroy the GeometryBuffer. ///// </summary> ///// <returns> ///// GeometryBuffer object. ///// </returns> //public abstract GeometryBuffer CreateGeometryBuffer(); /// <summary> /// Destroy a GeometryBuffer that was returned when calling the /// createGeometryBuffer function. Before destroying any GeometryBuffer /// you should ensure that it has been removed from any RenderQueue that /// was using it. /// </summary> /// <param name="buffer"> /// The GeometryBuffer object to be destroyed. /// </param> public void DestroyGeometryBuffer(GeometryBuffer buffer) { #if DEBUG if (!d_geometryBuffers.Contains(buffer)) { return; } #endif d_geometryBuffers.Remove(buffer); buffer.Dispose(); }
public override void AddToRenderGeometry(GeometryBuffer geomBuffer, ref Rectf renderArea, ref Rectf?clipArea, ColourRect colours) { Rectf texRect = Rectf.Zero, finalRect; var isFullClipped = CalculateTextureAndRenderAreas(renderArea, ref clipArea, out finalRect, ref texRect); if (isFullClipped) { return; } var vbuffer = new TexturedColouredVertex[6]; CreateTexturedQuadVertices(vbuffer, colours, ref finalRect, ref texRect); geomBuffer.AppendGeometry(vbuffer); }
/// <summary> /// /// </summary> /// <param name="text"></param> /// <param name="nextGlyphPosX"> /// The x-coordinate where subsequent text should be rendered to ensure correct /// positioning (which is not possible to determine accurately by using the /// extent measurement functions).</param> /// <param name="position"></param> /// <param name="clipRect"></param> /// <param name="clippingEnabled"></param> /// <param name="colours"></param> /// <param name="spaceExtra"></param> /// <param name="xScale"></param> /// <param name="yScale"></param> /// <returns> /// Returns a list of GeometryBuffers representing the render geometry of the text. /// </returns> public List <GeometryBuffer> CreateRenderGeometryForText(string text, out float nextGlyphPosX, Lunatics.Mathematics.Vector2 position, Rectf?clipRect, bool clippingEnabled, ColourRect colours, float spaceExtra = 0.0f, float xScale = 1.0f, float yScale = 1.0f) { var baseY = position.Y + GetBaseline(yScale); var glyphPos = position; var lastChar = (char)0; var geomBuffers = new List <GeometryBuffer>(); GeometryBuffer textGeometryBuffer = null; var imgRenderSettings = new ImageRenderSettings(Rectf.Zero, clipRect, clippingEnabled, colours); foreach (var c in text) { var glyph = GetGlyphData(c); if (glyph != null) { var img = glyph.GetImage(); glyphPos.X += GetKerningAmount(lastChar, c); glyphPos.Y = baseY - (img.GetRenderedOffset().Y - img.GetRenderedOffset().Y *yScale); imgRenderSettings.DestArea = new Rectf(glyphPos, glyph.GetSize(xScale, yScale)); if (textGeometryBuffer == null) { var currentGeombuffs = img.CreateRenderGeometry(imgRenderSettings); Debug.Assert(currentGeombuffs.Count <= 1, "Glyphs are expected to be built from a single GeometryBuffer (or none)"); if (currentGeombuffs.Count == 1) { textGeometryBuffer = currentGeombuffs[0]; } } else { // Else we add geometry to the rendering batch of the existing geometry img.AddToRenderGeometry(textGeometryBuffer, ref imgRenderSettings.DestArea, ref clipRect, colours); } glyphPos.X += glyph.GetAdvance(xScale); // apply extra spacing to space chars if (c == ' ') { glyphPos.X += spaceExtra; } } lastChar = c; } if (textGeometryBuffer != null) { geomBuffers.Add(textGeometryBuffer); } nextGlyphPosX = glyphPos.X; // Adding a single geometry buffer containing the batched glyphs return(geomBuffers); }
/// <summary> /// Appends additional render geometry for this image to an GeometryBuffers. /// The GeometryBuffer must be created beforehand and must feature render /// settings that allow adding this image geometry into the same render batch. /// Batching compatibility has to be ensured before this call. /// </summary> /// <param name="geomBuffer"> /// The existing GeometryBuffers to which the new render geometry will be appended. /// </param> /// <param name="renderArea"> /// The target area at which the image should be rendered. /// </param> /// <param name="clipAreaColourRect"> /// </param> /// <param name="colours"> /// Multiplicative colours to be applied to the text. /// </param> public abstract void AddToRenderGeometry(GeometryBuffer geomBuffer, ref Rectf renderArea, ref Rectf?clipAreaColourRect, ColourRect colours);
/// <summary> /// Take point \a p_in unproject it and put the result in \a p_out. /// Resulting point is local to GeometryBuffer \a buff. /// </summary> /// <param name="buff"></param> /// <param name="pIn"></param> /// <param name="pOut"></param> public abstract void UnprojectPoint(GeometryBuffer buff, Lunatics.Mathematics.Vector2 pIn, out Lunatics.Mathematics.Vector2 pOut);
/// <summary> /// Draw geometry from the given GeometryBuffer onto the surface that /// this RenderTarget represents. /// </summary> /// <param name="buffer"> /// GeometryBuffer object holding the geometry that should be drawn to the /// RenderTarget. /// </param> public virtual void Draw(GeometryBuffer buffer) { buffer.Draw(); }
/// <summary> /// Remove the specified GeometryBuffer from the specified queue. /// </summary> /// <param name="queue"> /// One of the RenderQueueID enumerated values indicating which prioritised /// queue the GeometryBuffer should be removed from. /// </param> /// <param name="buffer"> /// GeometryBuffer object to be removed from the specified rendering queue. /// </param> public void RemoveGeometryBuffer(RenderQueueId queue, GeometryBuffer buffer) { d_queues[queue].RemoveGeometryBuffer(buffer); }
/// <summary> /// Add the specified GeometryBuffer to the specified queue for rendering /// when the RenderingSurface is drawn. /// </summary> /// <param name="queue"> /// One of the RenderQueueID enumerated values indicating which prioritised /// queue the GeometryBuffer should be added to. /// </param> /// <param name="buffer"> /// GeometryBuffer object to be added to the specified rendering queue. /// </param> /// <remarks> /// The RenderingSurface does not take ownership of the <see cref="GeometryBuffer"/>, and /// does not destroy it when the RenderingSurface geometry is cleared. Rather, the /// RenderingSurface is just maintaining a list of thigs to be drawn; the actual /// GeometryBuffers can be re-used by whichever object \e does own them, and even changed /// or updated while still "attached" to a RenderingSurface. /// </remarks> public void AddGeometryBuffer(RenderQueueId queue, GeometryBuffer buffer) { d_queues[queue].AddGeometryBuffer(buffer); }
/// <summary> /// Remove a GeometryBuffer previously queued for drawing. If the specified /// GeometryBuffer is not added to the queue, no action is taken. The /// removed GeometryBuffer is not destroyed or modified in any way. /// </summary> /// <param name="buffer"> /// GeometryBuffer to be removed from the queue. /// </param> public void RemoveGeometryBuffer(GeometryBuffer buffer) { _buffers.Remove(buffer); }
/// <summary> /// Add a GeometryBuffer to the RenderQueue. Ownership of the /// GeometryBuffer does not pass to the RenderQueue. /// </summary> /// <param name="buffer"> /// GeometryBuffer that is to be added to the RenderQueue for later drawing. /// </param> public void AddGeometryBuffer(GeometryBuffer buffer) { _buffers.Add(buffer); }
/// <summary> /// Adds a created GeometryBuffer, which was returned when calling one of the /// createGeometryBuffer functions, to the list of GeometryBuffers. /// </summary> /// <param name="geometryBuffer"> /// The GeometryBuffer object to be destroyed. /// </param> protected void AddGeometryBuffer(GeometryBuffer geometryBuffer) { d_geometryBuffers.Add(geometryBuffer); }