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 stellt zwei Materialklassen in der klassischen Schattierungshierarchie bereit:

  • LambertMaterial: diffuse matte Schattierung (keine Specularität)
  • PhongMaterial: erweitert Lambert um spekulare Glanzlichter und Glanz

Beide werden einem zugewiesen Node über node.material. Farben werden festgelegt mit Vector3(r, g, b) wobei Komponenten 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`
transparencyfloatDeckkraftstufe: 0.0 = vollständig undurchsichtig, 1.0 = vollständig transparent. Begrenzt auf [0.0, 1.0].

PhongMaterial 

class PhongMaterial(LambertMaterial):

Properties

A3DObject → Material → LambertMaterial → PhongMaterial

Erbt alle LambertMaterial Eigenschaften und fügt hinzu:

Speichert Texturkoordinatenpaare (Vector2) pro Vertex oder pro Polygon‑Ecke. Ein Mesh kann mehrere UV‑Ebenen enthalten.

PropertiesPropertiesProperties
specular_color`Vector3None`
specular_factorfloatSkalierung des specular-Beitrags. Standard 0.0.
shininessfloatPhong-Glanz-Exponent. Höher = engere/kleinere Highlights. Standard 0.0.
reflection_color`Vector3None`
reflection_factorfloatMischanteil für Reflexion. Standard 0.0.

Anwendungsbeispiele

Lambert-Matte-Material 

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")

Phong-Glänzendes Material 

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")

Halbtransparentes Material 

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

Material aus importierter Szene lesen 

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

PBR (Physically Based Rendering) Material. Verwendet von glTF 2.0 und anderen PBR‑fähigen Formaten. Zugewiesen zu einem Node via node.material.

Properties 

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

Properties

PropertiesPropertiesProperties
albedo`Vector3None`
albedo_texturebeliebigTexturkarte für den Albedo‑Kanal.
normal_texturebeliebigNormal-Map-Textur.
metallic_factorfloatMetallischer Beitrag: 0.0 = vollständig dielektrisch, 1.0 = vollständig metallisch.
roughness_factorfloatOberflächenrauheit: 0.0 = glatt/spiegelnd, 1.0 = vollständig rau.
metallic_roughness= beliebig= Kombinierte Metallic-Roughness-Textur (glTF-Konvention: B=metallic, G=roughness).
occlusion_texture= beliebig= Ambient-Occlusion-Textur.
occlusion_factorfloat= Stärke des Ambient-Occlusion-Effekts.
emissive_texture= beliebig= Emissive-Textur für selbstleuchtende Bereiche.
emissive_color`Vector3None`
transparencyfloat= Deckkraftstufe: 0.0 = vollständig undurchsichtig, 1.0 = vollständig transparent.

Klassenmethode

PropertiesRückgabetypProperties
PbrMaterial.from_material(material)PbrMaterialKonvertiert ein LambertMaterial oder PhongMaterial zu einem PbrMaterial Approximation.

Ein Dokument programmgesteuert erstellen 

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")

Siehe auch

 Deutsch