Export of Logic Node Tree

Didier · January 29, 2019, 6:24pm

Do you know if there would be a simple way to retrieve the list of objects contained in the logic node editor / node trees ( the node tree name; nodes ; frames) ?
The idea is to accelerate the production of software design documentation, like reusing those data in order to create call graphs and list of CSCs/CSUs?

zicklag · January 29, 2019, 7:13pm

That shouldn’t be that difficult to implement. Armory is essentially doing the same thing when it compiles the node tree to Haxe; it is outputting the node tree to a format ( Haxe code ) for use in the game. You would have to figure out what you would want it to export to, though.

You can access all of the node trees and the way that each node is connected through any Blender python plugin, so you could make a standalone plugin for it if you wanted. You can find the code that builds the logic trees here:

github.com

armory3d/armory/blob/master/blender/arm/make_logic.py

import os
import bpy
import arm.utils
import arm.log
from arm.exporter import ArmoryExporter

parsed_nodes = []
parsed_ids = dict() # Sharing node data
function_nodes = dict()
function_node_outputs = dict()
group_name = ''

def get_logic_trees():
    ar = []
    for node_group in bpy.data.node_groups:
        if node_group.bl_idname == 'ArmLogicTreeType':
            node_group.use_fake_user = True # Keep fake references for now
            ar.append(node_group)
    return ar

This file has been truncated. show original

Didier · January 30, 2019, 10:27am

Thanks @zicklag
Effectively the function get_root_nodes is at the heart of doing it. The file blender.py too.

The possibility to get the Frames is important for me too as it’s a way to encapsulate nodes as into a CSC (Computer Software Component) to create my hierarchy of CSCs/CSU (CSU are nodes). (CSC = a node tree ; sub CSC = Frame; CSU= node)

For info actuallly I use a mindmap tool (open source Freeplane) to do it, where it’s relatively easy to make your own tools. It gives for me what’s important to find in the software design documentation with Armory, that is a way to quickly visualize the sequences of events activating which CSCs, and where are localized specialized nodes used inside which CSCs. It’s important for reusability between “kick and dirt” rapid prototyping stages where you need to explore different use cases.

Thereafter an example of what I would like to generate automaticaly with an export from Armory to Freeplane.

Something that could be discussed on the forum, that is automaticaly generate design documentation and create/maintain traceability with software requirements specifications ?