Changes - History

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 TinmanAddOnsSQLiteModule 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.

Improved responsiveness of EnvironmentMapResource by optimizing the performance of IEnvironmentMap.Rasterize² and ColorCube.Texture¹.

Reduced memory pressure when using Grammar to parse huge amounts of complex source code.

Fixed incorrect output of parenthesis according to precedence and associativity of CxExpression objects, regarding right-associative operators.

Fixed a bug in StringUtil.NumberParse and Parse.Number that caused numeric imprecision for very long numbers in non-scientific format (i.e. 0.000123, instead of 1.23E-4).

Fixed a bug in EnvironmentMapResource that prevented IEnvironmentMap.MaximumEnvironmentColor from being applied correctly in some cases.

Fixed a bug in IModel.ColliderWithPose that made the method return an empty IModelCollider if neither IModel.Collider, IModel.ColliderLoad nor IModel.PrepareLazy has been used before.

Fixed a threading issue regarding parallel use of IEnvironmentMap.ComputeEnvironmentColor that caused sporadic flickering in scene lighting because of temporary inconsistencies in the resulting environment map texture.

Now using static constexpr for compile-time floating-point constants with initialization in the header file, instead of the source file.

The ITextureFactory.CreateTexture2D method now throws a RenderException if the requested texture array slice count is greater than MaximumCount, instead of throwing a FailedAssertionException in DEBUG mode and returning a truncated texture in RELEASE mode.

The Colors.Adjust method now preserves the alpha channel value of the given input color, instead of always returning an opaque color, which also affects the behaviour of IImageOps.Adjust and IPixelLayer.Adjust.

Added support for rendering of realtime data to TerrainDecal. See Example_TextureStreaming for details.

Added Geodata Examples for Venus and Mercury.

Fixed a bug in ColorOp.Blend of IImageOps.Op that caused slight numeric imprecision.

Fixed a bug in SpatialOctree that made 3D ray-picking fail to work for 3D models which only have a single triangle as geometry.

Fixed performance issues during equality comparison of ModelTexture.For when wrapping ColorBuffer or TexelBuffer objects.

Fixed some minor performance issues related to the use of the generic CollectionsUtil.EqualsArray method by using the new SystemUtil.ArrayEquals method for primitive types.

Fixed incorrect handling of row padding in tiled TIFFs by ImageFormat.TIFF, which resulted in bad data at the right-most tile column for image widths that are not multiples of the tile size. Please use GdalImageFormat as a work-around.

Fixed a bug that made the Workshop Application fail to display a message box when the Processor Tool tries to report that "The given value is empty", which means that the Operation value is null.

Finished TerrainBufferFlags.Coverage feature set.

Added a general-purpose 3D model decoration framework to 3D Model, including a built-in decorator for silhouettes. See the following for details: Silhouette, SilhouetteDecorator, TerrainView.Decorator, Vehicle.Silhouette, Example_Models.BuildSilhouette.

ImageFormat.WriteImage is now available for ImageFormat.PXB.

Finished IModel.ColliderWithPose, which allows to perform spatial queries on IModel hierarchies in combination with ModelPose.

Improved overall traversal performance of SpatialTree by optimizing the nested hierarchy of bounding boxes.

Fixed a bug in ISpatialQuery.DistanceTo that in some cases caused incorrect results and/or performance degradation.

Fixed a stack-overflow error in IImage.ReadImage that could occur for some image descriptors when passing the RenderImageFlags.Range flag.

The specification of ByteBuffer.Allocate now requires initialization of the allocated memory to zero. The C# implementation already did this, now the C++ implementation also does. Before, the initial memory contents were undefined.

The TexelBuffer.Convert methods now take an srgb parameter for controlling the Srgb flag of the resulting texel buffer.

Subclasses of Widget are now required to call ScreenshotProcess, in order to trigger processing of screenshot requests that have been submitted via IWidget.Screenshot.

The Render method of Widget is now annotated with EmptyBodyAttribute and thus no longer calls Render2D and no longer triggers screenshot processing. The Render method of WidgetApplication now calls Render2D on each of its widgets.

