mirror of
https://github.com/google/pebble.git
synced 2025-03-15 08:41:21 +00:00
117 lines
4.9 KiB
Python
117 lines
4.9 KiB
Python
# Copyright 2024 Google LLC
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
from waflib import Node, Task, TaskGen
|
|
|
|
from resources.resource_map import resource_generator
|
|
from resources.resource_map.resource_generator_js import JsResourceGenerator
|
|
from resources.types.resource_definition import StorageType
|
|
from resources.types.resource_object import ResourceObject
|
|
from resources.types.resource_ball import ResourceBall
|
|
|
|
|
|
class reso(Task.Task):
|
|
def run(self):
|
|
reso = resource_generator.generate_object(self, self.definition)
|
|
reso.dump(self.outputs[0])
|
|
|
|
|
|
@Task.update_outputs
|
|
class resource_ball(Task.Task):
|
|
def run(self):
|
|
resos = [ResourceObject.load(r.abspath()) for r in self.inputs]
|
|
resource_id_mapping = getattr(self.env, 'RESOURCE_ID_MAPPING', {})
|
|
|
|
ordered_resos = []
|
|
|
|
# Sort the resources into an ordered list by storage. Don't just use sorted
|
|
# because we want to preserve the ordering within the storage type. If a
|
|
# resource id mapping exists, use that to sort the resources instead.
|
|
if not resource_id_mapping:
|
|
for s in [StorageType.pbpack, StorageType.builtin, StorageType.pfs]:
|
|
ordered_resos.extend((o for o in resos if o.definition.storage == s))
|
|
else:
|
|
resos_dict = {resource_id_mapping[reso.definition.name]: reso for reso in resos}
|
|
ordered_resos = [resos_dict[x] for x in range(1, len(resos) + 1)]
|
|
|
|
res_ball = ResourceBall(ordered_resos, getattr(self, 'resource_declarations', []))
|
|
res_ball.dump(self.outputs[0])
|
|
|
|
|
|
def process_resource_definition(task_gen, resource_definition):
|
|
"""
|
|
Create a task that generates a .reso and returns the node pointing to
|
|
the output
|
|
"""
|
|
|
|
sources = []
|
|
for s in resource_definition.sources:
|
|
source_node = task_gen.path.make_node(s)
|
|
if source_node is None:
|
|
task_gen.bld.fatal("Could not find resource at %s" %
|
|
task_gen.bld.path.find_node(s).abspath())
|
|
sources.append(source_node)
|
|
|
|
output_name = '%s.%s.%s' % (sources[0].relpath(), str(resource_definition.name), 'reso')
|
|
|
|
# Build our outputs in a directory relative to where our final pbpack is going to go
|
|
output = task_gen.resource_ball.parent.make_node(output_name)
|
|
|
|
task = task_gen.create_task('reso', sources, output)
|
|
task.definition = resource_definition
|
|
task.dep_nodes = getattr(task_gen, 'resource_dependencies', [])
|
|
|
|
# Save JS bytecode filename for dependency calculation for SDK memory report
|
|
if resource_definition.type == 'js' and 'PEBBLE_SDK_ROOT' in task_gen.env:
|
|
task_gen.bld.all_envs[task_gen.env.PLATFORM_NAME].JS_RESO = output
|
|
|
|
return output
|
|
|
|
|
|
@TaskGen.feature('generate_resource_ball')
|
|
@TaskGen.before_method('process_source', 'process_rule')
|
|
def process_resource_ball(task_gen):
|
|
"""
|
|
resources: a list of ResourceDefinitions objects and nodes pointing to
|
|
.reso files
|
|
resource_dependencies: node list that all our generated resources depend on
|
|
resource_ball: a node to where the ball should be generated
|
|
vars: a list of environment variables that generated resources should depend on as a source
|
|
"""
|
|
resource_objects = []
|
|
bundled_resos = []
|
|
|
|
for r in task_gen.resources:
|
|
if isinstance(r, Node.Node):
|
|
# It's already a node, presumably pointing to a .reso file
|
|
resource_objects.append(r)
|
|
else:
|
|
# It's a resource definition, we need to process it into a .reso
|
|
# file. Note this is where the task that does the data conversion
|
|
# gets created.
|
|
processed_resource = process_resource_definition(task_gen, r)
|
|
resource_objects.append(processed_resource)
|
|
bundled_resos.append(processed_resource)
|
|
|
|
if getattr(task_gen, 'project_resource_ball', None):
|
|
prb_task = task_gen.create_task('resource_ball',
|
|
bundled_resos,
|
|
task_gen.project_resource_ball)
|
|
prb_task.dep_node = getattr(task_gen, 'resource_dependencies', [])
|
|
prb_task.dep_vars = getattr(task_gen, 'vars', [])
|
|
|
|
task = task_gen.create_task('resource_ball', resource_objects, task_gen.resource_ball)
|
|
task.resource_declarations = getattr(task_gen, 'resource_declarations', [])
|
|
task.dep_nodes = getattr(task_gen, 'resource_dependencies', [])
|
|
task.dep_vars = getattr(task_gen, 'vars', [])
|