Explore nuestros productos
Aspose.3D for .NET 17,9 Notas de la versión
Otras mejoras y cambios
Clave | Resumen | Categoría |
---|---|---|
THREEDNET-286 | Agregue soporte para identificar de forma única las mallas de FBX | Nueva característica |
THREEDNET-288 | Agregar soporte a la escena de renderizado en sombreadores completamente personalizados | Nueva característica |
THREEDNET-284 | Mejorar el consumo de memoria al escribir un archivo grande FBX | Mejora |
THREEDNET-293 | Exportación incorrecta OBJ con textura a GLTF y GLB | Error |
THREEDNET-290 | Animar propiedades rotación (Euler) y escala para el formato FBX | 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.
Agrega el miembro CreateAnimationClip a Aspose.ThreeD. Clase de escena
Ayuda a crear animaciones.
Definición C#
/// <summary>
/// A shorthand function to create and register the <see cref="AnimationClip"/>
/// The first <see cref="AnimationClip"/> will be assigned to the <see cref="CurrentAnimationClip"/>
/// </summary>
/// <param name="name">Animation clip's name</param>
/// <returns></returns>
public Aspose.ThreeD.Animation.AnimationClip CreateAnimationClip(string name)
Esta es una función abreviada para crear el clip de animación, antes de que se realizara esta función, para crear un clip de animación que tiene que:
Enfoque heredado C#
AnimationClip anim = new AnimationClip("anim");
scene.AnimationClips.Add(anim);
//set this as current clip
scene.CurrentAnimationClip = anim;
El código equivalente es:
Nuevo enfoque C#
//create an animation clip
AnimationClip anim = scene.CreateAnimationClip("anim");
El método CreateAnimationClip hará un AnimationClip en una escena.
Agrega el miembro CreateAnimationNode a Aspose.ThreeD. Clase Animation.AnimationClip
Ayuda en la creación de nodo de animación.
Definición C#
/// <summary>
/// A shorthand function to create and register the animation node on current clip.
/// </summary>
/// <param name="nodeName">New animation node's name</param>
/// <returns></returns>
public Aspose.ThreeD.Animation.AnimationNode CreateAnimationNode(string nodeName)
Esta es una función abreviada para crear y registrar el AnimationNode, antes de esta función que necesita escribir:
Enfoque heredado C#
var anode = new AnimationNode("animRot");
anim.Animations.Add(anode);
El código equivalente es:
Nuevo enfoque C#
var anode = anim.CreateAnimationNode("animRot");
Añade tres miembros al Aspose.ThreeD. Animación. Clase de curva
Todos estos miembros ayudan a crear marcos clave.
Definición C#
/// <summary>
/// Create a new key frame with specified value
/// A synonym of <see cref="CreateKeyFrame(double, float)"/>
/// </summary>
/// <param name="time">Time position(measured in seconds)</param>
/// <param name="value">The value at this time position</param>
public void Add(double time, float value)
/// <summary>
/// Create a new key frame with specified value
/// A synonym of <see cref="CreateKeyFrame(double, float, Interpolation)"/>
/// </summary>
/// <param name="time">Time position(measured in seconds)</param>
/// <param name="value">The value at this time position</param>
/// <param name="interpolation">The interpolation type of this key frame</param>
public void Add(double time, float value, Aspose.ThreeD.Animation.Interpolation interpolation)
/// <summary>
/// Gets the enumerator to traverse all key frames.
/// </summary>
/// <returns></returns>
public System.Collections.Generic.IEnumerator<Aspose.ThreeD.Animation.KeyFrame> GetEnumerator()
Los métodos Add es el sinónimo de CreateKeyFrame, los métodos CreateKeyFrame están marcados como obsoletos y la clase Curve ahora implementa IEnumerable
Agrega el miembro BindCurve al Aspose.ThreeD. Animación. CurveMapping clase
Esto unirá los datos de la curva en un canal existente en CurveMapping.
Definición C#
/// <summary>
/// Bind the curve to specified channel
/// </summary>
/// <param name="channelName">Which channel the curve will be bound to</param>
/// <param name="curve">The curve data</param>
public void BindCurve(string channelName, Aspose.ThreeD.Animation.Curve curve)
Antes de la versión 17,9 para crear la animación manualmente es necesario:
C#
//create a curve mapping on cube node's transform object, the curve manipulates the property 'Scale'
var scale = anode.CreateCurveMapping(cube1.Transform, "Scale");
// Create the animation curve on Y component of the scale
Curve scaleYCurve = scale.CreateCurve("Y");
//let cube1.Transform.Scale.Y to be 1.0f at 0th sec using bezier interpolation
scaleYCurve.CreateKeyFrame(0, 1.0f, Interpolation.Bezier);
//let cube1.Transform.Scale.Y to be 2.0f at 2th sec using bezier interpolation
scaleYCurve.CreateKeyFrame(2, 2.0f, Interpolation.Bezier);
//let cube1.Transform.Scale.Y to be 0.2f at 5th sec using linear interpolation
scaleYCurve.CreateKeyFrame(5, 0.2f, Interpolation.Linear);
//let cube1.Transform.Scale.Y to be 1.0f at 8th sec using bezier interpolation
scaleYCurve.CreateKeyFrame(8, 1.0f, Interpolation.Bezier);
Ahora en la versión 17,9 puede implementar la misma tarea usando el azúcar de sintaxis:
C#
//create a curve mapping on cube node's transform object, the curve manipulates the property 'Scale'
var scale = anode.CreateCurveMapping(cube1.Transform, "Scale");
// Create the animation curve on Y component of the scale
scale.BindCurve("Y", new Curve()
{
//let cube1.Transform.Scale.Y to be 1.0f at 0th sec using bezier interpolation
{0, 1.0f, Interpolation.Bezier},
//let cube1.Transform.Scale.Y to be 2.0f at 2th sec using bezier interpolation
{2, 2.0f, Interpolation.Bezier},
//let cube1.Transform.Scale.Y to be 0.2f at 5th sec using linear interpolation
{5, 0.2f, Interpolation.Linear},
//let cube1.Transform.Scale.Y to be 1.0f at 8th sec using bezier interpolation
{8, 1.0f, Interpolation.Bezier}
});
Agregue miembros ShaderSet y PresetShaders a Aspose.ThreeD. Clase Render.Renderer
ShaderSet le permite anular la implementación predeterminada del renderizador Aspose.3D, si ha asignado una instancia de ShaderSet personalizada, la propiedad PresetShaders se convierte en PresetShaders. Personalizado, si desea volver al conjunto de sombreadores predeterminado Aspose.3D, puede asignar PresetShaders. Por defecto para invalidar la propiedad ShaderSet, utilizando este mecanismo, Podemos permitir que el usuario controle los efectos de render mientras podamos proporcionar nuestra propia implementación con suficiente extensibilidad.
Definición C#
/// <summary>
/// Gets or sets the shader set that used to render the scene
/// </summary>
Aspose.ThreeD.Render.ShaderSet ShaderSet{ get;set;}
/// <summary>
/// Gets or sets the preset shader set
/// </summary>
Aspose.ThreeD.Render.PresetShaders PresetShaders{ get;set;}
Agrega Aspose.ThreeD.Render. Clase PresetShaders
En este momento, solo está disponible el valor predeterminado, en el futuro se pueden proporcionar otros estilos de renderizado como sombreadores no realistas.
Definición C#
/// <summary>
/// This defines the preset internal shaders used by the renderer.
/// </summary>
public enum PresetShaders
{
/// <summary>
/// Use the default shaders for phong/lambert/pbr materials
/// </summary>
Default,
/// <summary>
/// User's customized shader set
/// </summary>
Customized
}
Agrega Aspose.ThreeD. Clase Render.ShaderSet
Ayuda a personalizar el ShaderProgram utilizado por cada material diferente para tomar el control total del resultado de renderizado final.
Definición C#
/// <summary>
/// Shader programs for each kind of materials
/// </summary>
public class ShaderSet : IDisposable
{
/// <summary>
/// Gets or sets the shader that used to render the lambert material
/// </summary>
public ShaderProgram Lambert { get; set; }
/// <summary>
/// Gets or sets the shader that used to render the phong material
/// </summary>
public ShaderProgram Phong { get; set; }
/// <summary>
/// Gets or sets the shader that used to render the PBR material
/// </summary>
public ShaderProgram Pbr { get; set; }
/// <summary>
/// Gets or sets the fallback shader when required shader is unavailable
/// </summary>
public ShaderProgram Fallback { get; set; }
}
Rinde la escena en modo Panorama con sombreadores personalizados con profundidad linealizada en lugar de colores.
Ayuda a personalizar el ShaderProgram utilizado por cada material diferente para tomar el control total del resultado de renderizado final.
Definición C#
public void RenderPanoramaInDepth()
{
string path = TestData + @"/textures/skybox2/skybox.obj";
//load the scene
Scene scene = new Scene(path);
//create a camera for capturing the cube map
Camera cam = new Camera(ProjectionType.Perspective);
cam.NearPlane = 0.1;
cam.FarPlane = 200;
scene.RootNode.CreateChildNode(cam).Transform.Translation = new Vector3(5, 6, 0);
cam.RotationMode = RotationMode.FixedDirection;
//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()
{
LightType = LightType.Point,
ConstantAttenuation = 0.1,
Color = new Vector3(Color.CadetBlue)
}).Transform.Translation = new Vector3(49, 0, 49);
//create a render target
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.ShaderSet = CreateDepthShader(renderer);
renderer.Render(rt);
//execute the equirectangular projection post-processing with the previous rendered cube map as input
PostProcessing equirectangular = renderer.GetPostProcessing("equirectangular");
equirectangular.Input = rt.Targets[0];
renderer.Execute(equirectangular, final);
//save the texture into disk
((ITexture2D)final.Targets[0]).Save(RenderResult + "/depth-equirectangular.png", ImageFormat.Png);
}
}
private static ShaderSet CreateDepthShader(Renderer renderer)
{
GLSLSource src = new GLSLSource();
src.VertexShader = @"#version 330 core
layout (location = 0) in vec3 position;
uniform mat4 matWorldViewProj;
out float depth;
void main()
{
gl_Position = matWorldViewProj * vec4(position, 1.0f);
float zfar = 200.0;
float znear = 0.5;
//visualize the depth by linearize it so we don't get a blank screen
depth = (2.0 * znear) / (zfar + znear - gl_Position.z /gl_Position.w * (zfar - znear));
}";
src.FragmentShader = @"#version 330 core
in float depth;
out vec4 color;
void main()
{
color = vec4(depth, depth, depth, 1);
}";
//we only need the position to render the depth map
VertexDeclaration fd = new VertexDeclaration();
fd.AddField(VertexFieldDataType.FVector3, VertexFieldSemantic.Position);
//compile shader from GLSL source code and specify the vertex input format
var shader = renderer.RenderFactory.CreateShaderProgram(src, fd);
//connect GLSL uniform to renderer's internal variable
shader.Variables = new ShaderVariable[]
{
new ShaderVariable("matWorldViewProj", VariableSemantic.MatrixWorldViewProj)
};
//create a shader set
ShaderSet ret = new ShaderSet();
//we only use the fallback, and left other shaders unassigned, so all materials will be rendered by this shader
ret.Fallback = shader;
return ret;
}
Ejemplos de uso
Compruebe la lista de temas de ayuda agregados o actualizados en los documentos wiki Aspose.3D: