Add #9: render large scenery objects

Author: oli414

RCT Graphics Helper Addon/rct_graphics_helper/render_task.py

@@ -30,6 +30,41 @@ def mask_layer(layer_index, context):
 def render(context, index):
     bpy.data.scenes['Scene'].render.filepath = get_output_path(context, index)
     bpy.ops.render.render( write_still = True ) 
+    return
+
+def rotate_for_vertical_joint(x, y, modifier = 1):
+    vertical_joint = bpy.data.objects['VerticalJoint']
+    if vertical_joint is None:
+        return False
+    angle = -vertical_joint.rotation_euler[2] * modifier
+    return [round(x * math.cos(angle) - y * math.sin(angle)), round(x * math.sin(angle) + y * math.cos(angle))]
+
+
+def position_cookie_cutter(context, x, y, left, right, enable):
+    cookie_cutter = bpy.data.objects['CookieCutter']
+    if cookie_cutter is None:
+        return False
+    cookie_cutter_floor = bpy.data.objects['CookieCutterFloor']
+    if cookie_cutter_floor is None:
+        return False
+    vertical_joint = bpy.data.objects['VerticalJoint']
+    if vertical_joint is None:
+        return False
+    cookie_cutter_floor.hide_render = not enable
+    angle = vertical_joint.rotation_euler[2]
+    cookie_cutter.location[1] = -(x * math.cos(angle) - y * math.sin(angle)) * 4
+    cookie_cutter.location[0] = -(x * math.sin(angle) + y * math.cos(angle)) * 4
+    cookie_cutter.location[2] = 0
+    
+    cookie_cutter_l = bpy.data.objects['CookieCutterLeft']
+    if cookie_cutter_l is None:
+        return False
+    cookie_cutter_l.hide_render = not left
+    cookie_cutter_r = bpy.data.objects['CookieCutterRight']
+    if cookie_cutter_r is None:
+        return False
+    cookie_cutter_r.hide_render = not right
+    return True
 
 def rotate_rig(context, angle, verAngle=0, bankedAngle=0, midAngle=0):
         object = bpy.data.objects['Rig']
@@ -40,16 +75,33 @@ def rotate_rig(context, angle, verAngle=0, bankedAngle=0, midAngle=0):
         vJoint.rotation_euler = (0,0,math.radians(angle))
         return True
 
-def post_render(context, index):
+def post_render(context, index, crop = True):
     magick_path = "magick"
     output_path = get_output_path(context, index)
 
     palette_path = context.scene.rct_graphics_helper_general_properties.palette_path
-    result = str(subprocess.check_output(magick_path + " \"" + output_path + "\" -fuzz 0 -fill none -opaque rgb(57,59,57)  -quantize RGB -dither FloydSteinberg -define dither:diffusion-amount=30% -remap \"" + palette_path + "\" -colorspace sRGB -bordercolor none -border 1 -trim -format  \"%[fx:page.x - page.width/2] %[fx:page.y - page.height/2]\" -write info: \"" + output_path + "\"", shell=True))
+
+    result = ""
+    if crop:
+        result = str(subprocess.check_output(magick_path + " \"" + output_path + "\" -fuzz 0 -fill none -opaque rgb(57,59,57)  -quantize RGB -dither FloydSteinberg -define dither:diffusion-amount=30% -remap \"" + palette_path + "\" -colorspace sRGB -bordercolor none -border 1 -trim -format  \"%[fx:page.x - page.width/2] %[fx:page.y - page.height/2]\" -write info: \"" + output_path + "\"", shell=True))
+        
+        offset_file = open(get_offset_output_path(context, index), "w")
+        offset_file.write(result[2:][:-1])
+        offset_file.close()
 
-    offset_file = open(get_offset_output_path(context, index), "w")
-    offset_file.write(result[2:][:-1])
-    offset_file.close()
+    else:
+        result = str(subprocess.check_output(magick_path + " \"" + output_path + "\" -fuzz 0 -fill none -opaque rgb(57,59,57)  -quantize RGB -dither FloydSteinberg -define dither:diffusion-amount=30% -remap \"" + palette_path + "\" -colorspace sRGB \"" + output_path + "\"", shell=True))
+        return
+
+def mask(context, base, mask, output, operation = "In"):
+    magick_path = "magick"
+    output_path = get_output_path(context, output)
+    base_path = get_output_path(context, base)
+    mask_path = get_output_path(context, mask)
+
+    result = str(subprocess.check_output(magick_path + " \"" + mask_path + "\" +repage -gravity center \"" + base_path + "\" -compose " + operation + " -composite \"" + output_path + "\"", shell=True))
+    return
+
 
 class AngleSectionTask(object):
     section = None
@@ -64,6 +116,8 @@ class AngleSectionTask(object):
     inverted = False
     context = None
     render_layer = 0
+    width = 1
+    height = 1
 
     def __init__(self, section_in, out_index_start, context):
         self.render_layer = section_in.render_layer
@@ -78,6 +132,11 @@ def __init__(self, section_in, out_index_start, context):
         self.anim_index = 0
         self.status = "CREATED"
         self.context = context
+        self.width = section_in.width
+        self.height = section_in.height
+        self.wx = 0
+        self.wy = 0
+        self.sub_tiles = False
 
     def step(self):
         if self.frame_index == len(self.section):
@@ -100,13 +159,75 @@ def step(self):
         if self.inverted:
             extra_roll = 180
 
+        has_sub_tiles = self.width > 1 or self.height > 1
+
         self.context.scene.frame_set(self.anim_start + self.anim_index)
         rotate_rig(self.context, angle, frame[2], frame[3] + extra_roll, frame[4])
-        render(self.context, self.out_index)
-        post_render(self.context, self.out_index)
 
-        self.out_index += 1
-        self.anim_index += 1
+        if self.sub_tiles:
+            wh = rotate_for_vertical_joint(-1, -1)
+            if wh[0] < 0:
+                wh[0] = 0
+            if wh[1] < 0:
+                wh[1] = 0
+            xy = rotate_for_vertical_joint(self.wx, self.wy)
+            position_cookie_cutter(self.context, self.wx, self.wy, abs(xy[0]) == wh[1] * (self.height - 1), abs(xy[1]) == wh[0] * (self.width - 1), True)
+        else:
+            position_cookie_cutter(self.context, 0, 0, False, False, False)
+
+        output = self.out_index
+        if has_sub_tiles:
+            output = "full" + "_" + str(self.out_index)
+        if has_sub_tiles and self.sub_tiles:
+            output = (self.wy * self.width + self.wx) * frame[1] + self.out_index
+        render(self.context, output)
+        post_render(self.context, output, not has_sub_tiles)
+
+        if self.sub_tiles:
+            if self.wx == self.width - 1:
+                self.wx = 0
+                if self.wy == self.height - 1:
+                    self.wy = 0
+                    self.sub_tiles = False
+                    self.anim_index += 1
+
+                    for i in range(self.width):
+                        for j in range(self.height):
+                            index = (j * self.width + i) * frame[1] + self.out_index
+                            mask(self.context, index, index, "c_" + str(index), "Dst")
+
+                    for i in range(self.width):
+                        for j in range(self.height):
+                            posx =  rotate_for_vertical_joint(1, 0)
+                            posy =  rotate_for_vertical_joint(0, 1)
+                            index = (j * self.width + i) * frame[1] + self.out_index
+                            indexx2 = ((j + posx[1]) * self.width + (i + posx[0])) * frame[1] + self.out_index
+                            indexy2 = ((j + posy[1]) * self.width + (i + posy[0])) * frame[1] + self.out_index
+                            if i + posx[0] < self.width and j + posx[1] < self.height and i + posx[0] >= 0 and j + posx[1] >= 0:
+                                mask(self.context, "c_" + str(index), str(indexx2), "c_" + str(index), "Out")
+                            if i + posy[0] < self.width and j + posy[1] < self.height and i + posy[0] >= 0 and j + posy[1] >= 0:
+                                mask(self.context, "c_" + str(index), str(indexy2), "c_" + str(index), "Out")
+
+                    for i in range(self.width):
+                        for j in range(self.height):
+                            index = (j * self.width + i) * frame[1] + self.out_index
+                            mask(self.context, "c_" + str(index), "full" + "_" + str(self.out_index), index, "Dst_In")
+                            os.remove(get_output_path(self.context, "c_" + str(index)))
+                            post_render(self.context, index)
+                            
+                    self.out_index += 1
+                else:
+                    self.wy += 1
+            else:
+                self.wx += 1
+        else:
+            if has_sub_tiles:
+                if not self.sub_tiles:
+                    self.sub_tiles = True
+            else:
+                self.anim_index += 1
+                self.out_index += 1
+
         if self.anim_index == self.anim_count:
             self.anim_index = 0
             self.sub_index += 1
