Touch and multi-touch support is becoming more and more important. The previous version of Ab3d.PowerToys had only basic touch support – it supported only those touch events that were transformed into mouse events. To get better touch support users needed to use MultiTouchMouseCameraController class that was available in a separate project.

The new version adds excellent touch and multi-touch support to the core of the Ab3d.PowerToys library. This means that without any change in your code, the users of your application that will have touch screen will be able to rotate and move the camera with touch and also use pinch to zoom in and out. New MouseCameraController has many new properties that can be used to configure the touch actions.  To get full control of touch events, you can override some methods that control the behavior of MouseCameraController. See help file for more information.

To further improve the user experience, the new version now also adds camera rotation velocity inertia. This means that if user rotates the camera and then released the mouse button (or touch), the velocity of the camera rotation is preserved and the camera’s rotation is stopped slowly. This looks much more naturally, especially when used with touch.

The new rotation easing is now also supported by StartRotation and StopRotation methods. Now it is possible to start and stop rotation with slowly accelerating / decelerating the rotation velocity.

The last new feature is related to HeightMapVisual3D. Now when the data that is set to HeightData is changed, it is possible to call the new UpdateContent method to update the 3D model of the height map.

I hope you and your customers will like the new features. If you have any additional requests or ideas, please do not hesitate to contact us.

I am happy to announce that a new version of Ab2d.ReaderSvg and Ab2d.ReaderWmf have been published.

I am particularly proud of adding some very interesting hierarchy optimizations to ReaderSvg. Drawings in svg files are many times defined in many groups and with using transformations. In case you do want to simply show your vector assets, than it is much more convenient to have the drawing objects compact and without the complex hierarchies. With the new version of ReaderSvg this is not very easy task. More about that later in this post.

First let me show what is new for Ab2d.ReaderWmf – metafile reader for WPF:

• Improved reading geometries when rectangle or ellipse have both Canvas position (Canvas.Left or Canvas.Top) and transformation set.
• Improved xaml writer to prevent writing Canvas.Left = "0" and Canvas.Top = "0" (zero values can be skipped).
• Prevented writing "Canvas.Left" and "Canvas.Top" properties in XAML two times.
• Added IgnoreRootElementSize property to GeometrySetting - added possibility to remove the transformations or RectangleGeometry based on the size or root element.
• Fixed not showing some texts under some circumstances.

Most of the improvements in ReaderWmf are also available in ReaderSvg. Here is the full list:

• Clip path now works on all elements and not just on Canvas.
• Improved size measurement when AutoSize is set to true and some objects are hidden.
• Added objects grouping optimizations to ReaderSvg - they can be controlled by new properties in ReaderSvg: OptimizeObjectGroups, FlattenHierarchies, TransformShapes
• Improved transforming read objects with calling Transform method.
• Updated SvgBounds after calling Transform method with updateLastReadViewbox set to true.
• Prevented throwing exception in GetObjectsWithCustomProperties when svg file does not have any custom properties.
• Added IgnoreRootElementSize property to GeometrySetting - added possibility to remove the transformations or RectangleGeometry based on the size or root element. This can produce nicer XAML.
• Fixed using transformations on EllipseGeometry and RectGeometry when reading svg file as geometry.
• Prevented writing "Canvas.Left" and "Canvas.Top" properties in XAML two times.
• Improved reading geometries when rectangle or ellipse have both Canvas position (Canvas.Left or Canvas.Top) and transformation set.
• Improved XAML writer to prevent writing Canvas.Left = "0" and Canvas.Top = "0" (zero values can be skipped).

As mentioned before ReaderSvg now support optimizing groups. The best way to describe this new functionality is to show it in action. Let’s start with the following XAML that can be get when using no optimization:

