private bool CalculateTextureAndRenderAreas(Rectf renderSettingDestArea, ref Rectf?clippingArea, out Rectf finalRect, ref Rectf texRect) { var dest = (renderSettingDestArea); // apply rendering offset to the destination Rect dest.Offset(d_scaledOffset); // get the rect area that we will actually draw to (i.e. perform clipping) finalRect = clippingArea.HasValue ? dest.GetIntersection(clippingArea.Value) : dest; // check if rect was totally clipped if ((finalRect.Width == 0) || (finalRect.Height == 0)) { return(true); } // Obtain correct scale values from the texture var texelScale = _texture.GetTexelScaling(); var texPerPix = new Lunatics.Mathematics.Vector2(d_imageArea.Width / dest.Width, d_imageArea.Height / dest.Height); // calculate final, clipped, texture co-ordinates texRect = new Rectf((d_imageArea.d_min + ((finalRect.d_min - dest.d_min) * texPerPix)) * texelScale, (d_imageArea.d_max + ((finalRect.d_max - dest.d_max) * texPerPix)) * texelScale); // TODO: This is clearly not optimal but the only way to go with the current // Font rendering system. Distance field rendering would allow us to ignore the // pixel alignment. finalRect.d_min.X = CoordConverter.AlignToPixels(finalRect.d_min.X); finalRect.d_min.Y = CoordConverter.AlignToPixels(finalRect.d_min.Y); finalRect.d_max.X = CoordConverter.AlignToPixels(finalRect.d_max.X); finalRect.d_max.Y = CoordConverter.AlignToPixels(finalRect.d_max.Y); return(false); }
public override float GetValue(Window wnd) { // get window to use. var sourceWindow = String.IsNullOrEmpty(d_childName) ? wnd : wnd.GetChild(d_childName); if (d_type == DimensionType.Invalid) { // check property data type and convert to float if necessary var pi = sourceWindow.GetPropertyInstance(d_property); if (pi.GetDataType() == typeof(bool).Name) { return(sourceWindow.GetProperty <bool>(d_property) ? 1.0f : 0.0f); } // return float property value. return(sourceWindow.GetProperty <float>(d_property)); } var d = sourceWindow.GetProperty <UDim>(d_property); var s = sourceWindow.GetPixelSize(); switch (d_type) { case DimensionType.Width: return(CoordConverter.AsAbsolute(d, s.Width)); case DimensionType.Height: return(CoordConverter.AsAbsolute(d, s.Height)); default: throw new InvalidRequestException("unknown or unsupported DimensionType encountered."); } }
/// <summary> /// Return a Rectd describing the absolute pixel area represented by this /// ComponentArea. /// </summary> /// <param name="wnd"> /// Window object to be used when calculating final pixel area. /// </param> /// <param name="container"> /// Rect object to be used as a base or container when converting relative /// dimensions. /// </param> /// <returns> /// Rectf object describing the pixels area represented by this /// ComponentArea when using \a wnd and \a container as a reference for /// calculating the final pixel dimensions. /// </returns> public Rectf GetPixelRect(Window wnd, Rectf container) { var pixelRect = new Rectf(); // use a property? if (IsAreaFetchedFromProperty()) { pixelRect = CoordConverter.AsAbsolute(wnd.GetProperty <URect>(_namedSource), wnd.GetPixelSize()); } else if (IsAreaFetchedFromNamedArea()) { return(WidgetLookManager.GetSingleton() .GetWidgetLook(_namedAreaSourceLook) .GetNamedArea(_namedSource) .GetArea() .GetPixelRect(wnd, container)); } else { // not via property or named area- calculate using Dimensions // sanity check, we mus be able to form a Rect from what we represent. global::System.Diagnostics.Debug.Assert(d_left.GetDimensionType() == DimensionType.LeftEdge || d_left.GetDimensionType() == DimensionType.XPosition); global::System.Diagnostics.Debug.Assert(d_top.GetDimensionType() == DimensionType.TopEdge || d_top.GetDimensionType() == DimensionType.YPosition); global::System.Diagnostics.Debug.Assert(d_right_or_width.GetDimensionType() == DimensionType.RightEdge || d_right_or_width.GetDimensionType() == DimensionType.Width); global::System.Diagnostics.Debug.Assert(d_bottom_or_height.GetDimensionType() == DimensionType.BottomEdge || d_bottom_or_height.GetDimensionType() == DimensionType.Height); pixelRect.Left = d_left.GetBaseDimension().GetValue(wnd, container) + container.Left; pixelRect.Top = d_top.GetBaseDimension().GetValue(wnd, container) + container.Top; if (d_right_or_width.GetDimensionType() == DimensionType.Width) { pixelRect.Width = d_right_or_width.GetBaseDimension().GetValue(wnd, container); } else { pixelRect.Right = d_right_or_width.GetBaseDimension().GetValue(wnd, container) + container.Left; } if (d_bottom_or_height.GetDimensionType() == DimensionType.Height) { pixelRect.Height = d_bottom_or_height.GetBaseDimension().GetValue(wnd, container); } else { pixelRect.Bottom = d_bottom_or_height.GetBaseDimension().GetValue(wnd, container) + container.Top; } } return(pixelRect); }
// Implementation of the base class interface public override float GetValue(Window wnd) { Window widget; // if target widget name is empty, then use the input window. if (String.IsNullOrEmpty(d_widgetName)) { widget = wnd; } // name not empty, so find window with required name else { widget = wnd.GetChild(d_widgetName); } // get size of parent; required to extract pixel values var parentSize = widget.GetParentPixelSize(); switch (d_what) { case DimensionType.Width: return(widget.GetPixelSize().Width); case DimensionType.Height: return(widget.GetPixelSize().Height); case DimensionType.XOffset: System.GetSingleton().Logger .LogEvent("WigetDim.GetValue - Nonsensical DimensionType of XOffset specified! returning 0.0f"); return(0.0f); case DimensionType.YOffset: System.GetSingleton().Logger .LogEvent("WigetDim.GetValue - Nonsensical DimensionType of YOffset specified! returning 0.0f"); return(0.0f); case DimensionType.LeftEdge: case DimensionType.XPosition: return(CoordConverter.AsAbsolute(widget.GetPosition().d_x, parentSize.Width)); case DimensionType.TopEdge: case DimensionType.YPosition: return(CoordConverter.AsAbsolute(widget.GetPosition().d_y, parentSize.Height)); case DimensionType.RightEdge: return(CoordConverter.AsAbsolute(widget.GetArea().d_max.d_x, parentSize.Width)); case DimensionType.BottomEdge: return(CoordConverter.AsAbsolute(widget.GetArea().d_max.d_y, parentSize.Height)); default: throw new InvalidRequestException("unknown or unsupported DimensionType encountered."); } }
public override float GetValue(Window wnd, Rectf container) { switch (d_what) { case DimensionType.LeftEdge: case DimensionType.RightEdge: case DimensionType.XPosition: case DimensionType.XOffset: case DimensionType.Width: return(CoordConverter.AsAbsolute(d_value, container.Width)); case DimensionType.TopEdge: case DimensionType.BottomEdge: case DimensionType.YPosition: case DimensionType.YOffset: case DimensionType.Height: return(CoordConverter.AsAbsolute(d_value, container.Height)); default: throw new InvalidRequestException("unknown or unsupported DimensionType encountered."); } }
// implemets abstract from base protected override void AddImageRenderGeometryToWindowImpl(Window srcWindow, Rectf destRect, ColourRect modColours, Rectf?clipper, bool clipToDisplay) { // get final image to use. var img = IsImageFetchedFromProperty() ? srcWindow.GetProperty <Image>(ImagePropertyName) : Image; // do not draw anything if image is not set. if (img == null) { return; } var horzFormatting = HorizontalFormatting.Get(srcWindow); var vertFormatting = VerticalFormatting.Get(srcWindow); int horzTiles, vertTiles; float xpos, ypos; var imgSz = img.GetRenderedSize(); // calculate final colours to be used ColourRect finalColours; InitColoursRect(srcWindow, modColours, out finalColours); // calculate initial x co-ordinate and horizontal tile count according to formatting options switch (horzFormatting) { case Base.HorizontalFormatting.Stretched: imgSz.Width = destRect.Width; xpos = destRect.Left; horzTiles = 1; break; case Base.HorizontalFormatting.Tiled: xpos = destRect.Left; horzTiles = Math.Abs((int)((destRect.Width + (imgSz.Width - 1)) / imgSz.Width)); break; case Base.HorizontalFormatting.LeftAligned: xpos = destRect.Left; horzTiles = 1; break; case Base.HorizontalFormatting.CentreAligned: xpos = destRect.Left + CoordConverter.AlignToPixels((destRect.Width - imgSz.Width) * 0.5f); horzTiles = 1; break; case Base.HorizontalFormatting.RightAligned: xpos = destRect.Right - imgSz.Width; horzTiles = 1; break; default: throw new InvalidRequestException("An unknown HorizontalFormatting value was specified."); } // calculate initial y co-ordinate and vertical tile count according to formatting options switch (vertFormatting) { case Base.VerticalFormatting.Stretched: imgSz.Height = destRect.Height; ypos = destRect.Top; vertTiles = 1; break; case Base.VerticalFormatting.Tiled: ypos = destRect.Top; vertTiles = Math.Abs((int)((destRect.Height + (imgSz.Height - 1)) / imgSz.Height)); break; case Base.VerticalFormatting.TopAligned: ypos = destRect.Top; vertTiles = 1; break; case Base.VerticalFormatting.CentreAligned: ypos = destRect.Top + CoordConverter.AlignToPixels((destRect.Height - imgSz.Height) * 0.5f); vertTiles = 1; break; case Base.VerticalFormatting.BottomAligned: ypos = destRect.Bottom - imgSz.Height; vertTiles = 1; break; default: throw new InvalidRequestException("An unknown VerticalFormatting value was specified."); } // perform final rendering (actually is now a caching of the images which will be drawn) var imgRenderSettings = new ImageRenderSettings(Rectf.Zero, null, !clipToDisplay, finalColours); imgRenderSettings.DestArea.Top = ypos; imgRenderSettings.DestArea.Bottom = ypos + imgSz.Height; for (uint row = 0; row < vertTiles; ++row) { imgRenderSettings.DestArea.Left = xpos; imgRenderSettings.DestArea.Right = xpos + imgSz.Width; for (uint col = 0; col < horzTiles; ++col) { // use custom clipping for right and bottom edges when tiling the imagery if (((vertFormatting == Base.VerticalFormatting.Tiled) && row == vertTiles - 1) || ((horzFormatting == Base.HorizontalFormatting.Tiled) && col == horzTiles - 1)) { imgRenderSettings.ClipArea = clipper.HasValue ? clipper.Value.GetIntersection(destRect) : destRect; } // not tiliing, or not on far edges, just used passed in clipper (if any). else { imgRenderSettings.ClipArea = clipper; } // add geometry for image to the target window. var geomBuffers = img.CreateRenderGeometry(imgRenderSettings); srcWindow.AppendGeometryBuffers(geomBuffers); imgRenderSettings.DestArea.d_min.X += imgSz.Width; imgRenderSettings.DestArea.d_max.X += imgSz.Width; } imgRenderSettings.DestArea.d_min.Y += imgSz.Height; imgRenderSettings.DestArea.d_max.Y += imgSz.Height; } }
/// <summary> /// return the current constraint area of the mouse cursor. /// </summary> /// <returns> /// Rect object describing the active area that the mouse cursor is constrained to. /// </returns> public Rectf GetConstraintArea() { return(CoordConverter.AsAbsolute(d_constraints, System.GetSingleton().GetRenderer().GetDisplaySize())); }
protected List <GeometryBuffer> CreateRenderGeometryForImage(Image image, VerticalFormatting vertFmt, HorizontalFormatting horzFmt, Rectf destRect, ColourRect colours, Rectf?clipper, bool clipToDisplay) { int horzTiles, vertTiles; float xpos, ypos; var imgSz = image.GetRenderedSize(); // calculate initial x co-ordinate and horizontal tile count according to formatting options switch (horzFmt) { case HorizontalFormatting.Stretched: imgSz.Width = destRect.Width; xpos = destRect.Left; horzTiles = 1; break; case HorizontalFormatting.Tiled: xpos = destRect.Left; horzTiles = Math.Abs((int)((destRect.Width + (imgSz.Width - 1)) / imgSz.Width)); break; case HorizontalFormatting.LeftAligned: xpos = destRect.Left; horzTiles = 1; break; case HorizontalFormatting.CentreAligned: xpos = destRect.Left + CoordConverter.AlignToPixels((destRect.Width - imgSz.Width) * 0.5f); horzTiles = 1; break; case HorizontalFormatting.RightAligned: xpos = destRect.Right - imgSz.Width; horzTiles = 1; break; default: throw new InvalidRequestException("An unknown HorizontalFormatting value was specified."); } // calculate initial y co-ordinate and vertical tile count according to formatting options switch (vertFmt) { case VerticalFormatting.Stretched: imgSz.Height = destRect.Height; ypos = destRect.Top; vertTiles = 1; break; case VerticalFormatting.Tiled: ypos = destRect.Top; vertTiles = Math.Abs((int)((destRect.Height + (imgSz.Height - 1)) / imgSz.Height)); break; case VerticalFormatting.TopAligned: ypos = destRect.Top; vertTiles = 1; break; case VerticalFormatting.CentreAligned: ypos = destRect.Top + CoordConverter.AlignToPixels((destRect.Height - imgSz.Height) * 0.5f); vertTiles = 1; break; case VerticalFormatting.BottomAligned: ypos = destRect.Bottom - imgSz.Height; vertTiles = 1; break; default: throw new InvalidRequestException("An unknown VerticalFormatting value was specified."); } // Create the render geometry var geomBuffers = new List <GeometryBuffer>(); var renderSettings = new ImageRenderSettings(Rectf.Zero, null, !clipToDisplay, colours); renderSettings.DestArea.d_min.Y = ypos; renderSettings.DestArea.d_max.Y = ypos + imgSz.Height; for (uint row = 0; row < vertTiles; ++row) { renderSettings.DestArea.d_min.X = xpos; renderSettings.DestArea.d_max.X = xpos + imgSz.Width; for (uint col = 0; col < horzTiles; ++col) { // use custom clipping for right and bottom edges when tiling the imagery if (((vertFmt == VerticalFormatting.Tiled) && row == vertTiles - 1) || ((horzFmt == HorizontalFormatting.Tiled) && col == horzTiles - 1)) { renderSettings.ClipArea = clipper.HasValue ? clipper.Value.GetIntersection(destRect) : destRect; } else { // not tiling, or not on far edges, just used passed in clipper (if any). renderSettings.ClipArea = clipper; } geomBuffers.AddRange(image.CreateRenderGeometry(renderSettings)); renderSettings.DestArea.d_min.X += imgSz.Width; renderSettings.DestArea.d_max.X += imgSz.Width; } renderSettings.DestArea.d_min.Y += imgSz.Height; renderSettings.DestArea.d_max.Y += imgSz.Height; } return(geomBuffers); }