Changes - History

Updated 3rd-party libraries:

The PixelFormat.Truecolor enumeration item is no longer a single flag bit, but instead a flag bit mask which includes the Grayscale bit, analogously to Precision and SixteenBits.

This change simplifies AND / OR logic when combining pixel formats, but existing single flag bit tests need to be refactored:

The methods for reading and writing VarInt values have been improved for better interoperability with Protocol Buffers and now have different names:

The former Tinman.AddOns.SQLite component has been integrated into the Tinman.AddOns library and is no longer provided separately. It now uses the NativeLibrary class to interface with the SQLite3 library.

The NuGet package Tinman.AddOns.SQLite is now obsolete. Please use the Tinman.AddOns package instead.

The Microsoft.Data.Sqlite library is no longer used by the C# version. The C++ version still allows to embed the SQLite3 library as source.

The native implementations of some of the methods of string use culture-sensitive and linguistic logic for comparison.

To ensure consistent behaviour of Code-X code everywhere and to avoid performance bottlenecks, these methods have been replaced with analogous null-safe counterparts that use case-sensitive comparision of ordinal UTF-16 code units:

The InputEvent.IsKeyboard property no longer includes events of type Character. The new property InputEvent.IsCharacter must be used instead.

The InputEvent.Character field now holds a single Unicode code point, instead of a single UTF-16 code unit. Use InputEvent.CharacterString to obtain the corresponding UTF-16 code unit sequence.

The new property IInputConsumer.IsConsumingTextInput is now used to enable / disable text input for the application window, see IApplicationWindow.IsTextInputActive.

The GLSL code no longer uses interface blocks to pass data between GL program stages. Now, regular in / out variables are used, based on a naming scheme that reflects matching via semantics, see StageInOutAttribute.

The Code-X Processor generates updated GLSL code automatically, no changes need to be performed on existing Gpu-X source code.

Simplified the API in the following areas:

The TextureLayer scene component now has two constructors, instead of a single one:

To migrate, just wrap the constructor argument string triplets with TextureLayerContent.For.

The Tinman 3D SDK supports desktop POSIX platforms like Linux and macOS as well as ARM CPU architectures. Please refer to Getting Started / Architectures for details.

In pure .NET Standard mode, the C# assemblies can be used to cross-compile to WASM. The C++ code supports cross-compilation to WASM via Emscripten.

With Thread.SingleThreadedMode, the SDK can be put into single-threaded mode, where calls to the multithreading API get mapped transparently to the application thread. This makes it possible to use standard multithreaded code in (web) environments that do not support threads.

Window creation for GUI applications is now performed through IApplicationWindowFactory objects that may be registered at runtime. There are built-in factories for the Windows API and the Simple DirectMedia Layer (SDL).

Window factories and graphics context factories are used in conjunction, to choose a suitable combination at runtime, see NativeHandleFlags for details.

The IBuildAction interface and its implementations provide programmatic access to the build-time actions that are used by the Tinman 3D SDK:

The line thickness setting for 2D/3D rendering now also applies to point rendering, see ILineThickness, ILineThicknessProperty and IMaterial.LineThickness.

The following collection classes can now be subclassed, to create custom implementations for specific generic type arguments:

Improved text rendering via Graphics and DocumentView:

Added a couple of features related to rendering of terrain texture layers:

Fixed a bug in IDataStream.Deflate that could produce non-standard output data streams, when given specific inputs. Such non-standard stream can be read with IDataStream.Inflate, but other RFC 1950/1951 implementations may fail with an error.

The SpriteCache now uses the transform Diagonal instead of Rotate when it needs to flip the coordinate axes for fitting a sprite into its allocated rectangle. Pixel padding at the top and left edges is no longer required to avoid color-bleeding, but when inspecting the sprite cache texture visually, some sprites may appear mirrored.

BinaryDigest.MD5 has been fixed and lo longer produces incorrect checksums for input that contains 2 GB of data or more.

To prevent fraud and abuse, licence keys will use a different private encryption key. Starting with the next SDK version, existing licence keys will no longer work.

Customers owning valid licence keys will receive an updated licence certificate document, to ensure smooth transition without interruption.

Any licence key received from "MyCommerce / A Digital River Company" after 2023/10/26 or any other 3rd-party must be considered illicit. Any use or possession of such fraudulent licence keys is prohibited by international laws and will lead to immediate termination of all licence agreements with Tinman 3D.

Changed the definition of TerrainView.LightingMatrix for the SkyMode.Global with Geocentric case: the altitude and azimuth angles of IEnvironmentMap now correspond to geographic latitude and longitude, which simplifies the process of placing the prominent scene light at the zenith above a given terrain location.

To get the old behaviour, add -90° to the azimuth angle when calling ILightProvider.SetLight.

Added type traits to common struct types, which introduced some minor name changes:

Updated 3rd-party libraries:

With the Quickstart.Evaluation method, the Tinman 3D SDK can be put into instant evaluation mode, for example after adding the SDK libraries via NuGet.

To request a full evaluation licence, please refer to Licencing and Pricing.

Updated the EPSG geodata registry to version 11.025:

Added Geodata Example for "Black Marble / Night Lights".

The built-in data type string represents a sequence of UTF-16 code units, which is the de-facto standard for Java and C#. To encode characters with a code point higher than 65535, surrogate pairs must be used, for example "\uD83D\uDCA9\" for "💩", which has a length of 2 char values.

Support for Unicode has been improved throughout the SDK:

Please note that grapheme clusters are not interpreted. Instead, they are consumed as code point sequences.

Fixed rendering of terrain reflections when using high-dynamic range scale factors.

Fixed a buffer-underflow error when calling the proj_info function of the PROJ library (version 6 or newer) from C#, which could lead to unstable CLR behaviour or other subtle application bugs.

The problem occured only if all the following were true:

Removed an API relic related to GPU rendering with hardware instancing, which required specification of the instance range with the call to IGraphicsContext.SetGeometryBuffer. Now, the instance range is passed to the Draw* methods of the IPrimitiveRenderer object.

The RenderEffectParameters API has been changed in order to improve runtime performance and to reduce the amount of required boilerplate code, see the new Aggregate method.

Please refer to GPU Programming / Render Effect Parameters for an example.

The active IGeoRegistry may be queried with GeoRegistry.Current but can no longer be specified by setting that property. Instead, the new stack-based API must be used, in global and/or thread-local scope.

Updated 3rd-party library:

The 3D Models domain model uses interfaces for read-only access and the implementation class for read-write access, see IModel.Mutable. The IMaterial interface now fully integrates this concept, see IMaterial.Mutable and IMaterialPart / MaterialPart.

Updated the EPSG geodata registry to version 11.021:

It is now possible to specify a transformation matrix for use with lighting via TerrainView.LightingMatrixAdjust, analogously to TerrainSky.EnvironmentMatrix and TerrainSky.TextureMatrix.

The transformation can be used to move the light position on the GPU, instead of updating the light position via ILightProvider.SetLight, which triggers re-computation of the environment map texture on the CPU.

To render high-resolution backgrounds, the new SkyDome class can be used: based on a ITexelPyramid in a TextureAtlas, it renders the background at the correct level-of-detail, taking into account the camera viewport and zoom.

Please refer to Tutorial_24_Moon, which shows how to do this.

Introduced version 6 of the file format Compiled Model Hierarchy (CMH), please refer to ModelFormat.CMH and IModelWriterCmh for more information.

Finished ClampU, ClampV, MirrorU and MirrorV of MaterialFlags.

Added optimization methods for improving performance of complex IModel hierarchies:

Please refer to Performance Guider / ModelRenderer for additional information.

Fixed a problem with object pooling, triggered by calling ObjectPoolUilt.PoolClear, which could possibly lead to corrupted data.

