375 lines
10 KiB
Python
375 lines
10 KiB
Python
# SPDX-FileCopyrightText: 2018-2023 Blender Authors
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
|
|
"""
|
|
Example Usage
|
|
=============
|
|
|
|
Command line::
|
|
|
|
./blender.bin \
|
|
icon_file.blend --background --python ./release/datafiles/blender_icons_geom.py -- \
|
|
--output-dir=./release/datafiles/blender_icons_geom
|
|
|
|
Icon Format
|
|
===========
|
|
|
|
This is a simple binary format (all bytes, so no endian).
|
|
|
|
The header is 8 bytes:
|
|
|
|
:0..3: ``VCO``: identifier.
|
|
:4: ``0``: icon file version.
|
|
:5: icon size-x.
|
|
:6: icon size-y.
|
|
:7: icon start-x.
|
|
:8: icon start-y.
|
|
|
|
Icon width and height are for icons that don't use the full byte range
|
|
(so we don't get bad alignment for 48 pixel grid for eg).
|
|
|
|
Start values are currently unused.
|
|
|
|
After the header, the remaining length of the data defines the geometry size.
|
|
|
|
:6 bytes each: triangle (XY) locations.
|
|
:12 bytes each: triangle (RGBA) locations.
|
|
|
|
All coordinates are written, then all colors.
|
|
|
|
Since this is a binary format which isn't intended for general use
|
|
the ``.dat`` file extension should be used.
|
|
"""
|
|
|
|
# This script writes out geometry-icons.
|
|
import bpy
|
|
|
|
# Generic functions
|
|
|
|
OBJECTS_TYPES_MESH_COMPATIBLE = {'CURVE', 'MESH'}
|
|
|
|
|
|
def area_tri_signed_2x_v2(v1, v2, v3):
|
|
return (v1[0] - v2[0]) * (v2[1] - v3[1]) + (v1[1] - v2[1]) * (v3[0] - v2[0])
|
|
|
|
|
|
class TriMesh:
|
|
"""
|
|
Triangulate, may apply other changes here too.
|
|
"""
|
|
__slots__ = ("object", "mesh")
|
|
|
|
def __init__(self, ob):
|
|
self.object = ob
|
|
self.mesh = None
|
|
|
|
def __enter__(self):
|
|
self.mesh = self._tri_copy_from_object(self.object)
|
|
return self.mesh
|
|
|
|
def __exit__(self, *args):
|
|
bpy.data.meshes.remove(self.mesh)
|
|
|
|
@staticmethod
|
|
def _tri_copy_from_object(ob):
|
|
import bmesh
|
|
assert ob.type in OBJECTS_TYPES_MESH_COMPATIBLE
|
|
bm = bmesh.new()
|
|
bm.from_mesh(ob.to_mesh())
|
|
bmesh.ops.triangulate(bm, faces=bm.faces)
|
|
me = bpy.data.meshes.new(ob.name + ".copy")
|
|
bm.to_mesh(me)
|
|
bm.free()
|
|
ob.to_mesh_clear()
|
|
return me
|
|
|
|
|
|
def object_material_colors(ob):
|
|
material_colors = []
|
|
color_default = (1.0, 1.0, 1.0, 1.0)
|
|
for slot in ob.material_slots:
|
|
material = slot.material
|
|
color = color_default
|
|
if material is not None and material.use_nodes:
|
|
node_tree = material.node_tree
|
|
if node_tree is not None:
|
|
color = next((
|
|
node.outputs[0].default_value[:]
|
|
for node in node_tree.nodes
|
|
if node.type == 'RGB'
|
|
), color_default)
|
|
if min(color) < 0.0 or max(color) > 1.0:
|
|
print(f"Material: {material.name!r} has color out of 0..1 range {color!r}")
|
|
color = tuple(max(min(c, 1.0), 0.0) for c in color)
|
|
material_colors.append(color)
|
|
return material_colors
|
|
|
|
|
|
def object_child_map(objects):
|
|
objects_children = {}
|
|
for ob in objects:
|
|
ob_parent = ob.parent
|
|
# Get the root.
|
|
if ob_parent is not None:
|
|
while ob_parent and ob_parent.parent:
|
|
ob_parent = ob_parent.parent
|
|
if ob_parent is not None:
|
|
objects_children.setdefault(ob_parent, []).append(ob)
|
|
for ob_all in objects_children.values():
|
|
ob_all.sort(key=lambda ob: ob.name)
|
|
return objects_children
|
|
|
|
|
|
def mesh_data_lists_from_mesh(me, material_colors):
|
|
me_loops = me.loops[:]
|
|
me_verts = me.vertices[:]
|
|
me_polys = me.polygons[:]
|
|
|
|
if me.attributes.active_color:
|
|
me_loops_color = me_loops_color_active.data[:]
|
|
else:
|
|
me_loops_color = None
|
|
|
|
tris_data = []
|
|
|
|
for p in me_polys:
|
|
# Note, all faces are handled, backfacing/zero area is checked just before writing.
|
|
material_index = p.material_index
|
|
if material_index < len(material_colors):
|
|
base_color = material_colors[p.material_index]
|
|
else:
|
|
base_color = (1.0, 1.0, 1.0, 1.0)
|
|
|
|
l_sta = p.loop_start
|
|
l_len = p.loop_total
|
|
loops_poly = me_loops[l_sta:l_sta + l_len]
|
|
if me_loops_color is not None:
|
|
color_poly = me_loops_color[l_sta:l_sta + l_len]
|
|
i0 = 0
|
|
i1 = 1
|
|
|
|
# we only write tris now
|
|
assert len(loops_poly) == 3
|
|
|
|
for i2 in range(2, l_len):
|
|
l0 = loops_poly[i0]
|
|
l1 = loops_poly[i1]
|
|
l2 = loops_poly[i2]
|
|
|
|
if me_loops_color is not None:
|
|
c0 = color_poly[i0].color
|
|
c1 = color_poly[i1].color
|
|
c2 = color_poly[i2].color
|
|
else:
|
|
c0 = c1 = c2 = (1.0, 1.0, 1.0, 1.0)
|
|
|
|
v0 = me_verts[l0.vertex_index]
|
|
v1 = me_verts[l1.vertex_index]
|
|
v2 = me_verts[l2.vertex_index]
|
|
|
|
tris_data.append((
|
|
# float depth
|
|
p.center.z,
|
|
# XY coords.
|
|
(
|
|
v0.co.xy[:],
|
|
v1.co.xy[:],
|
|
v2.co.xy[:],
|
|
),
|
|
# RGBA color in sRGB color space.
|
|
(
|
|
color_multiply_and_from_linear_to_srgb(base_color, c0),
|
|
color_multiply_and_from_linear_to_srgb(base_color, c1),
|
|
color_multiply_and_from_linear_to_srgb(base_color, c2),
|
|
),
|
|
))
|
|
i1 = i2
|
|
return tris_data
|
|
|
|
|
|
def color_multiply_and_from_linear_to_srgb(base_color, vertex_color):
|
|
"""
|
|
Return the RGBA color in sRGB and byte format (0-255).
|
|
|
|
base_color and vertex_color are expected in linear space.
|
|
The final color is the product between the base color and the vertex color.
|
|
"""
|
|
import mathutils
|
|
color_linear = [c * b for c, b in zip(vertex_color, base_color)]
|
|
color_srgb = mathutils.Color(color_linear[:3]).from_scene_linear_to_srgb()
|
|
return tuple(round(c * 255) for c in (*color_srgb, color_linear[3]))
|
|
|
|
|
|
def mesh_data_lists_from_objects(ob_parent, ob_children):
|
|
tris_data = []
|
|
|
|
has_parent = False
|
|
if ob_children:
|
|
parent_matrix = ob_parent.matrix_world.copy()
|
|
parent_matrix_inverted = parent_matrix.inverted()
|
|
|
|
for ob in (ob_parent, *ob_children):
|
|
with TriMesh(ob) as me:
|
|
if has_parent:
|
|
me.transform(parent_matrix_inverted @ ob.matrix_world)
|
|
|
|
tris_data.extend(
|
|
mesh_data_lists_from_mesh(
|
|
me,
|
|
object_material_colors(ob),
|
|
)
|
|
)
|
|
has_parent = True
|
|
return tris_data
|
|
|
|
|
|
def write_mesh_to_py(fh, ob, ob_children):
|
|
|
|
def float_as_byte(f, axis_range):
|
|
assert axis_range <= 255
|
|
# -1..1 -> 0..255
|
|
f = (f + 1.0) * 0.5
|
|
f = round(f * axis_range)
|
|
return min(max(f, 0), axis_range)
|
|
|
|
def vert_as_byte_pair(v):
|
|
return (
|
|
float_as_byte(v[0], coords_range_align[0]),
|
|
float_as_byte(v[1], coords_range_align[1]),
|
|
)
|
|
|
|
tris_data = mesh_data_lists_from_objects(ob, ob_children)
|
|
|
|
# 100 levels of Z depth, round to avoid differences from precision error
|
|
# causing different computers to write triangles in more or less random order.
|
|
tris_data.sort(key=lambda data: int(data[0] * 100))
|
|
|
|
if 0:
|
|
# make as large as we can, keeping alignment
|
|
def size_scale_up(size):
|
|
assert size != 0
|
|
while size * 2 <= 255:
|
|
size *= 2
|
|
return size
|
|
|
|
coords_range = (
|
|
size_scale_up(ob.get("size_x")) or 255,
|
|
size_scale_up(ob.get("size_y")) or 255,
|
|
)
|
|
else:
|
|
# disable for now
|
|
coords_range = 255, 255
|
|
|
|
# Pixel size needs to be increased since a pixel needs one extra geom coordinate,
|
|
# if we're writing 32 pixel, align verts to 33.
|
|
coords_range_align = tuple(min(c + 1, 255) for c in coords_range)
|
|
|
|
print("Writing:", fh.name, coords_range)
|
|
|
|
fw = fh.write
|
|
|
|
# Header (version 0).
|
|
fw(b'VCO\x00')
|
|
# Width, Height
|
|
fw(bytes(coords_range))
|
|
# X, Y
|
|
fw(bytes((0, 0)))
|
|
|
|
# Once converted into bytes, the triangle might become zero area
|
|
tri_skip = [False] * len(tris_data)
|
|
for i, (_, tri_coords, _) in enumerate(tris_data):
|
|
tri_coords_as_byte = [vert_as_byte_pair(vert) for vert in tri_coords]
|
|
if area_tri_signed_2x_v2(*tri_coords_as_byte) <= 0:
|
|
tri_skip[i] = True
|
|
continue
|
|
for vert_byte in tri_coords_as_byte:
|
|
fw(bytes(vert_byte))
|
|
for i, (_, _, tri_color) in enumerate(tris_data):
|
|
if tri_skip[i]:
|
|
continue
|
|
for color in tri_color:
|
|
fw(bytes(color))
|
|
|
|
|
|
def create_argparse():
|
|
import argparse
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument(
|
|
"--output-dir",
|
|
dest="output_dir",
|
|
default=".",
|
|
type=str,
|
|
metavar="DIR",
|
|
required=False,
|
|
help="Directory to write icons to.",
|
|
)
|
|
parser.add_argument(
|
|
"--group",
|
|
dest="group",
|
|
default="",
|
|
type=str,
|
|
metavar="GROUP",
|
|
required=False,
|
|
help="Group name to export from (otherwise export all objects).",
|
|
)
|
|
return parser
|
|
|
|
|
|
def main():
|
|
import os
|
|
import sys
|
|
parser = create_argparse()
|
|
if "--" in sys.argv:
|
|
argv = sys.argv[sys.argv.index("--") + 1:]
|
|
else:
|
|
argv = []
|
|
args = parser.parse_args(argv)
|
|
|
|
objects = []
|
|
depsgraph = bpy.context.view_layer.depsgraph
|
|
|
|
if args.group:
|
|
group = bpy.data.collections.get(args.group)
|
|
if group is None:
|
|
print(f"Group {args.group!r} not found!")
|
|
return
|
|
objects_source = group.objects
|
|
del group
|
|
else:
|
|
objects_source = bpy.data.objects
|
|
|
|
for ob in objects_source:
|
|
|
|
# Skip non-mesh objects
|
|
if ob.type not in OBJECTS_TYPES_MESH_COMPATIBLE:
|
|
continue
|
|
|
|
ob_eval = ob.evaluated_get(depsgraph)
|
|
name = ob_eval.name
|
|
|
|
# Skip copies of objects
|
|
if name.rpartition(".")[2].isdigit():
|
|
continue
|
|
|
|
if (not hasattr(ob_eval.data, 'attributes')) or not ob_eval.data.attributes.active_color:
|
|
print("Skipping:", name, "(no vertex colors)")
|
|
continue
|
|
|
|
objects.append((name, ob_eval))
|
|
|
|
objects.sort(key=lambda a: a[0])
|
|
|
|
objects_children = object_child_map(depsgraph.objects)
|
|
|
|
for name, ob in objects:
|
|
if ob.parent:
|
|
continue
|
|
filename = os.path.join(args.output_dir, name + ".dat")
|
|
with open(filename, 'wb') as fh:
|
|
write_mesh_to_py(fh, ob, objects_children.get(ob, []))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|