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(Così puoi vedere che viene aggiunto un GetEnumerator), quindi puoi usare la sintassi dell’inizializzatore di c # (Refhttps://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers) Per semplificare la creazione della curva.

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:

  1. Aggiungere proprietà di animazione e configurare la fotocamera di destinazione nel file 3D
  2. Render 3D Scena con modalità Panorama in profondità