HPS::Subwindow Class Reference

#include <hps.h>

Public Types

enum  Background : uint32_t {
Background::SolidColor, Background::Image, Background::Cubemap, Background::Blend,
Background::Transparent, Background::Interactive, Background::GradientTopToBottom, Background::GradientBottomToTop,
Background::GradientLeftToRight, Background::GradientRightToLeft, Background::GradientTopLeftToBottomRight, Background::GradientTopRightToBottomLeft,
Background::GradientBottomLeftToTopRight, Background::GradientBottomRightToTopLeft
}




 
enum  Border : uint32_t {
Border::None, Border::Inset, Border::InsetBold, Border::Overlay,
Border::OverlayBold
}
 
enum  RenderingAlgorithm : uint32_t { RenderingAlgorithm::ZBuffer, RenderingAlgorithm::HiddenLine, RenderingAlgorithm::FastHiddenLine, RenderingAlgorithm::Priority }
 
enum  Type : uint32_t { Type::Standard, Type::Lightweight }
 

Detailed Description

This is the Subwindow Class

Member Enumeration Documentation

◆ Background

enum HPS::Subwindow::Background : uint32_t
strong
Enumerator
SolidColor 

Subwindow Background.

Image 

Subwindow Background.

Cubemap 

Subwindow Background.

Blend 

Subwindow Background.

Transparent 

Subwindow Background.

Interactive 

Subwindow Background.

GradientTopToBottom 

Subwindow Background.

GradientBottomToTop 

Subwindow Background.

GradientLeftToRight 

Subwindow Background.

GradientRightToLeft 

Subwindow Background.

GradientTopLeftToBottomRight 

Subwindow Background.

GradientTopRightToBottomLeft 

Subwindow Background.

GradientBottomLeftToTopRight 

Subwindow Background.

GradientBottomRightToTopLeft 

Subwindow Background.

◆ Border

enum HPS::Subwindow::Border : uint32_t
strong
Enumerator
None 

Subwindow Border.

Inset 

Subwindow Border.

InsetBold 

Subwindow Border.

Overlay 

Subwindow Border.

OverlayBold 

Subwindow Border.

◆ RenderingAlgorithm

enum HPS::Subwindow::RenderingAlgorithm : uint32_t
strong

Specifies the Rendering Algorithm to use for drawing the scene.

Enumerator
ZBuffer 

Instructs the system to use a z-buffering algorithm which is of O(n) complexity. A hardware z-buffer will be used if the active display driver supports it, otherwise a software-buffer will be used.

HiddenLine 

Instructs the system to display visible (i.e. unobscured) lines, edges, markers and text. Recommended when rendering an HLR result to any 2D driver device such as hardcopy. Faces which are set to be visible are used to obscure the lines, edges, markers and text. It is O(n log n) complexity, and therefore computationally intensive when dealing with a large amount of geometry in the scene.
This rendering algorithm is not interruptible, and Visualize will perform a full update regardless of the amount of time required.
Therefore it is not compatible with time-bound updates which are also used by Visualize to provide fixed-framerate support.

FastHiddenLine 

Instructs the system to display visible (i.e. unobscured) lines, edges, markers and text. Recommended when you wish to display accurate HLR result on the screen. Faces which are set to be visible are used to obscure the lines, edges, markers and text. It is O(n) complexity and uses a multi-pass, z-buffer rendering approach that takes advantage of underlying 3D graphics hardware.
This rendering algorithm is not interruptible, and Visualize will perform a full update regardless of the amount of time required. Therefore it is not compatible with time-bound updates which are also used by Visualize to provide fixed-framerate support.

Priority 

Instructs the system to use the priority value specified by SegmentKey::SetPriority to ultimately determine the drawing order of objects. Objects with the highest priority are drawn on top, regardless of Z order. This algorithm is primarily intended to control layering within 2D scenes and will cause undesired results when rendering non-planar objects that have some parts overlapping others within the same primitive. The shader-based DirectX and OpenGL2 drivers have the ability to convert priority values into final Z positions, thereby enabling hardware-accelerated z-buffer rendering, and thus fast performance. Other drivers will produce the correct result, but rendering will be slower since all geometry will be sorted during scene-graph traversal. Priority can be set at a number of different levels:

Segment-level priority: Priority values only control the traversal order of sibling segments. It does not directly control drawing order of geometry, however, segment-level priority will influence the draw order of two geometries in sibling segments which have the same priority value.

Geometry-level priority: Priority values applied to primitives are global and are honored irrespective of the priority values of their parent segments. Use this to control draw order.

Include links: All primitives behind an include link are put into the global list according to the priority set on the include link and then sorted relative to each other using their respective priorities.

Limitations:

This algorithm does NOT work with anti-aliasing. Anti-aliasing will not be applied to scenes rendered with priority. If it is attempted, geometry will be drawn, but it will NOT be anti-aliased.

Working with priority on a mobile platform? You should be aware that when two geometries are inserted with the same priority, and one of those geometries is transparent, the transparent geometry will draw on top of the opaque one. This only apples when depth peeling is used as the transparency method.

◆ Type

enum HPS::Subwindow::Type : uint32_t
strong
Enumerator
Standard 

Subwindow Type.

Lightweight 

Subwindow Type.


The documentation for this class was generated from the following file: