Explore nuestros productos
Aspose.3D for .NET 17,8 Notas de la versión
Otras mejoras y cambios
Clave | Resumen | Categoría |
---|---|---|
THREEDNET-279 | Renderizar la escena en un mapa de cubos con 6 caras. | Nueva característica |
THREEDNET-280 | Añadir post-procesamiento de proyección equirectangular. | Nueva característica |
THREEDNET-281 | Render mapa del cubo a ojo de pez. | Nueva característica |
THREEDNET-276 | Conversión incorrecta de OBJ a GLTF y GLB. | Error |
Público API y cambios incompatibles al revés
Consulte la lista de cualquier cambio realizado al público API, como miembros agregados, renombrados, eliminados o obsoletados, así como cualquier cambio no compatible con versiones anteriores realizado a Aspose.3D for .NET. Si tiene inquietudes sobre cualquier cambio enumerado, por favor recújelo en elAspose.3D foro de apoyo.
Métodos marcados como obsoletos y serán retirados a finales de este año 2017
Antes del 17,8, todas las unidades de textura (utilizadas por el renderizador) están representadas por la interfaz ITextureUnit, pero este diseño no funciona bien para el mapa del cubo y la textura 3D en el futuro (aún no se ha implementado), por lo que todos estos métodos están marcados como obsoletos, Para asegurarse de que el código no romperá el compilador, los desarrolladores deben usar los métodos con el mismo nombre de ITexture1D/ITexture2D/ITextureCubemap.
C#
interface ITextureUnit
{
void Load(TextureData bitmap);
void Save(string path, ImageFormat format);
void Save(Bitmap bitmap);
Bitmap ToBitmap();
}
Añadido nuevo tipo de enum Aspose.ThreeD.Render.CubeFace
Este tipo funciona con Aspose.ThreeD.Render.CubeFaceData<>Y Aspose.ThreeD.Render.ITextureCubemap para acceder a los datos según la cara del 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
}
Añadido nueva clase Aspose.ThreeD.Render.CubeFaceData<>
Esta clase es una clase genérica para describir los datos de cada cara de cubemap, como el nombre de archivo o el mapa de bits.
Añadido nueva clase 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'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);
}
Añadido nueva clase Aspose.ThreeD.Render.ITexture1D
Esta interfaz se utiliza para representar un objeto de textura 1D
Añadido nueva clase Aspose.ThreeD.Render.ITexture2D
Esta interfaz se utiliza para representar un objeto de textura 2D
Se han añadido nuevos métodos a la clase 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)
Se ha añadido un nuevo método en la clase Aspose.ThreeD.Render.Renderer:
En las versiones anteriores, el procesamiento posterior solo se puede utilizar proporcionando una cadena de efectos de procesamiento posterior al Aspose.ThreeD. ¡Render! ¡Renderer! PostProcessings, ahora con este método el usuario puede ejecutar manualmente el procedimiento de procesamiento posterior, esto es útil en la nueva THREEDNET-280 de características y THREEDNET-281, significa que puede representar un cubemap en una imagen panorámica o una imagen de ojo de pez.
C#
public void Execute(Aspose.ThreeD.Render.PostProcessing postProcessing, Aspose.ThreeD.Render.IRenderTarget result)
Generar una imagen panorámica en 3D Escena
Los desarrolladores pueden usar herramientas de terceros como three.js/Pano2VR para visualizar el resultado.
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'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("panorama.png", ImageFormat.Png);
}
Generar efecto de lente de ojo de pez en la escena 3D
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'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);
}
Añadido métodos para struct Aspose.ThreeD.Utilities.FVector3:
Estas son las dos operaciones primitivas de los vectores.
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)
Ejemplos de uso
Compruebe la lista de temas de ayuda agregados o actualizados en los documentos wiki Aspose.3D: