Add walls support. Add GXC support. Add assetpack support

Author: oli414

rct-graphics-helper/__init__.py

@@ -12,6 +12,7 @@
 from .properties.preferences import RCTGraphicsHelperPreferences
 from .properties.vehicle_properties import register_vehicles_properties, unregister_vehicles_properties
 from .properties.tiles_properties import register_tiles_properties, unregister_tiles_properties
+from .properties.walls_properties import register_walls_properties, unregister_walls_properties
 from .properties.general_properties import register_general_properties, unregister_general_properties
 from .rct_graphics_helper_panel import GraphicsHelperPanel
 from . import developer_utils
@@ -22,7 +23,7 @@
     "name": "RCT Graphics Helper",
     "description": "Render tool to replicate RCT graphics",
     "author": "Olivier Wervers",
-    "version": (0, 3, 4),
+    "version": (0, 4, 0),
     "blender": (2, 79, 0),
     "location": "Render",
     "support": "COMMUNITY",
@@ -48,6 +49,7 @@ def register():
     register_general_properties()
     register_tiles_properties()
     register_vehicles_properties()
+    register_walls_properties()
 
     print("Registered {} with {} modules".format(
         bl_info["name"], len(modules)))
@@ -62,5 +64,6 @@ def unregister():
     unregister_general_properties()
     unregister_tiles_properties()
     unregister_vehicles_properties()
+    unregister_walls_properties()
 
     print("Unregistered {}".format(bl_info["name"]))

rct-graphics-helper/builders/compositor_builder.py

@@ -115,6 +115,14 @@ def create_metadata_image(self, layers_node):
 
         self.link(layers_node, 15, map_range_node, 0)
 
+        map_range_node_blue = self.create_node("CompositorNodeMapRange")
+        map_range_node_blue.inputs[1].default_value = 0
+        map_range_node_blue.inputs[2].default_value = 255
+        map_range_node_blue.inputs[3].default_value = 0
+        map_range_node_blue.inputs[4].default_value = 1
+
+        self.link(layers_node, 14, map_range_node_blue, 0)
+
         alpha_convert_node = self.create_node("CompositorNodePremulKey")
         alpha_convert_node.mapping = "PREMUL_TO_STRAIGHT"
 
@@ -167,6 +175,7 @@ def create_metadata_image(self, layers_node):
         combine_node = self.create_node("CompositorNodeCombRGBA")
         self.link(map_range_node, 0, combine_node, 0)
         self.link(map_range_node2, 0, combine_node, 1)
+        self.link(map_range_node_blue, 0, combine_node, 2)
 
         self.next_process()
 

rct-graphics-helper/builders/task_builder.py

@@ -40,11 +40,20 @@ def __init__(self):
 
         self.palette = None
 
+        self.offset_x = 0
+        self.offset_y = 0
+
+        self.occlusion_layers = 0
+
         self.task = RenderTask(None)
 
     def set_output_index(self, output_index):
         self.output_index = output_index
 
+    def set_offset(self, offset_x, offset_y):
+        self.offset_x = offset_x
+        self.offset_y = offset_y
+
     # Adds render angles for the given number of viewing angles relative to the currently configured rotation
     def add_viewing_angles(self, number_of_viewing_angles, animation_frame_index=0, animation_frames=1):
 
@@ -58,6 +67,8 @@ def add_viewing_angles(self, number_of_viewing_angles, animation_frame_index=0,
                               self.bank_angle, self.vertical_angle, self.mid_angle)
                 frame.set_multi_tile_size(self.width, self.length)
 
+                frame.set_offset(self.offset_x, self.offset_y)
+
                 frame.set_recolorables(self.recolorables)
 
                 frame.set_layer(self.layer)
@@ -69,6 +80,15 @@ def add_viewing_angles(self, number_of_viewing_angles, animation_frame_index=0,
 
                 frame.animation_frame_index = animation_frame_index + j
 
+                frame.set_occlusion_layers(self.occlusion_layers)
+
+                if self.occlusion_layers > 0:
+                    output_indices = []
+                    for k in range(self.occlusion_layers):
+                        output_indices.append(
+                            start_output_index + k * animation_frames * number_of_viewing_angles + j * number_of_viewing_angles + i)
+                    frame.set_output_indices(output_indices)
+
                 if frame.oversized:
                     output_indices = []
                     for k in range(frame.width * frame.length):
@@ -78,8 +98,12 @@ def add_viewing_angles(self, number_of_viewing_angles, animation_frame_index=0,
 
                 self.angles.append(frame)
 
-        self.output_index += number_of_viewing_angles * \
+        frames = number_of_viewing_angles * \
             animation_frames * self.width * self.length
+        if self.occlusion_layers > 0:
+            frames *= self.occlusion_layers
+            
+        self.output_index += frames
 
     # Sets the number of recolorable materials
     def set_recolorables(self, number_of_recolorables):
@@ -110,7 +134,7 @@ def set_size(self, width, length):
         self.length = length
 
     # Sets the rotation applied to future render angles
-    def set_rotation(self, view_angle, bank_angle, vertical_angle, mid_angle):
+    def set_rotation(self, view_angle, bank_angle=0, vertical_angle=0, mid_angle=0):
         self.view_angle = view_angle
         self.bank_angle = bank_angle
         self.vertical_angle = vertical_angle
@@ -123,6 +147,10 @@ def reset_rotation(self):
         self.vertical_angle = 0
         self.mid_angle = 0
 
+    # Sets the number of occlusion layers
+    def set_occlusion_layers(self, layers):
+        self.occlusion_layers = layers
+
     # Creates a render task with the supplied angles. Clears the buffer for reuse of the task builder
     def create_task(self, context):
         task = self.task
@@ -137,6 +165,10 @@ def clear(self):
         self.width = 1
         self.length = 1
 
+        self.set_offset(0, 0)
+
+        self.set_occlusion_layers(0)
+
         self.recolorables = 0
 
         self.task = RenderTask(None)

rct-graphics-helper/frame.py

@@ -35,10 +35,15 @@ def __init__(self, frame_index, task, view_angle, bank_angle=0, vertical_angle=0
 
         self.animation_frame_index = 0
 
+        self.occlusion_layers = 0
+
         self.use_anti_aliasing = True
         self.anti_alias_with_background = False
         self.maintain_aliased_silhouette = True
 
+        self.offset_x = 0
+        self.offset_y = 0
+
         self.base_palette = None
 
     def get_meta_render_output_path(self, suffix=""):
@@ -62,14 +67,14 @@ def get_quantized_render_output_path(self):
         return os.path.join(self.task.get_temporary_output_folder(), "quantized_{}.png".format(self.frame_index))
 
     def get_final_output_paths(self):
-        if self.oversized:
+        if self.oversized or self.occlusion_layers > 0:
             output_paths = []
             for output_index in self.output_indices:
                 output_paths.append(os.path.join(
-                    self.task.get_output_folder(), "sprite_{}.png".format(output_index)))
+                    self.task.get_output_folder(), "sprites", "sprite_{}.png".format(output_index)))
             return output_paths
         else:
-            return [os.path.join(self.task.get_output_folder(), "sprite_{}.png".format(self.frame_index))]
+            return [os.path.join(self.task.get_output_folder(), "sprites", "sprite_{}.png".format(self.frame_index))]
 
     def prepare_scene(self):
         object = bpy.data.objects['Rig']
@@ -90,6 +95,10 @@ def set_anti_aliasing_with_background(self, use_anti_aliasing, anti_alias_with_b
         self.maintain_aliased_silhouette = ((
             not anti_alias_with_background) or maintain_aliased_silhouette) and use_anti_aliasing
 
+    def set_offset(self, offset_x, offset_y):
+        self.offset_x = offset_x
+        self.offset_y = offset_y
+
     def set_multi_tile_size(self, width, length):
         self.width = width
         self.length = length
@@ -105,9 +114,15 @@ def set_recolorables(self, number_of_recolorables):
     def set_base_palette(self, palette):
         self.base_palette = palette
 
+    def set_occlusion_layers(self, layers):
+        self.occlusion_layers = layers
+
     def set_output_indices(self, indices):
         self.output_indices = indices
 
-        if len(self.output_indices) != self.width * self.length:
+        layers = self.occlusion_layers
+        if layers == 0:
+            layers = 1
+        if len(self.output_indices) != self.width * self.length * layers:
             raise Exception(
-                "The number of output indices does not match the number of expected output sprites for this frame's tile footprint")
+                "The number of output indices does not match the number of expected output sprites for this frame")

rct-graphics-helper/magick_command.py

@@ -36,7 +36,7 @@ def quantize(self, palette, amount):
     def trim(self):
         self.use_repage = True
         self.full_command += \
-            " -bordercolor none -compose Copy -border 1 -trim  -format \"%[fx:page.x - page.width/2] %[fx:page.y - page.height/2]\" -write info:"
+            " -bordercolor none -compose Copy -border 1 -trim  -format \"%[fx:page.x-page.width/2] %[fx:page.y-page.height/2]\" -write info:"
 
     # Sets a number of channels (Red, Green, Blue) to 0
     def nullify_channels(self, channels_to_nullify):
@@ -92,6 +92,12 @@ def set_bit_depth(self, depth):
     def output(self, file):
         self.full_command += " -write PNG8:" + file
 
+    def clone(self):
+        mc = MagickCommand("")
+        mc.full_command = self.full_command
+        mc.use_repage = self.use_repage
+        return mc
+
     # Gets the cli command to perform the ImageMagick operation
 
     def get_command_string(self, magick_path, output):

rct-graphics-helper/operators/init_operator.py

@@ -89,6 +89,7 @@ def create_render_layer(self, context, name):
 
         layer.use_pass_combined = True
         layer.use_pass_material_index = True
+        layer.use_pass_object_index = True
         layer.use_zmask = True
 
         return layer

rct-graphics-helper/operators/render_operator.py

@@ -55,6 +55,9 @@ def execute(self, context):
         bpy.data.cameras["Camera"].ortho_scale = 169.72 / \
             (1920 / context.scene.render.resolution_x)
 
+        bpy.data.cameras["Camera"].shift_x = -0.000345 * \
+            96 / context.scene.render.resolution_x
+
         def finish():
             general_props.rendering = False
             rotate_rig(0, 0, 0, 0)

rct-graphics-helper/operators/vehicle_render_operator.py

@@ -121,38 +121,3 @@ def add_render_angles(self, context, is_inverted=False, animation_frames=1):
                     else:
                         self.task_builder.add_viewing_angles(
                             track_section[1], 0, animation_frames)
-
-    def OLD_append_angles_to_rendertask(self, render_layer, inverted):
-        start_anim = 0
-        """
-        if self.scene.rct_graphics_helper_general_properties.number_of_animation_frames != 1:
-            start_anim = 4
-        anim_count = self.scene.rct_graphics_helper_general_properties.number_of_animation_frames
-        for i in range(len(track_angle_sections_names)):
-            key = track_angle_sections_names[i]
-            track_section = track_angle_sections[key]
-            if self.key_is_property(key):
-                if self.property_value(key):
-                    self.renderTask.add(
-                        track_section, render_layer, inverted, start_anim, anim_count)
-            elif key == "VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TURNS" or key == "VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TRANSITIONS":
-                if self.property_value("SLOPED_TURNS"):
-                    self.renderTask.add(
-                        track_section, render_layer, inverted, start_anim, anim_count)
-            elif key == "VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_WHILE_BANKED_TRANSITIONS":
-                if self.property_value("SLOPED_TURNS") and self.property_value("VEHICLE_SPRITE_FLAG_FLAT_BANKED"):
-                    self.renderTask.add(
-                        track_section, render_layer, inverted, start_anim, anim_count)
-            elif key == "VEHICLE_SPRITE_FLAG_DIAGONAL_GENTLE_SLOPE_BANKED_TRANSITIONS":
-                if self.property_value("SLOPED_TURNS") and self.property_value("VEHICLE_SPRITE_FLAG_DIAGONAL_SLOPES"):
-                    self.renderTask.add(
-                        track_section, render_layer, inverted, start_anim, anim_count)
-            elif key == "VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_BANKED_TRANSITIONS":
-                if self.property_value("VEHICLE_SPRITE_FLAG_FLAT_BANKED") and self.property_value("VEHICLE_SPRITE_FLAG_GENTLE_SLOPES"):
-                    self.renderTask.add(
-                        track_section, render_layer, inverted, start_anim, anim_count)
-            elif key == "VEHICLE_SPRITE_FLAG_RESTRAINT_ANIMATION" and inverted == False:
-                if self.props.restraint_animation:
-                    self.renderTask.add(
-                        track_section, render_layer, inverted, 1, 3)
-        """