from typing import Union
import bpy
from mathutils import Euler, Vector
import arm
import arm.material.cycles as c
import arm.material.cycles_functions as c_functions
from arm.material.parser_state import ParserState
from arm.material.shader import floatstr, vec3str
if arm.is_reload(__name__):
c = arm.reload_module(c)
c_functions = arm.reload_module(c_functions)
arm.material.parser_state = arm.reload_module(arm.material.parser_state)
from arm.material.parser_state import ParserState
arm.material.shader = arm.reload_module(arm.material.shader)
from arm.material.shader import floatstr, vec3str
else:
arm.enable_reload(__name__)
def parse_curvevec(node: bpy.types.ShaderNodeVectorCurve,
out_socket: bpy.types.NodeSocket,
state: ParserState) -> vec3str:
fac = c.parse_value_input(node.inputs[0])
vec = c.parse_vector_input(node.inputs[1])
curves = node.mapping.curves
name = c.node_name(node.name)
# mapping.curves[0].points[0].handle_type # bezier curve
return '(vec3({0}, {1}, {2}) * {3})'.format(
import bpy.types
from bpy.props import *
from nodeitems_utils import NodeItem
from arm.logicnode.arm_sockets import ArmCustomSocket
import arm # we cannot import arm.livepatch here or we have a circular import
# Pass custom property types and NodeReplacement forward to individual
# node modules that import arm_nodes
from arm.logicnode.arm_props import *
from arm.logicnode.replacement import NodeReplacement
import arm.node_utils
import arm.utils
if arm.is_reload(__name__):
arm.logicnode.arm_props = arm.reload_module(arm.logicnode.arm_props)
from arm.logicnode.arm_props import *
arm.logicnode.replacement = arm.reload_module(arm.logicnode.replacement)
from arm.logicnode.replacement import NodeReplacement
arm.node_utils = arm.reload_module(arm.node_utils)
arm.utils = arm.reload_module(arm.utils)
else:
arm.enable_reload(__name__)
# When passed as a category to add_node(), this will use the capitalized
# name of the package of the node as the category to make renaming
# categories easier.
PKG_AS_CATEGORY = "__pkgcat__"
nodes = []
category_items: ODict[str, List['ArmNodeCategory']] = OrderedDict()
import bpy
import arm
import arm.material.cycles as cycles
import arm.material.mat_state as mat_state
import arm.material.make_mesh as make_mesh
import arm.material.make_finalize as make_finalize
import arm.assets as assets
if arm.is_reload(__name__):
cycles = arm.reload_module(cycles)
mat_state = arm.reload_module(mat_state)
make_mesh = arm.reload_module(make_mesh)
make_finalize = arm.reload_module(make_finalize)
assets = arm.reload_module(assets)
else:
arm.enable_reload(__name__)
def make(context_id):
con_transluc = mat_state.data.add_context({ 'name': context_id, 'depth_write': False, 'compare_mode': 'less', 'cull_mode': 'clockwise', \
'blend_source': 'blend_one', 'blend_destination': 'blend_one', 'blend_operation': 'add', \
'alpha_blend_source': 'blend_zero', 'alpha_blend_destination': 'inverse_source_alpha', 'alpha_blend_operation': 'add' })
make_mesh.make_forward_base(con_transluc,
parse_opacity=True,
transluc_pass=True)
vert = con_transluc.vert
frag = con_transluc.frag
tese = con_transluc.tese
import json
import os
import shutil
import stat
import html
from typing import List
import bpy
import arm.assets as assets
import arm.make_state as state
import arm.utils
if arm.is_reload(__name__):
import arm
assets = arm.reload_module(assets)
state = arm.reload_module(state)
arm.utils = arm.reload_module(arm.utils)
else:
arm.enable_reload(__name__)
def on_same_drive(path1: str, path2: str) -> bool:
drive_path1, _ = os.path.splitdrive(path1)
drive_path2, _ = os.path.splitdrive(path2)
return drive_path1 == drive_path2
def add_armory_library(sdk_path: str, name: str, rel_path=False) -> str:
if rel_path:
sdk_path = '../' + os.path.relpath(sdk_path, arm.utils.get_fp()).replace('\\', '/')
import bpy
from bpy.types import NodeSocket
import arm
import arm.material.cycles as c
from arm.material.parser_state import ParserState
if arm.is_reload(__name__):
c = arm.reload_module(c)
arm.material.parser_state = arm.reload_module(arm.material.parser_state)
from arm.material.parser_state import ParserState
else:
arm.enable_reload(__name__)
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)
import importlib
import inspect
import pkgutil
import sys
import arm
import arm.logicnode.arm_nodes as arm_nodes
from arm.logicnode.arm_props import *
import arm.logicnode.arm_sockets as arm_sockets
from arm.logicnode.replacement import NodeReplacement
if arm.is_reload(__name__):
arm_nodes = arm.reload_module(arm_nodes)
arm.logicnode.arm_props = arm.reload_module(arm.logicnode.arm_props)
from arm.logicnode.arm_props import *
arm_sockets = arm.reload_module(arm_sockets)
arm.logicnode.replacement = arm.reload_module(arm.logicnode.replacement)
from arm.logicnode.replacement import NodeReplacement
HAS_RELOADED = True
else:
arm.enable_reload(__name__)
def init_categories():
"""Register default node menu categories."""
arm_nodes.add_category(
'Logic',
icon='OUTLINER',
section="basic",
description=
import bpy
import nodeitems_utils
from nodeitems_utils import NodeCategory
import arm
import arm.material.arm_nodes.arm_nodes as arm_nodes
# Import all nodes so that they register. Do not remove this import
# even if it looks unused
from arm.material.arm_nodes import *
if arm.is_reload(__name__):
arm_nodes = arm.reload_module(arm_nodes)
arm.material.arm_nodes = arm.reload_module(arm.material.arm_nodes)
from arm.material.arm_nodes import *
else:
arm.enable_reload(__name__)
registered_nodes = []
class MaterialNodeCategory(NodeCategory):
@classmethod
def poll(cls, context):
return context.space_data.tree_type == 'ShaderNodeTree'
def register_nodes():
global registered_nodes
# Re-register all nodes for now..
if len(registered_nodes) > 0:
import arm.props_ui
import arm.handlers
import arm.utils
import arm.keymap
reload_started = 0
if arm.is_reload(__name__):
arm.log.debug('Reloading Armory SDK...')
reload_started = time.time()
# Clear the module cache
import importlib
arm = importlib.reload(arm) # type: ignore
arm.nodes_logic = arm.reload_module(arm.nodes_logic)
arm.nodes_material = arm.reload_module(arm.nodes_material)
arm.props_traits_props = arm.reload_module(arm.props_traits_props)
arm.props_traits = arm.reload_module(arm.props_traits)
arm.props_lod = arm.reload_module(arm.props_lod)
arm.props_tilesheet = arm.reload_module(arm.props_tilesheet)
arm.props_exporter = arm.reload_module(arm.props_exporter)
arm.props_bake = arm.reload_module(arm.props_bake)
arm.props_renderpath = arm.reload_module(arm.props_renderpath)
arm.props_properties = arm.reload_module(arm.props_properties)
arm.props_collision_filter_mask = arm.reload_module(arm.props_collision_filter_mask)
arm.props = arm.reload_module(arm.props)
arm.props_ui = arm.reload_module(arm.props_ui)
arm.handlers = arm.reload_module(arm.handlers)
arm.utils = arm.reload_module(arm.utils)
arm.keymap = arm.reload_module(arm.keymap)
from contextlib import contextmanager
import math
import multiprocessing
import os
import re
import subprocess
import bpy
import arm.assets as assets
import arm.log as log
import arm.utils
if arm.is_reload(__name__):
import arm
assets = arm.reload_module(assets)
log = arm.reload_module(log)
arm.utils = arm.reload_module(arm.utils)
else:
arm.enable_reload(__name__)
# The format used for rendering the environment. Choose HDR or JPEG.
ENVMAP_FORMAT = 'JPEG'
ENVMAP_EXT = 'hdr' if ENVMAP_FORMAT == 'HDR' else 'jpg'
def add_irr_assets(output_file_irr):
assets.add(output_file_irr + '.arm')
def add_rad_assets(output_file_rad, rad_format, num_mips):
import bpy
import arm
import arm.material.make_tess as make_tess
from arm.material.shader import ShaderContext
if arm.is_reload(__name__):
make_tess = arm.reload_module(make_tess)
arm.material.shader = arm.reload_module(arm.material.shader)
from arm.material.shader import ShaderContext
else:
arm.enable_reload(__name__)
def make(con_mesh: ShaderContext):
vert = con_mesh.vert
frag = con_mesh.frag
geom = con_mesh.geom
tesc = con_mesh.tesc
tese = con_mesh.tese
# Additional values referenced in cycles
# TODO: enable from cycles.py
if frag.contains('dotNV') and not frag.contains('float dotNV'):
frag.write_init('float dotNV = max(dot(n, vVec), 0.0);')
# n is not always defined yet (in some shadowmap shaders e.g.)
if not frag.contains('vec3 n'):
vert.add_out('vec3 wnormal')
vert.add_uniform('mat3 N', '_normalMatrix')
vert.write_attrib('wnormal = normalize(N * vec3(nor.xy, pos.w));')
import arm
import arm.material.cycles as cycles
import arm.material.make_shader as make_shader
import arm.material.mat_state as mat_state
if arm.is_reload(__name__):
cycles = arm.reload_module(cycles)
make_shader = arm.reload_module(make_shader)
mat_state = arm.reload_module(mat_state)
else:
arm.enable_reload(__name__)
# TODO: handle groups
# TODO: handle cached shaders
batchDict = None
signatureDict = None
def traverse_tree(node, sign):
sign += node.type + '-'
for inp in node.inputs:
if inp.is_linked:
sign = traverse_tree(inp.links[0].from_node, sign)
else:
sign += 'o' # Unconnected socket
return sign
def get_signature(mat):
nodes = mat.node_tree.nodes
output_node = cycles.node_by_type(nodes, 'OUTPUT_MATERIAL')
import arm
import arm.material.make_finalize as make_finalize
import arm.material.make_mesh as make_mesh
import arm.material.mat_state as mat_state
import arm.material.mat_utils as mat_utils
if arm.is_reload(__name__):
make_finalize = arm.reload_module(make_finalize)
make_mesh = arm.reload_module(make_mesh)
mat_state = arm.reload_module(mat_state)
mat_utils = arm.reload_module(mat_utils)
else:
arm.enable_reload(__name__)
def make(context_id):
con = {
'name': context_id,
'depth_write': True,
'compare_mode': 'less',
'cull_mode': 'clockwise'
}
mat = mat_state.material
blend = mat.arm_blending
if blend:
con['blend_source'] = mat.arm_blending_source
con['blend_destination'] = mat.arm_blending_destination
con['blend_operation'] = mat.arm_blending_operation
con['alpha_blend_source'] = mat.arm_blending_source_alpha
con['alpha_blend_destination'] = mat.arm_blending_destination_alpha
con['alpha_blend_operation'] = mat.arm_blending_operation_alpha
from bpy.props import *
from bpy.types import Node
import arm
from arm.material.arm_nodes.arm_nodes import add_node
from arm.material.shader import Shader
if arm.is_reload(__name__):
arm.material.arm_nodes.arm_nodes = arm.reload_module(
arm.material.arm_nodes.arm_nodes)
from arm.material.arm_nodes.arm_nodes import add_node
arm.material.shader = arm.reload_module(arm.material.shader)
from arm.material.shader import Shader
else:
arm.enable_reload(__name__)
class ShaderDataNode(Node):
"""Allows access to shader data such as uniforms and inputs."""
bl_idname = 'ArmShaderDataNode'
bl_label = 'Shader Data'
bl_icon = 'NONE'
input_type: EnumProperty(
items=[('input', 'Input', 'Shader Input'),
('uniform', 'Uniform', 'Uniform value')],
name='Input Type',
default='input',
description="The kind of data that should be retrieved")
input_source: EnumProperty(items=[
import bpy
from bpy.app.handlers import persistent
import arm
import arm.api
import arm.live_patch as live_patch
import arm.logicnode.arm_nodes as arm_nodes
import arm.nodes_logic
import arm.make as make
import arm.make_state as state
import arm.props as props
import arm.utils
if arm.is_reload(__name__):
arm.api = arm.reload_module(arm.api)
live_patch = arm.reload_module(live_patch)
arm_nodes = arm.reload_module(arm_nodes)
arm.nodes_logic = arm.reload_module(arm.nodes_logic)
make = arm.reload_module(make)
state = arm.reload_module(state)
props = arm.reload_module(props)
arm.utils = arm.reload_module(arm.utils)
else:
arm.enable_reload(__name__)
@persistent
def on_depsgraph_update_post(self):
if state.proc_build != None:
return
from enum import IntEnum, unique
from typing import List, Set, Tuple, Union, Optional
import bpy
import arm
from arm.material.shader import Shader, ShaderContext, vec3str, floatstr
if arm.is_reload(__name__):
arm.material.shader = arm.reload_module(arm.material.shader)
from arm.material.shader import Shader, ShaderContext, vec3str, floatstr
else:
arm.enable_reload(__name__)
@unique
class ParserContext(IntEnum):
"""Describes which kind of node tree is parsed."""
OBJECT = 0
# Texture node trees are not supported yet
# TEXTURE = 1
WORLD = 2
class ParserState:
"""Dataclass to keep track of the current state while parsing a shader tree."""
def __init__(self,
context: ParserContext,
tree_name: str,
world: Optional[bpy.types.World] = None):
self.context = context
self.tree_name = tree_name
import cProfile
import os
import pstats
import arm
import arm.log as log
import arm.utils as utils
if arm.is_reload(__name__):
log = arm.reload_module(log)
utils = arm.reload_module(utils)
else:
arm.enable_reload(__name__)
class Profile:
"""Context manager for profiling the enclosed code when the given condition is true.
The output file is stored in the SDK directory and can be opened by tools such as SnakeViz.
"""
def __init__(self, filename_out: str, condition: bool):
self.filename_out = filename_out
self.condition = condition
self.pr = cProfile.Profile()
def __enter__(self):
if self.condition:
self.pr.enable()
log.debug("Profiling started")
return self
import bpy
import arm
import arm.log as log
import arm.props_ui as props_ui
if arm.is_reload(__name__):
props_ui = arm.reload_module(props_ui)
else:
arm.enable_reload(__name__)
arm_keymaps = []
def register():
wm = bpy.context.window_manager
addon_keyconfig = wm.keyconfigs.addon
# Keyconfigs are not available in background mode. If the keyconfig
# was not found despite running _not_ in background mode, a warning
# is printed
if addon_keyconfig is None:
if not bpy.app.background:
log.warn("No keyconfig path found")
return
km = addon_keyconfig.keymaps.new(name='Window',
space_type='EMPTY',
region_type="WINDOW")
km.keymap_items.new(props_ui.ArmoryPlayButton.bl_idname,
type='F5',