<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="200" Height="100">
    <Canvas>
        <Canvas Name="g1">
            <Rectangle Fill="Yellow" Width="200" Height="100"/>
            <Canvas Name="g2">
                <Canvas Name="g3">
                    <Ellipse Name="e1" Fill="Red" Width="20" Height="20"/>
                    <Canvas Name="g4">
                        <Canvas Name="g6" RenderTransform="2,0,0,1,-60,-10">
                            <Canvas Name="g5" Canvas.Left="50" Canvas.Top="10">
                                <Ellipse Name="e2" Fill="Green" Width="20" Height="20" Canvas.Left="10" Canvas.Top="10"/>
                                <Canvas Name="g7" RenderTransform="0.5,0,0,1,20,20">
                                    <Canvas Name="g8">
                                        <Canvas Name="e3" RenderTransform="1,0,0,2,20,0">
                                            <Ellipse Fill="Blue" Width="20" Height="20" Canvas.Left="20"/>
                                        </Canvas>
                                    </Canvas>
                                </Canvas>
                                <Canvas Name="g9" RenderTransform="5,0,0,5,0,0">
                                    <Canvas Name="g10">
                                        <Ellipse Name="e4" Fill="Orange" Width="4" Height="4" Canvas.Left="11" Canvas.Top="3"/>
                                    </Canvas>
                                </Canvas>
                                <Canvas Name="g11" Canvas.Left="-10" Canvas.Top="30">
                                    <Polygon Name="p1" Points="10,10 30,10 20,20" Fill="Lime" StrokeThickness="1"/>
                                    <Canvas Name="g12" RenderTransform="1.5,0,0,1,0,10">
                                        <Polygon Name="p2" Points="10,10 30,10 20,20" Fill="Aqua" StrokeThickness="1"/>
                                        <Canvas Name="g13" RenderTransform="0.866025388240814,0.5,-0.5,0.866025388240814,0,0">
                                            <Polygon Name="p3" Points="10,10 30,10 20,20" Fill="Purple" StrokeThickness="1"/>
                                        </Canvas>
                                    </Canvas>
                                </Canvas>
                            </Canvas>
                        </Canvas>
                    </Canvas>
                </Canvas>
            </Canvas>
        </Canvas>
    </Canvas>
</Canvas>

The XAML shows that there are many Canvases that contains only other Canvases. In the first step we can set OptimizeObjectGroups to true. This reduces the size of XAML to:

<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="200" Height="100">
    <Canvas Name="g1">
        <Rectangle Fill="Yellow" Width="200" Height="100"/>
        <Canvas Name="g3">
            <Ellipse Name="e1" Fill="Red" Width="20" Height="20"/>
            <Canvas Name="g5" RenderTransform="2,0,0,1,40,0">
                <Ellipse Name="e2" Fill="Green" Width="20" Height="20" Canvas.Left="10" Canvas.Top="10"/>
                <Canvas Name="e3" RenderTransform="0.5,0,0,2,30,20">
                    <Ellipse Fill="Blue" Width="20" Height="20" Canvas.Left="20"/>
                </Canvas>
                <Canvas Name="g10" RenderTransform="5,0,0,5,0,0">
                    <Ellipse Name="e4" Fill="Orange" Width="4" Height="4" Canvas.Left="11" Canvas.Top="3"/>
                </Canvas>
                <Canvas Name="g11" Canvas.Left="-10" Canvas.Top="30">
                    <Polygon Name="p1" Points="10,10 30,10 20,20" Fill="Lime" StrokeThickness="1"/>
                    <Canvas Name="g12" RenderTransform="1.5,0,0,1,0,10">
                        <Polygon Name="p2" Points="10,10 30,10 20,20" Fill="Aqua" StrokeThickness="1"/>
                        <Canvas Name="g13" RenderTransform="0.866025388240814,0.5,-0.5,0.866025388240814,0,0">
                            <Polygon Name="p3" Points="10,10 30,10 20,20" Fill="Purple" StrokeThickness="1"/>
                        </Canvas>
                    </Canvas>
                </Canvas>
            </Canvas>
        </Canvas>
    </Canvas>
</Canvas>

But there are still many Canvases. A more radical step is to remove the all the hierarchies. This can be simply done with setting FlattenHierarhy to true (OptimizeObjectGroups can be set to false). The results speak for themselves:

<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="200" Height="100">
    <Rectangle Fill="Yellow" Width="200" Height="100"/>
    <Ellipse Name="e1" Fill="Red" Width="20" Height="20"/>
    <Ellipse Name="e2" Fill="Green" Width="20" Height="20" RenderTransform="2,0,0,1,40,0" Canvas.Left="20" Canvas.Top="10"/>
    <Ellipse Fill="Blue" Width="20" Height="20" RenderTransform="1,0,0,2,100,20" Canvas.Left="20"/>
    <Ellipse Name="e4" Fill="Orange" Width="4" Height="4" RenderTransform="10,0,0,5,40,0" Canvas.Left="110" Canvas.Top="15"/>
    <Polygon Name="p1" Points="10,10 30,10 20,20" Fill="Lime" StrokeThickness="1" RenderTransform="2,0,0,1,20,30"/>
    <Polygon Name="p2" Points="10,10 30,10 20,20" Fill="Aqua" StrokeThickness="1" RenderTransform="3,0,0,1,20,40"/>
    <Polygon Name="p3" Points="10,10 30,10 20,20" Fill="Purple" StrokeThickness="1" RenderTransform="2.59807616472244,0.5,-1.5,0.866025388240814,20,40"/>
</Canvas>

With using just one simple property we have come from a complex hierarchy to one simple Canvas that contain all the objects. But we can go even one more step further. As seen in the last step, almost all the objects use RenderTransform to transform them. With setting TransformShapes to true we can eliminate almost all RenderTransforms from the objects. So after setting both FlattenHierarhy and TransformShapes to true, we are left with the following XAML:

<Canvas xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="200" Height="100">
    <Rectangle Fill="Yellow" Width="200" Height="100"/>
    <Ellipse Name="e1" Fill="Red" Width="20" Height="20"/>
    <Ellipse Name="e2" Fill="Green" StrokeThickness="1.414" Width="40" Height="20" Canvas.Left="60" Canvas.Top="10"/>
    <Ellipse Fill="Blue" StrokeThickness="1.414" Width="20" Height="40" Canvas.Left="120" Canvas.Top="20"/>
    <Ellipse Name="e4" Fill="Orange" StrokeThickness="7.071" Width="40" Height="20" Canvas.Left="150" Canvas.Top="15"/>
    <Polygon Name="p1" Points="40,40 80,40 60,50" Fill="Lime" StrokeThickness="1.414"/>
    <Polygon Name="p2" Points="50,50 110,50 80,60" Fill="Aqua" StrokeThickness="1.732"/>
    <Polygon Name="p3" Points="30.981,53.66 82.942,63.66 41.962,67.321" Fill="Purple" StrokeThickness="1.732"/>
</Canvas>

Nice and clean!

No more transformations. Instead the values of the shapes were transformed to give us clean and simple object model.

Note that when the Canvas defines the clipping area, than even when FlattenHierarhy is set to true, this Canvas is preserved. This way the end results are still the same as with having the whole hierarchy. 

In the same fashion, the TransformShapes could preserve some RenderTransforms. This happens when it is not possible to preserve the object with only transform the object’s values – for example if Ellipse or Rectangle is rotated with RenderTransforms,  then we cannot preserve this rotation without using transformation (with Ellipse and Rectangle we can only change the position and size).

I am sure that those new features are great for anyone that wants to use vector assets instead of bitmap. I think that using vector assets is the future. They have many advantages over bitmaps. For example they are DPI independent and can be scaled up and down without any loss. They usually take less space on disk. They can be simply manipulated – for example if you want that one icon changes color when the mouse is over it, this can be done with simply changing the Stroke or Fill color. With bitmap you need to use provide the bitmaps in all possible colors.

Therefore I am already working on a new application that will allow users to simply create ResourceDictionaries with many vector objects created from svg or metafiles. The application will allow the user to optimize and transform the objects before they are added to ResourceDictionary. For example it will be possible to create vector assets that will all have the same size and the same padding regardless from which source they are created. And what is more, the application will be available with full source code.

At the end of this post I would like to remind you, that the XAML that is created with our converter applications (ViewerSvg and Paste2Xaml) are not meant only for WPF. They can be also used for Silverlight and also for Windows Phone and Windows Store apps.

