Let's start with a screenshot:

This screenshot shows you that the Ab3d.DXEngine now fully supports Oculus Rift. And as you can see from the the window title and Oculus Performance overlay it has no problems with rendering at 90 FPS and still having plently of performance headroom.

What is more, because there were no up-to-date wrapper library for Oculus SKD available (the newest was OculusWrap, but it was discontinued on April 2016), I have decided to update the OculusWrap library to support the latest Oculus SDK (1.10.2) and published the updated library to GitHub to https://github.com/ab4d/Ab3d.OculusWrap.

The previous two paragraphs mean two things:

1) If you would like to use Oculus Rift in .Net and would like a low level access to the native Oculus library, you can do that now with the updated Ab3d.OculusWrap library.

2) If you want to stay in the comfort of using WPF 3D, Ab3d.PowerToys and Ab3d.DXEngine libraries and would like to add Oculus Rift support, you can now do that with adding just a few lines of code.

So if you have an Oculus Rift headset, you are most welcome to go to the above GitHub address and enter the VR world generated by .Net code.

I am really happy to inform you that after many hours of coding that resulted in tons of new features and improvements a major new version of Ab3d.DXEngine is released. Ab3d.DXEngine is a super fast 3D rendering engine that uses DirectX 11 and SharpDX and can be used in .Net Desktop applications.

The biggest new feature is support for shadow rendering. Ab3d.DXEngine uses variance shadow mapping technique that can produce nice soft shadow with little artifacts (based on the article in GPU Gems). The following screenshot shows an example taken from samples that come with the library:

In the lower right corner of the screenshot you can see various shadow settings that allow easy control over shadow resolution and amount of softness.

Another great improvement is a new option that allow rendering 3D lines that are visible through solid objects. This is a great feature for showing selected 3D objects.

The new version also improves handling frozen WPF 3D objects – for example frozen DiffuseMaterial or MeshGeometry3D. Before frozen objects were not very well reused by DXEngine. The new version handles this much better and this can improve initialization time, memory usage and rendering performance.

Ab3d.DXEngine is using SharpDX library for providing access to native DirectX API. The previous version of Ab3d.DXEngine used SharpDX version 2.6.3. The reason for this was that version 2.6.3 was the latest version that supported .Net 4.0 framework. Later version of SharpDX require .Net 4.5. Because Ab3d.DXEngine comes with build for both .Net 4.0 and .Net 4.5, it was possible to update the .Net 4.5 version so that it now uses the latest SharpDX version 3.1.0. The build for .Net 4.0 still uses SharpDX 2.6.3 - here a slightly updated version is used that supports feature level 11.1 (before 11.0 was supported).

This release also comes with a new diagnostics tool that is called DXEngineSnoop. As the name suggests, the tool can “snoop” (from WPF Snoop) into a running WPF application, finds the DXViewportView and attaches to its events and then provides live diagnostics and performance data. The tool also allows starting many actions that show various details about the rendering process – for example hierarchical view of SceneNodes.

The following screenshot shows the DXEngineSnoop window after it has been attached to a running DXEngine (right side shows context menu that is opened when user click on the menu icon):

This tool can help improve understanding of how Ab3d.DXEngine works behind the scene.

I will write more about that in one of the future articles. Now I can just quickly describe the process: first the DXViewportView converts all the WPF 3D models that are defined in Viewport3D into different SceneNodes. The hierarchical organization of SceneNodes can be seen with clicking on “Dump SceneNodes”. The SceneNodes than create low level objects that are put into various Rendering Queues (for example transparent objects are put into “Transparent RenderingQueue”). Those two steps are done in the Update part of the rendering (on the left side seen as UpdateTime). Then rendering of objects in Rendering Queues begin. The operations that happen there are defined in the RenderingSteps collection (can be seen with clicking on “Dump RenderingSteps”). Those steps can change when different rendering modes are used – for example shadow rendering require some additional rendering steps that render shadow map; stereoscopic rendering require a simple loop that repeats some rendering steps for left and for right eye. RenderingSteps collection is fully customizable and provides a great extensibility point for many engine customizations.

DXEngineSnoop can be also used to diagnose memory issues with providing simple way to start tracking object creation and to easily show reports of live objects. There is also a new section in the DXEngine help file that describes how to check for memory leaks.

