Elements.Core
Controls alignment for various UI elements. Vertical is first followed by Horizontal
Indicates is given type is a base engine primitive - this includes numeric types, bool and strings.
The set of base primitives is fixed and updated rarely - it is not extensible by users.
This means types like enums and such are excluded from this, because those can be freely declared.
The type to determine if it's engine primitive or not
Whether given type is base engine primitive or not
List of all base engine primitives
This indicates if given type is engine primitive - either base or expanded. This means that it
can be potentially used within data model, because it has all necessary encoding functions defined.
However it still must be checked if it's an allowed type within given session (or within engine at all).
E.g. any Enums can be generically included in the data model - but they must be marked explicitly to be
allowed to be included int he data model.
Type to determine
Whether it's an engine primitive or not
No-frills list that wraps an accessible array.
Type of elements contained by the list.
Direct access to the elements owned by the raw list.
Be careful about the operations performed on this list;
use the normal access methods if in doubt.
Gets the number of elements contained in the .
Can also be set; setting the count is a direct change to the count integer and does not change the state of the array.
The number of elements contained in the .
Constructs an empty list.
Constructs an empty list.
Initial capacity to allocate for the list.
Thrown when the initial capacity is zero or negative.
Constructs a raw list from another list.
List to copy.
Removes an element from the list.
Index of the element to remove.
Removes an element from the list without maintaining order.
Index of the element to remove.
Gets or sets the current size allocated for the list.
If the new capacity is less than the current Count, the excess elements are truncated.
Adds an item to the .
The object to add to the .The is read-only.
Adds a range of elements to the list from another list.
Elements to add.
How many elements to add.
Adds a range of elements to the list from another list.
Elements to add.
Adds a range of elements to the list from another list.
Elements to add.
Adds a range of elements to the list from another list.
Elements to add.
Removes all items from the .
The is read-only.
Removes the first occurrence of a specific object from the .
true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original .
The object to remove from the .The is read-only.
Removes the first occurrence of a specific object from the collection without maintaining element order.
true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original .
The object to remove from the .The is read-only.
Determines the index of a specific item in the .
The index of if found in the list; otherwise, -1.
The object to locate in the .
Copies the elements from the list into an array.
An array containing the elements in the list.
Inserts the element at the specified index.
Index to insert the item.
Element to insert.
Inserts the element at the specified index without maintaining list order.
Index to insert the item.
Element to insert.
Gets or sets the element of the list at the given index.
Index in the list.
Element at the given index.
Determines if an item is present in the list.
Item to be tested.
Whether or not the item was contained by the list.
Copies the list's contents to the array.
Array to receive the list's contents.
Index in the array to start the dump.
Gets an enumerator for the list.
Enumerator for the list.
Sorts the list.
Comparer to use to sort the list.
Enumerator for the RawList.
Constructs a new enumerator.
No-frills list that wraps an accessible array.
Type of elements contained by the list.
Direct access to the elements owned by the raw list.
Be careful about the operations performed on this list;
use the normal access methods if in doubt.
Gets the number of elements contained in the .
Can also be set; setting the count is a direct change to the count integer and does not change the state of the array.
The number of elements contained in the .
Constructs an empty list.
Constructs an empty list.
Initial capacity to allocate for the list.
Thrown when the initial capacity is zero or negative.
Constructs a raw list from another list.
List to copy.
Removes an element from the list.
Index of the element to remove.
Removes an element from the list without maintaining order.
Index of the element to remove.
Adds an item to the .
The object to add to the .The is read-only.
Adds a range of elements to the list from another list.
Elements to add.
Adds a range of elements to the list from another list.
Elements to add.
Adds a range of elements to the list from another list.
Elements to add.
Removes all items from the .
The is read-only.
Removes the first occurrence of a specific object from the .
true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original .
The object to remove from the .The is read-only.
Removes the first occurrence of a specific object from the collection without maintaining element order.
true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original .
The object to remove from the .The is read-only.
Determines the index of a specific item in the .
The index of if found in the list; otherwise, -1.
The object to locate in the .
Copies the elements from the list into an array.
An array containing the elements in the list.
Inserts the element at the specified index.
Index to insert the item.
Element to insert.
Inserts the element at the specified index without maintaining list order.
Index to insert the item.
Element to insert.
Gets or sets the element of the list at the given index.
Index in the list.
Element at the given index.
Determines if an item is present in the list.
Item to be tested.
Whether or not the item was contained by the list.
Copies the list's contents to the array.
Array to receive the list's contents.
Index in the array to start the dump.
Gets an enumerator for the list.
Enumerator for the list.
Sorts the list.
Comparer to use to sort the list.
Enumerator for the RawValueList.
Constructs a new enumerator.
Prefer the left hand operand's color profile.
Prefer the right hand operand's color profile.
Apply the operation in linear space.
Apply the operation in linear space only if the operands are not in the same profile.
Left hand side of the operation.
Right hand side of the operation.
Color profile derived from the operation.
Converts an input color from a given profile, to a different profile.
The color's profile.
The target profile.
The color.
A converted color.
Converts an input color in a given profile to linear
The color's profile.
The color.
A converted color.
Converts an input linear color to a particular profile
The target profile.
The color.
A converted color.
Converts an already linear value to a profile.
The already linearized input value.
The target profile.
The profile-correct value.
Converts a value in a non-linear profile to linear.
The non-linear value.
The source profile.
A linear value.
Used for color profile aware operations, such as lerp.
Left hand color
Right hand color
The profile option, e.g., left hand profile, right hand profile, linear, etc.
The colors in the targeted color profile.
A managed color that can automatically convert between an original base color and a linear color.
Retrieves the cached linear color.
Computes luminance information based upon an input color, evaluating red, green, and blue channels.
The input color to compute luminance data from.
The calculated luminance.
Normalizes HDR values to unit length, and provides the gain of the original HDR value.
The gain of the original HDR value.
A normalized colorX.
Constructs a new HDR colorX using the supplied gain, scaling this colorX by the gain in the process.
The gain to apply to this colorX.
A HDR colorX that has the supplied gain applied.
Applies a supplied gamma curve to this colorX. Note inverse gammas must be pre-inverted by dividing 1 by gamma prior to calling this.
A gamma curve to apply in the event of any component being HDR.
A colorX with the supplied gamma applied to any HDR values.
This class is responsible for emulating legacy math under Mono / .NET Framework
There is a number of differences that happened in .NET (Core) to make math consistent with the spec
So this class is used to manually emulate the legacy behavior for compatibility reasons
Provides a conversion from wavelength to color
Based on lambda calculus from part 4.2 of: (skips gamma conversion)
Visible wavelength in nanometers (visible wavelength ranges from 380nm to 700nm)
A linear color that this wavelength corresponds to which closely resembles how the human eye perceives this wavelength
Gets the linear RGB color of black-body radiation at a specified kelvin temperature
Corresponds to CIE 1964 10 degree color-matching functions (CMFs)
Values correspond to the '10deg' rows here: http://www.vendian.org/mncharity/dir3/blackbody/UnstableURLs/bbr_color.html
Temperature, in degrees kelvin
Color of black-body radiation at the specified temperature
Lookup table for black-body radiation values.
Corresponds to CIE 1964 10 degree color-matching functions (CMFs)
Values correspond to the '10deg' rows here: http://www.vendian.org/mncharity/dir3/blackbody/UnstableURLs/bbr_color.html
Returns Nth smallest element from the list. Here n starts from 0 so that n=0 returns minimum, n=1 returns 2nd smallest element etc.
Note: specified list would be mutated in the process.
Reference: Introduction to Algorithms 3rd Edition, Corman et al, pp 216
Note: specified list would be mutated in the process.
Computes luminance information based upon an input color, evaluating red, green, and blue channels.
The input color to compute luminance data from.
The calculated luminance.
This value is obsolete, because the cuteness has increased way beyond what this can represent
2 MB of memory will be reserved for dictionary.
Incerease numFastBytes to get better compression ratios.
32 - moderate compression
128 - extreme compression
Compress input stream into output stream using LZMA.
Remeber to set desirable positions input and output streams.
Input reading starts at inStream.Position and ends at inStream.Length.
Output writing starts at outStream.Position.
Input stream
Output stream
Decompress LZMA compressed stream into outStream.
Remeber to set desirable positions in input and output streams.
Input stream
Output stream
Gets the bare name of a type. In most cases, this is no different from .
If the type's name contains a backtick (`), such as for generic types, that character and everything
after is disregarded.
Identifies the indices of points in a set which are on the outer convex hull of the set.
List of points in the set.
List of indices into the input point set composing the triangulated surface of the convex hull.
Each group of 3 indices represents a triangle on the surface of the hull.
Removes redundant points. Two points are redundant if they occupy the same hash grid cell.
List of points to prune.
Size of cells to determine redundancy.
This stream catches any exceptions coming from the inner stream, so they do not propagate outside.
This is necessary for when Streams are used for an interop with native code, because exceptions cannot
be propagated through native stack on certain platforms (e.g. Linux), which results them being treated as
unhandled exceptions. See here:
https://www.mono-project.com/docs/advanced/pinvoke/#runtime-exception-propagation
MemoryStream implementation that deals with pooling and managing memory streams which use potentially large
buffers.
This class works in tandem with the RecylableMemoryStreamManager to supply MemoryStream
objects to callers, while avoiding these specific problems:
1. LOH allocations - since all large buffers are pooled, they will never incur a Gen2 GC
2. Memory waste - A standard memory stream doubles its size when it runs out of room. This
leads to continual memory growth as each stream approaches the maximum allowed size.
3. Memory copying - Each time a MemoryStream grows, all the bytes are copied into new buffers.
This implementation only copies the bytes when GetBuffer is called.
4. Memory fragmentation - By using homogeneous buffer sizes, it ensures that blocks of memory
can be easily reused.
The stream is implemented on top of a series of uniformly-sized blocks. As the stream's length grows,
additional blocks are retrieved from the memory manager. It is these blocks that are pooled, not the stream
object itself.
The biggest wrinkle in this implementation is when GetBuffer() is called. This requires a single
contiguous buffer. If only a single block is in use, then that block is returned. If multiple blocks
are in use, we retrieve a larger buffer from the memory manager. These large buffers are also pooled,
split by size--they are multiples of a chunk size (1 MB by default).
Once a large buffer is assigned to the stream the blocks are NEVER again used for this stream. All operations take place on the
large buffer. The large buffer can be replaced by a larger buffer from the pool as needed. All blocks and large buffers
are maintained in the stream until the stream is disposed (unless AggressiveBufferReturn is enabled in the stream manager).
All of these blocks must be the same size
This buffer exists so that WriteByte can forward all of its calls to Write
without creating a new byte[] buffer on every call.
This list is used to store buffers once they're replaced by something larger.
This is for the cases where you have users of this class that may hold onto the buffers longer
than they should and you want to prevent race conditions which could corrupt the data.
This is only set by GetBuffer() if the necessary buffer is larger than a single block size, or on
construction if the caller immediately requests a single large buffer.
If this field is non-null, it contains the concatenation of the bytes found in the individual
blocks. Once it is created, this (or a larger) largeBuffer will be used for the life of the stream.
A temporary identifier for the current usage of this stream.
Object has been disposed
Gets the memory manager being used by this stream.
Object has been disposed
Callstack of the constructor. It is only set if MemoryManager.GenerateCallStacks is true,
which should only be in debugging situations.
Callstack of the Dispose call. It is only set if MemoryManager.GenerateCallStacks is true,
which should only be in debugging situations.
Allocate a new RecyclableMemoryStream object.
The memory manager
Allocate a new RecyclableMemoryStream object
The memory manager
A string identifying this stream for logging and debugging purposes
Allocate a new RecyclableMemoryStream object
The memory manager
A string identifying this stream for logging and debugging purposes
The initial requested size to prevent future allocations
Allocate a new RecyclableMemoryStream object
The memory manager
A string identifying this stream for logging and debugging purposes
The initial requested size to prevent future allocations
An initial buffer to use. This buffer will be owned by the stream and returned to the memory manager upon Dispose.
Returns the memory used by this stream back to the pool.
Whether we're disposing (true), or being called by the finalizer (false)
Equivalent to Dispose
Gets or sets the capacity
Capacity is always in multiples of the memory manager's block size, unless
the large buffer is in use. Capacity never decreases during a stream's lifetime.
Explicitly setting the capacity to a lower value than the current value will have no effect.
This is because the buffers are all pooled by chunks and there's little reason to
allow stream truncation.
Object has been disposed
Gets the number of bytes written to this stream.
Object has been disposed
Gets the current position in the stream
Object has been disposed
Whether the stream can currently read
Whether the stream can currently seek
Always false
Whether the stream can currently write
Returns a single buffer containing the contents of the stream.
The buffer may be longer than the stream length.
A byte[] buffer
IMPORTANT: Doing a Write() after calling GetBuffer() invalidates the buffer. The old buffer is held onto
until Dispose is called, but the next time GetBuffer() is called, a new buffer from the pool will be required.
Object has been disposed
Returns a new array with a copy of the buffer's contents. You should almost certainly be using GetBuffer combined with the Length to
access the bytes in this stream. Calling ToArray will destroy the benefits of pooled buffers, but it is included
for the sake of completeness.
Object has been disposed
Reads from the current position into the provided buffer
Destination buffer
Offset into buffer at which to start placing the read bytes.
Number of bytes to read.
The number of bytes read
buffer is null
offset or count is less than 0
offset subtracted from the buffer length is less than count
Object has been disposed
Reads from the specified position into the provided buffer
Destination buffer
Offset into buffer at which to start placing the read bytes.
Number of bytes to read.
Position in the stream to start reading from
The number of bytes read
buffer is null
offset or count is less than 0
offset subtracted from the buffer length is less than count
Object has been disposed
Writes the buffer to the stream
Source buffer
Start position
Number of bytes to write
buffer is null
offset or count is negative
buffer.Length - offset is not less than count
Object has been disposed
Returns a useful string for debugging. This should not normally be called in actual production code.
Writes a single byte to the current position in the stream.
byte value to write
Object has been disposed
Reads a single byte from the current position in the stream.
The byte at the current position, or -1 if the position is at the end of the stream.
Object has been disposed
Reads a single byte from the specified position in the stream.
The position in the stream to read from
The byte at the current position, or -1 if the position is at the end of the stream.
Object has been disposed
Sets the length of the stream
value is negative or larger than MaxStreamLength
Object has been disposed
Sets the position to the offset from the seek location
How many bytes to move
From where
The new position
Object has been disposed
offset is larger than MaxStreamLength
Invalid seek origin
Attempt to set negative position
Synchronously writes this stream's bytes to the parameter stream.
Destination stream
Important: This does a synchronous write, which may not be desired in some situations
Release the large buffer (either stores it for eventual release or returns it immediately).
Manages pools of RecyclableMemoryStream objects.
There are two pools managed in here. The small pool contains same-sized buffers that are handed to streams
as they write more data.
For scenarios that need to call GetBuffer(), the large pool contains buffers of various sizes, all
multiples of LargeBufferMultiple (1 MB by default). They are split by size to avoid overly-wasteful buffer
usage. There should be far fewer 8 MB buffers than 1 MB buffers, for example.
Generic delegate for handling events without any arguments.
Delegate for handling reports of stream size when streams are allocated
Bytes allocated.
Delegate for handling periodic reporting of memory use statistics.
Bytes currently in use in the small pool.
Bytes currently free in the small pool.
Bytes currently in use in the large pool.
Bytes currently free in the large pool.
pools[0] = 1x largeBufferMultiple buffers
pools[1] = 2x largeBufferMultiple buffers
etc., up to maximumBufferSize
Initializes the memory manager with the default block/buffer specifications.
Initializes the memory manager with the given block requiredSize.
Size of each block that is pooled. Must be > 0.
Each large buffer will be a multiple of this value.
Buffers larger than this are not pooled
blockSize is not a positive number, or largeBufferMultiple is not a positive number, or maximumBufferSize is less than blockSize.
maximumBufferSize is not a multiple of largeBufferMultiple
The size of each block. It must be set at creation and cannot be changed.
All buffers are multiples of this number. It must be set at creation and cannot be changed.
Gets or sets the maximum buffer size.
Any buffer that is returned to the pool that is larger than this will be
discarded and garbage collected.
Number of bytes in small pool not currently in use
Number of bytes currently in use by stream from the small pool
Number of bytes in large pool not currently in use
Number of bytes currently in use by streams from the large pool
How many blocks are in the small pool
How many buffers are in the large pool
How many bytes of small free blocks to allow before we start dropping
those returned to us.
How many bytes of large free buffers to allow before we start dropping
those returned to us.
Maximum stream capacity in bytes. Attempts to set a larger capacity will
result in an exception.
A value of 0 indicates no limit.
Whether to save callstacks for stream allocations. This can help in debugging.
It should NEVER be turned on generally in production.
Whether dirty buffers can be immediately returned to the buffer pool. E.g. when GetBuffer() is called on
a stream and creates a single large buffer, if this setting is enabled, the other blocks will be returned
to the buffer pool immediately.
Note when enabling this setting that the user is responsible for ensuring that any buffer previously
retrieved from a stream which is subsequently modified is not used after modification (as it may no longer
be valid).
Removes and returns a single block from the pool.
A byte[] array
Returns a buffer of arbitrary size from the large buffer pool. This buffer
will be at least the requiredSize and always be a multiple of largeBufferMultiple.
The minimum length of the buffer
The tag of the stream returning this buffer, for logging if necessary.
A buffer of at least the required size.
Returns the buffer to the large pool
The buffer to return.
The tag of the stream returning this buffer, for logging if necessary.
buffer is null
buffer.Length is not a multiple of LargeBufferMultiple (it did not originate from this pool)
Returns the blocks to the pool
Collection of blocks to return to the pool
The tag of the stream returning these blocks, for logging if necessary.
blocks is null
blocks contains buffers that are the wrong size (or null) for this memory manager
Retrieve a new MemoryStream object with no tag and a default initial capacity.
A MemoryStream.
Retrieve a new MemoryStream object with the given tag and a default initial capacity.
A tag which can be used to track the source of the stream.
A MemoryStream.
Retrieve a new MemoryStream object with the given tag and at least the given capacity.
A tag which can be used to track the source of the stream.
The minimum desired capacity for the stream.
A MemoryStream.
Retrieve a new MemoryStream object with the given tag and at least the given capacity, possibly using
a single continugous underlying buffer.
Retrieving a MemoryStream which provides a single contiguous buffer can be useful in situations
where the initial size is known and it is desirable to avoid copying data between the smaller underlying
buffers to a single large one. This is most helpful when you know that you will always call GetBuffer
on the underlying stream.
A tag which can be used to track the source of the stream.
The minimum desired capacity for the stream.
Whether to attempt to use a single contiguous buffer.
A MemoryStream.
Retrieve a new MemoryStream object with the given tag and with contents copied from the provided
buffer. The provided buffer is not wrapped or used after construction.
The new stream's position is set to the beginning of the stream when returned.
A tag which can be used to track the source of the stream.
The byte buffer to copy data from.
The offset from the start of the buffer to copy from.
The number of bytes to copy from the buffer.
A MemoryStream.
Triggered when a new block is created.
Triggered when a new block is created.
Triggered when a new large buffer is created.
Triggered when a new stream is created.
Triggered when a stream is disposed.
Triggered when a stream is finalized.
Triggered when a stream is finalized.
Triggered when a user converts a stream to array.
Periodically triggered to report usage statistics.
This will flush the log after every single message. This should be turned on temporarily only for debugging
purposes though, because it can have pretty significant performance impact
A generic Result object, that can represent the Result of an operation with an optional message
Like but contains a as a value for the result
The type of value that the result can contain
Count the occurences of pattern within the string text.
Text to search
Pattern to search for
Count of occurences of pattern within text.
Contains utility methods for throttling/rate-limiting operations
Runs an operation repeatedly until it succeeds or a maximum number of attempts is reached.
A delay is inserted between each attempt, doubling each time, up to a maximum delay.
Function to run for each attempt, returning whether the operation was successful
Runs an operation repeatedly until it succeeds or a maximum number of attempts is reached.
A delay is inserted between each attempt, doubling each time, up to a maximum delay.
Function to run for each attempt, returning whether the operation was successful
1D simplex noise
2D simplex noise
Provides a work-stealing scheduler.
Initializes a new instance of the class.
This constructors defaults to using twice as many threads as there are processors.
Initializes a new instance of the class.
The number of threads to use in the scheduler.
Queues a task to the scheduler.
The task to be scheduled.
Executes a task on the current thread.
The task to be executed.
Ignored.
Whether the could be executed.
Gets the maximum concurrency level supported by this scheduler.
Gets all of the tasks currently scheduled to this scheduler.
An enumerable containing all of the scheduled tasks.
Adds a work-stealing queue to the set of queues.
The queue to be added.
Remove a work-stealing queue from the set of queues.
The work-stealing queue to remove.
The dispatch loop run by each thread in the scheduler.
Signal the scheduler to shutdown and wait for all threads to finish.
A work-stealing queue.
Specifies the type of data stored in the queue.