In this blog post I will show you how easy is to show Kinect skeleton as a 3D model.

To jump start into 3D programming we will be using WPF and Ab3d.PowerToys library. The library will help us with providing the standard 3D models that will be used to display the skeleton and cameras that can be easily controller by the user.

The image above shows us that the skeleton is created from yellow spheres that represent the joints and bi-pyramids are used to connect the joints together. To make the sample more interesting the skeleton has a Darth Wader’s head. Below the skeleton model a 3D wire grid is shown. It represents the floor.

In the lower right corner three different types of arrow buttons are shown. They can be used to control the camera – move, rotate and zoom in / out the camera. They are created by simply adding CameraControlPanel to the Window. Camera can be controlled also without using buttons. The MouseCameraController lets you rotate the camera with holding down the left mouse button, zoom in and out with mouse wheel and move the camera with holding control key and left mouse button. The MouseCameraController also provides easy way to specify different combinations of keys and mouse buttons for rotate and move actions.

Before diving into the code that shows the 3D model, let’s quickly look how we get the required 3D data from Kinect. Kinect SKD can provide real time skeleton and depth data. To make the sample work without having an actual Kinect device and an actual actor in front of the sensor, the Kinect data was saved into files with using Kinect Toolkit (an open source helper library). This way we can replay the recorded data any time we want.

For each recorded frame we get data for all recorded skeleton models. For each skeleton we get collection of joints and BoneOrientation objects. With them it is quite easy to get the actual 3D positions of the joints and the transformations (rotations and translations) applied on each of the joint. Once we have that data we can start on code that will show our 3D model.

In our sample we can show the 3D model in 4 different ways.  User can change that by selecting different value in the “Skeleton display mode” ComboBox. The following are the available options:

• Lines,
• Pyramids,
• BiPyramids,
• TransformedBiPyramids

Using 3D lines

The simplest solution to show 3D model is to show it with 3D lines. Actually, if we would be using only standard WPF 3D objects without Ab3d.PowerToys, this would be the hardest solution to implement. The problem is that WPF 3D does not have native support for 3D lines and therefore they need to be created manually by defining the triangles that would show 3D line. Luckily Ab3d.PowerToys library adds that support to WPF. With the Ab3d.PowerToys library the code to add 3D line between two joints is the following:

AddSkeletonLines(Point3D startPoint, Point3D endPoint)
{
    var lineVisual3D = new LineVisual3D()
    {
        StartPosition = startPoint,
        EndPosition = endPoint,
        LineColor = Colors.Green,
        LineThickness = _skeletonThickness * 100.0
    };

    Placeholder3D.Children.Add(lineVisual3D);
}

The following image shows how the skeleton is shown when using 3D lines:

Note that it is very easy to define the line thickness.

Using pyramids

Using 3D lines already gives you some 3D feeling of the model, especially because you can rotate the camera around the model and observe it from any angle.

To give the model a better 3D look, we will use 3D pyramids to connect joints.

Because we need to orient the pyramid model based on start and end position, we cannot use standard pyramid model from Ab3d.PowerToys library. Instead we need to use a low level object - DirectedPyramidMesh3D. It can create a MeshGeometry3D that represent a pyramid oriented in such a way that the pyramid’s center is defined by start point and the pyramid’s top is define by end position.

The following screenshot shows the skeleton displayed with pyramid:

Using bi-pyramids

Pyramids already gave us a better 3D representation that is more similar to actual 3D person model. But this can be further improved with using bi-pyramids. Bi-pyramids are objects that are created with combining two pyramids together.

We could easily create bi-pyramid with using two objects created with DirectedPyramidMesh3D. All we needed to do is to use the end position of the first directed pyramid as the start position of the second directed pyramid.

But to demonstrate some advanced features of the Ab3d.PowerToys we will create bi-pyramids with using lathe 3D objects. Lathe 3D object is an object that is defined by a 2D shape and start and end position. The 2D shape is than rotated around an axis defined by start and end position. This creates a 3D object – typical lathe objects are glasses and vases.