The new version also brings many stability and performance improvements.

For example, when rendering thousands of models with object instancing, it is now possible to do a faster update of data when only a few objects were changed (their color or transformation is changed). For cases when object data are changed often it is now possible to further improve performance with creating a dynamic instance buffer (with UseDynamicInstanceBuffer property).

There are also some other minor performance improvements. But the majority of work was done on improving support for customizing the engine. This means that it will be easier to add new features and extend the engine to provide additional rendering functionality.

Also, users that know how to program with SharpDX and DirectX and would like to include existing SharpDX code into the engine have now more options to do that. There are also a few new samples with extended code comments about that. If you are doing a low-level customization, I would recommend that you contact me and we can discuss the best options for your use case.

To show new functionality, there are also a few new samples. Some older samples were also improved.

What is more, the new version comes with a new WinForms project that shows three different ways how to use DXEngine to easily show great DirectX 11 graphics inside WinForms application. The following screenshot shows one of the samples:

I do not want to make this blog post too long. Therefore, I will not publish the huge change log here but would rather invite you to check it on the DXEngines’s web page.

Instead, I would like to conclude with a few future plans.

First, I would like to publish the sample that shows how to use DXEngine with Oculus Rift. Actually, there is already a working sample that brings full Oculus Rift support to WPF and WinForms (and without need to understand the world of DirectX). The samole just need some additional plising before being published. If you cannot wait for an official release, you can contact me and I will send you the current version.

Then I will start working on a new version of Ab3d.PowerToys. I already have many many great ideas. The main focus will be to make the library better suited for CAD like scenarios. As a result, I want to create a big sample that will be a simple CAD like application written in .Net and that will use Ab3d.PowerToys and Ab3d.DXEngine.

I am very happy that I can present you some great new features of new versions of Ab3d.PowerToys and Ab3d.DXEngine.

The greatest new features of this release are:

- Support for stereoscopic rendering for 3D TV and for red-cyan glasses,
- Ultra-quality settings with new super-sampling mode that improve render quality,
- Improved support for rendering over Remote desktop.,
- Export WPF 3D models to Collada (.dae), obj, ply and stl files (using Assimp exporter).

Stereoscopic rendering

Ad3d.DXEngine just got support for split-screen and anaglyph rendering. Those are the first two steps into the virtual reality world.

Split-screen rendering allows viewing the 3D scene on 3D TV screens. The following screenshot shows a simple generated 3D screen:

The virtual reality 3D effect can be also achieved with using red-cyan (or some other colors) glasses and with using the Anaglyph rendering mode:

I also checked the requirements for NVIDIA 3D Vision. But unfortunately it requires an exclusive full screen rendering mode and does not work in maximized borderless window mode that is the only full screen mode possible by WPF. But the good news is that it looks like it will be possible to add support for Oculus Rift and Vive. So if you like virtual reality, stay tuned for the future version.

Super-sampling mode

DirectX usually uses multi-sampling (MSAA) that improves the quality of the edges with producing nice anti-aliased edges. Instead of using multi-sampling it is also possible to use post-processing techniques (for example FXAA or SMAA) to produce nice soft edges. But neither multi-sampling nor anti-aliasing post processing do not solve the problem where small details are can be lost when objects are rendered far away from the camera.

This problem is visible on the left side of the following screenshot:

The solution to this problem is to use super-sampling – as shown on the rights side. Super-sampling solves this problem with calculating color (executing pixel shader) for each sample – this means multiple times for each pixel. This effectively gives the same results as if the image would be rendered at a bigger resolution and then scale the image down to the target resolution.

Remote desktop

I would also like to mention that the new version of Ab3d.DXEngine library improves support for rendering over remote desktop. Previously the 3D scene was visible through remote desktop only when DirectXOverlay PresentationType way used. But this presentation type has a serious drawback because it does not allow to mix 3D content with other 2D WPF content – for example render 2D controls on top of 3D scene. With the new version, the remote desktop works well also with DirectXImage PresentationType – this allows showing 3D scene that is mixed with other 2D controls. Note that this requires .Net target framework 4.5 or later and using the .net 4.5 build of Ab3d.DXEngine library.

Those three new features were in my opinion the best new features of this release for Ab3d.DXEngine. But as always there are more new features and fixes available. The following is the full list of all other changes:

• Simplified setting line depth bias with SetDXAttribute(DXAttributeType.LineDepthBias, depthBias) method - this can prevent z-fighting when rendering 3D lines on top of solid objects.
• Added Ab3d.DirectX.DXDiagnostics.CaptureNextFrame and IsCaptureFrameSupported methods to programmatically captures the next rendered frame with Visual Studio Graphics Debugging (this also allows capturing frames for DirectXImage PresentationType).
• Added support for Visibility property on objects derived from UIElement3D .
• Added IsMaterialSortingEnabled property to DXScene to control if sorting objects by their materials is enabled. Enabling sorting improves performance because objects with the same materials are rendered one after another (this reduces the required DirectX state changes), but when you want to have determined order of rendering you can disable the sorting.
• Improved automatically updating WireframeVisual3D when LineThickenss or LineColor is changed.
• Improved hardware rendering of 3D lines - depth problems could occur when long lines are crossing the near plane (one end of the line is behind the line).
• Added Clone method to GraphicsProfile to simplify creating your custom graphic profiles that are based on default graphics profiles.
• Added ExecutePixelShaderPerSample to DXScene and to GraphicsProfile - this allows turning multisampling into supersampling for better shader quality (used by new UltraQualityHardwareRendering).
• Prevented throwing exception when ImageBrush uses a texture with relative Uri.
• Fixed using EmissiveMaterial properties on materials that do not have DiffuseMaterial (under some circumstances).
• Fixed using Opacity or alpha value for EmissiveMaterial.
• Changed some properties and methods in RenderingContext class and in some RenderingSteps - if you are an advanced DXEngine user and use custom rendering steps, you can contact us to get a full list of changes.

Export 3D models to Collada, obj, ply and stl files

This release also brings many new features to the Ab3d.PowerToys library.

The most important new feature is added ability to export WPF 3D models to Collada (.dae), obj, ply and stl files. This was really a highly requested feature. It allows creation of 3D models with WPF 3D and Ab3d.PowerToys that can be exported and used in some other 3D modelling application.

The code that does the exporting is using the great open source Assimp library. 

As with Ab3d.DXEngine, this release of Ab3d.PowerToys also has quite long list of improvements and fixes – the following is the full list of changes:

• Added support for texture coordinates generation in extruded mesh - use new ExtrudeTextureCoordinatesGenerationType.
• Added ConeTubeVisual3D - it can be used to create Visual3D that represents a 3D Tube with different top and bottom radius.
• Added a new constructor to TubeMesh3D that takes different inner and outer radius of top and bottom of the tube.
• Added IsXAxisShown, IsYAxisShown and IsZAxisShown properties to ModelMoverVisual3D to allow showing only specifed arrows.
• Added MeshUtils.GenerateCylindricalTextureCoordinates method that generates TextureCoordinates based on the Cylindrical projection.
• Added MeshUtils.Project3DPointsTo2DPlane to project 3D positions to a 2D plane.
• Improved EventManager3D to call MouseLeave, MouseEnter and other events when the camera is changed by MouseWheel.
• Added UpdateHitObjects method to EventManager3D - it can be used to manually update the current 3D object behind the mouse position - this is useful when camera is changed without changing the mouse position.
• Improved FreezeMeshGeometry3D property on BoxVisual3D and SphereVisual3D so that they do not to be set before all other properties.
• Added ModelUtils.HasAnyLight method that checks the Viewport3D, Visual3D or Model and returns true if any light is defined (it is possible to exclude AmbientLight).
• Changed default AssimpWpfImporter.AssimpPostProcessSteps from PostProcessSteps.FlipUVs | PostProcessSteps.GenerateSmoothNormals | PostProcessSteps.Triangulate to PostProcessSteps.Triangulate.
• Improved automatically setting shapeYVector in an overload of CreateExtrudedMeshGeometry that does not have the shapeYVector parameter.
• Fixed problems with ModelMoverVisual3D when it is shown inside DXEngine and AxisLength, AxisRadius or AxisArrowRadius are changed after the ModelMoverVisual3D is already shown.
• Fixed recreating 3D lines in cases when the parent ModelVisual3D is removed from Viewport3D, then the camera is changed and the parent ModelVisual3D is added to the scene again.

I hope that you like the new features and stay tuned for next version. The plan is to add support for shadow mapping and great new ways to animate the camera in 3D space.