Fixed a number of small issues and problems.

Fixed a null-pointer error in Heightmap.Split that occured when the calling code holds sole ownership and there are no output layers, i.e. the split layers and the heightmap layers are disjoint.

Alpha blending for rendering the sky background now works as documented by TerrainSky:

Please refer to Tutorial_24_Moon for an example setup.

Greatly improved performance when performing extensive manipulations on large IModel hierarchies (more than ~50000 nodes).

Fixed error "name must not be null" when writing CMH files with the DEBUG binaries.

Fixed a bug related to HeightmapShape / IScene.Correction that could generate incorrect terrain data under some circumstances.

Fixed a bug in ResourceCache (see Graphics.Cache) which could sporadically cause the following issues while the cache is at 100% of its capacity (total memory size or object count):

Improved performance of clearing ArrayDeque, ArrayVector, Map and Set containers, by avoiding redundant clears and by dirty clearing where applicable:

Fixed a bug in ShapeFormat.SHP which caused a "bad record numbering" exception to be thrown for valid shape data, when all the following is true:

Replaced default use of LineEnding.Native with LineEnding.LF:

Updated 3rd-party libraries:

The API now uses generic methods instead of generic class wrappers for helper functionality, which has been moved as follows:

The Code-X Processor has been improved to generate forward declarations, using declarations and #include directives in C++ header files more intelligently, in order to increase code robustness and compilation speed. Existing code might run into problems, though:

To fix, just include the missing types. For more details, please refer to: Why does compilation or linking fail?

The SceneObject base class now implements the CallbackMask property in a different way: it is no longer virtual and its value must be specified via the constructor.

The ISwapChain.Present method has been split into PresentBegin and PresentEnd, to allow additional performance optimizations in ApplicationLoop.

Updated the EPSG geodata registry to version 11.017:

The new DecoratorCoordinateAxes.RenderOverlay method can be used to render the same 2D overlay for coordinate axis labels and metrics as used by the ModelWidget class.

The IShapeExtruder now supports texturing via its Texture property, see ShapeExtruderTexture.Building for an example for buildings.

The new Privilege API allows client code to restrict the access that the Tinman 3D SDK has to system resources and native APIs:

The Demo Application now showcases the Code-X Workflow by using the Code-X Processor to generate the C++, HLSL and GLSL source code from the Code-X compliant C# source code. Please refer to Code-X Framework for details on the development process.

Fixed a problem in MeshBuffer that could cause the internal object pools to grow excessively up to approx. 1.5 GB of RAM when using complex IHeightmap objects, which in turn could cause out of memory errors, especially on 32-bit platforms. Please refer to Performance Guide / ObjectPoolUtil / Interval for details.

Fixed a bug in the algorithm used by IShapeOps.Convert to convert shapes with from ShapeType.Polygon to ShapeType.Mesh, which causes incorrect results under some circumstances.

Fixed various issues in CameraPath resulting from improper handling of control point replication (see ICurve) and from improper camera control interaction (see CameraControl). Now, Uniform-B splines and camera control suspension are used, see Maths.SplineUniformB and CameraControl.Suspend.

Fixed a problem with the computation of per-pixel eye vectors in ModelRenderer for models with large polygons that intersect the near clipping plane, which caused incorrect rendering of reflections.

Fixed a bug in Viewport that prevented the value of the AspectRatio property from being updated correctly when the Set method was used.

Fixed a bug in the GPU shader code that caused slight flickering of the overall scene brightness while the lighting parameters change continuously, most noticeable when the Sun moves across the sky.

Using SceneObject.DirtyFrame to trigger a redraw after a property change only works when ISceneObject.CallbackMask includes the SceneObjectCallback.UpdateFrameTime flag.

The SceneObject base class has been fixed, so that the required flag is always returned when a redraw has been requested earlier, even if the subclass did not specify it in the first place.

