Aspose.3D for .NET 17.9 Note di rilascio
Altri miglioramenti e modifiche
| Chiave | Riassunto | Categoria |
|---|---|---|
| THREEDNET-286 | Aggiungi supporto per identificare in modo univoco le mesh dallo FBX | Nuova funzionalità |
| THREEDNET-288 | Aggiungi supporto alla scena di rendering in shader completamente personalizzati | Nuova funzionalità |
| THREEDNET-284 | Migliorare il consumo di memoria quando si scrive un file FBX di grandi dimensioni | Miglioramento |
| THREEDNET-293 | Esportazione errata OBJ con texture a GLTF e GLB | Bug |
| THREEDNET-290 | Rotazione delle proprietà animate (Eulero) e scala per il formato FBX | Bug |
Pubblico API e modifiche incompatibili arretrate
Vedere l’elenco di eventuali modifiche apportate al pubblico API come membri aggiunti, rinominati, rimossi o deprecati, nonché qualsiasi modifica non retrocompatibile apportata allo Aspose.3D for .NET. Se hai dubbi su eventuali modifiche elencate, sollevalo sulForum di supporto Aspose.3D.
Aggiunge il membro CreateAnimationClip alla classe Aspose.ThreeD.Scene
Aiuta nella creazione di animazioni.
Definizione 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)Questa è una funzione abbreviata per creare la clip di animazione, prima che questa funzione fosse fatta, per creare una clip di animazione devi:
Approccio legacy C#
AnimationClip anim = new AnimationClip("anim");
scene.AnimationClips.Add(anim);
//set this as current clip
scene.CurrentAnimationClip = anim;Il codice equivalente è:
Nuovo approccio C#
//create an animation clip
AnimationClip anim = scene.CreateAnimationClip("anim");Il metodo CreateAnimationClip farà un AnimationClip in una scena.
Aggiunge il membro CreateAnimationNode a Aspose.ThreeD.Animation.AnimationClip class
Aiuta nella creazione del nodo di animazione.
Definizione 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)Questa è una funzione stenografia per creare e registrare il Nodo d’animazione, prima di questa funzione è necessario scrivere:
Approccio legacy C#
var anode = new AnimationNode("animRot");
anim.Animations.Add(anode);Il codice equivalente è:
Nuovo approccio C#
var anode = anim.CreateAnimationNode("animRot");Aggiunge tre membri alla classe Aspose.ThreeD.Animation.Curve
Tutti questi membri aiutano nella creazione di fotogrammi chiave.
Definizione 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()I metodi Aggiungi sono il sinonimo di CreateKeyFrame, i metodi CreateKeyFrame sono tutti contrassegnati come obsoleti e la classe Curve ora implementa IEnumerable
Aggiunge il membro BindCurve allo Aspose.ThreeD.Animation.CurveMapping class
Questo collegerà i dati della curva su un canale esistente in CurveMapping.
Definizione 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)Prima della versione 17.9 per creare l’animazione manualmente è necessario:
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);Ora nella versione 17.9 è possibile implementare la stessa attività utilizzando lo zucchero sintassi:
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}
});Aggiungi membri di ShaderSet e PresetShader alla classe Aspose.ThreeD.Render.Renderer
ShaderSet consente di sovrascrivere l’implementazione predefinita del renderer dello Aspose.3D, se viene assegnata un’istanza ShaderSet personalizzata, la proprietà PresetShaders diventa PresetShader. Personalizzato, se si desidera tornare al set shader predefinito dello Aspose.3D, è possibile assegnare PresetShader. Default per invalidare la proprietà ShaderSet utilizzando questo meccanismo, Possiamo consentire all’utente di controllare gli effetti di rendering mentre possiamo ancora fornire la nostra implementazione con sufficiente estensibilità.
Definizione 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;}Aggiunge Aspose.ThreeD.Render. Classe PresetShaders
Al momento è disponibile solo il Default, altri stili di rendering come shader non realistici possono essere forniti in futuro.
Definizione 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
}Aggiunge Aspose.ThreeD.Render.ShaderSet di classe
Aiuta a personalizzare lo ShaderProgram utilizzato da ciascun diverso materiale per assumere completamente il controllo del risultato finale del rendering.
Definizione 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; }
}Rende la scena in modalità Panorama con shader personalizzati con profondità linearizzata anziché colori.
Aiuta a personalizzare lo ShaderProgram utilizzato da ogni diverso materiale per assumere completamente il controllo del risultato di rendering finale.
Definizione 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;
}Esempi di utilizzo
Controlla l’elenco degli argomenti di aiuto aggiunti o aggiornati nei documenti Wiki Aspose.3D: