Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.9

0.7.9 / src / geometry_set / materials.lucb

## The materials family: material definitions carried with geometry, as a
## library. Each has a path (what a face's `material` attribute names), the
## shader that reads it ("openpbr") and named parameters of one to four
## numbers (colors are three), or of text (an image file a texture reads).
## Merge joins libraries, Group nests them in instances and Blast filters
## them by path; renderers flatten them (`materials_flattened`).
## Geocore does not interpret parameters: shaders own their meaning. Where two
## definitions share a path, the later one wins.

## One named parameter: up to four numbers, or a text value.
pub struct MaterialParameter:
    var name_at: usize
    var name_length: usize
    ## The numbers; `width` of them are used.
    pub var value: f64[4]
    ## How many of the numbers it uses, 1..4.
    pub var width: u8
    ## A text value (empty for numbers): a texture's image file.
    var text_at: usize
    var text_length: usize

## Where one material's path, shader and parameters sit.
struct MaterialRecord:
    var path_at: usize
    var path_length: usize
    var shader_at: usize
    var shader_length: usize
    var first: usize
    var count: usize

## Material definitions with their paths, shaders and parameters: a set's
## materials component, and what flattening a set gathers.
pub struct Materials:
    var records: Growing[MaterialRecord]
    var parameters: Growing[MaterialParameter]
    ## Every path, shader and parameter name, back to back.
    var text: Growing[u8]

    ## No materials.
    pub func init():
        self.records = Growing[MaterialRecord]()
        self.parameters = Growing[MaterialParameter]()
        self.text = Growing[u8]()

    ## How many materials there are.
    pub func count() -> usize:
        return self.records.count

    func slice(at: usize, length: usize) -> str:
        return (str)self.text.items[at..<at + length]

    ## Material `index`'s path, which a face's `material` names.
    pub func path(index: usize) -> str:
        let record = &self.records.items[index]
        return self.slice(record.path_at, record.path_length)

    ## The shader material `index` is for.
    pub func shader(index: usize) -> str:
        let record = &self.records.items[index]
        return self.slice(record.shader_at, record.shader_length)

    ## How many parameters material `index` has.
    pub func parameter_count(index: usize) -> usize:
        return self.records.items[index].count

    ## Parameter `at`'s name.
    pub func parameter_name(index: usize, at: usize) -> str:
        let parameter = &self.parameters.items[self.records.items[index].first + at]
        return self.slice(parameter.name_at, parameter.name_length)

    ## Parameter `at`'s value.
    pub func parameter_value(index: usize, at: usize) -> MaterialParameter:
        return self.parameters.items[self.records.items[index].first + at]

    ## Parameter `at`'s text (empty for numbers).
    pub func parameter_text(index: usize, at: usize) -> str:
        let parameter = &self.parameters.items[self.records.items[index].first + at]
        return self.slice(parameter.text_at, parameter.text_length)

    ## The text of parameter `name` of material `index`; empty when it has none.
    pub func find_text(index: usize, name: str) -> str:
        for at in 0..<self.parameter_count(index):
            if self.parameter_name(index, at) == name: return self.parameter_text(index, at)
        return ""

    ## The value of parameter `name` of material `index`, if it has one.
    pub func find(index: usize, name: str) -> MaterialParameter?:
        for at in 0..<self.parameter_count(index):
            if self.parameter_name(index, at) == name: return self.parameter_value(index, at)
        return none

    ## The last material at `path` (-1 when none is).
    pub func index_of(path: str) -> i64:
        var found: i64 = -1
        for index in 0..<self.count():
            if self.path(index) == path: found = (i64)index
        return found

    func intern(value: str) -> (usize, usize)!:
        let at = self.text.count
        try append_text(&self.text, value)
        return (at, value.length)

    ## Add a material: `names` one per line, `values` four numbers per name
    ## (`widths` how many of them it uses; none: four each), and `texts` one
    ## per line beside the names (a parameter with text is text-valued; an
    ## empty line or none keeps numbers).
    pub func add(path: str, shader: str, names: str, values: const f64[], widths: const u8[]?, texts: str = "") -> !:
        let path_text = try self.intern(path)
        let shader_text = try self.intern(shader)
        let first = self.parameters.count
        var start: usize = 0
        var index: usize = 0
        var text_line: usize = 0
        let bytes = names.bytes
        for at in 0..<bytes.length + 1:
            if at < bytes.length and bytes[at] != 10: continue
            if at > start:
                if index * 4 + 4 > values.length: error(errors.invalid, "a material parameter needs four numbers")
                let name_text = try self.intern((str)bytes[start..<at])
                var value: f64[4] = [values[index * 4], values[index * 4 + 1], values[index * 4 + 2], values[index * 4 + 3]]
                var width: u8 = 4
                if let given = widths: width = given[index]
                var end = text_line
                while end < texts.length and texts.bytes[end] != 10: end += 1
                let text = (str)texts.bytes[text_line..<end] if text_line < texts.length else ""
                text_line = end + 1
                let text_value = try self.intern(text)
                try self.parameters.push(MaterialParameter(name_text.0, name_text.1, value, width, text_value.0, text_value.1))
                index += 1
            start = at + 1
        try self.records.push(MaterialRecord(path_text.0, path_text.1, shader_text.0, shader_text.1, first, index))

    ## Add material `index` of `other`.
    pub func add_from(other: const Materials*, index: usize) -> !:
        var names = Growing[u8]()
        defer names.close()
        var values = Growing[f64]()
        defer values.close()
        var widths = Growing[u8]()
        defer widths.close()
        var texts = Growing[u8]()
        defer texts.close()
        for at in 0..<other.parameter_count(index):
            if at > 0:
                try append_text(&names, "\n")
                try append_text(&texts, "\n")
            try append_text(&names, other.parameter_name(index, at))
            try append_text(&texts, other.parameter_text(index, at))
            let parameter = other.parameter_value(index, at)
            for k in 0..<(usize)4: try values.push(parameter.value[k])
            try widths.push(parameter.width)
        try self.add(other.path(index), other.shader(index), (str)names.view(), values.view(), widths.view(), (str)texts.view())

    ## Add every material of `other`.
    pub func add_all(other: const Materials*) -> !:
        for index in 0..<other.count(): try self.add_from(other, index)

    ## Release the materials.
    pub func close():
        self.records.close()
        self.parameters.close()
        self.text.close()

## Heap storage for a materials component, empty.
pub func new_materials() -> Materials*!:
    return try new Materials() in memory.heap

## The materials family.
pub let materials_component: ComponentType = ComponentType("materials", share_materials, close_materials, materials_size, materials_bytes, materials_bounds, place_materials, join_materials, materials_paths, filter_materials, describe_materials, "", no_trace)

func share_materials(data: const void*) -> void*!:
    let copy = try new_materials()
    copy.add_all((const Materials*)data) catch failure:
        close_materials((void*)copy)
        error(failure.code, failure.message)
    return (void*)copy

func close_materials(data: void*):
    let materials = (Materials*)data
    materials.close()
    free(Materials[](materials, 1)) in memory.heap

func materials_size(data: const void*) -> usize:
    return ((const Materials*)data).count()

func materials_bytes(data: const void*, ids: IdSet*) -> usize!:
    _ = ids
    let materials = (const Materials*)data
    return 64 + materials.records.count * memory.size_of(MaterialRecord) + materials.parameters.count * memory.size_of(MaterialParameter) + materials.text.count

func materials_bounds(data: const void*, matrix: Matrix4, out: Bounds*) -> bool!:
    _ = data
    _ = matrix
    _ = out
    return false

## Definitions have no place: placing shares them.
func place_materials(data: const void*, placement: const Placement*) -> void*!:
    _ = placement
    return try share_materials(data)

func join_materials(first: const void*, second: const void*) -> void*!:
    let joined = try new_materials()
    errdefer close_materials((void*)joined)
    try joined.add_all((const Materials*)first)
    try joined.add_all((const Materials*)second)
    return (void*)joined

func materials_paths(data: const void*, out: TableBuilder*) -> !:
    let materials = (const Materials*)data
    for index in 0..<materials.count(): _ = try out.intern(materials.path(index))

func filter_materials(data: const void*, filter: const PathFilter*, keep: bool) -> void*!:
    let source = (const Materials*)data
    let result = try new_materials()
    errdefer close_materials((void*)result)
    for index in 0..<source.count():
        if filter.matches(source.path(index)) == keep: try result.add_from(source, index)
    return (void*)result

func describe_materials(data: const void*, out: Growing[u8]*) -> !:
    try append_number(out, ((const Materials*)data).count())
    try append_text(out, " materials")

## Every material of `set` and its instances (each prototype once), into `out`.
pub func materials_flattened(set: const GeometrySet*, out: Materials*) -> !:
    if let data = set.find(&materials_component): try out.add_all((const Materials*)data)
    let found = set.find(&instances_component) else return
    let instances = (const Instances*)found
    for index in 0..<instances.prototype_count(): try materials_flattened(instances.prototype(index), out)

extend GeometrySet:
    ## This set with a material at `path` read by `shader`: `names` one per
    ## line, `values` four numbers per name.
    ## `texts`: one per line beside the names, for text-valued parameters
    ## (texture files); empty keeps every parameter numeric.
    pub func with_material(path: str, shader: str, names: str, values: const f64[], texts: str = "") -> interop.Reference[GeometrySet]!:
        let materials = try new_materials()
        if let existing = self.find(&materials_component):
            materials.add_all((const Materials*)existing) catch failure:
                close_materials((void*)materials)
                error(failure.code, failure.message)
        materials.add(path, shader, names, values, none, texts) catch failure:
            close_materials((void*)materials)
            error(failure.code, failure.message)
        return try adopt_set(try self.with_component(&materials_component, (void*)materials))

    ## The paths of every material of the set and its instances, one per line,
    ## in order (later definitions of a path after earlier ones).
    pub func material_paths() -> interop.Owned[str]!:
        var all = Materials()
        defer all.close()
        try materials_flattened(&self, &all)
        var text = Growing[u8]()
        defer text.close()
        for index in 0..<all.count():
            if index > 0: try append_text(&text, "\n")
            try append_text(&text, all.path(index))
        return try interop.copy_text((str)text.view())

    ## This set with every material of `other` and its instances added after
    ## its own (later definitions win): how Assign Material passes its library on.
    pub func with_materials_from(other: interop.Reference[GeometrySet]) -> interop.Reference[GeometrySet]!:
        let materials = try new_materials()
        if let existing = self.find(&materials_component):
            materials.add_all((const Materials*)existing) catch failure:
                close_materials((void*)materials)
                error(failure.code, failure.message)
        let source = other.get() catch failure:
            close_materials((void*)materials)
            error(failure.code, failure.message)
        materials_flattened(source, materials) catch failure:
            close_materials((void*)materials)
            error(failure.code, failure.message)
        return try adopt_set(try self.with_component(&materials_component, (void*)materials))