@@ -125,12 +246,16 @@ class RenderTaskSection(object):
     render_layer = 0
     anim_frame_index = 0
     anim_frame_count = 1
-    def __init__(self, angle_section, render_layer = 0, inverted = False, frame_index = 0, frame_count = 1):
+    width = 1
+    height = 1
+    def __init__(self, angle_section, render_layer = 0, inverted = False, frame_index = 0, frame_count = 1, width = 1, height = 1):
         self.angle_section = angle_section
         self.inverted = inverted
         self.render_layer = render_layer
         self.anim_frame_index = frame_index
         self.anim_frame_count = frame_count
+        self.width = width
+        self.height = height
 
 
 class RenderTask(object):
@@ -141,16 +266,18 @@ class RenderTask(object):
     section_task = None
     out_index = 0
     context = None
+    use_antialiasing = False
     def __init__(self, out_index_start, context):
         self.out_index = out_index_start
         self.sections = []
         self.section_index = 0
         self.status = "CREATED"
         self.section_task = None
         self.context = context
+        self.use_antialiasing = context.scene.render.use_antialiasing
 
-    def add(self, angle_section, render_layer = 0, inverted = False, frame_index = 0, frame_count = 1):
-        self.sections.append(RenderTaskSection(angle_section, render_layer, inverted, frame_index, frame_count))
+    def add(self, angle_section, render_layer = 0, inverted = False, frame_index = 0, frame_count = 1, width = 1, height = 1):
+        self.sections.append(RenderTaskSection(angle_section, render_layer, inverted, frame_index, frame_count, width, height))
 
     def step(self):
         if self.section_task is None:
@@ -165,5 +292,6 @@ def step(self):
             self.section_index += 1
 
             if self.section_index == len(self.sections):
+                position_cookie_cutter(self.context, 0, 0, False, False, False)
                 self.status = "FINISHED"
                 return "FINISHED"

RCT Graphics Helper Addon/rct_graphics_helper/static_panel.py

@@ -29,7 +29,7 @@ def execute(self, context):
         self.renderTask = RenderTask(context.scene.rct_graphics_helper_general_properties.out_start_index, context)
 
         for i in range(context.scene.rct_graphics_helper_general_properties.number_of_rider_sets + 1):
-            self.renderTask.add([[ False, context.scene.rct_graphics_helper_static_properties.viewing_angles, 0, 0, 0 ]], i, False, 0, context.scene.rct_graphics_helper_general_properties.number_of_animation_frames)
+            self.renderTask.add([[ False, context.scene.rct_graphics_helper_static_properties.viewing_angles, 0, 0, 0 ]], i, False, 0, context.scene.rct_graphics_helper_general_properties.number_of_animation_frames, self.props.object_width, self.props.object_length)
 
         return super(RenderStatic, self).execute(context)
 
@@ -43,6 +43,17 @@ class StaticProperties(bpy.types.PropertyGroup):
         description = "Number of viewing angles to render for",
         default = 4,
         min = 1)
+        
+    object_width = bpy.props.IntProperty(
+        name = "Object Width",
+        description = "Width of the object in tiles. Only used for large scenery",
+        default = 1,
+        min = 1)
+    object_length = bpy.props.IntProperty(
+        name = "Object Length",
+        description = "Length of the object in tiles. Only used for large scenery",
+        default = 1,
+        min = 1)
 
 
 class StaticPanel(bpy.types.Panel):
@@ -60,6 +71,10 @@ def draw(self, context):
         row = layout.row()
         row.prop(properties, "viewing_angles")
 
+        row = layout.row()
+        row.prop(properties, "object_width")
+        row.prop(properties, "object_length")
+        
         row = layout.row()
         row.operator("render.rct_static", text = "Render Static Object")
 

Sample Models/Pyramid/Pyramid.blend

@@ -0,0 +1 @@
+-482 -272

Sample Models/Pyramid/example output/0.png

@@ -0,0 +1 @@
+-31 -62

Sample Models/Pyramid/example output/0.txt

@@ -0,0 +1 @@
+-96 -112