Aspose.3D FOSS
Python
Material

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

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

Aspose.3D FOSS proporciona dues classes de material a la jerarquia clàssica d’ombrejat:

  • LambertMaterial: ombrejat mat difús (sense especularitat)
  • PhongMaterial: amplia Lambert amb reflexos especulars i lluentor

Ambdós s’assignen a un Node a través de node.material. Els colors s’estableixen amb Vector3(r, g, b) on les components es troben a [0.0, 1.0].

LambertMaterial 

class LambertMaterial(Material):

Enumerations

A3DObject → Material → LambertMaterial

Enumerations 

LambertMaterial(name: str = None)

Enumerations

EnumerationsEnumerationsEnumerations
ambient_color`Vector3None`
diffuse_color`Vector3None`
emissive_color`Vector3None`
transparent_color`Vector3None`
transparencyfloatNivell d’opacitat: 0.0 = completament opac, 1.0 = completament transparent. Limitat a [0.0, 1.0].

PhongMaterial 

class PhongMaterial(LambertMaterial):

Enumerations

A3DObject → Material → LambertMaterial → PhongMaterial

Hereta tot LambertMaterial les propietats i afegeix:

Opcions de càrrega i desament

EnumerationsEnumerationsEnumerations
specular_color`Vector3None`
specular_factorfloatEscala de la contribució especular. Per defecte 0.0.
shininessfloatExponent de brillantor Phong. Més alt = ressaltats més estrets/menors. Per defecte 0.0.
reflection_color`Vector3None`
reflection_factorfloatQuantitat de mescla per a la reflexió. Per defecte 0.0.

Exemples d’ús

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

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

Material Semitransparent 

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

Llegir Material des d’Escena Importada 

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

Enumerations

A3DObject → Material → PbrMaterial

Material PBR (Physically Based Rendering). Utilitzat per glTF 2.0 i altres formats compatibles amb PBR. Assignat a un Node via node.material.

Enumerations 

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

Enumerations

EnumerationsEnumerationsEnumerations
albedo`Vector3None`
albedo_texturequalsevolMapa de textura per al canal albedo.
normal_texturequalsevolTextura de mapa normal.
metallic_factorfloatContribució metàl·lica: 0.0 = totalment dielèctric, 1.0 = totalment metàl·lic.
roughness_factorfloatRugositat de la superfície: 0.0 = suau/espill, 1.0 = completament rugós.
metallic_roughness= qualsevol= Textura combinada metallic-roughness (convenció glTF: B=metallic, G=roughness).
occlusion_texture= qualsevol= Textura d’occlusió ambiental.
occlusion_factorfloat= Intensitat de l’efecte d’occlusió ambiental.
emissive_texture= qualsevol= Textura emissiva per a regions autoil·luminades.
emissive_color`Vector3None`
transparencyfloat= Nivell d’opacitat: 0.0 totalment opac, 1.0 totalment transparent.

Mètode de classe

EnumerationsTipus de retornEnumerations
PbrMaterial.from_material(material)PbrMaterialConverteix un LambertMaterial o PhongMaterial a un PbrMaterial aproximació.

Interfície IColorFormat 

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

Vegeu també

 Català