Generate meta data details

Author: duncanspumpkin

loco-graphics-helper/loco_object_helper_panel.py

@@ -26,8 +26,8 @@ def draw(self, context):
             return
         row.prop(object_properties, "object_type")
 
-        if object_properties.object_type == "CAR":
-            self.draw_car_panel(context, layout)
+        if object_properties.object_type == "BODY":
+            self.draw_body_panel(context, layout)
 
         if object_properties.object_type == "BOGIE":
             self.draw_bogie_panel(context, layout)
@@ -43,6 +43,14 @@ def draw_bogie_panel(self, context, layout):
 
         vehicle_properties = context.object.loco_graphics_helper_vehicle_properties
 
+        row.prop(vehicle_properties, "is_clone_bogie")
+        row = layout.row()
+
+        if vehicle_properties.is_clone_bogie:
+            row.prop(vehicle_properties, "index",text="Clone of bogie index:")
+            row = layout.row()
+            return
+
         box = layout.box()
 
         row = box.row()
@@ -67,13 +75,16 @@ def draw_bogie_panel(self, context, layout):
         row.prop(vehicle_properties, "index")
         row = layout.row()
 
+        row.prop(vehicle_properties, "bogie_parent_index")
+        row = layout.row()
+
         row.prop(vehicle_properties, "number_of_animation_frames")
         row = layout.row()
 
         row.prop(vehicle_properties, "rotational_symmetry")
         row = layout.row()
 
-    def draw_car_panel(self, context, layout):
+    def draw_body_panel(self, context, layout):
         scene = context.scene
         general_properties = scene.loco_graphics_helper_general_properties
         row = layout.row()

loco-graphics-helper/operators/vehicle_render_operator.py

@@ -36,18 +36,18 @@ def create_task(self, context):
         self.task_builder.set_palette(self.palette_manager.get_base_palette(
             general_props.palette, general_props.number_of_recolorables, "FULL"))
 
-        cars = [x for x in context.scene.objects if x.loco_graphics_helper_object_properties.object_type == "CAR"]
-        cars = sorted(cars, key=lambda x: x.loco_graphics_helper_vehicle_properties.index)
-        for car_object in cars:
-            self.add_render_angles(car_object)
+        bodies = [x for x in context.scene.objects if x.loco_graphics_helper_object_properties.object_type == "BODY"]
+        bodies = sorted(bodies, key=lambda x: x.loco_graphics_helper_vehicle_properties.index)
+        for body_object in bodies:
+            self.add_render_angles(body_object)
 
-        if cars[0].loco_graphics_helper_vehicle_properties.is_airplane:
+        if bodies[0].loco_graphics_helper_vehicle_properties.is_airplane:
             self.task_builder.set_cast_shadows(
                 True)
             self.task_builder.set_palette(self.palette_manager.get_shadow_palette())
-            self.add_airplane_shadow_render_angles(cars[0])
+            self.add_airplane_shadow_render_angles(bodies[0])
         else:
-            bogies = [x for x in context.scene.objects if x.loco_graphics_helper_object_properties.object_type == "BOGIE"]
+            bogies = [x for x in context.scene.objects if x.loco_graphics_helper_object_properties.object_type == "BOGIE" and not x.loco_graphics_helper_vehicle_properties.is_clone_bogie]
             bogies = sorted(bogies, key=lambda x: x.loco_graphics_helper_vehicle_properties.index)
             for bogie_object in bogies:
                 self.add_render_angles(bogie_object)
@@ -72,10 +72,10 @@ def should_render_feature(self, key, props):
                 return True
         return False
 
-    def add_render_angles(self, car_object):
-        props = car_object.loco_graphics_helper_vehicle_properties
-        is_bogie = car_object.loco_graphics_helper_object_properties.object_type == "BOGIE"
-        target_object = car_object
+    def add_render_angles(self, object):
+        props = object.loco_graphics_helper_vehicle_properties
+        is_bogie = object.loco_graphics_helper_object_properties.object_type == "BOGIE"
+        target_object = object
         animation_frames = props.number_of_animation_frames
         roll_frames = 1 if props.roll_angle == 0 else 3
 
@@ -115,7 +115,7 @@ def add_render_angles(self, car_object):
                         # to the rig (could use anything though that can't render)
                         target_object = bpy.data.objects['Rig']
                     else:
-                        target_object = car_object
+                        target_object = object
 
                     for i in range(num_viewing_angles):
                         if roll_frames != 1:
@@ -140,8 +140,8 @@ def add_render_angles(self, car_object):
                                     frame_index, num_viewing_angles, i, 0, rotation_range, target_object)
                                 self.task_builder.set_layer("Editor")
 
