# # This module builds upon Cycles nodes work licensed as # Copyright 2011-2013 Blender Foundation # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import os import shutil from typing import Any, Dict, Optional, Tuple import bpy import lnx.assets import lnx.log as log import lnx.make_state import lnx.material.cycles_functions as c_functions import lnx.material.node_meta as node_meta import lnx.material.mat_state as mat_state from lnx.material.parser_state import ParserState, ParserContext, ParserPass from lnx.material.shader import Shader, ShaderContext, floatstr, vec3str import lnx.node_utils import lnx.utils if lnx.is_reload(__name__): lnx.assets = lnx.reload_module(lnx.assets) log = lnx.reload_module(log) lnx.make_state = lnx.reload_module(lnx.make_state) c_functions = lnx.reload_module(c_functions) lnx.material.cycles_nodes = lnx.reload_module(lnx.material.cycles_nodes) node_meta = lnx.reload_module(node_meta) from lnx.material.cycles_nodes import * mat_state = lnx.reload_module(mat_state) lnx.material.parser_state = lnx.reload_module(lnx.material.parser_state) from lnx.material.parser_state import ParserState, ParserContext, ParserPass lnx.material.shader = lnx.reload_module(lnx.material.shader) from lnx.material.shader import Shader, ShaderContext, floatstr, vec3str lnx.node_utils = lnx.reload_module(lnx.node_utils) lnx.utils = lnx.reload_module(lnx.utils) else: lnx.enable_reload(__name__) # Particle info export particle_info: Dict[str, bool] = {} state: Optional[ParserState] 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, mat_state.material.name) 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, 'LnxCustomParticleNode') 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 def parse_material_output(node: bpy.types.Node, custom_particle_node: bpy.types.Node): global particle_info parse_surface = state.parse_surface parse_opacity = state.parse_opacity parse_displacement = state.parse_displacement particle_info = { 'index': False, 'age': False, 'lifetime': False, 'location': False, 'size': False, 'velocity': False, 'angular_velocity': False } wrd = bpy.data.worlds['Lnx'] mat_state.emission_type = mat_state.EmissionType.NO_EMISSION # Surface if parse_surface or parse_opacity: state.parents = [] state.parsed = set() state.normal_parsed = False curshader = state.frag state.curshader = curshader out_basecol, out_roughness, out_metallic, out_occlusion, out_specular, out_opacity, out_ior, out_emission_col = parse_shader_input(node.inputs[0]) if parse_surface: curshader.write(f'basecol = {out_basecol};') curshader.write(f'roughness = {out_roughness};') curshader.write(f'metallic = {out_metallic};') curshader.write(f'occlusion = {out_occlusion};') curshader.write(f'specular = {out_specular};') curshader.write(f'emissionCol = {out_emission_col};') if mat_state.emission_type == mat_state.EmissionType.SHADELESS: if '_EmissionShadeless' not in wrd.world_defs: wrd.world_defs += '_EmissionShadeless' elif mat_state.emission_type == mat_state.EmissionType.SHADED: if '_EmissionShaded' not in wrd.world_defs: wrd.world_defs += '_EmissionShaded' lnx.assets.add_khafile_def('rp_gbuffer_emission') if parse_opacity: curshader.write('opacity = {0};'.format(out_opacity)) curshader.write('ior = {0};'.format(out_ior)) # Volume # parse_volume_input(node.inputs[1]) # Displacement if parse_displacement and disp_enabled() and node.inputs[2].is_linked: state.parents = [] state.parsed = set() state.normal_parsed = False rpdat = lnx.utils.get_rp() if rpdat.lnx_rp_displacement == 'Tessellation' and state.tese is not None: state.curshader = state.tese else: state.curshader = state.vert out_disp = parse_displacement_input(node.inputs[2]) state.curshader.write('vec3 disp = {0};'.format(out_disp)) if custom_particle_node is not None: if not (parse_displacement and disp_enabled() and node.inputs[2].is_linked): state.parents = [] state.parsed = set() state.normal_parsed = False state.curshader = state.vert custom_particle_node.parse(state.curshader, state.con) def parse_group(node, socket): # Entering group index = socket_index(node, socket) output_node = node_by_type(node.node_tree.nodes, 'GROUP_OUTPUT') if output_node is None: return inp = output_node.inputs[index] state.parents.append(node) out_group = parse_input(inp) state.parents.pop() return out_group def parse_group_input(node: bpy.types.Node, socket: bpy.types.NodeSocket): index = socket_index(node, socket) parent = state.parents.pop() # Leaving group inp = parent.inputs[index] res = parse_input(inp) state.parents.append(parent) # Return to group return res def parse_input(inp: bpy.types.NodeSocket): if inp.type == 'SHADER': return parse_shader_input(inp) elif inp.type in ('RGB', 'RGBA', 'VECTOR'): return parse_vector_input(inp) elif inp.type == 'VALUE': return parse_value_input(inp) def parse_shader_input(inp: bpy.types.NodeSocket) -> Tuple[str, ...]: # Follow input if inp.is_linked: link = inp.links[0] if link.from_node.type == 'REROUTE': return parse_shader_input(link.from_node.inputs[0]) if link.from_socket.type != 'SHADER': log.warn(f'Node tree "{tree_name()}": socket "{link.from_socket.name}" of node "{link.from_node.name}" cannot be connected to a shader socket') state.reset_outs() return state.get_outs() return parse_shader(link.from_node, link.from_socket) else: # Return default shader values state.reset_outs() return state.get_outs() def parse_shader(node: bpy.types.Node, socket: bpy.types.NodeSocket) -> Tuple[str, ...]: supported_node_types = ( 'MIX_SHADER', 'ADD_SHADER', 'BSDF_PRINCIPLED', 'BSDF_DIFFUSE', 'BSDF_GLOSSY', 'BSDF_SHEEN', 'AMBIENT_OCCLUSION', 'BSDF_ANISOTROPIC', 'EMISSION', 'BSDF_GLASS', 'HOLDOUT', 'SUBSURFACE_SCATTERING', 'BSDF_TRANSLUCENT', 'BSDF_TRANSPARENT', 'BSDF_VELVET', ) state.reset_outs() if node.type in supported_node_types: node_meta.get_node_meta(node).parse_func(node, socket, state) elif node.type == 'GROUP': if node.node_tree.name.startswith('Leenkx PBR'): if state.parse_surface: # Normal if node.inputs[5].is_linked and node.inputs[5].links[0].from_node.type == 'NORMAL_MAP': log.warn(tree_name() + ' - Do not use Normal Map node with Leenkx PBR, connect Image Texture directly') parse_normal_map_color_input(node.inputs[5]) emission_factor = f'clamp({parse_value_input(node.inputs[6])}, 0.0, 1.0)' basecol = parse_vector_input(node.inputs[0]) # Multiply base color with inverse of emission factor to # copy behaviour of the Mix Shader node used in the group # (less base color -> less shading influence) state.out_basecol = f'({basecol} * (1 - {emission_factor}))' state.out_occlusion = parse_value_input(node.inputs[2]) state.out_roughness = parse_value_input(node.inputs[3]) state.out_metallic = parse_value_input(node.inputs[4]) # Emission if node.inputs[6].is_linked or node.inputs[6].default_value != 0.0: state.out_emission_col = f'({basecol} * {emission_factor})' mat_state.emission_type = mat_state.EmissionType.SHADED if state.parse_opacity: state.out_opacity = parse_value_input(node.inputs[1]) state.out_ior = 1.450; else: return parse_group(node, socket) elif node.type == 'GROUP_INPUT': return parse_group_input(node, socket) elif node.type == 'CUSTOM': if node.bl_idname == 'LnxShaderDataNode': return node_meta.get_node_meta(node).parse_func(node, socket, state) else: log.warn(f'Node tree "{tree_name()}": material node type {node.type} not supported') return state.get_outs() def parse_displacement_input(inp): if inp.is_linked: l = inp.links[0] if l.from_node.type == 'REROUTE': return parse_displacement_input(l.from_node.inputs[0]) return parse_vector_input(inp) else: return None def parse_vector_input(inp: bpy.types.NodeSocket) -> vec3str: """Return the parsed result of the given input socket.""" # Follow input if inp.is_linked: link = inp.links[0] if link.from_node.type == 'REROUTE': return parse_vector_input(link.from_node.inputs[0]) res_var = write_result(link) st = link.from_socket.type if st in ('RGB', 'RGBA', 'VECTOR'): return res_var elif st in ('VALUE', 'INT'): return f'vec3({res_var})' else: log.warn(f'Node tree "{tree_name()}": socket "{link.from_socket.name}" of node "{link.from_node.name}" cannot be connected to a vector-like socket') return to_vec3([0.0, 0.0, 0.0]) # Unlinked reroute elif inp.type == 'VALUE': return to_vec3([0.0, 0.0, 0.0]) # Use direct socket value else: if mat_batch() and inp.is_uniform: return to_uniform(inp) else: return to_vec3(inp.default_value) def parse_vector(node: bpy.types.Node, socket: bpy.types.NodeSocket) -> str: """Parses the vector/color output value from the given node and socket.""" supported_node_types = ( 'ATTRIBUTE', # RGB outputs 'RGB', 'TEX_BRICK', 'TEX_CHECKER', 'TEX_ENVIRONMENT', 'TEX_GRADIENT', 'TEX_IMAGE', 'TEX_MAGIC', 'TEX_MUSGRAVE', 'TEX_NOISE', 'TEX_POINTDENSITY', 'TEX_SKY', 'TEX_VORONOI', 'TEX_WAVE', 'VERTEX_COLOR', 'BRIGHTCONTRAST', 'GAMMA', 'HUE_SAT', 'INVERT', 'MIX', 'BLACKBODY', 'VALTORGB', 'CURVE_VEC', 'CURVE_RGB', 'COMBINE_COLOR', 'COMBHSV', 'COMBRGB', 'WAVELENGTH', # Vector outputs 'CAMERA', 'NEW_GEOMETRY', 'HAIR_INFO', 'OBJECT_INFO', 'PARTICLE_INFO', 'TANGENT', 'TEX_COORD', 'UVMAP', 'BUMP', 'MAPPING', 'NORMAL', 'NORMAL_MAP', 'VECT_TRANSFORM', 'COMBXYZ', 'VECT_MATH', 'DISPLACEMENT', 'VECTOR_ROTATE', ) if node.type in supported_node_types: return node_meta.get_node_meta(node).parse_func(node, socket, state) elif node.type == 'GROUP': return parse_group(node, socket) elif node.type == 'GROUP_INPUT': return parse_group_input(node, socket) elif node.type == 'CUSTOM': if node.bl_idname == 'LnxShaderDataNode': return node_meta.get_node_meta(node).parse_func(node, socket, state) log.warn(f'Node tree "{tree_name()}": material node type {node.type} not supported') return "vec3(0, 0, 0)" def parse_normal_map_color_input(inp, strength_input=None): frag = state.frag if state.basecol_only or not inp.is_linked or state.normal_parsed: return state.normal_parsed = True frag.write_normal += 1 if not get_lnx_export_tangents() or mat_get_material().lnx_decal: # Compute TBN matrix frag.write('vec3 texn = ({0}) * 2.0 - 1.0;'.format(parse_vector_input(inp))) frag.write('texn.y = -texn.y;') frag.add_include('std/normals.glsl') frag.write('mat3 TBN = cotangentFrame(n, -vVec, texCoord);') frag.write('n = TBN * normalize(texn);') else: frag.write('n = ({0}) * 2.0 - 1.0;'.format(parse_vector_input(inp))) if strength_input is not None: strength = parse_value_input(strength_input) if strength != '1.0': frag.write('n.xy *= {0};'.format(strength)) frag.write('n = normalize(TBN * n);') state.con.add_elem('tang', 'short4norm') frag.write_normal -= 1 def parse_value_input(inp: bpy.types.NodeSocket) -> floatstr: # Follow input if inp.is_linked: link = inp.links[0] if link.from_node.type == 'REROUTE': return parse_value_input(link.from_node.inputs[0]) res_var = write_result(link) socket_type = link.from_socket.type if socket_type in ('RGB', 'RGBA', 'VECTOR'): # RGB to BW return rgb_to_bw(res_var) elif socket_type in ('VALUE', 'INT'): return res_var else: log.warn(f'Node tree "{tree_name()}": socket "{link.from_socket.name}" of node "{link.from_node.name}" cannot be connected to a scalar value socket') return '0.0' # Use value from socket else: if mat_batch() and inp.is_uniform: return to_uniform(inp) else: return to_vec1(inp.default_value) def parse_value(node, socket): supported_node_types = ( 'ATTRIBUTE', 'CAMERA', 'FRESNEL', 'NEW_GEOMETRY', 'HAIR_INFO', 'LAYER_WEIGHT', 'LIGHT_PATH', 'OBJECT_INFO', 'PARTICLE_INFO', 'VALUE', 'WIREFRAME', 'TEX_BRICK', 'TEX_CHECKER', 'TEX_GRADIENT', 'TEX_IMAGE', 'TEX_MAGIC', 'TEX_MUSGRAVE', 'TEX_NOISE', 'TEX_POINTDENSITY', 'TEX_VORONOI', 'TEX_WAVE', 'LIGHT_FALLOFF', 'NORMAL', 'CLAMP', 'VALTORGB', 'MATH', 'MIX', 'RGBTOBW', 'SEPARATE_COLOR', 'SEPHSV', 'SEPRGB', 'SEPXYZ', 'VECT_MATH', 'MAP_RANGE', ) if node.type in supported_node_types: return node_meta.get_node_meta(node).parse_func(node, socket, state) elif node.type == 'GROUP': if node.node_tree.name.startswith('Leenkx PBR'): # Displacement if socket == node.outputs[1]: return parse_value_input(node.inputs[7]) else: return None else: return parse_group(node, socket) elif node.type == 'GROUP_INPUT': return parse_group_input(node, socket) elif node.type == 'CUSTOM': if node.bl_idname == 'LnxShaderDataNode': return node_meta.get_node_meta(node).parse_func(node, socket, state) log.warn(f'Node tree "{tree_name()}": material node type {node.type} not supported') return '0.0' def vector_curve(name, fac, points): curshader = state.curshader # Write Ys array ys_var = name + '_ys' + state.get_parser_pass_suffix() curshader.write('float {0}[{1}];'.format(ys_var, len(points))) # TODO: Make const for i in range(0, len(points)): curshader.write('{0}[{1}] = {2};'.format(ys_var, i, points[i].location[1])) # Get index fac_var = name + '_fac' + state.get_parser_pass_suffix() curshader.write('float {0} = {1};'.format(fac_var, fac)) index = '0' for i in range(1, len(points)): index += ' + ({0} > {1} ? 1 : 0)'.format(fac_var, points[i].location[0]) # Write index index_var = name + '_i' + state.get_parser_pass_suffix() curshader.write('int {0} = {1};'.format(index_var, index)) # Linear # Write Xs array facs_var = name + '_xs' + state.get_parser_pass_suffix() curshader.write('float {0}[{1}];'.format(facs_var, len(points))) # TODO: Make const for i in range(0, len(points)): curshader.write('{0}[{1}] = {2};'.format(facs_var, i, points[i].location[0])) # Map vector return 'mix({0}[{1}], {0}[{1} + 1], ({2} - {3}[{1}]) * (1.0 / ({3}[{1} + 1] - {3}[{1}]) ))'.format(ys_var, index_var, fac_var, facs_var) def write_normal(inp): if inp.is_linked and inp.links[0].from_node.type != 'GROUP_INPUT': normal_res = parse_vector_input(inp) if normal_res != None: state.curshader.write('n = {0};'.format(normal_res)) def is_parsed(node_store_name: str): return node_store_name in state.parsed def res_var_name(node: bpy.types.Node, socket: bpy.types.NodeSocket) -> str: """Return the name of the variable that stores the parsed result from the given node and socket.""" name = node_name(node.name) + '_' + safesrc(socket.name) + '_res' if '__' in name: # Consecutive _ are reserved name = name.replace('_', '_x') return name def write_result(link: bpy.types.NodeLink) -> Optional[str]: """Write the parsed result of the given node link to the shader.""" res_var = res_var_name(link.from_node, link.from_socket) need_dxdy_offset = node_need_reevaluation_for_screenspace_derivative(link.from_node) if need_dxdy_offset: res_var += state.get_parser_pass_suffix() # Unparsed node if not is_parsed(res_var): state.parsed.add(res_var) st = link.from_socket.type if st in ('RGB', 'RGBA', 'VECTOR'): res = parse_vector(link.from_node, link.from_socket) if res is None: log.error(f'{link.from_node.name} returned `None` while parsing!') return None state.curshader.write(f'vec3 {res_var} = {res};') elif st == 'VALUE': res = parse_value(link.from_node, link.from_socket) if res is None: log.error(f'{link.from_node.name} returned `None` while parsing!') return None if link.from_node.type == "VALUE" and not link.from_node.lnx_material_param: state.curshader.add_const('float', res_var, res) else: state.curshader.write(f'float {res_var} = {res};') if state.dxdy_varying_input_value: state.curshader.write(f'{res_var} = {apply_screenspace_derivative_offset_if_required(res_var)};') state.dxdy_varying_input_value = False # Normal map already parsed, return elif link.from_node.type == 'NORMAL_MAP': return None return res_var def write_procedurals(): if state.curshader not in state.procedurals_written: state.curshader.add_function(c_functions.str_tex_proc) state.procedurals_written.add(state.curshader) def glsl_type(socket_type: str): """Socket to glsl type.""" if socket_type in ('RGB', 'RGBA', 'VECTOR'): return 'vec3' else: return 'float' def to_uniform(inp: bpy.types.NodeSocket): uname = safesrc(inp.node.name) + safesrc(inp.name) state.curshader.add_uniform(glsl_type(inp.type) + ' ' + uname) return uname def store_var_name(node: bpy.types.Node) -> str: name = node_name(node.name) if name[-1] == "_": return name + '_x_store' # Prevent consecutive __ return name + '_store' def texture_store(node, tex, tex_name, to_linear=False, tex_link=None, default_value=None, is_lnx_mat_param=None): curshader = state.curshader tex_store = store_var_name(node) if node_need_reevaluation_for_screenspace_derivative(node): tex_store += state.get_parser_pass_suffix() if is_parsed(tex_store): return tex_store state.parsed.add(tex_store) if is_lnx_mat_param is None: mat_bind_texture(tex) state.con.add_elem('tex', 'short2norm') curshader.add_uniform('sampler2D {0}'.format(tex_name), link=tex_link, default_value=default_value, is_lnx_mat_param=is_lnx_mat_param) triplanar = node.projection == 'BOX' if node.inputs[0].is_linked: uv_name = parse_vector_input(node.inputs[0]) if triplanar: uv_name = 'vec3({0}.x, 1.0 - {0}.y, {0}.z)'.format(uv_name) else: uv_name = 'vec2({0}.x, 1.0 - {0}.y)'.format(uv_name) else: uv_name = 'vec3(texCoord.xy, 0.0)' if triplanar else 'texCoord' if triplanar: if not curshader.has_include('std/mapping.glsl'): curshader.add_include('std/mapping.glsl') if state.normal_parsed: nor = 'TBN[2]' else: nor = 'n' curshader.write('vec4 {0} = vec4(triplanarMapping({1}, {2}, {3}), 0.0);'.format(tex_store, tex_name, nor, uv_name)) else: if mat_state.texture_grad: curshader.write('vec4 {0} = textureGrad({1}, {2}.xy, g2.xy, g2.zw);'.format(tex_store, tex_name, uv_name)) else: curshader.write('vec4 {0} = texture({1}, {2}.xy);'.format(tex_store, tex_name, uv_name)) if to_linear: curshader.write('{0}.rgb = pow({0}.rgb, vec3(2.2));'.format(tex_store)) return tex_store def apply_screenspace_derivative_offset_if_required(coords: str) -> str: """Apply screen-space derivative offsets to the given coordinates, if required by the current ParserPass. """ # Derivative functions are only available in fragment shaders if state.curshader.shader_type == 'frag': if state.current_pass == ParserPass.DX_SCREEN_SPACE: coords = f'({coords}) + {dfdx_fine(coords)}' elif state.current_pass == ParserPass.DY_SCREEN_SPACE: coords = f'({coords}) + {dfdy_fine(coords)}' return '(' + coords + ')' def node_need_reevaluation_for_screenspace_derivative(node: bpy.types.Node) -> bool: if state.current_pass not in (ParserPass.DX_SCREEN_SPACE, ParserPass.DY_SCREEN_SPACE): return False should_compute_offset = node_meta.get_node_meta(node).compute_dxdy_variants if should_compute_offset == node_meta.ComputeDXDYVariant.ALWAYS: return True elif should_compute_offset == node_meta.ComputeDXDYVariant.NEVER: return False # ComputeDXDYVariant.DYNAMIC for inp in node.inputs: c_node, _ = lnx.node_utils.input_get_connected_node(inp) if c_node is None: continue if node_need_reevaluation_for_screenspace_derivative(c_node): return True return False def dfdx_fine(val: str) -> str: # GL_ARB_derivative_control is unavailable in OpenGL ES (= no fine/coarse variants), # OES_standard_derivatives is automatically enabled in kha.SystemImpl return f'dFdx({val})' if lnx.utils.is_gapi_gl_es() else f'dFdxFine({val})' def dfdy_fine(val: str) -> str: return f'dFdy({val})' if lnx.utils.is_gapi_gl_es() else f'dFdyFine({val})' def to_vec1(v): return str(v) def to_vec2(v): return f'vec2({v[0]}, {v[1]})' def to_vec3(v): return f'vec3({v[0]}, {v[1]}, {v[2]})' def cast_value(val: str, from_type: str, to_type: str) -> str: """Casts a value that is already parsed in a glsl string to another value in a string. vec2 types are not supported (not used in the node editor) and there is no cast towards int types. If casting from vec3 to vec4, the w coordinate/alpha channel is filled with a 1. If this function is called with invalid parameters, a TypeError is raised. """ if from_type == to_type: return val if from_type in ('int', 'float'): if to_type in ('int', 'float'): return val elif to_type in ('vec2', 'vec3', 'vec4'): return f'{to_type}({val})' elif from_type == 'vec3': if to_type == 'float': return rgb_to_bw(val) elif to_type == 'vec4': return f'vec4({val}, 1.0)' elif from_type == 'vec4': if to_type == 'float': return rgb_to_bw(val) elif to_type == 'vec3': return f'{val}.xyz' raise TypeError("Invalid type cast in shader!") def rgb_to_bw(res_var: vec3str) -> floatstr: # Blender uses the default OpenColorIO luma coefficients which # originally come from the Rec. 709 standard (see ITU-R BT.709-6 Item 3.3) return f'dot({res_var}, vec3(0.2126, 0.7152, 0.0722))' def node_by_type(nodes, ntype: str) -> bpy.types.Node: for n in nodes: if n.type == ntype: return n def node_by_name(nodes, name: str) -> bpy.types.Node: for n in nodes: if n.bl_idname == name: return n def socket_index(node: bpy.types.Node, socket: bpy.types.NodeSocket) -> int: for i in range(0, len(node.outputs)): if node.outputs[i] == socket: return i def node_name(s: str) -> str: """Return a unique and safe name for a node for shader code usage.""" for p in state.parents: s = p.name + '_' + s if state.curshader.write_textures > 0: s += '_texread' s = safesrc(s) if '__' in s: # Consecutive _ are reserved s = s.replace('_', '_x') return s ## def make_texture( image: bpy.types.Image, tex_name: str, matname: str, interpolation: str, extension: str, ) -> Optional[Dict[str, Any]]: """Creates a texture binding entry for the scene's export data ('bind_textures') for a given texture image. """ tex = {'name': tex_name} if image is None: return None if matname is None: matname = mat_state.material.name # Get filepath filepath = image.filepath if filepath == '': if image.packed_file is not None: filepath = './' + image.name has_ext = filepath.endswith(('.jpg', '.png', '.hdr')) if not has_ext: # Raw bytes, write converted .jpg to /unpacked filepath += '.raw' elif image.source == "GENERATED": unpack_path = os.path.join(lnx.utils.get_fp_build(), 'compiled', 'Assets', 'unpacked') if not os.path.exists(unpack_path): os.makedirs(unpack_path) filepath = os.path.join(unpack_path, image.name + ".jpg") lnx.utils.convert_image(image, filepath, "JPEG") else: log.warn(matname + '/' + image.name + ' - invalid file path') return None else: filepath = lnx.utils.to_absolute_path(filepath, image.library) # Reference image name texpath = lnx.utils.asset_path(filepath) texfile = lnx.utils.extract_filename(filepath) tex['file'] = lnx.utils.safestr(texfile) s = tex['file'].rsplit('.', 1) if len(s) == 1: log.warn(matname + '/' + image.name + ' - file extension required for image name') return None ext = s[1].lower() do_convert = ext not in ('jpg', 'png', 'hdr', 'mp4') # Convert image if do_convert: new_ext = 'png' if (ext in ('tga', 'dds')) else 'jpg' tex['file'] = tex['file'].rsplit('.', 1)[0] + '.' + new_ext if image.packed_file is not None or not is_ascii(texfile): # Extract packed data / copy non-ascii texture unpack_path = os.path.join(lnx.utils.get_fp_build(), 'compiled', 'Assets', 'unpacked') if not os.path.exists(unpack_path): os.makedirs(unpack_path) unpack_filepath = os.path.join(unpack_path, tex['file']) if do_convert: if not os.path.isfile(unpack_filepath): fmt = 'PNG' if new_ext == 'png' else 'JPEG' lnx.utils.convert_image(image, unpack_filepath, file_format=fmt) else: # Write bytes if size is different or file does not exist yet if image.packed_file is not None: if 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) # Copy non-ascii texture else: if not os.path.isfile(unpack_filepath) or os.path.getsize(unpack_filepath) != os.path.getsize(texpath): shutil.copy(texpath, unpack_filepath) lnx.assets.add(unpack_filepath) else: if not os.path.isfile(lnx.utils.asset_path(filepath)): log.warn('Material ' + matname + '/' + image.name + ' - file not found(' + filepath + ')') return None if do_convert: unpack_path = os.path.join(lnx.utils.get_fp_build(), 'compiled', 'Assets', 'unpacked') if not os.path.exists(unpack_path): os.makedirs(unpack_path) converted_path = os.path.join(unpack_path, tex['file']) # TODO: delete cache when file changes if not os.path.isfile(converted_path): fmt = 'PNG' if new_ext == 'png' else 'JPEG' lnx.utils.convert_image(image, converted_path, file_format=fmt) lnx.assets.add(converted_path) else: # Link image path to assets # TODO: Khamake converts .PNG to .jpg? Convert ext to lowercase on windows if lnx.utils.get_os() == 'win': s = filepath.rsplit('.', 1) lnx.assets.add(lnx.utils.asset_path(s[0] + '.' + s[1].lower())) else: lnx.assets.add(lnx.utils.asset_path(filepath)) # if image_format != 'RGBA32': # tex['format'] = image_format rpdat = lnx.utils.get_rp() texfilter = rpdat.lnx_texture_filter if texfilter == 'Anisotropic': interpolation = 'Smart' elif texfilter == 'Linear': interpolation = 'Linear' elif texfilter == 'Point': interpolation = 'Closest' if interpolation == 'Cubic': # Mipmap linear tex['mipmap_filter'] = 'linear' tex['generate_mipmaps'] = True elif interpolation == 'Smart': # Mipmap anisotropic tex['min_filter'] = 'anisotropic' tex['mipmap_filter'] = 'linear' tex['generate_mipmaps'] = True elif interpolation == 'Closest': tex['min_filter'] = 'point' tex['mag_filter'] = 'point' # else defaults to linear if extension != 'REPEAT': # Extend or clip tex['u_addressing'] = 'clamp' tex['v_addressing'] = 'clamp' if image.source == 'MOVIE': tex['source'] = 'movie' tex['min_filter'] = 'linear' tex['mag_filter'] = 'linear' tex['mipmap_filter'] = 'no' tex['generate_mipmaps'] = False return tex def make_texture_from_image_node(image_node: bpy.types.ShaderNodeTexImage, tex_name: str, matname: str = None) -> Optional[Dict[str, Any]]: if matname is None: matname = mat_state.material.name return make_texture(image_node.image, tex_name, matname, image_node.interpolation, image_node.extension) def is_pow(num): return ((num & (num - 1)) == 0) and num != 0 def is_ascii(s): return len(s) == len(s.encode()) ## def get_lnx_export_tangents(): return bpy.data.worlds['Lnx'].lnx_export_tangents def safesrc(name): return lnx.utils.safesrc(name) def disp_enabled(): return lnx.utils.disp_enabled(lnx.make_state.target) def assets_add(path): lnx.assets.add(path) def assets_add_embedded_data(path): lnx.assets.add_embedded_data(path) def tree_name() -> str: return state.tree_name def mat_batch(): return mat_state.batch def mat_bind_texture(tex): mat_state.bind_textures.append(tex) def mat_get_material(): return mat_state.material def mat_get_material_users(): return mat_state.mat_users