Resource revamp

arcade/__init__.py

@@ -397,22 +397,22 @@ def configure_logging(level: Optional[int] = None):
 # Piggyback on pyglet's doc run detection
 if not getattr(sys, 'is_pyglet_doc_run', False):
     # Auto load fonts
-    load_font(":resources:fonts/ttf/Kenney_Blocks.ttf")
-    load_font(":resources:fonts/ttf/Kenney_Future.ttf")
-    load_font(":resources:fonts/ttf/Kenney_Future_Narrow.ttf")
-    load_font(":resources:fonts/ttf/Kenney_High.ttf")
-    load_font(":resources:fonts/ttf/Kenney_High_Square.ttf")
-    load_font(":resources:fonts/ttf/Kenney_Mini.ttf")
-    load_font(":resources:fonts/ttf/Kenney_Mini_Square.ttf")
-    load_font(":resources:fonts/ttf/Kenney_Pixel.ttf")
-    load_font(":resources:fonts/ttf/Kenney_Pixel_Square.ttf")
-    load_font(":resources:fonts/ttf/Kenney_Rocket.ttf")
-    load_font(":resources:fonts/ttf/Kenney_Rocket_Square.ttf")
+    load_font(":system:fonts/ttf/Kenney_Blocks.ttf")
+    load_font(":system:fonts/ttf/Kenney_Future.ttf")
+    load_font(":system:fonts/ttf/Kenney_Future_Narrow.ttf")
+    load_font(":system:fonts/ttf/Kenney_High.ttf")
+    load_font(":system:fonts/ttf/Kenney_High_Square.ttf")
+    load_font(":system:fonts/ttf/Kenney_Mini.ttf")
+    load_font(":system:fonts/ttf/Kenney_Mini_Square.ttf")
+    load_font(":system:fonts/ttf/Kenney_Pixel.ttf")
+    load_font(":system:fonts/ttf/Kenney_Pixel_Square.ttf")
+    load_font(":system:fonts/ttf/Kenney_Rocket.ttf")
+    load_font(":system:fonts/ttf/Kenney_Rocket_Square.ttf")
 
     # Load additional game controller mappings to Pyglet
     if not pyglet.options['headless']:
         try:
-            mappings_file = resources.resolve_resource_path(":resources:gamecontrollerdb.txt")
+            mappings_file = resources.resolve(":system:gamecontrollerdb.txt")
             pyglet.input.controller.add_mappings_from_file(mappings_file)
         except AssertionError:
             pass

arcade/__pyinstaller/hook-arcade.py

@@ -20,8 +20,8 @@
 
 datas = [
     (
-        arcade_path / "resources",
-        "./arcade/resources",
+        arcade_path / "resources" / "system",
+        "./arcade/resources/system",
     ),
 ]
 

arcade/background/__init__.py

@@ -4,7 +4,7 @@
 
 import arcade.gl as gl
 from arcade import get_window
-from arcade.resources import resolve_resource_path
+from arcade.resources import resolve
 
 from arcade.background.background_texture import BackgroundTexture
 from arcade.background.background import Background
@@ -29,7 +29,7 @@ def texture_from_file(
 ) -> BackgroundTexture:
     _context = get_window().ctx
 