Fixed an unwarranted runtime validation warning message that is output by Direct3D 11 when using DirectX11Context and calling IGraphicsFence.Set subsequently without calling IGraphicsFence.Wait in between, which is explicitly allowed by the interface and handled correctly by Direct3D:

"ID3D11DeviceContext::End: End is being invoked on a Query, where the previous results have not been obtained with GetData. This is valid; but unusual. The previous results are being abandoned, and new Query results will be generated."

Fixed some render issues with ApplicationControlWpf when using DirectX11Context:

The GLSL code now implements a proper work-around for the unsupported noperspective keyword when OpenGLES is used.

Improved rendering of 3D lines with the Renderer class: depth clipping distortions no longer occur for thin lines (LineThickness = 1) with DX10 and are now a documented restriction of DX9.

The Tinman.AddOns.DirectX9 component now uses the IDirect3DDevice9Ex API, instead of IDirect3DDevice9.

The IGraphicsContextFactory.AdapterOrdinal and Graphics.adapter properties no longer revert to adapter ordinal #0 when a value outside of the allowed range is specified. Initialization of the graphics context now fails in such a case.

The ApplicationControlWpf class of the Tinman.AddOns.WPF component now supports Direct3D 11 as render API, in addition to Direct3D 9. The WpfContextFactory class has been removed, please use DirectX9ContextFactory or DirectX11ContextFactory instead.

Handling of multiple graphics adapters has been improved, to avoid problems related to incorrectly chosen adapters (e.g. integrated / power-saver vs. high-performance), see the following for more information:

The Silk.NET library does not support 32-bit for Direct3D 9 (and randomly crashes the process), so the CanCreateGraphicsContext property of DirectX9ContextFactory now returns false when running in a 32-bit CLR.

Updated the EPSG geodata registry to version 11.012:

The GdalImageFormat now supports all GDAL versions from 1.7 as well as PROJ version 4 and all versions from 6. For details, please refer to the LibraryNames methods of the GdalLibrary, Proj4Library and Proj6Library classes.

The LookupMemory methods of GL and GLES now make correct use of the GL_ATI_meminfo extension. Before, their incorrect use could cause runtime errors and/or memory corruption.

As a work-around, use IGraphicsContextFactory.AvailableVideoMemory to specify the amount of video memory, which avoids the problematic video memory query.

The ModelFormat.OBJ now correctly interprets the .mtl commands d and Tr for material transparency.

The GLSL source code no longer uses the following language constructs, which are not required by the GLSL specification and thus may be unsupported by some OpenGL drivers, for example Intel® HD Graphics:

The == operator behaves differently in GLSL (scalar result) and HLSL (vector result). Use of all(…​) is required for HLSL but demands non-standard support by GLSL, via implicit conversion.

Fixed incorrect interpretation of ReadModelFlags.PureTextures by OpenFlightModelReader.

Fixed a method precondition in the constructor of GLEffect: compilationMacro is optional and may be null.

The OpenGLEffect class passes a null value, which caused an InvalidArgumentException in DEBUG mode. As work-around, please change null to a dummy compilation macro name, for example "GL_DUMMY".

GLSL code output has been improved for compatibility with more strict and less lenient OpenGL drivers, for example Intel® UHD Graphics:

Throughout the SDK, the FileFlags.NoShare flag is used when writing files, in order to prevent accidental read accesses to incomplete (hence corrupt) data.

Change ownership behaviour of IPixelPyramid.Cache², ITexelPyramid.Cache, IDataset.UseCache and DatasetFileCacheDelegate. To migrate existing invocations, an additional call to Acquire must be made to acquire ownership.

The StringUtil.ToLower and StringUtil.ToUpper methods now behave like char.ToLowerInvariant and char.ToUpperInvariant of .NET 8.0 on Windows 10. Before, it was consistent with .NET Framework 4.8. See this breaking change for additional information.

