Öffentliche API Änderungen in Aspose.3D 2.0.0
Inhalts übersicht
- Fügt das Collada-Format hinzu
- Fügt Aspose hinzu. ThreeD.Render.IRender Target/IRender Texture/IRender Window/ITexture Unit-Schnitts tellen und Aspose.ThreeD.Render.Viewport/Initial isierung Exception/Renderer/Texture Type/Driver Exception/Render Factory/Render Parameters-Klassen
- Fügt Aspose hinzu. ThreeD.Render.PostProcessing-Klasse
- Fügt Aspose die GetBoundingBox-Methode hinzu. ThreeD. Knoten klasse, Fügt neue Klassen Aspose hinzu. ThreeD.Utilities.Bounding Box und Aspose.ThreeD.Utilities.Bounding Box Extent
- Echtzeit-Rendering
- AddData-Methoden werden zu Aspose hinzugefügt. ThreeD.Entities.Vertex ElementUV-Klasse
Fügt das Collada-Format hinzu
In dieser Version (2.0.0) können Entwickler Collada 3D-Dateien importieren, sodass die Collada-Eigenschaft zur Aspose.ThreeD.FileFormat-Klasse hinzugefügt wird.
Fügt Aspose hinzu. ThreeD.Render.IRender Target/IRender Texture/IRender Window/ITexture Unit-Schnitts tellen und Aspose.ThreeD.Render.Viewport/Initial isierung Exception/Renderer/Texture Type/Driver Exception/Render Factory/Render Parameters-Klassen
Die neuen Viewport-und Renderer-Klassen sind die Hauptklassen, mit denen Sie die Ansichten einer 3D-Szene erfassen und in einer Textur oder einem Fenster speichern können. Alle Details anderer helfender Klassen sind wie folgt:
- Aspose.ThreeD.Render.DriverException-Klasse-Die Ausnahmen des internen Renderers werden als Driver Exception eingewickelt.
- Aspose.ThreeD.Render.Initial isierung Exception-Klasse-Diese Ausnahme wird ausgelöst, während der Renderer nicht initial isiert werden kann, z. B. um ihn auf einem Computer zu initial isieren, der keine Hardware-Unterstützung von OpenGL 4.0 hat.
- IrenderTarget-Schnitts telle-Es ist die Basis-Schnitts telle von IRender Texture/Ireder Window.
- IrenderTexture-Schnitts telle-Es ermöglicht das Rendern der Szene auf eine oder mehrere Texturen (Texturen befinden sich im Videosp eicher und können in den Systemsp eicher übertragen werden).
- IrenderWindow-Schnitts telle-Es erlaubt, die Szene in Echtzeit zum Fenster zu rendern.
- IITextureUnit-Schnitts telle-Itexture Unit ist der Textur-Sampler auf der GPU-Seite und die Textur daten im CPU-oder GPU-Speicher.
- Texture Type enum-Es definiert die Art der Texturen, wie Texture1D, Texture2D, Texture3D, CubeMap und Array2D.
- Render Factory Klasse-Es hilft beim Rendern einer Szene zu Texturen oder Fenster in Echtzeit.
- RenderParameter-Klasse-Es definiert die Parameter zum Erstellen des Render ziels wie Farbbits, Tiefen bits, Schablonen bits und Doppel pufferung.
Erfassen Sie die View ports einer 3D-Szene und Render zu einer Textur oder einem Fenster
C#
// load an existing 3D scene
Scene scene = new Scene("scene.obj");
// create an instance of the camera
Camera camera = new Camera();
scene.RootNode.CreateChildNode("camera", camera).Transform.Translation = new Vector3(2, 44, 66);
// set the target
camera.LookAt = new Vector3(50, 12, 0);
//create a light
scene.RootNode.CreateChildNode("light", new Light() {Color = new Vector3(Color.White), LightType = LightType.Point}).Transform.Translation = new Vector3(26, 57, 43);
// the CreateRenderer will create a hardware OpenGL-backend renderer
// and some internal initializations will be done.
// when the renderer left using the scope, the unmanaged hardware resources will also be disposed
using (var renderer = Renderer.CreateRenderer())
{
renderer.EnableShadows = false;
// create a new render target that renders the scene to texture(s)
// use default render parameters
// and one output targets
// size is 1024 x 1024
// this render target can have multiple render output textures, but here we only need one output.
// The other textures and depth textures are mainly used by deferred shading in the future.
// but you can also access the depth texture through IRenderTexture.DepthTeture
// use CreateRenderWindow method to render in window, like:
// window = renderer.RenderFactory.CreateRenderWindow(new RenderParameters(), Handle);
using (IRenderTexture rt = renderer.RenderFactory.CreateRenderTexture(new RenderParameters(), 1, 1024, 1024))
{
//this render target has one viewport to render, the viewport occupies the 100% width and 100% height
Viewport vp = rt.CreateViewport(camera, new RelativeRectangle() {ScaleWidth = 1, ScaleHeight = 1});
//render the target and save the target texture to external file
renderer.Render(rt);
rt.Targets[0].Save("file-1viewports.png", ImageFormat.Png);
//now let's change the previous viewport only uses the half left side(50% width and 100% height)
vp.Area = new RelativeRectangle() {ScaleWidth = 0.5f, ScaleHeight = 1};
//and create a new viewport that occupies the 50% width and 100% height and starts from 50%
//both of them are using the same camera, so the rendered content should be the same
rt.CreateViewport(camera, new RelativeRectangle() {ScaleX = 0.5f, ScaleWidth = 0.5f, ScaleHeight = 1});
//but this time let's increase the field of view of the camera to 90 degree so it can see more part of the scene
camera.FieldOfView = 90;
renderer.Render(rt);
rt.Targets[0].Save("file-2viewports.png", ImageFormat.Png);
}
}
Fügt Aspose hinzu. ThreeD.Render.PostProcessing-Klasse
Mit der PostProcessing-Klasse können Entwickler Echtzeit-Bild verarbeitung filter auf das gerenderte Bild anwenden. In dieser Version 2.0.0 haben wir 4 integrierte Nach bearbeitungs effekte bereit gestellt. Wir werden Entwicklern erlauben, ihren eigenen benutzer definierten Post-Processing-Algorithmus in der zukünftigen Version zu haben.
Wenden Sie visuelle Effekte an, um 3D-Ansichten zu speichern
C#
// load an existing 3D scene
Scene scene = new Scene("scene.obj");
// create an instance of the camera
Camera camera = new Camera();
scene.RootNode.CreateChildNode("camera", camera).Transform.Translation = new Vector3(2, 44, 66);
// set the target
camera.LookAt = new Vector3(50, 12, 0);
//create a light
scene.RootNode.CreateChildNode("light", new Light() { Color = new Vector3(Color.White), LightType = LightType.Point }).Transform.Translation = new Vector3(26, 57, 43);
// the CreateRenderer will create a hardware OpenGL-backend renderer, more renderer will be added in the future
// and some internal initializations will be done.
// when the renderer left using the scope, the unmanaged hardware resources will also be disposed
using (var renderer = Renderer.CreateRenderer())
{
renderer.EnableShadows = false;
// create a new render target that renders the scene to texture(s)
// use default render parameters
// and one output targets
// size is 1024 x 1024
// this render target can have multiple render output textures, but here we only need one output.
// The other textures and depth textures are mainly used by deferred shading in the future.
// but you can also access the depth texture through IRenderTexture.DepthTeture
using (IRenderTexture rt = renderer.RenderFactory.CreateRenderTexture(new RenderParameters(), 1, 1024, 1024))
{
// this render target has one viewport to render, the viewport occupies the 100% width and 100% height
Viewport vp = rt.CreateViewport(camera, new RelativeRectangle() { ScaleWidth = 1, ScaleHeight = 1 });
//render the target and save the target texture to external file
renderer.Render(rt);
rt.Targets[0].Save("Original_viewport.png", ImageFormat.Png);
// create a post-processing effect
PostProcessing pixelation = renderer.GetPostProcessing("pixelation");
renderer.PostProcessings.Add(pixelation);
renderer.Render(rt);
rt.Targets[0].Save("VisualEffect_pixelation.png", ImageFormat.Png);
//clear previous post-processing effects and try another one
PostProcessing grayscale = renderer.GetPostProcessing("grayscale");
renderer.PostProcessings.Clear();
renderer.PostProcessings.Add(grayscale);
renderer.Render(rt);
rt.Targets[0].Save("VisualEffect_grayscale.png", ImageFormat.Png);
//we can also combine post-processing effects
renderer.PostProcessings.Clear();
renderer.PostProcessings.Add(grayscale);
renderer.PostProcessings.Add(pixelation);
renderer.Render(rt);
rt.Targets[0].Save("VisualEffect_grayscale+pixelation.png", ImageFormat.Png);
//clear previous post-processing effects and try another one
PostProcessing edgedetection = renderer.GetPostProcessing("edge-detection");
renderer.PostProcessings.Clear();
renderer.PostProcessings.Add(edgedetection);
renderer.Render(rt);
rt.Targets[0].Save("VisualEffect_edgedetection.png", ImageFormat.Png);
//clear previous post-processing effects and try another one
PostProcessing blur = renderer.GetPostProcessing("blur");
renderer.PostProcessings.Clear();
renderer.PostProcessings.Add(blur);
renderer.Render(rt);
rt.Targets[0].Save("VisualEffect_blur.png", ImageFormat.Png);
}
}
Fügt Aspose die GetBoundingBox-Methode hinzu. ThreeD. Knoten klasse, Fügt neue Klassen Aspose hinzu. ThreeD.Utilities.Bounding Box und Aspose.ThreeD.Utilities.Bounding Box Extent
Die Klassen Bounding Box und Bounding Box Extent repräsentieren das Begrenzung sfeld eines 3D-Knotens. Entwickler können die Kamera zurücksetzen und die Höhe aus dem Begrenzung sfeld berechnen. Die unendliche oder Null-Begrenzung sbox bedeutet, dass die Szene keine Geometrien hat und die Höhe der Kamera nur anpasst, wenn sie endlich ist.
Echtzeit-Rendering
Es ermöglicht Entwicklern, leistungs starkes Echtzeit-Rendering auf einem GUI-Framework wie Win Forms durch zuführen. Es ist GUI-Framework-unabhängig, sodass die anderen GUI-Frameworks dies ebenfalls unterstützen sollten.
AddData-Methoden werden zu Aspose hinzugefügt. ThreeD.Entities.Vertex ElementUV-Klasse
Die Basis klasse des Vertex ElementUV hat sich von Vertex Element Template geändert