import bpy import webbrowser from bpy.types import Menu, Panel, UIList from bpy.props import * import arm.utils import arm.make as make import arm.make_state as state import arm.assets as assets import arm.log as log import arm.proxy import arm.props_renderpath # Menu in object region class ObjectPropsPanel(bpy.types.Panel): bl_label = "Armory Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "object" def draw(self, context): layout = self.layout obj = bpy.context.object if obj == None: return row = layout.row() row.prop(obj, 'arm_export') if not obj.arm_export: return row.prop(obj, 'arm_spawn') row = layout.row() row.prop(obj, 'arm_mobile') row.prop(obj, 'arm_animation_enabled') if obj.type == 'MESH': layout.prop(obj, 'arm_instanced') if obj.arm_instanced: layout.label('Location') column = layout.column() column.prop(obj, 'arm_instanced_loc_x') column.prop(obj, 'arm_instanced_loc_y') column.prop(obj, 'arm_instanced_loc_z') # layout.label('Rotation') # row = layout.row() # row.prop(obj, 'arm_instanced') # row.prop(obj, 'arm_instanced') # row.prop(obj, 'arm_instanced') # layout.label('Scale') # row = layout.row() # row.prop(obj, 'arm_instanced') # row.prop(obj, 'arm_instanced') # row.prop(obj, 'arm_instanced') wrd = bpy.data.worlds['Arm'] layout.prop_search(obj, "arm_tilesheet", wrd, "arm_tilesheetlist", "Tilesheet") if obj.arm_tilesheet != '': selected_ts = None for ts in wrd.arm_tilesheetlist: if ts.name == obj.arm_tilesheet: selected_ts = ts break layout.prop_search(obj, "arm_tilesheet_action", selected_ts, "arm_tilesheetactionlist", "Action") class ModifiersPropsPanel(bpy.types.Panel): bl_label = "Armory Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "modifier" def draw(self, context): layout = self.layout obj = bpy.context.object if obj == None: return layout.operator("arm.invalidate_cache") # Assume as first modifier if len(obj.modifiers) > 0 and obj.modifiers[0].type == 'OCEAN': layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_base_color') layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_water_color') layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_fade') layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_amplitude') layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_height') layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_choppy') layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_speed') layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_freq') layout.prop(bpy.data.worlds['Arm'], 'arm_ocean_fade') class ParticlesPropsPanel(bpy.types.Panel): bl_label = "Armory Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "particle" def draw(self, context): layout = self.layout obj = bpy.context.particle_system if obj == None: return layout.prop(obj.settings, 'arm_loop') layout.prop(obj.settings, 'arm_gpu_sim') layout.prop(obj.settings, 'arm_count_mult') class PhysicsPropsPanel(bpy.types.Panel): bl_label = "Armory Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "physics" def draw(self, context): layout = self.layout obj = bpy.context.object if obj == None: return if obj.rigid_body != None: # use_deactivation = obj.rigid_body.use_deactivation # layout.prop(obj.rigid_body, 'use_deactivation') # row = layout.row() # row.enabled = use_deactivation # row.prop(obj, 'arm_rb_deactivation_time') layout.prop(obj, 'arm_rb_linear_factor') layout.prop(obj, 'arm_rb_angular_factor') layout.prop(obj, 'arm_rb_trigger') layout.prop(obj, 'arm_rb_terrain') layout.prop(obj, 'arm_rb_force_deactivation') if obj.soft_body != None: layout.prop(obj, 'arm_soft_body_margin') # Menu in data region class DataPropsPanel(bpy.types.Panel): bl_label = "Armory Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "data" def draw(self, context): layout = self.layout obj = bpy.context.object if obj == None: return wrd = bpy.data.worlds['Arm'] if obj.type == 'CAMERA': layout.prop(obj.data, 'arm_frustum_culling') layout.prop(obj.data, 'arm_render_to_texture') col = layout.column() col.enabled = obj.data.arm_render_to_texture row = col.row(align=True) row.label('Resolution') row.prop(obj.data, 'arm_texture_resolution_x') row.prop(obj.data, 'arm_texture_resolution_y') elif obj.type == 'MESH' or obj.type == 'FONT' or obj.type == 'META': row = layout.row(align=True) row.prop(obj.data, 'arm_dynamic_usage') row.prop(obj.data, 'arm_compress') # if obj.type == 'MESH': # layout.prop(obj.data, 'arm_sdfgen') layout.operator("arm.invalidate_cache") elif obj.type == 'LAMP': row = layout.row(align=True) col = row.column() col.prop(obj.data, 'arm_clip_start') col.prop(obj.data, 'arm_clip_end') col = row.column() col.prop(obj.data, 'arm_fov') col.prop(obj.data, 'arm_shadows_bias') if obj.data.type == 'POINT': layout.prop(obj.data, 'arm_omni_shadows') col = layout.column() col.enabled = obj.data.arm_omni_shadows col.prop(wrd, 'arm_pcfsize') layout.prop(wrd, 'arm_lamp_texture') layout.prop(wrd, 'arm_lamp_ies_texture') layout.prop(wrd, 'arm_lamp_clouds_texture') elif obj.type == 'SPEAKER': layout.prop(obj.data, 'arm_play_on_start') layout.prop(obj.data, 'arm_loop') layout.prop(obj.data, 'arm_stream') elif obj.type == 'ARMATURE': layout.prop(obj.data, 'arm_compress') class ScenePropsPanel(bpy.types.Panel): bl_label = "Armory Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "scene" def draw(self, context): layout = self.layout scene = bpy.context.scene if scene == None: return row = layout.row() column = row.column() row.prop(scene, 'arm_export') row.prop(scene, 'arm_compress') # column.prop(scene, 'arm_gp_export') # columnb = column.column() # columnb.enabled = scene.arm_gp_export # columnb.operator('arm.invalidate_gp_cache') class InvalidateCacheButton(bpy.types.Operator): '''Delete cached mesh data''' bl_idname = "arm.invalidate_cache" bl_label = "Invalidate Cache" def execute(self, context): context.object.data.arm_cached = False return{'FINISHED'} class InvalidateMaterialCacheButton(bpy.types.Operator): '''Delete cached material data''' bl_idname = "arm.invalidate_material_cache" bl_label = "Invalidate Cache" def execute(self, context): context.material.is_cached = False return{'FINISHED'} class InvalidateGPCacheButton(bpy.types.Operator): '''Delete cached grease pencil data''' bl_idname = "arm.invalidate_gp_cache" bl_label = "Invalidate GP Cache" def execute(self, context): if context.scene.grease_pencil != None: context.scene.grease_pencil.arm_cached = False return{'FINISHED'} class MaterialPropsPanel(bpy.types.Panel): bl_label = "Armory Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "material" def draw(self, context): layout = self.layout mat = bpy.context.material if mat == None: return row = layout.row() column = row.column() column.prop(mat, 'arm_cast_shadow') column.prop(mat, 'arm_receive_shadow') column.separator() column.prop(mat, 'arm_two_sided') columnb = column.column() columnb.enabled = not mat.arm_two_sided columnb.prop(mat, 'arm_cull_mode') column = row.column() column.prop(mat, 'arm_overlay') column.prop(mat, 'arm_decal') column.separator() column.prop(mat, 'arm_discard') columnb = column.column() columnb.enabled = mat.arm_discard columnb.prop(mat, 'arm_discard_opacity') columnb.prop(mat, 'arm_discard_opacity_shadows') layout.separator() row = layout.row() column = row.column() column.prop(mat, 'arm_tess') columnb = column.column() columnb.enabled = mat.arm_tess columnb.prop(mat, 'arm_tess_inner') columnb.prop(mat, 'arm_tess_outer') column = row.column() column.prop(mat, 'arm_tess_shadows') columnb = column.column() columnb.enabled = mat.arm_tess_shadows columnb.prop(mat, 'arm_tess_shadows_inner') columnb.prop(mat, 'arm_tess_shadows_outer') layout.prop(mat, 'arm_custom_material') layout.prop(mat, 'arm_skip_context') layout.prop(mat, 'arm_material_id') layout.prop(mat, 'arm_billboard') layout.prop(mat, 'arm_particle') if mat.arm_particle == 'gpu': layout.prop(mat, 'arm_particle_fade') row = layout.row() row.prop(mat, 'arm_tilesheet_mat') row.prop(mat, 'arm_blending') layout.operator("arm.invalidate_material_cache") class WorldPropsPanel(bpy.types.Panel): bl_label = "Armory Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "world" def draw(self, context): layout = self.layout wrd = bpy.data.worlds['Arm'] layout.prop(wrd, 'arm_irradiance') row = layout.row() row.enabled = wrd.arm_irradiance column = row.column() column.prop(wrd, 'arm_radiance') columnb = column.column() columnb.enabled = wrd.arm_radiance columnb.prop(wrd, 'arm_radiance_size') column = row.column() column.prop(wrd, 'arm_radiance_sky') class ArmoryPlayerPanel(bpy.types.Panel): bl_label = "Armory Player" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "render" def draw(self, context): layout = self.layout wrd = bpy.data.worlds['Arm'] row = layout.row(align=True) row.alignment = 'EXPAND' if state.playproc == None and state.compileproc == None: row.operator("arm.play", icon="PLAY") else: row.operator("arm.stop", icon="MESH_PLANE") if state.playproc == None and state.krom_running == False: row.operator("arm.build") else: row.operator("arm.patch") row.operator("arm.clean_menu") layout.prop(wrd, 'arm_play_runtime') layout.prop(wrd, 'arm_play_camera') class ArmoryRenderPanel(bpy.types.Panel): bl_label = "Armory Render" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "render" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout row = layout.row(align=True) row.alignment = 'EXPAND' row.operator("arm.render", icon="RENDER_STILL") row.operator("arm.render_anim", icon="RENDER_ANIMATION") layout.prop(bpy.data.worlds['Arm'], "rp_rendercapture_format") if bpy.context.scene != None: layout.prop(bpy.context.scene.render, "filepath") class ArmoryExporterPanel(bpy.types.Panel): bl_label = "Armory Exporter" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "render" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout wrd = bpy.data.worlds['Arm'] row = layout.row(align=True) row.alignment = 'EXPAND' row.operator("arm.build_project") row.operator("arm.patch_project") row.operator("arm.publish_project") row.enabled = wrd.arm_exporterlist_index >= 0 and len(wrd.arm_exporterlist) > 0 rows = 2 if len(wrd.arm_exporterlist) > 1: rows = 4 row = layout.row() row.template_list("ArmExporterList", "The_List", wrd, "arm_exporterlist", wrd, "arm_exporterlist_index", rows=rows) col = row.column(align=True) col.operator("arm_exporterlist.new_item", icon='ZOOMIN', text="") col.operator("arm_exporterlist.delete_item", icon='ZOOMOUT', text="") if wrd.arm_exporterlist_index >= 0 and len(wrd.arm_exporterlist) > 0: item = wrd.arm_exporterlist[wrd.arm_exporterlist_index] layout.prop(item, 'arm_project_target') layout.prop(item, arm.utils.target_to_gapi(item.arm_project_target)) wrd.arm_rpcache_list.clear() # Make UIList work with prop_search() for i in wrd.arm_rplist: wrd.arm_rpcache_list.add().name = i.name layout.prop_search(item, "arm_project_rp", wrd, "arm_rpcache_list", "Render Path") if item.arm_project_scene == '': item.arm_project_scene = bpy.data.scenes[0].name layout.prop_search(item, 'arm_project_scene', bpy.data, 'scenes', 'Scene') class ArmoryProjectPanel(bpy.types.Panel): bl_label = "Armory Project" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "render" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout wrd = bpy.data.worlds['Arm'] row = layout.row(align=True) row.operator("arm.kode_studio") row.operator("arm.open_project_folder") layout.label('Build:') row = layout.row() col = row.column() col.prop(wrd, 'arm_play_console') col.prop(wrd, 'arm_stream_scene') if arm.utils.with_krom(): col.prop(wrd, 'arm_play_live_patch') colb = col.column() colb.enabled = wrd.arm_play_live_patch colb.prop(wrd, 'arm_play_auto_build') col = row.column() col.prop(wrd, 'arm_cache_shaders') col.prop(wrd, 'arm_cache_compiler') col.prop(wrd, 'arm_gpu_processing') layout.label('Flags:') row = layout.row() col = row.column() col.prop(wrd, 'arm_batch_meshes') col.prop(wrd, 'arm_batch_materials') col.prop(wrd, 'arm_sampled_animation') col.prop(wrd, 'arm_dce') col.prop(wrd, 'arm_asset_compression') col = row.column() col.prop(wrd, 'arm_minimize') col.prop(wrd, 'arm_optimize_mesh') col.prop(wrd, 'arm_deinterleaved_buffers') col.prop(wrd, 'arm_export_tangents') layout.label('Window:') row = layout.row() col = row.column() col.prop(wrd, 'arm_vsync') col.prop(wrd, 'arm_loadbar') col.prop(wrd, 'arm_winmode') col = row.column() col.prop(wrd, 'arm_winresize') row = col.row() row.enabled = wrd.arm_winresize row.prop(wrd, 'arm_winmaximize') col.prop(wrd, 'arm_winminimize') layout.prop(wrd, 'arm_winorient') layout.label('Assets:') layout.prop(wrd, 'arm_texture_quality') layout.prop(wrd, 'arm_sound_quality') layout.separator() layout.label('Modules:') layout.prop(wrd, 'arm_audio') layout.prop(wrd, 'arm_physics') layout.prop(wrd, 'arm_navigation') layout.prop(wrd, 'arm_ui') layout.prop(wrd, 'arm_hscript') layout.separator() layout.label('Project:') layout.prop(wrd, 'arm_project_name') layout.prop(wrd, 'arm_project_package') layout.prop_search(wrd, 'arm_khafile', bpy.data, 'texts', 'Khafile') layout.prop_search(wrd, 'arm_khamake', bpy.data, 'texts', 'Khamake') layout.prop(wrd, 'arm_project_root') layout.label('Armory v' + wrd.arm_version) class ArmVirtualInputPanel(bpy.types.Panel): bl_label = "Armory Virtual Input" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "render" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout class ArmNavigationPanel(bpy.types.Panel): bl_label = "Armory Navigation" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "scene" def draw(self, context): layout = self.layout scene = bpy.context.scene if scene == None: return layout.operator("arm.generate_navmesh") class ArmoryGenerateNavmeshButton(bpy.types.Operator): '''Generate navmesh from selected meshes''' bl_idname = 'arm.generate_navmesh' bl_label = 'Generate Navmesh' def execute(self, context): obj = context.active_object if obj == None or obj.type != 'MESH': return{'CANCELLED'} # TODO: build tilecache here # Navmesh trait obj.arm_traitlist.add() obj.arm_traitlist[-1].type_prop = 'Bundled Script' obj.arm_traitlist[-1].class_name_prop = 'NavMesh' # For visualization bpy.ops.mesh.navmesh_make('EXEC_DEFAULT') obj = context.active_object obj.hide_render = True obj.arm_export = False return{'FINISHED'} class ArmoryPlayButton(bpy.types.Operator): '''Launch player in new window''' bl_idname = 'arm.play' bl_label = 'Play' def execute(self, context): if state.compileproc != None: return {"CANCELLED"} if not arm.utils.check_saved(self): return {"CANCELLED"} if not arm.utils.check_sdkpath(self): return {"CANCELLED"} if not arm.utils.check_engine(self): return {"CANCELLED"} arm.utils.check_default_rp() rpdat = arm.utils.get_rp() if rpdat.rp_rendercapture == True: rpdat.rp_rendercapture = False state.is_export = False assets.invalidate_enabled = False make.play_project(False) assets.invalidate_enabled = True return{'FINISHED'} class ArmoryPlayInViewportButton(bpy.types.Operator): '''Launch player in 3D viewport''' bl_idname = 'arm.play_in_viewport' bl_label = 'Play in Viewport' def execute(self, context): if state.compileproc != None: return {"CANCELLED"} if not arm.utils.check_saved(self): return {"CANCELLED"} if not arm.utils.check_sdkpath(self): return {"CANCELLED"} if not arm.utils.check_engine(self): return {"CANCELLED"} if context.area == None: return {"CANCELLED"} arm.utils.check_default_rp() rpdat = arm.utils.get_rp() if rpdat.rp_rendercapture == True: rpdat.rp_rendercapture = False state.is_export = False assets.invalidate_enabled = False if state.playproc == None and state.krom_running == False: if context.area.type != 'VIEW_3D': return {"CANCELLED"} # Cancel viewport render for space in context.area.spaces: if space.type == 'VIEW_3D': if space.viewport_shade == 'RENDERED': space.viewport_shade = 'SOLID' break make.play_project(True) else: make.play_project(True) assets.invalidate_enabled = True return{'FINISHED'} class ArmoryStopButton(bpy.types.Operator): '''Stop currently running player''' bl_idname = 'arm.stop' bl_label = 'Stop' def execute(self, context): make.stop_project() return{'FINISHED'} class ArmoryBuildButton(bpy.types.Operator): '''Build and compile project''' bl_idname = 'arm.build' bl_label = 'Build' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} if not arm.utils.check_sdkpath(self): return {"CANCELLED"} if not arm.utils.check_engine(self): return {"CANCELLED"} arm.utils.check_default_rp() state.target = make.runtime_to_target(in_viewport=False) state.is_export = False assets.invalidate_enabled = False make.build_project() make.compile_project(watch=True) assets.invalidate_enabled = True return{'FINISHED'} class ArmoryBuildProjectButton(bpy.types.Operator): '''Build and compile project''' bl_idname = 'arm.build_project' bl_label = 'Build' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} if not arm.utils.check_sdkpath(self): return {"CANCELLED"} if not arm.utils.check_engine(self): return {"CANCELLED"} arm.utils.check_projectpath(self) arm.utils.check_default_rp() wrd = bpy.data.worlds['Arm'] item = wrd.arm_exporterlist[wrd.arm_exporterlist_index] if item.arm_project_rp == '': item.arm_project_rp = wrd.arm_rplist[wrd.arm_rplist_index].name # Assume unique rp names rplist_index = wrd.arm_rplist_index for i in range(0, len(wrd.arm_rplist)): if wrd.arm_rplist[i].name == item.arm_project_rp: wrd.arm_rplist_index = i break state.target = item.arm_project_target state.is_export = True assets.invalidate_shader_cache(None, None) assets.invalidate_enabled = False make.build_project() make.compile_project(watch=True) state.is_export = False wrd.arm_rplist_index = rplist_index assets.invalidate_enabled = True return{'FINISHED'} class ArmoryPatchProjectButton(bpy.types.Operator): ''' Build/compile project without generating project files. This allows iterating faster on native platforms since project file is not reloaded. ''' bl_idname = 'arm.patch_project' bl_label = 'Patch' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} if not arm.utils.check_sdkpath(self): return {"CANCELLED"} if not arm.utils.check_engine(self): return {"CANCELLED"} self.report({'INFO'}, 'Patching project, check console for details.') arm.utils.check_projectpath(self) arm.utils.check_default_rp() wrd = bpy.data.worlds['Arm'] item = wrd.arm_exporterlist[wrd.arm_exporterlist_index] if item.arm_project_rp == '': item.arm_project_rp = wrd.arm_rplist[wrd.arm_rplist_index].name # Assume unique rp names rplist_index = wrd.arm_rplist_index for i in range(0, len(wrd.arm_rplist)): if wrd.arm_rplist[i].name == item.arm_project_rp: wrd.arm_rplist_index = i break #make.clean_project() state.target = item.arm_project_target state.is_export = True assets.invalidate_enabled = False make.build_project(is_publish=True) make.compile_project(no_project_file=True) state.is_export = False wrd.arm_rplist_index = rplist_index assets.invalidate_enabled = True return{'FINISHED'} class ArmoryPublishProjectButton(bpy.types.Operator): '''Build project ready for publishing''' bl_idname = 'arm.publish_project' bl_label = 'Publish' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} if not arm.utils.check_sdkpath(self): return {"CANCELLED"} if not arm.utils.check_engine(self): return {"CANCELLED"} self.report({'INFO'}, 'Publishing project, check console for details.') arm.utils.check_projectpath(self) arm.utils.check_default_rp() wrd = bpy.data.worlds['Arm'] item = wrd.arm_exporterlist[wrd.arm_exporterlist_index] if item.arm_project_rp == '': item.arm_project_rp = wrd.arm_rplist[wrd.arm_rplist_index].name # Assume unique rp names rplist_index = wrd.arm_rplist_index for i in range(0, len(wrd.arm_rplist)): if wrd.arm_rplist[i].name == item.arm_project_rp: wrd.arm_rplist_index = i break make.clean_project() state.target = item.arm_project_target state.is_export = True assets.invalidate_enabled = False make.build_project(is_publish=True) make.compile_project(watch=True) state.is_export = False wrd.arm_rplist_index = rplist_index assets.invalidate_enabled = True target_name = arm.utils.get_kha_target(state.target) files_path = arm.utils.get_fp_build() + '/' + target_name if target_name == 'html5': print('HTML5 files are being exported to ' + files_path) elif target_name == 'ios' or target_name == 'osx': # TODO: to macos print('XCode project files are being exported to ' + files_path + '-build') elif target_name == 'windows': print('VisualStudio 2017 project files are being exported to ' + files_path + '-build') elif target_name == 'windowsapp': print('VisualStudio 2017 project files are being exported to ' + files_path + '-build') elif target_name == 'android-native': print('Android Studio project files are being exported to ' + files_path + '-build/' + arm.utils.safestr(wrd.arm_project_name)) else: print('Makefiles are being exported to ' + files_path + '-build') return{'FINISHED'} class ArmoryPatchButton(bpy.types.Operator): '''Update currently running player instance''' bl_idname = 'arm.patch' bl_label = 'Patch' def execute(self, context): assets.invalidate_enabled = False make.play_project(True) assets.invalidate_enabled = True return{'FINISHED'} class ArmoryOpenProjectFolderButton(bpy.types.Operator): '''Open project folder''' bl_idname = 'arm.open_project_folder' bl_label = 'Project Folder' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} webbrowser.open('file://' + arm.utils.get_fp()) return{'FINISHED'} class ArmoryKodeStudioButton(bpy.types.Operator): '''Launch this project in Kode Studio''' bl_idname = 'arm.kode_studio' bl_label = 'Kode Studio' bl_description = 'Open Project in Kode Studio' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} arm.utils.kode_studio() return{'FINISHED'} class CleanMenu(bpy.types.Menu): bl_label = "Ok?" bl_idname = "OBJECT_MT_clean_menu" def draw(self, context): layout = self.layout layout.operator("arm.clean_project") class CleanButtonMenu(bpy.types.Operator): '''Clean cached data''' bl_label = "Clean" bl_idname = "arm.clean_menu" def execute(self, context): bpy.ops.wm.call_menu(name=CleanMenu.bl_idname) return {"FINISHED"} class ArmoryCleanProjectButton(bpy.types.Operator): '''Delete all cached project data''' bl_idname = 'arm.clean_project' bl_label = 'Clean Project' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} make.clean_project() return{'FINISHED'} class ArmoryRenderButton(bpy.types.Operator): '''Capture Armory output as render result''' bl_idname = 'arm.render' bl_label = 'Render' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} if not arm.utils.check_sdkpath(self): return {"CANCELLED"} if not arm.utils.check_engine(self): return {"CANCELLED"} arm.utils.check_default_rp() if state.playproc != None: make.stop_project() if bpy.data.worlds['Arm'].arm_play_runtime != 'Krom': bpy.data.worlds['Arm'].arm_play_runtime = 'Krom' rpdat = arm.utils.get_rp() if rpdat.rp_rendercapture == False: rpdat.rp_rendercapture = True if rpdat.rp_antialiasing != 'TAA': rpdat.rp_antialiasing = 'TAA' assets.invalidate_enabled = False make.get_render_result() assets.invalidate_enabled = True return{'FINISHED'} class ArmoryRenderAnimButton(bpy.types.Operator): '''Capture Armory output as render result''' bl_idname = 'arm.render_anim' bl_label = 'Animation' def execute(self, context): if not arm.utils.check_saved(self): return {"CANCELLED"} if not arm.utils.check_sdkpath(self): return {"CANCELLED"} if not arm.utils.check_engine(self): return {"CANCELLED"} arm.utils.check_default_rp() if state.playproc != None: make.stop_project() if bpy.data.worlds['Arm'].arm_play_runtime != 'Krom': bpy.data.worlds['Arm'].arm_play_runtime = 'Krom' rpdat = arm.utils.get_rp() if rpdat.rp_rendercapture == False: rpdat.rp_rendercapture = True if rpdat.rp_antialiasing != 'TAA': rpdat.rp_antialiasing = 'TAA' assets.invalidate_enabled = False make.get_render_anim_result() assets.invalidate_enabled = True return{'FINISHED'} # Play button in 3D View panel def draw_view3d_header(self, context): layout = self.layout if state.playproc == None and state.compileproc == None: if arm.utils.with_krom(): layout.operator("arm.play_in_viewport", icon="PLAY") else: layout.operator("arm.play", icon="PLAY") else: layout.operator("arm.stop", icon="MESH_PLANE") # Info panel in header def draw_info_header(self, context): layout = self.layout if 'Arm' not in bpy.data.worlds: return wrd = bpy.data.worlds['Arm'] if wrd.arm_progress < 100: layout.prop(wrd, 'arm_progress') if log.info_text != '': layout.label(log.info_text) class ArmRenderPathPanel(bpy.types.Panel): bl_label = "Armory Render Path" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "render" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout wrd = bpy.data.worlds['Arm'] rows = 2 if len(wrd.arm_rplist) > 1: rows = 4 row = layout.row() row.template_list("ArmRPList", "The_List", wrd, "arm_rplist", wrd, "arm_rplist_index", rows=rows) col = row.column(align=True) col.operator("arm_rplist.new_item", icon='ZOOMIN', text="") col.operator("arm_rplist.delete_item", icon='ZOOMOUT', text="") if wrd.arm_rplist_index >= 0 and len(wrd.arm_rplist) > 0: rpdat = wrd.arm_rplist[wrd.arm_rplist_index] drivers = arm.props_renderpath.drivers if len(drivers) > 1: if len(rpdat.rp_driver_list) == 0: for s in drivers: rpdat.rp_driver_list.add().name = s layout.prop_search(rpdat, "rp_driver", rpdat, "rp_driver_list", "Driver") layout.separator() if rpdat.rp_driver != 'Armory': arm.props_renderpath.driver_props[rpdat.rp_driver](layout) return layout.prop(wrd, "rp_preset") layout.separator() layout.prop(rpdat, "rp_renderer") if rpdat.rp_renderer == 'Forward': layout.prop(rpdat, 'rp_depthprepass') layout.prop(rpdat, "arm_material_model") layout.prop(rpdat, "rp_shadowmap") if rpdat.rp_shadowmap != 'Off': layout.prop(rpdat, "rp_shadowmap_cascades") layout.prop(rpdat, "rp_translucency_state") layout.prop(rpdat, "rp_overlays_state") layout.prop(rpdat, "rp_decals_state") layout.prop(rpdat, "rp_sss_state") layout.prop(rpdat, "rp_blending_state") layout.prop(rpdat, "rp_background") layout.prop(rpdat, 'rp_gi') if rpdat.rp_gi != 'Off': layout.prop(rpdat, 'rp_voxelgi_resolution') layout.prop(rpdat, 'rp_voxelgi_resolution_z') layout.prop(rpdat, 'arm_voxelgi_dimensions') layout.prop(rpdat, 'arm_voxelgi_revoxelize') if rpdat.arm_voxelgi_revoxelize: layout.prop(rpdat, 'arm_voxelgi_camera') layout.prop(rpdat, 'arm_voxelgi_temporal') # layout.prop(rpdat, 'arm_voxelgi_anisotropic') # layout.prop(rpdat, 'arm_voxelgi_shadows') if rpdat.rp_gi == 'Voxel GI': layout.prop(rpdat, 'arm_voxelgi_refraction') layout.prop(rpdat, 'arm_voxelgi_emission') layout.prop(rpdat, 'rp_voxelgi_hdr') # layout.prop(rpdat, 'arm_voxelgi_multibounce') layout.separator() layout.prop(rpdat, "rp_hdr") layout.prop(rpdat, "rp_stereo") # layout.prop(rpdat, "rp_greasepencil") layout.separator() layout.prop(rpdat, "rp_render_to_texture") if rpdat.rp_render_to_texture: layout.prop(rpdat, "rp_supersampling") layout.prop(rpdat, "rp_antialiasing") layout.prop(rpdat, "rp_compositornodes") layout.prop(rpdat, "rp_autoexposure") layout.prop(rpdat, "rp_volumetriclight") layout.prop(rpdat, "rp_ssgi") # layout.prop(wrd, 'arm_ssao_half_res') layout.prop(rpdat, "rp_ssr") if rpdat.rp_ssr: layout.prop(rpdat, 'arm_ssr_half_res') # layout.prop(rpdat, "rp_dfao") # layout.prop(rpdat, "rp_dfrs") # layout.prop(rpdat, "rp_dfgi") layout.prop(rpdat, "rp_bloom") layout.prop(rpdat, "rp_ocean") # layout.prop(rpdat, "rp_eyeadapt") layout.prop(rpdat, "rp_motionblur") layout.prop(rpdat, 'arm_rp_resolution') layout.prop(rpdat, 'rp_dynres') layout.separator() layout.prop(rpdat, 'arm_soft_shadows') if rpdat.arm_soft_shadows != 'Off': layout.prop(rpdat, 'arm_soft_shadows_penumbra') layout.prop(rpdat, 'arm_soft_shadows_distance') layout.prop(rpdat, 'arm_samples_per_pixel') layout.prop(rpdat, 'arm_texture_filter') layout.prop(rpdat, "arm_diffuse_model") layout.prop(rpdat, 'arm_ssrs') layout.prop(rpdat, 'arm_displacement') layout.prop(rpdat, 'arm_clouds') class ArmRenderPropsPanel(bpy.types.Panel): bl_label = "Armory Render Props" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "render" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout wrd = bpy.data.worlds['Arm'] dat = bpy.data.worlds['Arm'] layout.prop(wrd, 'arm_tonemap') layout.prop(wrd, 'arm_culling') layout.prop(wrd, 'arm_two_sided_area_lamp') layout.prop(wrd, 'arm_skin') if wrd.arm_skin.startswith('GPU'): layout.prop(wrd, 'arm_skin_max_bones_auto') if not wrd.arm_skin_max_bones_auto: layout.prop(wrd, 'arm_skin_max_bones') layout.label('Shadows') layout.prop(wrd, 'arm_shadowmap_split') layout.label('Clouds') row = layout.row() row.prop(wrd, 'arm_clouds_density') row.prop(wrd, 'arm_clouds_size') row = layout.row() row.prop(wrd, 'arm_clouds_lower') row.prop(wrd, 'arm_clouds_upper') layout.prop(wrd, 'arm_clouds_wind') layout.prop(wrd, 'arm_clouds_secondary') row = layout.row() row.prop(wrd, 'arm_clouds_precipitation') row.prop(wrd, 'arm_clouds_eccentricity') layout.label('Voxel GI') row = layout.row() row.prop(wrd, 'arm_voxelgi_diff') row.prop(wrd, 'arm_voxelgi_spec') row = layout.row() row.prop(wrd, 'arm_voxelgi_occ') row.prop(wrd, 'arm_voxelgi_env') row = layout.row() row.prop(wrd, 'arm_voxelgi_step') row.prop(wrd, 'arm_voxelgi_range') row = layout.row() row.prop(wrd, 'arm_voxelgi_offset_diff') row.prop(wrd, 'arm_voxelgi_offset_spec') row = layout.row() row.prop(wrd, 'arm_voxelgi_offset_shadow') row.prop(wrd, 'arm_voxelgi_offset_refract') layout.prop(wrd, 'arm_voxelgi_cones') layout.label('SSAO') row = layout.row() row.prop(wrd, 'arm_ssao_size') row.prop(wrd, 'arm_ssao_strength') layout.label('SSGI') layout.prop(wrd, 'arm_ssgi_rays') row = layout.row() row.prop(wrd, 'arm_ssgi_strength') row.prop(wrd, 'arm_ssgi_step_size') row = layout.row() row.prop(wrd, 'arm_ssgi_max_steps') layout.label('Bloom') row = layout.row() row.prop(wrd, 'arm_bloom_threshold') row.prop(wrd, 'arm_bloom_strength') layout.prop(wrd, 'arm_bloom_radius') layout.label('Motion Blur') layout.prop(wrd, 'arm_motion_blur_intensity') layout.label('SSR') row = layout.row() row.prop(wrd, 'arm_ssr_ray_step') row.prop(wrd, 'arm_ssr_min_ray_step') row = layout.row() row.prop(wrd, 'arm_ssr_search_dist') row.prop(wrd, 'arm_ssr_falloff_exp') layout.prop(wrd, 'arm_ssr_jitter') layout.label('SSS') layout.prop(wrd, 'arm_sss_width') layout.label('SSRS') layout.prop(wrd, 'arm_ssrs_ray_step') layout.label('Volumetric Light') layout.prop(wrd, 'arm_volumetric_light_air_turbidity') layout.prop(wrd, 'arm_volumetric_light_air_color') layout.label('Compositor') layout.prop(wrd, 'arm_letterbox') layout.prop(wrd, 'arm_letterbox_size') layout.prop(wrd, 'arm_grain') layout.prop(wrd, 'arm_grain_strength') layout.prop(wrd, 'arm_fog') layout.prop(wrd, 'arm_fog_color') row = layout.row() row.prop(wrd, 'arm_fog_amounta') row.prop(wrd, 'arm_fog_amountb') layout.prop(wrd, 'arm_fisheye') layout.prop(wrd, 'arm_vignette') layout.prop(wrd, 'arm_lensflare') layout.prop(wrd, 'arm_autoexposure_strength') layout.prop(wrd, 'arm_lens_texture') layout.prop(wrd, 'arm_lut_texture') class ArmGenLodButton(bpy.types.Operator): '''Automatically generate LoD levels''' bl_idname = 'arm.generate_lod' bl_label = 'Auto Generate' def lod_name(self, name, level): return name + '_LOD' + str(level + 1) def execute(self, context): obj = context.object if obj == None: return{'CANCELLED'} # Clear mdata = context.object.data mdata.arm_lodlist_index = 0 mdata.arm_lodlist.clear() # Lod levels wrd = bpy.data.worlds['Arm'] ratio = wrd.arm_lod_gen_ratio num_levels = wrd.arm_lod_gen_levels for level in range(0, num_levels): new_obj = obj.copy() for i in range(0, 3): new_obj.location[i] = 0 new_obj.rotation_euler[i] = 0 new_obj.scale[i] = 1 new_obj.data = obj.data.copy() new_obj.name = self.lod_name(obj.name, level) new_obj.parent = obj new_obj.hide = True new_obj.hide_render = True mod = new_obj.modifiers.new('Decimate', 'DECIMATE') mod.ratio = ratio ratio *= wrd.arm_lod_gen_ratio context.scene.objects.link(new_obj) # Screen sizes for level in range(0, num_levels): mdata.arm_lodlist.add() mdata.arm_lodlist[-1].name = self.lod_name(obj.name, level) mdata.arm_lodlist[-1].screen_size_prop = (1 - (1 / (num_levels + 1)) * level) - (1 / (num_levels + 1)) return{'FINISHED'} class ArmLodPanel(bpy.types.Panel): bl_label = "Armory Lod" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "object" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout obj = bpy.context.object # Mesh only for now if obj.type != 'MESH': return mdata = obj.data rows = 2 if len(mdata.arm_lodlist) > 1: rows = 4 row = layout.row() row.template_list("ArmLodList", "The_List", mdata, "arm_lodlist", mdata, "arm_lodlist_index", rows=rows) col = row.column(align=True) col.operator("arm_lodlist.new_item", icon='ZOOMIN', text="") col.operator("arm_lodlist.delete_item", icon='ZOOMOUT', text="") if mdata.arm_lodlist_index >= 0 and len(mdata.arm_lodlist) > 0: item = mdata.arm_lodlist[mdata.arm_lodlist_index] row = layout.row() row.prop_search(item, "name", bpy.data, "objects", "Object") row = layout.row() row.prop(item, "screen_size_prop") # Auto lod for meshes if obj.type == 'MESH': layout.separator() layout.operator("arm.generate_lod") wrd = bpy.data.worlds['Arm'] row = layout.row() row.prop(wrd, 'arm_lod_gen_levels') row.prop(wrd, 'arm_lod_gen_ratio') layout.prop(mdata, "arm_lod_material") class ArmTilesheetPanel(bpy.types.Panel): bl_label = "Armory Tilesheet" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "object" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout wrd = bpy.data.worlds['Arm'] rows = 2 if len(wrd.arm_tilesheetlist) > 1: rows = 4 row = layout.row() row.template_list("ArmTilesheetList", "The_List", wrd, "arm_tilesheetlist", wrd, "arm_tilesheetlist_index", rows=rows) col = row.column(align=True) col.operator("arm_tilesheetlist.new_item", icon='ZOOMIN', text="") col.operator("arm_tilesheetlist.delete_item", icon='ZOOMOUT', text="") if wrd.arm_tilesheetlist_index >= 0 and len(wrd.arm_tilesheetlist) > 0: dat = wrd.arm_tilesheetlist[wrd.arm_tilesheetlist_index] row = layout.row() row.prop(dat, "tilesx_prop") row.prop(dat, "tilesy_prop") layout.prop(dat, "framerate_prop") layout.label('Actions') rows = 2 if len(dat.arm_tilesheetactionlist) > 1: rows = 4 row = layout.row() row.template_list("ArmTilesheetList", "The_List", dat, "arm_tilesheetactionlist", dat, "arm_tilesheetactionlist_index", rows=rows) col = row.column(align=True) col.operator("arm_tilesheetactionlist.new_item", icon='ZOOMIN', text="") col.operator("arm_tilesheetactionlist.delete_item", icon='ZOOMOUT', text="") if dat.arm_tilesheetactionlist_index >= 0 and len(dat.arm_tilesheetactionlist) > 0: adat = dat.arm_tilesheetactionlist[dat.arm_tilesheetactionlist_index] row = layout.row() row.prop(adat, "start_prop") row.prop(adat, "end_prop") layout.prop(adat, "loop_prop") class ArmProxyPanel(bpy.types.Panel): bl_label = "Armory Proxy" bl_space_type = "PROPERTIES" bl_region_type = "WINDOW" bl_context = "object" bl_options = {'DEFAULT_CLOSED'} def draw(self, context): layout = self.layout layout.operator("arm.make_proxy") obj = bpy.context.object if obj != None and obj.proxy != None: layout.label("Sync") col = layout.column(align=True) row = col.row(align=True) row.prop(obj, "arm_proxy_sync_loc") row.prop(obj, "arm_proxy_sync_rot") row.prop(obj, "arm_proxy_sync_scale") row = col.row(align=True) row.prop(obj, "arm_proxy_sync_materials") row.prop(obj, "arm_proxy_sync_modifiers") row.prop(obj, "arm_proxy_sync_traits") row = layout.row(align=True) row.alignment = 'EXPAND' row.operator("arm.proxy_toggle_all") row.operator("arm.proxy_apply_all") class ArmMakeProxyButton(bpy.types.Operator): '''Create proxy from linked object''' bl_idname = 'arm.make_proxy' bl_label = 'Make Proxy' def execute(self, context): obj = context.object if obj == None: return{'CANCELLED'} if obj.library == None: self.report({'ERROR'}, 'Select linked object.') arm.proxy.make(obj) return{'FINISHED'} class ArmProxyToggleAllButton(bpy.types.Operator): bl_idname = 'arm.proxy_toggle_all' bl_label = 'Toggle All' def execute(self, context): obj = context.object b = not obj.arm_proxy_sync_loc obj.arm_proxy_sync_loc = b obj.arm_proxy_sync_rot = b obj.arm_proxy_sync_scale = b obj.arm_proxy_sync_materials = b obj.arm_proxy_sync_modifiers = b obj.arm_proxy_sync_traits = b return{'FINISHED'} class ArmProxyApplyAllButton(bpy.types.Operator): bl_idname = 'arm.proxy_apply_all' bl_label = 'Apply to All' def execute(self, context): for obj in bpy.data.objects: if obj.proxy == None: continue if obj.proxy == context.object.proxy: obj.arm_proxy_sync_loc = context.object.arm_proxy_sync_loc obj.arm_proxy_sync_rot = context.object.arm_proxy_sync_rot obj.arm_proxy_sync_scale = context.object.arm_proxy_sync_scale obj.arm_proxy_sync_materials = context.object.arm_proxy_sync_materials obj.arm_proxy_sync_modifiers = context.object.arm_proxy_sync_modifiers obj.arm_proxy_sync_traits = context.object.arm_proxy_sync_traits return{'FINISHED'} class ArmSyncProxyButton(bpy.types.Operator): bl_idname = 'arm.sync_proxy' bl_label = 'Sync' def execute(self, context): if len(bpy.data.libraries) > 0: for obj in bpy.data.objects: if obj == None or obj.proxy == None: continue if obj.arm_proxy_sync_loc: arm.proxy.sync_location(obj) if obj.arm_proxy_sync_rot: arm.proxy.sync_rotation(obj) if obj.arm_proxy_sync_scale: arm.proxy.sync_scale(obj) if obj.arm_proxy_sync_materials: arm.proxy.sync_materials(obj) if obj.arm_proxy_sync_modifiers: arm.proxy.sync_modifiers(obj) if obj.arm_proxy_sync_traits: arm.proxy.sync_traits(obj) print('Armory: Proxy objects synchronized') return{'FINISHED'} class ArmPrintTraitsButton(bpy.types.Operator): bl_idname = 'arm.print_traits' bl_label = 'Print Traits' def execute(self, context): for s in bpy.data.scenes: print(s.name + ' traits:') for o in s.objects: for t in o.arm_traitlist: if not t.enabled_prop: continue tname = t.nodes_name_prop if t.type_prop == 'Logic Nodes' else t.class_name_prop print('Object {0} - {1}'.format(o.name, tname)) return{'FINISHED'} def register(): bpy.utils.register_class(ObjectPropsPanel) bpy.utils.register_class(ModifiersPropsPanel) bpy.utils.register_class(ParticlesPropsPanel) bpy.utils.register_class(PhysicsPropsPanel) bpy.utils.register_class(DataPropsPanel) bpy.utils.register_class(ScenePropsPanel) bpy.utils.register_class(InvalidateCacheButton) bpy.utils.register_class(InvalidateMaterialCacheButton) bpy.utils.register_class(InvalidateGPCacheButton) bpy.utils.register_class(MaterialPropsPanel) bpy.utils.register_class(WorldPropsPanel) bpy.utils.register_class(ArmoryPlayerPanel) bpy.utils.register_class(ArmoryRenderPanel) bpy.utils.register_class(ArmoryExporterPanel) bpy.utils.register_class(ArmoryProjectPanel) bpy.utils.register_class(ArmRenderPathPanel) bpy.utils.register_class(ArmRenderPropsPanel) # bpy.utils.register_class(ArmVirtualInputPanel) bpy.utils.register_class(ArmoryPlayButton) bpy.utils.register_class(ArmoryPlayInViewportButton) bpy.utils.register_class(ArmoryStopButton) bpy.utils.register_class(ArmoryBuildButton) bpy.utils.register_class(ArmoryBuildProjectButton) bpy.utils.register_class(ArmoryPatchProjectButton) bpy.utils.register_class(ArmoryPatchButton) bpy.utils.register_class(ArmoryOpenProjectFolderButton) bpy.utils.register_class(ArmoryKodeStudioButton) bpy.utils.register_class(CleanMenu) bpy.utils.register_class(CleanButtonMenu) bpy.utils.register_class(ArmoryCleanProjectButton) bpy.utils.register_class(ArmoryPublishProjectButton) bpy.utils.register_class(ArmoryRenderButton) bpy.utils.register_class(ArmoryRenderAnimButton) bpy.utils.register_class(ArmoryGenerateNavmeshButton) bpy.utils.register_class(ArmNavigationPanel) bpy.utils.register_class(ArmGenLodButton) bpy.utils.register_class(ArmLodPanel) bpy.utils.register_class(ArmTilesheetPanel) bpy.utils.register_class(ArmProxyPanel) bpy.utils.register_class(ArmMakeProxyButton) bpy.utils.register_class(ArmProxyToggleAllButton) bpy.utils.register_class(ArmProxyApplyAllButton) bpy.utils.register_class(ArmSyncProxyButton) bpy.utils.register_class(ArmPrintTraitsButton) bpy.types.VIEW3D_HT_header.append(draw_view3d_header) bpy.types.INFO_HT_header.prepend(draw_info_header) def unregister(): bpy.types.VIEW3D_HT_header.remove(draw_view3d_header) bpy.types.INFO_HT_header.remove(draw_info_header) bpy.utils.unregister_class(ObjectPropsPanel) bpy.utils.unregister_class(ModifiersPropsPanel) bpy.utils.unregister_class(ParticlesPropsPanel) bpy.utils.unregister_class(PhysicsPropsPanel) bpy.utils.unregister_class(DataPropsPanel) bpy.utils.unregister_class(ScenePropsPanel) bpy.utils.unregister_class(InvalidateCacheButton) bpy.utils.unregister_class(InvalidateMaterialCacheButton) bpy.utils.unregister_class(InvalidateGPCacheButton) bpy.utils.unregister_class(MaterialPropsPanel) bpy.utils.unregister_class(WorldPropsPanel) bpy.utils.unregister_class(ArmoryPlayerPanel) bpy.utils.unregister_class(ArmoryRenderPanel) bpy.utils.unregister_class(ArmoryExporterPanel) bpy.utils.unregister_class(ArmoryProjectPanel) bpy.utils.unregister_class(ArmRenderPathPanel) bpy.utils.unregister_class(ArmRenderPropsPanel) # bpy.utils.unregister_class(ArmVirtualInputPanel) bpy.utils.unregister_class(ArmoryPlayButton) bpy.utils.unregister_class(ArmoryPlayInViewportButton) bpy.utils.unregister_class(ArmoryStopButton) bpy.utils.unregister_class(ArmoryBuildButton) bpy.utils.unregister_class(ArmoryBuildProjectButton) bpy.utils.unregister_class(ArmoryPatchProjectButton) bpy.utils.unregister_class(ArmoryPatchButton) bpy.utils.unregister_class(ArmoryOpenProjectFolderButton) bpy.utils.unregister_class(ArmoryKodeStudioButton) bpy.utils.unregister_class(CleanMenu) bpy.utils.unregister_class(CleanButtonMenu) bpy.utils.unregister_class(ArmoryCleanProjectButton) bpy.utils.unregister_class(ArmoryPublishProjectButton) bpy.utils.unregister_class(ArmoryRenderButton) bpy.utils.unregister_class(ArmoryRenderAnimButton) bpy.utils.unregister_class(ArmoryGenerateNavmeshButton) bpy.utils.unregister_class(ArmNavigationPanel) bpy.utils.unregister_class(ArmGenLodButton) bpy.utils.unregister_class(ArmLodPanel) bpy.utils.unregister_class(ArmTilesheetPanel) bpy.utils.unregister_class(ArmProxyPanel) bpy.utils.unregister_class(ArmMakeProxyButton) bpy.utils.unregister_class(ArmProxyToggleAllButton) bpy.utils.unregister_class(ArmProxyApplyAllButton) bpy.utils.unregister_class(ArmSyncProxyButton) bpy.utils.unregister_class(ArmPrintTraitsButton)