Added Asset manager and other improvements

shader loading
wireframe toggle
Fixed upside-down crosshair render and texture
Crosshair negative over background
updated crosshair image in atlas
Color blend attribute presets

Author: nb-programmer

README.md

@@ -50,6 +50,7 @@ F3|Toggle visibility of debug view
 Shift+F3|Connect to Panda3D's PStats tool for profiling
 F5|Change camera mode from one of [Free, First Person or Third Person]
 F6|Toggle your control between camera and the Vehicle
+F8|Toggle wireframe render
 F11|Toggle fullscreen
 v|Show/hide all buffers
 `\`|Dump current simulator state to console

dronesim/app/asset_manager.py

@@ -1,10 +1,14 @@
 
 from direct.showbase.Loader import Loader
-from panda3d.core import FileStream, VirtualFileSystem
+from panda3d.core import (
+    VirtualFileSystem,
+    Filename,
+    Shader
+)
 from dronesim.types import PandaFilePath
 
 import json
-from typing import Optional
+from typing import Optional, Callable, Dict, Any
 
 
 class VFSFileReaderMixin:
@@ -25,21 +29,51 @@ def read_file(cls, file_path: PandaFilePath, vfs: Optional[VirtualFileSystem] =
             with open(file_path, 'rb') as f:
                 return f.read()
 
+def read_json_file(assets_file: PandaFilePath, vfs: Optional[VirtualFileSystem] = None):
+    asset_conf = AnyFileReaderMixin.read_file(assets_file, vfs)
+    return json.loads(asset_conf)
 
-class JSONLoader(AnyFileReaderMixin):
-    @classmethod
-    def load(cls, loader: Loader, assets_file: PandaFilePath, vfs: Optional[VirtualFileSystem] = None):
-        # try:
-        data = cls.read_file(assets_file, vfs)
-        assets_config: dict = json.loads(data)
 
+def loader_load_shader(cfg: dict, loader: Loader):
+    shader_program_language = Shader.SL_GLSL
+    vertex_path: Filename = Filename(cfg.get('vertex_path', ''))
+    fragment_path: Filename = Filename(cfg.get('fragment_path', ''))
+    geometry_path: Filename = Filename(cfg.get('geometry_path', ''))
+
+    shader_program = Shader.load(
+        shader_program_language,
+        vertex=vertex_path,
+        fragment=fragment_path,
+        geometry=geometry_path
+    )
+
+    return shader_program
+
+
+ASSET_LOADERS: Dict[str, Callable[[dict, Loader], Any]] = {
+    'shader': loader_load_shader
+}
+
+class AssetHolder(dict):
+    def __init__(selfs):
+        super().__init__()
+
+    def load_from_config(self, assets_file: PandaFilePath, loader: Loader, vfs: Optional[VirtualFileSystem] = None):
+        self.load(read_json_file(assets_file, vfs), loader, vfs)
+
+    def load(self, assets_config: dict, loader: Loader, vfs: Optional[VirtualFileSystem] = None):
         mounts: dict = assets_config.get('mounts', {})
+        config_data: dict = assets_config.get('data', {})
         asset_load: dict = assets_config.get('load', {})
 
-        # TODO
+        for asset_type, asset_items in asset_load.items():
+            load_method = ASSET_LOADERS.get(asset_type)
+            if load_method:
+                for asset_name, asset_config in asset_items.items():
+                    is_enabled: bool = asset_config.pop('enabled', True)
+                    if is_enabled:
+                        asset = load_method(asset_config, loader)
+                        self[asset_name] = asset
 
-        # print("mounts:", mounts)
-        # print("load:", asset_load)
 
-        # except OSError:
-        #     pass
+GLOBAL_ASSET_HOLDER = AssetHolder()

dronesim/app/attrib_presets.py

@@ -0,0 +1,20 @@
+
+from panda3d.core import (
+    LColor,
+    ColorBlendAttrib
+)
+COLOR_BLEND_INVERT = ColorBlendAttrib.make(
+    ColorBlendAttrib.M_subtract,
+    ColorBlendAttrib.O_constant_color, ColorBlendAttrib.O_one,
+    LColor(0.5,0.5,0.5,0)
+)
+
+# COLOR_BLEND_INVERT = ColorBlendAttrib.make(
+#     rgb_mode=ColorBlendAttrib.M_max,
+#     rgb_a=ColorBlendAttrib.OOne,
+#     rgb_b=ColorBlendAttrib.O_one_minus_incoming_color,
+
+#     alpha_mode = ColorBlendAttrib.M_max,
+#     alpha_a=ColorBlendAttrib.OOne,
+#     alpha_b=ColorBlendAttrib.O_one_minus_incoming_alpha
+# )

dronesim/app/hud.py

@@ -11,6 +11,8 @@
 from direct.gui.DirectGui import DirectFrame, OnscreenImage
 from typing import Optional, Tuple
 
+from .attrib_presets import COLOR_BLEND_INVERT
+
 
 # TODO: Cleanup required
 
@@ -28,18 +30,28 @@ def __init__(self, parent: Optional[NodePath] = None, **kwargs):
         super().__init__(parent=parent, **kwargs)
 
 class Crosshair(NodePath):
-    # Coord system is (left, right, bottom, top), and defines the bounds of the card
-    FRAME_RANGE_DEFAULT = (-1,1,-1,1) # Same as using setFrameFullscreenQuad() on the CardMaker
-    TEXTURE_UV_RANGE_DEFAULT = (LTexCoord(0,0), LTexCoord(1,-1))
+    # Coord system of frame is (left, right, bottom, top), and defines the bounds of the card
+    # Texture UV:
+    #   U = X-axis (0=left, 1=right)
+    #   V = Y-axis but from the bottom (1=bottom, 0=top)
+    # So (0,1),(1,0) is the whole texture oriented from top-left to bottom-right.
+
+    TEXTURE_UV_RANGE_DEFAULT = (LTexCoord(0,1), LTexCoord(1,0))
     def __init__(self,
                  name: str,
                  tex: Texture,
-                 frame: Tuple[float,float,float,float] = FRAME_RANGE_DEFAULT,
+                 frame: Optional[Tuple[float,float,float,float]] = None,
                  tex_uv_range: Tuple[LTexCoord,LTexCoord] = TEXTURE_UV_RANGE_DEFAULT):
         super().__init__(name)
         self._ch = CardMaker('cm_%s' % name)
-        self._ch.set_frame(*frame)
+        if frame is None:
+            # Use the whole space (for aspect2d it will fill the window as a best-fit square)
+            self._ch.setFrameFullscreenQuad()
+        else:
+            # Position and size from given bounds
+            self._ch.set_frame(*frame)
         self._ch.set_uv_range(*tex_uv_range)
         self._ch_node = self.attach_new_node(self._ch.generate())
         self._ch_node.set_texture(tex)
-        self._ch_node.set_transparency(TransparencyAttrib.MAlpha)
+        self._ch_node.set_transparency(TransparencyAttrib.M_alpha)
+        self._ch_node.set_attrib(COLOR_BLEND_INVERT)

dronesim/app/sim_app.py

@@ -11,7 +11,8 @@
     Spotlight,
     LPoint3f, LVecBase3f, LPoint4f,
     NodePath, TextNode, SamplerState,
-    LTexCoord,
+    LColor, LTexCoord,
+    RenderModeAttrib,
     PStatClient
 )
 
@@ -29,7 +30,7 @@
 from .hud import HUDFieldMixin, HUDFrame, Crosshair
 from .environment import Panda3DEnvironment
 from .camera_control import FreeCam, FPCamera, TPCamera
-from .asset_manager import JSONLoader
+from .asset_manager import GLOBAL_ASSET_HOLDER
 
 from dronesim.actor import VehicleModel
 
@@ -56,18 +57,7 @@
 """
 loadPrcFileData("", DEFAULT_CONFIG_VARS)
 
-# Instruct the Virtual File System to mount the real 'assets/' folder to the virtual directory '/assets/'
 ASSETS_VFS = VirtualFileSystem.get_global_ptr()
-ASSETS_VFS.mount(
-    VirtualFileMountSystem(Filename.from_os_specific(
-        os.path.join(PACKAGE_BASE, 'assets/')
-    )),
-    '/assets/',
-    VirtualFileSystem.MFReadOnly
-)
-
-# Add virtual assets directory to load models and scenes from to the loader's search path
-getModelPath().prepend_directory('/assets')
 
 # Colors used for some HUD elements as foreground (text color) and background
 HUD_COLORS = dict(
@@ -78,6 +68,23 @@
 LOG = logging.getLogger(__name__)
 
 
+def mount_assets_folder(vfs: VirtualFileSystem = ASSETS_VFS):
+    '''
+    Instruct the Virtual File System to mount the real `assets/` folder to the virtual directory `/assets/`
+    '''
+    vfs.mount(
+        VirtualFileMountSystem(Filename.from_os_specific(
+            os.path.join(PACKAGE_BASE, 'assets/')
+        )),
+        '/assets/',
+        VirtualFileSystem.MFReadOnly
+    )
+
+    # Add virtual assets directory to load models and scenes from to the loader's search path
+    getModelPath().prepend_directory('/assets')
+
+mount_assets_folder()
+
 def objectHUDFormatter(o):
     '''Simple JSON string formatter for various data types'''
     if isinstance(o, enum.Enum):
@@ -315,6 +322,12 @@ def eToggleDebugView(self):
         else:
             self.HUD_debug_info.hide()
 
+    def eToggleWireframe(self):
+        if self.render.getRenderMode() == RenderModeAttrib.M_unchanged:
+            self.render.setRenderModeFilledWireframe(LColor(0,1,0,1))
+        else:
+            self.render.clearRenderMode()
+
     def eConnectPStats(self):
         '''Start connection with Pandas' PStats server, or disconnects from it'''
         self._toggle_pstats_connection()
@@ -427,9 +440,7 @@ def _getMovementControlState(self) -> StepRC:
     # App/UI related
 
     def _init_assets(self):
-        assets = JSONLoader.load(
-            self.loader, self._assets_load_file, ASSETS_VFS)
-        # TODO
+        GLOBAL_ASSET_HOLDER.load_from_config(self._assets_load_file, self.loader, ASSETS_VFS)
 
     def _init_keybinds(self):
         # Buffer viewer keybind
@@ -444,6 +455,7 @@ def _init_keybinds(self):
         self._event_hook.accept("shift-wheel_down", self.eMouseWheelScroll, [-0.25])
         self._event_hook.accept("f1", self.eToggleHUDView)
         self._event_hook.accept("f3", self.eToggleDebugView)
+        self._event_hook.accept("f8", self.eToggleWireframe)
         self._event_hook.accept("shift-f3", self.eConnectPStats)
         self._event_hook.accept("f5", self.eToggleCameraMode)
         self._event_hook.accept("f6", self.eToggleControlMode)
@@ -493,8 +505,8 @@ def _init_hud(self):
         self.HUD_crosshair = Crosshair(
             "player_crosshair",
             crosshair_tex,
-            frame=square_aspect2d_frame(0.015),
-            tex_uv_range=(LTexCoord(4/128,-4/128),LTexCoord(12/128,-12/128))
+            frame=square_aspect2d_frame(0.02),
+            tex_uv_range=(LTexCoord(4/128, 1 - (11/128)), LTexCoord(11/128, 1 - (4/128)))
         )
         self.HUD_crosshair.reparent_to(self.HUD_holder)
 
@@ -525,10 +537,11 @@ def _init_ui(self):
 
     @classmethod
     def formatDictToHUD(cls, d: dict, serializer: Callable[[Any], str] = str, level=0) -> str:
+        INDENT = '  '
         return '\n'.join(
             '%s%s:\n%s' % (
-                ' '*level, k, cls.formatDictToHUD(v, serializer, level+1))
+                INDENT*level, k, cls.formatDictToHUD(v, serializer, level+1))
             if isinstance(v, dict)
-            else (' '*level+k+': '+serializer(v))
+            else ('%s%s: %s' % (INDENT*level, k, serializer(v)))
             for k, v in d.items()
         )

dronesim/assets/assets.json

@@ -25,15 +25,15 @@
             "tex.ui.atlas1": {
                 "path": "/assets/textures/ui_1.png",
                 "options": {
-                    "minfilter": "{SamplerState.FT_nearest}",
-                    "magfilter": "{SamplerState.FT_nearest}"
+                    "minfilter": "{p3dc.SamplerState.FT_nearest}",
+                    "magfilter": "{p3dc.SamplerState.FT_nearest}"
                 },
                 "data": {
                     "hud": {
                         "crosshair": {
                             "uv_range": [
-                                [0.03125, -0.03125],
-                                [0.09375, -0.09375]
+                                [0.03125, 0.90625],
+                                [0.09375, 0.96875]
                             ]
                         }
                     }
@@ -56,7 +56,7 @@
 
         },
         "shader": {
-
+            
         }
     }
 }