-    def add_airplane_shadow_render_angles(self, car_object):
-        props = car_object.loco_graphics_helper_vehicle_properties
+    def add_airplane_shadow_render_angles(self, object):
+        props = object.loco_graphics_helper_vehicle_properties
 
         track_sections = track_angle_sections["VEHICLE_SPRITE_FLAG_FLAT"]
         for track_section in track_sections:
@@ -165,5 +165,5 @@ def add_airplane_shadow_render_angles(self, car_object):
                 self.task_builder.set_layer("Top Down Shadow")
                 frame_index = start_output_index + i
                 self.task_builder.add_frame(
-                    frame_index, num_viewing_angles, i, 0, rotation_range, car_object)
+                    frame_index, num_viewing_angles, i, 0, rotation_range, object)
                 self.task_builder.set_layer("Editor")

loco-graphics-helper/properties/object_properties.py

@@ -21,8 +21,8 @@ def object_type_update_func(self, context):
         props.braking_lights = False
         props.is_airplane = False
 
-    # Reset to default for cars
-    if object.loco_graphics_helper_object_properties.object_type == "CAR":
+    # Reset to default for bodies
+    if object.loco_graphics_helper_object_properties.object_type == "BODY":
         props = object.loco_graphics_helper_vehicle_properties
         props.flat_viewing_angles = "64"
         props.sloped_viewing_angles = "32"
@@ -33,7 +33,7 @@ class ObjectProperties(bpy.types.PropertyGroup):
         name="Object Type",
         items=(
             ("NONE", "None", "", 0),
-            ("CAR", "Car", "", 1),
+            ("BODY", "Body", "", 1),
             ("BOGIE", "Bogie", "", 2),
             ("CARGO", "Cargo", "", 3),
         ),

loco-graphics-helper/properties/vehicle_properties.py

@@ -87,8 +87,8 @@ class VehicleProperties(bpy.types.PropertyGroup):
         min=0) 
 
     index = bpy.props.IntProperty(
-        name="Car/Bogie Index",
-        description="Controls the order of the cars/bogies",
+        name="Body/Bogie Index",
+        description="Controls the order of the bodies/bogies",
         default=1,
         min=1)
 
@@ -116,6 +116,18 @@ class VehicleProperties(bpy.types.PropertyGroup):
         default=False
     )
 
+    is_clone_bogie = bpy.props.BoolProperty(
+        name="Is a clone of another bogie",
+        description="If a bogie clone will not be rendered and here just for show/location data",
+        default=False
+    )
+
+    bogie_parent_index = bpy.props.IntProperty(
+        name="Parent Body Index",
+        description="Set to the parent body index",
+        default=1,
+        min=1)
+
 
 def register_vehicles_properties():
     bpy.types.Object.loco_graphics_helper_vehicle_properties = bpy.props.PointerProperty(

loco-graphics-helper/rct_graphics_helper_panel.py

@@ -8,8 +8,9 @@
 '''
 
 import bpy
-import math
+#import math
 import os
+from mathutils import Vector
 
 from .operators.init_operator import Init
 
@@ -237,39 +238,123 @@ def get_number_of_sprites(object):
             num_sprites = num_sprites + int(props.flat_viewing_angles) * multiplier / 2
         return int(num_sprites)
 
+    @staticmethod
+    def get_min_max_x_bound_box_corners(object):
+        bbox_corners = [object.matrix_world * Vector(corner) for corner in object.bound_box]
+        min_x = min([x[0] for x in bbox_corners])
+        max_x = max([x[0] for x in bbox_corners])
+        return (min_x, max_x)
+
+    @staticmethod
+    def get_longest_component_edge(front, back, body):
+        mins = []
+        maxs = []
+        if not front is None:
+            min_x, max_x = GraphicsHelperPanel.get_min_max_x_bound_box_corners(front)
+            mins.append(min_x)
+            maxs.append(max_x)
+
+        if not back is None:
+            min_x, max_x = GraphicsHelperPanel.get_min_max_x_bound_box_corners(back)
+            mins.append(min_x)
+            maxs.append(max_x)
+        
+        body_min_x, body_max_x = GraphicsHelperPanel.get_min_max_x_bound_box_corners(body)
+        mins.append(body_min_x)
+        maxs.append(body_max_x)
+
+        min_x = body.location[0] - min(mins)
+        max_x = max(maxs) - body.location[0]
+        return max(min_x, max_x)
+
+    @staticmethod
+    def get_bogie_position_from_component(bogie, body, half_width):
+        body_x = body.location[0]
+        bogie_x = bogie.location[0]
+        position_from_centre = max(body_x, bogie_x) - min(body_x, bogie_x)
+        return half_width - position_from_centre
+
+    @staticmethod 
+    def get_car_components(bogies, bodies):
+        components = []
+        for body in bodies:
+            component_bogies = [x for x in bogies if x.loco_graphics_helper_vehicle_properties.bogie_parent_index == body.loco_graphics_helper_vehicle_properties.index]
+            if len(component_bogies) != 2:
+                components.append((None, None, body))
+                continue
+            
+            front_bogie = component_bogies[0] if component_bogies[0].location[0] > component_bogies[1].location[0] else component_bogies[1]
+            back_bogie = component_bogies[1] if component_bogies[0].location[0] > component_bogies[1].location[0] else component_bogies[0]
+
+            components.append((front_bogie, back_bogie, body))
+        return components
+
+    @staticmethod
+    def blender_to_loco_dist(dist):
+        return int(dist * 32 + 0.5)
+
     def draw_vehicle_panel(self, scene, layout):
         general_properties = scene.loco_graphics_helper_general_properties
-        cars = [x for x in scene.objects if x.loco_graphics_helper_object_properties.object_type == "CAR"]
-        cars = sorted(cars, key=lambda x: x.loco_graphics_helper_vehicle_properties.index)
+        bodies = [x for x in scene.objects if x.loco_graphics_helper_object_properties.object_type == "BODY"]
+        bodies = sorted(bodies, key=lambda x: x.loco_graphics_helper_vehicle_properties.index)
         bogies = [x for x in scene.objects if x.loco_graphics_helper_object_properties.object_type == "BOGIE"]
         bogies = sorted(bogies, key=lambda x: x.loco_graphics_helper_vehicle_properties.index)
 
         total_number_of_sprites = 0
 
-        if len(cars) > 0:
+        components = self.get_car_components(bogies, bodies)
+        if len(components) > 0:     
             row = layout.row()
             row.label("Car(s) details:")
-            for idx, car in enumerate(cars):
+
+            for component in components:
+                front, back, body = component
+                idx = body.loco_graphics_helper_vehicle_properties.index
+                half_width = self.get_longest_component_edge(front, back, body)
+
+                front_position = 0
+                back_position = 0
+                front_idx = 255
+                back_idx = 255
+
+                if not front is None:
+                    front_position = self.get_bogie_position_from_component(front, body, half_width)
+                    back_position = self.get_bogie_position_from_component(back, body, half_width)
+
+                    front_idx = front.loco_graphics_helper_vehicle_properties.index - 1
+                    back_idx = back.loco_graphics_helper_vehicle_properties.index - 1
+                
+                row = layout.row()
+                row.label(" {}. {}, Half-Width: {}, Front Position: {}, Back Position: {}".format(idx, body.name, self.blender_to_loco_dist(half_width), self.blender_to_loco_dist(front_position), self.blender_to_loco_dist(back_position)))
                 row = layout.row()
-                number_of_sprites = self.get_number_of_sprites(car)
-                row.label(" {}. {}, Number of sprites: {}".format(idx + 1, car.name, number_of_sprites))
+                row.label("    Body Sprite Index: {}, Front Bogie Sprite Index: {}, Back Bogie Sprite Index: {},".format(idx - 1, front_idx, back_idx))
+
+        if len(bodies) > 0:
+            row = layout.row()
+            row.label("Body(s) details:")
+            for idx, body in enumerate(bodies):
+                row = layout.row()
+                number_of_sprites = self.get_number_of_sprites(body)
+                row.label(" {}. {}, Number of sprites: {}".format(idx + 1, body.name, number_of_sprites))
                 total_number_of_sprites = total_number_of_sprites + number_of_sprites
 
         if len(bogies) > 0:
             row = layout.row()
             row.label("Bogie(s) details:")
             for idx, bogie in enumerate(bogies):
                 row = layout.row()
-                number_of_sprites = self.get_number_of_sprites(bogie)
+                number_of_sprites = 0
+                if not bogie.loco_graphics_helper_vehicle_properties.is_clone_bogie:
+                    number_of_sprites = self.get_number_of_sprites(bogie)
+                    total_number_of_sprites = total_number_of_sprites + number_of_sprites
                 row.label(" {}. {}, Number of sprites: {}".format(idx + 1, bogie.name, number_of_sprites))
-                total_number_of_sprites = total_number_of_sprites + number_of_sprites
 
         row = layout.row()
         row.label("Total number of sprites: {}".format(total_number_of_sprites))
 
         if total_number_of_sprites == 0:
             row = layout.row()
-            row.label("NO CARS OR BOGIES SET!")
+            row.label("NO BODIES OR BOGIES SET!")
             row = layout.row()
             row.label("NOTHING WILL BE RENDERED!")