Added support for OpenGL 4.1 Core Profile (or newer), see OpenGLContextFactory.

Added support for OpenGLES 3.0 (or newer), see OpenGLESContextFactory.

Fixed a bug in MaterialParameters that sometimes prevented glossiness/roughness from being applied correctly during rendering.

Implemented some overall runtime performance improvements:

Fixed a numeric overflow bug in Parse.Number and StringUtil.NumberParse that caused incorrect results for inputs near the value of Maths.MaxLong.

The ConsumeInput method of Widget now correctly passes absolute window-space mouse coordinates when calling the same method on its child components.

Fixed a bug in RenderPipeline.Flush that, in some cases, prevented RenderPipeline.WaitForGpu from working correctly.

Fixed a bug in RootSignature that caused a crash when running in 32-bit mode.

Corrected detection of available video memory (see ITextureFactory.AvailableVideoMemory) for DirectX11Context and DirectX12Context.

Fixed some issues with DirectX12Context: - Detection of supported multisample counts now works correctly. - Rendering of point primitives now works correctly. - No longer requiring support for a RaytracingTier, this is now optional.

Fixed 2D vertex format of Graphics:

As a work-around, call ByteBuffer.PutLong to write the missing 8 bytes of padding manually.

Removed unused methods from Geometric helper class.

Added support for high-performance collision detection / distance queries between 3D models, see ISpatialQuery.DistanceTo.

Added members to IWidgetGui for selectively controlling the visibility of the whole widget GUI or its panels, see Visible and PanelState.

Existing Direct3D 11 devices can now be wrapped with DirectX11Context.ForDevice.

