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 leverer to materialklasser i den klassiske shading-hierarki:

  • LambertMaterial: diffus mat skygge (ingen spekularitet)
  • PhongMaterial: udvider Lambert med spekulære højdepunkter og glans

Begge er tildelt en Node via node.material. Farver sættes ved hjælp af Vector3(r, g, b) hvor komponenterne er i [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`
transparencyfloatOpacitetsniveau: 0.0 = fuldt ugennemsigtigt, 1.0 = fuldt gennemsigtigt. Begrænset til [0.0, 1.0].

PhongMaterial 

class PhongMaterial(LambertMaterial):

Properties

A3DObject → Material → LambertMaterial → PhongMaterial

Arver alle LambertMaterial egenskaber og tilføjer:

Yderligere egenskaber

PropertiesPropertiesProperties
specular_color`Vector3None`
specular_factorfloatSkala for den spekulære andel. Standard 0.0.
shininessfloatPhong-glans eksponent. Højere = strammere/mindre højlys. Standard 0.0.
reflection_color`Vector3None`
reflection_factorfloatBlandingens mængde for refleksion. Standard 0.0.

API-reference for klassen AttachedFile i aspose-note v26.3.1. Repræsenterer en filvedhæftning indlejret i en OneNote-side.

Lambert mat materiale 

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 skinnende materiale 

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

Semi-gennemsigtigt materiale 

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

Læs materiale fra importeret scene 

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)-materiale. Bruges af glTF 2.0 og andre PBR-kompatible formater. Tildelt til en Node via node.material.

Properties 

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

Properties

PropertiesPropertiesProperties
albedo`Vector3None`
albedo_textureenhverTeksturkort for albedo-kanalen.
normal_textureenhverNormalmaptekstur.
metallic_factorfloatMetallisk bidrag: 0.0 = fuldt dielektrisk, 1.0 = fuldt metallisk.
roughness_factorfloatOverfladeråhed: 0.0 = glat/spejl, 1.0 = fuldt ru.
metallic_roughnessenhverKombineret metallic-roughness-textur (glTF-konvention: B=metallic, G=roughness).
occlusion_textureenhverAmbient occlusion-textur.
occlusion_factorfloatStyrken af ambient occlusion-effekten.
emissive_textureenhverEmissiv tekstur for selvbelyste områder.
emissive_color`Vector3None`
transparencyfloatGennemsigtighedsniveau: 0.0 = fuldt ugennemsigtigt, 1.0 = fuldt gennemsigtigt.

Klassemetode

PropertiesReturntypeProperties
PbrMaterial.from_material(material)PbrMaterialKonverterer en LambertMaterial eller PhongMaterial til en PbrMaterial tilnærmelse.

Aspose.Slides FOSS API-referencen for alle understøttede platforme. Vælg din platform for at gennemse klasser, metoder og egenskaber. 

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

Se også

 Dansk