Aspose.3D 17.8.0

Aspose.3D for .NET

Aspose.3D is a class library for working with 3D files. It allows developers to create/manipulate/render 3D scene and work with FBX,STL,OBJ,3DS,U3D,DAE,PDF,DRC,GLTF files. It allows you to open files and manipulate the elements in the 3D scene, from line,mesh,nurbs curve, to more complex elements animation, and then export to FBX ASCII, FBX binary, STL ASCII, STL binary, Collada, Wavefront .obj, 3DS, PDF formats, glTF, glTF2, Google Draco.

Install-Package Aspose.3D -Version 17.8.0
dotnet add package Aspose.3D --version 17.8.0
paket add Aspose.3D --version 17.8.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.

Release Notes

This page contains release notes for Aspose.3D for .NET 17.8.

                   
   
Other Improvements and Changes
Key Summary Category

THREEDNET-279 Render scene into a cube map with 6 faces.
New feature


THREEDNET-280 Add post-processing of equirectangular projection. New feature

THREEDNET-281 Render cube map to fisheye. New feature

THREEDNET-276 Incorrect conversion of OBJ to GLTF and GLB. Bug

Public API and Backwards Incompatible Changes
See the list of any changes made to the public API such as added, renamed, removed or deprecated members as well as any non-backward compatible change made to Aspose.3D for .NET. If you have concerns about any change listed, please raise it on the Aspose.3D support forum.
Methods marked as obsoleted and will be removed in the end of this year 2017

Before the 17.8 all texture units (used by the renderer) are represented by the interface ITextureUnit but this design is not working well for the cube map and 3D texture in the future (not implemented yet), so these methods are all marked as obsolete, to make sure that the code will not break the compiler, developers should use the methods with same name from ITexture1D/ITexture2D/ITextureCubemap.
C#

interface ITextureUnit
{
   void Load(TextureData bitmap);
   void Save(string path, ImageFormat format);
   void Save(Bitmap bitmap);
   Bitmap ToBitmap();



Added new enum type Aspose.ThreeD.Render.CubeFace

This type works with Aspose.ThreeD.Render.CubeFaceData<> and Aspose.ThreeD.Render.ITextureCubemap to access data as per the face of cubemap.
C#

/// <summary>
/// Each face of the cube map texture
/// </summary>
public enum CubeFace
{
   /// <summary>
   /// The +X face
   /// </summary>
   PositiveX,
   /// <summary>
   /// The -X face
   /// </summary>
   NegativeX,
   /// <summary>
   /// The +Y face
   /// </summary>
   PositiveY,
   /// <summary>
   /// The -Y face
   /// </summary>
   NegativeY,
   /// <summary>
   /// The +Z face
   /// </summary>
   PositiveZ,
   /// <summary>
   /// The -Z face
   /// </summary>
   NegativeZ
}


Added new class Aspose.ThreeD.Render.CubeFaceData<>
This class is a generic class to describe per cubemap face's data like file name or bitmap.
Added new class Aspose.ThreeD.Render.ITextureCubemap
C#

/// <summary>
/// Cube map texture
/// </summary>
public interface ITextureCubemap : ITextureUnit
{
   /// <summary>
   /// Load texture content from specified files
   /// </summary>
   /// <param name="fileNames"></param>
   void Load(CubeFaceData<string> fileNames);
   /// <summary>
   /// Load texture content from specified <see cref="TextureData"/>
   /// </summary>
   /// <param name="data"></param>
   void Load(CubeFaceData<TextureData> data);
   /// <summary>
   /// Load the data into specified face
   /// </summary>
   /// <param name="face"></param>
   /// <param name="data"></param>
   void Load(CubeFace face, TextureData data);
   /// <summary>
   /// Save the cube&#39;s sides texture content to external files.
   /// </summary>
   /// <param name="path">File names to save.</param>
   /// <param name="format">Image format</param>
   void Save(CubeFaceData<string> path, ImageFormat format);
   /// <summary>
   /// Save the texture content to memory.
   /// </summary>
   /// <param name="bitmap">Result bitmap to save.</param>
   void Save(CubeFaceData<Bitmap> bitmap);

   /// <summary>
   /// Save the specified side to memory
   /// </summary>
   /// <param name="side"></param>
   /// <param name="bitmap"></param>
   void Save(CubeFace side, Bitmap bitmap);

