e955c94ed3
Listing the "Blender Foundation" as copyright holder implied the Blender Foundation holds copyright to files which may include work from many developers. While keeping copyright on headers makes sense for isolated libraries, Blender's own code may be refactored or moved between files in a way that makes the per file copyright holders less meaningful. Copyright references to the "Blender Foundation" have been replaced with "Blender Authors", with the exception of `./extern/` since these this contains libraries which are more isolated, any changed to license headers there can be handled on a case-by-case basis. Some directories in `./intern/` have also been excluded: - `./intern/cycles/` it's own `AUTHORS` file is planned. - `./intern/opensubdiv/`. An "AUTHORS" file has been added, using the chromium projects authors file as a template. Design task: #110784 Ref !110783.
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()
|