Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-usd

Source of release 0.9.2

0.9.2 / src / convert / subdivision.lucb

## Subdivision surfaces (UsdGeomMesh's subdivisionScheme,
## interpolateBoundary, creases, corners and holes) as geocore's display
## attributes: detail subd.scheme (1 Catmull-Clark, 2 Loop, 3 bilinear),
## subd.level 1 and subd.boundary; edge `crease` and point
## `corner_sharpness` in USD's own sharpness units; the face group `hole`.
## A detail holds one scheme for the merged mesh: the one most faces ask for.

func put_subdivision(stage: Stage*, build: const MeshBuild*, mesh: Mesh*, options: const ImportOptions*, warnings: Warnings*) -> !:
    let t = stage.tokens
    var faces: usize[4] = [0, 0, 0, 0]
    var boundary: f64 = 1.0
    var chosen_boundary = false
    for index in 0..<build.sources.count:
        let source = &build.sources.items[index]
        let scheme_token = try stage.token_value(source.path, t.subdivision_scheme, 0)
        var scheme: usize = 1 if options.subdivide_unauthored else 0
        if scheme_token == t.catmull_clark: scheme = 1
        elif scheme_token == t.loop_scheme: scheme = 2
        elif scheme_token == t.bilinear: scheme = 3
        elif scheme_token == t.none_value: scheme = 0
        faces[scheme] += face_end(build, index) - source.face_base
        if scheme != 0 and not chosen_boundary:
            chosen_boundary = true
            let rule = try stage.token_value(source.path, t.interpolate_boundary, t.edge_and_corner)
            boundary = 1.0 if rule == t.edge_and_corner else 0.0
    var scheme: usize = 0
    for at in 1..<(usize)4:
        if faces[at] > faces[scheme]: scheme = at
    var kinds: usize = 0
    for count in faces:
        if count > 0: kinds += 1
    if kinds > 1: try warnings.add("Merged meshes ask for different subdivision schemes; the one most faces use applies")
    if scheme == 0: return
    try put_detail_number(mesh, "subd.scheme", (f64)scheme)
    try put_detail_number(mesh, "subd.level", 1.0)
    try put_detail_number(mesh, "subd.boundary", boundary)
    try put_creases(stage, build, mesh, warnings)
    try put_corners(stage, build, mesh)
    try put_holes(stage, build, mesh)

func put_detail_number(mesh: Mesh*, name: str, value: f64) -> !:
    let values: f64[1] = [value]
    try put_attribute(mesh, try Attribute.from_numbers(name, Domain.detail, 1, values[..<1], true))

## Crease chains as sharpness on the edges between consecutive chain
## points: one sharpness per chain, or one per edge when there are as many
## as edges.
func put_creases(stage: Stage*, build: const MeshBuild*, mesh: Mesh*, warnings: Warnings*) -> !:
    let t = stage.tokens
    var pairs = Growing[i32]()
    defer pairs.close()
    var sharpness = Growing[f32]()
    defer sharpness.close()
    for index in 0..<build.sources.count:
        let source = &build.sources.items[index]
        var indices = try stage.value(source.path, t.crease_indices)
        defer indices.release()
        var lengths = try stage.value(source.path, t.crease_lengths)
        defer lengths.release()
        var values = try stage.value(source.path, t.crease_sharpnesses)
        defer values.release()
        if indices.kind != ValueKind.int or lengths.kind != ValueKind.int or not values.array: continue
        let chain_points = ints_of(&indices)
        let chains = ints_of(&lengths)
        var edges: usize = 0
        for length in chains:
            if length > 1: edges += (usize)length - 1
        let per_edge = values.count == edges and values.count != chains.length
        var at: usize = 0
        var edge: usize = 0
        for chain in 0..<chains.length:
            let length = (usize)math.max(0.0, (f64)chains[chain])
            if at + length > chain_points.length: break
            for k in 1..<length:
                let a = chain_points[at + k - 1]
                let b = chain_points[at + k]
                let which = edge if per_edge else chain
                edge += 1
                if a < 0 or b < 0 or (usize)a >= source.point_count or (usize)b >= source.point_count or which >= values.count: continue
                try pairs.push(a + (i32)source.point_base)
                try pairs.push(b + (i32)source.point_base)
                try sharpness.push((f32)read_number(values.bytes(), scalar_of(values.kind), which))
            at += length
    if sharpness.count == 0: return
    let edges = (usize)(try mesh.edge_count())
    var found = Growing[i64]()
    defer found.close()
    var missing: usize = 0
    for at in 0..<sharpness.count:
        let edge = try mesh.find_edge((i64)pairs.items[at * 2], (i64)pairs.items[at * 2 + 1])
        if edge < 0: missing += 1
        try found.push(edge)
    if missing > 0: try warnings.add("Some creases name edges the mesh does not have; they were dropped")
    # put_attribute takes the attribute, releasing it when it fails.
    var attribute = try Attribute.create("crease", Domain.edge, DataType.float32, 1, edges)
    let out = f32[]((f32*)attribute.data.span().data, edges)
    for at in 0..<edges: out[at] = 0.0
    for at in 0..<found.count:
        let edge = found.items[at]
        if edge >= 0: out[(usize)edge] = (f32)math.max((f64)out[(usize)edge], (f64)sharpness.items[at])
    try put_attribute(mesh, attribute)

## Corner sharpness on points.
func put_corners(stage: Stage*, build: const MeshBuild*, mesh: Mesh*) -> !:
    let t = stage.tokens
    var sharpness = Growing[f32]()
    defer sharpness.close()
    for index in 0..<build.sources.count:
        let source = &build.sources.items[index]
        var indices = try stage.value(source.path, t.corner_indices)
        defer indices.release()
        var values = try stage.value(source.path, t.corner_sharpnesses)
        defer values.release()
        if indices.kind != ValueKind.int or not values.array or values.count != indices.count or values.count == 0: continue
        if sharpness.count == 0: try sharpness.fill(build.points, 0.0)
        let points = ints_of(&indices)
        for at in 0..<points.length:
            if points[at] < 0 or (usize)points[at] >= source.point_count: continue
            sharpness.items[source.point_base + (usize)points[at]] = (f32)read_number(values.bytes(), scalar_of(values.kind), at)
    if sharpness.count == 0: return
    # put_attribute takes the attribute, releasing it when it fails.
    var attribute = try Attribute.create("corner_sharpness", Domain.point, DataType.float32, 1, build.points)
    memory.copy(f32[]((f32*)attribute.data.span().data, build.points), sharpness.view(), build.points)
    try put_attribute(mesh, attribute)

## Hole faces as the face group `hole`.
func put_holes(stage: Stage*, build: const MeshBuild*, mesh: Mesh*) -> !:
    let t = stage.tokens
    var bits = try BitsBuilder.zeros(build.faces)
    defer bits.close()
    var any = false
    for index in 0..<build.sources.count:
        var holes = try stage.value(build.sources.items[index].path, t.hole_indices)
        defer holes.release()
        if holes.kind != ValueKind.int or not holes.array or holes.count == 0: continue
        var faces = Growing[i32]()
        defer faces.close()
        try output_face_map(build, index, &faces)
        for at in ints_of(&holes):
            if at < 0 or (usize)at >= faces.count or faces.items[(usize)at] < 0: continue
            bits.set((usize)faces.items[(usize)at])
            any = true
    if any: try put_attribute(mesh, try Attribute.group_of("hole", Domain.face, build.faces, bits.words()))