   /// <summary>
   /// Convert the texture unit to <see cref="Bitmap"/> instance
   /// </summary>
   Bitmap ToBitmap(CubeFace side);    
}

C#

//The model used in this sample can be found at https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/1.0/VC/glTF-Binary
string path = @"D:\Projects\glTF-Sample-Models\1.0\VC\glTF-Binary\VC.glb";
//load the scene
Scene scene = new Scene(path);
//create a camera for capturing the cube map
Camera cam = new Camera(ProjectionType.Perspective)
{
   NearPlane = 0.1,
   FarPlane = 200,
   RotationMode = RotationMode.FixedDirection
};
scene.RootNode.CreateChildNode(cam).Transform.Translation = new Vector3(5, 6, 0);
//create two lights to illuminate the scene
scene.RootNode.CreateChildNode(new Light() {LightType = LightType.Point}).Transform.Translation = new Vector3(-10, 7, -10);
scene.RootNode.CreateChildNode(new Light()
{
   Color = new Vector3(Color.CadetBlue)
}).Transform.Translation = new Vector3(49, 0, 49);

//create a renderer
using (var renderer = Renderer.CreateRenderer())
{
   //Create a cube map render target with depth texture, depth is required when rendering a scene.
   IRenderTexture rt = renderer.RenderFactory.CreateCubeRenderTexture(new RenderParameters(false), 512, 512);
   //a viewport is required on the render target
   rt.CreateViewport(cam, RelativeRectangle.FromScale(0, 0, 1, 1));
   renderer.Render(rt);
   //now lets get the cubemap texture
   ITextureCubemap cubemap = rt.Targets[0] as ITextureCubemap;
   //we can directly save each face to disk by specifing the file name
   CubeFaceData<string> fileNames = new CubeFaceData<string>()
   {
       Right = "right.png",
       Left = "left.png",
       Back = "back.png",
       Front = "front.png",
       Bottom = "bottom.png",
       Top = "top.png"
   };
   //and call Save method
   cubemap.Save(fileNames, ImageFormat.Png);
   //or we just need to use the render result in memory, we can save it to CubeFaceData<Bitmap>
   CubeFaceData<Bitmap> bitmaps = new CubeFaceData<Bitmap>();
   cubemap.Save(bitmaps);
   bitmaps.Back.Save("back.bmp", ImageFormat.Bmp);
}


Added new class Aspose.ThreeD.Render.ITexture1D
This interface is used to represent an 1D texture object
Added new class Aspose.ThreeD.Render.ITexture2D
This interface is used to represent a 2D texture object
Added new methods to class Aspose.ThreeD.Render.RenderFactory:C#

// this is an overloaded version for method IRenderTexture CreateRenderTexture(Aspose.ThreeD.Render.RenderParameters parameters, int targets, int width, int height) with targets to 1
public Aspose.ThreeD.Render.IRenderTexture CreteRenderTexture(Aspose.ThreeD.Render.RenderParameters parameters, int width, int height)
//Create a render target that will render the scene into a cube map
public Aspose.ThreeD.Render.IRenderTexture CreateCubeRenderTexture(Aspose.ThreeD.Render.RenderParameters parameters, int width, int height)
// allow user to create ITexture1D/ITexture2D/ITextureCubemap manually
public Aspose.ThreeD.Render.ITextureUnit CreateTextureUnit(Aspose.ThreeD.Render.TextureType textureType)

Added new method in class Aspose.ThreeD.Render.Renderer:

In the previous versions the post processing can only be used by providing a chain of post processing effects to Aspose.ThreeD.Render.Renderer.PostProcessings, now with this method user can manually execute the post processing procedure, this is useful in the new feature THREEDNET-280 and THREEDNET-281, means you can render a cubemap into a panaroma image or fisheye image.
C#

public void Execute(Aspose.ThreeD.Render.PostProcessing postProcessing, Aspose.ThreeD.Render.IRenderTarget result)


 

 

 

Generate a Panaroma Image in 3D Scene

Developers can use 3rd party tools like three.js/Pano2VR to visualize the result.
C#

//The model used in this sample can be found at https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/1.0/VC/glTF-Binary
string path = @"D:\Projects\glTF-Sample-Models\1.0\VC\glTF-Binary\VC.glb";
//load the scene
Scene scene = new Scene(path);
//create a camera for capturing the cube map
Camera cam = new Camera(ProjectionType.Perspective)
{
   NearPlane = 0.1,
   FarPlane = 200,
   RotationMode = RotationMode.FixedDirection
};
scene.RootNode.CreateChildNode(cam).Transform.Translation = new Vector3(5, 6, 0);

//create two lights to illuminate the scene
scene.RootNode.CreateChildNode(new Light() {LightType = LightType.Point}).Transform.Translation = new Vector3(-10, 7, -10);
scene.RootNode.CreateChildNode(new Light()
{
   Color = new Vector3(Color.CadetBlue)
}).Transform.Translation = new Vector3(49, 0, 49);
//create a renderer
using (var renderer = Renderer.CreateRenderer())
{
   //Create a cube map render target with depth texture, depth is required when rendering a scene.
   IRenderTexture rt = renderer.RenderFactory.CreateCubeRenderTexture(new RenderParameters(false), 512, 512);
   //create a 2D texture render target with no depth texture used for image processing
   IRenderTexture final = renderer.RenderFactory.CreateRenderTexture(new RenderParameters(false, 32, 0, 0), 1024 * 3 , 1024);

   //a viewport is required on the render target
   rt.CreateViewport(cam, RelativeRectangle.FromScale(0, 0, 1, 1));
   renderer.Render(rt);

   //execute the equirectangular projection post-processing with the previous rendered cube map as input
   PostProcessing equirectangular = renderer.GetPostProcessing("equirectangular");
   //Specify the cube map rendered from the scene as this post processing&#39;s input
   equirectangular.Input = rt.Targets[0];
   //Execute the post processing effect and save the result to render target final
   renderer.Execute(equirectangular, final);
   //save the texture into disk
   ((ITexture2D)final.Targets[0]).Save("panaroma.png", ImageFormat.Png);
}


 

 

 


Generate Fisheye Lens Effect in 3D Scene
C#

//The model used in this sample can be found at https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/1.0/VC/glTF-Binary
string path = @"D:\Projects\glTF-Sample-Models\1.0\VC\glTF-Binary\VC.glb";
//load the scene
Scene scene = new Scene(path);
//create a camera for capturing the cube map
Camera cam = new Camera(ProjectionType.Perspective)
{
   NearPlane = 0.1,
   FarPlane = 200,
   RotationMode = RotationMode.FixedDirection
};
scene.RootNode.CreateChildNode(cam).Transform.Translation = new Vector3(5, 6, 0);

//create two lights to illuminate the scene
scene.RootNode.CreateChildNode(new Light() {LightType = LightType.Point}).Transform.Translation = new Vector3(-10, 7, -10);
scene.RootNode.CreateChildNode(new Light()
{
   Color = new Vector3(Color.CadetBlue)
}).Transform.Translation = new Vector3(49, 0, 49);

//create a renderer
using (var renderer = Renderer.CreateRenderer())
{
   //Create a cube map render target with depth texture, depth is required when rendering a scene.
   IRenderTexture rt = renderer.RenderFactory.CreateCubeRenderTexture(new RenderParameters(false), 512, 512);
   //create a 2D texture render target with no depth texture used for image processing
   IRenderTexture final = renderer.RenderFactory.CreateRenderTexture(new RenderParameters(false, 32, 0, 0), 1024, 1024);

   //a viewport is required on the render target
   rt.CreateViewport(cam, RelativeRectangle.FromScale(0, 0, 1, 1));
   renderer.Render(rt);

   //execute the fisheye projection post-processing with the previous rendered cube map as input
   //the fisheye can have field of view more than 180 degree, so a cube map with all direction is required.
   PostProcessing fisheye = renderer.GetPostProcessing("fisheye");
   // we can change the fov to 360 instead of the default value 180.
   fisheye.FindProperty("fov").Value = 360.0;
   //Specify the cube map rendered from the scene as this post processing&#39;s input
   fisheye.Input = rt.Targets[0];
   //Execute the post processing effect and save the result to render target final
   renderer.Execute(fisheye, final);
   //save the texture into disk
   ((ITexture2D)final.Targets[0]).Save("fisheye.png", ImageFormat.Png);
}


Added methods to struct Aspose.ThreeD.Utilities.FVector3:


These are the two primitive operations of vectors.
C#

//Calculate the normalized vector of the FVector3, equivalent implementation of Vector3.Normalize
public Aspose.ThreeD.Utilities.FVector3 Normalize()
//Calculate the cross product of two FVector3, equivalent implementation of Vector3.Cross
public Aspose.ThreeD.Utilities.FVector3 Cross(Aspose.ThreeD.Utilities.FVector3 rhs)





Usage Examples

Please check the list of help topics added or updated in the Aspose.3D Wiki docs:

   
       

       
https://docs.aspose.com/display/3dnet/Aspose.3D+for+.NET+17.8+Release+Notes

Dependencies

This package has no dependencies.

Version History

Version Downloads Last updated
17.11.0 41 11/6/2017
17.10.0 79 10/10/2017
17.9.0 125 9/7/2017
17.8.0 (current version) 102 8/8/2017
17.7.0 109 7/17/2017
17.6.0 691 6/5/2017
17.5.0 134 5/8/2017
17.4.0 155 4/5/2017
17.3.0 154 3/6/2017
17.2.0 130 2/15/2017
17.1.0 201 1/5/2017
16.12.0 159 12/4/2016
16.11.0 184 11/1/2016
16.9.0 152 9/29/2016
2.1.0 133 8/30/2016
2.0.0 143 8/2/2016
1.7.0 151 6/29/2016
1.6.1 315 5/26/2016
1.5.0 152 4/27/2016
1.4.0 181 4/1/2016
1.3.0 182 2/23/2016
1.2.0 263 12/18/2015
1.1.0 169 11/27/2015
1.0.0 202 10/26/2015