I would like to inform you that today new versions of all the AB4D products have been published.

The main reason for this release is that the evaluation and commercial licensing code that is included in all the products have been greatly improved. What is more, the deployment script that I use to prepare all release version have been improved.

Also, all the products got some additional functionality or fixed bugs. For example, the following image shows new ViewCubeCameraController from Ab3d.PowerToys library:

The main benefits of the new licensing and deployment are:

• All products are now also compiled for .Net 4.5 target framework. This means that all products are available for .Net 3.5, .Net 4.0 and also .Net 4.5 (an exception is Ab3d.DXEngine that does not support .Net 3.5). This will allow using new language features in the libraries – especially async and await support.
• New evaluation and commercial licensing code is now faster and required less resources.
• New evaluation code allows starting ad-hock evaluation on a computer that do not have the evaluation version installed. This means that you will be able to create a sample project with an evaluation version and then just copy your application to another computer. At the first start of your application you will get a dialog to start a new evaluation and then be able to continue running your application. In the previous version you needed to install evaluation version on the other computer too.
• Improved commercial licensing code that brings new options to embed license key into your project and allows using special license key for application. This simplifies compiling projects on cloud base build servers and allows some other non-standard distributions. More details about that can be found in the new “Using commercial version” help file.

The new version also introduces new directory structure that is created after the libraries are installed. In the previous version the libraries for .Net 3.5 framework were installed into “bin” folder and libraries for .Net 4.0 framework were installed into “bin\.Net 4” folder. Now the organization is much more standard: the .Net 3.5 assemblies are in “bin\net35” folder, .Net 4.0 assemblies are in “bin\net40” folder and .Net 4.5 assemblies are in “bin\net45” folder.

This means that you might need to update your references.

The new .Net 4.5 versions of the libraries will allow using async keywords. Currently this has not yet been added to any of the libraries. But in the near future I plan to add support for async to all of the libraries. For example, async loading of 3D models or svg files. Another possibility is to create async methods to animate camera or ZoomPanel.

As mentioned before, this release also brings other improvements and fixes.

Ab3d.PowerToys got some great new features. The most highly anticipated feature is the ability to control the camera with 3D cube. The image with three possible cubes was shown before.

Another great addition to the library are new TubePathVisual3D and TubePathMesh3D that allows creating various tube based objects:

The following is a full list of new features in Ab3d.PowerToys library

• Added ViewCubeCameraController.
• Added TubePathVisual3D and TubePathMesh3D.
• Added support to create extruded MeshGeometry3D that has custom orientation (not only in the direction of Y axis). This can be achieved with using a new override of CreateExtrudedMeshGeometry that also takes shapeYVector parameter.
• Added IsStartPositionClosed and IsEndPositionClosed properties to TubeLineVisual3D. Also added additional isStartPositionClosed and isEndPositionClosed constructor parameters to the TubeLineMesh3D.
• Added FreezeMeshGeometry3D to BoxVisual3D and SphereVisual3D to control if the MeshGeometry3D is frozen.
• Improved TubeVisual3D that now allows setting Height to 0 - this creates an optimized TubeVisual3D without creating both bottom and top ring - in this case only bottom ring is created.
• Fixed using adjustmentFactor in FitIntoView method.
• Fixed using FitIntoView when it is called in Loaded method and the Viewport3D is shown in Ab3d.DXEngine.
• Fixed type used by ShowMovablePlanes property.
• Improved MouseCameraController to capture the mouse only when the mouse rotation / movement is bigger than a few pixels. This prevents "swallowing" MouseUp event for processing mouse click in EventManager3D.
• Added UsePreviewEvents property to EventManager3D – when set to true the EventManager3D subscribes to Preview mouse and touch events instead of standard events - for example PreviewMouseUp event instead of MouseUp event. This can be used to use left mouse button for camera rotation and also for click events.
• Added TurnTo method to FirstPersonCamera - this turns the camera towards the specified position or to the specified direction vector.
• CameraControlPanel now moves the FirstPersonCamera forward or backwards when ZoomIn or ZoomOut buttons are clicked.
• When MouseCameraController is used for FirstPersonCamera the mouse wheel now moves camera forward and backwards.