The behaviour of FormattingUtil.GetCategory has been changed to become consistent with .NET 8.0. Before, it was consistent with .NET Framework 4.8. See this breaking change for additional information.

String.LastIndexOf now returns the string length if the search token has zero length, instead of the string length minus one.

The Tinman.AddOns.SQLite component now uses the NuGet package Microsoft.Data.Sqlite and no longer contains the native SQLite binaries, which must be provided as described by the NuGet package. See Tinman.AddOns.SQLite.TinmanAddOnsSQLiteModule.adoc for more information.

The IImageOps.Pad method now offers a special padding mode, which can be used to restore the redundant pixel column in wrap-around datasets with PixelIsPoint semantic, if the pixel column has been omitted from the data. See the EGM2008 dataset for an example.

The IJsonValue.ToFile and IJsonValue.ToString now provide a choice for the output encoding, which is transparently read back by JsonValue.FromFile:

The ConfigScript supports a new aggregation operator a +> b and its shortcut form +a, see Scripting Overview / Operators.

The CoordinateSystemWkt class now supports both WKT version 1 and 2.

The ICurve interface now supports the concept of replicating control points, in order to control the curve. See ICurve.Replicate for details.

Updated the EPSG geodata registry to version 11.008:

The old version is still included, in a bug-fixed revision:

Fixed a bug in GeoPathTrail that sporadically caused incorrect rendering and/or index-out-of-bounds errors when Timestamp was updated frequently.

Fixed the default value of Animation.TimeLapse upon construction: it is now 1.0 (as documented), but was 0.0 before.

Cancelling HTTP requests via ISimpleHttp.Cancel now also stops the download, if it is already in progress. Although the interface is intended to be used for numerous requests carrying little data, getting large chunks of data is sometimes desirable, too. The fixed behaviour eliminates unnecessary wait times when cancelling heavy requests.

Fixed a multi-threading bug related to IHeightmap objects created with HeightmapBuilder.Memory, possibly leading to inconsistent data or dead-locked threads. As work-around, access in-memory raster datasets only from a single thread.

Fixed incorrect handling of TextureFormat.A8L8 and TextureFormat.L8 in OpenGLContext and OpenGLESContext.

Updated 3rd-party libraries:

The options of ModelReader have been extracted to the ModelReaderOptions class. Use IModelReader.Options to access them.

The ModelSimplifyFlags.RemoveRedundant flag now also removes superfluous parent-child links by merging the IModel objects, if possible.

Removed RenderStatePreset.AntiAliasing, because it provides little practical use, given its behavioural differences between graphics APIs. The RenderStatePreset.AlphaBlending preset now includes alpha-based anti-aliasing for line primitives if multi-sampling is not used.

The OpenFlightModelReader class provides several performance improvements as well as additional properties. The default values of the new KeepPolygonFootprint and KeepStructure properties establish a different behaviour: polygons classified as footprint for CAT cutout were excluded, now they are included; the hierarchical scene structure was flattened by default, now it is retained.

The GeoPathTrail scene entity now uses an improved method for generating dynamic geometry that supports incremental updates, which allows use of geo path trails that are highly detailed and/or very long, without performance degradation.

To migrate, review uses of the removed MaximumSegments and MinimumTimestampStep properties and replace with Capacity and TimestampStep.

The redundant GpuBufferFlags.Update flag has been removed, because non-static GPU buffers are implicitly updatable. The GpuBufferFlags.Volatile flag has been replaced by GpuBufferFlags.Map.

When creating non-static GPU buffers via IBufferFactory, the specified GpuBufferFlags now determine the ResourceAccessPattern of the created IGpuBuffer object, instead of merely suggesting it.

The documentation of the behaviour of GPU buffer updates has been improved to better explain the interaction between GpuBufferFlags and ResourceAccessPattern.

The IStreamingTarget interface is now IDisposable, so that ownership of IModelTextureDynamic objects can be tracked properly.

Calls to the TinmanModule.RegisterResource method are now only allowed from TinmanModule.DoInitialize, during SDK initialization.

The OpenFlightModelReader class now exposes geo-referencing metadata of the fltHeader database record via new Flt* properties.

The ModelFormat.WriteModel method now returns a IModelWriter object, which can be used to provide format-specific options for writing model files, for example IModelWriterCmh for ModelFormat.CMH.

The IModelGeometry interface now supports preloading via IPreloadingResourceHandle, which eliminates framerate stuttering when the ModelRenderer needs to load geometry data through the ResourceCache.

The GLSL source code no longer uses the following language features, which are not required by the GLSL specification and thus may be unsupported by some OpenGL drivers:

Fixed issues in the constructor of WGLContext which caused calls to RegisterClass and/or wglChoosePixelFormat(ARB|EXT) to fail.

The new IModelReader.ReadModelDebug method can be used to diagnose file format problems when loading 3D models.

The TerrainLayer of a TextureLayer or ShapeLayer scene entity can now be hidden via HideUntilReady while the texture content is being rebuilt, instead of showing data with increasing resolution during the build process.

The NativeLibrary class now outputs a warning log message for each required function that failed to load, to explain the reason why IsLibraryLoaded returns false. If RenderContext.CanCreate returns false although the GLApi is known to be available, the warning messages can be used to analyze the problem.

The built-in IGraphicsContextFactory implementations that use Silk.NET now output a warning log message via GraphicsContext.Logger before returning false from CanCreateGraphicsContext, after detecting an unexpected failure, which simplifies debugging.

If the Silk.NET assemblies have not been redistributed with an application, no log message is output, because this is treated as an expected failure and the graphics context factory will be disabled silently.

Fixed some API usage problems with DirectX12Context which caused runtime validation errors and warnings:

Fixed errors in the following NuGet packages that have been introduced by § 242 / FEATURE in version V1.0 RC4.20: - Tinman.AddOns.WPF - Tinman.AddOns.WinForms

Fixed a bug in DirectX11Context which caused a call to IUnknown::Release() on a COM object that had already been destroyed, when disposing a non-multisample IRenderTarget that has been created with CreateRenderTarget.

IGraphicsContext objects now use two separate repositories for GPU shaders: a shared public one and a private one. The former has become optional and may be specified via IGraphicsContextFactory.ShaderRepository. The latter may be defined by IRenderEffectFactory implementations. The AddOns components now contain a private GPU shader repository:

The NuGet packages of the Tinman 3D SDK now include separate sets of binaries for DEBUG and RELEASE.

See Software Architecture / DEBUG vs. RELEASE for details.

Fixed a bug in OpenGLEffect and OpenGLESEffect that caused incorrect rendering of the wireframe overlay on top of the material terrain layer, see TerrainLayer.Material and TerrainViewFlags.ShowWireframe.

Fixed a bug in Graphics that caused sporadic render artifacts in rare cases, apparent only when using a DirectX12Context.

Terrain layer content can now be prepared while the layer is invisible and the texture progress can be queried per layer. Before, content building started when the layer became visible, which progressively showed data with increasing resolution, which might not be desirable.

Improved performance of GPU buffer updates with GpuUpdateFlag.Discard for Direct3D 12.

Reduced frequency of error checking with GLBase.ErrorReset to improve performance. Use GLContext.DebugFrequentErrorChecks to restore the previous error checking level.

Added some helpers for wrapping native arrays and/or buffers with CodeX::Array and ByteBuffer.

Added SpriteCache and VisualCache classes, to support rasterization of 2D visuals (see IVisual) and efficient rendering using batched sprites.

Header and source files (*.h, *.hpp, *.cpp) now use UTF-8 encoding, instead of ISO-8859-1.

The AddOn libraries for Direct3D 9, 11 and 12 and the AddOn library for WPF now use the Silk.NET package for accessing native APIs.