-    with Image.open(resolve_resource_path(tex_src)).convert("RGBA") as img:
+    with Image.open(resolve(tex_src)).convert("RGBA") as img:
         texture = _context.texture(
             img.size,
             data=img.transpose(Image.Transpose.FLIP_TOP_BOTTOM).tobytes(),

arcade/background/background.py

@@ -30,8 +30,8 @@ def __init__(
 
         if shader is None:
             shader = get_window().ctx.load_program(
-                vertex_shader=":resources:/shaders/background_vs.glsl",
-                fragment_shader=":resources:/shaders/background_fs.glsl",
+                vertex_shader=":system:/shaders/background_vs.glsl",
+                fragment_shader=":system:/shaders/background_fs.glsl",
             )
         self.shader = shader
 

arcade/background/background_texture.py

@@ -3,7 +3,7 @@
 from PIL import Image
 
 import arcade.gl as gl
-from arcade.resources import resolve_resource_path
+from arcade.resources import resolve
 from arcade.window_commands import get_window
 from pyglet.math import Mat3
 from arcade import ArcadeContext
@@ -143,7 +143,7 @@ def from_file(
     ):
         _context = get_window().ctx
 
-        with Image.open(resolve_resource_path(tex_src)).convert("RGBA") as img:
+        with Image.open(resolve(tex_src)).convert("RGBA") as img:
             texture = _context.texture(
                 img.size,
                 data=img.transpose(Image.Transpose.FLIP_TOP_BOTTOM).tobytes(),

arcade/cache/hit_box.py

@@ -15,7 +15,7 @@
 from collections import OrderedDict
 
 from arcade.types import PointList
-from arcade.resources import resolve_resource_path
+from arcade.resources import resolve
 
 if TYPE_CHECKING:
     from arcade import Texture
@@ -102,7 +102,7 @@ def load(self, path: Union[str, Path]) -> None:
 
         if the file extension is ".gz" the file will be compressed.
         """
-        path = resolve_resource_path(path)
+        path = resolve(path)
         if path.suffix == ".gz":
             with gzip.open(path, mode="rb") as fd:
                 data = json.loads(fd.read())

arcade/context.py

@@ -64,59 +64,59 @@ def __init__(self, window: pyglet.window.Window, gc_mode: str = "context_gc", gl
         # FIXME: These pre-created resources needs to be packaged nicely
         #        Just having them globally in the context is probably not a good idea
         self.line_vertex_shader: Program = self.load_program(
-            vertex_shader=":resources:shaders/shapes/line/line_vertex_shader_vs.glsl",
-            fragment_shader=":resources:shaders/shapes/line/line_vertex_shader_fs.glsl",
+            vertex_shader=":system:shaders/shapes/line/line_vertex_shader_vs.glsl",
+            fragment_shader=":system:shaders/shapes/line/line_vertex_shader_fs.glsl",
         )
         self.line_generic_with_colors_program: Program = self.load_program(
-            vertex_shader=":resources:shaders/shapes/line/line_generic_with_colors_vs.glsl",
-            fragment_shader=":resources:shaders/shapes/line/line_generic_with_colors_fs.glsl",
+            vertex_shader=":system:shaders/shapes/line/line_generic_with_colors_vs.glsl",
+            fragment_shader=":system:shaders/shapes/line/line_generic_with_colors_fs.glsl",
         )
         self.shape_element_list_program: Program = self.load_program(
-            vertex_shader=":resources:shaders/shape_element_list_vs.glsl",
-            fragment_shader=":resources:shaders/shape_element_list_fs.glsl",
+            vertex_shader=":system:shaders/shape_element_list_vs.glsl",
+            fragment_shader=":system:shaders/shape_element_list_fs.glsl",
         )
         self.sprite_list_program_no_cull: Program = self.load_program(
-            vertex_shader=":resources:shaders/sprites/sprite_list_geometry_vs.glsl",
-            geometry_shader=":resources:shaders/sprites/sprite_list_geometry_no_cull_geo.glsl",
-            fragment_shader=":resources:shaders/sprites/sprite_list_geometry_fs.glsl",
+            vertex_shader=":system:shaders/sprites/sprite_list_geometry_vs.glsl",
+            geometry_shader=":system:shaders/sprites/sprite_list_geometry_no_cull_geo.glsl",
+            fragment_shader=":system:shaders/sprites/sprite_list_geometry_fs.glsl",
         )
         self.sprite_list_program_no_cull["sprite_texture"] = 0
         self.sprite_list_program_no_cull["uv_texture"] = 1
 
         self.sprite_list_program_cull: Program = self.load_program(
-            vertex_shader=":resources:shaders/sprites/sprite_list_geometry_vs.glsl",
-            geometry_shader=":resources:shaders/sprites/sprite_list_geometry_cull_geo.glsl",
-            fragment_shader=":resources:shaders/sprites/sprite_list_geometry_fs.glsl",
+            vertex_shader=":system:shaders/sprites/sprite_list_geometry_vs.glsl",
+            geometry_shader=":system:shaders/sprites/sprite_list_geometry_cull_geo.glsl",
+            fragment_shader=":system:shaders/sprites/sprite_list_geometry_fs.glsl",
         )
         self.sprite_list_program_cull["sprite_texture"] = 0
         self.sprite_list_program_cull["uv_texture"] = 1
 
         # Shapes
         self.shape_line_program: Program = self.load_program(
-            vertex_shader=":resources:shaders/shapes/line/unbuffered_vs.glsl",
-            fragment_shader=":resources:shaders/shapes/line/unbuffered_fs.glsl",
-            geometry_shader=":resources:shaders/shapes/line/unbuffered_geo.glsl",
+            vertex_shader=":system:shaders/shapes/line/unbuffered_vs.glsl",
+            fragment_shader=":system:shaders/shapes/line/unbuffered_fs.glsl",
+            geometry_shader=":system:shaders/shapes/line/unbuffered_geo.glsl",
         )
         self.shape_ellipse_filled_unbuffered_program: Program = self.load_program(
-            vertex_shader=":resources:shaders/shapes/ellipse/filled_unbuffered_vs.glsl",
-            fragment_shader=":resources:shaders/shapes/ellipse/filled_unbuffered_fs.glsl",
-            geometry_shader=":resources:shaders/shapes/ellipse/filled_unbuffered_geo.glsl",
+            vertex_shader=":system:shaders/shapes/ellipse/filled_unbuffered_vs.glsl",
+            fragment_shader=":system:shaders/shapes/ellipse/filled_unbuffered_fs.glsl",
+            geometry_shader=":system:shaders/shapes/ellipse/filled_unbuffered_geo.glsl",
         )
         self.shape_ellipse_outline_unbuffered_program: Program = self.load_program(
-            vertex_shader=":resources:shaders/shapes/ellipse/outline_unbuffered_vs.glsl",
-            fragment_shader=":resources:shaders/shapes/ellipse/outline_unbuffered_fs.glsl",
-            geometry_shader=":resources:shaders/shapes/ellipse/outline_unbuffered_geo.glsl",
+            vertex_shader=":system:shaders/shapes/ellipse/outline_unbuffered_vs.glsl",
+            fragment_shader=":system:shaders/shapes/ellipse/outline_unbuffered_fs.glsl",
+            geometry_shader=":system:shaders/shapes/ellipse/outline_unbuffered_geo.glsl",
         )
         self.shape_rectangle_filled_unbuffered_program = self.load_program(
-            vertex_shader=":resources:shaders/shapes/rectangle/filled_unbuffered_vs.glsl",
-            fragment_shader=":resources:shaders/shapes/rectangle/filled_unbuffered_fs.glsl",
-            geometry_shader=":resources:shaders/shapes/rectangle/filled_unbuffered_geo.glsl",
+            vertex_shader=":system:shaders/shapes/rectangle/filled_unbuffered_vs.glsl",
+            fragment_shader=":system:shaders/shapes/rectangle/filled_unbuffered_fs.glsl",
+            geometry_shader=":system:shaders/shapes/rectangle/filled_unbuffered_geo.glsl",
         )
         # Atlas shaders
         self.atlas_resize_program: Program = self.load_program(
-            vertex_shader=":resources:shaders/atlas/resize_vs.glsl",
-            geometry_shader=":resources:shaders/atlas/resize_gs.glsl",
-            fragment_shader=":resources:shaders/atlas/resize_fs.glsl",
+            vertex_shader=":system:shaders/atlas/resize_vs.glsl",
+            geometry_shader=":system:shaders/atlas/resize_gs.glsl",
+            fragment_shader=":system:shaders/atlas/resize_fs.glsl",
         )
         self.atlas_resize_program["atlas_old"] = 0  # Configure texture channels
         self.atlas_resize_program["atlas_new"] = 1
@@ -125,8 +125,8 @@ def __init__(self, window: pyglet.window.Window, gc_mode: str = "context_gc", gl
 
         # SpriteList collision resources
         self.collision_detection_program = self.load_program(
-            vertex_shader=":resources:shaders/collision/col_trans_vs.glsl",
-            geometry_shader=":resources:shaders/collision/col_trans_gs.glsl",
+            vertex_shader=":system:shaders/collision/col_trans_vs.glsl",
+            geometry_shader=":system:shaders/collision/col_trans_gs.glsl",
         )
         self.collision_buffer = self.buffer(reserve=1024 * 4)
         self.collision_query = self.query(samples=False, time=False, primitives=True)
@@ -349,12 +349,12 @@ def load_program(
         varyings: Optional[Sequence[str]] = None,
         varyings_capture_mode: str = "interleaved",
     ) -> Program:
-        """Create a new program given a file names that contain the vertex shader and
+        """
+        Create a new program given a file names that contain the vertex shader and
         fragment shader. Note that fragment and geometry shader are optional for
         when transform shaders are loaded.
 
-        This method also supports the ``:resources:`` prefix.
-        It's recommended to use absolute paths, but not required.
+        This method also supports the resource handles.
 
         Example::
 
@@ -380,27 +380,27 @@ def load_program(
                                           Based on these settings the `transform()` method will accept a single
                                           buffer or a list of buffer.
         """
-        from arcade.resources import resolve_resource_path
+        from arcade.resources import resolve
 
-        vertex_shader_src = resolve_resource_path(vertex_shader).read_text()
+        vertex_shader_src = resolve(vertex_shader).read_text()
         fragment_shader_src = None
         geometry_shader_src = None
         tess_control_src = None
         tess_evaluation_src = None
 
-        common_src = [resolve_resource_path(c).read_text() for c in common]
+        common_src = [resolve(c).read_text() for c in common]
 
         if fragment_shader:
-            fragment_shader_src = resolve_resource_path(fragment_shader).read_text()
+            fragment_shader_src = resolve(fragment_shader).read_text()
             fragment_shader_src = self.shader_inc(fragment_shader_src)
 
         if geometry_shader:
-            geometry_shader_src = resolve_resource_path(geometry_shader).read_text()
+            geometry_shader_src = resolve(geometry_shader).read_text()
             geometry_shader_src = self.shader_inc(geometry_shader_src)
 
         if tess_control_shader and tess_evaluation_shader:
-            tess_control_src = resolve_resource_path(tess_control_shader).read_text()
-            tess_evaluation_src = resolve_resource_path(
+            tess_control_src = resolve(tess_control_shader).read_text()
+            tess_evaluation_src = resolve(
                 tess_evaluation_shader
             ).read_text()
             tess_control_src = self.shader_inc(tess_control_src)
@@ -430,9 +430,9 @@ def load_compute_shader(self, path: Union[str, Path], common: Iterable[Union[str
         :param Union[str,pathlib.Path] path: Path to texture
         :param Iterable[Union[str,pathlib.Path]] common: Common source injected into compute shader
         """
-        from arcade.resources import resolve_resource_path
-        path = resolve_resource_path(path)
-        common_src = [resolve_resource_path(c).read_text() for c in common]
+        from arcade.resources import resolve
+        path = resolve(path)
+        common_src = [resolve(c).read_text() for c in common]
         return self.compute_shader(
             source=self.shader_inc(path.read_text()),
             common=common_src,
@@ -460,9 +460,9 @@ def load_texture(
         :param bool flip: Flips the image upside down
         :param bool build_mipmaps: Build mipmaps for the texture
         """
-        from arcade.resources import resolve_resource_path
+        from arcade.resources import resolve
 
-        path = resolve_resource_path(path)
+        path = resolve(path)
 
         image = Image.open(str(path))
 
@@ -493,12 +493,12 @@ def shader_inc(self, source: str) -> str:
 
         :param str source: Shader
         """
-        from arcade.resources import resolve_resource_path
+        from arcade.resources import resolve
         lines = source.splitlines()
         for i, line in enumerate(lines):
             line = line.strip()
             if line.startswith("#include"):
-                path = resolve_resource_path(line.split()[1].replace('"', ""))
+                path = resolve(line.split()[1].replace('"', ""))
                 lines[i] = path.read_text()
         return "\n".join(lines)
 

arcade/experimental/atlas_load_save.py

@@ -18,7 +18,7 @@
 from arcade.texture_atlas.helpers import save_atlas, load_atlas
 
 MODE = 'load'
-RESOURCE_ROOT = arcade.resources.RESOURCE_PATH
+RESOURCE_ROOT = arcade.resources.ASSET_PATH
 DESTINATION = Path.cwd()
 
 texture_paths: List[Path] = []

arcade/experimental/bloom_filter.py

@@ -19,17 +19,17 @@ def __init__(
     ):
         self.shadertoy = Shadertoy.create_from_file(
             (width, height),
-            ":resources:shaders/bloom/bloom_filter_image.glsl"
+            ":system:shaders/bloom/bloom_filter_image.glsl"
         )
         self.fbo = self.shadertoy.ctx.framebuffer(
             color_attachments=[self.shadertoy.ctx.texture((width, height), components=4)]
         )
 
-        self.shadertoy.buffer_a = self.shadertoy.create_buffer_from_file(":resources:shaders/bloom/bloom_filter_a.glsl")
+        self.shadertoy.buffer_a = self.shadertoy.create_buffer_from_file(":system:shaders/bloom/bloom_filter_a.glsl")
         self.shadertoy.buffer_a.program['intensity'] = intensity
         self.shadertoy.buffer_a.channel_0 = self.fbo.color_attachments[0]
 
-        self.shadertoy.buffer_b = self.shadertoy.create_buffer_from_file(":resources:shaders/bloom/bloom_filter_b.glsl")
+        self.shadertoy.buffer_b = self.shadertoy.create_buffer_from_file(":system:shaders/bloom/bloom_filter_b.glsl")
         self.shadertoy.buffer_b.channel_0 = self.shadertoy.buffer_a.texture
 
         self.shadertoy.channel_0 = self.shadertoy.buffer_a.texture

arcade/experimental/lights.py

@@ -95,13 +95,13 @@ def __init__(self, width: int, height: int):
             ),
         ])
         self._light_program = self.ctx.load_program(
-            vertex_shader=":resources:shaders/lights/point_lights_vs.glsl",
-            geometry_shader=":resources:shaders/lights/point_lights_geo.glsl",
-            fragment_shader=":resources:shaders/lights/point_lights_fs.glsl",
+            vertex_shader=":system:shaders/lights/point_lights_vs.glsl",
+            geometry_shader=":system:shaders/lights/point_lights_geo.glsl",
+            fragment_shader=":system:shaders/lights/point_lights_fs.glsl",
         )
         self._combine_program = self.ctx.load_program(
-            vertex_shader=":resources:shaders/lights/combine_vs.glsl",
-            fragment_shader=":resources:shaders/lights/combine_fs.glsl",
+            vertex_shader=":system:shaders/lights/combine_vs.glsl",
+            fragment_shader=":system:shaders/lights/combine_fs.glsl",
         )
         # NOTE: Diffuse buffer created in parent
         self._light_buffer = self.ctx.framebuffer(color_attachments=self.ctx.texture((width, height), components=3))

arcade/experimental/postprocessing.py

@@ -87,8 +87,8 @@ def __init__(self, size: Tuple[int, int], kernel_size=5, sigma=2, multiplier=1,
         self._fbo = self.ctx.framebuffer(color_attachments=color_attachment)
         self._program = self.ctx.load_program(
             # defines=self._create_kernel(),
-            vertex_shader=':resources:shaders/texture_default_projection_vs.glsl',
-            fragment_shader=':resources:shaders/postprocessing/gaussian_blur_x_fs.glsl',
+            vertex_shader=':system:shaders/texture_default_projection_vs.glsl',
+            fragment_shader=':system:shaders/postprocessing/gaussian_blur_x_fs.glsl',
         )
         self._quad_fs = geometry.quad_2d_fs()
 
@@ -113,8 +113,8 @@ def __init__(self, size: Tuple[int, int], kernel_size=5, sigma=2, multiplier=1,
                                                wrap_y=self.ctx.CLAMP_TO_EDGE))
         self._program = self.ctx.load_program(
             # defines=self._create_kernel(),
-            vertex_shader=':resources:shaders/texture_default_projection_vs.glsl',
-            fragment_shader=':resources:shaders/postprocessing/gaussian_blur_y_fs.glsl',
+            vertex_shader=':system:shaders/texture_default_projection_vs.glsl',
+            fragment_shader=':system:shaders/postprocessing/gaussian_blur_y_fs.glsl',
         )
         self._quad_fs = geometry.quad_2d_fs()
 
@@ -182,14 +182,14 @@ def __init__(self,
         self._cb_luma_buffer = self.ctx.framebuffer(color_attachments=[luma_tex])
         # Buffer for the converted luma values
         self._cb_luma_program = self.ctx.load_program(
-            vertex_shader=':resources:shaders/postprocessing/glow_filter_vs.glsl',
-            fragment_shader=':resources:shaders/postprocessing/glow_filter_fs.glsl'
+            vertex_shader=':system:shaders/postprocessing/glow_filter_vs.glsl',
+            fragment_shader=':system:shaders/postprocessing/glow_filter_fs.glsl'
         )
 
         # Program for combining the original buffer and the blurred buffer
         self._combine_program = self.ctx.load_program(
-            vertex_shader=':resources:shaders/texture_default_projection_vs.glsl',
-            fragment_shader=':resources:shaders/postprocessing/gaussian_combine_fs.glsl'
+            vertex_shader=':system:shaders/texture_default_projection_vs.glsl',
+            fragment_shader=':system:shaders/postprocessing/gaussian_combine_fs.glsl'
         )
         self._quad_fs = geometry.quad_2d_fs()