Aspose.3D FOSS
Python
Material

LambertMaterial and PhongMaterial — Aspose.3D FOSS for Python API Reference

Properties: aspose.threed.shading (aspose-3d-foss)

Aspose.3D FOSS fornisce due classi di materiale nella gerarchia di shading classica:

  • LambertMaterial: ombreggiatura opaca diffusa (senza specularità)
  • PhongMaterial: estende Lambert con riflessi speculari e lucentezza

Entrambi sono assegnati a un Node tramite node.material. I colori sono impostati usando Vector3(r, g, b) dove i componenti sono in [0.0, 1.0].

LambertMaterial 

class LambertMaterial(Material):

Properties

A3DObject → Material → LambertMaterial

Properties 

LambertMaterial(name: str = None)

Properties

PropertiesPropertiesProperties
ambient_color`Vector3None`
diffuse_color`Vector3None`
emissive_color`Vector3None`
transparent_color`Vector3None`
transparencyfloatLivello di opacità: 0.0 = completamente opaco, 1.0 = completamente trasparente. Limitato a [0.0, 1.0].

PhongMaterial 

class PhongMaterial(LambertMaterial):

Properties

A3DObject → Material → LambertMaterial → PhongMaterial

Eredita tutto LambertMaterial proprietà e aggiunge:

Proprietà aggiuntive

PropertiesPropertiesProperties
specular_color`Vector3None`
specular_factorfloatScala del contributo specular. Predefinito 0.0.
shininessfloatEsponente di lucentezza Phong. Valori più alti = evidenziazioni più strette/piccole. Predefinito 0.0.
reflection_color`Vector3None`
reflection_factorfloatQuantità di miscelazione per il riflesso. Predefinito 0.0.

Esempi di utilizzo

Materiale opaco Lambert 

from aspose.threed import Scene
from aspose.threed.entities import Mesh
from aspose.threed.shading import LambertMaterial
from aspose.threed.utilities import Vector3, Vector4

scene = Scene()

# Build a simple triangle mesh
mesh = Mesh()
mesh.control_points.append(Vector4(0, 0, 0, 1))
mesh.control_points.append(Vector4(1, 0, 0, 1))
mesh.control_points.append(Vector4(0.5, 1, 0, 1))
mesh.create_polygon(0, 1, 2)

# Create a matte red material
mat = LambertMaterial("red-matte")
mat.diffuse_color = Vector3(0.8, 0.1, 0.1)    # R, G, B in [0, 1]
mat.ambient_color = Vector3(0.1, 0.05, 0.05)

node = scene.root_node.create_child_node("triangle", mesh)
node.material = mat

scene.save("lambert.obj")

Materiale lucido Phong 

from aspose.threed import Scene
from aspose.threed.entities import Mesh
from aspose.threed.shading import PhongMaterial
from aspose.threed.utilities import Vector3, Vector4

scene = Scene()

mesh = Mesh()
mesh.control_points.append(Vector4(0, 0, 0, 1))
mesh.control_points.append(Vector4(1, 0, 0, 1))
mesh.control_points.append(Vector4(0.5, 1, 0, 1))
mesh.create_polygon(0, 1, 2)

mat = PhongMaterial("shiny-blue")
mat.diffuse_color = Vector3(0.1, 0.2, 0.8)   # blue
mat.specular_color = Vector3(1.0, 1.0, 1.0)  # white highlights
mat.specular_factor = 0.5
mat.shininess = 64.0                           # tight specular lobe
mat.ambient_color = Vector3(0.05, 0.05, 0.1)

node = scene.root_node.create_child_node("mesh", mesh)
node.material = mat

scene.save("phong.obj")

Materiale semitrasparente 

from aspose.threed.shading import LambertMaterial
from aspose.threed.utilities import Vector3

mat = LambertMaterial("glass")
mat.diffuse_color = Vector3(0.7, 0.9, 1.0)   # faint blue tint
mat.transparency = 0.7                         # 70% transparent

Leggi il materiale dalla scena importata 

from aspose.threed import Scene
from aspose.threed.shading import LambertMaterial, PhongMaterial

scene = Scene()
scene.open("model.obj")

def inspect_node(node):
    if node.material:
        m = node.material
        kind = "Phong" if isinstance(m, PhongMaterial) else "Lambert"
        print(f"Node '{node.name}': {kind}: diffuse={m.diffuse_color}")
        if isinstance(m, PhongMaterial):
            print(f"  shininess={m.shininess}")
    for child in node.child_nodes:
        inspect_node(child)

inspect_node(scene.root_node)

PbrMaterial 

class PbrMaterial(Material):

Properties

A3DObject → Material → PbrMaterial

Materiale PBR (Physically Based Rendering). Usato da glTF 2.0 e altri formati compatibili PBR. Assegnato a un Node tramite node.material.

Properties 

PbrMaterial(name: str = None, albedo: Vector3 = None)

Properties

PropertiesPropertiesProperties
albedo`Vector3None`
albedo_texturequalsiasiMappa di texture per il canale albedo.
normal_texturequalsiasiTexture della mappa normale.
metallic_factorfloatContributo metallico: 0.0 = completamente dielettrico, 1.0 = completamente metallico.
roughness_factorfloatRugosità della superficie: 0.0 = liscio/specchio, 1.0 = completamente ruvido.
metallic_roughnessqualsiasiTexture combinata metallic-roughness (convenzione glTF: B=metallic, G=roughness).
occlusion_texturequalsiasiTexture di occlusione ambientale.
occlusion_factorfloatIntensità dell’effetto di occlusione ambientale.
emissive_texturequalsiasiTexture emissiva per le regioni autoilluminate.
emissive_color`Vector3None`
transparencyfloatLivello di opacità: 0.0 = completamente opaco, 1.0 = completamente trasparente.

Metodo di classe

PropertiesTipo di ritornoProperties
PbrMaterial.from_material(material)PbrMaterialConverte un LambertMaterial o PhongMaterial in un PbrMaterial approssimazione.

Esempio di utilizzo 

from aspose.threed import Scene
from aspose.threed.entities import Mesh
from aspose.threed.shading import PbrMaterial
from aspose.threed.utilities import Vector3, Vector4

scene = Scene()

mesh = Mesh()
mesh.control_points.append(Vector4(0, 0, 0, 1))
mesh.control_points.append(Vector4(1, 0, 0, 1))
mesh.control_points.append(Vector4(0.5, 1, 0, 1))
mesh.create_polygon(0, 1, 2)

mat = PbrMaterial("pbr-metal")
mat.albedo = Vector3(0.8, 0.6, 0.2)    # gold-ish base color
mat.metallic_factor = 0.9
mat.roughness_factor = 0.2

node = scene.root_node.create_child_node("mesh", mesh)
node.material = mat

scene.save("pbr.glb")

Vedi anche

 Italiano