Fixed incorrect handling of nested preprocessor directives (see #include) in Processor class.

The source code of the HLSL/GLSL shaders now has a uniform structure, which is generated automatically from C# code using the Code-X workflow.

Moved the types in the Tinman.AddOns.API namespace to Tinman.Engine.API, which makes them part of the Tinman.Engine component.

Removed Quality from MultiSampleType, because it represented a mostly outdated and practically obsolete concept (e.g. choosing a device-specific quality level for multi-sampling, such as NVidia’s CSAA for the GeForce 8 series), at least in the context of the Tinman 3D SDK.

Added a ready-to-use ISceneEntity implementation to the Scene framework for creating particle effects, see ParticleEffect.

Fixed a bug in ModelReader.TextureFileReplace that prevented texture file replacements to be applied correctly when the bad texture name refers to a non-existent file.

The ConfigValueBrowser_Tinman_AddOns.BrowseModelReader method now correctly outputs the validation messages that have been generated by IModelReader, for example: "texture['bad-name.png']: Cannot resolve texture name.". In the Workshop Application, these messages now show up properly in the Message List, in the Browser section. The Inspector Tool does not show these messages, because it only inspects the model reader itself, without loading the model.

Fixed incorrect rasterization of HeightmapShape objects that use per-vertex HeightmapSamples data which does not include all HeightmapLayers of the enclosing IHeightmapShape object.

Fixed rendering of thick 3D lines with Renderer for LineFeatureLevel.DX10 (wrong clipping, distorted thickness) when the line segment endpoints are on different sides of the Z=0 plane.

Distribution licence keys may only be used to unlock the redistributable binaries in non-debug mode. To unlock the SDK in debug mode, a Development licence key is required.

Added support for particle effects (e.g. smoke, fire, dust) to the Scene framework. See ParticleBuffer, Example_SceneApi.BuildFireEffect and Tutorial_31_Showcase for details.

Fixed a bug in ISimpleHttp.GetImage of SimpleHttp where the defaultSrgb parameter could get interpreted incorrectly.

Fixed rendering of ICanvasFactory.Bounds in CanvasWidget (green rectangle) after setting Factory to a different object.

The ITextureFactory.CreateTexture2DStatic method now also scales the given TexelBuffer objects to the supported texture size, in addition to converting them to the supported texture format, instead of throwing a RenderException.

Added new render target formats and changed the naming scheme to become more compact.

Decoupled GPU render target buffers when using IGraphicsContext.CreateRenderTarget, to allow more flexible usage scenarios:

Added order-independent transparency to the GPU rendering layer. See the new IRenderStage API for details.

The ImageDecal class now supports image content tiling, which allows image data to be used that is larger than the supported maximum texture size and increases parallelism of loading large images.

Added a deterministic refinement mode to the MeshBuffer class, for example to be used during offline processing or in distributed rendering environments, see MeshBuffer.CycleLimit and TerrainBufferFlags.Deterministic.

Fixed a panic in MeshBuffer.MeshUpdate that could happen after removing a mesh right after its creation, before it would become ready.

Simplified TerrainBufferFlags and exposed them to SceneOptions.

Dropped obsolete per-vertex tangent vectors for terrain meshes: terrain texturing uses terrain-space instead of tangent-space, terrain materials use tri-planar mapping.

WidgetBounds.FullScreen now always puts the widget onto the whole screen and ignores the user-interface screen regions (see INonUserInterfaceBounds). Use WidgetBounds.ClientArea to get the old behaviour.

Changed default value of EnvironmentMapSky.GroundColorDark. Use #111111 to get the old appearance.

Replaced the ModelRenderer.Wireframe property with the model renderer flag ModelRendererFlags.Wireframe.

Improved quality and robustness of per-vertex ambient occlusion terms (see Semantic.Horizon) and shadow-mapping (see ShadowMapping).

The new ModelRendererFlags.PixelFrequency flag may be used to improve performance in cases where the quality improvement of running pixel shaders at sample frequency is negligible. For example, Tutorial_22_Game uses on-the-fly planting of instanced geometry, which is rendered at pixel frequency, because the quality difference to sample frequency is not noticeable while the drop in performance is significant.

Fixed a problem with inconsistent input event processing of WidgetApplication when IApplicationWindow.MouseCaptured is used.

Added missing CODEX_TYPE_METADATA_BASE directives for types derived from the system types IEquatable, IComparable, IEnumerable and IEnumerator, to make CodeX::cast, CodeX::castSafe and CodeX::instanceOf work as expected.

Fixed undefined semantic of IBagConst.ContainsAll when both collections are empty.

Moved input state processing of WidgetApplication out of RenderPrepare, to fix problems related to lingering and/or lost input events when the application loop performs no rendering.

The DirectX12Context class now splits large GPU uploads (for example huge textures or vertex buffers), instead of failing.

The ModelRenderer class now uses bicubic interpolation on the GPU to produce high-quality specular reflections.

Finished IRenderTarget.Finish of DirectX12Context for RenderTargetFormat.Mipmaps.

Added support for high-dynamic range environment maps, see EnvironmentMapImage.HdrAutomatic and ImageFormat.HDR.

The range of actual raw pixel values in an image may now be queried with IImageInfo.Values and computed with ReadImageFlags.Range, if necessary.

Added support for tiled images to ImageFormat.TIFF.

Fixed a bug when using RenderTargetFormat.Mipmap with DirectX11Context that prevented mipmap levels from being computed correctly.

Fixed a bug in ImageFormat.TIFF that prevented images with planar configuration to be loaded correctly.

Fixed a bug that caused gamma-correction to be applied to alpha values in GdalImageFormat, ImageFormat.BMP and ImageFormat.TIFF.

The ModelRenderer class now uses the formulae of the glTF 2.0 specification and the associated reference implementation for rendering, using the new material properties of the IMaterial interface.

Changed error handling of DirectX12Context: instead of panicking, the RenderPipeline now goes into failure mode and silently drops all subsequent rendering. Error details are output as log messages and the next call to IGraphicsContext.Validate will then return false.

Replaced the ModelFlags.Lighting flag with the ModelPartFlags.NoLighting flag. Building 3D models by using the Model class will now create lit geometry by default, the new flag may specified explicitly to create unlit geometry.

ModelFormat.GLB (read)

ModelFormat.GLTF (read)

Native Libraries (Used By table columns)

Added a debug helper to the MG class for enabling system messages of the OpenFlight API, for testing and debugging.

Fixed some byte alignment issues when using non-power-of-two textures that have a block-based format (for example BC1) with DX9 / DX11 / DX12, which caused incorrect rendering of whole textures or single mipmap levels.

Fixed several bugs in ModelWidget regarding camera control problems, level-of-detail rendering not working properly for the shadow pass and clamping of the visible depth range.

Fixed several bugs in the implementations of IBufferCodec.BufferEncode that caused false-positive assertion failures regarding texture block size misalignment and possible buffer overflows when passing in byte buffers with a capacity of 22 bytes or less.

Fixed handling of instance and reference nodes in OpenFlightModelReader when reading 3D models in the FLT format.

Fixed a bug in IModel.Simplify that mingled child transformations when ModelSimplifyFlags.RemoveEmptyChildren or ModelSimplifyFlags.SortChildren was used.

Dirty state processing of built-in SceneObject subclasses now correctly triggers rendering of new frames by returning true from UpdateFrameTime.

Fixed a bug in Mat3D.Orthogonalize and Mat3F.Orthogonalize which resulted in non-orthogonal output basis vectors if the input basis vectors are nearly co-linear.

Texturing.Progress now returns 100 instead of 0 when no terrain sectors have been processed, for example when all terrain parts are culled away while looking straight up.

Changed default unit of UnitOfMeasureType.Angle from UnitOfMeasure.Radian to UnitOfMeasure.Degree and introduced default values to scripting fields of CoordSys (and related types), in order to avoid output of redundant script code.

This change affects the following API:

Simplified factory methods of ColorRamp and rasterization helpers of PixelPyramidShape.

Changed JSON grammar to no longer allow control characters (0x00..0x1F) to be present in string literals, for compliance with the official JSON specification. Trying to parse such an invalid value now correctly throws a ValidatingException.

IMapShapes.ShapeAdd and IMapShapes.ShapePrepare no longer always transform the given IShape to the target coordinate system that is used by rasterization. Instead, the transform parameter may now be used to perform this transformation optionally.

Added surface levels to 3D models, to avoid Z-fighting of co-planar surfaces, see IModelPart.Layer.

Built-in file format / OpenFlightModelFormat (read)

Updated the documentation to better explain the interaction between ISceneEntity.CreateView, ISceneEntityView.Owner and ISceneView.ViewOf.

Added features for curves based on cubic splines (see Curve.Tangent) and associated shape factories, see Shape.Curve and RoadBuilder.

Shape rasterization via IMapShapes now supports on-the-fly projection, which will be performed automatically if the coordinate system of a IShape is not the same as the target coordinate system used by rasterization (for example, a global cubemap coordinate system).

Added support for localization of text labels in GUI components.

The ISceneView objects that are created by the Vehicle class via ISceneEntity.CreateView now return their respective owner via ISceneEntityView.Owner, instead of returning null, which made ISceneView.ViewOf return null and caused null-pointer errors when a Vehicle was removed from the scene.

Fixed equality comparison between IGeoObject objects after deserialization, where objects that had been equivalent before became non-equivalent afterwards.

Fixed rendering of FloatingLabel tick lines that broke with § 85.

Fixed handling of distance field offsets for IShape objects that use a geographic coordinate system by correcting the scale factor that is used by CoordinateSystemTransform.TransformScale, affecting the following API: - IShapeOps.Offset - IShapeOps.Outline - IShapeOps.TransformCoordinateSystem - IShapeOps.TransformCubemap - IShapeOps.TransformGeometry - Shape.CheckerBoard - Shape.Circle²

Eliminated the possibility of object self-destruction during the execution of constructors of classes derived from CodeX::Object (C++), caused by smart pointers that acquire and release the this pointer. Constructors may now use the new CODEX_CONSTRUCTOR macro to prevent this. Before this fix, self-destruction had to be avoided by not wrapping this in smart pointers, which required special care when coding constructors.

Fixed bad handling of corrupted BlockStorage data by throwing an IOException (instead of panicking or crashing) which indicates the location of corrupted file, for example:
Invalid 'BST' file: <path/to/corrupted/file>

Fixed a null-pointer error in the implementation of the ISceneObject.QueryRay method by the SceneEntity class, which occurred when the list of TerrainModel objects (see ITerrainEntityContainer) is empty. As a work-around, add an empty TerrainModel object:
sceneView.TerrainModelAdd(new TerrainModel());

Fixed a bug in GPU synchronization with multiple ISceneView objects which caused occasional flickering, because GpuUpdateFlag.NoOverwrite was used to update data still being in use by rendering.

Fixed a sporadic GPU crash after resetting / switching the graphics context because of uninitialized data being used by TriangleMode.TriangleTerminal or TriangleMode.SectorList, which triggered Timeout detection and recovery (TDR).

Improved performance of when using TriangleMode.SectorList for terrain triangulation on the GPU.

Fixed terrain mesh refinement for problematic data (e.g. spikes, near-vertical slopes, displacement with wrinkles), which produced high amounts of unnecessary triangles, thus slowing down overall performance.

Moved some helper methods from ISceneView3D to IScene, please use ISceneView.Scene to access them, if necessary.

Fixed calls to SceneObject.QueryScreenLabelResult² that were passing null as the label parameter, causing possible null-pointer errors in FloatingLabel and ScreenGizmo.

Repackaged the Tinman.AddOns library components so that a separate library is only used when 3rd-party dependencies exist at build-time (dependencies still exist at run-time).

Fixed a bug in Path.Copy that sporadically caused IOError.SharingViolation errors due to a lingering IFile object for the source of the file copy operation.

Fixed a bug that could cause an array out-of-bounds error when decoding TriangleMode.SectorList primitives on the CPU and could make the GPU crash when using TerrainFeatureLevel.DX11 or higher.

The IScene.Transform method family now takes VerticalType.Height as default parameter value instead of VerticalType.HeightMesh, because its primary purpose is to place static objects in the scene.

The CodeX::String::Trim (C++) method no longer uses isspace resp. iswspace to check for whitespaces. Instead, the logic of FormattingUtil.IsWhitespace is used. The same logic is used by System.String.Trim (C#).

Fixed a null-pointer error in ScreenLabelPlacement when calling Clear without having initialized Size first.

Fixed a bug that sometimes caused a DirectX9RenderTarget to not update its content properly when IRenderTarget.Finish is called.

Fixed a spurious panic in MeshBuffer and a possible mesh refinement freeze that became apparent with § 75.

Greatly improved performance of IHeightmap.GetSample, especially when being used repeatedly on heightmaps that have a complex aggregation structure, as it is often the case in the Scene API where Geocentric.ToVerticalOffset is used a lot, for example by GeoPathTrack entities.

Fixed a sporadic bug in MeshBuffer that could make the Refinement Thread think that a vertex may be re-used, although it is still visible to the application in the Shadow Buffer.

The Aircraft class has been refactored into the Vehicle class, which provides additional helpers and examples for moving ground vehicles around while aligning them to the terrain slope.

Added helpers to the Scene API for placing objects on the ground, while aligning them with the terrain slope by computing pitch and roll angles automatically, see GroundPathTransform, YawPitchRollTransform and IScene.Transform.

Fixed a grammar bug in ConfigScript which made it impossible to declare an array of qualified identifiers:
variableName = [ ScriptName::memberName ] ;

Fixed a number of minor issues in the ConfigScript API that prevented qualified identifiers to be resolved properly, when referring to members of other scripts in the domain.

Added callbacks for dynamic DPI changes at runtime, so that applications may adjust rendering, for example by choosing appropriate font and image sizes: IApplicationWindow.Resolution, IApplication.WindowResolution, IGraphicsComponent.GraphicsResolution

Fixed a bug in the high-DPI handling code of ApplicationControlWpf in the Tinman.AddOns.WPF component, which caused the render canvas to be sized incorrectly and the mouse cursor position to be interpreted wrongly.

Platform-specific limits for file and directory path lengths are now taken into account by IFileSystem.PathValidate of LocalFileSystem.

Fixed stack-overflow error when outputting extremely long messages with LogMessageFormat.Default.

The C# assemblies of Tinman 3D SDK are now available on NuGet.

ModelRenderer now uses AffineTransform instead of Mat4D, which reduces the number of required arithmetic operations during model traversal and eliminates redundant conversions.

AffineTransform now uses separate methods for forward and reverse transformations, instead of a single combined one with an inverse parameter, which favors more aggressive optimization by compilers.

The Visual Studio solutions in the Tinman 3D SDK package now use the 2022 version. C++ code may be compiled with the 2022, 2019, 2017 or 2015 toolset. C# code may target Mono 6+, .NET Framework 4.8, .NET Core 3.1 or .NET 6.0+. Out-of-support versions or legacy toolsets may still be used (for example .NET 5.0), by adjusting the project files.

Fixed a bug in GeoPathConverter that did not read the input vertical coordinate correctly if it was different to GeoPathValue.Ellipsoid.

Various performance improvements and minor fixes regarding use of numerous scene objects (> 10.000) with the Scene API.

TerrainView.TextureProgress now returns 100 instead of 0 if the terrain does not have any texture layers.

Various performance optimization regarding memory consumption and runtime efficiency: - Grammar
Improved handling of left-recursion and performance of rule matching, which greatly increases overall performance. - ShapeBuilder
Minimized dynamic memory allocations during shape building, to improve performance when building lots of shapes successively. - Software Architecture / Collections
Harmonized uses of EqualsDelegate, CompareDelegate and HashCodeDelegate to avoid inadvertent value-boxing at runtime.

Fixed the signed distance field of shapes that have shared polygon contour edges, which may result from using the ReadShapeFlags.HintMergePolygons flag.

Fixed trimming of the common whitespace prefix from all text lines in a TextBlockNode when there are one or more empty text lines.

The difference between state handling of terrain objects in the High-level Terrain API and scene objects in the Scene API is now explained in Scene Overview / State Handling and exposed to code by the ITerrainEntityContainer interface.

IShapeReader and Shape.File now support filtering and modification while reading shape data.

Shapes may now carry JSON metadata and custom per-vertex shape values.

Introduced IJsonValue interface, so that immutable JSON values may be passed around safely.

ShapeFormat.CSH now uses delta encoding to reduce file sizes by ~30%. New .csh files can no longer be read with old SDK versions, but old .csh files may still be read with new SDK versions.

ShapeFormat.SHP no longer requires that the *.shx index file exists and can read shape data solely from a single *.shp file.

Extracted GUI code from tutorials and moved them to sub-namespaces, according to their target API (e.g. low-level / high-level terrain API, scene API).

Revised ISceneQuery API, to allow re-use of scene query objects and to increase flexibility via aggregated query operations.

Optimized interpolation code in GeoPath, which increases performance by a factor of ~300%.

ModelReader now computes per-face normal vectors when a model does not contain normal vector data. Computation of smooth per-vertex normal vectors may be enabled with ReadModelFlags.SmoothNormals.

ModelFormat.OBJ now supports materials via .mtl files.

ModelFormat.OBJ and ModelFormat.LAS now correctly apply ModelReader.RootUnit.

Fixed longitude wrap-around distortion in IPixelPyramid.Unproject.

Added default color-space handling to ISimpleHttp.GetImage and HttpPyramid, to disambiguate cases when sRGB image data is returned without color-space information. For example, BingMaps sometimes returns PNG files that contain sRGB image data but do not include a GAMA or SRGB chunk.

The PixelFontBuilder class has been improved to provide better control over the font building process and now uses a slightly modified pixel font image format. Please rebuild your custom pixel font files once, to migrate to the new format.

Fixed rendering of opaque 3D lines with Direct3D 9 which broke with § 32.

Refactored C# project files (*.csproj) to SDK-style and performed minor code fixes to compile and run on .NET Framework, Mono and .NET 5+ / .NET Core.

The Decaling class has been improved to eliminate inaccurate mapping of decal textures, which happened at cubemap edges / corners and when large geo-referenced image overlays were used.

Changed semantic of decal textures in Low-level Terrain API: decal vertex coordinates must now be specified in a given coordinate system, it is no longer possible to use heightmap coordinates directly. See IDecal for details.

Fixed some numeric precision issues in ICoordinateTransform implementations to comply to to the Geospatial Integrity of Geoscience Software (GIGS) Test Dataset v2.1.

Fixed numeric overflow bug in LatLon.FromSexagesimal and updated epsg-9.9.1.dat accordingly. IGeoRegistry.Name returns "EPSG 9.9.1 / Tinman 1.0 / Rev.1" for the fixed version.

Changed semantic of CoordinateSystem.CreateCoordinateTransform to throw a GeorefException when CoordinateSystem.IsLocal returns true.

Changed semantic of Dome.Subdivision to allow direct control of the coefficients that are passed to ModelGeometry.Sphere and ModelGeometry.SphereIco.

The texture addressing mode in the DirectX9Effect subclass for decaling was incorrectly set to TADDRESS_CLAMP and has been fixed to TADDRESS_BORDER with transparent black as border color.

ModelRenderer.LineThickness and TerrainModel.LineThickness have been removed. Please use Material.LineThickness and IModelGeometrySimple.ToModel instead.

Geocentric.Vertical no longer assumes that the given heightmaps are cubemaps and use the same geographic coordinate system as the Geocentric object.

The value of TextureDecal.Offset is now added to the vertex coordinates of the decal texture (after scaling and rotation), instead of subtracting it.

Scene.UpdateFrameTime no longer calls SceneView.UpdateFrameTime. See Scene and SceneView for details on the new update behaviour.

Changed semantic of automatic calls to MeshBuffer.MeshUpdate, which makes TerrainViewFlags.MeshUpdate obsolete. See TerrainView for details.

In the logging framework, renamed LogSeverity to LogVerbosity.

Enabled of TextureLayer now toggles the visibility of the underlying TerrainLayer.

MBTilesPyramid now applies the geographic bounds, if present in metadata table, to avoid that out-of-bounds data appears on the terrain.

SceneEntityBase.SceneAttach no longer calls UpdateState before returning, so that subclasses do not have to deal with incomplete initialization in their DoUpdateState overrides.

Modifying the GeoPathTrail.ColorFill / GeoPathTrail.ColorLine properties now correctly triggers an update to the 3D model.

The render order of terrain decals can now be configured per terrain layer, see: TerrainDecal.SortIndex, ImageDecal.SortIndex, TextureDecal.SortIndex.

DirectX9Context.SetGeometryBuffer now sets up non-instanced geometry explicitly:

Instead of using an instance count of 1 (n = number of instances):

These variants should be equivalent. In some specific cases, the second variant does not work.

Fixed endless loop in Path.MakeRelative when passing Path.Unknown.

IGraphicsContext.ClearRenderTarget is no longer allowed to fail silently when invalid clear flags are passed. Instead, the clear is performed using the valid subset of the given flags.

Added warning log messages for failed non-critical render API calls (DirectX9, DirectX11).

Added the possibility for case-insensitive comparisons in various methods of the Path class and the related API.

Exposed the set of invalid characters for path elements via IFileSystem.InvalidCharacters.

Added NATVIS files to make C++ debugging easier.

Moved unit testing API (C#) into separate library.

Now using C++ noexcept for non-throwing methods, in order to allow more aggressive code optimization.

No longer using the WinAPI WaitForSingleObject function.

Fixed some numerical bugs in map projection code.

Updated EPSG geodata registry to version 9.9.1.

Fixed the algorithm that orders #include directives in the C++ source code, to reduce the number of code changes for future updates.

Unified DisposeManaged / DisposeUnmanaged of Disposable into DisposeResources.

Removed obsolete hooks for disposal at shutdown.

Tinman shutdown now frees all resources and reverts to the initial state.

Tinman can now be used again after shutdown.

Fixed a bug when loading non-power-of-two DDS textures.

Now using local NuGet cache for packages, please run "Restore NuGet packages" once.

AddOns for Direct3D 9 no longer use the D3DX Effects API, source code has been dropped.

Now performing additional thread-synchronization in Disposable class. There were reports of spurious sharing violation problems on dataset files when being used concurrently.