maxmustermann/armory
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Begin UI merge

Browse source
This commit is contained in:
Lubos Lenco 2017-08-19 03:08:42 +02:00
parent 0517a71990
commit b4325b2e27
17 changed files with 455 additions and 1435 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Shaders/deferred_light/deferred_light.frag.glsl
View file

@ -170,10 +170,8 @@ void main() {
visibility = dfrs(p, l, lightPos);
#endif
// Per-light
#ifndef _NoLampFalloff
visibility *= attenuate(distance(p, lightPos));
#endif
#ifdef _LampIES
visibility *= iesAttenuation(-l);
#endif

148
blender/arm/exporter.py
View file

@ -1212,31 +1212,6 @@ class ArmoryExporter:
return region.width
return 0
def make_fake_omni_lamps(self, o, bobject):
# Look down
o['transform']['values'] = [1.0, 0.0, 0.0, bobject.location.x, 0.0, 1.0, 0.0, bobject.location.y, 0.0, 0.0, 1.0, bobject.location.z, 0.0, 0.0, 0.0, 1.0]
if not hasattr(o, 'children'):
o['children'] = []
# Make child lamps
for i in range(0, 5):
child_lamp = {}
child_lamp['name'] = o['name'] + '__' + str(i)
child_lamp['data_ref'] = o['data_ref']
child_lamp['type'] = 'lamp_object'
if i == 0:
mat = [0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]
elif i == 1:
mat = [0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]
elif i == 2:
mat = [0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]
elif i == 3:
mat = [0.0, -1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]
elif i == 4:
mat = [-1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 1.0]
child_lamp['transform'] = {}
child_lamp['transform']['values'] = mat
o['children'].append(child_lamp)
def export_object(self, bobject, scene, poseBone = None, parento = None):
# This function exports a single object in the scene and includes its name,
# object reference, material references (for meshes), and transform.
@ -1259,7 +1234,7 @@ class ArmoryExporter:
o['type'] = structIdentifier[type]
o['name'] = bobjectRef["structName"]
if bobject.hide_render or not bobject.game_visible:
if bobject.hide_render:
o['visible'] = False
if not bobject.cycles_visibility.camera:
@ -1277,14 +1252,14 @@ class ArmoryExporter:
if bobject.dupli_type == 'GROUP' and bobject.dupli_group != None:
o['group_ref'] = bobject.dupli_group.name
if ArmoryExporter.option_spawn_all_layers == False:
layer_found = False
for l in self.active_layers:
if bobject.layers[l] == True:
layer_found = True
break
if layer_found == False:
o['spawn'] = False
# if ArmoryExporter.option_spawn_all_layers == False:
layer_found = False
for l in self.active_layers:
if bobject.layers[l] == True:
layer_found = True
break
if layer_found == False:
o['spawn'] = False
# Export the object reference and material references
objref = bobject.data
@ -1388,12 +1363,8 @@ class ArmoryExporter:
# Export the transform. If object is animated, then animation tracks are exported here
self.export_object_transform(bobject, scene, o)
# 6 directional lamps if cubemap is disabled
if type == NodeTypeLamp and objref.type == 'POINT' and objref.lamp_omni_shadows and not objref.lamp_omni_shadows_cubemap:
self.make_fake_omni_lamps(o, bobject)
# Viewport Camera - overwrite active camera matrix with viewport matrix
if type == NodeTypeCamera and bpy.data.worlds['Arm'].arm_play_viewport_camera and self.scene.camera != None and bobject.name == self.scene.camera.name:
if type == NodeTypeCamera and bpy.data.worlds['Arm'].arm_play_camera != 'Scene' and self.scene.camera != None and bobject.name == self.scene.camera.name:
viewport_matrix = self.get_viewport_view_matrix()
if viewport_matrix != None:
o['transform']['values'] = self.write_matrix(viewport_matrix.inverted())
@ -1414,9 +1385,6 @@ class ArmoryExporter:
actions = bpy.data.actions
action = actions.get('armorypose', actions.new(name='armorypose'))
if bobject.edit_actions_prop:
action = bpy.data.actions[bobject.start_action_name_prop]
# Bone export
armatureid = self.asset_name(bdata)
armatureid = arm.utils.safestr(armatureid)
@ -1426,12 +1394,7 @@ class ArmoryExporter:
o['bones_ref'] = 'bones_' + armatureid + '_' + action.name + ext
# Write bones
if bdata.edit_actions:
export_actions = []
for t in bdata.my_actiontraitlist:
export_actions.append(bpy.data.actions[t.name])
else: # Use default
export_actions = [action]
export_actions = [action]
# orig_action = bobject.animation_data.action
# bobject.animation_data.action = orig_action
@ -2148,11 +2111,8 @@ class ArmoryExporter:
o['lamp_size'] = lamp_size * 10 # Match to Cycles
if objtype == 'POINT' and objref.lamp_omni_shadows and not arm.utils.get_gapi().startswith('direct3d'):
o['fov'] = 1.5708 # 90 deg
if objref.lamp_omni_shadows_cubemap:
o['shadowmap_cube'] = True
o['shadows_bias'] *= 4.0
# if (o['near_plane'] <= 0.11:
# o['near_plane'] /= 10 # Prevent acne on close surfaces
o['shadowmap_cube'] = True
o['shadows_bias'] *= 4.0
# Parse nodes
# Emission only for now
@ -2176,10 +2136,6 @@ class ArmoryExporter:
o['color_texture'] = color_node.image.name
break
if objtype == 'POINT' and objref.lamp_omni_shadows and not objref.lamp_omni_shadows_cubemap:
# 6 separate maps
o['strength'] /= 6
self.output['lamp_datas'].append(o)
def export_camera(self, objectRef):
@ -2195,7 +2151,7 @@ class ArmoryExporter:
o['far_plane'] = objref.clip_end
o['fov'] = objref.angle
if bpy.data.worlds['Arm'].arm_play_viewport_camera and ArmoryExporter.in_viewport:
if bpy.data.worlds['Arm'].arm_play_camera != 'Scene' and ArmoryExporter.in_viewport:
pw = self.get_viewport_panels_w()
# Tool shelf and properties hidden
proj, is_persp = self.get_viewport_projection_matrix()
@ -2686,7 +2642,7 @@ class ArmoryExporter:
instance_offsets = [0.0, 0.0, 0.0] # Include parent
for sn in n.children:
# Child hidden
if sn.game_export == False or (sn.hide_render and ArmoryExporter.option_export_hide_render == False):
if sn.game_export == False:
continue
# Do not take parent matrix into account
loc = sn.matrix_local.to_translation()
@ -2724,8 +2680,6 @@ class ArmoryExporter:
ArmoryExporter.option_mesh_only = False
ArmoryExporter.option_mesh_per_file = True
ArmoryExporter.option_optimize_mesh = bpy.data.worlds['Arm'].arm_optimize_mesh
ArmoryExporter.option_export_hide_render = bpy.data.worlds['Arm'].arm_export_hide_render
ArmoryExporter.option_spawn_all_layers = bpy.data.worlds['Arm'].arm_spawn_all_layers
ArmoryExporter.option_minimize = bpy.data.worlds['Arm'].arm_minimize
ArmoryExporter.option_sample_animation = bpy.data.worlds['Arm'].arm_sampled_animation
ArmoryExporter.sample_animation_flag = ArmoryExporter.option_sample_animation
@ -2745,7 +2699,7 @@ class ArmoryExporter:
export_object = True
# Disabled object
if bobject.game_export == False or (bobject.hide_render and ArmoryExporter.option_export_hide_render == False):
if bobject.game_export == False:
return False
for m in bobject.modifiers:
@ -2764,41 +2718,19 @@ class ArmoryExporter:
if arm.utils.is_bone_animation_enabled(bobject) or arm.utils.is_object_animation_enabled(bobject):
x = {}
x['frame_time'] = 1 / self.scene.render.fps
if len(bobject.my_cliptraitlist) > 0:
# Edit clips enabled
x['names'] = []
x['starts'] = []
x['ends'] = []
x['speeds'] = []
x['loops'] = []
x['reflects'] = []
for at in bobject.my_cliptraitlist:
if at.enabled_prop:
x['names'].append(at.name)
x['starts'].append(at.start_prop)
x['ends'].append(at.end_prop)
x['speeds'].append(at.speed_prop)
x['loops'].append(at.loop_prop)
x['reflects'].append(at.reflect_prop)
start_track = bobject.start_track_name_prop
if start_track == '' and len(bobject.my_cliptraitlist) > 0: # Start track undefined
start_track = bobject.my_cliptraitlist[0].name
x['start_track'] = start_track
x['max_bones'] = bpy.data.worlds['Arm'].generate_gpu_skin_max_bones
# Export assigned action
if arm.utils.is_bone_animation_enabled(bobject):
begin_frame, end_frame = self.get_action_framerange(bobject.parent.animation_data.action)
else:
# Export default clip, taking full action
if arm.utils.is_bone_animation_enabled(bobject):
begin_frame, end_frame = self.get_action_framerange(bobject.parent.animation_data.action)
else:
begin_frame, end_frame = self.get_action_framerange(bobject.animation_data.action)
x['start_track'] = 'default'
x['names'] = ['default']
x['starts'] = [begin_frame]
x['ends'] = [end_frame]
x['speeds'] = [1.0]
x['loops'] = [True]
x['reflects'] = [False]
x['max_bones'] = bpy.data.worlds['Arm'].generate_gpu_skin_max_bones
begin_frame, end_frame = self.get_action_framerange(bobject.animation_data.action)
x['start_track'] = 'default'
x['names'] = ['default']
x['starts'] = [begin_frame]
x['ends'] = [end_frame]
x['speeds'] = [1.0]
x['loops'] = [True]
x['reflects'] = [False]
x['max_bones'] = bpy.data.worlds['Arm'].generate_gpu_skin_max_bones
o['animation_setup'] = x
# Export traits
@ -2980,8 +2912,8 @@ class ArmoryExporter:
console_trait['class_name'] = 'armory.trait.internal.DebugConsole'
console_trait['parameters'] = []
o['traits'].append(console_trait)
# Viewport camera enabled, attach navigation to active camera if enabled
if self.scene.camera != None and bobject.name == self.scene.camera.name and bpy.data.worlds['Arm'].arm_play_viewport_camera and bpy.data.worlds['Arm'].arm_play_viewport_navigation == 'Walk':
# Viewport camera enabled, attach navigation to active camera
if self.scene.camera != None and bobject.name == self.scene.camera.name and bpy.data.worlds['Arm'].arm_play_camera != 'Scene':
navigation_trait = {}
navigation_trait['type'] = 'Script'
navigation_trait['class_name'] = 'armory.trait.WalkNavigation'
@ -3080,26 +3012,6 @@ class ArmoryExporter:
po['sun_direction'] = list(world.world_envtex_sun_direction)
po['turbidity'] = world.world_envtex_turbidity
po['ground_albedo'] = world.world_envtex_ground_albedo
# Probe cameras attached in scene
for cam in bpy.data.cameras:
if cam.is_probe:
# Generate probe straight here for now
volume_object = bpy.data.objects[cam.probe_volume]
# Assume empty box of size 2, multiply by scale and dividy by 2 to get half extents
volume = [2 * volume_object.scale[0] / 2, 2 * volume_object.scale[1] / 2, 2 * volume_object.scale[2] / 2]
volume_center = [volume_object.location[0], volume_object.location[1], volume_object.location[2]]
disable_hdr = cam.probe_texture.endswith('.jpg')
generate_radiance = cam.probe_generate_radiance
if world_generate_radiance == False:
generate_radiance = False
texture_path = '//' + cam.probe_texture
cam.probe_num_mips = write_probes.write_probes(texture_path, disable_hdr, cam.probe_num_mips, generate_radiance=generate_radiance)
base_name = cam.probe_texture.rsplit('.', 1)[0]
po = self.make_probe(cam.name, base_name, base_name, cam.probe_num_mips, cam.probe_strength, cam.probe_blending, volume, volume_center, generate_radiance, generate_irradiance, disable_hdr)
o['probes'].append(po)
def post_export_grease_pencil(self, gp):
o = {}

14
blender/arm/make.py
View file

@ -15,7 +15,6 @@ import arm.make_renderpath as make_renderpath
import arm.make_world as make_world
import arm.make_utils as make_utils
import arm.make_state as state
import arm.path_tracer as path_tracer
import arm.assets as assets
import arm.log as log
import arm.lib.make_datas
@ -117,6 +116,15 @@ def export_data(fp, sdk_path, is_play=False, is_publish=False, in_viewport=False
if wrd.arm_ui == 'Enabled':
export_ui = True
modules = []
if export_physics:
modules.append('physics')
if export_navigation:
modules.append('navigation')
if export_ui:
modules.append('ui')
print('Exported modules: ' + str(modules))
# Write referenced shader variants
for ref in assets.shader_datas:
# Data does not exist yet
@ -262,10 +270,6 @@ def build_project(is_play=False, is_publish=False, is_render=False, in_viewport=
if not os.path.exists(sources_path):
os.makedirs(sources_path)
# Compile path tracer shaders
# if len(bpy.data.cameras) > 0 and bpy.data.cameras[0].renderpath_path == 'pathtrace_path':
# path_tracer.compile(raw_shaders_path + 'pt_trace_pass/pt_trace_pass.frag.glsl')
# Save external scripts edited inside Blender
write_texts = False
for text in bpy.data.texts:

5
blender/arm/make_renderpath.py
View file

@ -897,11 +897,6 @@ def parse_render_target(node, node_group, render_targets, depth_buffers):
else: # ShadowMapNodeType
target = make_shadowmap_target(node, scale)
render_targets.append(target)
# Clamp non-cubemap omni-shadows
for lamp in bpy.data.lamps:
if lamp.type == 'POINT' and lamp.lamp_omni_shadows and not lamp.lamp_omni_shadows_cubemap:
bpy.data.worlds['Arm'].rp_defs += '_Clampstc'
elif node.bl_idname == 'ImageNodeType' or node.bl_idname == 'Image3DNodeType':
# Target already exists

5
blender/arm/make_world.py
View file

@ -87,13 +87,8 @@ def build_node_tree(world):
bpy.data.worlds['Arm'].world_defs += '_LampIES'
assets.add_embedded_data('iestexture.png')
if not wrd.generate_lamp_falloff:
bpy.data.worlds['Arm'].world_defs += '_NoLampFalloff'
voxelgi = False
for cam in bpy.data.cameras:
if cam.is_probe:
wrd.world_defs += '_Probes'
if cam.rp_shadowmap == 'None':
wrd.world_defs += '_NoShadows'
assets.add_khafile_def('arm_no_shadows')

454
blender/arm/path_tracer.py
View file

@ -1,454 +0,0 @@
# Based on WebGL Path Tracing by Evan Wallace
# (http://madebyevan.com/webgl-path-tracing/)
import bpy
bounces = '2'
epsilon = '0.0001'
infinity = '10000.0'
lightSize = 0.1
lightVal = 0.5
objects = None
sampleCount = 0
MATERIAL_DIFFUSE = 0
MATERIAL_MIRROR = 1
MATERIAL_GLOSSY = 2
material = MATERIAL_DIFFUSE
def concat(objects, func):
text = ''
for i in range(0, len(objects)):
text += func(objects[i])
return text
tracerFragmentSourceHeader = """
#version 450
#ifdef GL_ES
precision mediump float;
#endif
in vec3 initialRay;
in vec2 texCoord;
out vec4 fragColor;
uniform vec3 eye;
//uniform float textureWeight;
uniform float timeSinceStart;
//uniform sampler2D stexture;
uniform float glossiness;
//vec3 roomCubeMin = vec3(0.0, 0.0, 0.0);
//vec3 roomCubeMax = vec3(1.0, 1.0, 1.0);
vec3 origin;
vec3 ray;
vec3 colorMask = vec3(1.0);
vec3 accumulatedColor = vec3(0.0);
"""
# compute the near and far intersections of the cube (stored in the x and y components) using the slab method
# no intersection means vec.x > vec.y (really tNear > tFar)
intersectCubeSource = """
vec2 intersectCube(vec3 origin, vec3 ray, vec3 cubeCenter, vec3 cubeSize) {
vec3 cubeMin = cubeCenter - cubeSize;
vec3 cubeMax = cubeCenter + cubeSize;
vec3 tMin = (cubeMin - origin) / ray;
vec3 tMax = (cubeMax - origin) / ray;
vec3 t1 = min(tMin, tMax);
vec3 t2 = max(tMin, tMax);
float tNear = max(max(t1.x, t1.y), t1.z);
float tFar = min(min(t2.x, t2.y), t2.z);
return vec2(tNear, tFar);
}
"""
# given that hit is a point on the cube, what is the surface normal?
# TODO: do this with fewer branches
normalForCubeSource = """
vec3 normalForCube(vec3 hit, vec3 cubeCenter, vec3 cubeSize) {
vec3 cubeMin = cubeCenter - cubeSize;
vec3 cubeMax = cubeCenter + cubeSize;
if (hit.x < cubeMin.x + """ + epsilon + """) return vec3(-1.0, 0.0, 0.0);
else if (hit.x > cubeMax.x - """ + epsilon + """) return vec3(1.0, 0.0, 0.0);
else if (hit.y < cubeMin.y + """ + epsilon + """) return vec3(0.0, -1.0, 0.0);
else if (hit.y > cubeMax.y - """ + epsilon + """) return vec3(0.0, 1.0, 0.0);
else if (hit.z < cubeMin.z + """ + epsilon + """) return vec3(0.0, 0.0, -1.0);
//else return vec3(0.0, 0.0, 1.0);
return vec3(0.0, 0.0, 1.0);
}
"""
# compute the near intersection of a sphere
# no intersection returns a value of +infinity
intersectSphereSource = """
float intersectSphere(vec3 origin, vec3 ray, vec3 sphereCenter, float sphereRadius) {
vec3 toSphere = origin - sphereCenter;
float a = dot(ray, ray);
float b = 2.0 * dot(toSphere, ray);
float c = dot(toSphere, toSphere) - sphereRadius*sphereRadius;
float discriminant = b*b - 4.0*a*c;
if (discriminant > 0.0) {
float t = (-b - sqrt(discriminant)) / (2.0 * a);
if (t > 0.0) return t;
}
return """ + infinity + """;
}
"""
# given that hit is a point on the sphere, what is the surface normal?
normalForSphereSource = """
vec3 normalForSphere(vec3 hit, vec3 sphereCenter, float sphereRadius) {
return (hit - sphereCenter) / sphereRadius;
}
"""
# random cosine-weighted distributed vector
# from http://www.rorydriscoll.com/2009/01/07/better-sampling/
cosineWeightedDirectionSource = """
vec3 cosineWeightedDirection(float seed, vec3 normal) {
float u = random(vec3(12.9898, 78.233, 151.7182), seed);
float v = random(vec3(63.7264, 10.873, 623.6736), seed);
float r = sqrt(u);
float angle = 6.283185307179586 * v;
// compute basis from normal
vec3 sdir, tdir;
if (abs(normal.x) < 0.5) {
sdir = cross(normal, vec3(1.0, 0.0, 0.0));
}
else {
sdir = cross(normal, vec3(0.0, 1.0, 0.0));
}
tdir = cross(normal, sdir);
return r*cos(angle)*sdir + r*sin(angle)*tdir + sqrt(1.0-u)*normal;
}
"""
# use the fragment position for randomness
randomSource = """
float random(vec3 scale, float seed) {
// return fract(sin(dot(texCoord.xyx + seed, scale)) * 43758.5453 + seed);
float d = 43758.5453;
float dt = dot(texCoord.xyx + seed,scale);
float sn = mod(dt,3.1415926);
return fract(sin(sn) * d);
}
"""
# random normalized vector
uniformlyRandomDirectionSource = """
vec3 uniformlyRandomDirection(float seed) {
float u = random(vec3(12.9898, 78.233, 151.7182), seed);
float v = random(vec3(63.7264, 10.873, 623.6736), seed);
float z = 1.0 - 2.0 * u;
float r = sqrt(1.0 - z * z);
float angle = 6.283185307179586 * v;
return vec3(r * cos(angle), r * sin(angle), z);
}
"""
# random vector in the unit sphere
# note: this is probably not statistically uniform, saw raising to 1/3 power somewhere but that looks wrong?
uniformlyRandomVectorSource = """
vec3 uniformlyRandomVector(float seed) {
return uniformlyRandomDirection(seed) * sqrt(random(vec3(36.7539, 50.3658, 306.2759), seed));
}
"""
# compute specular lighting contribution
specularReflection = """
vec3 reflectedLight = normalize(reflect(light - hit, normal));
specularHighlight = max(0.0, dot(reflectedLight, normalize(hit - origin)));"""
# update ray using normal and bounce according to a diffuse reflection
newDiffuseRay = """
ray = cosineWeightedDirection(time + float(bounce), normal);"""
# update ray using normal according to a specular reflection
newReflectiveRay = """
ray = reflect(ray, normal);
""" + specularReflection + """
specularHighlight = 2.0 * pow(specularHighlight, 20.0);"""
# update ray using normal and bounce according to a glossy reflection
newGlossyRay = """
ray = normalize(reflect(ray, normal)) + uniformlyRandomVector(time + float(bounce)) * glossiness;
""" + specularReflection + """
specularHighlight = pow(specularHighlight, 3.0);"""
# yellowBlueCornellBox = """
# if (hit.x < -0.9999) surfaceColor = vec3(0.1, 0.1, 0.7); // blue
# else if (hit.x > 0.9999) surfaceColor = vec3(0.7, 0.1, 0.1); // yellow"""
# redGreenCornellBox = """
# if (hit.x < -0.9999) surfaceColor = vec3(1.0, 0.3, 0.1); // red
# else if (hit.x > 0.9999) surfaceColor = vec3(0.3, 1.0, 0.1); // green"""
def _getShadowTestCode(o):
return o.getShadowTestCode()
def makeShadow(objects):
return """
float shadow(vec3 origin, vec3 ray) {
""" + concat(objects, _getShadowTestCode) + """
return 1.0;
}"""
def _getIntersectCode(o):
return o.getIntersectCode()
def _getMinimumIntersectCode(o):
return o.getMinimumIntersectCode()
def _getNormalCalculationCode(o):
return o.getNormalCalculationCode()
def makeDoBounce(objects):
return """
int doBounce(float time, vec3 light, int bounce) {
// compute the intersection with everything
""" + concat(objects, _getIntersectCode) + """
// find the closest intersection
float t = """ + infinity + """;
""" + concat(objects, _getMinimumIntersectCode) + """
// info about hit
vec3 hit = origin + ray * t;
vec3 surfaceColor = vec3(0.75);
float specularHighlight = 0.0;
vec3 normal;
if (t == """ + infinity + """) {
//break;
return 0;
}
else {
int aa = 0;
if (aa == 1) {aa = 0;} // hack to discard the first 'else' in 'else if'
""" + concat(objects, _getNormalCalculationCode) + """
""" + [newDiffuseRay, newReflectiveRay, newGlossyRay][material] + """
}
// compute diffuse lighting contribution
vec3 toLight = light - hit;
//float diffuse = max(0.0, dot(normalize(toLight), normal));
float diffuse = max(0.0, dot(normalize(toLight), normal)) / dot(toLight,toLight);
// do light bounce
colorMask *= surfaceColor;
//if (bounce > 0) {
// trace a shadow ray to the light
float shadowIntensity = shadow(hit + normal * """ + epsilon + """, toLight);
accumulatedColor += colorMask * (""" + str(lightVal) + """ * diffuse * shadowIntensity);
accumulatedColor += colorMask * specularHighlight * shadowIntensity;
//}
// calculate next origin
origin = hit;
return 0;
}
"""
def makeCalculateColor(objects):
return """
vec3 calculateColor(float time, vec3 _origin, vec3 _ray, vec3 light) {
//vec3 colorMask = vec3(1.0);
//vec3 accumulatedColor = vec3(0.0);
origin = _origin;
ray = _ray;
// main raytracing loop
//for (int bounce = 0; bounce < """ + bounces + """; bounce++) {
int a;
a = doBounce(time, light, 0);
a = doBounce(time, light, 1);
a = doBounce(time, light, 2);
//}
return accumulatedColor;
}
"""
def makeDoSamples(num_samples):
s = ''
for i in range(0, num_samples):
s += """newLight = light + uniformlyRandomVector(time - 53.0) * """ + str(lightSize) + """;
"""
s += """col += calculateColor(time, eye, initialRay, newLight);
"""
s += """time += 0.35;
"""
return s
def makeMain():
return """
void main() {
float time = 0.0;//timeSinceStart;
//timeSinceStart % 46735.275 ) / 1000;
vec3 col = vec3(0.0);
const int samples = 1;
vec3 newLight;
//for (int i = 0; i < samples; i++) {
""" + \
makeDoSamples(1) + \
"""
//}
fragColor = vec4(vec3(col / samples), 1.0);
fragColor.rgb = pow(fragColor.rgb * 0.7, vec3(1.0 / 2.2));
}
"""
def _getGlobalCode(o):
return o.getGlobalCode()
def makeTracerFragmentSource(objects):
return tracerFragmentSourceHeader + \
concat(objects, _getGlobalCode) + \
intersectCubeSource + \
normalForCubeSource + \
intersectSphereSource + \
normalForSphereSource + \
randomSource + \
cosineWeightedDirectionSource + \
uniformlyRandomDirectionSource + \
uniformlyRandomVectorSource + \
makeShadow(objects) + \
makeDoBounce(objects) + \
makeCalculateColor(objects) + \
makeMain()
class Sphere:
def __init__(self, center, radius, color, id):
self.center = center;
self.radius = radius;
self.color = color;
self.centerStr = 'sphereCenter' + str(id);
self.radiusStr = 'sphereRadius' + str(id);
self.colorStr = 'sphereColor' + str(id);
self.intersectStr = 'tSphere' + str(id);
def getGlobalCode(self):
return """
uniform vec3 """ + self.centerStr + """;
uniform float """ + self.radiusStr + """;
uniform vec3 """ + self.colorStr + """;"""
def getIntersectCode(self):
return """
float """ + self.intersectStr + """ = intersectSphere(origin, ray, """ + self.centerStr + """, """ + self.radiusStr + """);"""
def getShadowTestCode(self):
return """
""" + self.getIntersectCode() + """
if (""" + self.intersectStr + """ < 1.0) return 0.0;"""
def getMinimumIntersectCode(self):
return """
if (""" + self.intersectStr + """ < t) t = """ + self.intersectStr + """;"""
def getNormalCalculationCode(self):
return """
else if (t == """ + self.intersectStr + """) { normal = normalForSphere(hit, """ + self.centerStr + """, """ + self.radiusStr + """); surfaceColor = """ + self.colorStr + """; }"""
class Cube:
def __init__(self, center, size, color, id):
self.center = center;
self.size = size;
self.color = color;
self.centerStr = 'cubeCenter' + str(id);
self.sizeStr = 'cubeSize' + str(id);
self.colorStr = 'cubeColor' + str(id);
self.intersectStr = 'tCube' + str(id);
def getGlobalCode(self):
return """
uniform vec3 """ + self.centerStr + """;
uniform vec3 """ + self.sizeStr + """;
uniform vec3 """ + self.colorStr + """;"""
def getIntersectCode(self):
return """
vec2 """ + self.intersectStr + """ = intersectCube(origin, ray, """ + self.centerStr + """, """ + self.sizeStr + """);"""
def getShadowTestCode(self):
return """
""" + self.getIntersectCode() + """
if (""" + self.intersectStr + """.x > 0.0 && """ + self.intersectStr + """.x < 1.0 && """ + self.intersectStr + """.x < """ + self.intersectStr + """.y) return 0.0;"""
def getMinimumIntersectCode(self):
return """
if (""" + self.intersectStr + """.x > 0.0 && """ + self.intersectStr + """.x < """ + self.intersectStr + """.y && """ + self.intersectStr + """.x < t) t = """ + self.intersectStr + """.x;"""
def getNormalCalculationCode(self):
return """
// have to compare intersectStr.x < intersectStr.y otherwise two coplanar
// cubes will look wrong (one cube will "steal" the hit from the other)
else if (t == """ + self.intersectStr + """.x) { if (""" + self.intersectStr + """.x < """ + self.intersectStr + """.y) normal = normalForCube(hit, """ + self.centerStr + """, """ + self.sizeStr + """); surfaceColor = """ + self.colorStr + """; }"""
#else if (t == """ + self.intersectStr + """.x && """ + self.intersectStr + """.x < """ + self.intersectStr + """.y) normal = normalForCube(hit, """ + self.centerStr + """, """ + self.sizeStr + """);"""
class Light:
def __init__(self):
pass
def getGlobalCode(self):
return """uniform vec3 light;"""
def getIntersectCode(self):
return """"""
def getShadowTestCode(self):
return """"""
def getMinimumIntersectCode(self):
return """"""
def getNormalCalculationCode(self):
return """"""
def initObjects():
nextSphereId = 0
nextCubeId = 0
objects = []
objects.append(Light())
for o in bpy.context.scene.objects:
if o.name.split('.', 1)[0] == 'Sphere':
objects.append(Sphere([0, 0, 0], 0, [0.8, 0.8, 0.8], nextSphereId))
nextSphereId += 1
elif o.name.split('.', 1)[0] == 'Cube':
objects.append(Cube([0, 0, 0], [0, 0, 0], [0.8, 0.8, 0.8], nextCubeId))
nextCubeId += 1
return objects
objects = initObjects()
def compile(frag_path):
with open(frag_path, 'w') as f:
f.write(makeTracerFragmentSource(objects))

113
blender/arm/props.py
View file

@ -2,8 +2,6 @@ import bpy
from bpy.props import *
import os
import shutil
from arm.props_traits_clip import *
from arm.props_traits_action import *
from arm.props_traits_library import *
import arm.props_ui as props_ui
import arm.props_renderer as props_renderer
@ -165,13 +163,11 @@ def init_properties():
items = [('Disabled', 'Disabled', 'Disabled'),
('Enabled', 'Enabled', 'Enabled'),
('Auto', 'Auto', 'Auto')],
name = "UI Library", default='Auto', description="Include UI library")
# bpy.types.World.arm_networking = EnumProperty(
# items = [('Disabled', 'Disabled', 'Disabled'),
# ('Enabled', 'Enabled', 'Enabled'),
# ('Auto', 'Auto', 'Auto')],
# name = "Networking", default='Auto')
bpy.types.World.arm_hscript = BoolProperty(name="hscript", description="Include hscript library", default=False)
name = "Zui", default='Auto', description="Include UI library")
bpy.types.World.arm_hscript = EnumProperty(
items = [('Disabled', 'Disabled', 'Disabled'),
('Enabled', 'Enabled', 'Enabled')],
name = "Hscript", default='Disabled', description="Include Hscript library")
bpy.types.World.arm_khafile = StringProperty(name="Khafile", description="Source appended to khafile.js")
bpy.types.World.arm_khamake = StringProperty(name="Khamake", description="Command line params appended to khamake")
bpy.types.World.arm_minimize = BoolProperty(name="Minimize Data", description="Export scene data in binary", default=True, update=assets.invalidate_compiled_data)
@ -182,27 +178,18 @@ def init_properties():
bpy.types.World.arm_batch_meshes = BoolProperty(name="Batch Meshes", description="Group meshes by materials to speed up rendering", default=False)
bpy.types.World.arm_batch_materials = BoolProperty(name="Batch Materials", description="Marge similar materials into single pipeline state", default=False, update=assets.invalidate_shader_cache)
bpy.types.World.arm_stream_scene = BoolProperty(name="Stream Scene", description="Stream scene content", default=False)
bpy.types.World.arm_export_hide_render = BoolProperty(name="Export Hidden Renders", description="Export hidden objects", default=True)
bpy.types.World.arm_spawn_all_layers = BoolProperty(name="Spawn All Layers", description="Spawn objects from all scene layers", default=False)
bpy.types.World.arm_play_advanced = BoolProperty(name="Advanced", default=False)
bpy.types.World.arm_build_advanced = BoolProperty(name="Advanced", default=False)
bpy.types.World.arm_project_advanced = BoolProperty(name="Advanced", default=False)
bpy.types.World.arm_object_advanced = BoolProperty(name="Advanced", default=False)
bpy.types.World.arm_material_advanced = BoolProperty(name="Advanced", default=False)
bpy.types.World.arm_camera_props_advanced = BoolProperty(name="Advanced", default=False)
bpy.types.World.arm_lod_advanced = BoolProperty(name="Advanced", default=False)
bpy.types.World.arm_lod_gen_levels = IntProperty(name="Levels", description="Number of levels to generate", default=3, min=1)
bpy.types.World.arm_lod_gen_ratio = FloatProperty(name="Decimate Ratio", description="Decimate ratio", default=0.8)
bpy.types.World.arm_cache_shaders = BoolProperty(name="Cache Shaders", description="Do not rebuild existing shaders", default=True, update=assets.invalidate_shader_cache)
bpy.types.World.arm_cache_compiler = BoolProperty(name="Cache Compiler", description="Only recompile sources when required", default=True)
bpy.types.World.arm_gpu_processing = BoolProperty(name="GPU Processing", description="Utilize GPU for asset pre-processing at build time", default=True, update=assets.invalidate_compiled_data)
bpy.types.World.arm_play_live_patch = BoolProperty(name="Live Patching", description="Sync running player data to Blender", default=True)
bpy.types.World.arm_play_live_patch = BoolProperty(name="Live Patch", description="Sync running player data to Blender", default=True)
bpy.types.World.arm_play_auto_build = BoolProperty(name="Auto Build", description="Rebuild scene on operator changes", default=True)
bpy.types.World.arm_play_viewport_camera = BoolProperty(name="Viewport Camera", description="Start player at viewport camera position", default=False)
bpy.types.World.arm_play_viewport_navigation = EnumProperty(
items=[('None', 'None', 'None'),
('Walk', 'Walk', 'Walk')],
name="Navigation", description="Enable camera controls", default='Walk')
bpy.types.World.arm_play_camera = EnumProperty(
items=[('Scene', 'Scene', 'Scene'),
('Viewport', 'Viewport', 'Viewport'),
('Viewport Shared', 'Viewport Shared', 'Viewport Shared')],
name="Camera", description="Viewport camera", default='Scene')
bpy.types.World.arm_play_console = BoolProperty(name="Debug Console", description="Show inspector in player", default=False)
bpy.types.World.arm_play_runtime = EnumProperty(
items=[('Browser', 'Browser', 'Browser'),
@ -217,7 +204,7 @@ def init_properties():
items = [('Window', 'Window', 'Window'),
('BorderlessWindow', 'Borderless', 'BorderlessWindow'),
('Fullscreen', 'Fullscreen', 'Fullscreen')],
name="Window Mode", default='Window', description='Window mode to start in')
name="", default='Window', description='Window mode to start in')
bpy.types.World.arm_winresize = BoolProperty(name="Resizable", description="Allow window resize", default=False)
bpy.types.World.arm_winmaximize = BoolProperty(name="Maximizable", description="Allow window maximize", default=False)
bpy.types.World.arm_winminimize = BoolProperty(name="Minimizable", description="Allow window minimize", default=True)
@ -272,20 +259,11 @@ def init_properties():
bpy.types.Object.override_material = bpy.props.BoolProperty(name="Override Material", default=False)
bpy.types.Object.override_material_name = bpy.props.StringProperty(name="Name", default="")
bpy.types.Object.game_export = bpy.props.BoolProperty(name="Export", description="Export object data", default=True)
bpy.types.Object.game_visible = bpy.props.BoolProperty(name="Visible", description="Render this object", default=True)
bpy.types.Object.spawn = bpy.props.BoolProperty(name="Spawn", description="Auto-add this object when creating scene", default=True)
bpy.types.Object.mobile = bpy.props.BoolProperty(name="Mobile", description="Object moves during gameplay", default=True)
bpy.types.Object.soft_body_margin = bpy.props.FloatProperty(name="Soft Body Margin", description="Collision margin", default=0.04)
# - Clips
bpy.types.Object.bone_animation_enabled = bpy.props.BoolProperty(name="Bone Animation", description="Enable skinning", default=True)
bpy.types.Object.object_animation_enabled = bpy.props.BoolProperty(name="Object Animation", description="Enable timeline animation", default=True)
bpy.types.Object.edit_tracks_prop = bpy.props.BoolProperty(name="Edit Clips", description="Manually set animation frames", default=False)
bpy.types.Object.start_track_name_prop = bpy.props.StringProperty(name="Start Track", description="Play this track by default", default="")
bpy.types.Object.my_cliptraitlist = bpy.props.CollectionProperty(type=ListClipTraitItem)
bpy.types.Object.cliptraitlist_index = bpy.props.IntProperty(name="Clip index", default=0)
# - Actions
bpy.types.Object.edit_actions_prop = bpy.props.BoolProperty(name="Edit Actions", description="Manually set used actions", default=False)
bpy.types.Object.start_action_name_prop = bpy.props.StringProperty(name="Start Action", description="Play this action by default", default="")
bpy.types.Object.bone_animation_enabled = bpy.props.BoolProperty(name="Animation", description="Enable skinning", default=True)
bpy.types.Object.object_animation_enabled = bpy.props.BoolProperty(name="Animation", description="Enable timeline animation", default=True)
# For speakers
bpy.types.Speaker.loop = bpy.props.BoolProperty(name="Loop", description="Loop this sound", default=False)
bpy.types.Speaker.stream = bpy.props.BoolProperty(name="Stream", description="Stream this sound", default=False)
@ -309,22 +287,11 @@ def init_properties():
# For armature
bpy.types.Armature.data_cached = bpy.props.BoolProperty(name="Armature Cached", description="No need to reexport armature data", default=False)
bpy.types.Armature.data_compressed = bpy.props.BoolProperty(name="Compress Data", description="Pack data into zip file", default=False)
# Actions
bpy.types.Armature.edit_actions = bpy.props.BoolProperty(name="Edit Actions", description="Manually set used actions", default=False)
bpy.types.Armature.my_actiontraitlist = bpy.props.CollectionProperty(type=ListActionTraitItem)
bpy.types.Armature.actiontraitlist_index = bpy.props.IntProperty(name="Action index", default=0)
# For camera
bpy.types.Camera.frustum_culling = bpy.props.BoolProperty(name="Frustum Culling", description="Perform frustum culling for this camera", default=True)
bpy.types.Camera.renderpath_path = bpy.props.StringProperty(name="Render Path", description="Render path nodes used for this camera", default="armory_default", update=assets.invalidate_shader_cache)
bpy.types.Camera.renderpath_id = bpy.props.StringProperty(name="Render Path ID", description="Asset ID", default="deferred")
bpy.types.Camera.renderpath_passes = bpy.props.StringProperty(name="Render Path Passes", description="Referenced render passes", default="")
bpy.types.Camera.is_probe = bpy.props.BoolProperty(name="Probe", description="Render this camera as environment probe using Cycles", default=False)
bpy.types.Camera.probe_generate_radiance = bpy.props.BoolProperty(name="Generate Radiance", description="Generate radiance textures", default=False)
bpy.types.Camera.probe_texture = bpy.props.StringProperty(name="Texture", default="")
bpy.types.Camera.probe_num_mips = bpy.props.IntProperty(name="Number of mips", default=0)
bpy.types.Camera.probe_volume = bpy.props.StringProperty(name="Volume", default="")
bpy.types.Camera.probe_strength = bpy.props.FloatProperty(name="Strength", default=1.0)
bpy.types.Camera.probe_blending = bpy.props.FloatProperty(name="Blending", default=0.0)
bpy.types.Camera.is_mirror = bpy.props.BoolProperty(name="Mirror", description="Render this camera into texture", default=False)
bpy.types.Camera.mirror_resolution_x = bpy.props.FloatProperty(name="X", default=512.0)
bpy.types.Camera.mirror_resolution_y = bpy.props.FloatProperty(name="Y", default=256.0)
@ -382,7 +349,7 @@ def init_properties():
bpy.types.Camera.rp_bloom = bpy.props.BoolProperty(name="Bloom", description="Bloom processing", default=False, update=update_renderpath)
bpy.types.Camera.rp_eyeadapt = bpy.props.BoolProperty(name="Eye Adaptation", description="Auto-exposure based on histogram", default=False, update=update_renderpath)
bpy.types.Camera.rp_rendercapture = bpy.props.BoolProperty(name="Render Capture", description="Save output as render result", default=False, update=update_renderpath)
bpy.types.Camera.rp_rendercapture_format = EnumProperty(
bpy.types.World.rp_rendercapture_format = EnumProperty(
items=[('8bit', '8bit', '8bit'),
('16bit', '16bit', '16bit'),
('32bit', '32bit', '32bit')],
@ -455,18 +422,18 @@ def init_properties():
bpy.types.World.world_defs = bpy.props.StringProperty(name="World Shader Defs", default='')
bpy.types.World.rp_defs = bpy.props.StringProperty(name="Render Path Shader Defs", default='')
bpy.types.World.compo_defs = bpy.props.StringProperty(name="Compositor Shader Defs", default='')
bpy.types.World.generate_irradiance = bpy.props.BoolProperty(name="Probe Irradiance", description="Generate spherical harmonics", default=True, update=assets.invalidate_shader_cache)
bpy.types.World.generate_radiance = bpy.props.BoolProperty(name="Probe Radiance", description="Generate radiance textures", default=True, update=assets.invalidate_shader_cache)
bpy.types.World.generate_irradiance = bpy.props.BoolProperty(name="Irradiance", description="Generate spherical harmonics", default=True, update=assets.invalidate_shader_cache)
bpy.types.World.generate_radiance = bpy.props.BoolProperty(name="Radiance", description="Generate radiance textures", default=True, update=assets.invalidate_shader_cache)
bpy.types.World.generate_radiance_size = EnumProperty(
items=[('512', '512', '512'),
('1024', '1024', '1024'),
('2048', '2048', '2048')],
name="Probe Size", description="Prefiltered map size", default='1024', update=assets.invalidate_envmap_data)
name="", description="Prefiltered map size", default='1024', update=assets.invalidate_envmap_data)
bpy.types.World.generate_radiance_sky = bpy.props.BoolProperty(name="Sky Radiance", default=True, update=assets.invalidate_shader_cache)
bpy.types.World.generate_radiance_sky_type = EnumProperty(
items=[('Fake', 'Fake', 'Fake'),
('Hosek', 'Hosek', 'Hosek')],
name="Type", description="Prefiltered maps to be used for radiance", default='Hosek', update=assets.invalidate_envmap_data)
name="", description="Prefiltered maps to be used for radiance", default='Hosek', update=assets.invalidate_envmap_data)
bpy.types.World.generate_clouds = bpy.props.BoolProperty(name="Clouds", default=False, update=assets.invalidate_shader_cache)
bpy.types.World.generate_clouds_density = bpy.props.FloatProperty(name="Density", default=0.5, min=0.0, max=10.0, update=assets.invalidate_shader_cache)
bpy.types.World.generate_clouds_size = bpy.props.FloatProperty(name="Size", default=1.0, min=0.0, max=10.0, update=assets.invalidate_shader_cache)
@ -534,10 +501,9 @@ def init_properties():
('Reinhard', 'Reinhard', 'Reinhard'),
('Uncharted', 'Uncharted', 'Uncharted')],
name='Tonemap', description='Tonemapping operator', default='Filmic', update=assets.invalidate_shader_cache)
bpy.types.World.generate_lamp_texture = bpy.props.StringProperty(name="Lamp Texture", default="")
bpy.types.World.generate_lamp_ies_texture = bpy.props.StringProperty(name="Lamp IES Texture", default="")
bpy.types.World.generate_lamp_texture = bpy.props.StringProperty(name="Mask Texture", default="")
bpy.types.World.generate_lamp_ies_texture = bpy.props.StringProperty(name="IES Texture", default="")
bpy.types.World.generate_lens_texture = bpy.props.StringProperty(name="Lens Texture", default="")
bpy.types.World.generate_lamp_falloff = bpy.props.BoolProperty(name="Lamp Falloff", default=True, update=assets.invalidate_shader_cache)
bpy.types.World.generate_fisheye = bpy.props.BoolProperty(name="Fish Eye", default=False, update=assets.invalidate_shader_cache)
bpy.types.World.generate_vignette = bpy.props.BoolProperty(name="Vignette", default=False, update=assets.invalidate_shader_cache)
# Skin
@ -572,9 +538,9 @@ def init_properties():
bpy.types.Material.cast_shadow = bpy.props.BoolProperty(name="Cast Shadow", default=True)
bpy.types.Material.receive_shadow = bpy.props.BoolProperty(name="Receive Shadow", default=True)
bpy.types.Material.override_shader = bpy.props.BoolProperty(name="Override Shader", default=False)
bpy.types.Material.override_shader_name = bpy.props.StringProperty(name="Name", default='')
bpy.types.Material.override_shader_name = bpy.props.StringProperty(name="", default='')
bpy.types.Material.override_shader_context = bpy.props.BoolProperty(name="Override Context", default=False)
bpy.types.Material.override_shader_context_name = bpy.props.StringProperty(name="Name", default='')
bpy.types.Material.override_shader_context_name = bpy.props.StringProperty(name="", default='')
bpy.types.Material.stencil_mask = bpy.props.IntProperty(name="Stencil Mask", default=0)
bpy.types.Material.export_uvs = bpy.props.BoolProperty(name="Export UVs", default=False)
bpy.types.Material.export_vcols = bpy.props.BoolProperty(name="Export VCols", default=False)
@ -583,15 +549,15 @@ def init_properties():
bpy.types.Material.skip_context = bpy.props.StringProperty(name="Skip Context", default='')
bpy.types.Material.overlay = bpy.props.BoolProperty(name="Overlay", default=False)
bpy.types.Material.decal = bpy.props.BoolProperty(name="Decal", default=False)
bpy.types.Material.two_sided_shading = bpy.props.BoolProperty(name="Two-Sided Shading", default=False)
bpy.types.Material.two_sided_shading = bpy.props.BoolProperty(name="Two-Sided", default=False)
bpy.types.Material.override_cull_mode = EnumProperty(
items = [('none', 'None', 'None'),
('clockwise', 'Clockwise', 'Clockwise'),
('counter_clockwise', 'Counter-Clockwise', 'Counter-Clockwise')],
name = "Face Culling", default='clockwise')
bpy.types.Material.discard_transparent = bpy.props.BoolProperty(name="Discard Transparent", default=False)
bpy.types.Material.discard_transparent_opacity = bpy.props.FloatProperty(name="Discard Opacity", default=0.2, min=0, max=1)
bpy.types.Material.discard_transparent_opacity_shadows = bpy.props.FloatProperty(name="Discard Opacity Shadows", default=0.1, min=0, max=1)
items=[('none', 'Both', 'None'),
('clockwise', 'Front', 'Clockwise'),
('counter_clockwise', 'Back', 'Counter-Clockwise')],
name="", default='clockwise', description="Draw geometry faces")
bpy.types.Material.discard_transparent = bpy.props.BoolProperty(name="Discard", default=False)
bpy.types.Material.discard_transparent_opacity = bpy.props.FloatProperty(name="Mesh Opacity", default=0.2, min=0, max=1)
bpy.types.Material.discard_transparent_opacity_shadows = bpy.props.FloatProperty(name="Shadows Opacity", default=0.1, min=0, max=1)
bpy.types.Material.override_compare = bpy.props.BoolProperty(name="Override Compare-Mode", default=False)
bpy.types.Material.override_compare_mode = EnumProperty(
items = [('Always', 'Always', 'Always'),
@ -602,12 +568,12 @@ def init_properties():
items = [('True', 'True', 'True'),
('False', 'False', 'False')],
name = "Depth-Write", default='True')
bpy.types.Material.height_tess = bpy.props.BoolProperty(name="Tessellated Displacement", description="Use tessellation shaders to subdivide and displace surface", default=True)
bpy.types.Material.height_tess_inner = bpy.props.IntProperty(name="Inner Level", description="Inner tessellation level for mesh", default=14)
bpy.types.Material.height_tess_outer = bpy.props.IntProperty(name="Outer Level", description="Outer tessellation level for mesh", default=14)
bpy.types.Material.height_tess_shadows = bpy.props.BoolProperty(name="Tessellated Shadows", description="Use tessellation shaders when rendering shadow maps", default=True)
bpy.types.Material.height_tess_shadows_inner = bpy.props.IntProperty(name="Inner Level", description="Inner tessellation level for shadows", default=7)
bpy.types.Material.height_tess_shadows_outer = bpy.props.IntProperty(name="Outer Level", description="Outer tessellation level for shadows", default=7)
bpy.types.Material.height_tess = bpy.props.BoolProperty(name="Tess Displacement", description="Use tessellation shaders to subdivide and displace surface", default=True)
bpy.types.Material.height_tess_inner = bpy.props.IntProperty(name="Inner", description="Inner tessellation level for mesh", default=14)
bpy.types.Material.height_tess_outer = bpy.props.IntProperty(name="Outer", description="Outer tessellation level for mesh", default=14)
bpy.types.Material.height_tess_shadows = bpy.props.BoolProperty(name="Tess Shadows", description="Use tessellation shaders when rendering shadow maps", default=True)
bpy.types.Material.height_tess_shadows_inner = bpy.props.IntProperty(name="Inner", description="Inner tessellation level for shadows", default=7)
bpy.types.Material.height_tess_shadows_outer = bpy.props.IntProperty(name="Outer", description="Outer tessellation level for shadows", default=7)
bpy.types.Material.transluc_shadows = bpy.props.BoolProperty(name="Translucent Shadows", description="Cast shadows for translucent surfaces", default=True)
# For scene
bpy.types.Scene.game_export = bpy.props.BoolProperty(name="Export", description="Export scene data", default=True)
@ -618,9 +584,8 @@ def init_properties():
bpy.types.Lamp.lamp_clip_end = bpy.props.FloatProperty(name="Clip End", default=50.0)
bpy.types.Lamp.lamp_fov = bpy.props.FloatProperty(name="Field of View", default=0.84)
bpy.types.Lamp.lamp_shadows_bias = bpy.props.FloatProperty(name="Bias", description="Depth offset for shadow acne", default=0.0001)
bpy.types.Lamp.lamp_omni_shadows = bpy.props.BoolProperty(name="Omnidirectional Shadows", description="Draw shadows to all faces of the cube map", default=True)
bpy.types.Lamp.lamp_omni_shadows_cubemap = bpy.props.BoolProperty(name="Cubemap Capture", description="Store shadowmap in a single cubemap", default=True)
bpy.types.World.lamp_omni_shadows_cubemap_pcfsize = bpy.props.FloatProperty(name="PCF Size", description="Filter size", default=0.001)
bpy.types.Lamp.lamp_omni_shadows = bpy.props.BoolProperty(name="Omni-Shadows", description="Draw shadows to all faces of the cube map", default=True)
bpy.types.World.lamp_omni_shadows_pcfsize = bpy.props.FloatProperty(name="PCF Size", description="Filter size", default=0.001)
if not 'Arm' in bpy.data.worlds:
wrd = bpy.data.worlds.new('Arm')

18
blender/arm/props_globalvars.py
View file

@ -1,18 +0,0 @@
import bpy
from bpy.types import Menu, Panel, UIList
from bpy.props import *
class ArmGlobalVarsPropsPanel(bpy.types.Panel):
bl_label = "Armory Global Variables"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "world"
def draw(self, context):
layout = self.layout
def register():
bpy.utils.register_class(ArmGlobalVarsPropsPanel)
def unregister():
bpy.utils.unregister_class(ArmGlobalVarsPropsPanel)

10
blender/arm/props_lod.py
View file

@ -156,7 +156,6 @@ class ToolsLodPanel(bpy.types.Panel):
return
mdata = obj.data
layout.prop(mdata, "lod_material")
rows = 2
if len(mdata.my_lodlist) > 1:
@ -180,10 +179,11 @@ class ToolsLodPanel(bpy.types.Panel):
layout.separator()
layout.operator("arm.generate_lod")
wrd = bpy.data.worlds['Arm']
layout.prop(wrd, 'arm_lod_advanced')
if wrd.arm_lod_advanced:
layout.prop(wrd, 'arm_lod_gen_levels')
layout.prop(wrd, 'arm_lod_gen_ratio')
row = layout.row()
row.prop(wrd, 'arm_lod_gen_levels')
row.prop(wrd, 'arm_lod_gen_ratio')
layout.prop(mdata, "lod_material")
def register():
bpy.utils.register_class(ListLodItem)

51
blender/arm/props_navigation.py
View file

@ -1,51 +0,0 @@
import bpy
from bpy.types import Menu, Panel, UIList
from bpy.props import *
class ArmoryGenerateNavmeshButton(bpy.types.Operator):
'''Generate navmesh from selected meshes'''
bl_idname = 'arm.generate_navmesh'
bl_label = 'Generate Navmesh'
def execute(self, context):
obj = context.active_object
if obj == None or obj.type != 'MESH':
return{'CANCELLED'}
# TODO: build tilecache here
# Navmesh trait
obj.my_traitlist.add()
obj.my_traitlist[-1].type_prop = 'Bundled Script'
obj.my_traitlist[-1].class_name_prop = 'NavMesh'
# For visualization
bpy.ops.mesh.navmesh_make('EXEC_DEFAULT')
obj = context.active_object
obj.hide_render = True
obj.game_export = False
return{'FINISHED'}
class SceneNavigationPropsPanel(bpy.types.Panel):
bl_label = "Armory Navigation"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "scene"
def draw(self, context):
layout = self.layout
scene = bpy.context.scene
if scene == None:
return
layout.operator("arm.generate_navmesh")
def register():
bpy.utils.register_class(ArmoryGenerateNavmeshButton)
bpy.utils.register_class(SceneNavigationPropsPanel)
def unregister():
bpy.utils.unregister_class(ArmoryGenerateNavmeshButton)
bpy.utils.unregister_class(SceneNavigationPropsPanel)

111
blender/arm/props_renderer.py
View file

@ -372,8 +372,6 @@ class GenRPDataPropsPanel(bpy.types.Panel):
layout.prop(dat, "rp_eyeadapt")
layout.prop(dat, "rp_motionblur")
layout.prop(dat, "rp_rendercapture")
if dat.rp_rendercapture:
layout.prop(dat, "rp_rendercapture_format")
layout.prop(dat, "rp_ocean")
class PropsRPDataPropsPanel(bpy.types.Panel):
@ -408,58 +406,71 @@ class PropsRPDataPropsPanel(bpy.types.Panel):
layout.prop(wrd, 'tessellation_enabled')
layout.prop(wrd, 'force_no_culling')
layout.prop(wrd, 'generate_two_sided_area_lamp')
layout.prop(wrd, 'generate_clouds')
if wrd.generate_clouds:
layout.prop(wrd, 'generate_clouds_density')
layout.prop(wrd, 'generate_clouds_size')
layout.prop(wrd, 'generate_clouds_lower')
layout.prop(wrd, 'generate_clouds_upper')
layout.prop(wrd, 'generate_clouds_wind')
layout.prop(wrd, 'generate_clouds_secondary')
layout.prop(wrd, 'generate_clouds_precipitation')
layout.prop(wrd, 'generate_clouds_eccentricity')
layout.prop(wrd, 'arm_camera_props_advanced')
if wrd.arm_camera_props_advanced:
layout.label('SSAO')
# layout.prop(wrd, 'generate_ssao')
# if wrd.generate_ssao:
layout.prop(wrd, 'generate_ssao_size')
layout.prop(wrd, 'generate_ssao_strength')
layout.prop(wrd, 'generate_ssao_half_res')
layout.label('Bloom')
# layout.prop(wrd, 'generate_bloom')
# if wrd.generate_bloom:
layout.prop(wrd, 'generate_bloom_threshold')
layout.prop(wrd, 'generate_bloom_strength')
layout.prop(wrd, 'generate_bloom_radius')
layout.label('Motion Blur')
# layout.prop(wrd, 'generate_motion_blur')
# if wrd.generate_motion_blur:
layout.prop(wrd, 'generate_motion_blur_intensity')
layout.label('SSR')
# layout.prop(wrd, 'generate_ssr')
# if wrd.generate_ssr:
layout.prop(wrd, 'generate_ssr_ray_step')
layout.prop(wrd, 'generate_ssr_min_ray_step')
layout.prop(wrd, 'generate_ssr_search_dist')
layout.prop(wrd, 'generate_ssr_falloff_exp')
layout.prop(wrd, 'generate_ssr_jitter')
layout.prop(wrd, 'generate_ssr_half_res')
layout.prop(wrd, 'generate_clouds')
if wrd.generate_clouds:
layout.prop(wrd, 'generate_clouds_density')
layout.prop(wrd, 'generate_clouds_size')
layout.prop(wrd, 'generate_clouds_lower')
layout.prop(wrd, 'generate_clouds_upper')
layout.prop(wrd, 'generate_clouds_wind')
layout.prop(wrd, 'generate_clouds_secondary')
layout.prop(wrd, 'generate_clouds_precipitation')
layout.prop(wrd, 'generate_clouds_eccentricity')
layout.label('SSAO')
# layout.prop(wrd, 'generate_ssao')
# if wrd.generate_ssao:
layout.prop(wrd, 'generate_ssao_size')
layout.prop(wrd, 'generate_ssao_strength')
layout.prop(wrd, 'generate_ssao_half_res')
layout.label('Bloom')
# layout.prop(wrd, 'generate_bloom')
# if wrd.generate_bloom:
layout.prop(wrd, 'generate_bloom_threshold')
layout.prop(wrd, 'generate_bloom_strength')
layout.prop(wrd, 'generate_bloom_radius')
layout.label('Motion Blur')
# layout.prop(wrd, 'generate_motion_blur')
# if wrd.generate_motion_blur:
layout.prop(wrd, 'generate_motion_blur_intensity')
layout.label('SSR')
# layout.prop(wrd, 'generate_ssr')
# if wrd.generate_ssr:
layout.prop(wrd, 'generate_ssr_ray_step')
layout.prop(wrd, 'generate_ssr_min_ray_step')
layout.prop(wrd, 'generate_ssr_search_dist')
layout.prop(wrd, 'generate_ssr_falloff_exp')
layout.prop(wrd, 'generate_ssr_jitter')
layout.prop(wrd, 'generate_ssr_half_res')
layout.label('SSRS')
layout.prop(wrd, 'generate_ssrs_ray_step')
layout.label('SSRS')
layout.prop(wrd, 'generate_ssrs_ray_step')
layout.label('Volumetric Light')
# layout.prop(wrd, 'generate_volumetric_light')
# if wrd.generate_volumetric_light:
layout.prop(wrd, 'generate_volumetric_light_air_turbidity')
layout.prop(wrd, 'generate_volumetric_light_air_color')
layout.label('Volumetric Light')
# layout.prop(wrd, 'generate_volumetric_light')
# if wrd.generate_volumetric_light:
layout.prop(wrd, 'generate_volumetric_light_air_turbidity')
layout.prop(wrd, 'generate_volumetric_light_air_color')
layout.prop(wrd, 'generate_tonemap')
layout.prop(wrd, 'generate_letterbox')
if wrd.generate_letterbox:
layout.prop(wrd, 'generate_letterbox_size')
layout.prop(wrd, 'generate_grain')
if wrd.generate_grain:
layout.prop(wrd, 'generate_grain_strength')
layout.prop(wrd, 'generate_fog')
if wrd.generate_fog:
layout.prop(wrd, 'generate_fog_color')
layout.prop(wrd, 'generate_fog_amounta')
layout.prop(wrd, 'generate_fog_amountb')
layout.prop(wrd, 'generate_fisheye')
layout.prop(wrd, 'generate_vignette')
layout.prop(wrd, 'generate_lens_texture')
def register():
bpy.utils.register_class(GenRPDataPropsPanel)

139
blender/arm/props_traits_action.py
View file

@ -1,139 +0,0 @@
import shutil
import bpy
import os
import json
from bpy.types import Menu, Panel, UIList
from bpy.props import *
class ListActionTraitItem(bpy.types.PropertyGroup):
# Group of properties representing an item in the list
name = bpy.props.StringProperty(
name="Name",
description="A name for this item",
default="")
enabled_prop = bpy.props.BoolProperty(
name="",
description="A name for this item",
default=True)
action_name_prop = bpy.props.StringProperty(
name="Action",
description="A name for this item",
default="")
class MY_UL_ActionTraitList(bpy.types.UIList):
def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
# We could write some code to decide which icon to use here...
custom_icon = 'OBJECT_DATAMODE'
# Make sure your code supports all 3 layout types
if self.layout_type in {'DEFAULT', 'COMPACT'}:
layout.prop(item, "enabled_prop")
layout.label(item.name, icon=custom_icon)
# layout.prop(item, "name", text="", emboss=False, icon=custom_icon)
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label("", icon = custom_icon)
class LIST_OT_ActionTraitNewItem(bpy.types.Operator):
# Add a new item to the list
bl_idname = "my_actiontraitlist.new_item"
bl_label = "Add a new item"
def execute(self, context):
trait = context.object.data
trait.my_actiontraitlist.add()
trait.actiontraitlist_index = len(trait.my_actiontraitlist) - 1
return{'FINISHED'}
class LIST_OT_ActionTraitDeleteItem(bpy.types.Operator):
# Delete the selected item from the list
bl_idname = "my_actiontraitlist.delete_item"
bl_label = "Deletes an item"
@classmethod
def poll(self, context):
""" Enable if there's something in the list """
trait = context.object.data
return len(trait.my_actiontraitlist) > 0
def execute(self, context):
trait = context.object.data
list = trait.my_actiontraitlist
index = trait.actiontraitlist_index
list.remove(index)
if index > 0:
index = index - 1
trait.actiontraitlist_index = index
return{'FINISHED'}
class LIST_OT_ActionTraitMoveItem(bpy.types.Operator):
# Move an item in the list
bl_idname = "my_actiontraitlist.move_item"
bl_label = "Move an item in the list"
direction = bpy.props.EnumProperty(
items=(
('UP', 'Up', ""),
('DOWN', 'Down', ""),))
@classmethod
def poll(self, context):
""" Enable if there's something in the list. """
trait = context.object.data
return len(trait.my_actiontraitlist) > 0
def move_index(self):
# Move index of an item render queue while clamping it
trait = context.object.data
index = trait.actiontraitlist_index
list_length = len(trait.my_actiontraitlist) - 1
new_index = 0
if self.direction == 'UP':
new_index = index - 1
elif self.direction == 'DOWN':
new_index = index + 1
new_index = max(0, min(new_index, list_length))
index = new_index
def execute(self, context):
trait = context.object.data
list = trait.my_actiontraitlist
index = trait.actiontraitlist_index
if self.direction == 'DOWN':
neighbor = index + 1
#queue.move(index,neighbor)
self.move_index()
elif self.direction == 'UP':
neighbor = index - 1
#queue.move(neighbor, index)
self.move_index()
else:
return{'CANCELLED'}
return{'FINISHED'}
def register():
bpy.utils.register_class(ListActionTraitItem)
bpy.utils.register_class(MY_UL_ActionTraitList)
bpy.utils.register_class(LIST_OT_ActionTraitNewItem)
bpy.utils.register_class(LIST_OT_ActionTraitDeleteItem)
bpy.utils.register_class(LIST_OT_ActionTraitMoveItem)
def unregister():
bpy.utils.unregister_class(ListActionTraitItem)
bpy.utils.unregister_class(MY_UL_ActionTraitList)
bpy.utils.unregister_class(LIST_OT_ActionTraitNewItem)
bpy.utils.unregister_class(LIST_OT_ActionTraitDeleteItem)
bpy.utils.unregister_class(LIST_OT_ActionTraitMoveItem)

160
blender/arm/props_traits_clip.py
View file

@ -1,160 +0,0 @@
import shutil
import bpy
import os
import json
from bpy.types import Menu, Panel, UIList
from bpy.props import *
class ListClipTraitItem(bpy.types.PropertyGroup):
# Group of properties representing an item in the list
name = bpy.props.StringProperty(
name="Name",
description="A name for this item",
default="Untitled")
enabled_prop = bpy.props.BoolProperty(
name="",
description="A name for this item",
default=True)
start_prop = bpy.props.IntProperty(
name="Start",
description="A name for this item",
default=0)
end_prop = bpy.props.IntProperty(
name="End",
description="A name for this item",
default=0)
speed_prop = bpy.props.FloatProperty(
name="Speed",
description="A name for this item",
default=1.0)
loop_prop = bpy.props.BoolProperty(
name="Loop",
description="A name for this item",
default=True)
reflect_prop = bpy.props.BoolProperty(
name="Reflect",
description="A name for this item",
default=False)
class MY_UL_ClipTraitList(bpy.types.UIList):
def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
# We could write some code to decide which icon to use here...
custom_icon = 'OBJECT_DATAMODE'
# Make sure your code supports all 3 layout types
if self.layout_type in {'DEFAULT', 'COMPACT'}:
layout.prop(item, "enabled_prop")
#layout.label(item.name, icon = custom_icon)
layout.prop(item, "name", text="", emboss=False, icon=custom_icon)
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label("", icon = custom_icon)
class LIST_OT_ClipTraitNewItem(bpy.types.Operator):
# Add a new item to the list
bl_idname = "my_cliptraitlist.new_item"
bl_label = "Add a new item"
def execute(self, context):
trait = context.object
trait.my_cliptraitlist.add()
trait.cliptraitlist_index = len(trait.my_cliptraitlist) - 1
return{'FINISHED'}
class LIST_OT_ClipTraitDeleteItem(bpy.types.Operator):
# Delete the selected item from the list
bl_idname = "my_cliptraitlist.delete_item"
bl_label = "Deletes an item"
@classmethod
def poll(self, context):
""" Enable if there's something in the list """
trait = context.object
return len(trait.my_cliptraitlist) > 0
def execute(self, context):
trait = context.object
list = trait.my_cliptraitlist
index = trait.cliptraitlist_index
list.remove(index)
if index > 0:
index = index - 1
trait.cliptraitlist_index = index
return{'FINISHED'}
class LIST_OT_ClipTraitMoveItem(bpy.types.Operator):
# Move an item in the list
bl_idname = "my_cliptraitlist.move_item"
bl_label = "Move an item in the list"
direction = bpy.props.EnumProperty(
items=(
('UP', 'Up', ""),
('DOWN', 'Down', ""),))
@classmethod
def poll(self, context):
""" Enable if there's something in the list. """
trait = context.object
return len(trait.my_cliptraitlist) > 0
def move_index(self):
# Move index of an item render queue while clamping it
trait = context.object
index = trait.cliptraitlist_index
list_length = len(trait.my_cliptraitlist) - 1
new_index = 0
if self.direction == 'UP':
new_index = index - 1
elif self.direction == 'DOWN':
new_index = index + 1
new_index = max(0, min(new_index, list_length))
index = new_index
def execute(self, context):
trait = context.object
list = trait.my_cliptraitlist
index = trait.cliptraitlist_index
if self.direction == 'DOWN':
neighbor = index + 1
#queue.move(index,neighbor)
self.move_index()
elif self.direction == 'UP':
neighbor = index - 1
#queue.move(neighbor, index)
self.move_index()
else:
return{'CANCELLED'}
return{'FINISHED'}
def register():
bpy.utils.register_class(ListClipTraitItem)
bpy.utils.register_class(MY_UL_ClipTraitList)
bpy.utils.register_class(LIST_OT_ClipTraitNewItem)
bpy.utils.register_class(LIST_OT_ClipTraitDeleteItem)
bpy.utils.register_class(LIST_OT_ClipTraitMoveItem)
def unregister():
bpy.utils.unregister_class(ListClipTraitItem)
bpy.utils.unregister_class(MY_UL_ClipTraitList)
bpy.utils.unregister_class(LIST_OT_ClipTraitNewItem)
bpy.utils.unregister_class(LIST_OT_ClipTraitDeleteItem)
bpy.utils.unregister_class(LIST_OT_ClipTraitMoveItem)

621
blender/arm/props_ui.py
View file

@ -3,8 +3,6 @@ import subprocess
import webbrowser
from bpy.types import Menu, Panel, UIList
from bpy.props import *
from arm.props_traits_clip import *
from arm.props_traits_action import *
import arm.utils
import arm.make_renderer as make_renderer
import arm.make as make
@ -29,88 +27,40 @@ class ObjectPropsPanel(bpy.types.Panel):
wrd = bpy.data.worlds['Arm']
if wrd.arm_export_hide_render == False:
layout.prop(obj, 'hide_render')
hide = obj.hide_render
else:
layout.prop(obj, 'game_export')
hide = not obj.game_export
if hide:
row = layout.row()
row.prop(obj, 'game_export')
if not obj.game_export:
return
layout.prop(wrd, 'arm_object_advanced')
if wrd.arm_object_advanced:
if wrd.arm_export_hide_render == False:
layout.prop(obj, 'game_visible')
else:
layout.prop(obj, 'hide_render')
row = layout.row(align=True)
row.prop(obj, 'spawn')
row.prop(obj, 'mobile')
if obj.type == 'MESH':
layout.prop(obj, 'instanced_children')
if obj.instanced_children:
layout.label('Location')
row = layout.row()
row.prop(obj, 'instanced_children_loc_x')
row.prop(obj, 'instanced_children_loc_y')
row.prop(obj, 'instanced_children_loc_z')
layout.label('Rotation')
row = layout.row()
row.prop(obj, 'instanced_children_rot_x')
row.prop(obj, 'instanced_children_rot_y')
row.prop(obj, 'instanced_children_rot_z')
layout.label('Scale')
row = layout.row()
row.prop(obj, 'instanced_children_scale_x')
row.prop(obj, 'instanced_children_scale_y')
row.prop(obj, 'instanced_children_scale_z')
layout.prop(obj, 'override_material')
if obj.override_material:
layout.prop(obj, 'override_material_name')
row.prop(obj, 'spawn')
if obj.type == 'ARMATURE':
layout.prop(obj, 'bone_animation_enabled')
if obj.bone_animation_enabled:
layout.prop(obj, 'edit_actions_prop')
if obj.edit_actions_prop:
layout.prop_search(obj, "start_action_name_prop", obj.data, "my_actiontraitlist", "Start Action")
else:
layout.prop(obj, 'object_animation_enabled')
if (obj.type == 'ARMATURE' and obj.bone_animation_enabled) or (obj.type != 'ARMATURE' and obj.object_animation_enabled):
layout.prop(obj, 'edit_tracks_prop')
if obj.edit_tracks_prop:
layout.prop_search(obj, "start_track_name_prop", obj, "my_cliptraitlist", "Start Clip")
# Tracks list
layout.label("Clips")
animrow = layout.row()
animrows = 2
if len(obj.my_cliptraitlist) > 1:
animrows = 4
row = layout.row()
row.template_list("MY_UL_ClipTraitList", "The_List", obj, "my_cliptraitlist", obj, "cliptraitlist_index", rows=animrows)
row = layout.row()
row.prop(obj, 'mobile')
if obj.type == 'ARMATURE':
row.prop(obj, 'bone_animation_enabled')
else:
row.prop(obj, 'object_animation_enabled')
col = row.column(align=True)
col.operator("my_cliptraitlist.new_item", icon='ZOOMIN', text="")
col.operator("my_cliptraitlist.delete_item", icon='ZOOMOUT', text="")
if len(obj.my_cliptraitlist) > 1:
col.separator()
col.operator("my_cliptraitlist.move_item", icon='TRIA_UP', text="").direction = 'UP'
col.operator("my_cliptraitlist.move_item", icon='TRIA_DOWN', text="").direction = 'DOWN'
if obj.cliptraitlist_index >= 0 and len(obj.my_cliptraitlist) > 0:
animitem = obj.my_cliptraitlist[obj.cliptraitlist_index]
row = layout.row()
row.prop(animitem, "start_prop")
row.prop(animitem, "end_prop")
layout.prop(animitem, "speed_prop")
row = layout.row(align=True)
row.prop(animitem, "loop_prop")
row.prop(animitem, "reflect_prop")
if obj.type == 'MESH':
layout.prop(obj, 'instanced_children')
if obj.instanced_children:
layout.label('Location')
column = layout.column()
column.prop(obj, 'instanced_children_loc_x')
column.prop(obj, 'instanced_children_loc_y')
column.prop(obj, 'instanced_children_loc_z')
# layout.label('Rotation')
# row = layout.row()
# row.prop(obj, 'instanced_children_rot_x')
# row.prop(obj, 'instanced_children_rot_y')
# row.prop(obj, 'instanced_children_rot_z')
# layout.label('Scale')
# row = layout.row()
# row.prop(obj, 'instanced_children_scale_x')
# row.prop(obj, 'instanced_children_scale_y')
# row.prop(obj, 'instanced_children_scale_z')
# layout.prop(obj, 'override_material')
# if obj.override_material:
# layout.prop(obj, 'override_material_name')
class ModifiersPropsPanel(bpy.types.Panel):
bl_label = "Armory Props"
@ -165,21 +115,17 @@ class DataPropsPanel(bpy.types.Panel):
if obj == None:
return
wrd = bpy.data.worlds['Arm']
if obj.type == 'CAMERA':
layout.prop(obj.data, 'is_probe')
if obj.data.is_probe == True:
layout.prop(obj.data, 'probe_texture')
layout.prop_search(obj.data, "probe_volume", bpy.data, "objects")
layout.prop(obj.data, 'probe_strength')
layout.prop(obj.data, 'probe_blending')
layout.prop(obj.data, 'is_mirror')
if obj.data.is_mirror == True:
layout.label('Resolution')
row = layout.row(align=True)
row.prop(obj.data, 'mirror_resolution_x')
row.prop(obj.data, 'mirror_resolution_y')
layout.prop(obj.data, 'frustum_culling')
layout.prop_search(obj.data, "renderpath_path", bpy.data, "node_groups")
layout.prop(obj.data, 'frustum_culling')
layout.prop(obj.data, 'is_mirror')
col = layout.column()
col.enabled = obj.data.is_mirror
row = col.row(align=True)
row.label('Resolution')
row.prop(obj.data, 'mirror_resolution_x')
row.prop(obj.data, 'mirror_resolution_y')
elif obj.type == 'MESH' or obj.type == 'FONT' or obj.type == 'META':
row = layout.row(align=True)
row.prop(obj.data, 'dynamic_usage')
@ -189,50 +135,23 @@ class DataPropsPanel(bpy.types.Panel):
layout.operator("arm.invalidate_cache")
elif obj.type == 'LAMP':
row = layout.row(align=True)
row.prop(obj.data, 'lamp_clip_start')
row.prop(obj.data, 'lamp_clip_end')
row = layout.row(align=False)
row.prop(obj.data, 'lamp_fov')
row.prop(obj.data, 'lamp_shadows_bias')
col = row.column()
col.prop(obj.data, 'lamp_clip_start')
col.prop(obj.data, 'lamp_clip_end')
col = row.column()
col.prop(obj.data, 'lamp_fov')
col.prop(obj.data, 'lamp_shadows_bias')
if obj.data.type == 'POINT':
layout.prop(obj.data, 'lamp_omni_shadows')
if obj.data.lamp_omni_shadows:
layout.prop(obj.data, 'lamp_omni_shadows_cubemap')
if not obj.data.lamp_omni_shadows_cubemap:
layout.label('Warning: Will result in performance loss')
else:
layout.prop(bpy.data.worlds['Arm'], 'lamp_omni_shadows_cubemap_pcfsize')
col = layout.column()
col.enabled = obj.data.lamp_omni_shadows
col.prop(wrd, 'lamp_omni_shadows_pcfsize')
layout.prop(wrd, 'generate_lamp_texture')
layout.prop(wrd, 'generate_lamp_ies_texture')
elif obj.type == 'SPEAKER':
layout.prop(obj.data, 'loop')
layout.prop(obj.data, 'stream')
elif obj.type == 'ARMATURE':
layout.prop(obj.data, 'edit_actions')
if obj.data.edit_actions:
# Actions list
layout.label("Actions")
animrow = layout.row()
animrows = 2
if len(obj.data.my_actiontraitlist) > 1:
animrows = 4
row = layout.row()
row.template_list("MY_UL_ActionTraitList", "The_List", obj.data, "my_actiontraitlist", obj.data, "actiontraitlist_index", rows=animrows)
col = row.column(align=True)
col.operator("my_actiontraitlist.new_item", icon='ZOOMIN', text="")
col.operator("my_actiontraitlist.delete_item", icon='ZOOMOUT', text="")
if len(obj.data.my_actiontraitlist) > 1:
col.separator()
col.operator("my_actiontraitlist.move_item", icon='TRIA_UP', text="").direction = 'UP'
col.operator("my_actiontraitlist.move_item", icon='TRIA_DOWN', text="").direction = 'DOWN'
if obj.data.actiontraitlist_index >= 0 and len(obj.data.my_actiontraitlist) > 0:
item = obj.data.my_actiontraitlist[obj.data.actiontraitlist_index]
item.name = item.action_name_prop
row = layout.row()
row.prop_search(item, "action_name_prop", bpy.data, "actions", "Action")
layout.prop(obj.data, 'data_compressed')
class ScenePropsPanel(bpy.types.Panel):
@ -246,11 +165,15 @@ class ScenePropsPanel(bpy.types.Panel):
scene = bpy.context.scene
if scene == None:
return
layout.prop(scene, 'game_export')
layout.prop(scene, 'gp_export')
if scene.gp_export:
layout.operator('arm.invalidate_gp_cache')
layout.prop(scene, 'data_compressed')
row = layout.row()
column = row.column()
column.prop(scene, 'game_export')
column.prop(scene, 'data_compressed')
column = row.column()
column.prop(scene, 'gp_export')
columnb = column.column()
columnb.enabled = scene.gp_export
columnb.operator('arm.invalidate_gp_cache')
class InvalidateCacheButton(bpy.types.Operator):
'''Delete cached mesh data'''
@ -273,7 +196,7 @@ class InvalidateMaterialCacheButton(bpy.types.Operator):
class InvalidateGPCacheButton(bpy.types.Operator):
'''Delete cached grease pencil data'''
bl_idname = "arm.invalidate_gp_cache"
bl_label = "Invalidate Grease Pencil Cache"
bl_label = "Invalidate GP Cache"
def execute(self, context):
if context.scene.grease_pencil != None:
@ -292,49 +215,62 @@ class MaterialPropsPanel(bpy.types.Panel):
if mat == None:
return
row = layout.row(align=True)
row.prop(mat, 'cast_shadow')
row.prop(mat, 'receive_shadow')
row = layout.row()
column = row.column()
column.prop(mat, 'cast_shadow')
column.prop(mat, 'receive_shadow')
column.separator()
column.prop(mat, 'two_sided_shading')
columnb = column.column()
columnb.enabled = not mat.two_sided_shading
columnb.prop(mat, 'override_cull_mode')
layout.prop(bpy.data.worlds['Arm'], 'arm_material_advanced')
if bpy.data.worlds['Arm'].arm_material_advanced:
layout.prop(mat, 'overlay')
layout.prop(mat, 'decal')
layout.prop(mat, 'two_sided_shading')
if not mat.two_sided_shading:
layout.prop(mat, 'override_cull_mode')
layout.prop(mat, 'discard_transparent')
if mat.discard_transparent:
layout.prop(mat, 'discard_transparent_opacity')
layout.prop(mat, 'discard_transparent_opacity_shadows')
layout.prop(mat, 'override_shader')
if mat.override_shader:
layout.prop(mat, 'override_shader_name')
layout.prop(mat, 'override_shader_context')
if mat.override_shader_context:
layout.prop(mat, 'override_shader_context_name')
# layout.prop(mat, 'override_compare')
# if mat.override_compare:
# layout.prop(mat, 'override_compare_mode')
# layout.prop(mat, 'override_depthwrite')
# if mat.override_depthwrite:
# layout.prop(mat, 'override_depthwrite_mode')
layout.prop(mat, 'stencil_mask')
layout.prop(mat, 'skip_context')
layout.label('Height map')
layout.prop(mat, 'height_tess')
if mat.height_tess:
row = layout.row(align=True)
row.prop(mat, 'height_tess_inner')
row.prop(mat, 'height_tess_outer')
layout.prop(mat, 'height_tess_shadows')
if mat.height_tess_shadows:
row = layout.row(align=True)
row.prop(mat, 'height_tess_shadows_inner')
row.prop(mat, 'height_tess_shadows_outer')
layout.prop(mat, 'transluc_shadows')
column = row.column()
column.prop(mat, 'overlay')
column.prop(mat, 'decal')
layout.operator("arm.invalidate_material_cache")
column.separator()
column.prop(mat, 'discard_transparent')
columnb = column.column()
columnb.enabled = mat.discard_transparent
columnb.prop(mat, 'discard_transparent_opacity')
columnb.prop(mat, 'discard_transparent_opacity_shadows')
# row = layout.row()
# column = row.column()
# column.prop(mat, 'override_shader')
# columnb = column.column()
# columnb.enabled = mat.override_shader
# columnb.prop(mat, 'override_shader_name')
# column = row.column()
# column.prop(mat, 'override_shader_context')
# columnb = column.column()
# columnb.enabled = mat.override_shader_context
# columnb.prop(mat, 'override_shader_context_name')
# row = layout.row()
# row.prop(mat, 'stencil_mask')
# row.prop(mat, 'skip_context')
layout.separator()
row = layout.row()
column = row.column()
column.prop(mat, 'height_tess')
columnb = column.column()
columnb.enabled = mat.height_tess
columnb.prop(mat, 'height_tess_inner')
columnb.prop(mat, 'height_tess_outer')
column = row.column()
column.prop(mat, 'height_tess_shadows')
columnb = column.column()
columnb.enabled = mat.height_tess_shadows
columnb.prop(mat, 'height_tess_shadows_inner')
columnb.prop(mat, 'height_tess_shadows_outer')
layout.prop(mat, 'transluc_shadows')
layout.operator("arm.invalidate_material_cache")
class WorldPropsPanel(bpy.types.Panel):
bl_label = "Armory Props"
@ -347,38 +283,15 @@ class WorldPropsPanel(bpy.types.Panel):
# wrd = bpy.context.world
wrd = bpy.data.worlds['Arm']
row = layout.row(align=True)
row.prop(wrd, 'generate_irradiance')
if wrd.generate_irradiance:
row.prop(wrd, 'generate_radiance')
if wrd.generate_radiance:
layout.prop(wrd, 'generate_radiance_size')
layout.prop(wrd, 'generate_radiance_sky')
if wrd.generate_radiance_sky:
layout.prop(wrd, 'generate_radiance_sky_type')
layout.separator()
# TODO: migrate to compositor
layout.label('Compositor (deprecated)')
layout.prop(wrd, 'generate_tonemap')
layout.prop(wrd, 'generate_letterbox')
if wrd.generate_letterbox:
layout.prop(wrd, 'generate_letterbox_size')
layout.prop(wrd, 'generate_grain')
if wrd.generate_grain:
layout.prop(wrd, 'generate_grain_strength')
layout.prop(wrd, 'generate_fog')
if wrd.generate_fog:
layout.prop(wrd, 'generate_fog_color')
layout.prop(wrd, 'generate_fog_amounta')
layout.prop(wrd, 'generate_fog_amountb')
layout.prop(wrd, 'generate_fisheye')
layout.prop(wrd, 'generate_vignette')
layout.prop(wrd, 'generate_lamp_texture')
layout.prop(wrd, 'generate_lamp_ies_texture')
layout.prop(wrd, 'generate_lens_texture')
layout.prop(wrd, 'generate_lamp_falloff')
layout.prop(wrd, 'generate_irradiance')
row = layout.row()
row.enabled = wrd.generate_irradiance
column = row.column()
column.prop(wrd, 'generate_radiance')
column.prop(wrd, 'generate_radiance_size')
column = row.column()
column.prop(wrd, 'generate_radiance_sky')
column.prop(wrd, 'generate_radiance_sky_type')
class ArmoryPlayerPanel(bpy.types.Panel):
bl_label = "Armory Player"
@ -403,42 +316,40 @@ class ArmoryPlayerPanel(bpy.types.Panel):
row.operator("arm.clean_menu")
layout.prop(wrd, 'arm_play_runtime')
layout.prop(wrd, 'arm_play_viewport_camera')
if wrd.arm_play_viewport_camera:
layout.prop(wrd, 'arm_play_viewport_navigation')
layout.prop(wrd, 'arm_play_camera')
layout.prop(wrd, 'arm_play_advanced')
if wrd.arm_play_advanced:
layout.prop(wrd, make_utils.runtime_to_gapi())
layout.prop(wrd, 'arm_play_console')
if arm.utils.with_krom():
row = layout.row(align=True)
row.prop(wrd, 'arm_play_live_patch')
if wrd.arm_play_live_patch:
row.prop(wrd, 'arm_play_auto_build')
layout.operator("arm.render", icon="RENDER_STILL")
class ArmoryRenderPanel(bpy.types.Panel):
bl_label = "Armory Render"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
wrd = bpy.data.worlds['Arm']
row = layout.row(align=True)
row.alignment = 'EXPAND'
row.operator("arm.render", icon="RENDER_STILL")
row.operator("arm.render_anim", icon="RENDER_ANIMATION")
layout.prop(wrd, "rp_rendercapture_format")
row = layout.row(align=True)
row.prop(wrd, 'arm_cache_shaders')
row.prop(wrd, 'arm_cache_compiler')
row = layout.row(align=True)
row.prop(wrd, 'arm_minimize')
row.prop(wrd, 'arm_optimize_mesh')
row = layout.row(align=True)
row.prop(wrd, 'arm_gpu_processing')
row.prop(wrd, 'arm_sampled_animation')
row = layout.row(align=True)
row.prop(wrd, 'arm_batch_meshes')
row.prop(wrd, 'arm_batch_materials')
row = layout.row(align=True)
row.prop(wrd, 'arm_deinterleaved_buffers')
row.prop(wrd, 'arm_export_tangents')
layout.prop(wrd, 'arm_stream_scene')
layout.label('Libraries')
layout.prop(wrd, 'arm_physics')
layout.prop(wrd, 'arm_navigation')
layout.prop(wrd, 'arm_ui')
layout.prop(wrd, 'arm_hscript')
class ArmoryExporterPanel(bpy.types.Panel):
bl_label = "Armory Exporter"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
wrd = bpy.data.worlds['Arm']
row = layout.row(align=True)
row.alignment = 'EXPAND'
row.operator("arm.build_project")
row.operator("arm.publish_project")
layout.prop(wrd, 'arm_project_target')
layout.prop(wrd, make_utils.target_to_gapi())
class ArmoryProjectPanel(bpy.types.Panel):
bl_label = "Armory Project"
@ -450,24 +361,75 @@ class ArmoryProjectPanel(bpy.types.Panel):
def draw(self, context):
layout = self.layout
wrd = bpy.data.worlds['Arm']
row = layout.row(align=True)
row.operator("arm.kode_studio")
row.operator("arm.open_project_folder")
layout.label('Build:')
row = layout.row()
col = row.column()
col.prop(wrd, 'arm_play_console')
col.prop(wrd, 'arm_stream_scene')
if arm.utils.with_krom():
col.prop(wrd, 'arm_play_live_patch')
colb = col.column()
colb.enabled = wrd.arm_play_live_patch
colb.prop(wrd, 'arm_play_auto_build')
col = row.column()
col.prop(wrd, 'arm_cache_shaders')
col.prop(wrd, 'arm_cache_compiler')
col.prop(wrd, 'arm_gpu_processing')
layout.label('Flags:')
row = layout.row()
col = row.column()
col.prop(wrd, 'arm_batch_meshes')
col.prop(wrd, 'arm_batch_materials')
col.prop(wrd, 'arm_sampled_animation')
col.prop(wrd, 'arm_dce')
col.prop(wrd, 'arm_play_active_scene')
if not wrd.arm_play_active_scene:
col.prop_search(wrd, 'arm_project_scene', bpy.data, 'scenes', '')
col = row.column()
col.prop(wrd, 'arm_minimize')
col.prop(wrd, 'arm_optimize_mesh')
col.prop(wrd, 'arm_deinterleaved_buffers')
col.prop(wrd, 'arm_export_tangents')
col.prop(wrd, 'arm_asset_compression')
layout.label('Window:')
row = layout.row()
col = row.column()
col.prop(wrd, 'arm_vsync')
col.prop(wrd, 'arm_loadbar')
col.prop(wrd, 'arm_winmode')
col = row.column()
col.prop(wrd, 'arm_winresize')
col.prop(wrd, 'arm_winmaximize')
col.prop(wrd, 'arm_winminimize')
layout.separator()
layout.label('Modules:')
layout.prop(wrd, 'arm_physics')
layout.prop(wrd, 'arm_navigation')
layout.prop(wrd, 'arm_ui')
layout.prop(wrd, 'arm_hscript')
layout.separator()
layout.label('Project:')
layout.prop(wrd, 'arm_project_name')
layout.prop(wrd, 'arm_project_package')
layout.prop_search(wrd, 'arm_khafile', bpy.data, 'texts', 'Khafile')
layout.prop_search(wrd, 'arm_khamake', bpy.data, 'texts', 'Khamake')
row = layout.row(align=True)
row.operator("arm.kode_studio")
row.operator("arm.open_project_folder")
row = layout.row(align=True)
row.alignment = 'EXPAND'
row.operator("arm.build_project")
row.operator("arm.publish_project")
layout.prop(wrd, 'arm_project_target')
layout.prop(wrd, make_utils.target_to_gapi())
row = layout.row(align=True)
row.prop(wrd, 'arm_dce')
row.prop(wrd, 'arm_asset_compression')
layout.label("Libraries")
layout.separator()
layout.label("Libraries:")
rows = 2
if len(wrd.my_librarytraitlist) > 1:
rows = 4
@ -486,29 +448,67 @@ class ArmoryProjectPanel(bpy.types.Panel):
# if wrd.librarytraitlist_index >= 0 and len(wrd.my_librarytraitlist) > 0:
# libitem = wrd.my_librarytraitlist[wrd.librarytraitlist_index]
layout.prop(wrd, 'arm_project_advanced')
if wrd.arm_project_advanced:
row = layout.row()
row.prop(wrd, 'arm_loadbar')
row.prop(wrd, 'arm_vsync')
row = layout.row()
row.prop(wrd, 'arm_export_hide_render')
row.prop(wrd, 'arm_spawn_all_layers')
layout.prop(wrd, 'arm_play_active_scene')
if wrd.arm_play_active_scene == False:
layout.prop_search(wrd, 'arm_project_scene', bpy.data, 'scenes', 'Scene')
layout.prop(wrd, 'arm_winmode')
layout.prop(wrd, 'arm_winresize')
layout.prop(wrd, 'arm_winmaximize')
layout.prop(wrd, 'arm_winminimize')
layout.label('Armory v' + wrd.arm_version)
layout.operator('arm.check_updates')
row = layout.row(align=True)
row.alignment = 'EXPAND'
row.operator('arm.open_manual')
row.operator('arm.report_issue')
layout.label('Armory v' + wrd.arm_version)
class ArmVirtualInputPanel(bpy.types.Panel):
bl_label = "Armory Virtual Input"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
class ArmGlobalVarsPanel(bpy.types.Panel):
bl_label = "Armory Global Variables"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
class ArmNavigationPanel(bpy.types.Panel):
bl_label = "Armory Navigation"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "scene"
def draw(self, context):
layout = self.layout
scene = bpy.context.scene
if scene == None:
return
layout.operator("arm.generate_navmesh")
class ArmoryGenerateNavmeshButton(bpy.types.Operator):
'''Generate navmesh from selected meshes'''
bl_idname = 'arm.generate_navmesh'
bl_label = 'Generate Navmesh'
def execute(self, context):
obj = context.active_object
if obj == None or obj.type != 'MESH':
return{'CANCELLED'}
# TODO: build tilecache here
# Navmesh trait
obj.my_traitlist.add()
obj.my_traitlist[-1].type_prop = 'Bundled Script'
obj.my_traitlist[-1].class_name_prop = 'NavMesh'
# For visualization
bpy.ops.mesh.navmesh_make('EXEC_DEFAULT')
obj = context.active_object
obj.hide_render = True
obj.game_export = False
return{'FINISHED'}
class ArmoryPlayButton(bpy.types.Operator):
'''Launch player in new window'''
@ -670,33 +670,6 @@ class ArmoryOpenProjectFolderButton(bpy.types.Operator):
webbrowser.open('file://' + arm.utils.get_fp())
return{'FINISHED'}
class ArmoryCheckUpdatesButton(bpy.types.Operator):
'''Open a website in the web-browser'''
bl_idname = 'arm.check_updates'
bl_label = 'Check for Updates'
def execute(self, context):
webbrowser.open("http://armory3d.org/download.html")
return{'FINISHED'}
class ArmoryManualButton(bpy.types.Operator):
'''Open a website in the web-browser'''
bl_idname = 'arm.open_manual'
bl_label = 'Manual'
def execute(self, context):
webbrowser.open("http://armory3d.org/manual/")
return{'FINISHED'}
class ArmoryReportIssueButton(bpy.types.Operator):
'''Open a website in the web-browser'''
bl_idname = 'arm.report_issue'
bl_label = 'Report Issue'
def execute(self, context):
webbrowser.open("https://github.com/armory3d/armory/issues")
return{'FINISHED'}
class ArmoryKodeStudioButton(bpy.types.Operator):
'''Launch this project in Kode Studio'''
bl_idname = 'arm.kode_studio'
@ -792,6 +765,20 @@ class ArmoryRenderButton(bpy.types.Operator):
assets.invalidate_enabled = True
return{'FINISHED'}
class ArmoryRenderAnimButton(bpy.types.Operator):
'''Capture Armory output as render result'''
bl_idname = 'arm.render_anim'
bl_label = 'Animation'
def execute(self, context):
if state.playproc != None:
make.stop_project()
if bpy.data.worlds['Arm'].arm_play_runtime != 'Krom':
bpy.data.worlds['Arm'].arm_play_runtime = 'Krom'
self.report({"ERROR"}, "Animation capture not yet supported")
return {"CANCELLED"}
# return{'FINISHED'}
# Play button in 3D View panel
def draw_view3d_header(self, context):
layout = self.layout
@ -826,7 +813,11 @@ def register():
bpy.utils.register_class(MaterialPropsPanel)
bpy.utils.register_class(WorldPropsPanel)
bpy.utils.register_class(ArmoryPlayerPanel)
bpy.utils.register_class(ArmoryRenderPanel)
bpy.utils.register_class(ArmoryExporterPanel)
bpy.utils.register_class(ArmoryProjectPanel)
# bpy.utils.register_class(ArmVirtualInputPanel)
# bpy.utils.register_class(ArmGlobalVarsPanel)
bpy.utils.register_class(ArmoryPlayButton)
bpy.utils.register_class(ArmoryPlayInViewportButton)
bpy.utils.register_class(ArmoryStopButton)
@ -834,9 +825,6 @@ def register():
bpy.utils.register_class(ArmoryBuildProjectButton)
bpy.utils.register_class(ArmoryPatchButton)
bpy.utils.register_class(ArmoryOpenProjectFolderButton)
bpy.utils.register_class(ArmoryCheckUpdatesButton)
bpy.utils.register_class(ArmoryManualButton)
bpy.utils.register_class(ArmoryReportIssueButton)
bpy.utils.register_class(ArmoryKodeStudioButton)
bpy.utils.register_class(CleanMenu)
bpy.utils.register_class(CleanButtonMenu)
@ -844,6 +832,9 @@ def register():
bpy.utils.register_class(ArmoryCleanProjectButton)
bpy.utils.register_class(ArmoryPublishButton)
bpy.utils.register_class(ArmoryRenderButton)
bpy.utils.register_class(ArmoryRenderAnimButton)
bpy.utils.register_class(ArmoryGenerateNavmeshButton)
bpy.utils.register_class(ArmNavigationPanel)
bpy.types.VIEW3D_HT_header.append(draw_view3d_header)
bpy.types.INFO_HT_header.prepend(draw_info_header)
@ -863,7 +854,11 @@ def unregister():
bpy.utils.unregister_class(MaterialPropsPanel)
bpy.utils.unregister_class(WorldPropsPanel)
bpy.utils.unregister_class(ArmoryPlayerPanel)
bpy.utils.unregister_class(ArmoryRenderPanel)
bpy.utils.unregister_class(ArmoryExporterPanel)
bpy.utils.unregister_class(ArmoryProjectPanel)
# bpy.utils.unregister_class(ArmVirtualInputPanel)
# bpy.utils.unregister_class(ArmGlobalVarsPanel)
bpy.utils.unregister_class(ArmoryPlayButton)
bpy.utils.unregister_class(ArmoryPlayInViewportButton)
bpy.utils.unregister_class(ArmoryStopButton)
@ -871,9 +866,6 @@ def unregister():
bpy.utils.unregister_class(ArmoryBuildProjectButton)
bpy.utils.unregister_class(ArmoryPatchButton)
bpy.utils.unregister_class(ArmoryOpenProjectFolderButton)
bpy.utils.unregister_class(ArmoryCheckUpdatesButton)
bpy.utils.unregister_class(ArmoryManualButton)
bpy.utils.unregister_class(ArmoryReportIssueButton)
bpy.utils.unregister_class(ArmoryKodeStudioButton)
bpy.utils.unregister_class(CleanMenu)
bpy.utils.unregister_class(CleanButtonMenu)
@ -881,3 +873,6 @@ def unregister():
bpy.utils.unregister_class(ArmoryCleanProjectButton)
bpy.utils.unregister_class(ArmoryPublishButton)
bpy.utils.unregister_class(ArmoryRenderButton)
bpy.utils.unregister_class(ArmoryRenderAnimButton)
bpy.utils.unregister_class(ArmoryGenerateNavmeshButton)
bpy.utils.unregister_class(ArmNavigationPanel)

18
blender/arm/props_virtualinput.py
View file

@ -1,18 +0,0 @@
import bpy
from bpy.types import Menu, Panel, UIList
from bpy.props import *
class ArmVirtualInputPropsPanel(bpy.types.Panel):
bl_label = "Armory Virtual Input"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "world"
def draw(self, context):
layout = self.layout
def register():
bpy.utils.register_class(ArmVirtualInputPropsPanel)
def unregister():
bpy.utils.unregister_class(ArmVirtualInputPropsPanel)

4
blender/arm/write_data.py
View file

@ -144,7 +144,7 @@ project.addSources('Sources');
f.write(add_assets(p.replace('\\', '/')))
assets.add_khafile_def('arm_ui')
if wrd.arm_hscript:
if wrd.arm_hscript == 'Enabled':
if os.path.exists('Libraries/hscript'):
f.write('project.addLibrary("hscript");\n')
else:
@ -290,7 +290,7 @@ const float PI = 3.1415926535;
const float PI2 = PI * 2.0;
const vec2 cameraPlane = vec2(""" + str(round(clip_start * 100) / 100) + """, """ + str(round(clip_end * 100) / 100) + """);
const vec2 shadowmapSize = vec2(""" + str(shadowmap_size) + """, """ + str(shadowmap_size) + """);
const float shadowmapCubePcfSize = """ + str(round(wrd.lamp_omni_shadows_cubemap_pcfsize * 10000) / 10000) + """;
const float shadowmapCubePcfSize = """ + str(round(wrd.lamp_omni_shadows_pcfsize * 10000) / 10000) + """;
""")
if wrd.generate_clouds:
f.write(

15
blender/start.py
View file

@ -1,16 +1,11 @@
import arm.nodes_logic
import arm.nodes_renderpath
import arm.make_renderer
import arm.props_traits_action
import arm.props_traits_clip
import arm.props_traits_library
import arm.props_traits_params
import arm.props_traits_props
import arm.props_traits
import arm.props_lod
import arm.props_navigation
import arm.props_globalvars
import arm.props_virtualinput
import arm.props
import arm.props_ui
import arm.props_renderer
@ -25,8 +20,6 @@ def register():
global registered
registered = True
arm.utils.register()
arm.props_traits_action.register()
arm.props_traits_clip.register()
arm.props_traits_library.register()
arm.props.register()
arm.props_ui.register()
@ -38,9 +31,6 @@ def register():
arm.props_traits_props.register()
arm.props_traits.register()
arm.props_lod.register()
arm.props_navigation.register()
arm.props_globalvars.register()
arm.props_virtualinput.register()
arm.space_armory.register()
arm.keymap.register()
arm.handlers.register()
@ -57,14 +47,9 @@ def unregister():
arm.props_traits_props.unregister()
arm.props_traits.unregister()
arm.props_lod.unregister()
arm.props_navigation.unregister()
arm.props_globalvars.unregister()
arm.props_virtualinput.unregister()
arm.handlers.unregister()
arm.props_renderer.unregister()
arm.props_ui.unregister()
arm.props.unregister()
arm.props_traits_action.unregister()
arm.props_traits_clip.unregister()
arm.props_traits_library.unregister()
arm.space_armory.unregister()