Asset packer generates function for getting asset by name

src/ttblit/asset/builder.py

@@ -106,7 +106,7 @@ def __call__(self, f):
         @functools.wraps(f)
         def cmd(input_file, input_type, output_file, output_format, symbol_name, force, **kwargs):
             aw = AssetWriter()
-            aw.add_asset(symbol_name, f(input_file, input_type, **kwargs))
+            aw.add_asset(symbol_name, f(input_file, input_type, **kwargs), input_file)
             aw.write(output_format, output_file, force, report=False)
 
         self._commands[self.name] = cmd

src/ttblit/asset/formatters/c.py

@@ -27,14 +27,41 @@ def c_declaration(types, symbol, data=None):
         size=f' = sizeof({symbol})' if data else '',
     )
 
+def c_index(symbol, path):
+    return f'{{"{path}", {symbol}, sizeof({symbol})}}' if path else None
 
-def c_boilerplate(data, include, header=True):
+def c_boilerplate(data, include, header=True, index=None):
     lines = ['// Auto Generated File - DO NOT EDIT!']
+
     if header:
         lines.append('#pragma once')
+    else:
+        lines.append('#include <string>')
+
     lines.append(f'#include <{include}>')
     lines.append('')
     lines.extend(data)
+
+    if (not header) and index:
+        lines.append(textwrap.dedent('''\
+        std::pair<const uint8_t*, uint32_t> get_asset_by_name(const std::string& name) {{
+            struct Entry {{
+                const char *name;
+                const uint8_t *data;
+                uint32_t size;
+            }};
+            static const Entry entries[] = {{
+                {entries}
+            }};
+            for (uint32_t i = 0; i < sizeof(entries)/sizeof(entries[0]); ++i) {{
+                if (name == entries[i].name)
+                    return {{entries[i].data, entries[i].size}};
+            }}
+            return {{nullptr, 0}};
+        }}
+        ''').format(
+            entries=',\n        '.join(index)
+        ))
     return '\n'.join(lines)
 
 
@@ -48,11 +75,12 @@ def c_header(path, fragments):
     return {None: c_boilerplate(fragments[None], include="cstdint", header=True)}
 
 
-@AssetFormatter(components=('hpp', 'cpp'), extensions=('.cpp', '.c'))
-def c_source(symbol, data):
+@AssetFormatter(components=('hpp', 'cpp', 'index'), extensions=('.cpp', '.c'))
+def c_source(symbol, data, path):
     return {
         'hpp': c_declaration('extern const', symbol),
         'cpp': c_declaration('const', symbol, data),
+        'index': c_index(symbol, path)
     }
 
 
@@ -61,5 +89,8 @@ def c_source(path, fragments):
     include = path.with_suffix('.hpp').name
     return {
         'hpp': c_boilerplate(fragments['hpp'], include='cstdint', header=True),
-        'cpp': c_boilerplate(fragments['cpp'], include=include, header=False),
+        'cpp': c_boilerplate(fragments['cpp'],
+                             include=include,
+                             header=False,
+                             index=[x for x in fragments['index'] if x]),
     }

src/ttblit/asset/writer.py

@@ -8,18 +8,18 @@ class AssetWriter:
     def __init__(self):
         self._assets = {}
 
-    def add_asset(self, symbol, data):
+    def add_asset(self, symbol, data, path):
         if symbol in self._assets:
             raise NameError(f'Symbol {symbol} has already been added.')
-        self._assets[symbol] = data
+        self._assets[symbol] = {"data": data, "path":path}
 
     def _sorted(self, sort):
         if sort is None:
             return self._assets.items()
         elif sort == 'symbol':
             return sorted(self._assets.items())
         elif sort == 'size':
-            return sorted(self._assets.items(), key=lambda i: len(i[1]))
+            return sorted(self._assets.items(), key=lambda i: len(i.data[1]))
         else:
             raise ValueError(f"Don't know how to sort by {sort}.")
 
@@ -38,7 +38,7 @@ def _get_format(self, value, path, default='c_header'):
     def write(self, fmt=None, path=None, force=False, report=True, sort=None):
         fmt = self._get_format(fmt, path)
         assets = self._sorted(sort)
-        fragments = [fmt.fragments(symbol, data) for symbol, data in assets]
+        fragments = [fmt.fragments(symbol, asset["data"], asset["path"]) for symbol, asset in assets]
         components = {key: [f[key] for f in fragments] for key in fragments[0]}
         outpaths = []
 
@@ -61,8 +61,8 @@ def write(self, fmt=None, path=None, force=False, report=True, sort=None):
             lines = [
                 f'Formatter: {fmt.name}',
                 'Files:', *(f'    {path}' for path in outpaths),
-                'Assets:', *('    {}: {}'.format(symbol, len(data)) for symbol, data in assets),
-                'Total size: {}'.format(sum(len(data) for symbol, data in assets)),
+                'Assets:', *('    {}: {}'.format(symbol, len(asset["data"])) for symbol, asset in assets),
+                'Total size: {}'.format(sum(len(asset["data"]) for symbol, asset in assets)),
                 '',
             ]
             path.with_name(path.stem + '_report.txt').write_text('\n'.join(lines))

src/ttblit/tool/packer.py

@@ -79,7 +79,7 @@ def run(self, config, output, files, force):
 
             aw.write(options.get('type'), self.destination_path / path.name, force=force)
 
-    def build_assets(self, input_files, working_path, name=None, type=None, prefix=None, **builder_options):
+    def build_assets(self, input_files, working_path, name=None, type=None, prefix=None, index=None, **builder_options):
         if type is None:
             # Glob files all have the same suffix, so we only care about the first one
             try:
@@ -110,7 +110,7 @@ def build_assets(self, input_files, working_path, name=None, type=None, prefix=N
                 input_type=input_type, input_subtype=input_subtype, prefix=prefix
             )
 
-            yield symbol_name, builder.from_file(file, input_subtype, **builder_options)
+            yield symbol_name, builder.from_file(file, input_subtype, **builder_options), index
             logging.info(f' - {typestr} {file} -> {symbol_name}')