The TexelBuffer.PixelEncode method now pads the given pixel buffer with transparent black, instead of requiring that the buffer is large enough.

The TexelBuffer.PixelEncodeMipmaps method now pads the given pixel buffer by duplicating the right and bottom edges, instead of filling with transparent black.

Fixed a bug in RenderPipeline.UploadBytes which causes incorrect uploads to Direct3D 12 resources via IGpuBuffer.BufferUpdate when more than 64 MB of data was specified.

Fixed a bug in Bitmap that happened after ITextureFactory.ValidateTextureSize had adjusted the texture size, which caused a possible index out of bounds error in Bitmap.SetPixels.

The Processor now correctly substitutes all macro occurrences in a text line, instead of just the first one.

Fixed RenderStatePreset.AlphaBlending so that destination alpha is accumulated correctly.

Fixed visual artefacts when rendering thick lines with non-zero surface layers, see IMaterial.LineThickness and IModelPart.Layer.

Fixed a bug in EffectComponents of ModelRendererParameters that always enabled ModelRendererFlags.PixelFrequency.

Changed behaviour of RenderStatePreset.AntiAliasing to make use of line anti-aliasing (if supported) when multi-sampling is not available.

Removed a decade old hack which used GetErrorMessage instead of GetMessage for System.Message, to compensate for the WinAPI #define. Now using #undef instead, where necessary. See FAQ for details.

The CodeX::String class uses the same logic as CharacterEncodingSimple.ISO_8859_1 when converting characters from UTF-16 to ISO-8859-1. For code points below 256, the behaviour is still the same.

Removed ValueToBox and BoxToValue from SystemUtilGeneric. Please use Boxed instead.

Removed unnecessary boilerplate from SDK code:

Changed default render state values when using the IRenderEffect framework:

The RenderStatePreset enumeration is now annotated with FlagsAttribute, which allows to apply multiple presets in a single call.

If a TerrainModel does not have the ShadowReceiver flag, its geometry will now be rendered without shadows. Lighting may still be performed on it and it may still cast shadows.

The default TinmanException.Panic behaviour now calls std::terminate in RELEASE mode.

The SamplerStatePreset enumeration has been extended to cover more sampler state combinations:

The ModelPoseFlags have been extended to support better material manipulation via ModelPose.Material.

Modernized CodeX::Delegate: - Replaced preprocessor macros with variadic templates. - Added Ptr<T>::operator()(Type::*Member) as an alternative to Ptr<T>::Method(Type::*Member). - Delegates can now wrap std::function values, which allows use of lambda expressions.

CodeX::String values can now be constructed via literal operators "…​"_CX and L"…​"_CX, the old-style macros CSTRING("…​"), ZSTRING("…​") and ZCHAR('?') have been deprecated.

Minimized use of CodeX::TypeOf<T>::Default() and moved field assignment statements in constructors to the initializer list.

Added a best practice recommendation to IDataStream which states that Finish should be called before disposing the stream and updated SDK classes accordingly.

The GPU code now uses the exact sRGB formula instead of the exponent 2.2 approximation for VertexElementFlags.Srgb, to match the sRGB processing that is performed by the GPU.

The TextureAtlasOptions class now obeys the new ITextureFactory.MaximumSize resource size limit, by balancing the texture and slice counts. For example, see Resource Limits (Direct3D 11).

The DecorationFor method of SilhouetteDecorator no longer throws a FailedAssertionException in DEBUG mode when the silhouette is empty (i.e. Silhouette.Vertices is empty).

Fixed a buffer overflow error when using ImageFormat.DDS to read a block-compressed texture whose width and/or height are not aligned to the block size.

Fixed an access violation error during the final exit procedure of the process, caused by a bad dependency on the order in which ShutdownSurviveAttribute values are deleted, for binaries that link statically to the Tinman 3D SDK.

For older entries, please refer to Archived - 2023 / § 205.