Onek8/LNXSDK
1
0
Fork 0
forked from LeenkxTeam/LNXSDK
Code Pull Requests Activity
Files
2998a5585e0b8005a7f7217bef96147aeeae1407
LNXSDK/leenkx/blender/lnx/props_ui.py
Onek8 e014484d27 merge upstream
2025-06-02 20:16:04 +00:00

2970 lines
113 KiB
Python
Raw Blame History

import json
import os
import sys
import shutil
import textwrap
import mathutils
import bpy
from bpy.props import *
from lnx.lightmapper.panels import scene
import lnx.api
import lnx.assets as assets
from lnx.exporter import LeenkxExporter
import lnx.log as log
import lnx.logicnode.replacement
import lnx.make as make
import lnx.make_state as state
import lnx.props as props
import lnx.props_properties
import lnx.props_traits
import lnx.nodes_logic
import lnx.ui_icons as ui_icons
import lnx.utils
import lnx.utils_vs
import lnx.write_probes
if lnx.is_reload(__name__):
lnx.api = lnx.reload_module(lnx.api)
assets = lnx.reload_module(assets)
lnx.exporter = lnx.reload_module(lnx.exporter)
from lnx.exporter import LeenkxExporter
log = lnx.reload_module(log)
lnx.logicnode.replacement = lnx.reload_module(lnx.logicnode.replacement)
make = lnx.reload_module(make)
state = lnx.reload_module(state)
props = lnx.reload_module(props)
lnx.props_properties = lnx.reload_module(lnx.props_properties)
lnx.props_traits = lnx.reload_module(lnx.props_traits)
lnx.nodes_logic = lnx.reload_module(lnx.nodes_logic)
ui_icons = lnx.reload_module(ui_icons)
lnx.utils = lnx.reload_module(lnx.utils)
lnx.utils_vs = lnx.reload_module(lnx.utils_vs)
lnx.write_probes = lnx.reload_module(lnx.write_probes)
else:
lnx.enable_reload(__name__)
class LNX_PT_ObjectPropsPanel(bpy.types.Panel):
"""Menu in object region."""
bl_label = "Leenkx Props"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "object"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
obj = bpy.context.object
if obj == None:
return
col = layout.column()
col.prop(obj, 'lnx_export')
if not obj.lnx_export:
return
col.prop(obj, 'lnx_spawn')
col.prop(obj, 'lnx_mobile')
col.prop(obj, 'lnx_animation_enabled')
col.prop(obj, 'lnx_visible_shadow')
if obj.type == 'MESH':
layout.prop(obj, 'lnx_instanced')
wrd = bpy.data.worlds['Lnx']
layout.prop_search(obj, "lnx_tilesheet", wrd, "lnx_tilesheetlist", text="Tilesheet")
if obj.lnx_tilesheet != '':
selected_ts = None
for ts in wrd.lnx_tilesheetlist:
if ts.name == obj.lnx_tilesheet:
selected_ts = ts
break
layout.prop_search(obj, "lnx_tilesheet_action", selected_ts, "lnx_tilesheetactionlist", text="Action")
layout.prop(obj, "lnx_use_custom_tilesheet_node")
# Properties list
lnx.props_properties.draw_properties(layout, obj)
# Lightmapping props
if obj.type == "MESH":
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_lightmap_use")
if obj.TLM_ObjectProperties.tlm_mesh_lightmap_use:
row = layout.row()
row.prop(obj.TLM_ObjectProperties, "tlm_use_default_channel")
if not obj.TLM_ObjectProperties.tlm_use_default_channel:
row = layout.row()
row.prop_search(obj.TLM_ObjectProperties, "tlm_uv_channel", obj.data, "uv_layers", text='UV Channel')
row = layout.row()
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_lightmap_resolution")
if obj.TLM_ObjectProperties.tlm_use_default_channel:
row = layout.row()
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_lightmap_unwrap_mode")
row = layout.row()
if obj.TLM_ObjectProperties.tlm_mesh_lightmap_unwrap_mode == "AtlasGroupA":
if scene.TLM_AtlasListItem >= 0 and len(scene.TLM_AtlasList) > 0:
row = layout.row()
item = scene.TLM_AtlasList[scene.TLM_AtlasListItem]
row.prop_search(obj.TLM_ObjectProperties, "tlm_atlas_pointer", scene, "TLM_AtlasList", text='Atlas Group')
row = layout.row()
else:
row = layout.label(text="Add Atlas Groups from the scene lightmapping settings.")
row = layout.row()
else:
row = layout.row()
row.prop(obj.TLM_ObjectProperties, "tlm_postpack_object")
row = layout.row()
if obj.TLM_ObjectProperties.tlm_postpack_object and obj.TLM_ObjectProperties.tlm_mesh_lightmap_unwrap_mode != "AtlasGroupA":
if scene.TLM_PostAtlasListItem >= 0 and len(scene.TLM_PostAtlasList) > 0:
row = layout.row()
item = scene.TLM_PostAtlasList[scene.TLM_PostAtlasListItem]
row.prop_search(obj.TLM_ObjectProperties, "tlm_postatlas_pointer", scene, "TLM_PostAtlasList", text='Atlas Group')
row = layout.row()
else:
row = layout.label(text="Add Atlas Groups from the scene lightmapping settings.")
row = layout.row()
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_unwrap_margin")
row = layout.row()
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filter_override")
row = layout.row()
if obj.TLM_ObjectProperties.tlm_mesh_filter_override:
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_mode")
row = layout.row(align=True)
if obj.TLM_ObjectProperties.tlm_mesh_filtering_mode == "Gaussian":
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_gaussian_strength")
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_iterations")
elif obj.TLM_ObjectProperties.tlm_mesh_filtering_mode == "Box":
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_box_strength")
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_iterations")
elif obj.TLM_ObjectProperties.tlm_mesh_filtering_mode == "Bilateral":
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_bilateral_diameter")
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_bilateral_color_deviation")
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_bilateral_coordinate_deviation")
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_iterations")
else:
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_median_kernel", expand=True)
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_mesh_filtering_iterations")
#If UV Packer installed
if "UV-Packer" in bpy.context.preferences.addons.keys():
row.prop(obj.TLM_ObjectProperties, "tlm_use_uv_packer")
if obj.TLM_ObjectProperties.tlm_use_uv_packer:
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_uv_packer_padding")
row = layout.row(align=True)
row.prop(obj.TLM_ObjectProperties, "tlm_uv_packer_packing_engine")
class LNX_PT_ModifiersPropsPanel(bpy.types.Panel):
bl_label = "Leenkx Props"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "modifier"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
obj = bpy.context.object
if obj == None:
return
layout.operator("lnx.invalidate_cache")
class LNX_PT_ParticlesPropsPanel(bpy.types.Panel):
bl_label = "Leenkx Props"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "particle"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
obj = bpy.context.particle_system
if obj == None:
return
layout.prop(obj.settings, 'lnx_auto_start')
layout.prop(obj.settings, 'lnx_is_unique')
layout.prop(obj.settings, 'lnx_loop')
layout.prop(obj.settings, 'lnx_count_mult')
class LNX_PT_PhysicsPropsPanel(bpy.types.Panel):
bl_label = "Leenkx Props"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "physics"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
obj = bpy.context.object
if obj == None:
return
rb = obj.rigid_body
if rb is not None:
col = layout.column()
row = col.row()
row.alignment = 'RIGHT'
rb_type = 'Dynamic'
if LeenkxExporter.rigid_body_static(rb):
rb_type = 'Static'
if rb.kinematic:
rb_type = 'Kinematic'
row.label(text=(f'Rigid Body Export Type: {rb_type}'), icon='AUTO')
layout.prop(obj, 'lnx_rb_linear_factor')
layout.prop(obj, 'lnx_rb_angular_factor')
layout.prop(obj, 'lnx_rb_angular_friction')
layout.prop(obj, 'lnx_rb_trigger')
layout.prop(obj, 'lnx_rb_ccd')
layout.prop(obj, 'lnx_rb_interpolate')
if obj.soft_body is not None:
layout.prop(obj, 'lnx_soft_body_margin')
if obj.rigid_body_constraint is not None:
layout.prop(obj, 'lnx_relative_physics_constraint')
class LNX_OT_AddArmatureRootMotion(bpy.types.Operator):
bl_idname = "lnx.add_root_motion_bone"
bl_label = "Add root bone"
bl_description = "Add a new bone and set it as the root bone. This may be used for root motion."
@classmethod
def poll(cls, context):
obj = context.object
if obj.mode == 'EDIT':
return False
armature = obj.data
if armature.bones:
if armature.bones.active:
return True
def execute(self, context):
obj = context.object
current_mode = obj.mode
bpy.ops.object.mode_set(mode='EDIT')
armature = obj.data
edit_bones = armature.edit_bones
current_root_pos = edit_bones.active.head
current_root_len = edit_bones.active.length
new_root = edit_bones.new("LeenkxRoot")
new_root.head = current_root_pos
new_root.tail = new_root.head + mathutils.Vector((0.0, 0.0, current_root_len))
bpy.ops.object.mode_set(mode=current_mode)
return{'FINISHED'}
# Menu in data region
class LNX_PT_DataPropsPanel(bpy.types.Panel):
bl_label = "Leenkx Props"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "data"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
obj = bpy.context.object
if obj == None:
return
wrd = bpy.data.worlds['Lnx']
if obj.type == 'CAMERA':
layout.prop(obj.data, 'lnx_frustum_culling')
elif obj.type == 'MESH' or obj.type == 'FONT' or obj.type == 'META':
layout.prop(obj.data, 'lnx_dynamic_usage')
layout.operator("lnx.invalidate_cache")
elif obj.type == 'LIGHT':
layout.prop(obj.data, 'lnx_clip_start')
layout.prop(obj.data, 'lnx_clip_end')
layout.prop(obj.data, 'lnx_fov')
layout.prop(obj.data, 'lnx_shadows_bias')
elif obj.type == 'SPEAKER':
layout.prop(obj.data, 'lnx_play_on_start')
layout.prop(obj.data, 'lnx_loop')
layout.prop(obj.data, 'lnx_stream')
elif obj.type == 'ARMATURE':
layout.prop(obj.data, 'lnx_autobake')
layout.prop(obj.data, 'lnx_relative_bone_constraints')
if obj.data.bones:
if obj.data.bones.active:
layout.label(text='Current Root: ' + obj.data.bones.active.name)
layout.operator('lnx.add_root_motion_bone', text='Add new root bone', icon='ADD')
pass
class LNX_PT_WorldPropsPanel(bpy.types.Panel):
bl_label = "Leenkx World Properties"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "world"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
world = context.world
if world is None:
return
layout.prop(world, 'lnx_light_ies_texture')
layout.prop(world, 'lnx_light_clouds_texture')
layout.prop(world, 'lnx_use_clouds')
col = layout.column(align=True)
col.enabled = world.lnx_use_clouds
col.prop(world, 'lnx_darken_clouds')
col.prop(world, 'lnx_clouds_lower')
col.prop(world, 'lnx_clouds_upper')
col.prop(world, 'lnx_clouds_precipitation')
col.prop(world, 'lnx_clouds_secondary')
col.prop(world, 'lnx_clouds_wind')
col.prop(world, 'lnx_clouds_steps')
class LNX_PT_ScenePropsPanel(bpy.types.Panel):
bl_label = "Leenkx Props"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "scene"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
scene = bpy.context.scene
if scene == None:
return
row = layout.row()
column = row.column()
row.prop(scene, 'lnx_export')
class InvalidateCacheButton(bpy.types.Operator):
"""Delete cached mesh data"""
bl_idname = "lnx.invalidate_cache"
bl_label = "Invalidate Cache"
def execute(self, context):
context.object.data.lnx_cached = False
return{'FINISHED'}
class InvalidateMaterialCacheButton(bpy.types.Operator):
"""Delete cached material data"""
bl_idname = "lnx.invalidate_material_cache"
bl_label = "Invalidate Cache"
def execute(self, context):
context.material.lnx_cached = False
context.material.signature = ''
return{'FINISHED'}
class LNX_OT_NewCustomMaterial(bpy.types.Operator):
bl_idname = "lnx.new_custom_material"
bl_label = "New Custom Material"
bl_description = "Add a new custom material. This will create all the necessary files and folders"
def poll_mat_name(self, context):
project_dir = lnx.utils.get_fp()
shader_dir_dst = os.path.join(project_dir, 'Shaders')
mat_name = lnx.utils.safestr(self.mat_name)
self.mat_exists = os.path.isdir(os.path.join(project_dir, 'Bundled', mat_name))
vert_exists = os.path.isfile(os.path.join(shader_dir_dst, f'{mat_name}.vert.glsl'))
frag_exists = os.path.isfile(os.path.join(shader_dir_dst, f'{mat_name}.frag.glsl'))
self.shader_exists = vert_exists or frag_exists
mat_name: StringProperty(
name='Material Name', description='The name of the new material',
default='MyCustomMaterial',
update=poll_mat_name)
mode: EnumProperty(
name='Target RP', description='Choose for which render path mode the new material is created',
default='deferred',
items=[('deferred', 'Deferred', 'Create the material for a deferred render path'),
('forward', 'Forward', 'Create the material for a forward render path')])
mat_exists: BoolProperty(
name='Material Already Exists',
default=False,
options={'HIDDEN', 'SKIP_SAVE'})
shader_exists: BoolProperty(
name='Shaders Already Exist',
default=False,
options={'HIDDEN', 'SKIP_SAVE'})
def invoke(self, context, event):
if not bpy.data.is_saved:
self.report({'INFO'}, "Please save your file first")
return {"CANCELLED"}
# Try to set deferred/forward based on the selected render path
try:
self.mode = 'forward' if lnx.utils.get_rp().rp_renderer == 'Forward' else 'deferred'
except IndexError:
# No render path, use default (deferred)
pass
self.poll_mat_name(context)
wm = context.window_manager
return wm.invoke_props_dialog(self, width=300)
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
layout.prop(self, 'mat_name')
layout.prop(self, 'mode', expand=True)
if self.mat_exists:
box = layout.box()
box.alert = True
col = box.column(align=True)
col.label(text='A custom material with that name already exists,', icon='ERROR')
col.label(text='clicking on \'OK\' will override the material!', icon='BLANK1')
if self.shader_exists:
box = layout.box()
box.alert = True
col = box.column(align=True)
col.label(text='Shader file(s) with that name already exists,', icon='ERROR')
col.label(text='clicking on \'OK\' will override the shader(s)!', icon='BLANK1')
def execute(self, context):
if self.mat_name == '':
return {'CANCELLED'}
project_dir = lnx.utils.get_fp()
shader_dir_src = os.path.join(lnx.utils.get_sdk_path(), 'leenkx', 'Shaders', 'custom_mat_presets')
shader_dir_dst = os.path.join(project_dir, 'Shaders')
mat_name = lnx.utils.safestr(self.mat_name)
mat_dir = os.path.join(project_dir, 'Bundled', mat_name)
os.makedirs(mat_dir, exist_ok=True)
os.makedirs(shader_dir_dst, exist_ok=True)
# Shader data
if self.mode == 'forward':
col_attachments = ['RGBA64']
constants = [{'link': '_worldViewProjectionMatrix', 'name': 'WVP', 'type': 'mat4'}]
vertex_elems = [{'name': 'pos', 'data': 'short4norm'}]
else:
col_attachments = ['RGBA64', 'RGBA64']
constants = [
{'link': '_worldViewProjectionMatrix', 'name': 'WVP', 'type': 'mat4'},
{'link': '_normalMatrix', 'name': 'N', 'type': 'mat3'}
]
vertex_elems = [
{'name': 'pos', 'data': 'short4norm'},
{'name': 'nor', 'data': 'short2norm'}
]
con = {
'color_attachments': col_attachments,
'compare_mode': 'less',
'constants': constants,
'cull_mode': 'clockwise',
'depth_write': True,
'fragment_shader': f'{mat_name}.frag',
'name': 'mesh',
'texture_units': [],
'vertex_shader': f'{mat_name}.vert',
'vertex_elements': vertex_elems
}
data = {
'shader_datas': [{
'contexts': [con],
'name': f'{mat_name}'
}]
}
# Save shader data file
with open(os.path.join(mat_dir, f'{mat_name}.json'), 'w') as datafile:
json.dump(data, datafile, indent=4, sort_keys=True)
# Copy preset shaders to project
if self.mode == 'forward':
shutil.copy(os.path.join(shader_dir_src, 'custom_mat_forward.frag.glsl'), os.path.join(shader_dir_dst, f'{mat_name}.frag.glsl'))
shutil.copy(os.path.join(shader_dir_src, 'custom_mat_forward.vert.glsl'), os.path.join(shader_dir_dst, f'{mat_name}.vert.glsl'))
else:
shutil.copy(os.path.join(shader_dir_src, 'custom_mat_deferred.frag.glsl'), os.path.join(shader_dir_dst, f'{mat_name}.frag.glsl'))
shutil.copy(os.path.join(shader_dir_src, 'custom_mat_deferred.vert.glsl'), os.path.join(shader_dir_dst, f'{mat_name}.vert.glsl'))
# True if called from the material properties tab, else it was called from the search menu
if hasattr(context, 'material') and context.material is not None:
context.material.lnx_custom_material = mat_name
return{'FINISHED'}
class LNX_PG_BindTexturesListItem(bpy.types.PropertyGroup):
uniform_name: StringProperty(
name='Uniform Name',
description='The name of the sampler uniform as used in the shader',
default='ImageTexture',
)
image: PointerProperty(
name='Image',
type=bpy.types.Image,
description='The image to attach to the texture unit',
)
class LNX_UL_BindTexturesList(bpy.types.UIList):
def draw_item(self, context, layout, data, item: LNX_PG_BindTexturesListItem, icon, active_data, active_propname, index):
row = layout.row(align=True)
if item.image is not None:
row.label(text=item.uniform_name, icon_value=item.image.preview.icon_id)
else:
row.label(text='<empty>', icon='ERROR')
class LNX_OT_BindTexturesListNewItem(bpy.types.Operator):
bl_idname = "lnx_bind_textures_list.new_item"
bl_label = "Add Texture Binding"
bl_description = "Add a new texture binding to the list"
bl_options = {'INTERNAL'}
@classmethod
def poll(cls, context):
mat = context.material
if mat is None:
return False
return True
def execute(self, context):
mat = context.material
mat.lnx_bind_textures_list.add()
mat.lnx_bind_textures_list_index = len(mat.lnx_bind_textures_list) - 1
return{'FINISHED'}
class LNX_OT_BindTexturesListDeleteItem(bpy.types.Operator):
bl_idname = "lnx_bind_textures_list.delete_item"
bl_label = "Remove Texture Binding"
bl_description = "Delete the selected texture binding from the list"
bl_options = {'INTERNAL'}
@classmethod
def poll(cls, context):
mat = context.material
if mat is None:
return False
return len(mat.lnx_bind_textures_list) > 0
def execute(self, context):
mat = context.material
lst = mat.lnx_bind_textures_list
index = mat.lnx_bind_textures_list_index
if len(lst) <= index:
return{'FINISHED'}
lst.remove(index)
if index > 0:
index = index - 1
mat.lnx_bind_textures_list_index = index
return{'FINISHED'}
class LNX_PT_MaterialPropsPanel(bpy.types.Panel):
bl_label = "Leenkx Props"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "material"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
mat = bpy.context.material
if mat is None:
return
layout.prop(mat, 'lnx_cast_shadow')
columnb = layout.column()
wrd = bpy.data.worlds['Lnx']
columnb.enabled = len(wrd.lnx_rplist) > 0 and lnx.utils.get_rp().rp_renderer == 'Forward'
columnb.prop(mat, 'lnx_receive_shadow')
layout.prop(mat, 'lnx_ignore_irradiance')
layout.prop(mat, 'lnx_two_sided')
columnb = layout.column()
columnb.enabled = not mat.lnx_two_sided
columnb.prop(mat, 'lnx_cull_mode')
layout.prop(mat, 'lnx_material_id')
layout.prop(mat, 'lnx_depth_read')
layout.prop(mat, 'lnx_overlay')
layout.prop(mat, 'lnx_decal')
layout.prop(mat, 'lnx_discard')
columnb = layout.column()
columnb.enabled = mat.lnx_discard
columnb.prop(mat, 'lnx_discard_opacity')
columnb.prop(mat, 'lnx_discard_opacity_shadows')
row = layout.row(align=True)
row.prop(mat, 'lnx_custom_material')
row.operator('lnx.new_custom_material', text='', icon='ADD')
layout.prop(mat, 'lnx_skip_context')
layout.prop(mat, 'lnx_particle_fade')
layout.prop(mat, 'lnx_billboard')
layout.operator("lnx.invalidate_material_cache")
class LNX_PT_BindTexturesPropsPanel(bpy.types.Panel):
bl_label = "Bind Textures"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "material"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_MaterialPropsPanel"
@classmethod
def poll(cls, context):
mat = context.material
if mat is None:
return False
return mat.lnx_custom_material != ''
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
mat = bpy.context.material
if mat is None:
return
row = layout.row(align=True)
col = row.column(align=True)
col.template_list('LNX_UL_BindTexturesList', '', mat, 'lnx_bind_textures_list', mat, 'lnx_bind_textures_list_index')
if mat.lnx_bind_textures_list_index >= 0 and len(mat.lnx_bind_textures_list) > 0:
item = mat.lnx_bind_textures_list[mat.lnx_bind_textures_list_index]
box = col.box()
if item.image is None:
_row = box.row()
_row.alert = True
_row.alignment = 'RIGHT'
_row.label(text="No image selected, skipping export")
box.prop(item, 'uniform_name')
box.prop(item, 'image')
col = row.column(align=True)
col.operator("lnx_bind_textures_list.new_item", icon='ADD', text="")
col.operator("lnx_bind_textures_list.delete_item", icon='REMOVE', text="")
class LNX_PT_MaterialDriverPropsPanel(bpy.types.Panel):
"""Per-material properties for custom render path drivers"""
bl_label = "Leenkx Driver Properties"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "material"
@classmethod
def poll(cls, context):
mat = context.material
if mat is None:
return False
wrd = bpy.data.worlds['Lnx']
if wrd.lnx_rplist_index < 0 or len(wrd.lnx_rplist) == 0:
return False
if len(lnx.api.drivers) == 0:
return False
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
return rpdat.rp_driver != 'Leenkx' and lnx.api.drivers[rpdat.rp_driver]['draw_mat_props'] is not None
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
lnx.api.drivers[rpdat.rp_driver]['draw_mat_props'](layout, context.material)
class LNX_PT_MaterialBlendingPropsPanel(bpy.types.Panel):
bl_label = "Blending"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "material"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_MaterialPropsPanel"
def draw_header(self, context):
if context.material is None:
return
self.layout.prop(context.material, 'lnx_blending', text="")
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
mat = bpy.context.material
if mat is None:
return
flow = layout.grid_flow()
flow.enabled = mat.lnx_blending
col = flow.column(align=True)
col.prop(mat, 'lnx_blending_source')
col.prop(mat, 'lnx_blending_destination')
col.prop(mat, 'lnx_blending_operation')
flow.separator()
col = flow.column(align=True)
col.prop(mat, 'lnx_blending_source_alpha')
col.prop(mat, 'lnx_blending_destination_alpha')
col.prop(mat, 'lnx_blending_operation_alpha')
class LNX_PT_LeenkxPlayerPanel(bpy.types.Panel):
bl_label = "Leenkx Player"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
row = layout.row(align=True)
row.alignment = 'EXPAND'
row.scale_y = 1.3
if state.proc_play is None and state.proc_build is None:
row.operator("lnx.play", icon="PLAY")
else:
if bpy.app.version < (3, 0, 0):
row.operator("lnx.stop", icon="CANCEL", text="")
elif bpy.app.version > (3, 0, 0) and bpy.app.version < (4, 3, 2):
row.operator("lnx.stop", icon="SEQUENCE_COLOR_01", text="")
else:
row.operator("lnx.stop", icon="EVENT_MEDIASTOP", text="")
row.operator("lnx.clean_menu", icon="BRUSH_DATA")
col = layout.box().column()
col.prop(wrd, 'lnx_runtime')
col.prop(wrd, 'lnx_play_camera')
col.prop(wrd, 'lnx_play_scene')
col.prop_search(wrd, 'lnx_play_renderpath', wrd, 'lnx_rplist', text='Render Path')
if log.num_warnings > 0:
box = layout.box()
box.alert = True
col = box.column(align=True)
warnings = 'warnings' if log.num_warnings > 1 else 'warning'
col.label(text=f'{log.num_warnings} {warnings} occurred during compilation!', icon='ERROR')
# Blank icon to achieve the same indentation as the line before
# prevent showing "open console" twice:
if log.num_errors == 0:
col.label(text='Please open the console to get more information.', icon='BLANK1')
if log.num_errors > 0:
box = layout.box()
box.alert = True
# Less spacing between lines
col = box.column(align=True)
errors = 'errors' if log.num_errors > 1 else 'error'
col.label(text=f'{log.num_errors} {errors} occurred during compilation!', icon='CANCEL')
# Blank icon to achieve the same indentation as the line before
col.label(text='Please open the console to get more information.', icon='BLANK1')
class LNX_PT_LeenkxExporterPanel(bpy.types.Panel):
bl_label = "Leenkx Exporter"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
row = layout.row(align=True)
row.alignment = 'EXPAND'
row.scale_y = 1.3
row.operator("lnx.build_project", icon="MOD_BUILD")
# row.operator("lnx.patch_project")
row.operator("lnx.publish_project", icon="EXPORT")
rows = 2
if len(wrd.lnx_exporterlist) > 1:
rows = 4
row = layout.row()
row.template_list("LNX_UL_ExporterList", "The_List", wrd, "lnx_exporterlist", wrd, "lnx_exporterlist_index", rows=rows)
col = row.column(align=True)
col.operator("lnx_exporterlist.new_item", icon='ADD', text="")
col.operator("lnx_exporterlist.delete_item", icon='REMOVE', text="")
col.menu("LNX_MT_ExporterListSpecials", icon='DOWNARROW_HLT', text="")
if len(wrd.lnx_exporterlist) > 1:
col.separator()
op = col.operator("lnx_exporterlist.move_item", icon='TRIA_UP', text="")
op.direction = 'UP'
op = col.operator("lnx_exporterlist.move_item", icon='TRIA_DOWN', text="")
op.direction = 'DOWN'
if wrd.lnx_exporterlist_index >= 0 and len(wrd.lnx_exporterlist) > 0:
item = wrd.lnx_exporterlist[wrd.lnx_exporterlist_index]
box = layout.box().column()
box.prop(item, 'lnx_project_target')
box.prop(item, 'lnx_project_khamake')
box.prop(item, lnx.utils.target_to_gapi(item.lnx_project_target))
box.prop_search(item, "lnx_project_rp", wrd, "lnx_rplist", text="Render Path")
box.prop_search(item, 'lnx_project_scene', bpy.data, 'scenes', text='Scene')
layout.separator()
col = layout.column(align=True)
col.prop(wrd, 'lnx_project_name')
col.prop(wrd, 'lnx_project_package')
col.prop(wrd, 'lnx_project_bundle')
col = layout.column(align=True)
col.prop(wrd, 'lnx_project_version')
col.prop(wrd, 'lnx_project_version_autoinc')
col = layout.column()
col.prop(wrd, 'lnx_project_icon')
col = layout.column(heading='Code Output', align=True)
col.prop(wrd, 'lnx_dce')
col.prop(wrd, 'lnx_compiler_inline')
col.prop(wrd, 'lnx_minify_js')
col.prop(wrd, 'lnx_no_traces')
col = layout.column(heading='Data', align=True)
col.prop(wrd, 'lnx_minimize')
col.prop(wrd, 'lnx_optimize_data')
col.prop(wrd, 'lnx_asset_compression')
col.prop(wrd, 'lnx_single_data_file')
class ExporterTargetSettingsMixin:
"""Mixin for common exporter setting subpanel functionality.
Panels that inherit from this mixin need to have a lnx_target
variable for polling."""
bl_space_type = 'PROPERTIES'
bl_region_type = 'WINDOW'
bl_context = 'render'
bl_parent_id = 'LNX_PT_LeenkxExporterPanel'
# Override this in sub classes
lnx_panel = ''
@classmethod
def poll(cls, context):
wrd = bpy.data.worlds['Lnx']
if (len(wrd.lnx_exporterlist) > 0) and (wrd.lnx_exporterlist_index >= 0):
item = wrd.lnx_exporterlist[wrd.lnx_exporterlist_index]
return item.lnx_project_target == cls.lnx_target
return False
def draw_header(self, context):
self.layout.label(text='', icon='SETTINGS')
class LNX_PT_LeenkxExporterAndroidSettingsPanel(ExporterTargetSettingsMixin, bpy.types.Panel):
bl_label = "Android Settings"
lnx_target = 'android-hl' # See ExporterTargetSettingsMixin
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
col = layout.column()
col.prop(wrd, 'lnx_winorient')
col.prop(wrd, 'lnx_project_android_sdk_min')
col.prop(wrd, 'lnx_project_android_sdk_target')
col.prop(wrd, 'lnx_project_android_sdk_compile')
class LNX_PT_LeenkxExporterAndroidPermissionsPanel(bpy.types.Panel):
bl_label = "Permissions"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_LeenkxExporterAndroidSettingsPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
# Permission
row = layout.row()
rows = 2
if len(wrd.lnx_exporter_android_permission_list) > 1:
rows = 4
row.template_list("LNX_UL_Exporter_AndroidPermissionList", "The_List", wrd, "lnx_exporter_android_permission_list", wrd, "lnx_exporter_android_permission_list_index", rows=rows)
col = row.column(align=True)
col.operator("lnx_exporter_android_permission_list.new_item", icon='ADD', text="")
col.operator("lnx_exporter_android_permission_list.delete_item", icon='REMOVE', text="")
row = layout.row()
if wrd.lnx_exporter_android_permission_list_index >= 0 and len(wrd.lnx_exporter_android_permission_list) > 0:
item = wrd.lnx_exporter_android_permission_list[wrd.lnx_exporter_android_permission_list_index]
row = layout.row()
row.prop(item, 'lnx_android_permissions')
class LNX_PT_LeenkxExporterAndroidAbiPanel(bpy.types.Panel):
bl_label = "Android ABI Filters"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = { 'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_LeenkxExporterAndroidSettingsPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
# ABIs
row = layout.row()
rows = 2
if len(wrd.lnx_exporter_android_abi_list) > 1:
rows = 4
row.template_list("LNX_UL_Exporter_AndroidAbiList", "The_List", wrd, "lnx_exporter_android_abi_list", wrd, "lnx_exporter_android_abi_list_index", rows=rows)
col = row.column(align=True)
col.operator("lnx_exporter_android_abi_list.new_item", icon='ADD', text="")
col.operator("lnx_exporter_android_abi_list.delete_item", icon='REMOVE', text="")
row = layout.row()
if wrd.lnx_exporter_android_abi_list_index >= 0 and len(wrd.lnx_exporter_android_abi_list) > 0:
item = wrd.lnx_exporter_android_abi_list[wrd.lnx_exporter_android_abi_list_index]
row = layout.row()
row.prop(item, 'lnx_android_abi')
class LNX_PT_LeenkxExporterAndroidBuildAPKPanel(bpy.types.Panel):
bl_label = "Building APK"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_LeenkxExporterAndroidSettingsPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
path = lnx.utils.get_android_sdk_root_path()
col = layout.column()
row = col.row()
row.enabled = len(path) > 0
row.prop(wrd, 'lnx_project_android_build_apk')
row = col.row()
row.enabled = wrd.lnx_project_android_build_apk
row.prop(wrd, 'lnx_project_android_rename_apk')
row = col.row()
row.enabled = wrd.lnx_project_android_build_apk and len(lnx.utils.get_android_apk_copy_path()) > 0
row.prop(wrd, 'lnx_project_android_copy_apk')
row = col.row(align=True)
row.prop(wrd, 'lnx_project_android_list_avd')
sub = row.column(align=True)
sub.enabled = len(path) > 0
sub.operator('lnx.update_list_android_emulator', text='', icon='FILE_REFRESH')
sub = row.column(align=True)
sub.enabled = len(path) > 0 and len(lnx.utils.get_android_emulator_name()) > 0
sub.operator('lnx.run_android_emulator', text='', icon='PLAY')
row = col.row()
row.enabled = lnx.utils.get_project_android_build_apk() and len(lnx.utils.get_android_emulator_name()) > 0
row.prop(wrd, 'lnx_project_android_run_avd')
class LNX_PT_LeenkxExporterHTML5SettingsPanel(ExporterTargetSettingsMixin, bpy.types.Panel):
bl_label = "HTML5 Settings"
lnx_target = 'html5' # See ExporterTargetSettingsMixin
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
col = layout.column()
col.prop(wrd, 'lnx_project_html5_popupmenu_in_browser')
row = col.row()
row.enabled = len(lnx.utils.get_html5_copy_path()) > 0
row.prop(wrd, 'lnx_project_html5_copy')
row = col.row()
row.enabled = len(lnx.utils.get_html5_copy_path()) > 0 and wrd.lnx_project_html5_copy and len(lnx.utils.get_link_web_server()) > 0
row.prop(wrd, 'lnx_project_html5_start_browser')
class LNX_PT_LeenkxExporterWindowsSettingsPanel(ExporterTargetSettingsMixin, bpy.types.Panel):
bl_label = "Windows Settings"
lnx_target = 'windows-hl' # See ExporterTargetSettingsMixin
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
is_windows = lnx.utils.get_os_is_windows()
col = layout.column()
col.prop(wrd, 'lnx_project_win_list_vs')
row = col.row()
row.enabled = is_windows
row.prop(wrd, 'lnx_project_win_build', text='After Publish')
layout = layout.column()
layout.enabled = is_windows
if is_windows and wrd.lnx_project_win_build != 'nothing' and not lnx.utils_vs.is_version_installed(wrd.lnx_project_win_list_vs):
box = draw_error_box(
layout,
'The selected version of Visual Studio could not be found and'
' may not be installed. The "After Publish" action may not work'
' as intended.'
)
box.operator('lnx.update_list_installed_vs', icon='FILE_REFRESH')
layout.separator()
col = layout.column()
col.enabled = wrd.lnx_project_win_build.startswith('compile')
col.prop(wrd, 'lnx_project_win_build_mode')
col.prop(wrd, 'lnx_project_win_build_arch')
col.prop(wrd, 'lnx_project_win_build_log')
col.prop(wrd, 'lnx_project_win_build_cpu')
col.prop(wrd, 'lnx_project_win_build_open')
class LNX_PT_LeenkxProjectPanel(bpy.types.Panel):
bl_label = "Leenkx Project"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
row = layout.row(align=True)
row.operator("lnx.open_editor", icon="DESKTOP")
row.operator("lnx.open_project_folder", icon="FILE_FOLDER")
class LNX_PT_ProjectFlagsPanel(bpy.types.Panel):
bl_label = "Flags"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_parent_id = "LNX_PT_LeenkxProjectPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
col = layout.column(heading='Debug', align=True)
col.prop(wrd, 'lnx_verbose_output')
col.prop(wrd, 'lnx_cache_build')
col.prop(wrd, 'lnx_clear_on_compile')
col.prop(wrd, 'lnx_assert_level')
col.prop(wrd, 'lnx_assert_quit')
col = layout.column(heading='Runtime', align=True)
col.prop(wrd, 'lnx_live_patch')
col.prop(wrd, 'lnx_stream_scene')
col.prop(wrd, 'lnx_loadscreen')
col.prop(wrd, 'lnx_write_config')
col = layout.column(heading='Renderer', align=True)
col.prop(wrd, 'lnx_batch_meshes')
col.prop(wrd, 'lnx_batch_materials')
col.prop(wrd, 'lnx_deinterleaved_buffers')
col.prop(wrd, 'lnx_export_tangents')
col = layout.column(heading='Quality')
row = col.row() # To expand below property UI horizontally
row.prop(wrd, 'lnx_canvas_img_scaling_quality', expand=True)
col.prop(wrd, 'lnx_texture_quality')
col.prop(wrd, 'lnx_sound_quality')
col = layout.column(heading='External Assets')
col.prop(wrd, 'lnx_copy_override')
col.operator('lnx.copy_to_bundled', icon='IMAGE_DATA')
class LNX_PT_ProjectFlagsDebugConsolePanel(bpy.types.Panel):
bl_label = "Debug Console"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_ProjectFlagsPanel"
def draw_header(self, context):
wrd = bpy.data.worlds['Lnx']
self.layout.prop(wrd, 'lnx_debug_console', text='')
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
col = layout.column()
col.enabled = wrd.lnx_debug_console
col.prop(wrd, 'lnx_debug_console_position')
col.prop(wrd, 'lnx_debug_console_scale')
col.prop(wrd, 'lnx_debug_console_visible')
col.prop(wrd, 'lnx_debug_console_trace_pos')
class LNX_PT_ProjectWindowPanel(bpy.types.Panel):
bl_label = "Window"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_LeenkxProjectPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
layout.prop(wrd, 'lnx_winmode')
col = layout.column(align=True)
col.prop(wrd, 'lnx_winresize')
sub = col.column()
sub.enabled = wrd.lnx_winresize
sub.prop(wrd, 'lnx_winmaximize')
col.enabled = True
col.prop(wrd, 'lnx_winminimize')
layout.prop(wrd, 'lnx_vsync')
class LNX_PT_ProjectModulesPanel(bpy.types.Panel):
bl_label = "Modules"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_LeenkxProjectPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
layout.prop(wrd, 'lnx_audio')
layout.prop(wrd, 'lnx_physics')
if wrd.lnx_physics != 'Disabled':
layout.prop(wrd, 'lnx_physics_engine')
layout.prop(wrd, 'lnx_navigation')
if wrd.lnx_navigation != 'Disabled':
layout.prop(wrd, 'lnx_navigation_engine')
layout.prop(wrd, 'lnx_ui')
layout.prop(wrd, 'lnx_network')
layout.prop_search(wrd, 'lnx_khafile', bpy.data, 'texts')
layout.prop(wrd, 'lnx_project_root')
class LnxVirtualInputPanel(bpy.types.Panel):
bl_label = "Leenkx Virtual Input"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
class LeenkxPlayButton(bpy.types.Operator):
'''Launch player in new window'''
bl_idname = 'lnx.play'
bl_label = 'Play'
def invoke(self, context, event):
if event.shift:
state.is_play = True
make.build_success()
return{'FINISHED'}
return self.execute(context)
def execute(self, context):
wrd = bpy.data.worlds['Lnx']
if state.proc_build is not None:
return {"CANCELLED"}
lnx.utils.check_blender_version(self)
if not lnx.utils.check_saved(self):
return {"CANCELLED"}
if not lnx.utils.check_sdkpath(self):
return {"CANCELLED"}
lnx.utils.check_projectpath(None)
lnx.utils.check_default_props()
assets.invalidate_enabled = False
if wrd.lnx_clear_on_compile:
os.system("cls")
make.play()
assets.invalidate_enabled = True
return{'FINISHED'}
class LeenkxStopButton(bpy.types.Operator):
'''Stop currently running player'''
bl_idname = 'lnx.stop'
bl_label = 'Stop'
def execute(self, context):
if state.proc_play != None:
state.proc_play.terminate()
state.proc_play = None
elif state.proc_build != None:
state.proc_build.terminate()
state.proc_build = None
lnx.write_probes.check_last_cmft_time()
return {'FINISHED'}
class LeenkxBuildProjectButton(bpy.types.Operator):
"""Build and compile project"""
bl_idname = 'lnx.build_project'
bl_label = 'Build'
@classmethod
def poll(cls, context):
wrd = bpy.data.worlds['Lnx']
return wrd.lnx_exporterlist_index >= 0 and len(wrd.lnx_exporterlist) > 0
def execute(self, context):
lnx.utils.check_blender_version(self)
if not lnx.utils.check_saved(self):
return {"CANCELLED"}
if not lnx.utils.check_sdkpath(self):
return {"CANCELLED"}
lnx.utils.check_projectpath(self)
lnx.utils.check_default_props()
wrd = bpy.data.worlds['Lnx']
item = wrd.lnx_exporterlist[wrd.lnx_exporterlist_index]
if item.lnx_project_rp == '':
item.lnx_project_rp = wrd.lnx_rplist[wrd.lnx_rplist_index].name
if item.lnx_project_scene == None:
item.lnx_project_scene = context.scene
# Assume unique rp names
rplist_index = wrd.lnx_rplist_index
for i in range(0, len(wrd.lnx_rplist)):
if wrd.lnx_rplist[i].name == item.lnx_project_rp:
wrd.lnx_rplist_index = i
break
assets.invalidate_shader_cache(None, None)
assets.invalidate_enabled = False
if wrd.lnx_clear_on_compile:
os.system("cls")
make.build(item.lnx_project_target, is_export=True)
make.compile()
wrd.lnx_rplist_index = rplist_index
assets.invalidate_enabled = True
return{'FINISHED'}
class LeenkxPublishProjectButton(bpy.types.Operator):
"""Build project ready for publishing."""
bl_idname = 'lnx.publish_project'
bl_label = 'Publish'
@classmethod
def poll(cls, context):
wrd = bpy.data.worlds['Lnx']
return wrd.lnx_exporterlist_index >= 0 and len(wrd.lnx_exporterlist) > 0
def execute(self, context):
lnx.utils.check_blender_version(self)
if not lnx.utils.check_saved(self):
return {"CANCELLED"}
if not lnx.utils.check_sdkpath(self):
return {"CANCELLED"}
self.report({'INFO'}, 'Publishing project, check console for details.')
lnx.utils.check_projectpath(self)
lnx.utils.check_default_props()
wrd = bpy.data.worlds['Lnx']
item = wrd.lnx_exporterlist[wrd.lnx_exporterlist_index]
if item.lnx_project_rp == '':
item.lnx_project_rp = wrd.lnx_rplist[wrd.lnx_rplist_index].name
if item.lnx_project_scene == None:
item.lnx_project_scene = context.scene
# Assume unique rp names
rplist_index = wrd.lnx_rplist_index
for i in range(0, len(wrd.lnx_rplist)):
if wrd.lnx_rplist[i].name == item.lnx_project_rp:
wrd.lnx_rplist_index = i
break
make.clean()
assets.invalidate_enabled = False
if wrd.lnx_clear_on_compile:
os.system("cls")
make.build(item.lnx_project_target, is_publish=True, is_export=True)
make.compile()
wrd.lnx_rplist_index = rplist_index
assets.invalidate_enabled = True
return{'FINISHED'}
class LeenkxOpenProjectFolderButton(bpy.types.Operator):
'''Open project folder'''
bl_idname = 'lnx.open_project_folder'
bl_label = 'Project Folder'
def execute(self, context):
if not lnx.utils.check_saved(self):
return {"CANCELLED"}
lnx.utils.open_folder(lnx.utils.get_fp())
return{'FINISHED'}
class LeenkxOpenEditorButton(bpy.types.Operator):
'''Launch this project in the IDE'''
bl_idname = 'lnx.open_editor'
bl_label = 'Code Editor'
bl_description = 'Open Project in IDE'
def execute(self, context):
if not lnx.utils.check_saved(self):
return {"CANCELLED"}
lnx.utils.check_default_props()
if not os.path.exists(lnx.utils.get_fp() + "/khafile.js"):
print('Generating Krom project for IDE build configuration')
make.build('krom')
lnx.utils.open_editor()
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("lnx.clean_project")
class CleanButtonMenu(bpy.types.Operator):
'''Clean cached data'''
bl_label = "Clean"
bl_idname = "lnx.clean_menu"
def execute(self, context):
bpy.ops.wm.call_menu(name=CleanMenu.bl_idname)
return {"FINISHED"}
class LeenkxCleanProjectButton(bpy.types.Operator):
'''Delete all cached project data'''
bl_idname = 'lnx.clean_project'
bl_label = 'Clean Project'
def execute(self, context):
if not lnx.utils.check_saved(self):
return {"CANCELLED"}
make.clean()
return{'FINISHED'}
def draw_view3d_header(self, context):
if state.proc_build is not None:
self.layout.label(text='Compiling..')
elif log.info_text != '':
self.layout.label(text=log.info_text)
def draw_view3d_object_menu(self, context):
self.layout.separator()
self.layout.operator_context = 'INVOKE_DEFAULT'
self.layout.operator('lnx.copy_traits_to_active')
class LNX_PT_TopbarPanel(bpy.types.Panel):
bl_label = "Leenkx Player"
bl_space_type = "VIEW_3D"
bl_region_type = "WINDOW"
bl_options = {'INSTANCED'}
def draw_header(self, context):
row = self.layout.row(align=True)
if state.proc_play is None and state.proc_build is None:
row.operator("lnx.play", icon="PLAY", text="")
else:
if bpy.app.version < (3, 0, 0):
row.operator("lnx.stop", icon="CANCEL", text="")
elif bpy.app.version > (3, 0, 0) and bpy.app.version < (4, 3, 2):
row.operator("lnx.stop", icon="SEQUENCE_COLOR_01", text="")
else:
row.operator("lnx.stop", icon="EVENT_MEDIASTOP", text="")
row.operator("lnx.clean_menu", icon="BRUSH_DATA", text="")
row.operator("lnx.open_editor", icon="DESKTOP", text="")
row.operator("lnx.open_project_folder", icon="FILE_FOLDER", text="")
def draw(self, context):
col = self.layout.column()
wrd = bpy.data.worlds['Lnx']
col.label(text="Leenkx Launch")
col.separator()
col.prop(wrd, 'lnx_runtime')
col.prop(wrd, 'lnx_play_camera')
col.prop(wrd, 'lnx_play_scene')
col.prop_search(wrd, 'lnx_play_renderpath', wrd, 'lnx_rplist', text='Render Path')
col.prop(wrd, 'lnx_debug_console', text="Debug Console")
def draw_space_topbar(self, context):
# for some blender reasons, topbar is instanced twice. this avoids doubling the panel
if context.region.alignment == 'RIGHT':
self.layout.popover(panel="LNX_PT_TopbarPanel", text="")
class LNX_PT_RenderPathPanel(bpy.types.Panel):
bl_label = "Leenkx Render Path"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
rows = 2
if len(wrd.lnx_rplist) > 1:
rows = 4
row = layout.row()
row.template_list("LNX_UL_RPList", "The_List", wrd, "lnx_rplist", wrd, "lnx_rplist_index", rows=rows)
col = row.column(align=True)
col.operator("lnx_rplist.new_item", icon='ADD', text="")
col.operator("lnx_rplist.delete_item", icon='REMOVE', text="")
if len(wrd.lnx_rplist) > 1:
col.separator()
op = col.operator("lnx_rplist.move_item", icon='TRIA_UP', text="")
op.direction = 'UP'
op = col.operator("lnx_rplist.move_item", icon='TRIA_DOWN', text="")
op.direction = 'DOWN'
if wrd.lnx_rplist_index < 0 or len(wrd.lnx_rplist) == 0:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
if len(lnx.api.drivers) > 0:
layout.prop_search(rpdat, "rp_driver", wrd, "rp_driver_list", text="Driver")
layout.separator()
if rpdat.rp_driver != 'Leenkx' and lnx.api.drivers[rpdat.rp_driver]['draw_props'] != None:
lnx.api.drivers[rpdat.rp_driver]['draw_props'](layout)
return
class LNX_PT_RenderPathRendererPanel(bpy.types.Panel):
bl_label = "Renderer"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_RenderPathPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
layout.prop(rpdat, 'rp_renderer')
if rpdat.rp_renderer == 'Forward':
layout.prop(rpdat, 'rp_depthprepass')
layout.prop(rpdat, 'lnx_material_model')
layout.prop(rpdat, 'rp_translucency_state')
layout.prop(rpdat, 'rp_overlays_state')
layout.prop(rpdat, 'rp_decals_state')
layout.prop(rpdat, 'rp_blending_state')
layout.prop(rpdat, 'rp_depth_texture_state')
layout.prop(rpdat, 'rp_draw_order')
layout.prop(rpdat, 'lnx_samples_per_pixel')
layout.prop(rpdat, 'lnx_texture_filter')
layout.prop(rpdat, 'rp_sss_state')
col = layout.column()
col.enabled = rpdat.rp_sss_state != 'Off'
col.prop(rpdat, 'lnx_sss_width')
layout.prop(rpdat, 'lnx_rp_displacement')
if rpdat.lnx_rp_displacement == 'Tessellation':
layout.label(text='Mesh')
layout.prop(rpdat, 'lnx_tess_mesh_inner')
layout.prop(rpdat, 'lnx_tess_mesh_outer')
layout.label(text='Shadow')
layout.prop(rpdat, 'lnx_tess_shadows_inner')
layout.prop(rpdat, 'lnx_tess_shadows_outer')
layout.prop(rpdat, 'lnx_particles')
layout.separator(factor=0.1)
col = layout.column()
col.prop(rpdat, 'lnx_skin')
col = col.column()
col.enabled = rpdat.lnx_skin == 'On'
col.prop(rpdat, 'lnx_use_armature_deform_only')
col.prop(rpdat, 'lnx_skin_max_bones_auto')
row = col.row()
row.enabled = not rpdat.lnx_skin_max_bones_auto
row.prop(rpdat, 'lnx_skin_max_bones')
layout.separator(factor=0.1)
col = layout.column()
col.prop(rpdat, 'lnx_morph_target')
col = col.column()
col.enabled = rpdat.lnx_morph_target == 'On'
layout.separator(factor=0.1)
col = layout.column()
col.prop(rpdat, "rp_hdr")
col.prop(rpdat, "rp_stereo")
col.prop(rpdat, 'lnx_culling')
col.prop(rpdat, 'rp_pp')
class LNX_PT_RenderPathShadowsPanel(bpy.types.Panel):
bl_label = "Shadows"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_RenderPathPanel"
def draw_header(self, context):
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
self.layout.prop(rpdat, "rp_shadows", text="")
def compute_subdivs(self, max, subdivs):
l = [max]
for i in range(subdivs - 1):
l.append(int(max / 2))
max = max / 2
return l
def tiles_per_light_type(self, rpdat: lnx.props_renderpath.LnxRPListItem, light_type: str) -> int:
if light_type == 'point':
return 6
elif light_type == 'spot':
return 1
else:
return int(rpdat.rp_shadowmap_cascades)
def lights_number_atlas(self, rpdat: lnx.props_renderpath.LnxRPListItem, atlas_size: int, shadowmap_size: int, light_type: str) -> int:
'''Compute number lights that could fit in an atlas'''
lights = atlas_size / shadowmap_size
lights *= lights / self.tiles_per_light_type(rpdat, light_type)
return int(lights)
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
layout.enabled = rpdat.rp_shadows
col = layout.column()
col.enabled = not rpdat.rp_shadowmap_atlas_single_map or not rpdat.rp_shadowmap_atlas
col.prop(rpdat, 'rp_shadowmap_cube')
layout.prop(rpdat, 'rp_shadowmap_cascade')
layout.prop(rpdat, 'rp_shadowmap_cascades')
layout.prop(rpdat, 'rp_shadowmap_transparent')
col = layout.column()
col2 = col.column()
col2.enabled = rpdat.rp_shadowmap_cascades != '1'
col2.prop(rpdat, 'lnx_shadowmap_split')
col.prop(rpdat, 'lnx_shadowmap_bounds')
col.prop(rpdat, 'lnx_pcfsize')
layout.separator()
layout.prop(rpdat, 'rp_shadowmap_atlas')
colatlas = layout.column()
colatlas.enabled = rpdat.rp_shadowmap_atlas
colatlas.prop(rpdat, 'rp_max_lights')
colatlas.prop(rpdat, 'rp_max_lights_cluster')
colatlas.prop(rpdat, 'rp_shadowmap_atlas_lod')
colatlas_lod = colatlas.column()
colatlas_lod.enabled = rpdat.rp_shadowmap_atlas_lod
colatlas_lod.prop(rpdat, 'rp_shadowmap_atlas_lod_subdivisions')
colatlas_lod_info = colatlas_lod.row()
colatlas_lod_info.alignment = 'RIGHT'
subdivs_list = self.compute_subdivs(int(rpdat.rp_shadowmap_cascade), int(rpdat.rp_shadowmap_atlas_lod_subdivisions))
subdiv_text = "Subdivisions for spot lights: " + ', '.join(map(str, subdivs_list))
colatlas_lod_info.label(text=subdiv_text, icon="IMAGE_ZDEPTH")
if not rpdat.rp_shadowmap_atlas_single_map:
colatlas_lod_info = colatlas_lod.row()
colatlas_lod_info.alignment = 'RIGHT'
subdivs_list = self.compute_subdivs(int(rpdat.rp_shadowmap_cube), int(rpdat.rp_shadowmap_atlas_lod_subdivisions))
subdiv_text = "Subdivisions for point lights: " + ', '.join(map(str, subdivs_list))
colatlas_lod_info.label(text=subdiv_text, icon="IMAGE_ZDEPTH")
size_warning = int(rpdat.rp_shadowmap_cascade) > 2048 or int(rpdat.rp_shadowmap_cube) > 2048
colatlas.prop(rpdat, 'rp_shadowmap_atlas_single_map')
# show size for single texture
if rpdat.rp_shadowmap_atlas_single_map:
colatlas_single = colatlas.column()
colatlas_single.prop(rpdat, 'rp_shadowmap_atlas_max_size')
if rpdat.rp_shadowmap_atlas_max_size != '':
atlas_size = int(rpdat.rp_shadowmap_atlas_max_size)
shadowmap_size = int(rpdat.rp_shadowmap_cascade)
if shadowmap_size > 2048:
size_warning = True
point_lights = self.lights_number_atlas(rpdat, atlas_size, shadowmap_size, 'point')
spot_lights = self.lights_number_atlas(rpdat, atlas_size, shadowmap_size, 'spot')
dir_lights = self.lights_number_atlas(rpdat, atlas_size, shadowmap_size, 'sun')
col = colatlas_single.row()
col.alignment = 'RIGHT'
col.label(text=f'Enough space for { point_lights } point lights or { spot_lights } spot lights or { dir_lights } directional lights.')
else:
# show size for all types
colatlas_mixed = colatlas.column()
colatlas_mixed.prop(rpdat, 'rp_shadowmap_atlas_max_size_spot')
if rpdat.rp_shadowmap_atlas_max_size_spot != '':
atlas_size = int(rpdat.rp_shadowmap_atlas_max_size_spot)
shadowmap_size = int(rpdat.rp_shadowmap_cascade)
spot_lights = self.lights_number_atlas(rpdat, atlas_size, shadowmap_size, 'spot')
if shadowmap_size > 2048:
size_warning = True
col = colatlas_mixed.row()
col.alignment = 'RIGHT'
col.label(text=f'Enough space for {spot_lights} spot lights.')
colatlas_mixed.prop(rpdat, 'rp_shadowmap_atlas_max_size_point')
if rpdat.rp_shadowmap_atlas_max_size_point != '':
atlas_size = int(rpdat.rp_shadowmap_atlas_max_size_point)
shadowmap_size = int(rpdat.rp_shadowmap_cube)
point_lights = self.lights_number_atlas(rpdat, atlas_size, shadowmap_size, 'point')
if shadowmap_size > 2048:
size_warning = True
col = colatlas_mixed.row()
col.alignment = 'RIGHT'
col.label(text=f'Enough space for {point_lights} point lights.')
colatlas_mixed.prop(rpdat, 'rp_shadowmap_atlas_max_size_sun')
if rpdat.rp_shadowmap_atlas_max_size_sun != '':
atlas_size = int(rpdat.rp_shadowmap_atlas_max_size_sun)
shadowmap_size = int(rpdat.rp_shadowmap_cascade)
dir_lights = self.lights_number_atlas(rpdat, atlas_size, shadowmap_size, 'sun')
if shadowmap_size > 2048:
size_warning = True
col = colatlas_mixed.row()
col.alignment = 'RIGHT'
col.label(text=f'Enough space for {dir_lights} directional lights.')
# show warning when user picks a size higher than 2048 (arbitrary number).
if size_warning:
col = layout.column()
row = col.row()
row.alignment = 'RIGHT'
row.label(text='Warning: Game will crash if texture size is higher than max texture size allowed by target.', icon='ERROR')
class LNX_PT_RenderPathVoxelsPanel(bpy.types.Panel):
bl_label = "Voxels"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_RenderPathPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
layout.prop(rpdat, 'rp_voxels')
col = layout.column()
col.enabled = rpdat.rp_voxels != 'Off'
col2 = col.column()
col2.enabled = rpdat.rp_voxels == 'Voxel GI'
col3 = col.column()
col3.enabled = rpdat.rp_voxels == 'Voxel AO'
col.prop(rpdat, 'lnx_voxelgi_shadows', text='Shadows')
col2.prop(rpdat, 'lnx_voxelgi_refract', text='Refraction')
#col.prop(rpdat, 'lnx_voxelgi_clipmap_count')
#col.prop(rpdat, 'lnx_voxelgi_cones')
col.prop(rpdat, 'rp_voxelgi_resolution')
col.prop(rpdat, 'lnx_voxelgi_size')
#col.prop(rpdat, 'rp_voxelgi_resolution_z')
col2.enabled = rpdat.rp_voxels == 'Voxel GI'
#col.prop(rpdat, 'lnx_voxelgi_temporal')
col.label(text="Light")
col2 = col.column()
col2.enabled = rpdat.rp_voxels == 'Voxel GI'
col2.prop(rpdat, 'lnx_voxelgi_diff')
col2.prop(rpdat, 'lnx_voxelgi_spec')
col2.prop(rpdat, 'lnx_voxelgi_refr')
col.prop(rpdat, 'lnx_voxelgi_shad')
col.prop(rpdat, 'lnx_voxelgi_env')
col.prop(rpdat, 'lnx_voxelgi_occ')
col.label(text="Ray")
#col.prop(rpdat, 'lnx_voxelgi_offset')
col.prop(rpdat, 'lnx_voxelgi_step')
col.prop(rpdat, 'lnx_voxelgi_range')
#col.prop(rpdat, 'lnx_voxelgi_aperture')
class LNX_PT_RenderPathWorldPanel(bpy.types.Panel):
bl_label = "World"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_RenderPathPanel"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
layout.prop(rpdat, "rp_background")
col = layout.column()
col.prop(rpdat, 'lnx_irradiance')
colb = col.column()
colb.enabled = rpdat.lnx_irradiance
colb.prop(rpdat, 'lnx_radiance')
sub = colb.row()
sub.enabled = rpdat.lnx_radiance
sub.prop(rpdat, 'lnx_radiance_size')
layout.separator()
layout.prop(rpdat, 'lnx_clouds')
col = layout.column(align=True)
col.prop(rpdat, "rp_water")
col = col.column(align=True)
col.enabled = rpdat.rp_water
col.prop(rpdat, 'lnx_water_level')
col.prop(rpdat, 'lnx_water_density')
col.prop(rpdat, 'lnx_water_displace')
col.prop(rpdat, 'lnx_water_speed')
col.prop(rpdat, 'lnx_water_freq')
col.prop(rpdat, 'lnx_water_refract')
col.prop(rpdat, 'lnx_water_reflect')
col.prop(rpdat, 'lnx_water_color')
class LNX_PT_RenderPathPostProcessPanel(bpy.types.Panel):
bl_label = "Post Process"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_RenderPathPanel"
def draw_header(self, context):
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
self.layout.prop(rpdat, "rp_render_to_texture", text="")
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
layout.enabled = rpdat.rp_render_to_texture
col = layout.column()
col.prop(rpdat, "rp_antialiasing")
col.prop(rpdat, "rp_supersampling")
col = layout.column()
col.prop(rpdat, 'lnx_rp_resolution')
if rpdat.lnx_rp_resolution == 'Custom':
col.prop(rpdat, 'lnx_rp_resolution_size')
col.prop(rpdat, 'lnx_rp_resolution_filter')
col.prop(rpdat, 'rp_dynres')
layout.separator()
col = layout.column()
col.prop(rpdat, "rp_ssgi")
sub = col.column()
sub.enabled = rpdat.rp_ssgi != 'Off'
sub.prop(rpdat, 'lnx_ssgi_half_res')
#sub.prop(rpdat, 'lnx_ssgi_rays')
sub.prop(rpdat, 'lnx_ssgi_radius')
sub.prop(rpdat, 'lnx_ssgi_strength')
sub.prop(rpdat, 'lnx_ssgi_samples')
layout.separator()
row = layout.row()
row.enabled = rpdat.lnx_material_model == 'Full'
row.prop(rpdat, 'lnx_micro_shadowing')
layout.separator()
col = layout.column()
col.prop(rpdat, "rp_ssr")
col.prop(rpdat, 'lnx_ssr_half_res')
col = col.column()
col.enabled = rpdat.rp_ssr
col.prop(rpdat, 'lnx_ssr_ray_step')
col.prop(rpdat, 'lnx_ssr_search_dist')
col.prop(rpdat, 'lnx_ssr_falloff_exp')
col.prop(rpdat, 'lnx_ssr_jitter')
layout.separator()
col = layout.column()
col.prop(rpdat, "rp_ss_refraction")
col = col.column()
col.enabled = rpdat.rp_ss_refraction
col.prop(rpdat, 'lnx_ss_refraction_ray_step')
col.prop(rpdat, 'lnx_ss_refraction_search_dist')
col.prop(rpdat, 'lnx_ss_refraction_falloff_exp')
col.prop(rpdat, 'lnx_ss_refraction_jitter')
layout.separator()
col = layout.column()
col.prop(rpdat, 'lnx_ssrs')
col = col.column()
col.enabled = rpdat.lnx_ssrs
col.prop(rpdat, 'lnx_ssrs_ray_step')
layout.separator()
col = layout.column()
col.prop(rpdat, "rp_bloom")
_col = col.column()
_col.enabled = rpdat.rp_bloom
if bpy.app.version < (4, 3, 0):
_col.prop(rpdat, 'lnx_bloom_follow_blender')
if not rpdat.lnx_bloom_follow_blender:
_col.prop(rpdat, 'lnx_bloom_threshold')
_col.prop(rpdat, 'lnx_bloom_knee')
_col.prop(rpdat, 'lnx_bloom_radius')
_col.prop(rpdat, 'lnx_bloom_strength')
else:
_col.prop(rpdat, 'lnx_bloom_threshold')
_col.prop(rpdat, 'lnx_bloom_knee')
_col.prop(rpdat, 'lnx_bloom_radius')
_col.prop(rpdat, 'lnx_bloom_strength')
_col.prop(rpdat, 'lnx_bloom_quality')
_col.prop(rpdat, 'lnx_bloom_anti_flicker')
layout.separator()
col = layout.column()
col.prop(rpdat, "rp_motionblur")
col = col.column()
col.enabled = rpdat.rp_motionblur != 'Off'
col.prop(rpdat, 'lnx_motion_blur_intensity')
layout.separator()
col = layout.column()
col.prop(rpdat, "rp_volumetriclight")
col = col.column()
col.enabled = rpdat.rp_volumetriclight
col.prop(rpdat, 'lnx_volumetric_light_air_color')
col.prop(rpdat, 'lnx_volumetric_light_air_turbidity')
col.prop(rpdat, 'lnx_volumetric_light_steps')
layout.separator()
col = layout.column()
col.prop(rpdat, "rp_chromatic_aberration")
col = col.column()
col.enabled = rpdat.rp_chromatic_aberration
col.prop(rpdat, 'lnx_chromatic_aberration_type')
col.prop(rpdat, 'lnx_chromatic_aberration_strength')
if rpdat.lnx_chromatic_aberration_type == "Spectral":
col.prop(rpdat, 'lnx_chromatic_aberration_samples')
class LNX_PT_RenderPathCompositorPanel(bpy.types.Panel):
bl_label = "Compositor"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "LNX_PT_RenderPathPanel"
def draw_header(self, context):
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
self.layout.prop(rpdat, "rp_compositornodes", text="")
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
if len(wrd.lnx_rplist) <= wrd.lnx_rplist_index:
return
rpdat = wrd.lnx_rplist[wrd.lnx_rplist_index]
layout.enabled = rpdat.rp_compositornodes
layout.prop(rpdat, 'lnx_tonemap')
layout.prop(rpdat, 'lnx_dithering')
if rpdat.lnx_dithering != 'Off':
row = layout.row(align=True)
row.prop(rpdat, 'lnx_dithering_strength')
layout.separator()
col = layout.column()
col.prop(rpdat, 'lnx_letterbox')
col = col.column(align=True)
col.enabled = rpdat.lnx_letterbox
col.prop(rpdat, 'lnx_letterbox_color')
col.prop(rpdat, 'lnx_letterbox_size')
layout.separator()
col = layout.column()
col.prop(rpdat, 'lnx_sharpen')
col = col.column(align=True)
col.enabled = rpdat.lnx_sharpen
col.prop(rpdat, 'lnx_sharpen_color')
col.prop(rpdat, 'lnx_sharpen_size')
col.prop(rpdat, 'lnx_sharpen_strength')
layout.separator()
col = layout.column()
draw_conditional_prop(col, 'Distort', rpdat, 'lnx_distort', 'lnx_distort_strength')
draw_conditional_prop(col, 'Film Grain', rpdat, 'lnx_grain', 'lnx_grain_strength')
draw_conditional_prop(col, 'Vignette', rpdat, 'lnx_vignette', 'lnx_vignette_strength')
layout.separator()
col = layout.column()
col.prop(rpdat, 'lnx_fog')
col = col.column(align=True)
col.enabled = rpdat.lnx_fog
col.prop(rpdat, 'lnx_fog_color')
col.prop(rpdat, 'lnx_fog_amounta')
col.prop(rpdat, 'lnx_fog_amountb')
layout.separator()
col = layout.column()
col.prop(rpdat, "rp_autoexposure")
sub = col.column(align=True)
sub.enabled = rpdat.rp_autoexposure
sub.prop(rpdat, 'lnx_autoexposure_strength', text='Strength')
sub.prop(rpdat, 'lnx_autoexposure_speed', text='Speed')
layout.separator()
col = layout.column()
col.prop(rpdat, 'lnx_fisheye')
col.prop(rpdat, 'lnx_lensflare')
layout.separator()
col = layout.column()
col.prop(rpdat, 'lnx_lens')
col = col.column(align=True)
col.enabled = rpdat.lnx_lens
col.prop(rpdat, 'lnx_lens_texture')
if rpdat.lnx_lens_texture != "":
col.prop(rpdat, 'lnx_lens_texture_masking')
if rpdat.lnx_lens_texture_masking:
sub = col.column(align=True)
sub.prop(rpdat, 'lnx_lens_texture_masking_centerMinClip')
sub.prop(rpdat, 'lnx_lens_texture_masking_centerMaxClip')
sub = col.column(align=True)
sub.prop(rpdat, 'lnx_lens_texture_masking_luminanceMin')
sub.prop(rpdat, 'lnx_lens_texture_masking_luminanceMax')
col.prop(rpdat, 'lnx_lens_texture_masking_brightnessExp')
layout.separator()
layout.separator()
col = layout.column()
col.prop(rpdat, 'lnx_lut')
col = col.column(align=True)
col.enabled = rpdat.lnx_lut
col.prop(rpdat, 'lnx_lut_texture')
layout.separator()
class LNX_PT_BakePanel(bpy.types.Panel):
bl_label = "Leenkx Bake"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
scn = bpy.data.scenes[context.scene.name]
row = layout.row(align=True)
row.prop(scn, "lnx_bakemode", expand=True)
if scn.lnx_bakemode == "Static Map":
row = layout.row(align=True)
row.alignment = 'EXPAND'
row.operator("lnx.bake_textures", icon="RENDER_STILL")
row.operator("lnx.bake_apply")
col = layout.column()
col.prop(scn, 'lnx_bakelist_scale')
col.prop(scn.cycles, "samples")
layout.prop(scn, 'lnx_bakelist_unwrap')
rows = 2
if len(scn.lnx_bakelist) > 1:
rows = 4
row = layout.row()
row.template_list("LNX_UL_BakeList", "The_List", scn, "lnx_bakelist", scn, "lnx_bakelist_index", rows=rows)
col = row.column(align=True)
col.operator("lnx_bakelist.new_item", icon='ADD', text="")
col.operator("lnx_bakelist.delete_item", icon='REMOVE', text="")
col.menu("LNX_MT_BakeListSpecials", icon='DOWNARROW_HLT', text="")
if len(scn.lnx_bakelist) > 1:
col.separator()
op = col.operator("lnx_bakelist.move_item", icon='TRIA_UP', text="")
op.direction = 'UP'
op = col.operator("lnx_bakelist.move_item", icon='TRIA_DOWN', text="")
op.direction = 'DOWN'
if scn.lnx_bakelist_index >= 0 and len(scn.lnx_bakelist) > 0:
item = scn.lnx_bakelist[scn.lnx_bakelist_index]
layout.prop_search(item, "obj", bpy.data, "objects", text="Object")
layout.prop(item, "res_x")
layout.prop(item, "res_y")
class LnxGenLodButton(bpy.types.Operator):
"""Automatically generate LoD levels."""
bl_idname = 'lnx.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.lnx_lodlist_index = 0
mdata.lnx_lodlist.clear()
# Lod levels
wrd = bpy.data.worlds['Lnx']
ratio = wrd.lnx_lod_gen_ratio
num_levels = wrd.lnx_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_viewport = True
new_obj.hide_render = True
mod = new_obj.modifiers.new('Decimate', 'DECIMATE')
mod.ratio = ratio
ratio *= wrd.lnx_lod_gen_ratio
context.scene.collection.objects.link(new_obj)
# Screen sizes
for level in range(0, num_levels):
mdata.lnx_lodlist.add()
mdata.lnx_lodlist[-1].name = self.lod_name(obj.name, level)
mdata.lnx_lodlist[-1].screen_size_prop = (1 - (1 / (num_levels + 1)) * level) - (1 / (num_levels + 1))
return{'FINISHED'}
class LNX_PT_LodPanel(bpy.types.Panel):
bl_label = "Leenkx Lod"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "object"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
obj = bpy.context.object
# Mesh only for now
if obj.type != 'MESH':
return
mdata = obj.data
rows = 2
if len(mdata.lnx_lodlist) > 1:
rows = 4
row = layout.row()
row.template_list("LNX_UL_LodList", "The_List", mdata, "lnx_lodlist", mdata, "lnx_lodlist_index", rows=rows)
col = row.column(align=True)
col.operator("lnx_lodlist.new_item", icon='ADD', text="")
col.operator("lnx_lodlist.delete_item", icon='REMOVE', text="")
if len(mdata.lnx_lodlist) > 1:
col.separator()
op = col.operator("lnx_lodlist.move_item", icon='TRIA_UP', text="")
op.direction = 'UP'
op = col.operator("lnx_lodlist.move_item", icon='TRIA_DOWN', text="")
op.direction = 'DOWN'
if mdata.lnx_lodlist_index >= 0 and len(mdata.lnx_lodlist) > 0:
item = mdata.lnx_lodlist[mdata.lnx_lodlist_index]
layout.prop_search(item, "name", bpy.data, "objects", text="Object")
layout.prop(item, "screen_size_prop")
layout.prop(mdata, "lnx_lod_material")
# Auto lod for meshes
if obj.type == 'MESH':
layout.separator()
layout.operator("lnx.generate_lod")
wrd = bpy.data.worlds['Lnx']
layout.prop(wrd, 'lnx_lod_gen_levels')
layout.prop(wrd, 'lnx_lod_gen_ratio')
class LnxGenTerrainButton(bpy.types.Operator):
'''Generate terrain sectors'''
bl_idname = 'lnx.generate_terrain'
bl_label = 'Generate'
def execute(self, context):
scn = context.scene
if scn == None:
return{'CANCELLED'}
sectors = scn.lnx_terrain_sectors
size = scn.lnx_terrain_sector_size
height_scale = scn.lnx_terrain_height_scale
# Create material
mat = bpy.data.materials.new(name="Terrain")
mat.use_nodes = True
nodes = mat.node_tree.nodes
links = mat.node_tree.links
node = nodes.new('ShaderNodeDisplacement')
node.location = (-200, 100)
node.inputs[2].default_value = height_scale
node.space = 'WORLD'
links.new(nodes['Material Output'].inputs[2], node.outputs[0])
node = nodes.new('ShaderNodeTexImage')
node.location = (-600, 100)
node.interpolation = 'Closest'
node.extension = 'EXTEND'
node.lnx_material_param = True
node.name = '_TerrainHeight'
node.label = '_TerrainHeight' # Height-map texture link for this sector
links.new(nodes['Displacement'].inputs[0], nodes['_TerrainHeight'].outputs[0])
node = nodes.new('ShaderNodeBump')
node.location = (-200, -200)
node.inputs[0].default_value = 5.0
links.new(nodes['Bump'].inputs[2], nodes['_TerrainHeight'].outputs[0])
links.new(nodes['Principled BSDF'].inputs[20], nodes['Bump'].outputs[0])
# Create sectors
root_obj = bpy.data.objects.new("Terrain", None)
root_obj.location[0] = 0
root_obj.location[1] = 0
root_obj.location[2] = 0
root_obj.lnx_export = False
scn.collection.objects.link(root_obj)
scn.lnx_terrain_object = root_obj
for i in range(sectors[0] * sectors[1]):
j = str(i + 1).zfill(2)
x = i % sectors[0]
y = int(i / sectors[0])
bpy.ops.mesh.primitive_plane_add(location=(x * size, -y * size, 0))
slice_obj = bpy.context.active_object
slice_obj.scale[0] = size / 2
slice_obj.scale[1] = -(size / 2)
slice_obj.scale[2] = height_scale
slice_obj.data.materials.append(mat)
for p in slice_obj.data.polygons:
p.use_smooth = True
slice_obj.name = 'Terrain.' + j
slice_obj.parent = root_obj
sub_mod = slice_obj.modifiers.new('Subdivision', 'SUBSURF')
sub_mod.subdivision_type = 'SIMPLE'
disp_mod = slice_obj.modifiers.new('Displace', 'DISPLACE')
disp_mod.texture_coords = 'UV'
disp_mod.texture = bpy.data.textures.new(name='Terrain.' + j, type='IMAGE')
disp_mod.texture.extension = 'EXTEND'
disp_mod.texture.use_interpolation = False
disp_mod.texture.use_mipmap = False
disp_mod.texture.image = bpy.data.images.load(filepath=scn.lnx_terrain_textures+'/heightmap_' + j + '.png')
f = 1
levels = 0
while f < disp_mod.texture.image.size[0]:
f *= 2
levels += 1
sub_mod.levels = sub_mod.render_levels = levels
return{'FINISHED'}
class LNX_PT_TerrainPanel(bpy.types.Panel):
bl_label = "Leenkx Terrain"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "scene"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
scn = bpy.context.scene
if scn == None:
return
layout.prop(scn, 'lnx_terrain_textures')
layout.prop(scn, 'lnx_terrain_sectors')
layout.prop(scn, 'lnx_terrain_sector_size')
layout.prop(scn, 'lnx_terrain_height_scale')
layout.operator('lnx.generate_terrain')
layout.prop(scn, 'lnx_terrain_object')
class LNX_PT_TilesheetPanel(bpy.types.Panel):
bl_label = "Leenkx Tilesheet"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "material"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
rows = 2
if len(wrd.lnx_tilesheetlist) > 1:
rows = 4
row = layout.row()
row.template_list("LNX_UL_TilesheetList", "The_List", wrd, "lnx_tilesheetlist", wrd, "lnx_tilesheetlist_index", rows=rows)
col = row.column(align=True)
col.operator("lnx_tilesheetlist.new_item", icon='ADD', text="")
col.operator("lnx_tilesheetlist.delete_item", icon='REMOVE', text="")
if len(wrd.lnx_tilesheetlist) > 1:
col.separator()
op = col.operator("lnx_tilesheetlist.move_item", icon='TRIA_UP', text="")
op.direction = 'UP'
op = col.operator("lnx_tilesheetlist.move_item", icon='TRIA_DOWN', text="")
op.direction = 'DOWN'
if wrd.lnx_tilesheetlist_index >= 0 and len(wrd.lnx_tilesheetlist) > 0:
dat = wrd.lnx_tilesheetlist[wrd.lnx_tilesheetlist_index]
layout.prop(dat, "tilesx_prop")
layout.prop(dat, "tilesy_prop")
layout.prop(dat, "framerate_prop")
layout.label(text='Actions')
rows = 2
if len(dat.lnx_tilesheetactionlist) > 1:
rows = 4
row = layout.row()
row.template_list("LNX_UL_TilesheetList", "The_List", dat, "lnx_tilesheetactionlist", dat, "lnx_tilesheetactionlist_index", rows=rows)
col = row.column(align=True)
col.operator("lnx_tilesheetactionlist.new_item", icon='ADD', text="")
col.operator("lnx_tilesheetactionlist.delete_item", icon='REMOVE', text="")
if len(dat.lnx_tilesheetactionlist) > 1:
col.separator()
op = col.operator("lnx_tilesheetactionlist.move_item", icon='TRIA_UP', text="")
op.direction = 'UP'
op = col.operator("lnx_tilesheetactionlist.move_item", icon='TRIA_DOWN', text="")
op.direction = 'DOWN'
if dat.lnx_tilesheetactionlist_index >= 0 and len(dat.lnx_tilesheetactionlist) > 0:
adat = dat.lnx_tilesheetactionlist[dat.lnx_tilesheetactionlist_index]
layout.prop(adat, "start_prop")
layout.prop(adat, "end_prop")
layout.prop(adat, "loop_prop")
class LnxPrintTraitsButton(bpy.types.Operator):
bl_idname = 'lnx.print_traits'
bl_label = 'Print All Traits'
bl_description = 'Returns all traits in current blend'
def execute(self, context):
for s in bpy.data.scenes:
print('Scene: {0}'.format(s.name))
for t in s.lnx_traitlist:
if not t.enabled_prop:
continue
tname = "undefined"
if t.type_prop == 'Haxe Script' or "Bundled":
tname = t.class_name_prop
if t.type_prop == 'Logic Nodes':
tname = t.node_tree_prop.name
if t.type_prop == 'UI Canvas':
tname = t.canvas_name_prop
if t.type_prop == 'WebAssembly':
tname = t.webassembly_prop
print('Scene Trait: {0} ("{1}")'.format(s.name, tname))
for o in s.objects:
for t in o.lnx_traitlist:
if not t.enabled_prop:
continue
tname = "undefined"
if t.type_prop == 'Haxe Script' or "Bundled":
tname = t.class_name_prop
if t.type_prop == 'Logic Nodes':
tname = t.node_tree_prop.name
if t.type_prop == 'UI Canvas':
tname = t.canvas_name_prop
if t.type_prop == 'WebAssembly':
tname = t.webassembly_prop
print(' Object Trait: {0} ("{1}")'.format(o.name, tname))
return{'FINISHED'}
class LNX_PT_MaterialNodePanel(bpy.types.Panel):
bl_label = 'Leenkx Material Node'
bl_idname = 'LNX_PT_MaterialNodePanel'
bl_space_type = 'NODE_EDITOR'
bl_region_type = 'UI'
bl_category = 'Leenkx'
@classmethod
def poll(cls, context):
return (context.space_data.tree_type == 'ShaderNodeTree'
and context.space_data.edit_tree
and context.space_data.shader_type == 'OBJECT')
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
n = context.active_node
if n != None and (n.bl_idname == 'ShaderNodeRGB' or n.bl_idname == 'ShaderNodeValue' or n.bl_idname == 'ShaderNodeTexImage'):
layout.prop(context.active_node, 'lnx_material_param')
class LNX_OT_CopyToBundled(bpy.types.Operator):
bl_label = 'Copy To Bundled'
bl_idname = 'lnx.copy_to_bundled'
bl_description = ('Copies and repaths external image assets to project Bundled folder')
def execute(self, context):
self.copy_to_bundled(bpy.data.images)
return {'FINISHED'}
@classmethod
def copy_to_bundled(self, data):
wrd = bpy.data.worlds['Lnx']
project_path = lnx.utils.get_fp()
# Blend - Images
for asset in data:
# File is saved
if asset.filepath_from_user() != '':
bundled_filepath = project_path + '/Bundled/' + asset.name
try:
# Exists -> Yes
if os.path.isfile(bundled_filepath):
# Override -> Yes
if (wrd.lnx_copy_override):
# Valid file
if asset.has_data:
asset.filepath_raw = bundled_filepath
asset.save()
asset.reload()
# Syntax - Yellow
print(log.colorize(f'Asset name "{asset.name}" already exists, overriding the original', 33), file=sys.stderr)
# Invalid file or corrupted
else:
# Syntax - Red
log.error(f'Asset name "{asset.name}" has no data to save or copy, skipping')
continue
# Override -> No
else:
# Syntax - Yellow
print(log.colorize(f'Asset name "{asset.name}" already exists, skipping', 33), file=sys.stderr)
continue
# Exists -> No
else:
# Valid file
if asset.has_data:
asset.filepath_raw = bundled_filepath
asset.save()
asset.reload()
# Syntax - Green
print(log.colorize(f'Asset name "{asset.name}" was successfully copied', 32), file=sys.stderr)
# Invalid file or corrupted
else:
# Syntax - Red
log.error(f'Asset name "{asset.name}" has no data to save or copy, skipping')
continue
except:
# Syntax - Red
log.error(f'Insufficient write permissions or other issues occurred')
continue
# File is unsaved
else:
# Syntax - Purple
log.warn(f'Asset name "{asset.name}" is either packed or unsaved, skipping')
continue
class LNX_OT_ShowFileVersionInfo(bpy.types.Operator):
bl_label = 'Show old file version info'
bl_idname = 'lnx.show_old_file_version_info'
bl_description = ('Displays an info panel that warns about opening a file'
'which was created in a previous version of Leenkx')
bl_options = {'INTERNAL'}
wrd = None
def draw_message_box(self, context):
file_version = LNX_OT_ShowFileVersionInfo.wrd.lnx_version
current_version = props.lnx_version
layout = self.layout
layout = layout.column(align=True)
layout.alignment = 'EXPAND'
if current_version == file_version:
layout.label('This file was saved in', icon='INFO')
layout.label('the current Leenkx version', icon='BLANK1')
layout.separator()
layout.label(f'(version: {current_version}')
row = layout.row(align=True)
row.active_default = True
row.operator('lnx.discard_popup', text='Ok')
# this will help order versions better, somewhat.
# note: this is NOT complete
current_version = tuple( current_version.split('.') )
file_version = tuple( file_version.split('.') )
if current_version > file_version:
layout.label(text='Warning: This file was saved in a', icon='ERROR')
layout.label(text='previous version of Leenkx!', icon='BLANK1')
layout.separator()
layout.label(text='Please inform yourself about breaking changes!', icon='BLANK1')
layout.label(text=f'File saved in: {file_version}', icon='BLANK1')
layout.label(text=f'Current version: {current_version}', icon='BLANK1')
layout.separator()
layout.separator()
layout.label(text='Should Leenkx try to automatically update', icon='BLANK1')
layout.label(text='the file to the current SDK version?', icon='BLANK1')
layout.separator()
row = layout.row(align=True)
row.active_default = True
row.operator('lnx.update_file_sdk', text='Yes')
row.active_default = False
row.operator('lnx.discard_popup', text='No')
else:
layout.label(text='Warning: This file was saved in a', icon='ERROR')
layout.label(text='future version of Leenkx!', icon='BLANK1')
layout.separator()
layout.label(text='It is impossible to downgrade a file,', icon='BLANK1')
layout.label(text='Something will probably be broken here.', icon='BLANK1')
layout.label(text=f'File saved in: {file_version}', icon='BLANK1')
layout.label(text=f'Current version: {current_version}', icon='BLANK1')
layout.separator()
layout.separator()
layout.label(text='Please check how this file was created', icon='BLANK1')
layout.separator()
row = layout.row(align=True)
row.active_default = True
row.operator('lnx.discard_popup', text='Ok')
def execute(self, context):
LNX_OT_ShowFileVersionInfo.wrd = bpy.data.worlds['Lnx']
context.window_manager.popover(LNX_OT_ShowFileVersionInfo.draw_message_box, ui_units_x=16)
return {"FINISHED"}
class LNX_OT_ShowNodeUpdateErrors(bpy.types.Operator):
bl_label = 'Show upgrade failure details'
bl_idname = 'lnx.show_node_update_errors'
bl_description = ('Displays an info panel that shows the different errors that occurred when upgrading nodes')
wrd = None # a helper internal variable
def draw_message_box(self, context):
list_of_errors = lnx.logicnode.replacement.replacement_errors.copy()
# note: list_of_errors is a set of tuples: `(error_type, node_class, tree_name)`
# where `error_type` can be "unregistered", "update failed", "future version", "bad version", or "misc."
file_version = LNX_OT_ShowNodeUpdateErrors.wrd.lnx_version
current_version = props.lnx_version
# this will help order versions better, somewhat.
# note: this is NOT complete
current_version_2 = tuple(current_version.split('.'))
file_version_2 = tuple(file_version.split('.'))
is_leenkx_upgrade = (current_version_2 > file_version_2)
error_types = set()
errored_trees = set()
errored_nodes = set()
for error_entry in list_of_errors:
error_types.add(error_entry[0])
errored_nodes.add(error_entry[1])
errored_trees.add(error_entry[2])
layout = self.layout
layout = layout.column(align=True)
layout.alignment = 'EXPAND'
layout.label(text="Some nodes failed to be updated to the current Leenkx version", icon="ERROR")
if current_version == file_version:
layout.label(text="(This might be because you are using a development snapshot, or a homemade version ;) )", icon='BLANK1')
elif not is_leenkx_upgrade:
layout.label(text="(Please note that it is not possible do downgrade nodes to a previous version either.", icon='BLANK1')
layout.label(text="This might be the cause of your problem.)", icon='BLANK1')
layout.label(text=f'File saved in: {file_version}', icon='BLANK1')
layout.label(text=f'Current version: {current_version}', icon='BLANK1')
layout.separator()
if 'update failed' in error_types:
layout.label(text="Some nodes do not have an update procedure to deal with the version saved in this file.", icon='BLANK1')
if current_version == file_version:
layout.label(text="(if you are a developer, this might be because you didn't implement it yet.)", icon='BLANK1')
if 'bad version' in error_types:
layout.label(text="Some nodes do not have version information attached to them.", icon='BLANK1')
if 'unregistered' in error_types:
if is_leenkx_upgrade:
layout.label(text='Some nodes seem to be too old to be understood by leenkx anymore', icon='BLANK1')
else:
layout.label(text="Some nodes are unknown to leenkx, either because they are too new or too old.", icon='BLANK1')
if 'future version' in error_types:
if is_leenkx_upgrade:
layout.label(text='Somehow, some nodes seem to have been created with a future version of leenkx.', icon='BLANK1')
else:
layout.label(text='Some nodes seem to have been created with a future version of leenkx.', icon='BLANK1')
if 'misc.' in error_types:
layout.label(text="Some nodes' update procedure failed to complete")
layout.separator()
layout.label(text='the nodes impacted are the following:', icon='BLANK1')
for node in errored_nodes:
layout.label(text=f' {node}', icon='BLANK1')
layout.separator()
layout.label(text='the node trees impacted are the following:', icon='BLANK1')
for tree in errored_trees:
layout.label(text=f' "{tree}"', icon='BLANK1')
layout.separator()
layout.label(text="A detailed error report has been saved next to the blender file.", icon='BLANK1')
layout.label(text="the file name is \"node_update_failure\", followed by the current time.", icon='BLANK1')
layout.separator()
row = layout.row(align=True)
row.active_default = False
row.operator('lnx.discard_popup', text='Ok')
row.operator('lnx.open_project_folder', text='Open Project Folder', icon="FILE_FOLDER")
def execute(self, context):
LNX_OT_ShowNodeUpdateErrors.wrd = bpy.data.worlds['Lnx']
context.window_manager.popover(LNX_OT_ShowNodeUpdateErrors.draw_message_box, ui_units_x=32)
return {"FINISHED"}
class LNX_OT_UpdateFileSDK(bpy.types.Operator):
bl_idname = 'lnx.update_file_sdk'
bl_label = 'Update file to current SDK version'
bl_description = bl_label
bl_options = {'INTERNAL'}
def execute(self, context):
wrd = bpy.data.worlds['Lnx']
# This allows for seamless migration from earlier versions of Leenkx
for rp in wrd.lnx_rplist: # TODO: deprecated
if rp.rp_gi != 'Off':
rp.rp_gi = 'Off'
rp.rp_voxelao = True
# Replace deprecated nodes
lnx.logicnode.replacement.replace_all()
wrd.lnx_version = props.lnx_version
wrd.lnx_commit = props.lnx_commit
lnx.make.clean()
print(f'Project updated to SDK {props.lnx_version}. Please save the .blend file.')
return {'FINISHED'}
class LNX_OT_DiscardPopup(bpy.types.Operator):
"""Empty operator for discarding dialogs."""
bl_idname = 'lnx.discard_popup'
bl_label = 'OK'
bl_description = 'Discard'
bl_options = {'INTERNAL'}
def execute(self, context):
return {'FINISHED'}
class LeenkxUpdateListAndroidEmulatorButton(bpy.types.Operator):
'''Updating the list of emulators for the Android platform'''
bl_idname = 'lnx.update_list_android_emulator'
bl_label = 'Update List Emulators'
def execute(self, context):
if not lnx.utils.check_saved(self):
return {"CANCELLED"}
if not lnx.utils.check_sdkpath(self):
return {"CANCELLED"}
if len(lnx.utils.get_android_sdk_root_path()) == 0:
return {"CANCELLED"}
os.environ['ANDROID_SDK_ROOT'] = lnx.utils.get_android_sdk_root_path()
items, err = lnx.utils.get_android_emulators_list()
if len(err) > 0:
print('Update List Emulators Warning: File "'+ lnx.utils.get_android_emulator_file() +'" not found. Check that the variable ANDROID_SDK_ROOT is correct in environment variables or in "Android SDK Path" setting: \n- If you specify an environment variable ANDROID_SDK_ROOT, then you need to restart Blender;\n- If you specify the setting "Android SDK Path", then repeat operation "Publish"')
return{'FINISHED'}
if len(items) > 0:
items_enum = []
for i in items:
items_enum.append((i, i, i))
bpy.types.World.lnx_project_android_list_avd = EnumProperty(items=items_enum, name="Emulator", update=assets.invalidate_compiler_cache)
return{'FINISHED'}
class LeenkxUpdateListAndroidEmulatorRunButton(bpy.types.Operator):
'''Launch Android emulator selected from the list'''
bl_idname = 'lnx.run_android_emulator'
bl_label = 'Launch Emulator'
def execute(self, context):
if not lnx.utils.check_saved(self):
return {"CANCELLED"}
if not lnx.utils.check_sdkpath(self):
return {"CANCELLED"}
if len(lnx.utils.get_android_sdk_root_path()) == 0:
return {"CANCELLED"}
make.run_android_emulators(lnx.utils.get_android_emulator_name())
return{'FINISHED'}
class LeenkxUpdateListInstalledVSButton(bpy.types.Operator):
"""Update the list of installed Visual Studio versions for the Windows platform"""
bl_idname = 'lnx.update_list_installed_vs'
bl_label = '(Re-)Fetch Installed Visual Studio Versions'
def execute(self, context):
if not lnx.utils.get_os_is_windows():
return {"CANCELLED"}
success = lnx.utils_vs.fetch_installed_vs()
if not success:
self.report({"ERROR"}, "Could not fetch installed Visual Studio versions, check console for details.")
return {'CANCELLED'}
return {'FINISHED'}
class LNX_PT_PhysicsProps(bpy.types.Panel):
bl_label = "Leenkx Props"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "scene"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "SCENE_PT_rigid_body_world"
@classmethod
def poll(cls, context):
return context.scene.rigidbody_world is not None
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
if wrd.lnx_physics_engine != 'Bullet' and wrd.lnx_physics_engine != 'Oimo':
row = layout.row()
row.alert = True
row.label(text="Physics debug drawing is only supported for the Bullet and Oimo physics engines")
col = layout.column(align=False)
col.prop(wrd, "lnx_physics_fixed_step")
class LNX_PT_PhysicsDebugDrawingPanel(bpy.types.Panel):
bl_label = "Leenkx Debug Drawing"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "scene"
bl_options = {'DEFAULT_CLOSED'}
bl_parent_id = "SCENE_PT_rigid_body_world"
@classmethod
def poll(cls, context):
return context.scene.rigidbody_world is not None
def draw(self, context):
layout = self.layout
layout.use_property_split = True
layout.use_property_decorate = False
wrd = bpy.data.worlds['Lnx']
if wrd.lnx_physics_engine != 'Bullet' and wrd.lnx_physics_engine != 'Oimo':
row = layout.row()
row.alert = True
row.label(text="Physics debug drawing is only supported for the Bullet and Oimo physics engines")
col = layout.column(align=False)
col.prop(wrd, "lnx_physics_dbg_draw_wireframe")
col.prop(wrd, "lnx_physics_dbg_draw_raycast")
col.prop(wrd, "lnx_physics_dbg_draw_aabb")
col.prop(wrd, "lnx_physics_dbg_draw_contact_points")
col.prop(wrd, "lnx_physics_dbg_draw_constraints")
col.prop(wrd, "lnx_physics_dbg_draw_constraint_limits")
col.prop(wrd, "lnx_physics_dbg_draw_normals")
col.prop(wrd, "lnx_physics_dbg_draw_axis_gizmo")
def draw_custom_node_menu(self, context):
"""Extension of the node context menu.
https://blender.stackexchange.com/questions/150101/python-how-to-add-items-in-context-menu-in-2-8
"""
if context.selected_nodes is None or len(context.selected_nodes) != 1:
return
if context.space_data.tree_type == 'LnxLogicTreeType':
if context.selected_nodes[0].bl_idname.startswith('LN'):
layout = self.layout
layout.separator()
layout.operator("lnx.open_node_documentation", text="Show documentation for this node", icon='HELP')
layout.operator("lnx.open_node_haxe_source", text="Open .hx source in the browser", icon_value=ui_icons.get_id("haxe"))
layout.operator("lnx.open_node_python_source", text="Open .py source in the browser", icon='FILE_SCRIPT')
elif context.space_data.tree_type == 'ShaderNodeTree':
if context.active_node.bl_idname in ('ShaderNodeRGB', 'ShaderNodeValue', 'ShaderNodeTexImage'):
layout = self.layout
layout.separator()
layout.prop(context.active_node, 'lnx_material_param', text='Leenkx: Material Parameter')
def draw_conditional_prop(layout: bpy.types.UILayout, heading: str, data: bpy.types.AnyType, prop_condition: str, prop_value: str) -> None:
"""Draws a property row with a checkbox that enables a value field.
The function fails when prop_condition is not a boolean property.
"""
col = layout.column(heading=heading)
row = col.row()
row.prop(data, prop_condition, text='')
sub = row.row()
sub.enabled = getattr(data, prop_condition)
sub.prop(data, prop_value, expand=True)
def draw_error_box(layout: bpy.types.UILayout, text: str) -> bpy.types.UILayout:
"""Draw an error box in the given UILayout and return it for
further optional modification. The text is wrapped automatically
according to the current region's width.
"""
textwrap_width = max(0, int((bpy.context.region.width - 25) / 6))
lines = textwrap.wrap(text, width=textwrap_width, break_long_words=True)
box = layout.box()
col = box.column(align=True)
col.alert = True
for idx, line in enumerate(lines):
col.label(text=line, icon='ERROR' if idx == 0 else 'BLANK1')
return box
def draw_multiline_with_icon(layout: bpy.types.UILayout, layout_width_px: int, icon: str, text: str) -> bpy.types.UILayout:
"""Draw a multiline string with an icon in the given UILayout
and return it for further optional modification.
The text is wrapped according to the given layout width.
"""
textwrap_width = max(0, layout_width_px // 6)
lines = textwrap.wrap(text, width=textwrap_width, break_long_words=True)
col = layout.column(align=True)
col.scale_y = 0.8
for idx, line in enumerate(lines):
col.label(text=line, icon=icon if idx == 0 else 'BLANK1')
return col
__REG_CLASSES = (
LNX_PT_ObjectPropsPanel,
LNX_PT_ModifiersPropsPanel,
LNX_PT_ParticlesPropsPanel,
LNX_PT_PhysicsPropsPanel,
LNX_PT_DataPropsPanel,
LNX_PT_ScenePropsPanel,
LNX_PT_WorldPropsPanel,
InvalidateCacheButton,
InvalidateMaterialCacheButton,
LNX_OT_NewCustomMaterial,
LNX_PG_BindTexturesListItem,
LNX_UL_BindTexturesList,
LNX_OT_BindTexturesListNewItem,
LNX_OT_BindTexturesListDeleteItem,
LNX_PT_MaterialPropsPanel,
LNX_PT_BindTexturesPropsPanel,
LNX_PT_MaterialBlendingPropsPanel,
LNX_PT_MaterialDriverPropsPanel,
LNX_PT_LeenkxPlayerPanel,
LNX_PT_TopbarPanel,
LNX_PT_LeenkxExporterPanel,
LNX_PT_LeenkxExporterAndroidSettingsPanel,
LNX_PT_LeenkxExporterAndroidPermissionsPanel,
LNX_PT_LeenkxExporterAndroidAbiPanel,
LNX_PT_LeenkxExporterAndroidBuildAPKPanel,
LNX_PT_LeenkxExporterHTML5SettingsPanel,
LNX_PT_LeenkxExporterWindowsSettingsPanel,
LNX_PT_LeenkxProjectPanel,
LNX_PT_ProjectFlagsPanel,
LNX_PT_ProjectFlagsDebugConsolePanel,
LNX_PT_ProjectWindowPanel,
LNX_PT_ProjectModulesPanel,
LNX_PT_RenderPathPanel,
LNX_PT_RenderPathRendererPanel,
LNX_PT_RenderPathShadowsPanel,
LNX_PT_RenderPathVoxelsPanel,
LNX_PT_RenderPathWorldPanel,
LNX_PT_RenderPathPostProcessPanel,
LNX_PT_RenderPathCompositorPanel,
LNX_PT_BakePanel,
# LnxVirtualInputPanel,
LeenkxPlayButton,
LeenkxStopButton,
LeenkxBuildProjectButton,
LeenkxOpenProjectFolderButton,
LeenkxOpenEditorButton,
CleanMenu,
CleanButtonMenu,
LeenkxCleanProjectButton,
LeenkxPublishProjectButton,
LnxGenLodButton,
LNX_PT_LodPanel,
LnxGenTerrainButton,
LNX_PT_TerrainPanel,
LNX_PT_TilesheetPanel,
LnxPrintTraitsButton,
LNX_PT_MaterialNodePanel,
LNX_OT_UpdateFileSDK,
LNX_OT_CopyToBundled,
LNX_OT_ShowFileVersionInfo,
LNX_OT_ShowNodeUpdateErrors,
LNX_OT_DiscardPopup,
LeenkxUpdateListAndroidEmulatorButton,
LeenkxUpdateListAndroidEmulatorRunButton,
LeenkxUpdateListInstalledVSButton,
LNX_PT_PhysicsProps,
LNX_PT_PhysicsDebugDrawingPanel,
LNX_OT_AddArmatureRootMotion,
scene.TLM_PT_Settings,
scene.TLM_PT_Denoise,
scene.TLM_PT_Filtering,
scene.TLM_PT_Encoding,
scene.TLM_PT_Utility,
scene.TLM_PT_Additional,
)
__reg_classes, __unreg_classes = bpy.utils.register_classes_factory(__REG_CLASSES)
def register():
__reg_classes()
bpy.types.VIEW3D_HT_header.append(draw_view3d_header)
bpy.types.VIEW3D_MT_object.append(draw_view3d_object_menu)
bpy.types.NODE_MT_context_menu.append(draw_custom_node_menu)
bpy.types.TOPBAR_HT_upper_bar.prepend(draw_space_topbar)
bpy.types.Material.lnx_bind_textures_list = CollectionProperty(type=LNX_PG_BindTexturesListItem)
bpy.types.Material.lnx_bind_textures_list_index = IntProperty(name='Index for lnx_bind_textures_list', default=0)
def unregister():
bpy.types.NODE_MT_context_menu.remove(draw_custom_node_menu)
bpy.types.VIEW3D_MT_object.remove(draw_view3d_object_menu)
bpy.types.VIEW3D_HT_header.remove(draw_view3d_header)
bpy.types.TOPBAR_HT_upper_bar.remove(draw_space_topbar)
__unreg_classes()
View Git Blame Copy Permalink