The library also got a few new samples. Two are to demonstrate the ViewCubeCameraController and TubePathVisual3D. There is also a greatly improved FirstPersonCamera sample that also shows how to turn the camera toward the clicked object. Another new sample shows how to create an application where user can draw to a 3D texture – for example to write annotation to a 3D height map.

Ab2d.ReaderSvg library that can read svg files also got many new features. 

The new version now supports textPath element that can render text on a path:

Another very interesting new feature is the new GetElementSvgText method that returns the outer xml text of the specified element. This can be very useful when you add some special attributes or elements to the svg elements. If those elements are not standard svg elements, then ReaderSvg cannot read them. But with using GetElementSvgText you can get the xml text from the specified element and then parse the data out of the xml.

The following is a list of all new features:

• Added support for textPath elements (positioning text on a path).
• Added GetElementSvgText to get the svg text of the element with the specified id (can be used to read some additional svg properties that are not read by ReaderSvg).
• Added support for dx and dy properties on the text element.
• Fixed writing new line characters in XAML.
• Added support for vertical text (glyph-orientation-vertical svg property).
• Improved writing images in XAML that are now written in more clear XAML. Also fixed setting Source for images that are created from foreign objects.
• Added support for reading number lists that end with comma - for example "12, 34, 56," - this prevented reading svg file in the previous version.
• Improved support for rounder corners on rectangles in case when only rx or only ry is specified - in this case the other value is set to the same value.

Other libraries got only a few updates.

For example, the Ab3d.DXEngine library does not have any new feature in the core libraries but there are three new samples that show how to use standard DirectX rendering code inside DXEngine. The samples show how to render 3D cube with SharpDX code, use the camera and camera controller from Ab3d.PowerToys and mix the rendered 3D cube with other 3D objects from Ab3d.PowerToys library.

Ab2d.ReaderWmf got the following new features:

• Improved reading images with negative scale transformations.
• Improved positioning text for some special use cases (correctly position text based on the TextAlign mode).
• Fixed ResourceDictionaryWriter so that the ResolveResourceKeyCallback is called also for root keys.

ZoomPanel library was only slightly improved – the number of history items was increased to 100.

Also Ab3d.Reader3ds got only one improvement. The support for reading broken 3ds files has been improved so that some invalid positions that are not used in TriangleIndices are fixed. This prevents creating too big bounds value that is usually used to position the camera after the model is loaded. 

I am really excited about this release. It improves many aspects of the libraries that are not related to the core functionality but are needed because of licensing. It also enables many new features that are possible with .Net 4.5 and allows creating more user friendly APIs with async methods.

I would like to inform you that a smaller maintenance update for Ab3d.DXEngine has been published.

The update does not add new functionality to the rendering engine. It improves the performance of the engine and fixes a few issues.

The following is a list of changes:

• Greatly improved performance of WireframeVisual3D when the 3D objects showing with WireframeVisual3D are animated with changing transformations.
• Prevented black edges that sometimes appeared when showing textures.
• Fixed rendering transparent objects that were not visible sometimes because of incorrect object order.
• Fixed rendering specular highlight for directional light shader.
• Fixed getting camera's view and projection matrices for left handed coordinate system (when IsRightHandedCoordinateSystem is false).

I am happy to announced that a new version of Ab2d.ReaderSvg is available.

As shown in the image above, the ReaderSvg now supports textPath svg element that positions text on a referenced path element.

Another very interesting new feature is a new GetElementSvgText method that returns the original svg text of the element specified with its name. This way it is possible to read data from svg file that are not recognized by ReaderSvg. The following image shows svg text for the selected element in ViewerSvg:

There are also some other great new features and fixes:

• Added support for vertical text (glyph-orientation-vertical svg property).
• Improved support for rounder corners on rectangles in case when only rx or only ry is specified - in this case the other value is set to the same value.
• Fixed reading text decorations (Underline and Strikethrough).
• Added support for reading metafiles embedded into image's base64 encoded string.
• Added support for reading images in foreignObject created in Microsoft Visio.
• Added ReadForeignObjects property to Ab2d.ReaderSvg that enables or disables reading foreignObject elements (enabled by default).
• Added support for reading data from number lists that end with comma - for example the following string in svg file was not read: "12, 34, 56,".
• Improved writing images in XAML. They are now written in more clear format. Also fixed setting Source for images that are created from foreign objects.
• Fixed writing new line characters in XAML.

As alwasy, the customers can get the latets version from their User Account page. Others can try the new version with downloading the evaluation version.

And if yuo find a svg file that is not read correctly, please send it to me and I will my best to improve ReaderSvg.

The new version of Ab3d.DXEngine brings three big new features:

1. Added support for rendering reflections with environmental and reflection maps.
2. Added support for rendering unlimited number of lights with using multi-pass rendering.
3. Improved rendering instanced objects with adding support for rendering many instances of Model3DGroup objects. Simplified hit testing on instanced objects with a new GetHitInstanceIndex method.

The Ab3d.PowerToys library also got some great new features. Some of the main new features are:

1. Added ModelRotatorVisual3D that allows users to rotate selected 3D model. Improved ModelMoverVisual3D so that it also works in Ab3d.DXEngine.
2. Greatly reduced the initialization time when creating many instances of SphereVisual3D and BoxVisual3D objects.
3. Simplified working with hierarchically organized 3D models with new model iterators.

Let’s see some more details about the new features.</p> <p>Showing reflections pushes the boundaries of what is possible to achieve with WPF 3D API even further. The above image with reflective teapot shows a fully reflective 3D model. The level of reflection can be adjusted and specified for the whole object. Or, it can be specified for each part of the model with using a reflection map. The following image shows that is action (the reflection map is shown on the right):

The handle and top of the teapot are shown with green color (specified in the teapot’s texture on the bottom image) and do not reflect the environment – those parts are almost black on the reflection map (upper image). But the rest of the teapot is fully reflective – defined by white color on the reflection map (in the bottom 1/3 of the image and on the smaller white rectangle on the right side).

To support scenarios where additional DXEngine properties need to be added to the existing WPF objects, the new version of Ab3d.DXEngine introduces a new set of extensions methods that allow adding additional attributes to WPF objects. 

For example the following two lines set EnvironmantMap and ReflectionMap to an existing WPF material:

usedMaterial.SetDXAttribute(DXAttributeType.Material_EnvironmentMap, _dxCubeMap);
usedMaterial.SetDXAttribute(DXAttributeType.Material_ReflectionMap, bitmapImage);

The new version of Ab3d.DXEngine also adds support to render unlimited number of lights. Previous version supported rendering only 16 lights + ambient light. This limit is now lifted with using multi-pass rendering. This means that when there are more than 16 lights in the scene it is rendered multiple times – each time different 16 lights are used and then all the rendered scenes are combined into the final image. The following screenshot shows a sample that animates the intensity of 64 PointLights:

Multi-pass rendering is great for such scenarios. But it also has some disadvantages. If you need to use many lights, please check the additional comments in the “Many lights” sample.

I would also like to write a few words about new object instancing capabilities.

Object instancing is the ultimate performance optimization – if you show really many 3D objects and you convert your code to use object instancing than you have almost reached the peak of the performance. Some additional performance gains are still possible with tweaking the shaders, but most of the work was already done.

The trick is that when object instancing is used, the applications sends one mesh geometry to the graphics card and then tells it to render it many times – for each instance of the mesh you can specify different color and different transformation. Because the data about all the instances is send in one draw call, this can be done very quickly on the CPU. So the usual performance problem where GPU waits for the CPU to send commands is completely eliminated. 

Because instancing is so great for improving performance, the new version also allows you to render many instances of Model3DGroup objects (and not only many instances of MeshGeometry3D). The following screenshot shows many instances of RobotArm model:

Another improvement with instancing is that a GetHitInstanceIndex method was added to the InstanceData class. That method can be used in hit testing to get the index of the hit instance. This way you can easily connect the hit object with the background data that are connected to the hit instance.

If you are rendering many 3D objects, I would really advice you to try to convert your code to use instancing. You will be amazed on how fast the graphics cards can become when they are not waiting for the CPU (a newer graphics card recommended).

There are still lots of other new features and fixes. Also Ab3d.PowerToys library has been greatly improved.

But I do not want to make this blog post too long. 

To check new features in action, please check the new samples that come with the libraries. And for the record here are the full list of changes:

Ab3d.DXEngine v1.2:

• Added support for rendering reflections with using EnvironmentalMaps
• Added support for ReflectionMaps
• Added support for rendering more than 16 lights (+ ambient light) with using multi-pass rendering.
• Added support for Transform on InstancedMeshGeometryVisual3D
• Added InstancedModelGroupVisual3D that can render many instances of all 3D models defined in the Model3DGroup.
• Added GetHitInstanceIndex method to InstanceData to get an index of hit instance
• Fixed showing transparent objects in some cases
• Added TextureBlendState to IDiffuseTextureMaterial interface
• Fixed rendering textures from files that use different DPI settings
• Added extension methods that simplify adding additional DXEngine attributes to the existing WPF's objects (SetDXAttribute, GetDXAttributeCollection, GetDXAttribute, IsDXAttributeSet, ClearDXAttribute, GetDXAttributeOrDefault). This is currently used to specify the EnvironmentalMap and ReflectionMap.
• Prevented memory leak when 3D model that was shown inside WireframeVisual3D was changed (further performance improvements in this case will follow).
• Prevented rendering strange 3D lines that sometimes occur when the 3D lines were completely behind the camera
• Fixed rendering transparent 3D lines
• Fixed rendering transparent objects with emissive materials
• Some other smaller bug fixes and improvements

BREAKING CHANGE:
The InstancedGeometryVisual3D was renamed into InstancedMeshGeometryVisual3D – the renaming was needed because a new InstancedModelGroupVisual3D was introduced and the previous name did not describe the class well enough.

Ab3d.PowerToys v7.4:

• Added ModelRotatorVisual3D that allows user to rotate selected Model3D around any axes.
• Added SubscribeWithEventManager3D method to ModelMoverVisual3D and ModelRotatorVisual3D to allow them to use EventManager3D for processing mouse events. This allows using the ModelMoverVisual3D and ModelRotatorVisual3D in Ab3d.DXEngine.
• Greatly reduced the initialization time when creating many instances of SphereVisual3D or BoxVisual3D objects
• Added ModelIterator class and two extension methods (ForEachVisual3D and ForEachGeometryModel3D) to simplify working with hierarchacly organized 3D models.
• Added FitIntoView and GetFitIntoViewDistanceOrCameraWidth methods to TargetPositionCamera, SceneCamera, TargetRect3DCamera and ThirdPersonCamera. The method has greatly improved algorithm then it was available in the "Scene Editor" sample in the previous versions of Ab3d.PowerToys.
• Fixed showing transparent 3D lines when LineColor's alpha value is less than 255.
• Improved support for TextureCoordinates in ModelOptimizer
• Added WidthDirection and HeightDirection to WireGridVisual3D that allows to set custom direction of the WireGrid (not only horizontal or horizontal in another coordinate system)
• Added CreateWireGrid to Line3DFactory that allows creating WireGrid object with custom widthDirection and heightDirection vectors.
• Added GetTargetViewport3DSceneBounds method to all Camera classes in Ab3d.PowerToys – the method calculates the scene bounding box
• Change validation of Size property on BoxVisual3D, WireBoxVisual3D, MultiMaterialBoxVisual3D and PyramidVisual3D to allow having one component of size zero.
• Fixed calculating scene size in SceneCamera when the scene hierarchy is complex
• Added GetBounds and CombineTransform methods to Ab3d.Utilities.ModelUtils
• Added CompositionRenderingHelper to help work with CompositionTarget.Rendering (allowing subscribed objects to be recycled by Garbage Collection and therefore preventing infinite rendering subscription in case when the Rendering is not unsubscribed)
• Improved ModelMoverVisual3D so that it can also use EventManager3D for mouse event processing - this allows using ModelMoverVisual3D inside Ab3d.DXEngine.
• Prevented throwing "Object reference" exception in ModelOptimiter that could occur sometimes when ImageBrush is used.
• Added HeightDirection to TubeVisual3D and TubeMesh3D – this allows orienting the object in any direction and not only in up (0, 1, 0) direction.
• Fixed throwing exception when Is3DAxesShown is initially set to false on CameraAxisPanel

• Added "Custom Up Axis" sample that shows how to show data in another coordinate system - for example where Z is up.
• Added "Perspective Transformation" sample that shows how to convert 3D positions to the 2D positions on the screen

BREAKING CHANGE:
Moved the ModelMovedEventArgs class from Ab3d.PowerToys.Common to Ab3d.Common namespace