The following image shows a screenshot from samples that come with Ab3d.PowerToys library and show how a lathe 3D object was created (the 2D shape is shown on the right with red line):

The 2D shape used to define the lathe object is defined by LatheSections. Bi-pyramid is actually one of the simplest lathe objects possible – it requires only one section definition. This section defines how wide the bi-pyramid is.

After implementing the creation of bi-pyramids our skeleton looks like the first image in this blog.

From the list of display mode options you can see that it is also possible to show the skeleton as TransformedBiPyramids. This option shows the same skeleton as with bi-pyramids, but instead of using start and end position to define the object orientation, this time the transformation of the joint is used to rotate the bi-pyramid. This option provides a possible optimization. It can be achieved by creating the bi-pyramid model only once and then apply different transformation to it.

Similar optimization was used for showing joint spheres. Here we create only one instance of sphere GeometryModel3D and then use different transformations to position and scale the individual joint models around the skeleton.

The only thing yet to describe is how the head was created. We used a Darth Wader image and use it as a texture shown on a 3D plane. Once we have the position of the head and a head transformation, it is super easy to add Darth Wader head to the skeleton:

// Add head - show image for head
var headPosition = skeleton.Joints[JointType.Head].Position.ToPoint3D(_skeletonScale) + offset;

var headPlane = new PlaneVisual3D()
{
    CenterPosition = headPosition,
    Material = _headMaterial,
    BackMaterial = _headMaterial,
    HeightDirection = new Vector3D(0, 1, 0),
    Normal = new Vector3D(0, 0, 1),
    Size = new Size(_skeletonScale * 0.3, _skeletonScale * 0.3),
    Transform = skeleton.BoneOrientations[JointType.Head].AbsoluteRotation.ToRotateTransform3D(headPosition)
};

Placeholder3D.Children.Add(headPlane);

Adding special model for head finishes our 3D visualization of Kinect skeleton.

As you have seen, having the right tools makes the job very easy. And Ab3d.PowerToys library contains the ultimate collection of tools to add 3D content to your .Net application very easy. More about the library can be read from Ab3d.PowerToys web page.

The sample with full source code is available with Ab3d.PowerToys library. The trial version of the library can be downloaded from downloads page.

I am very happy to announce that a new version of Ab3d.PowerToys is available.

The biggest new feature of the new version is a new WireframeVisual3D class. It can be used to show a 3D model with wireframe rendering. You just need to set a 3D model to OriginalModel property (or set the model as content in XAML) and then decide how you want to show the model and set the WireframeType property accordingly – you can show the model as wireframe only, as wireframe with solid model (can be also used to create wireframe with hidden lines) or as solid model only. What is more, the wireframe color can be fixed (for example all lines black) or the color of the lines can be determined by the color of the model’s material. The same choice can be made for solid model – it can be shown with original color or with fixed color.

The following two screenshots show two sample usages (screenshots from new samples that come with the library):

<visuals:WireframeVisual3D WireframeType="WireframeWithSingleColorSolidModel"
 LineThickness="2" UseModelColor="True" SolidModelColor="Black" > 
     <GeometryModel3D> …

<visuals:WireframeVisual3D WireframeType="WireframeWithOriginalSolidModel"
 LineThickness="2" LineColor="Black" UseModelColor="False" >
     <GeometryModel3D> …

What is more, the code in the new DXEngine (DirectX rendering engine that is being developed by AB4D) is specially optimized to render the wireframe and solid model in the most efficient way.

The new Ab3d.PowerToys also uses an improved algorithm for triangulation. Triangulation is used to create a 3D model (define triangles) from a 2D polygon. The code in the previous version used another version of algorithm that had some problems with some of the polygons. The new code is much better and should handle all possible polygons. But it does not support polygons with holes.

There is also a new DirectedPyramidMesh3D object that can be used to create a pyramid that is facing its peat to the specified direction.

And as always there are also some other improvements and bug fixes. The following is a list of all the changes:

• Added WireframeVisual3D to simplify showing models with wireframe.
• Improved triangulator - before in some cases a wrongly triangulated object was returned or an "Improperly formed polygon" error was thrown.
• Added DirectedPyramidMesh3D to create a pyramid object that is oriented in a specified direction.
• Added Ab3d.Utilities.ModelUtils class that contains ChangeMaterial (change material on all child Model3D objects) and CopyModel (copy child Model3D objects) methods.
• Improved 3D Lathe creator - now it is allowed to specify only one segment when start and end positions are closed.
• Added GetPerpendicularVectors to MathUtil - calculate two vectors that are perpendicular to the input vector.
• Fixed calling PreviewCameraChanged and CameraChanged events when CameraWidth is changed in Orthographic camera.
• Fixed Point3DTo2D and Rect3DTo2D if size of Viewport3D is changed or if CameraWidth in Orthographic camera is changed.
• Added Dump extension methods that can dump (write to Debug console) various WPF 3D objects (Matrix3D, Model3D, Geometry3D, Transform3D, Material, Rect3D). This is very useful to get detaled information in Visual Studio Immediate Window - Window – for example you can write "Ab3d.Utilities.Dumper.Dump(myModel3D)".
• Added GetWorldToViewportMatrix method to BaseCamera.
• Fixed Creating wireframe with WireframeFactory when model groups have transformations.
• Cleaned the code to remove compiler warings when compiling source code.
• Added overrides to CreateWireframe with additional removedDuplicates parameter - when the parameter is true this can significanlty increase time to create wireframe model, but creates less lines because duplicate lines are removed (this was used in the previous version). Not it is possible to set removedDuplicates to false to greatly reduce the initial creation time but end up with having more 3D lines. This can be user when rendering the lines with DXEngine were rendering lines is super-fast compared to WPF 3D where it is very slow.
• Added Microsoft Kinect 3D player sample.

The list of changes in the Ab3d.PowerToys library ends here. But this is not everything that is new is the new version. There is also a brand new sample project. It was developed with help of a customer that wanted to show the 3D skeleton that was captured with Microsoft Kinect with a 3D model where the user can rotate the camera around the model.

The sample showed again that when having the right tools (Ab3d.PowerToys in this case), it is very easy to create an application that show 3D models and allow user to rotate and move the camera around. You can check the sample with downloading the latest version of the library (note: you will need to install Microsoft Kinect SDK). I will write a separate blog post with more details about that sample in the following days. For now here is a screenshot of the sample:

Let’s start with the good news:
All products on AB4D.com are 20% off until the end of December 2013.

This makes December the best time to buy new products or renew the license. Even if your license is not close to expiration yet, it is worth buying a renewal now and get additional year of free upgrades and priority support.

Now to the other news:
After 1st January 2014 the following licensing changes will happen:

• price for Ab3d.PowerToys will increase,
• reader libraries and viewers will be sold only as pro licenses (no more basic licenses).

The Ab3d.PowerToys library has been improved many times in the last years and now has really a lot of features. With the latest version the library also got obj file reader so it is possible to import 3D models from obj files. This means that in most cases you do not need the Ab3d.Reader3ds library any more (see the previous blog post for the differences between 3ds and obj file to check if you still need 3ds files).

The new prices for Ab3d.PowerToys will be:

• Single developer license price: $399
• Team developer license price: $799
• Site developer license price: $1599
• Price for source code will remain the same at $490

Another change related to this price increase is that it will not be possible to buy both Ab3d.Reader3ds and Ab3d.PowerToys for the price of Ab3d.Reader3ds + 1 USD (getting Ab3d.PowerToys for 1 USD). After 1st January you will still be able to get both libraries with discounted price, but this time the discount will be 30% of the total price.

Another licensing change is that from 1st January 2014 on only Pro version of reader libraries and viewers will be sold. This means that it will not be possible to buy basic version of Viewer3ds or basic version of Reader3ds. The reason for that is that very little basic licenses were sold and that this concept added quite some confusion when potential customer tried to decide which version to buy. So from 1st January on instead of 4 types of licenses only 2 types will be available: one with viewer only (Viewer3ds, ViewerSvg or Paste2Xaml) and the other with library license (Ab3d.Reader3ds with Viewer3ds, Ab2d.ReaderSvg with ViewerSvg, Ab2d.ReaderWmf with Past2Xaml).

So to conclude in a better tone, I would just like to say that the Ab3d.PowerToys price increase is just another very good reason to buy the license renewal now.

Ab3d.PowerToys library continues to get great new features. The new version gets ability to read 3D models from obj files. This adds a great new value to the Ab3d.PowerToys library because now it is possible to import 3D objects directly with the library.
Obj file format is very common file format to store 3D models. The model data is written in simple text format.

The following screenshot shows a 3D ship model that was read with the new Ab3d.ReaderObj library:


Because now it is possible to import 3D models only with Ab3d.PowerToys library, the question arises if we still need Ab3d.Reader3ds library to read 3ds files. The following are the main differences between obj and 3ds file format:
obj is a text file; 3ds is a binary file,

• 3ds file can define hierarchy of 3D objects with object transformations; obj file does not support hierarchies and transformation,
• obj file does not support animations,
• 3ds file is not capable of storing texture file names that exceed the 8.3 format; file names in obj file can be in any length.

The main difference is that animations and object’s hierarchies are supported only by 3ds files. For example if you need to create 3D objects similar to that used in Robotarm sample where rotating one part of the robot also rotates all child objects, you will need to use 3ds files to store the hierarchies.
Anyway obj files are still very common to store simple 3D models.

I would also like to mention that the code that is used to read obj files is highly optimized to parse the values from text files very fast. Also when common methods like Split and Regex are used to parse large text files in .Net with the memory usage can be very high – many string instances can be created. The code in ReaderObj class has been optimized also in regard to memory usage to minimize the creation of many string instances.

The version also has the following new features and bug fixes:

• Fixed performance of LinesUpdater when the camera or other property is not changed (before lines were recreated every time, now only when they need to),
• Added additional override of Dumper.Dump with Model3D as paramter to write Model3D info to Visual Studio output or immediate window.

The new version also comes with a new very interesting arrows sample that animate the arrows in a very nice way. The following screenshot show the sample:


You can also see the new sample in a new video that also shows some other samples.

I am really happy to announce that the v4.0 of Ab3d.PowerToys is now available. It brings tons of new features and updates. The most important new features are:
-    Added polygon triangulation, creating extruded and lathe 3D objects,
-    Improved EventManager3D for even simpler usage of mouse events on 3D objects,
-    Added support for upcoming Ab3d.DXEngine library that will be able to render WPF 3D graphics with full DirectX 11 hardware acceleration.
-    Many new very interesting samples that show how easy is to create amazing 3D applications.

Polygon triangulation is a technique that converts a 2D polygon into triangles that can be used to define a 3D object. This makes it easy to create extruded objects – object that are created with extruding a 2D shape into a 3D world. The following image shows a screenshot from a sample that demonstrates those two techniques. The 2D shape is defined on the left side. It is the base for the 3D object that is shown on the right.

Lathe 3D objects are objects that are created be rotating the shape around an axis. The following image screenshot is taken from the sample that demonstrates how to create lathe objects. On the rights side the shape is defined by drawing the red lines. It is then rotated around up axis and the 3D object shown on the left is created. As seen on the 3D object it is also possible to define which edges are hard and which are soft.

Because we can now easily create lathe objects, we can also easily create 3D arrows. They can be created with the new ArrowMesh3D, ArrowVisual3D or ArrowUIElement3D objects. The following image shows many 3D arrows with different colors (screenshot from the new sample - still under development).

As mentioned before, another big improvement in this library was made with EventManager3D. EventManager3D can be used to simply subscribe to 3D objects just as they were normal FrameworkElements. For example the following code subscribes to some mouse events:

var eventSource3D = new Ab3d.Utilities.VisualEventSource3D(MyBoxVisual3D);
eventSource3D.MouseEnter += OnBoxMouseEnter;
eventSource3D.MouseLeave += OnBoxMouseLeave;
eventSource3D.MouseClick += OnBoxMouseClick;

var eventManager = new Ab3d.Utilities.EventManager3D(MyViewport3D);
eventManager.RegisterEventSource3D(eventSource3D);

The new version of Ab3d.PowerToys adds the following additional functionality to the EventManager3D:

• Added RegisterExcludedVisual3D and RemoveExcludedVisual3D methods to EventManager3D – used to define Visual3D objects that are excluded from hit testing.
• Added CustomEventsSourceElement property to EventManager3D - it can be set to any FrameworkElement that will be used as source of mouse events instead of TargetViewport3D.
• Added MouseMove event to EventManager3D.
• Added FinalPointHit to all EventArgs used in EventManager3D event handlers - it gets the transformed 3D point that was hit by the mouse (if Visual3D uses Transformation, than HitPoint will be wrong, but FinalHitPoint will be transformed).

Ab3d.PowerToys can help you in all stages of development – also during debugging. In the Ab3d.Utilities.Dumper there are many methods that can be used to get nicely formatted info about MeshGeometry3D, Model3D, Transform3D, Material or Matrix. With the new version it is now possible to specify the format string used to format the values (this allows control of the number of displayed decimals). The new version also adds two new methods to Dumper class: DumpMeshInitializationCode and GetMeshInitializationCode. They can be used to generate the complete c# source code that can be used to create the MeshGeometry3D with all the Position, TriangleIndices, etc.

This is not all. The following are the additional new features and fixes:

• Added CreateMouseRay3D to BaseCamera - it can be use used to calculate the 3D ray that goes from the mouse position into the 3D scene.
• Improved Refresh method in LinesUpdater - calling this method now forces to redraw all visible lines.
• Added MaxLineArrowLength and LineArrowAngle to LinesUpdater to better control the size and shape of the arrows on 3D lines.
• Fixed LineWithTextVisual3D when it was created in code behind and the properties were set without using BeginInit and EndInit methods.
• Fixed recreating the content of 3D objects derived from Visual3D (if initially IsVisible was set to false and was then set to true the object was not shown under some circumstances).
• Added many possibilities to change the CameraAxisPanel with overriding CreateAxisVisual, SetAxisLength, SetAxisColors or EnsureAxisTextBlocks (the later also existed before)
• Improved performance of Box3D geometry mesh creation when X, Y and Z segments count is 1 (simple box with 2 triangles for one plane) - the mesh is now created 10 times faster.
• Moved initialization of RotationCursor in MouseCameaController from constructor to OnLoad event handler - this prevented calling virtual method in constructor.

Besides new features in Ab3d.PowerToys there are also some new very interesting samples that demonstrate the use of the library. Extrude and Lathe samples were already mentioned. I would also like to show the screenshot of the new “Distance measurement” sample:

The sample uses HeightMap (also part of Ab3d.PowerToys), 3D lines and custom hit testing (uses CreateMouseRay3D method on camera) to show the distance between two points in 3D world.

Another interesting new sample is Objects inspector. It can display many information about the selected object – shows individual triangles with TriangleIndice index, normals, all positions, XAML text and other data. The following is the screenshot of the sample:

Lastly, the new version of Ab3d.PowerToys adds support for the upcoming Ab3d.DXEngine.

The Ab3d.DXEngine is a brand new 3D rendering engine that can render WPF 3D graphics in hardware accelerated DirectX 11. This means a huge performance boost and what is more it allows many customizations and tweaks of the displayed graphics. Do not get me wrong – I still think that WPF 3D is great for business applications that need 3D graphics. But it has its limits. When it comes to very complex 3D objects, the existing rendering engine based on DirectX 9 just cannot use the full power of the GPU. Another limitation is that the current WPF 3D engine is a closed box – you cannot extend it in any way. If you would like to use some other shading technique, this is not possible. Even simple task as showing 3D lines is kind of a hack in WPF 3D. What is more, the new engine can be used with just very minimal change in the code.

The new engine will be soon ready for the first alpha version. But before going public with the new engine, I would like to test it with some of our partners. I already have a few interested Ab3d.PowerToys customers that would like to try the new engine. If you are interested in that, please contact me to our email or with using Feedback page.