def parse_bsdfdiffuse(node: bpy.types.ShaderNodeBsdfDiffuse, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: c.write_normal(node.inputs[2]) state.out_basecol = c.parse_vector_input(node.inputs[0]) state.out_roughness = c.parse_value_input(node.inputs[1]) state.out_specular = '0.0'
def parse_bsdfglossy(node: bpy.types.ShaderNodeBsdfGlossy, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: c.write_normal(node.inputs[2]) state.out_basecol = c.parse_vector_input(node.inputs[0]) state.out_roughness = c.parse_value_input(node.inputs[1]) state.out_metallic = '1.0'
def parse_bsdfanisotropic(node: bpy.types.ShaderNodeBsdfAnisotropic, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: c.write_normal(node.inputs[4]) # Revert to glossy state.out_basecol = c.parse_vector_input(node.inputs[0]) state.out_roughness = c.parse_value_input(node.inputs[1]) state.out_metallic = '1.0'
def parse_bump(node: bpy.types.ShaderNodeBump, out_socket: bpy.types.NodeSocket, state: ParserState) -> vec3str: # Interpolation strength strength = c.parse_value_input(node.inputs[0]) # Height multiplier # distance = c.parse_value_input(node.inputs[1]) state.sample_bump = True height = c.parse_value_input(node.inputs[2]) state.sample_bump = False nor = c.parse_vector_input(node.inputs[3]) if state.sample_bump_res != '': if node.invert: ext = ('1', '2', '3', '4') else: ext = ('2', '1', '4', '3') state.curshader.write( 'float {0}_fh1 = {0}_{1} - {0}_{2}; float {0}_fh2 = {0}_{3} - {0}_{4};' .format(state.sample_bump_res, ext[0], ext[1], ext[2], ext[3])) state.curshader.write( '{0}_fh1 *= ({1}) * 3.0; {0}_fh2 *= ({1}) * 3.0;'.format( state.sample_bump_res, strength)) state.curshader.write( 'vec3 {0}_a = normalize(vec3(2.0, 0.0, {0}_fh1));'.format( state.sample_bump_res)) state.curshader.write( 'vec3 {0}_b = normalize(vec3(0.0, 2.0, {0}_fh2));'.format( state.sample_bump_res)) res = 'normalize(mat3({0}_a, {0}_b, normalize(vec3({0}_fh1, {0}_fh2, 2.0))) * n)'.format( state.sample_bump_res) state.sample_bump_res = '' else: res = 'n' return res
def parse_bsdfglass(node: bpy.types.ShaderNodeBsdfGlass, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: c.write_normal(node.inputs[3]) state.out_roughness = c.parse_value_input(node.inputs[1]) if state.parse_opacity: state.out_opacity = '(1.0 - {0}.r)'.format( c.parse_vector_input(node.inputs[0]))
def parse_emission(node: bpy.types.ShaderNodeEmission, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: # Multiply basecol state.out_basecol = c.parse_vector_input(node.inputs[0]) state.out_emission = '1.0' state.emission_found = True emission_strength = c.parse_value_input(node.inputs[1]) state.out_basecol = '({0} * {1})'.format(state.out_basecol, emission_strength)
def parse_bsdftranslucent(node: bpy.types.ShaderNodeBsdfTranslucent, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: c.write_normal(node.inputs[1]) if state.parse_opacity: state.out_opacity = '(1.0 - {0}.r)'.format( c.parse_vector_input(node.inputs[0]))
def parse_sky_hosekwilkie(node: bpy.types.ShaderNodeTexSky, state: ParserState) -> vec3str: world = state.world curshader = state.curshader # Match to cycles world.arm_envtex_strength *= 0.1 assets.add_khafile_def('arm_hosek') curshader.add_uniform('vec3 A', link="_hosekA") curshader.add_uniform('vec3 B', link="_hosekB") curshader.add_uniform('vec3 C', link="_hosekC") curshader.add_uniform('vec3 D', link="_hosekD") curshader.add_uniform('vec3 E', link="_hosekE") curshader.add_uniform('vec3 F', link="_hosekF") curshader.add_uniform('vec3 G', link="_hosekG") curshader.add_uniform('vec3 H', link="_hosekH") curshader.add_uniform('vec3 I', link="_hosekI") curshader.add_uniform('vec3 Z', link="_hosekZ") curshader.add_uniform('vec3 hosekSunDirection', link="_hosekSunDirection") curshader.add_function("""vec3 hosekWilkie(float cos_theta, float gamma, float cos_gamma) { \tvec3 chi = (1 + cos_gamma * cos_gamma) / pow(1 + H * H - 2 * cos_gamma * H, vec3(1.5)); \treturn (1 + A * exp(B / (cos_theta + 0.01))) * (C + D * exp(E * gamma) + F * (cos_gamma * cos_gamma) + G * chi + I * sqrt(cos_theta)); }""") world.arm_envtex_sun_direction = [node.sun_direction[0], node.sun_direction[1], node.sun_direction[2]] world.arm_envtex_turbidity = node.turbidity world.arm_envtex_ground_albedo = node.ground_albedo wrd = bpy.data.worlds['Arm'] rpdat = arm.utils.get_rp() mobile_mat = rpdat.arm_material_model == 'Mobile' or rpdat.arm_material_model == 'Solid' if not state.radiance_written: # Irradiance json file name wname = arm.utils.safestr(world.name) world.arm_envtex_irr_name = wname write_probes.write_sky_irradiance(wname) # Radiance if rpdat.arm_radiance and rpdat.arm_irradiance and not mobile_mat: wrd.world_defs += '_Rad' hosek_path = 'armory/Assets/hosek/' sdk_path = arm.utils.get_sdk_path() # Use fake maps for now assets.add(sdk_path + '/' + hosek_path + 'hosek_radiance.hdr') for i in range(0, 8): assets.add(sdk_path + '/' + hosek_path + 'hosek_radiance_' + str(i) + '.hdr') world.arm_envtex_name = 'hosek' world.arm_envtex_num_mips = 8 state.radiance_written = True curshader.write('float cos_theta = clamp(pos.z, 0.0, 1.0);') curshader.write('float cos_gamma = dot(pos, hosekSunDirection);') curshader.write('float gamma_val = acos(cos_gamma);') return 'Z * hosekWilkie(cos_theta, gamma_val, cos_gamma) * envmapStrength;'
def parse_bsdfprincipled(node: bpy.types.ShaderNodeBsdfPrincipled, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: c.write_normal(node.inputs[20]) state.out_basecol = c.parse_vector_input(node.inputs[0]) # subsurface = c.parse_vector_input(node.inputs[1]) # subsurface_radius = c.parse_vector_input(node.inputs[2]) # subsurface_color = c.parse_vector_input(node.inputs[3]) state.out_metallic = c.parse_value_input(node.inputs[4]) state.out_specular = c.parse_value_input(node.inputs[5]) # specular_tint = c.parse_vector_input(node.inputs[6]) state.out_roughness = c.parse_value_input(node.inputs[7]) # aniso = c.parse_vector_input(node.inputs[8]) # aniso_rot = c.parse_vector_input(node.inputs[9]) # sheen = c.parse_vector_input(node.inputs[10]) # sheen_tint = c.parse_vector_input(node.inputs[11]) # clearcoat = c.parse_vector_input(node.inputs[12]) # clearcoat_rough = c.parse_vector_input(node.inputs[13]) # ior = c.parse_vector_input(node.inputs[14]) # transmission = c.parse_vector_input(node.inputs[15]) # transmission_roughness = c.parse_vector_input(node.inputs[16]) if node.inputs[17].is_linked or node.inputs[17].default_value[0] != 0.0: state.out_emission = '({0}.x)'.format(c.parse_vector_input(node.inputs[17])) state.emission_found = True # clearcoar_normal = c.parse_vector_input(node.inputs[21]) # tangent = c.parse_vector_input(node.inputs[22]) if state.parse_opacity: if len(node.inputs) > 21: state.out_opacity = c.parse_value_input(node.inputs[19])
def parse_mixshader(node: bpy.types.ShaderNodeMixShader, out_socket: NodeSocket, state: ParserState) -> None: prefix = '' if node.inputs[0].is_linked else 'const ' fac = c.parse_value_input(node.inputs[0]) fac_var = c.node_name(node.name) + '_fac' fac_inv_var = c.node_name(node.name) + '_fac_inv' state.curshader.write('{0}float {1} = {2};'.format(prefix, fac_var, fac)) state.curshader.write('{0}float {1} = 1.0 - {2};'.format( prefix, fac_inv_var, fac_var)) bc1, rough1, met1, occ1, spec1, opac1, emi1 = c.parse_shader_input( node.inputs[1]) bc2, rough2, met2, occ2, spec2, opac2, emi2 = c.parse_shader_input( node.inputs[2]) if state.parse_surface: state.out_basecol = '({0} * {3} + {1} * {2})'.format( bc1, bc2, fac_var, fac_inv_var) state.out_roughness = '({0} * {3} + {1} * {2})'.format( rough1, rough2, fac_var, fac_inv_var) state.out_metallic = '({0} * {3} + {1} * {2})'.format( met1, met2, fac_var, fac_inv_var) state.out_occlusion = '({0} * {3} + {1} * {2})'.format( occ1, occ2, fac_var, fac_inv_var) state.out_specular = '({0} * {3} + {1} * {2})'.format( spec1, spec2, fac_var, fac_inv_var) state.out_emission = '({0} * {3} + {1} * {2})'.format( emi1, emi2, fac_var, fac_inv_var) if state.parse_opacity: state.out_opacity = '({0} * {3} + {1} * {2})'.format( opac1, opac2, fac_var, fac_inv_var)
def parse_addshader(node: bpy.types.ShaderNodeAddShader, out_socket: NodeSocket, state: ParserState) -> None: bc1, rough1, met1, occ1, spec1, opac1, emi1 = c.parse_shader_input(node.inputs[0]) bc2, rough2, met2, occ2, spec2, opac2, emi2 = c.parse_shader_input(node.inputs[1]) if state.parse_surface: state.out_basecol = '({0} + {1})'.format(bc1, bc2) state.out_roughness = '({0} * 0.5 + {1} * 0.5)'.format(rough1, rough2) state.out_metallic = '({0} * 0.5 + {1} * 0.5)'.format(met1, met2) state.out_occlusion = '({0} * 0.5 + {1} * 0.5)'.format(occ1, occ2) state.out_specular = '({0} * 0.5 + {1} * 0.5)'.format(spec1, spec2) state.out_emission = '({0} * 0.5 + {1} * 0.5)'.format(emi1, emi2) if state.parse_opacity: state.out_opacity = '({0} * 0.5 + {1} * 0.5)'.format(opac1, opac2)
def parse_holdout(node: bpy.types.ShaderNodeHoldout, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: # Occlude state.out_occlusion = '0.0'
def build_node_tree(world: bpy.types.World, frag: Shader, vert: Shader, con: ShaderContext): """Generates the shader code for the given world.""" world_name = arm.utils.safestr(world.name) world.world_defs = '' rpdat = arm.utils.get_rp() wrd = bpy.data.worlds['Arm'] if callback is not None: callback() # film_transparent, do not render if bpy.context.scene is not None and bpy.context.scene.render.film_transparent: world.world_defs += '_EnvCol' frag.add_uniform('vec3 backgroundCol', link='_backgroundCol') frag.write('fragColor.rgb = backgroundCol;') return parser_state = ParserState(ParserContext.WORLD, world) parser_state.con = con parser_state.curshader = frag parser_state.frag = frag parser_state.vert = vert cycles.state = parser_state # Traverse world node tree is_parsed = False if world.node_tree is not None: output_node = node_utils.get_node_by_type(world.node_tree, 'OUTPUT_WORLD') if output_node is not None: is_parsed = parse_world_output(world, output_node, frag) # No world nodes/no output node, use background color if not is_parsed: solid_mat = rpdat.arm_material_model == 'Solid' if rpdat.arm_irradiance and not solid_mat: world.world_defs += '_Irr' col = world.color world.arm_envtex_color = [col[0], col[1], col[2], 1.0] world.arm_envtex_strength = 1.0 world.world_defs += '_EnvCol' # Clouds enabled if rpdat.arm_clouds and world.arm_use_clouds: world.world_defs += '_EnvClouds' # Also set this flag globally so that the required textures are # included wrd.world_defs += '_EnvClouds' frag_write_clouds(world, frag) if '_EnvSky' in world.world_defs or '_EnvTex' in world.world_defs or '_EnvImg' in world.world_defs or '_EnvClouds' in world.world_defs: frag.add_uniform('float envmapStrength', link='_envmapStrength') # Clear background color if '_EnvCol' in world.world_defs: frag.write('fragColor.rgb = backgroundCol;') elif '_EnvTex' in world.world_defs and '_EnvLDR' in world.world_defs: frag.write('fragColor.rgb = pow(fragColor.rgb, vec3(2.2));') if '_EnvClouds' in world.world_defs: frag.write( 'if (pos.z > 0.0) fragColor.rgb = mix(fragColor.rgb, traceClouds(fragColor.rgb, pos), clamp(pos.z * 5.0, 0, 1));' ) if '_EnvLDR' in world.world_defs: frag.write('fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / 2.2));') # Mark as non-opaque frag.write('fragColor.a = 0.0;') finalize(frag, vert)
def parse_tex_environment(node: bpy.types.ShaderNodeTexEnvironment, out_socket: bpy.types.NodeSocket, state: ParserState) -> vec3str: if state.context == ParserContext.OBJECT: log.warn('Environment Texture node is not supported for object node trees, using default value') return c.to_vec3([0.0, 0.0, 0.0]) if node.image is None: return c.to_vec3([1.0, 0.0, 1.0]) world = state.world world.world_defs += '_EnvTex' curshader = state.curshader curshader.add_include('std/math.glsl') curshader.add_uniform('sampler2D envmap', link='_envmap') image = node.image filepath = image.filepath if image.packed_file is None and not os.path.isfile(arm.utils.asset_path(filepath)): log.warn(world.name + ' - unable to open ' + image.filepath) return c.to_vec3([1.0, 0.0, 1.0]) # Reference image name tex_file = arm.utils.extract_filename(image.filepath) base = tex_file.rsplit('.', 1) ext = base[1].lower() if ext == 'hdr': target_format = 'HDR' else: target_format = 'JPEG' do_convert = ext != 'hdr' and ext != 'jpg' if do_convert: if ext == 'exr': tex_file = base[0] + '.hdr' target_format = 'HDR' else: tex_file = base[0] + '.jpg' target_format = 'JPEG' if image.packed_file is not None: # Extract packed data unpack_path = arm.utils.get_fp_build() + '/compiled/Assets/unpacked' if not os.path.exists(unpack_path): os.makedirs(unpack_path) unpack_filepath = unpack_path + '/' + tex_file filepath = unpack_filepath if do_convert: if not os.path.isfile(unpack_filepath): arm.utils.unpack_image(image, unpack_filepath, file_format=target_format) elif not os.path.isfile(unpack_filepath) or os.path.getsize(unpack_filepath) != image.packed_file.size: with open(unpack_filepath, 'wb') as f: f.write(image.packed_file.data) assets.add(unpack_filepath) else: if do_convert: unpack_path = arm.utils.get_fp_build() + '/compiled/Assets/unpacked' if not os.path.exists(unpack_path): os.makedirs(unpack_path) converted_path = unpack_path + '/' + tex_file filepath = converted_path # TODO: delete cache when file changes if not os.path.isfile(converted_path): arm.utils.convert_image(image, converted_path, file_format=target_format) assets.add(converted_path) else: # Link image path to assets assets.add(arm.utils.asset_path(image.filepath)) rpdat = arm.utils.get_rp() if not state.radiance_written: # Generate prefiltered envmaps world.arm_envtex_name = tex_file world.arm_envtex_irr_name = tex_file.rsplit('.', 1)[0] disable_hdr = target_format == 'JPEG' from_srgb = image.colorspace_settings.name == "sRGB" mip_count = world.arm_envtex_num_mips mip_count = write_probes.write_probes(filepath, disable_hdr, from_srgb, mip_count, arm_radiance=rpdat.arm_radiance) world.arm_envtex_num_mips = mip_count state.radiance_written = True # Append LDR define if disable_hdr: world.world_defs += '_EnvLDR' wrd = bpy.data.worlds['Arm'] mobile_mat = rpdat.arm_material_model == 'Mobile' or rpdat.arm_material_model == 'Solid' # Append radiance define if rpdat.arm_irradiance and rpdat.arm_radiance and not mobile_mat: wrd.world_defs += '_Rad' return 'texture(envmap, envMapEquirect(pos)).rgb * envmapStrength'
def parse_ambientocclusion(node: bpy.types.ShaderNodeAmbientOcclusion, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: # Single channel state.out_occlusion = c.parse_vector_input(node.inputs[0]) + '.r'
def parse_subsurfacescattering(node: bpy.types.ShaderNodeSubsurfaceScattering, out_socket: NodeSocket, state: ParserState) -> None: if state.parse_surface: c.write_normal(node.inputs[4]) state.out_basecol = c.parse_vector_input(node.inputs[0])
def build_node_tree(world: bpy.types.World, frag: Shader, vert: Shader, con: ShaderContext): """Generates the shader code for the given world.""" world_name = arm.utils.safestr(world.name) world.world_defs = '' rpdat = arm.utils.get_rp() wrd = bpy.data.worlds['Arm'] if callback is not None: callback() # film_transparent, do not render if bpy.context.scene is not None and bpy.context.scene.render.film_transparent: world.world_defs += '_EnvCol' frag.add_uniform('vec3 backgroundCol', link='_backgroundCol') frag.write('fragColor.rgb = backgroundCol;') return parser_state = ParserState(ParserContext.WORLD, world) parser_state.con = con parser_state.curshader = frag parser_state.frag = frag parser_state.vert = vert cycles.state = parser_state # Traverse world node tree is_parsed = False if world.node_tree is not None: output_node = node_utils.get_node_by_type(world.node_tree, 'OUTPUT_WORLD') if output_node is not None: is_parsed = parse_world_output(world, output_node, frag) # No world nodes/no output node, use background color if not is_parsed: solid_mat = rpdat.arm_material_model == 'Solid' if rpdat.arm_irradiance and not solid_mat: world.world_defs += '_Irr' col = world.color world.arm_envtex_color = [col[0], col[1], col[2], 1.0] world.arm_envtex_strength = 1.0 # Irradiance/Radiance: clear to color if no texture or sky is provided if rpdat.arm_irradiance or rpdat.arm_irradiance: if '_EnvSky' not in world.world_defs and '_EnvTex' not in world.world_defs and '_EnvImg' not in world.world_defs: # Irradiance json file name world.arm_envtex_name = world_name world.arm_envtex_irr_name = world_name write_probes.write_color_irradiance(world_name, world.arm_envtex_color) # Clouds enabled if rpdat.arm_clouds and world.arm_use_clouds: world.world_defs += '_EnvClouds' # Also set this flag globally so that the required textures are # included wrd.world_defs += '_EnvClouds' frag_write_clouds(world, frag) if '_EnvSky' in world.world_defs or '_EnvTex' in world.world_defs or '_EnvImg' in world.world_defs or '_EnvClouds' in world.world_defs: frag.add_uniform('float envmapStrength', link='_envmapStrength') # Clear background color if '_EnvCol' in world.world_defs: frag.write('fragColor.rgb = backgroundCol;') elif '_EnvTex' in world.world_defs and '_EnvLDR' in world.world_defs: frag.write('fragColor.rgb = pow(fragColor.rgb, vec3(2.2));') if '_EnvClouds' in world.world_defs: frag.write( 'if (n.z > 0.0) fragColor.rgb = mix(fragColor.rgb, traceClouds(fragColor.rgb, n), clamp(n.z * 5.0, 0, 1));' ) if '_EnvLDR' in world.world_defs: frag.write('fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / 2.2));') # Mark as non-opaque frag.write('fragColor.a = 0.0;') # Hack to make procedural textures work frag_bpos = ( frag.contains('bposition') and not frag.contains('vec3 bposition')) or vert.contains('bposition') if frag_bpos: frag.add_in('vec3 bposition') vert.add_out('vec3 bposition') # Use normals for now vert.write('bposition = nor;') frag_mpos = ( frag.contains('mposition') and not frag.contains('vec3 mposition')) or vert.contains('mposition') if frag_mpos: frag.add_in('vec3 mposition') vert.add_out('vec3 mposition') # Use normals for now vert.write('mposition = nor;') if frag.contains('texCoord') and not frag.contains('vec2 texCoord'): frag.add_in('vec2 texCoord') vert.add_out('vec2 texCoord') # World has no UV map vert.write('texCoord = vec2(1.0, 1.0);')
def parse(nodes, con: ShaderContext, vert: Shader, frag: Shader, geom: Shader, tesc: Shader, tese: Shader, parse_surface=True, parse_opacity=True, parse_displacement=True, basecol_only=False): global state state = ParserState(ParserContext.OBJECT) state.parse_surface = parse_surface state.parse_opacity = parse_opacity state.parse_displacement = parse_displacement state.basecol_only = basecol_only state.con = con state.vert = vert state.frag = frag state.geom = geom state.tesc = tesc state.tese = tese output_node = node_by_type(nodes, 'OUTPUT_MATERIAL') if output_node is not None: custom_particle_node = node_by_name(nodes, 'ArmCustomParticleNode') parse_material_output(output_node, custom_particle_node) # Make sure that individual functions in this module aren't called with an incorrect/old parser state, set it to # None so that it will raise exceptions when not set state = None