Trabalhar com o gráfico de cena

Cada cena 3D em Aspose.3D para .NET é organizado como uma árvore de Node objetos. Scene.RootNode é a raiz daquela árvore e cada pedaço de geometria, material, e transformar vidas sob ela como uma criança ou descendente.

Criar a cena e acessar o nó raiz

Scene inicializa automaticamente com um nó raiz chamado "RootNode":

using Aspose.ThreeD;

var scene = new Scene();
Node root = scene.RootNode; // always "RootNode"

Adicionar Nodos Filhos

Chama-me . CreateChildNode() O método tem três sobrecargas comumente usadas:

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;

var scene = new Scene();
Node root = scene.RootNode;

// 1. Named node with no entity — useful as a pivot or transform container
Node pivot = root.CreateChildNode("pivot");

// 2. Named node with an entity
var box = new Box(2, 2, 2);
Node boxNode = root.CreateChildNode("box", box);

// 3. Named node with entity and material
var mat = new Aspose.ThreeD.Shading.PhongMaterial("red");
mat.Diffuse = new Vector4(0.8, 0.2, 0.2, 1.0);
Node decorated = pivot.CreateChildNode("red_box", box, mat);

Para anexar um nó construído separadamente, use AddChildNode():

var detached = new Node("standalone");
root.AddChildNode(detached);

Interrogação de Nodos Filhos

Encontre um filho direto por nome ou por índice, ou itere todos os filhos diretos:

// By name — returns null if no direct child has that name
Node? found = root.GetChild("box");
if (found != null)
    Console.WriteLine("Found: " + found.Name);

// By index
Node first = root.GetChild(0);

// Iterate all direct children
foreach (Node child in root.ChildNodes)
    Console.WriteLine(child.Name);

GetChild(string name) Apenas pesquisas. filhos diretos, não a sub-árvore completa. Use um auxiliar recursivo ou Accept() Para procurar a árvore inteira.

Atravessar a árvore cheia

Para uma caminhada completa, repita. ChildNodes de forma recursiva:

static void Walk(Node node, int depth = 0)
{
    Console.WriteLine(new string(' ', depth * 2) + node.Name);
    foreach (var child in node.ChildNodes)
        Walk(child, depth + 1);
}

Walk(scene.RootNode);

Para a travessia de saída antecipada, node.Accept(NodeVisitor) está disponível e chama o visitante em cada descendente até que o visitor retorne false.

Usar grupo para organizar objetos relacionados

Group é uma entidade de contêiner que organiza logicamente nós sem adicionar geometria. Anexe-o a um nó cujos filhos representam uma unidade lógica:

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;

var scene = new Scene();

// A group node for all furniture in a room
var furnitureGroup = new Group("furniture");
Node roomNode = scene.RootNode.CreateChildNode("living_room", furnitureGroup);

// Child nodes under the group node
Node sofaNode  = roomNode.CreateChildNode("sofa",         new Box(3, 1, 1));
Node tableNode = roomNode.CreateChildNode("coffee_table", new Box(2, 0.5, 1));

Movimento roomNode transforma todos os móveis juntos porque as crianças herdam o seu Transform.

Controlo da visibilidade e exclusão das exportações

Os nós podem ser ocultados ou excluídos da exportação sem serem removidos da hierarquia:

Node ground = scene.RootNode.CreateChildNode("ground_plane", new Box(100, 0.1, 100));
ground.Visible = false;       // hidden in viewport / renderer

Node helperNode = scene.RootNode.CreateChildNode("debug_arrow", new Box());
helperNode.Excluded = true;   // omitted from all export operations

Visible = false é uma sugestão de exibição. Excluded = true impede que o nó apareça em arquivos exportados, independentemente do formato.

Anexar múltiplas entidades a um nó

Um nó tem um primária entidade (Entity A Comissão Europeia tem um papel fundamental na política de segurança. AddEntity().Isto é útil quando diferentes peças de malha partilham uma única transformação:

var bodyMesh  = new Mesh("body");
var wheelMesh = new Mesh("wheel");

Node carNode = scene.RootNode.CreateChildNode("car");
carNode.AddEntity(bodyMesh);
carNode.AddEntity(wheelMesh);

// Retrieve all entities on this node
foreach (Entity ent in carNode.Entities)
    Console.WriteLine(ent.GetType().Name + ": " + ent.Name);

Nodos de fusão

Merge() Mova todos os filhos, entidades e materiais de um nó fonte para o nó alvo. O nó origem é deixado vazio:

Node lod0 = scene.RootNode.CreateChildNode("lod0");
lod0.CreateChildNode("mesh_high", new Box(1, 1, 1));

Node lod1 = scene.RootNode.CreateChildNode("lod1");
lod1.CreateChildNode("mesh_low", new Box(1, 1, 1));

// Consolidate lod0 children into lod1
lod1.Merge(lod0);
// lod1 now has both mesh_high and mesh_low; lod0 is empty

Pasos seguintes

Aplicando transformações posição, rotação e escala de qualquer nó usando seu Transform
Criando a Geometria Primitiva utilização Box, Sphere, e Cylinder como entidades de cena.
Criar e trabalhar com malhas construir geometria de polígonos e anexá-lo a nós

Referência rápida da API

Membro da Comissão	Descrição:
`scene.RootNode`	Raiz da árvore de cena; sempre presente depois `new Scene()`
`node.CreateChildNode(name)`	Criar um nó filho com nome sem entidade
`node.CreateChildNode(name, entity)`	Criar um nó filho com uma entidade nomeada
`node.CreateChildNode(name, entity, material)`	Criar um nó filho com nome de entidade e material
`node.AddChildNode(node)`	Anexar um construído separadamente `Node`
`node.GetChild(name)`	Encontrar um filho direto pelo nome; retorna `null` se não for encontrado.
`node.GetChild(index)`	Obter o filho direto em um determinado índice
`node.ChildNodes`	`IList<Node>` de todos os filhos directos
`node.Accept(visitor)`	Caminhe este nó e todos os descendentes profundamente primeiro.
`node.AddEntity(entity)`	Anexar uma entidade adicional ao nó
`node.Entities`	`IList<Entity>` de todas as entidades neste nó
`node.Visible`	Mostrar ou ocultar o nó
`node.Excluded`	Incluir ou excluir o nó da exportação
`node.Merge(other)`	Mover todas as crianças e entidades de `other` Neste nó.
`new Group(name)`	Entidade de recipiente para agrupar logicamente os nós filhos

Ver também:

Aspose.3D para .NET Documentação empresarial