Add import hashlib and formatted with black

Bumps [ruff](https://github.com/astral-sh/ruff) from 0.15.9 to 0.15.10.
- [Release notes](https://github.com/astral-sh/ruff/releases)
- [Changelog](https://github.com/astral-sh/ruff/blob/main/CHANGELOG.md)
- [Commits](https://github.com/astral-sh/ruff/compare/0.15.9...0.15.10)

---
updated-dependencies:
- dependency-name: ruff
  dependency-version: 0.15.10
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/scripts/publish-bonsai-releases.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env -S uv run
+# /// script
+# dependencies = [
+#     "PyGithub",
+#     "requests",
+# ]
+# ///
+
+import os
+from pathlib import Path
+
+import requests
+from github import Github
+from github.GitReleaseAsset import GitReleaseAsset
+
+EXTENSION_ID = "bonsai"
+CURRENT_PYTHON_VERSION = "py313"
+CURRENT_PLATFORMS = ["linux-x64", "macos-arm64", "windows-x64"]
+
+
+def publish_asset(asset: GitReleaseAsset, token: str, repo_root: Path) -> None:
+    """
+    Publish an asset to Blender Extensions.
+    Reference: https://extensions.blender.org/api/v1/swagger
+    """
+    temp_path = repo_root / asset.name
+
+    response = requests.get(asset.browser_download_url)
+    response.raise_for_status()
+    temp_path.write_bytes(response.content)
+
+    url = f"https://extensions.blender.org/api/v1/extensions/{EXTENSION_ID}/versions/upload/"
+    headers = {"Authorization": f"Bearer {token}"}
+
+    files = {"version_file": temp_path.read_bytes()}
+    response = requests.post(url, headers=headers, files=files)
+    response.raise_for_status()
+
+    temp_path.unlink()
+
+    print(f"✓ Published {asset.name}")
+
+
+def main() -> None:
+    token = os.getenv("BLENDER_EXTENSIONS_TOKEN")
+    if not token:
+        raise Exception("BLENDER_EXTENSIONS_TOKEN environment variable not set")
+
+    # Get the repository root
+    repo_root = Path(__file__).parent.parent.parent
+
+    # Read VERSION file
+    version_file = repo_root / "VERSION"
+    version = version_file.read_text().strip()
+
+    print(f"Current VERSION: {version}")
+
+    tag_name = f"bonsai-{version}"
+
+    # Get release from GitHub
+    gh = Github()
+    gh_repo = gh.get_repo("IfcOpenShell/IfcOpenShell")
+    release = gh_repo.get_release(tag_name)
+
+    assets = release.get_assets()
+
+    asset_platform_map: dict[str, tuple[GitReleaseAsset, str]] = {}
+    for asset in assets:
+        if CURRENT_PYTHON_VERSION not in asset.name:
+            continue
+        for platform in CURRENT_PLATFORMS:
+            if platform in asset.name:
+                asset_platform_map[asset.name] = (asset, platform)
+                break
+
+    if len(asset_platform_map) != len(CURRENT_PLATFORMS):
+        found_platforms = {platform for _, (_, platform) in asset_platform_map.items()}
+        missing_platforms = set(CURRENT_PLATFORMS) - found_platforms
+        raise Exception(
+            f"Expected {len(CURRENT_PLATFORMS)} assets but found {len(asset_platform_map)}. "
+            f"Missing: {', '.join(sorted(missing_platforms))}"
+        )
+
+    print("\nRelease assets:")
+    for asset_name in sorted(asset_platform_map.keys()):
+        print(f"- {asset_name}")
+
+    # https://extensions.blender.org/api/v1/swagger
+    print("\nPublishing assets to Blender Extensions:")
+    for asset_name, (asset, platform) in asset_platform_map.items():
+        publish_asset(asset, token, repo_root)
+
+
+if __name__ == "__main__":
+    main()

.github/workflows/build_rocky.yml

@@ -9,6 +9,13 @@ jobs:
     container: rockylinux:9
 
     steps:
+      - name: Set up uv
+        uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57 # v8.0.0
+
+      - name: Install Python
+        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
+        run: uv python install
+
       - name: Install Dependencies
         run: |
           dnf update -y
@@ -17,7 +24,6 @@ jobs:
                          sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel      \
                          readline-devel ncurses-devel libffi-devel libuuid-devel git-lfs \
                          findutils xz byacc
-          python3 -m pip install typing_extensions
           git config --global --add safe.directory '*'
 
       - name: Install aws cli
@@ -45,7 +51,7 @@ jobs:
       - name: Unpack Dependencies
         run: |
           cd build
-          python3 ../nix/cache_dependencies.py unpack
+          uv run ../nix/cache_dependencies.py unpack
 
       - name: ccache
         uses: hendrikmuhs/ccache-action@v1.2.22
@@ -56,7 +62,7 @@ jobs:
         shell: bash
         run: |
           set -o pipefail
-          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release python3 ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
+          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
 
       - name: Upload Build Logs
         if: always()
@@ -71,7 +77,7 @@ jobs:
       - name: Pack Dependencies
         run: |
           cd build
-          python3 ../nix/cache_dependencies.py pack
+          uv run ../nix/cache_dependencies.py pack
 
       - name: Commit and Push Changes to Build Repository
         run: |

.github/workflows/build_rocky_arm.yml

@@ -9,6 +9,13 @@ jobs:
     container: arm64v8/rockylinux:9
 
     steps:
+      - name: Set up uv
+        uses: astral-sh/setup-uv@cec208311dfd045dd5311c1add060b2062131d57 # v8.0.0
+
+      - name: Install Python
+        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
+        run: uv python install
+
       - name: Install Dependencies
         run: |
           dnf update -y
@@ -17,7 +24,6 @@ jobs:
                          sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel      \
                          readline-devel ncurses-devel libffi-devel libuuid-devel git-lfs \
                          findutils xz byacc
-          python3 -m pip install typing_extensions
           git config --global --add safe.directory '*'
 
       - name: Install aws cli
@@ -45,7 +51,7 @@ jobs:
       - name: Unpack Dependencies
         run: |
           cd build
-          python3 ../nix/cache_dependencies.py unpack
+          uv run ../nix/cache_dependencies.py unpack
 
       - name: ccache
         uses: hendrikmuhs/ccache-action@v1.2.22
@@ -56,7 +62,7 @@ jobs:
         shell: bash
         run: |
           set -o pipefail
-          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release python3 ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
+          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
 
       - name: Upload Build Logs
         if: always()
@@ -71,7 +77,7 @@ jobs:
       - name: Pack Dependencies
         run: |
           cd build
-          python3 ../nix/cache_dependencies.py pack
+          uv run ../nix/cache_dependencies.py pack
 
       - name: Commit and Push Changes to Build Repository
         run: |

.github/workflows/ci-lint.yaml

@@ -95,8 +95,7 @@ jobs:
             echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
           }
 
-          run_check poe ruff-main
-          run_check poe ruff-old
+          run_check poe ruff
 
           exit $ERROR
         continue-on-error: true

.github/workflows/publish-bonsai-releases.yml

@@ -0,0 +1,16 @@
+name: Publish Bonsai Releases
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v3
+
+      - run: uv run .github/scripts/publish-bonsai-releases.py
+        env:
+          BLENDER_EXTENSIONS_TOKEN: ${{ secrets.BLENDER_EXTENSIONS_TOKEN }}

nix/build-all.py

@@ -1,4 +1,6 @@
 #!/usr/bin/python
+# /// script
+# ///
 ###############################################################################
 #                                                                             #
 # This file is part of IfcOpenShell.                                          #
@@ -126,13 +128,7 @@ from collections.abc import Generator, Sequence
 from pathlib import Path
 from urllib.request import urlretrieve
 
-try:
-    from typing import Literal, Union
-except:
-    # python 3.6 compatibility for rocky 8
-    from typing import Union
-
-    from typing_extensions import Literal
+from typing import Literal, Union
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)

nix/cache_dependencies.py

@@ -1,3 +1,5 @@
+# /// script
+# ///
 """
 Cache built dependencies for builds.
 

pyproject.toml

@@ -3,7 +3,7 @@ name = "IfcOpenShell"
 version = "0.0.0"
 dependencies = [
     "black==26.3.1",
-    "ruff==0.15.9",
+    "ruff==0.15.10",
     "poethepoet",
     "ty==0.0.29",
     "gersemi==0.26.1",
@@ -215,10 +215,7 @@ exclude = [
 
 [tool.poe.tasks]
 
-ruff-main = "ruff check --extend-exclude nix/build-all.py"
-# It's actually Python 3.6, but ruff only supports 3.7+, but it should do.
-ruff-old = "ruff check nix/build-all.py --target-version py37"
-ruff.sequence = ["ruff-main", "ruff-old"]
+ruff = "ruff check"
 
 black = "black ."
 
@@ -238,7 +235,7 @@ ty-venv-ios.sequence = [
     {cmd = "uv pip install -r src/ifcopenshell-python/type-check-requirements.txt --python=src/ifcopenshell-python/.venv"},
 ]
 
-format.sequence = ["black", "ruff-main", "ruff-old"]
+format.sequence = ["black", "ruff"]
 
 cmake-format = "gersemi . --in-place"
 

src/bonsai/Makefile

@@ -17,8 +17,8 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 SHELL := sh
-PYTHON:=python3.11
-PIP:=pip3.11
+PYTHON:=python3
+PIP:=pip3
 PATCH:=patch
 SED:=sed -i
 VENV_ACTIVATE:=bin/activate

src/bonsai/bonsai/bim/module/light/__init__.py

@@ -23,7 +23,7 @@ from pathlib import Path
 import bpy
 import pyradiance
 
-from . import export, ies, list, material, prepare, prop, render, solar, ui
+from . import list, operator, prop, ui
 
 
 def get_pyradiance_path():
@@ -31,43 +31,31 @@ def get_pyradiance_path():
 
 
 classes = (
-    export.ExportOBJ,
-    solar.ImportLatLong,
-    solar.ImportTrueNorth,
-    solar.MoveSunPathTo3DCursor,
-    render.RadianceRender,
-    render.FalseColorRadiance,
-    render.RADIANCE_OT_select_camera,
-    solar.ViewFromSun,
-    solar.LightPickCoordinates,
-    solar.LightSetTimeToNow,
-    material.RefreshIFCMaterials,
-    material.UnmapMaterial,
-    material.RADIANCE_OT_export_material_mappings,
-    material.RADIANCE_OT_import_material_mappings,
-    material.RADIANCE_OT_open_spectraldb,
-    prepare.PrepareRadianceScene,
-    ies.AddIESLight,
-    ies.RemoveIESLight,
-    export.CleanupRadianceFiles,
+    operator.ExportOBJ,
+    operator.ImportLatLong,
+    operator.ImportTrueNorth,
+    operator.MoveSunPathTo3DCursor,
+    operator.RadianceRender,
+    operator.ViewFromSun,
+    operator.LightPickCoordinates,
+    operator.LightSetTimeToNow,
+    operator.RefreshIFCMaterials,
+    operator.UnmapMaterial,
+    operator.RADIANCE_OT_select_camera,
+    operator.RADIANCE_OT_export_material_mappings,
+    operator.RADIANCE_OT_import_material_mappings,
+    operator.RADIANCE_OT_open_spectraldb,
     prop.RadianceMaterial,
-    prop.IESLight,
     prop.BIMSolarProperties,
     prop.RadianceExporterProperties,
     ui.BIM_PT_radiance_exporter,
-    ui.BIM_PT_radiance_scene_setup,
-    ui.BIM_PT_radiance_materials,
-    ui.BIM_PT_radiance_lighting,
-    ui.BIM_PT_radiance_render_settings,
-    ui.BIM_PT_radiance_pipeline,
     ui.BIM_PT_solar,
     list.MATERIAL_UL_radiance_materials,
-    list.MATERIAL_UL_ies_lights,
 )
 
 
 def register():
-    bpy.types.Scene.BIMRadianceExporterProperties = bpy.props.PointerProperty(type=prop.RadianceExporterProperties)
+    bpy.types.Scene.BIMRadianceExporeterProperies = bpy.props.PointerProperty(type=prop.RadianceExporterProperties)
     bpy.types.Scene.BIMSolarProperties = bpy.props.PointerProperty(type=prop.BIMSolarProperties)
 
     if pyradiance:
@@ -80,5 +68,5 @@ def register():
 
 
 def unregister():
-    del bpy.types.Scene.BIMRadianceExporterProperties
+    del bpy.types.Scene.BIMRadianceExporeterProperies
     del bpy.types.Scene.BIMSolarProperties

src/bonsai/bonsai/bim/module/light/export.py

@@ -1,488 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-import multiprocessing
-import os
-from pathlib import Path
-
-import bpy
-import ifcopenshell
-import ifcopenshell.geom
-
-import bonsai.tool as tool
-from bonsai.bim.module.light.shared import ifc_materials, linked_model_exports
-
-
-class ExportOBJ(bpy.types.Operator):
-    """Exports the IFC File to OBJ"""
-
-    bl_idname = "export_scene.radiance"
-    bl_label = "Export"
-    bl_description = "Export the IFC to OBJ"
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Ifc.get():
-            cls.poll_message_set("No IFC file loaded in Bonsai.")
-            return False
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        return True
-
-    def _get_geom_settings(self):
-        """Create standard geometry and serializer settings for OBJ export."""
-        settings = ifcopenshell.geom.settings()
-        serializer_settings = ifcopenshell.geom.serializer_settings()
-        settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.SURFACES_AND_SOLIDS)
-        settings.set("apply-default-materials", True)
-        serializer_settings.set("use-element-guids", True)
-        settings.set("use-world-coords", True)
-        return settings, serializer_settings
-
-    def _get_exportable_elements(self, ifc_file, filter_visibility=True):
-        """Get the list of elements to export from an IFC file."""
-        if ifc_file.schema in ("IFC2X3", "IFC4"):
-            elements = ifc_file.by_type("IfcElement") + ifc_file.by_type("IfcProxy")
-        else:
-            elements = ifc_file.by_type("IfcElement")
-
-        elements += ifc_file.by_type("IfcSite")
-        elements = [e for e in elements if not e.is_a("IfcFeatureElement") or e.is_a("IfcSurfaceFeature")]
-
-        if not filter_visibility:
-            return elements
-
-        # Filter by visibility in Blender.
-        # We use hide_get() (user-toggled eye icon) instead of visible_get()
-        # because visible_get() also considers collection/view-layer visibility
-        # which incorrectly excludes objects in linked aggregate sub-collections.
-        visible_elements = []
-        for element in elements:
-            blender_obj = tool.Ifc.get_object(element)
-            if blender_obj is None:
-                # No Blender object (linked aggregate copies, or not yet represented)
-                # Include by default — the geometry exists in the IFC file
-                visible_elements.append(element)
-                continue
-            if not blender_obj.hide_get():
-                visible_elements.append(element)
-            else:
-                print(f"Skipping hidden element: {element.GlobalId if hasattr(element, 'GlobalId') else element.id()}")
-        return visible_elements
-
-    def _export_ifc_to_obj(self, ifc_file, obj_path, mtl_path, settings, serializer_settings, elements):
-        """Export elements from an IFC file to OBJ format. Returns collected material names."""
-        materials_collected = []
-        serialiser = ifcopenshell.geom.serializers.obj(obj_path, mtl_path, settings, serializer_settings)
-        serialiser.setFile(ifc_file)
-        serialiser.setUnitNameAndMagnitude("METER", 1.0)
-        serialiser.writeHeader()
-
-        print(f"Exporting {len(elements)} elements to {obj_path}")
-        iterator = ifcopenshell.geom.iterator(settings, ifc_file, multiprocessing.cpu_count(), include=elements)
-        if iterator.initialize():
-            while True:
-                shape = iterator.get()
-                for material in shape.geometry.materials:
-                    materials_collected.append(material.name)
-                serialiser.write(shape)
-                if not iterator.next():
-                    break
-
-        serialiser.finalize()
-        return materials_collected
-
-    def _sync_moved_object_placements(self):
-        """Sync Blender object positions to IFC ObjectPlacements for all moved objects.
-
-        This is critical for linked aggregate copies: their IFC ObjectPlacements
-        are initially copies of the original's placement. After the user moves them
-        in Blender, the IFC placements are stale until explicitly synced. Without
-        this, the iterator with use-world-coords=True exports all copies at the
-        original position.
-        """
-        import bonsai.core.geometry as core_geometry
-
-        synced = 0
-        for obj in bpy.data.objects:
-            element = tool.Ifc.get_entity(obj)
-            if element is None:
-                continue
-            if not element.is_a("IfcProduct"):
-                continue
-            try:
-                if tool.Ifc.is_moved(obj):
-                    core_geometry.edit_object_placement(
-                        ifc=tool.Ifc,
-                        geometry=tool.Geometry,
-                        surveyor=tool.Surveyor,
-                        obj=obj,
-                        apply_scale=False,
-                    )
-                    synced += 1
-            except Exception as e:
-                print(f"Could not sync placement for {obj.name}: {e}")
-        if synced:
-            print(f"Synced {synced} moved object placement(s) to IFC before export")
-
-    def _export_collection_instances_obj(self, context, output_dir):
-        """Export Blender collection instances as per-parent OBJ files.
-
-        Collection instances (empties with instance_type='COLLECTION') are purely
-        Blender constructs — they don't exist in the IFC file. The ifcopenshell
-        iterator ignores them entirely, so we must export their geometry via
-        Blender's depsgraph which evaluates all instances with correct world transforms.
-
-        Each collection instance parent gets its own OBJ file because obj2mesh
-        cannot handle all instances in a single file ("too many patch triangles").
-        """
-        depsgraph = context.evaluated_depsgraph_get()
-
-        # Find which objects are collection instance parents (visible, not hidden)
-        # Skip collections that belong to linked IFC models — those are already
-        # exported by _export_linked_models() via the IFC serializer.
-        instance_parents = set()
-        for obj in bpy.data.objects:
-            if obj.instance_type == "COLLECTION" and obj.instance_collection is not None:
-                if not obj.visible_get():
-                    continue
-                # Check if this collection contains linked IFC objects
-                coll = obj.instance_collection
-                is_linked_ifc = any("guids" in child for child in coll.all_objects if child.type == "MESH")
-                if is_linked_ifc:
-                    print(f"Skipping collection instance '{obj.name}' (linked IFC model, exported via IFC serializer)")
-                    continue
-                instance_parents.add(obj.name)
-
-        if not instance_parents:
-            return
-
-        print(f"Found {len(instance_parents)} collection instance(s) to export")
-
-        # Export one OBJ per collection instance parent
-        identity = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
-        total_meshes = 0
-
-        for parent_name in sorted(instance_parents):
-            obj_path = os.path.join(output_dir, f"instance_{parent_name}.obj")
-            vert_offset = 0
-            mesh_count = 0
-
-            with open(obj_path, "w") as f:
-                f.write(f"# Collection instance geometry for {parent_name}\n")
-                f.write("usemtl white\n\n")
-
-                for dep_inst in depsgraph.object_instances:
-                    if not dep_inst.is_instance:
-                        continue
-                    if dep_inst.parent is None:
-                        continue
-                    if dep_inst.parent.original.name != parent_name:
-                        continue
-
-                    eval_obj = dep_inst.object
-                    if eval_obj.type != "MESH":
-                        continue
-
-                    try:
-                        mesh = eval_obj.to_mesh()
-                    except RuntimeError:
-                        continue
-                    if mesh is None:
-                        continue
-
-                    matrix = dep_inst.matrix_world
-                    f.write(f"g obj_{mesh_count}\n")
-
-                    for v in mesh.vertices:
-                        co = matrix @ v.co
-                        f.write(f"v {co.x} {co.y} {co.z}\n")
-
-                    mesh.calc_loop_triangles()
-                    for tri in mesh.loop_triangles:
-                        i0 = vert_offset + tri.vertices[0] + 1
-                        i1 = vert_offset + tri.vertices[1] + 1
-                        i2 = vert_offset + tri.vertices[2] + 1
-                        f.write(f"f {i0} {i1} {i2}\n")
-
-                    vert_offset += len(mesh.vertices)
-                    mesh_count += 1
-                    eval_obj.to_mesh_clear()
-
-            if mesh_count == 0:
-                try:
-                    os.remove(obj_path)
-                except OSError:
-                    pass
-                continue
-
-            # Identity matrix — geometry is already at world coordinates
-            linked_model_exports.append((obj_path, "", identity))
-            total_meshes += mesh_count
-            print(f"  {parent_name}: {mesh_count} meshes, {vert_offset} vertices")
-
-        if total_meshes > 0:
-            print(f"Exported {total_meshes} instanced meshes across {len(linked_model_exports)} file(s)")
-
-    def _export_non_ifc_meshes(self, context, output_dir):
-        """Export visible Blender mesh objects that have no IFC entity.
-
-        These are plain Blender geometry (e.g. manually added planes, cubes)
-        that don't exist in any IFC file. They are skipped by the IFC iterator
-        and by the collection instance exporter, so we handle them separately.
-        """
-        non_ifc_meshes = []
-        for obj in bpy.data.objects:
-            if obj.type != "MESH":
-                continue
-            if not obj.visible_get():
-                continue
-            # Skip objects that have an IFC entity (handled by main/linked IFC export)
-            if tool.Ifc.get_entity(obj) is not None:
-                continue
-            # Skip objects inside instanced collections (handled by collection instance export)
-            if any(col.library for col in obj.users_collection):
-                continue
-            # Skip linked IFC element objects (have "guids" custom prop)
-            if "guids" in obj:
-                continue
-            non_ifc_meshes.append(obj)
-
-        if not non_ifc_meshes:
-            return
-
-        obj_path = os.path.join(output_dir, "blender_meshes.obj")
-        vert_offset = 0
-        mesh_count = 0
-        identity = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
-
-        depsgraph = context.evaluated_depsgraph_get()
-
-        with open(obj_path, "w") as f:
-            f.write("# Non-IFC Blender mesh geometry\n")
-            f.write("usemtl white\n\n")
-
-            for obj in non_ifc_meshes:
-                eval_obj = obj.evaluated_get(depsgraph)
-                try:
-                    mesh = eval_obj.to_mesh()
-                except RuntimeError:
-                    continue
-                if mesh is None:
-                    continue
-
-                matrix = obj.matrix_world
-                f.write(f"g {obj.name}\n")
-
-                for v in mesh.vertices:
-                    co = matrix @ v.co
-                    f.write(f"v {co.x} {co.y} {co.z}\n")
-
-                mesh.calc_loop_triangles()
-                for tri in mesh.loop_triangles:
-                    i0 = vert_offset + tri.vertices[0] + 1
-                    i1 = vert_offset + tri.vertices[1] + 1
-                    i2 = vert_offset + tri.vertices[2] + 1
-                    f.write(f"f {i0} {i1} {i2}\n")
-
-                vert_offset += len(mesh.vertices)
-                mesh_count += 1
-                eval_obj.to_mesh_clear()
-
-        if mesh_count == 0:
-            try:
-                os.remove(obj_path)
-            except OSError:
-                pass
-            return
-
-        linked_model_exports.append((obj_path, "", identity))
-        print(f"Exported {mesh_count} non-IFC Blender mesh(es) ({vert_offset} vertices)")
-
-    def execute(self, context):
-        ifc_materials.clear()
-        linked_model_exports.clear()
-
-        props = tool.Blender.get_radiance_exporter_props()
-        output_dir = props.output_dir
-        props.is_exporting = True
-
-        # Sync all moved Blender object positions to IFC before export.
-        self._sync_moved_object_placements()
-
-        settings, serializer_settings = self._get_geom_settings()
-
-        ifc_file = tool.Ifc.get()
-
-        # --- Export main model ---
-        obj_file_path = os.path.join(output_dir, "model.obj")
-        mtl_file_path = os.path.join(output_dir, "model.mtl")
-
-        visible_elements = self._get_exportable_elements(ifc_file, filter_visibility=True)
-        mats = self._export_ifc_to_obj(
-            ifc_file, obj_file_path, mtl_file_path, settings, serializer_settings, visible_elements
-        )
-        ifc_materials.extend(mats)
-
-        self.report({"INFO"}, f"Exported main model OBJ to: {obj_file_path}")
-
-        # --- Export linked models (external IFC files) ---
-        self._export_linked_models(ifc_file, output_dir, settings, serializer_settings)
-
-        # --- Export collection instances (Blender-level linked copies) ---
-        self._export_collection_instances_obj(context, output_dir)
-
-        # --- Export non-IFC Blender meshes (plain geometry with no IFC entity) ---
-        self._export_non_ifc_meshes(context, output_dir)
-
-        props.is_exporting = False
-        total_linked = len(linked_model_exports)
-        if total_linked:
-            self.report({"INFO"}, f"Also exported {total_linked} linked/instanced model(s)")
-        return {"FINISHED"}
-
-    def _export_linked_models(self, main_ifc_file, output_dir, settings, serializer_settings):
-        """Detect and export all linked IFC models."""
-        try:
-            project_props = tool.Project.get_project_props()
-        except Exception:
-            print("Could not access project properties for linked models")
-            return
-
-        for idx, link in enumerate(project_props.links):
-            if not link.is_loaded:
-                print(f"Skipping linked model '{link.name}' (not loaded)")
-                continue
-
-            # Check if the link's empty handle is hidden in Blender
-            try:
-                link_empty = tool.Project.get_link_empty_handle(link)
-                if link_empty is not None and not link_empty.visible_get():
-                    print(f"Skipping linked model '{link.name}' (hidden in viewport)")
-                    continue
-            except Exception:
-                pass  # If we can't check visibility, export anyway
-
-            try:
-                filepath = Path(tool.Ifc.resolve_uri(link.filepath))
-            except Exception as e:
-                print(f"Could not resolve path for linked model '{link.name}': {e}")
-                continue
-
-            if not filepath.exists():
-                print(f"Linked IFC file not found: {filepath}")
-                continue
-
-            print(f"Exporting linked model {idx}: {filepath.name}")
-            try:
-                linked_ifc = ifcopenshell.open(str(filepath))
-            except Exception as e:
-                print(f"  Failed to open linked IFC: {e}")
-                continue
-
-            link_obj_path = os.path.join(output_dir, f"linked_{idx}.obj")
-            link_mtl_path = os.path.join(output_dir, f"linked_{idx}.mtl")
-
-            # For linked models we don't filter by Blender visibility
-            # (their objects are collection instances, not individually tracked)
-            elements = self._get_exportable_elements(linked_ifc, filter_visibility=False)
-            if not elements:
-                print(f"  No exportable elements found in linked model")
-                continue
-
-            mats = self._export_ifc_to_obj(
-                linked_ifc, link_obj_path, link_mtl_path, settings, serializer_settings, elements
-            )
-            ifc_materials.extend(mats)
-
-            # Get the link transformation matrix
-            try:
-                link_matrix = tool.Project.calculate_link_matrix(link)
-                matrix_list = [list(row) for row in link_matrix]
-            except Exception as e:
-                print(f"  Could not calculate link matrix: {e}, using identity")
-                matrix_list = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
-
-            linked_model_exports.append((link_obj_path, link_mtl_path, matrix_list))
-            print(f"  Exported {len(elements)} elements from linked model '{link.name}'")
-
-
-class CleanupRadianceFiles(bpy.types.Operator):
-    """Delete all generated Radiance files from the output directory"""
-
-    bl_idname = "radiance.cleanup_files"
-    bl_label = "Cleanup Radiance Files"
-    bl_description = "Remove all generated files (OBJ, MTL, RTM, RAD, HDR, TIFF, DAT) from the output directory"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        return True
-
-    def execute(self, context):
-        import bonsai.bim.module.light.shared as shared
-
-        props = tool.Blender.get_radiance_exporter_props()
-        output_dir = props.output_dir
-
-        if not os.path.isdir(output_dir):
-            self.report({"WARNING"}, f"Output directory does not exist: {output_dir}")
-            return {"CANCELLED"}
-
-        cleanup_patterns = (
-            "model.obj",
-            "model.mtl",
-            "model.rtm",
-            "sky.rad",
-            "materials.rad",
-            "scene.rad",
-            "ascene.oct",
-            "mascene.oct",
-            "ascene.amb",
-        )
-        cleanup_extensions = (".hdr", ".tiff", ".rad", ".dat")
-        cleanup_prefixes = ("instance_", "linked_", "blender_meshes")
-
-        removed = 0
-        for filename in os.listdir(output_dir):
-            filepath = os.path.join(output_dir, filename)
-            if not os.path.isfile(filepath):
-                continue
-            is_generated = (
-                filename in cleanup_patterns
-                or os.path.splitext(filename)[1].lower() in cleanup_extensions
-                or any(filename.startswith(p) for p in cleanup_prefixes)
-            )
-            if is_generated:
-                try:
-                    os.remove(filepath)
-                    removed += 1
-                except OSError as e:
-                    print(f"Failed to remove {filepath}: {e}")
-
-        # Reset the global scene reference
-        shared.scene = None
-
-        self.report({"INFO"}, f"Cleaned up {removed} generated files from {output_dir}")
-        return {"FINISHED"}

src/bonsai/bonsai/bim/module/light/ies.py

@@ -1,80 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-from pathlib import Path
-
-import bpy
-from bpy_extras.io_utils import ImportHelper
-
-import bonsai.tool as tool
-
-
-class AddIESLight(bpy.types.Operator, ImportHelper):
-    """Upload and add an IES light fixture to the scene"""
-
-    bl_idname = "radiance.add_ies_light"
-    bl_label = "Add IES Light"
-    bl_options = {"REGISTER", "UNDO"}
-
-    filename_ext = ".ies"
-    filter_glob: bpy.props.StringProperty(default="*.ies;*.IES", options={"HIDDEN"})
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-
-        # Create new IES light entry
-        ies_light = props.ies_lights.add()
-        # Store as relative path if the blend file is saved
-        if bpy.data.filepath:
-            ies_light.ies_file_path = bpy.path.relpath(self.filepath)
-        else:
-            ies_light.ies_file_path = self.filepath
-        ies_light.rotation_z = 0.0
-        ies_light.is_enabled = True
-
-        # Set as active
-        props.active_ies_light_index = len(props.ies_lights) - 1
-
-        self.report({"INFO"}, f"Added IES light: {Path(self.filepath).name}")
-        return {"FINISHED"}
-
-
-class RemoveIESLight(bpy.types.Operator):
-    """Remove an IES light fixture mapping"""
-
-    bl_idname = "radiance.remove_ies_light"
-    bl_label = "Remove IES Light"
-    bl_options = {"REGISTER", "UNDO"}
-
-    index: bpy.props.IntProperty()
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-
-        if 0 <= self.index < len(props.ies_lights):
-            props.ies_lights.remove(self.index)
-
-            # Adjust active index if needed
-            if props.active_ies_light_index >= len(props.ies_lights):
-                props.active_ies_light_index = len(props.ies_lights) - 1
-
-            self.report({"INFO"}, "IES light removed")
-            return {"FINISHED"}
-
-        self.report({"WARNING"}, "Invalid IES light index")
-        return {"CANCELLED"}

src/bonsai/bonsai/bim/module/light/list.py

@@ -18,18 +18,21 @@
 
 from __future__ import annotations
 
-from pathlib import Path
+import json
+import os
 from typing import TYPE_CHECKING
 
 import bpy
 
 if TYPE_CHECKING:
     from bonsai.bim.module.light.prop import (
-        IESLight,
         RadianceExporterProperties,
         RadianceMaterial,
     )
 
+with open(os.path.join(os.path.dirname(__file__), "spectraldb.json"), "r") as f:
+    spectraldb = json.load(f)
+
 
 class MATERIAL_UL_radiance_materials(bpy.types.UIList):
     def draw_item(
@@ -61,41 +64,3 @@ class MATERIAL_UL_radiance_materials(bpy.types.UIList):
                 op.material_index = index
             else:
                 row.label(text="Not Mapped (White)")
-
-
-class MATERIAL_UL_ies_lights(bpy.types.UIList):
-    """UIList for displaying IES light fixtures."""
-
-    def draw_item(
-        self,
-        context,
-        layout: bpy.types.UILayout,
-        data: RadianceExporterProperties,
-        item: IESLight,
-        icon,
-        active_data,
-        active_propname,
-        index,
-    ) -> None:
-        if self.layout_type in {"DEFAULT", "COMPACT"}:
-            row = layout.row(align=True)
-
-            # Enable/disable checkbox (visible toggle)
-            row.prop(item, "is_enabled", text="", emboss=True)
-
-            # IES file name
-            if item.ies_file_path:
-                filename = Path(item.ies_file_path).name
-                row.label(text=filename, icon="FILE")
-            else:
-                row.label(text="(No file selected)", icon="ERROR")
-
-            # Target: collection or single object
-            if item.use_collection:
-                row.prop(item, "target_collection", text="", icon="OUTLINER_COLLECTION", emboss=False)
-            else:
-                row.prop(item, "target_object", text="", emboss=False)
-
-            # Remove button (X icon - negative action)
-            op = row.operator("radiance.remove_ies_light", text="", icon="X")
-            op.index = index

src/bonsai/bonsai/bim/module/light/material.py

@@ -1,136 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-import json
-import webbrowser
-
-import bpy
-from bpy_extras.io_utils import ExportHelper, ImportHelper
-
-import bonsai.tool as tool
-
-
-class RefreshIFCMaterials(bpy.types.Operator):
-    bl_idname = "bim.refresh_ifc_materials"
-    bl_label = "Refresh IFC Materials"
-    bl_description = "Refresh the list of IFC materials for mapping"
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Ifc.get():
-            cls.poll_message_set("No IFC file loaded in Bonsai.")
-            return False
-        return True
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        ifc_file = tool.Ifc.get()
-
-        props.materials.clear()
-
-        for style in ifc_file.by_type("IfcSurfaceStyle"):
-            for render_item in style.Styles:
-                if render_item.is_a("IfcSurfaceStyleRendering"):
-                    style_id = f"IfcSurfaceStyleRendering-{render_item.id()}"
-                    style_name = style.Name or f"Unnamed Style {render_item.id()}"
-
-                    # Extract color
-                    color = (1.0, 1.0, 1.0)  # Default white
-                    if render_item.SurfaceColour:
-                        color = (
-                            render_item.SurfaceColour.Red,
-                            render_item.SurfaceColour.Green,
-                            render_item.SurfaceColour.Blue,
-                        )
-
-                    material = props.add_material_mapping(style_id, style_name)
-                    material.color = color
-
-                    material.category = ""
-                    material.subcategory = ""
-                    material.is_mapped = False
-
-        props.active_material_index = 0 if props.materials else -1
-
-        self.report({"INFO"}, f"Refreshed {len(props.materials)} IFC materials")
-        return {"FINISHED"}
-
-
-class UnmapMaterial(bpy.types.Operator):
-    bl_idname = "bim.unmap_material"
-    bl_label = "Unmap Material"
-    bl_options = {"REGISTER", "UNDO"}
-
-    material_index: bpy.props.IntProperty()
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        material = props.materials[self.material_index]
-        props.unmap_material(material.name)
-        return {"FINISHED"}
-
-
-class RADIANCE_OT_export_material_mappings(bpy.types.Operator, ExportHelper):
-    bl_idname = "radiance.export_material_mappings"
-    bl_label = "Export Material Mappings"
-    bl_description = "Export material mappings to a JSON file"
-
-    filename_ext = ".json"
-    filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        mappings = {}
-
-        for material in props.materials:
-            if material.is_mapped:
-                mappings[material.style_id] = {
-                    "name": material.name,
-                    "category": material.category,
-                    "subcategory": material.subcategory,
-                }
-
-        with open(self.filepath, "w") as f:
-            json.dump(mappings, f, indent=4)
-
-        self.report({"INFO"}, f"Material mappings exported to {self.filepath}")
-        return {"FINISHED"}
-
-
-class RADIANCE_OT_import_material_mappings(bpy.types.Operator, ImportHelper):
-    bl_idname = "radiance.import_material_mappings"
-    bl_label = "Import Material Mappings"
-    bl_description = "Import material mappings from a JSON file"
-
-    filename_ext = ".json"
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        props.import_mappings(self.filepath)
-        self.report({"INFO"}, f"Material mappings imported from {self.filepath}")
-        return {"FINISHED"}
-
-
-class RADIANCE_OT_open_spectraldb(bpy.types.Operator):
-    bl_idname = "radiance.open_spectraldb"
-    bl_label = "Open SpectralDB"
-    bl_description = "Open the SpectralDB website for reference"
-
-    def execute(self, context):
-        webbrowser.open("https://spectraldb.com")
-        return {"FINISHED"}

src/bonsai/bonsai/bim/module/light/operator.py

@@ -16,44 +16,716 @@
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
-"""Thin re-export module for backward compatibility.
+import json
+import math
+import multiprocessing
+import os
+import time
+import webbrowser
+from datetime import datetime
+from math import radians
+from pathlib import Path
+from typing import TYPE_CHECKING, Union
 
-All operator classes are defined in their respective submodules:
-  - export.py:   ExportOBJ, CleanupRadianceFiles
-  - prepare.py:  PrepareRadianceScene
-  - render.py:   RadianceRender, FalseColorRadiance, RADIANCE_OT_select_camera
-  - solar.py:    ImportTrueNorth, ImportLatLong, MoveSunPathTo3DCursor,
-                 ViewFromSun, LightPickCoordinates, LightSetTimeToNow
-  - material.py: RefreshIFCMaterials, UnmapMaterial,
-                 RADIANCE_OT_export_material_mappings,
-                 RADIANCE_OT_import_material_mappings,
-                 RADIANCE_OT_open_spectraldb
-  - ies.py:      AddIESLight, RemoveIESLight
+import bpy
+import ifcopenshell
+import ifcopenshell.geom
+import ifcopenshell.ifcopenshell_wrapper as W
+import ifcopenshell.util.geolocation
+import pyradiance as pr
+import requests
+from bpy_extras.io_utils import ExportHelper, ImportHelper
+from mathutils import Vector
 
-EnumPropertySearch and SetEnumProperty are provided by the global
-bonsai.bim.operator module (bl_idname "bim.enum_property_search").
-"""
+import bonsai.tool as tool
+from bonsai.bim.module.light.data import SolarData
 
-from bonsai.bim.module.light.export import CleanupRadianceFiles, ExportOBJ  # noqa: F401
-from bonsai.bim.module.light.ies import AddIESLight, RemoveIESLight  # noqa: F401
-from bonsai.bim.module.light.material import (  # noqa: F401
-    RADIANCE_OT_export_material_mappings,
-    RADIANCE_OT_import_material_mappings,
-    RADIANCE_OT_open_spectraldb,
-    RefreshIFCMaterials,
-    UnmapMaterial,
-)
-from bonsai.bim.module.light.prepare import PrepareRadianceScene  # noqa: F401
-from bonsai.bim.module.light.render import (  # noqa: F401
-    FalseColorRadiance,
-    RADIANCE_OT_select_camera,
-    RadianceRender,
-)
-from bonsai.bim.module.light.solar import (  # noqa: F401
-    ImportLatLong,
-    ImportTrueNorth,
-    LightPickCoordinates,
-    LightSetTimeToNow,
-    MoveSunPathTo3DCursor,
-    ViewFromSun,
-)
+ifc_materials = []
+
+with open(os.path.join(os.path.dirname(__file__), "spectraldb.json"), "r") as f:
+    spectraldb = json.load(f)
+
+
+class ExportOBJ(bpy.types.Operator):
+    """Exports the IFC File to OBJ"""
+
+    bl_idname = "export_scene.radiance"
+    bl_label = "Export"
+    bl_description = "Export the IFC to OBJ"
+
+    @classmethod
+    def poll(cls, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        if not props.should_load_from_memory and not props.ifc_file:
+            cls.poll_message_set("Select an IFC file or use 'load from memory' if it's loaded in Bonsai.")
+            return False
+        return True
+
+    def execute(self, context):
+        # Get the output directory
+        props = tool.Blender.get_radiance_exporter_props()
+        should_load_from_memory = props.should_load_from_memory
+        output_dir = props.output_dir
+
+        props.is_exporting = True
+
+        # Conversion from IFC to OBJ
+        # Settings for obj
+        settings = ifcopenshell.geom.settings()
+        serializer_settings = ifcopenshell.geom.serializer_settings()
+
+        settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.SURFACES_AND_SOLIDS)
+        settings.set("apply-default-materials", True)
+        serializer_settings.set("use-element-guids", True)
+        settings.set("use-world-coords", True)
+
+        ifc_file: ifcopenshell.file
+        if should_load_from_memory:
+            ifc_file = tool.Ifc.get()
+
+        else:
+            ifc_file_path = props.ifc_file
+            ifc_file = ifcopenshell.open(ifc_file_path)
+
+        obj_file_path = os.path.join(output_dir, "model.obj")
+        mtl_file_path = os.path.join(output_dir, "model.mtl")
+
+        serialiser = ifcopenshell.geom.serializers.obj(obj_file_path, mtl_file_path, settings, serializer_settings)
+        serialiser.setFile(ifc_file)
+        serialiser.setUnitNameAndMagnitude("METER", 1.0)
+        serialiser.writeHeader()
+
+        if ifc_file.schema in ("IFC2X3", "IFC4"):
+            elements = ifc_file.by_type("IfcElement") + ifc_file.by_type("IfcProxy")
+        else:
+            elements = ifc_file.by_type("IfcElement")
+
+        elements += ifc_file.by_type("IfcSite")
+        elements = [e for e in elements if not e.is_a("IfcFeatureElement") or e.is_a("IfcSurfaceFeature")]
+
+        iterator = ifcopenshell.geom.iterator(settings, ifc_file, multiprocessing.cpu_count(), include=elements)
+        if iterator.initialize():
+            while True:
+                shape = iterator.get()
+                assert isinstance(shape, W.TriangulationElement)
+                materials = shape.geometry.materials
+
+                for material in materials:
+                    ifc_materials.append(material.name)
+
+                serialiser.write(shape)
+                if not iterator.next():
+                    break
+
+        serialiser.finalize()
+        props.is_exporting = False
+
+        self.report({"INFO"}, "Exported OBJ file to: {}".format(obj_file_path))
+
+        return {"FINISHED"}
+
+
+class RadianceRender(bpy.types.Operator):
+    """Radiance Rendering"""
+
+    bl_idname = "render_scene.radiance"
+    bl_label = "Render"
+    bl_description = "Renders the scene using Radiance"
+
+    def execute(self, context):
+        print("Starting Radiance rendering process...")
+        props = tool.Blender.get_radiance_exporter_props()
+        resolution_x, resolution_y = props.radiance_resolution_x, props.radiance_resolution_y
+
+        assert context.scene
+        context.scene.render.resolution_x = resolution_x
+        context.scene.render.resolution_y = resolution_y
+
+        aspect_ratio = resolution_x / resolution_y
+
+        quality = props.radiance_quality.upper()
+        detail = props.radiance_detail.upper()
+        variability = props.radiance_variability.upper()
+        output_dir = props.output_dir
+        output_file_name = props.output_file_name
+        output_file_format = props.output_file_format
+        use_hdr = props.use_hdr
+        choose_hdr_image = props.choose_hdr_image
+
+        print(f"Resolution: {resolution_x}x{resolution_y}")
+        print(f"Quality: {quality}, Detail: {detail}, Variability: {variability}")
+        print(f"Output directory: {output_dir}")
+
+        if use_hdr:
+            hdr_image = "noon_grass_2k.hdr"
+            hdr_mask = "noon_grass_2k_mask.hdr"
+            sky_map_cal = "skymap.cal"
+            hdr_image_path = os.path.join(os.path.dirname(__file__), "HDRs", hdr_image)
+            hdr_mask_path = os.path.join(os.path.dirname(__file__), "HDRs", hdr_mask)
+            sky_map_cal_path = os.path.join(os.path.dirname(__file__), "HDRs", sky_map_cal)
+
+        obj_file_path = os.path.join(output_dir, "model.obj")
+
+        sun_props = tool.Blender.get_solar_props()
+        sun_pos_props = tool.Blender.get_sun_props()
+        assert sun_pos_props
+        sky_file_path = os.path.join(output_dir, "sky.rad")
+        # latitude = sun_props.latitude
+        # longitude = sun_props.longitude
+        # month = sun_props.month
+        # day = sun_props.day
+        # hour = sun_props.hour
+        # minute = sun_props.minute
+
+        # print("Sun Properties:")
+        # print("Latitude: ", latitude)
+        # print("Longitude: ", longitude)
+        # print("Timezone: ", timezone)
+        # print("Month: ", month)
+        # print("Day: ", day)
+        # print("Hour: ", hour)
+        # print("Minute: ", minute)
+
+        print("Setting up camera...")
+        if props.use_active_camera:
+            camera = context.scene.camera
+        else:
+            camera = props.selected_camera
+
+        if camera is None:
+            self.report({"ERROR"}, "No active camera found in the scene. Please add a camera and set it as active.")
+            return {"CANCELLED"}
+
+        # Get camera position and direction
+        camera_position, camera_direction = self.get_camera_data(camera)
+
+        print(f"Camera position: {camera_position}")
+        print(f"Camera direction: {camera_direction}")
+
+        # sun_position = tool.Blender.get_addon("sun_position")
+        #     azimuth, elevation = sun_position.sun_calc.get_sun_coordinates(
+        #     sun_pos_props.time,
+        #     sun_pos_props.latitude,
+        #     sun_pos_props.longitude,
+        #     -sun_pos_props.UTC_zone,
+        #     sun_pos_props.month,
+        #     sun_pos_props.day,
+        #     sun_pos_props.year,
+        # )
+
+        dt = datetime(sun_pos_props.year, sun_props.month, sun_props.day, sun_props.hour, sun_props.minute)
+
+        sky_description = pr.gensky(
+            dt=dt,
+            # azimuth=64.1,
+            # altitude=-26.6,
+            latitude=sun_props.latitude,
+            longitude=sun_props.longitude,
+            year=sun_pos_props.year,
+            timezone=-int(sun_props.UTC_zone),
+            # sunny_with_sun=False,
+            # sunny_without_sun=False,
+            # cloudy=False,
+            # ground_reflectance=0.2,
+            # turbidity=3.0,
+        )
+
+        sky_description_str = sky_description.decode("utf-8")
+
+        # Write all this to file
+        # skyfunc glow sky_glow
+        # 0
+        # 0
+        # 4 .9 .9 1.15 0
+
+        # sky_glow source sky
+        # 0
+        # 0
+        # 4 0 0 1 180
+
+        # skyfunc glow ground_glow
+        # 0
+        # 0
+        # 4 1.4 .9 .6 0
+
+        # ground_glow source ground
+        # 0
+        # 0
+        # 4 0 0 -1 180
+
+        if use_hdr and choose_hdr_image == "Noon":
+
+            with open(sky_file_path, "w") as f:
+                f.write(sky_description_str)
+                f.write("\n")
+                # f.write("skyfunc glow sky_glow\n0\n0\n4 .9 .9 1.15 0\n")
+                # f.write("sky_glow source sky\n0\n0\n4 0 0 1 180\n")
+                # f.write("skyfunc glow ground_glow\n0\n0\n4 1.4 .9 .6 0\n")
+                # f.write("ground_glow source ground\n0\n0\n4 0 0 -1 180\n")
+
+                f.write(
+                    '''void colorpict env_map
+7 red green blue "'''
+                    + hdr_image_path
+                    + '''"  "'''
+                    + sky_map_cal_path
+                    + '''" map_u map_v
+0
+1 0.5
+
+# This is a multiplier to colour balance the env map
+# In this case, it provides a rough ground luminance from 3k-5k
+env_map colorfunc env_colour
+4 100 100 100 .
+0
+0
+
+# .37 .57 1.5 is measured from a HDRI image
+# It is multiplied by a factor such that grey(r,g,b) = 1
+skyfunc colorfunc sky_colour
+4 .64 .99 2.6 .
+0
+0
+
+void mixpict composite
+7 env_colour sky_colour grey "'''
+                    + hdr_mask_path
+                    + '''"  "'''
+                    + sky_map_cal_path
+                    + """" map_u map_v
+0
+2 0.5 1
+
+composite glow env_map_glow
+0
+0
+4 1 1 1 0
+
+env_map_glow source sky
+0
+0
+4 0 0 1 180
+
+env_colour glow ground_glow
+0
+0
+4 1 1 1 0
+
+ground_glow source ground
+0
+0
+4 0 0 -1 180"""
+                )
+
+        elif not use_hdr:
+            with open(sky_file_path, "w") as f:
+                f.write(sky_description_str)
+                f.write("\n")
+                # f.write("skyfunc glow sky_glow\n0\n0\n4 .9 .9 1.15 0\n")
+                # f.write("sky_glow source sky\n0\n0\n4 0 0 1 180\n")
+                # f.write("skyfunc glow ground_glow\n0\n0\n4 1.4 .9 .6 0\n")
+                # f.write("ground_glow source ground\n0\n0\n4 0 0 -1 180\n")
+
+        props = tool.Blender.get_radiance_exporter_props()
+
+        data = props.get_mappings_dict()
+
+        materials_file = os.path.join(output_dir, "materials.rad")
+        written_materials = set()
+
+        all_materials = set(ifc_materials)
+
+        with open(materials_file, "w") as file:
+            # Write default materials
+            default_materials = [
+                "void plastic white\n0\n0\n5 0.8 0.8 0.8 0 0\n",
+                # "void plastic blue_plastic\n0\n0\n5 0.1 0.2 0.8 0.05 0.1\n",
+                # "void plastic red_plastic\n0\n0\n5 0.8 0.1 0.2 0.05 0.1\n",
+                # "void metal silver_metal\n0\n0\n5 0.8 0.8 0.8 0.9 0.1\n",
+                # "void glass clear_glass\n0\n0\n3 0.96 0.96 0.96\n",
+                # "void light white_light\n0\n0\n3 1.0 1.0 1.0\n",
+                # "void trans olive_trans\n0\n0\n7 0.6 0.7 0.4 0.05 0.05 0.7 0.2\n",
+            ]
+            for material in default_materials:
+                file.write(material)
+                written_materials.add(material.split()[2])  # Add material name to written set
+
+            for style_id in all_materials:
+                material = next((m for m in props.materials if m.style_id == style_id), None)
+                if material and material.is_mapped:
+                    category, subcategory = material.category, material.subcategory
+                    if category in spectraldb and subcategory in spectraldb[category]:
+                        material_def = spectraldb[category][subcategory]
+                        material_name = material_def.split()[2]
+                        if material_name not in written_materials:
+                            file.write(material_def + "\n")
+                            written_materials.add(material_name)
+                        file.write(f"inherit alias {style_id} {material_name}\n")
+                    else:
+                        file.write(f"inherit alias {style_id} white\n")
+                else:
+                    # If the material is not mapped, alias it to white
+                    file.write(f"inherit alias {style_id} white\n")
+
+        self.report({"INFO"}, f"Exported Materials Rad file to: {materials_file}")
+
+        # Run obj2mesh
+        rtm_file_path = os.path.join(output_dir, "model.rtm")
+        mesh_file_path = save_obj2mesh_output(obj_file_path, rtm_file_path, matfiles=[materials_file])
+        # subprocess.run(["obj2mesh", "-a", materials_file, obj_file_path, rtm_file_path])
+        self.report({"INFO"}, "obj2mesh output: {}".format(mesh_file_path))
+        scene_file = os.path.join(output_dir, "scene.rad")
+        with open(scene_file, "w") as file:
+            file.write('void mesh model\n1 "' + rtm_file_path + '"\n0\n0\n')
+
+        self.report({"INFO"}, "Exported Scene file to: {}".format(scene_file))
+
+        print("Setting up Radiance scene...")
+        scene = pr.Scene("ascene")
+
+        material_path = os.path.join(output_dir, "materials.rad")
+        scene_path = os.path.join(output_dir, "scene.rad")
+
+        scene.add_material(material_path)
+        scene.add_surface(scene_path)
+        scene.add_source(sky_file_path)
+        print("Setting up view...")
+        assert isinstance(camera.data, bpy.types.Camera)
+        if camera.data.type == "PERSP":
+            # Perspective camera
+            camera_fov = camera.data.angle
+            # Calculate vertical FOV based on the desired aspect ratio
+            vertical_fov = 2 * math.atan(math.tan(camera_fov / 2) / aspect_ratio)
+
+            aview = pr.View(
+                vtype="v",  # Perspective view
+                position=camera_position,
+                direction=camera_direction,
+                vup=(0, 0, 1),  # Assuming Z is up
+                horiz=math.degrees(camera_fov),
+                vert=math.degrees(vertical_fov),
+            )
+        else:  # 'ORTHO'
+            # Orthographic camera
+            # Calculate the view size based on the camera's orthographic scale
+            ortho_scale = camera.data.ortho_scale
+            view_width = ortho_scale
+            view_height = ortho_scale / aspect_ratio
+
+            aview = pr.View(
+                vtype="l",  # Parallel projection (orthographic)
+                position=camera_position,
+                direction=camera_direction,
+                vup=(0, 0, 1),  # Assuming Z is up
+                horiz=view_width,
+                vert=view_height,
+            )
+        scene.add_view(aview)
+        print("Starting render...")
+        start_time = time.time()
+        image = pr.render(
+            scene,
+            ambbounce=1,
+            resolution=(resolution_x, resolution_y),
+            quality=quality,
+            detail=detail,
+            variability=variability,
+            nproc=multiprocessing.cpu_count(),
+        )
+        end_time = time.time()
+        print(f"Render completed in {end_time - start_time:.2f} seconds")
+
+        output_hdr_path = os.path.join(output_dir, f"{output_file_name}.{output_file_format.lower()}")
+        print(f"Saving HDR output to: {output_hdr_path}")
+        if output_file_format == "HDR":
+            with open(output_hdr_path, "wb") as wtr:
+                wtr.write(image)
+        else:
+            pass
+        print("Applying tone mapping...")
+        pcond_image = pr.pcond(hdr=output_hdr_path, human=True)
+
+        tiff_path = os.path.join(output_dir, f"{output_file_name}.tiff")
+        print(f"Saving TIFF output to: {tiff_path}")
+        pr.ra_tiff(inp=pcond_image, out=tiff_path, lzw=True)
+        print("Radiance rendering process completed successfully.")
+        self.report({"INFO"}, "Radiance rendering completed. Output: {}".format(tiff_path))
+        return {"FINISHED"}
+
+    def get_active_camera(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        if props.use_active_camera:
+            return context.scene.camera
+        else:
+            return props.selected_camera
+
+    def get_camera_data(self, camera):
+        # Get camera position
+        position = camera.matrix_world.to_translation()
+
+        # Get camera direction
+        direction = camera.matrix_world.to_quaternion() @ Vector((0, 0, -1))
+        direction.normalize()
+
+        return (position.x, position.y, position.z), (direction.x, direction.y, direction.z)
+
+    def getResolution(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        resolution_x = props.radiance_resolution_x
+        resolution_y = props.radiance_resolution_y
+        return resolution_x, resolution_y
+
+
+def save_obj2mesh_output(inp: Union[bytes, str, Path], output_file: str, **kwargs):
+    output_bytes = pr.obj2mesh(inp, **kwargs)
+
+    with open(output_file, "wb") as f:
+        f.write(output_bytes)
+    return output_file
+
+
+class ImportTrueNorth(bpy.types.Operator):
+    bl_idname = "bim.import_true_north"
+    bl_label = "Import True North"
+    bl_description = "Imports the True North from your IFC geometric context"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if not tool.Ifc.get():
+            return False
+        if not SolarData.is_loaded:
+            SolarData.load()
+        return SolarData.data["true_north"] is not None
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        for context in tool.Ifc.get().by_type("IfcGeometricRepresentationContext", include_subtypes=False):
+            if not context.TrueNorth:
+                continue
+            value = context.TrueNorth.DirectionRatios
+            props.true_north = radians(ifcopenshell.util.geolocation.yaxis2angle(*value[:2]))
+        return {"FINISHED"}
+
+
+class ImportLatLong(bpy.types.Operator):
+    bl_idname = "bim.import_lat_long"
+    bl_label = "Import Latitude / Longitude"
+    bl_description = "Imports the latitude / longitude from an IfcSite"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        site = tool.Ifc.get().by_id(int(props.sites))
+        if site.RefLatitude and site.RefLongitude:
+            props.latitude = ifcopenshell.util.geolocation.dms2dd(*site.RefLatitude)
+            props.longitude = ifcopenshell.util.geolocation.dms2dd(*site.RefLongitude)
+        return {"FINISHED"}
+
+
+class MoveSunPathTo3DCursor(bpy.types.Operator):
+    bl_idname = "bim.move_sun_path_to_3d_cursor"
+    bl_label = "Move Sun Path To 3D Cursor"
+    bl_description = "Shifts the visualisation of the Sun Path to the 3D cursor"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        assert context.scene
+        props.sun_path_origin = context.scene.cursor.location
+        tool.Blender.update_viewport()
+        return {"FINISHED"}
+
+
+class ViewFromSun(bpy.types.Operator):
+    bl_idname = "bim.view_from_sun"
+    bl_label = "View From Sun"
+    bl_description = "Views your model as if you were looking from the perspective of the sun"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        if not (camera := bpy.data.objects.get("SunPathCamera")):
+            camera = bpy.data.objects.new("SunPathCamera", bpy.data.cameras.new("SunPathCamera"))
+            assert isinstance(camera.data, bpy.types.Camera)
+            assert context.scene
+            camera.data.type = "ORTHO"
+            camera.data.ortho_scale = 100  # The default of 6m is too small
+            context.scene.collection.objects.link(camera)
+        tool.Blender.activate_camera(camera)
+        props = tool.Blender.get_solar_props()
+        props.hour = props.hour  # Just to refresh camera position
+        return {"FINISHED"}
+
+
+class LightPickCoordinates(bpy.types.Operator):
+    bl_idname = "bim.light_pick_coordinates"
+    bl_label = "Pick Coordinates"
+    bl_description = (
+        "Open web browser with Google Maps to pick coordinates (Right Mouse Click in maps to copy selected location).\n\n"
+        "ALT+Click to insert current location based on the current IP-address (using ip-api.com)."
+    )
+    bl_options = {"REGISTER", "UNDO"}
+
+    use_current_location: bpy.props.BoolProperty(options={"SKIP_SAVE"})
+
+    if TYPE_CHECKING:
+        use_current_location: bool
+
+    def invoke(self, context, event):
+        if event.alt:
+            self.use_current_location = True
+        return self.execute(context)
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        if not self.use_current_location:
+            zoom = 13.5
+            url = f"https://www.google.com/maps/@{props.latitude},{props.longitude},{zoom}z"
+            webbrowser.open(url)
+            return {"FINISHED"}
+
+        response = requests.get("http://ip-api.com/json/")
+        data = response.json()
+        props.latitude = data["lat"]
+        props.longitude = data["lon"]
+        return {"FINISHED"}
+
+
+class LightSetTimeToNow(bpy.types.Operator):
+    bl_idname = "bim.light_set_time_to_now"
+    bl_label = "Now"
+    bl_description = "Set time to current local time."
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        props = tool.Blender.get_solar_props()
+        props.set_from_datetime(datetime.now())
+        return {"FINISHED"}
+
+
+class RefreshIFCMaterials(bpy.types.Operator):
+    bl_idname = "bim.refresh_ifc_materials"
+    bl_label = "Refresh IFC Materials"
+    bl_description = "Refresh the list of IFC materials for mapping"
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        ifc_file: ifcopenshell.file
+        ifc_file = tool.Ifc.get() if props.should_load_from_memory else ifcopenshell.open(props.ifc_file)
+
+        props.materials.clear()
+
+        for style in ifc_file.by_type("IfcSurfaceStyle"):
+            for render_item in style.Styles:
+                if render_item.is_a("IfcSurfaceStyleRendering"):
+                    style_id = f"IfcSurfaceStyleRendering-{render_item.id()}"
+                    style_name = style.Name or f"Unnamed Style {render_item.id()}"
+
+                    # Extract color and transparency
+                    color = (1.0, 1.0, 1.0)  # Default white
+                    transparency = 0.0  # Default opaque
+                    if render_item.SurfaceColour:
+                        color = (
+                            render_item.SurfaceColour.Red,
+                            render_item.SurfaceColour.Green,
+                            render_item.SurfaceColour.Blue,
+                        )
+                    if hasattr(render_item, "Transparency") and render_item.Transparency is not None:
+                        transparency = render_item.Transparency
+
+                    # Add material with color
+                    material = props.add_material_mapping(style_id, style_name)
+                    material.color = color
+
+                    # If transparency is high, consider it as glass
+                    if transparency > 0.5:
+                        material.category = "Glass"
+                        material.subcategory = "Clear Glass"
+                        material.is_mapped = True
+
+        props.active_material_index = 0 if props.materials else -1
+
+        self.report({"INFO"}, f"Refreshed {len(props.materials)} IFC materials")
+        return {"FINISHED"}
+
+
+class UnmapMaterial(bpy.types.Operator):
+    bl_idname = "bim.unmap_material"
+    bl_label = "Unmap Material"
+    bl_options = {"REGISTER", "UNDO"}
+
+    material_index: bpy.props.IntProperty()
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        material = props.materials[self.material_index]
+        props.unmap_material(material.name)
+        return {"FINISHED"}
+
+
+class RADIANCE_OT_select_camera(bpy.types.Operator):
+    bl_idname = "radiance.select_camera"
+    bl_label = "Select Camera"
+    bl_description = "Select a camera from the viewport"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        return context.object is not None and context.object.type == "CAMERA"
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        props.selected_camera = context.object
+        props.use_active_camera = False
+        return {"FINISHED"}
+
+
+class RADIANCE_OT_export_material_mappings(bpy.types.Operator, ExportHelper):
+    bl_idname = "radiance.export_material_mappings"
+    bl_label = "Export Material Mappings"
+    bl_description = "Export material mappings to a JSON file"
+
+    filename_ext = ".json"
+    filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        mappings = {}
+
+        for material in props.materials:
+            if material.is_mapped:
+                mappings[material.style_id] = {
+                    "name": material.name,
+                    "category": material.category,
+                    "subcategory": material.subcategory,
+                }
+
+        with open(self.filepath, "w") as f:
+            json.dump(mappings, f, indent=4)
+
+        self.report({"INFO"}, f"Material mappings exported to {self.filepath}")
+        return {"FINISHED"}
+
+
+class RADIANCE_OT_import_material_mappings(bpy.types.Operator, ImportHelper):
+    bl_idname = "radiance.import_material_mappings"
+    bl_label = "Import Material Mappings"
+    bl_description = "Import material mappings from a JSON file"
+
+    filename_ext = ".json"
+
+    def execute(self, context):
+        props = tool.Blender.get_radiance_exporter_props()
+        props.import_mappings(self.filepath)
+        self.report({"INFO"}, f"Material mappings imported from {self.filepath}")
+        return {"FINISHED"}
+
+
+class RADIANCE_OT_open_spectraldb(bpy.types.Operator):
+    bl_idname = "radiance.open_spectraldb"
+    bl_label = "Open SpectralDB"
+    bl_description = "Open the SpectralDB website for reference"
+
+    def execute(self, context):
+        webbrowser.open("https://spectraldb.com")
+        return {"FINISHED"}

src/bonsai/bonsai/bim/module/light/prepare.py

@@ -1,741 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-import math
-import os
-import threading
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Union
-
-import bpy
-import pyradiance as pr
-from mathutils import Vector
-
-import bonsai.tool as tool
-from bonsai.bim.module.light.prop import spectraldb
-from bonsai.bim.module.light.shared import ifc_materials, linked_model_exports
-
-
-def _matrix_to_xform_args(matrix: list[list[float]]) -> str:
-    """Decompose a 4x4 matrix into Radiance xform arguments.
-
-    Decomposes into Z/Y/X Euler rotations + translation.
-    The matrix is expected in row-major format (Blender convention).
-    xform applies transforms right-to-left, so we write: -rx X -ry Y -rz Z -t tx ty tz
-    """
-    from mathutils import Matrix as MMatrix
-
-    m = MMatrix(matrix)
-    translation = m.to_translation()
-    euler = m.to_euler("XYZ")
-
-    parts = []
-    rx = math.degrees(euler.x)
-    ry = math.degrees(euler.y)
-    rz = math.degrees(euler.z)
-
-    if abs(rx) > 1e-6:
-        parts.append(f"-rx {rx:.6f}")
-    if abs(ry) > 1e-6:
-        parts.append(f"-ry {ry:.6f}")
-    if abs(rz) > 1e-6:
-        parts.append(f"-rz {rz:.6f}")
-
-    parts.append(f"-t {translation.x:.6f} {translation.y:.6f} {translation.z:.6f}")
-
-    return " ".join(parts)
-
-
-def save_obj2mesh_output(inp: Union[bytes, str, Path], output_file: str, **kwargs):
-    try:
-        output_bytes = pr.obj2mesh(inp, **kwargs)
-        with open(output_file, "wb") as f:
-            f.write(output_bytes)
-        return output_file
-    except Exception as e:
-        print(f"ERROR in obj2mesh conversion:")
-        print(f"  Input file: {inp}")
-        print(f"  Output file: {output_file}")
-        print(f"  Additional args: {kwargs}")
-        print(f"  Error: {str(e)}")
-        raise
-
-
-def convert_ies_to_radiance(
-    ies_file_path: str,
-    output_dir: str,
-    lamp_type: str = "",
-    lamp_color: tuple[float, float, float] = (1.0, 1.0, 1.0),
-    multiply_factor: float = 1.0,
-    radius: float = 0.0,
-) -> tuple[str, str]:
-    """Convert IES file to Radiance format using pyradiance.
-
-    Args:
-        ies_file_path: Path to the .ies file
-        output_dir: Directory where .rad and .dat files will be saved
-        lamp_type: Type of lamp (e.g., 'LED', 'metal halide')
-        lamp_color: RGB color tuple (0.0-1.0 each)
-        multiply_factor: Brightness multiplier (0.1-10.0)
-        radius: Illum sphere radius (0 = use IES geometry)
-
-    Returns:
-        Tuple of (rad_file_path, dat_file_path)
-    """
-    try:
-        ies_path = Path(bpy.path.abspath(ies_file_path))
-        base_name = ies_path.stem
-
-        output_path = os.path.join(output_dir, base_name)
-
-        kwargs = {"outname": output_path}
-
-        if lamp_type:
-            kwargs["lamp_type"] = lamp_type
-
-        if lamp_color != (1.0, 1.0, 1.0):
-            kwargs["lamp_color"] = lamp_color
-
-        if multiply_factor != 1.0:
-            kwargs["multiply_factor"] = multiply_factor
-
-        if radius > 0.0:
-            kwargs["radius"] = radius
-
-        pr.ies2rad(ies_path, **kwargs)
-
-        rad_file = os.path.join(output_dir, f"{base_name}.rad")
-        dat_file = os.path.join(output_dir, f"{base_name}.dat")
-
-        return rad_file, dat_file
-
-    except Exception as e:
-        raise RuntimeError(f"Failed to convert IES file '{ies_file_path}': {str(e)}")
-
-
-class PrepareRadianceScene(bpy.types.Operator):
-    """Prepares the Radiance scene (runs heavy work in background thread)"""
-
-    bl_idname = "scene.prepare_radiance"
-    bl_label = "Prepare Radiance Scene"
-    bl_description = "Prepares the Radiance scene by creating necessary files and setting up the view"
-
-    _timer = None
-    _thread: Union[threading.Thread, None] = None
-    _error: Union[str, None] = None
-    _start_time: float = 0.0
-
-    @classmethod
-    def poll(cls, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        if props.is_preparing:
-            cls.poll_message_set("Scene preparation is already in progress.")
-            return False
-        return True
-
-    def get_camera_data(self, camera):
-        position = camera.matrix_world.to_translation()
-
-        direction = camera.matrix_world.to_quaternion() @ Vector((0, 0, -1))
-        direction.normalize()
-
-        up = camera.matrix_world.to_quaternion() @ Vector((0, 1, 0))
-        up.normalize()
-
-        if abs(direction.dot(up)) > 0.99:
-            if abs(direction.dot(Vector((0, 1, 0)))) > 0.99:
-                reference = Vector((1, 0, 0))
-            else:
-                reference = Vector((0, 1, 0))
-            right = direction.cross(reference)
-            if right.length < 0.01:
-                reference = Vector((0, 0, 1))
-                right = direction.cross(reference)
-            right.normalize()
-            up = right.cross(direction)
-            up.normalize()
-
-        if up.length < 0.01:
-            up = Vector((0, 0, 1))
-        else:
-            up.normalize()
-
-        return (
-            (position.x, position.y, position.z),
-            (direction.x, direction.y, direction.z),
-            (up.x, up.y, up.z),
-        )
-
-    def execute(self, context):
-        print("Starting Radiance scene preparation...")
-        props = tool.Blender.get_radiance_exporter_props()
-        output_dir = props.output_dir
-
-        obj_file_path = os.path.join(output_dir, "model.obj")
-        if not os.path.exists(obj_file_path):
-            error_msg = "OBJ file not found. Please run 'Export Geometry for Simulation' first."
-            self.report({"ERROR"}, error_msg)
-            print(f"ERROR: {error_msg}")
-            print(f"  Expected file: {obj_file_path}")
-            return {"CANCELLED"}
-
-        resolution_x, resolution_y = props.radiance_resolution_x, props.radiance_resolution_y
-
-        assert context.scene
-        context.scene.render.resolution_x = resolution_x
-        context.scene.render.resolution_y = resolution_y
-
-        aspect_ratio = resolution_x / resolution_y
-        use_hdr = props.use_hdr
-        choose_hdr_image = props.choose_hdr_image
-
-        print(f"Resolution: {resolution_x}x{resolution_y}")
-        print(f"Output directory: {output_dir}")
-        print(f"Found OBJ file: {obj_file_path} ({os.path.getsize(obj_file_path)} bytes)")
-
-        hdr_image_path = ""
-        hdr_mask_path = ""
-        sky_map_cal_path = ""
-        if use_hdr:
-            hdr_image_path = os.path.join(os.path.dirname(__file__), "HDRs", "noon_grass_2k.hdr")
-            hdr_mask_path = os.path.join(os.path.dirname(__file__), "HDRs", "noon_grass_2k_mask.hdr")
-            sky_map_cal_path = os.path.join(os.path.dirname(__file__), "HDRs", "skymap.cal")
-
-        sky_file_path = os.path.join(output_dir, "sky.rad")
-
-        print("Setting up camera...")
-        if props.use_active_camera:
-            camera = context.scene.camera
-        else:
-            camera = props.selected_camera
-
-        if camera is None:
-            self.report({"ERROR"}, "No active camera found in the scene. Please add a camera and set it as active.")
-            return {"CANCELLED"}
-
-        camera_position, camera_direction, camera_up = self.get_camera_data(camera)
-        camera_type = camera.data.type
-        camera_fov = camera.data.angle if camera_type == "PERSP" else 0.0
-        camera_ortho_scale = camera.data.ortho_scale if camera_type == "ORTHO" else 0.0
-
-        print(f"Camera position: {camera_position}")
-        print(f"Camera direction: {camera_direction}")
-        print(f"Camera up: {camera_up}")
-
-        # Collect sky generation data (must be on main thread)
-        sky_data = None
-        if props.use_sun:
-            sun_props = tool.Blender.get_solar_props()
-            sun_pos_props = tool.Blender.get_sun_props()
-            if not sun_pos_props:
-                self.report(
-                    {"ERROR"}, "Sun position addon not available. Enable 'Sun Position' addon or disable 'Use Sun'."
-                )
-                return {"CANCELLED"}
-
-            sky_data = {
-                "year": sun_props.year,
-                "month": sun_props.month,
-                "day": sun_props.day,
-                "hour": sun_props.hour,
-                "minute": sun_props.minute,
-                "latitude": sun_props.latitude,
-                "longitude": sun_props.longitude,
-                "UTC_zone": sun_props.UTC_zone,
-                "sun_year": sun_pos_props.year,
-                "sky_condition": props.sky_condition,
-                "ground_reflectance": props.ground_reflectance,
-                "turbidity": props.turbidity,
-            }
-
-        # Collect IES light data (must be on main thread)
-        ies_light_data = []
-        for idx, ies_light in enumerate(props.ies_lights):
-            if not ies_light.is_enabled or not ies_light.ies_file_path:
-                ies_light_data.append(None)
-                continue
-
-            target_empties = ies_light.get_target_empties()
-            if not target_empties:
-                ies_light_data.append(None)
-                continue
-
-            positions = []
-            for obj in target_empties:
-                try:
-                    positions.append((obj.location.x, obj.location.y, obj.location.z))
-                except ReferenceError:
-                    continue
-
-            if not positions:
-                ies_light_data.append(None)
-                continue
-
-            ies_light_data.append(
-                {
-                    "ies_file_path": ies_light.ies_file_path,
-                    "lamp_type": ies_light.lamp_type,
-                    "lamp_color": ies_light.lamp_color,
-                    "multiply_factor": ies_light.multiply_factor,
-                    "radius": ies_light.radius,
-                    "rotation_z": ies_light.rotation_z,
-                    "positions": positions,
-                    "is_enabled": ies_light.is_enabled,
-                }
-            )
-
-        # Collect material mapping data (must be on main thread)
-        material_mappings = []
-        for m in props.materials:
-            material_mappings.append(
-                {
-                    "style_id": m.style_id,
-                    "is_mapped": m.is_mapped,
-                    "category": m.category,
-                    "subcategory": m.subcategory,
-                }
-            )
-
-        linked_exports_snapshot = list(linked_model_exports)
-
-        # All Blender data collected — now launch background thread
-        props.is_preparing = True
-        self._start_time = time.time()
-        self._error = None
-
-        import bonsai.bim.module.light.shared as shared
-
-        shared.scene = None
-
-        self._thread = threading.Thread(
-            target=self._prepare_worker,
-            args=(
-                output_dir,
-                obj_file_path,
-                sky_file_path,
-                use_hdr,
-                choose_hdr_image,
-                hdr_image_path,
-                hdr_mask_path,
-                sky_map_cal_path,
-                sky_data,
-                ies_light_data,
-                material_mappings,
-                linked_exports_snapshot,
-                camera_position,
-                camera_direction,
-                camera_up,
-                camera_type,
-                camera_fov,
-                camera_ortho_scale,
-                aspect_ratio,
-            ),
-            daemon=True,
-        )
-        self._thread.start()
-
-        wm = context.window_manager
-        self._timer = wm.event_timer_add(0.5, window=context.window)
-        wm.modal_handler_add(self)
-
-        self.report({"INFO"}, "Scene preparation started in background...")
-        context.window.cursor_set("WAIT")
-        return {"RUNNING_MODAL"}
-
-    def _prepare_worker(
-        self,
-        output_dir,
-        obj_file_path,
-        sky_file_path,
-        use_hdr,
-        choose_hdr_image,
-        hdr_image_path,
-        hdr_mask_path,
-        sky_map_cal_path,
-        sky_data,
-        ies_light_data,
-        material_mappings,
-        linked_exports_snapshot,
-        camera_position,
-        camera_direction,
-        camera_up,
-        camera_type,
-        camera_fov,
-        camera_ortho_scale,
-        aspect_ratio,
-    ):
-        """Runs in a background thread — no Blender API calls allowed here."""
-        try:
-            self._do_prepare(
-                output_dir,
-                obj_file_path,
-                sky_file_path,
-                use_hdr,
-                choose_hdr_image,
-                hdr_image_path,
-                hdr_mask_path,
-                sky_map_cal_path,
-                sky_data,
-                ies_light_data,
-                material_mappings,
-                linked_exports_snapshot,
-                camera_position,
-                camera_direction,
-                camera_up,
-                camera_type,
-                camera_fov,
-                camera_ortho_scale,
-                aspect_ratio,
-            )
-        except Exception as e:
-            self._error = str(e)
-            import traceback
-
-            traceback.print_exc()
-
-    def _do_prepare(
-        self,
-        output_dir,
-        obj_file_path,
-        sky_file_path,
-        use_hdr,
-        choose_hdr_image,
-        hdr_image_path,
-        hdr_mask_path,
-        sky_map_cal_path,
-        sky_data,
-        ies_light_data,
-        material_mappings,
-        linked_exports_snapshot,
-        camera_position,
-        camera_direction,
-        camera_up,
-        camera_type,
-        camera_fov,
-        camera_ortho_scale,
-        aspect_ratio,
-    ):
-        """The actual preparation logic (no Blender API)."""
-        import bonsai.bim.module.light.shared as shared
-
-        # --- Generate sky file ---
-        if sky_data is not None:
-            dt = datetime(sky_data["year"], sky_data["month"], sky_data["day"], sky_data["hour"], sky_data["minute"])
-
-            print(f"Sun position data for Radiance gensky:")
-            print(f"  DateTime: {dt}")
-            print(f"  Latitude: {sky_data['latitude']}°")
-            print(f"  Longitude: {sky_data['longitude']}°")
-
-            sky_condition = sky_data["sky_condition"]
-            longitude_for_gensky = -sky_data["longitude"]
-            timezone_for_gensky = -int(sky_data["UTC_zone"]) * 15
-
-            sky_description = pr.gensky(
-                dt=dt,
-                latitude=sky_data["latitude"],
-                longitude=longitude_for_gensky,
-                year=sky_data["sun_year"],
-                timezone=timezone_for_gensky,
-                sunny_with_sun=sky_condition == "SUNNY_WITH_SUN",
-                sunny_without_sun=sky_condition == "SUNNY_WITHOUT_SUN",
-                cloudy=sky_condition == "CLOUDY",
-                ground_reflectance=sky_data["ground_reflectance"],
-                turbidity=sky_data["turbidity"],
-            )
-
-            sky_description_str = sky_description.decode("utf-8")
-
-            if use_hdr and choose_hdr_image == "Noon":
-                with open(sky_file_path, "w") as f:
-                    f.write(sky_description_str)
-                    f.write("\n")
-                    f.write(
-                        '''void colorpict env_map
-7 red green blue "'''
-                        + hdr_image_path
-                        + '''"  "'''
-                        + sky_map_cal_path
-                        + '''" map_u map_v
-0
-1 0.5
-
-# This is a multiplier to colour balance the env map
-# In this case, it provides a rough ground luminance from 3k-5k
-env_map colorfunc env_colour
-4 100 100 100 .
-0
-0
-
-# .37 .57 1.5 is measured from a HDRI image
-# It is multiplied by a factor such that grey(r,g,b) = 1
-skyfunc colorfunc sky_colour
-4 .64 .99 2.6 .
-0
-0
-
-void mixpict composite
-7 env_colour sky_colour grey "'''
-                        + hdr_mask_path
-                        + '''"  "'''
-                        + sky_map_cal_path
-                        + """" map_u map_v
-0
-2 0.5 1
-
-composite glow env_map_glow
-0
-0
-4 1 1 1 0
-
-env_map_glow source sky
-0
-0
-4 0 0 1 180
-
-env_colour glow ground_glow
-0
-0
-4 1 1 1 0
-
-ground_glow source ground
-0
-0
-4 0 0 -1 180"""
-                    )
-            elif not use_hdr:
-                with open(sky_file_path, "w") as f:
-                    f.write(sky_description_str)
-                    f.write("\n")
-                    f.write("skyfunc glow sky_glow\n0\n0\n4 .9 .9 1.15 0\n")
-                    f.write("sky_glow source sky\n0\n0\n4 0 0 1 180\n")
-                    f.write("skyfunc glow ground_glow\n0\n0\n4 1.4 .9 .6 0\n")
-                    f.write("ground_glow source ground\n0\n0\n4 0 0 -1 180\n")
-        else:
-            print("Skipping sky generation (use_sun is False)...")
-
-        # --- Write materials.rad ---
-        materials_file = os.path.join(output_dir, "materials.rad")
-        written_materials = set()
-
-        all_materials = set(ifc_materials)
-
-        with open(materials_file, "w") as file:
-            default_materials = [
-                "void plastic white\n0\n0\n5 0.8 0.8 0.8 0 0\n",
-            ]
-            for material in default_materials:
-                file.write(material)
-                written_materials.add(material.split()[2])
-
-            for style_id in all_materials:
-                mat_data = next((m for m in material_mappings if m["style_id"] == style_id), None)
-                if mat_data and mat_data["is_mapped"]:
-                    category, subcategory = mat_data["category"], mat_data["subcategory"]
-                    if category in spectraldb and subcategory in spectraldb[category]:
-                        material_def = spectraldb[category][subcategory]
-                        material_name = material_def.split()[2]
-                        if material_name not in written_materials:
-                            file.write(material_def + "\n")
-                            written_materials.add(material_name)
-                        file.write(f"inherit alias {style_id} {material_name}\n")
-                    else:
-                        file.write(f"inherit alias {style_id} white\n")
-                else:
-                    file.write(f"inherit alias {style_id} white\n")
-
-        print(f"Exported Materials Rad file to: {materials_file}")
-
-        # --- Convert IES light files ---
-        print("Processing IES light files...")
-        converted_ies_lights = {}
-        for idx, ies_data in enumerate(ies_light_data):
-            if ies_data is None:
-                continue
-            try:
-                rad_file, dat_file = convert_ies_to_radiance(
-                    ies_data["ies_file_path"],
-                    output_dir,
-                    lamp_type=ies_data["lamp_type"],
-                    lamp_color=ies_data["lamp_color"],
-                    multiply_factor=ies_data["multiply_factor"],
-                    radius=ies_data["radius"],
-                )
-                converted_ies_lights[idx] = (rad_file, dat_file)
-                print(f"  Converted IES light {idx}: {Path(ies_data['ies_file_path']).name}")
-            except Exception as e:
-                print(f"  ERROR converting IES light {idx}: {str(e)}")
-
-        # --- Convert OBJ to RTM ---
-        print(f"OBJ file size: {os.path.getsize(obj_file_path)} bytes")
-        print(f"Materials file size: {os.path.getsize(materials_file)} bytes")
-        print(f"Converting OBJ to RTM format...")
-
-        rtm_file_path = os.path.join(output_dir, "model.rtm")
-        mesh_file_path = save_obj2mesh_output(obj_file_path, rtm_file_path, matfiles=[materials_file])
-        print(f"obj2mesh output: {mesh_file_path}")
-
-        # Convert linked model OBJs to RTM
-        linked_rtm_files = []
-        for link_idx, (link_obj_path, link_mtl_path, link_matrix) in enumerate(linked_exports_snapshot):
-            if not os.path.exists(link_obj_path):
-                print(f"Linked model OBJ not found: {link_obj_path}")
-                continue
-            link_rtm_path = os.path.join(output_dir, f"linked_{link_idx}.rtm")
-            try:
-                save_obj2mesh_output(link_obj_path, link_rtm_path, matfiles=[materials_file])
-                linked_rtm_files.append((link_rtm_path, link_matrix))
-                print(f"Converted linked model {link_idx} to RTM")
-            except Exception as e:
-                print(f"Failed to convert linked model {link_idx} to RTM: {e}")
-
-        # --- Write scene.rad ---
-        scene_file = os.path.join(output_dir, "scene.rad")
-        with open(scene_file, "w") as file:
-            file.write('void mesh model\n1 "' + rtm_file_path + '"\n0\n0\n')
-            file.write("\n")
-
-            if linked_rtm_files:
-                file.write("\n# Linked Models\n")
-                for link_idx, (link_rtm_path, link_matrix) in enumerate(linked_rtm_files):
-                    is_identity = all(
-                        abs(link_matrix[i][j] - (1.0 if i == j else 0.0)) < 1e-6 for i in range(4) for j in range(4)
-                    )
-
-                    if is_identity:
-                        file.write(f'void mesh linked_{link_idx}\n1 "{link_rtm_path}"\n0\n0\n\n')
-                        print(f"Added linked model {link_idx} to scene (identity, inline mesh)")
-                    else:
-                        link_rad_path = os.path.join(output_dir, f"linked_{link_idx}.rad")
-                        with open(link_rad_path, "w") as link_file:
-                            link_file.write(f'void mesh linked_{link_idx}\n1 "{link_rtm_path}"\n0\n0\n')
-
-                        xform_args = _matrix_to_xform_args(link_matrix)
-                        file.write(f'!xform {xform_args} "{link_rad_path}"\n')
-                        print(f"Added linked model {link_idx} to scene with xform: {xform_args}")
-
-            # IES light fixtures
-            if ies_light_data:
-                file.write("\n# IES Light Fixtures\n")
-                for idx, ies_data in enumerate(ies_light_data):
-                    if ies_data is None:
-                        continue
-                    z_rot = math.degrees(ies_data["rotation_z"])
-
-                    for pos in ies_data["positions"]:
-                        if idx in converted_ies_lights:
-                            rad_path = converted_ies_lights[idx][0]
-                            rad_filename = Path(rad_path).name
-                            file.write(f'!xform -rz {z_rot} -t {pos[0]} {pos[1]} {pos[2]} "{rad_filename}"\n')
-                        else:
-                            rad_base = Path(ies_data["ies_file_path"]).stem
-                            rad_filename = f"{rad_base}.rad"
-                            file.write(f'# !xform -rz {z_rot} -t {pos[0]} {pos[1]} {pos[2]} "{rad_filename}"\n')
-
-        print(f"Exported Scene file to: {scene_file}")
-
-        # --- Validate light sources ---
-        has_sky = sky_data is not None
-        has_ies_lights = len(converted_ies_lights) > 0
-
-        if not has_sky and not has_ies_lights:
-            raise RuntimeError("No light sources available. Please enable 'Use Sun' or add and map IES light fixtures.")
-
-        # --- Build pr.Scene ---
-        print("Setting up Radiance scene...")
-        new_scene = pr.Scene("ascene")
-
-        material_path = os.path.join(output_dir, "materials.rad")
-        scene_path = os.path.join(output_dir, "scene.rad")
-
-        new_scene.add_material(material_path)
-        new_scene.add_surface(scene_path)
-
-        if has_sky:
-            new_scene.add_source(sky_file_path)
-            print(f"Added sky light source")
-
-        if has_ies_lights:
-            print(f"Added {len(converted_ies_lights)} IES light source(s)")
-
-        print("Setting up view...")
-        if camera_type == "PERSP":
-            vertical_fov = 2 * math.atan(math.tan(camera_fov / 2) / aspect_ratio)
-            aview = pr.create_default_view()
-            aview.type = "v"
-            aview.vp = camera_position
-            aview.vdir = camera_direction
-            aview.vu = camera_up
-            aview.horiz = math.degrees(camera_fov)
-            aview.vert = math.degrees(vertical_fov)
-        else:
-            view_width = camera_ortho_scale
-            view_height = camera_ortho_scale / aspect_ratio
-            aview = pr.create_default_view()
-            aview.type = "l"
-            aview.vp = camera_position
-            aview.vdir = camera_direction
-            aview.vu = camera_up
-            aview.horiz = view_width
-            aview.vert = view_height
-
-        new_scene.add_view(aview)
-
-        # Set the global scene reference (thread-safe assignment)
-        shared.scene = new_scene
-        print("Scene preparation complete.")
-
-    def modal(self, context, event):
-        if event.type == "TIMER":
-            if self._thread is not None and self._thread.is_alive():
-                return {"RUNNING_MODAL"}
-
-            # Thread finished — clean up
-            self._cleanup_timer(context)
-            props = tool.Blender.get_radiance_exporter_props()
-            props.is_preparing = False
-            context.window.cursor_set("DEFAULT")
-
-            if self._error:
-                self.report({"ERROR"}, f"Scene preparation failed: {self._error}")
-                return {"CANCELLED"}
-
-            elapsed = time.time() - self._start_time
-            self.report({"INFO"}, f"Radiance scene prepared successfully in {elapsed:.1f}s")
-            print(f"Scene preparation completed in {elapsed:.2f} seconds")
-            return {"FINISHED"}
-
-        elif event.type == "ESC":
-            self._cleanup_timer(context)
-            props = tool.Blender.get_radiance_exporter_props()
-            props.is_preparing = False
-            context.window.cursor_set("DEFAULT")
-            self.report({"WARNING"}, "Scene preparation cannot be cancelled mid-operation")
-            return {"RUNNING_MODAL"}
-
-        return {"PASS_THROUGH"}
-
-    def _cleanup_timer(self, context):
-        if self._timer is not None:
-            context.window_manager.event_timer_remove(self._timer)
-            self._timer = None

src/bonsai/bonsai/bim/module/light/prop.py

@@ -16,7 +16,6 @@
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
-import calendar
 import datetime
 import json
 import os
@@ -44,6 +43,7 @@ from bonsai.bim.module.light.data import SolarData
 from bonsai.bim.module.light.decorator import SolarDecorator
 
 sun_position = tool.Blender.get_addon("sun_position")
+now = datetime.datetime.now()
 
 with open(os.path.join(os.path.dirname(__file__), "spectraldb.json"), "r") as f:
     spectraldb: dict[str, dict[str, str]] = json.load(f)
@@ -72,8 +72,8 @@ def update_coordinates(self: "BIMSolarProperties", context: bpy.types.Context) -
 def update_latlong(self: "BIMSolarProperties", context: bpy.types.Context) -> None:
     sun_props = tool.Blender.get_sun_props()
     assert sun_props
-    sun_props.longitude = self.longitude
-    sun_props.latitude = self.latitude
+    sun_props.longitude = sun_props.longitude
+    sun_props.latitude = sun_props.latitude
     self["coordinates"] = sun_props.coordinates
     update_sun_path(self)
 
@@ -135,14 +135,6 @@ def update_resolution(self: "RadianceExporterProperties", context: bpy.types.Con
     context.scene.render.resolution_y = self.radiance_resolution_y
 
 
-def update_day(self: "BIMSolarProperties", context: bpy.types.Context) -> None:
-    """Clamp the day to the valid range for the current month/year."""
-    max_day = calendar.monthrange(self.year, self.month)[1]
-    if self.day > max_day:
-        self["day"] = max_day
-    update_sun_path(self)
-
-
 def update_sun_path(self: "BIMSolarProperties", context: Union[bpy.types.Context, None] = None) -> None:
     if not SolarData.is_loaded:
         SolarData.load()
@@ -160,13 +152,9 @@ def update_sun_path(self: "BIMSolarProperties", context: Union[bpy.types.Context
     sun_props.sun_distance = self.sun_path_size
     sun_props.latitude = self.latitude
     sun_props.longitude = self.longitude
-    # Clamp day to valid range for the current month/year
-    max_day = calendar.monthrange(self.year, self.month)[1]
-    day = min(self.day, max_day)
-
     sun_props.year = self.year
     sun_props.month = self.month
-    sun_props.day = day
+    sun_props.day = self.day
     sun_props.time = self.hour + (self.minute / 60)
     # Preserve IFC sign convention
     sun_props.north_offset = self.true_north * -1
@@ -193,11 +181,8 @@ def update_sun_path(self: "BIMSolarProperties", context: Union[bpy.types.Context
     )
     sun_vector = sun_position.sun_calc.get_sun_vector(azimuth, elevation) * sun_props.sun_distance
     props.sun_position = sun_vector
-
-    # Update Blender viewport light direction for shadow visualization
-    # This coordinate transformation converts from sun_position addon's coordinate system
-    # to Blender's display.light_direction coordinate system
-    # Note: This only affects viewport shading, not the Radiance rendering
+    # sun_vector.z = max(0, sun_vector.z)
+    # Light direction is a bit weird?
     mat = Matrix(((-1.0, 0.0, 0.0, 0.0), (0.0, 0, 1.0, 0.0), (-0.0, -1.0, 0, 0.0), (0.0, 0.0, 0.0, 1.0))).inverted()
     rotation_euler = Euler((elevation - pi / 2, 0, -azimuth))
     rotation_quaternion = rotation_euler.to_quaternion()
@@ -208,9 +193,6 @@ def update_sun_path(self: "BIMSolarProperties", context: Union[bpy.types.Context
 
     assert bpy.context.scene
     assert bpy.context.scene.display
-    # Set viewport light direction based on sun position
-    # If sun is below horizon (z < 0), use default upward direction
-    # Otherwise, use calculated direction from sun position
     if sun_vector.z < 0:
         bpy.context.scene.display.light_direction = mat @ Vector((0, 0, 1))
     else:
@@ -241,106 +223,6 @@ class RadianceMaterial(PropertyGroup):
         color: tuple[float, float, float]
 
 
-class IESLight(PropertyGroup):
-    """Represents a mapping between an IES light file and scene Empty objects.
-
-    Supports two targeting modes:
-    - Object mode: target a single Empty object
-    - Collection mode: target all Empty objects in a collection
-    """
-
-    ies_file_path: StringProperty(
-        name="IES File Path",
-        description="Path to the IES luminaire data file",
-        subtype="FILE_PATH",
-        default="",
-    )
-    use_collection: BoolProperty(
-        name="Use Collection",
-        description="Apply this light to all Empty objects in a collection instead of a single object",
-        default=False,
-    )
-    target_object: PointerProperty(
-        type=bpy.types.Object,
-        name="Target Object",
-        description="Empty object where the light fixture will be placed",
-        poll=lambda self, obj: obj.type == "EMPTY",
-    )
-    target_collection: PointerProperty(
-        type=bpy.types.Collection,
-        name="Target Collection",
-        description="Collection of Empty objects where the light fixture will be placed",
-    )
-    rotation_z: FloatProperty(
-        name="Rotation Z",
-        description="Rotation around Z-axis in degrees (-180 to 180)",
-        min=-180.0,
-        max=180.0,
-        default=0.0,
-        subtype="ANGLE",
-    )
-    is_enabled: BoolProperty(
-        name="Enabled",
-        description="Include this light in the Radiance export",
-        default=True,
-    )
-
-    # Additional lamp properties for customization
-    lamp_type: StringProperty(
-        name="Lamp Type",
-        description="Type of lamp (e.g., 'LED', 'metal halide', 'fluorescent')",
-        default="",
-    )
-    lamp_color: FloatVectorProperty(
-        name="Lamp Color",
-        description="Lamp color (RGB) for custom color adjustments",
-        subtype="COLOR",
-        default=(1.0, 1.0, 1.0),
-        min=0.0,
-        max=1.0,
-        size=3,
-    )
-    multiply_factor: FloatProperty(
-        name="Brightness Factor",
-        description="Multiply all output quantities by this factor (0.1 to 10.0)",
-        min=0.1,
-        max=10.0,
-        default=1.0,
-    )
-    radius: FloatProperty(
-        name="Illum Sphere Radius",
-        description="Radius of illum sphere (ignores geometry from IES file). 0 = use IES geometry",
-        min=0.0,
-        max=10.0,
-        default=0.0,
-    )
-
-    def get_target_empties(self) -> list[bpy.types.Object]:
-        """Return all Empty objects this light targets."""
-        if self.use_collection and self.target_collection is not None:
-            return [obj for obj in self.target_collection.all_objects if obj.type == "EMPTY" and not obj.hide_get()]
-        elif not self.use_collection and self.target_object is not None:
-            try:
-                _ = self.target_object.name
-                if not self.target_object.hide_get():
-                    return [self.target_object]
-            except ReferenceError:
-                pass
-        return []
-
-    if TYPE_CHECKING:
-        ies_file_path: str
-        use_collection: bool
-        target_object: Union[bpy.types.Object, None]
-        target_collection: Union[bpy.types.Collection, None]
-        rotation_z: float
-        is_enabled: bool
-        lamp_type: str
-        lamp_color: tuple[float, float, float]
-        multiply_factor: float
-        radius: float
-
-
 class RadianceExporterProperties(PropertyGroup):
 
     def update_output_dir(self, context) -> None:
@@ -351,9 +233,6 @@ class RadianceExporterProperties(PropertyGroup):
         if self.ifc_file:
             self.ifc_file = bpy.path.abspath(self.ifc_file)
 
-    def get_categories(self, context):
-        return sorted([(k, k, "") for k in spectraldb.keys()])
-
     def add_material_mapping(self, style_id: str, style_name: str) -> RadianceMaterial:
         item = self.materials.add()
         item.name = style_name
@@ -368,10 +247,7 @@ class RadianceExporterProperties(PropertyGroup):
             mappings = json.load(f)
 
         for style_id, mapping in mappings.items():
-            # Try matching by style_id first, fall back to name
-            material = self.get_material_mapping_by_id(style_id)
-            if material is None:
-                material = self.get_material_mapping(mapping["name"])
+            material = self.get_material_mapping(mapping["name"])
             if material:
                 material.style_id = style_id
                 material.category = mapping["category"]
@@ -383,14 +259,11 @@ class RadianceExporterProperties(PropertyGroup):
                 new_material.subcategory = mapping["subcategory"]
                 new_material.is_mapped = True
 
-    def get_material_mapping_by_id(self, style_id: str) -> Union[RadianceMaterial, None]:
-        return next((item for item in self.materials if item.style_id == style_id), None)
-
     def get_material_mapping(self, style_name: str) -> Union[RadianceMaterial, None]:
         return next((item for item in self.materials if item.name == style_name), None)
 
     def set_material_mapping(self, style_id: str, style_name: str, category: str, subcategory: str) -> None:
-        item = self.get_material_mapping_by_id(style_id) or self.get_material_mapping(style_name)
+        item = self.get_material_mapping(style_name)
         if item:
             item.category = category
             item.subcategory = subcategory
@@ -406,12 +279,8 @@ class RadianceExporterProperties(PropertyGroup):
             if item.category and item.subcategory
         }
 
-    def unmap_material(self, style_name: str, style_id: str = "") -> None:
-        item = None
-        if style_id:
-            item = self.get_material_mapping_by_id(style_id)
-        if item is None:
-            item = self.get_material_mapping(style_name)
+    def unmap_material(self, style_name: str) -> None:
+        item = self.get_material_mapping(style_name)
         if item:
             item.category = ""
             item.subcategory = ""
@@ -421,14 +290,6 @@ class RadianceExporterProperties(PropertyGroup):
         name="Is Exporting", description="Whether the OBJ export is in progress", default=False
     )
 
-    is_preparing: bpy.props.BoolProperty(
-        name="Is Preparing", description="Whether scene preparation is in progress", default=False
-    )
-
-    is_rendering: bpy.props.BoolProperty(
-        name="Is Rendering", description="Whether a Radiance render is in progress", default=False
-    )
-
     categories = [
         ("Wall", "Wall", ""),
         ("Floor", "Floor", ""),
@@ -455,13 +316,16 @@ class RadianceExporterProperties(PropertyGroup):
             print(f"Material '{active_material.name}' mapped to {self.category} - {self.subcategory}")
 
     category: bpy.props.EnumProperty(
-        items=get_categories, name="Category", description="Material category", update=update_material_mapping
+        items=categories, name="Category", description="Material category", update=update_material_mapping
     )
 
     def get_subcategories(self, context: bpy.types.Context) -> tool.Blender.BLENDER_ENUM_ITEMS:
+        global SUBCATEGORIES_ENUM_ITEMS  # ty: ignore[unresolved-global]
         if self.category in spectraldb:
-            return sorted([(k, k, "") for k in spectraldb[self.category].keys()])
-        return []
+            SUBCATEGORIES_ENUM_ITEMS = [(k, k, "") for k in spectraldb[self.category].keys()]
+        else:
+            SUBCATEGORIES_ENUM_ITEMS = []
+        return SUBCATEGORIES_ENUM_ITEMS
 
     subcategory: bpy.props.EnumProperty(
         items=get_subcategories, name="Subcategory", description="Material subcategory", update=update_material_mapping
@@ -470,9 +334,12 @@ class RadianceExporterProperties(PropertyGroup):
     materials: CollectionProperty(type=RadianceMaterial)
     active_material_index: IntProperty()
 
+    # material_mappings: bpy.props.CollectionProperty(type=bpy.types.PropertyGroup, name="Material Mappings")
+    # material_mappings: CollectionProperty(type=MaterialMapping)
+
     should_load_from_memory: BoolProperty(
         name="Load from Memory",
-        default=True,
+        default=False,
     )
 
     radiance_resolution_x: IntProperty(
@@ -481,13 +348,6 @@ class RadianceExporterProperties(PropertyGroup):
     radiance_resolution_y: IntProperty(
         name="Y", description="Vertical resolution of the output image", default=1080, min=1, update=update_resolution
     )
-    radiance_bin_dir: StringProperty(
-        name="Radiance Bin",
-        description="Path to the Radiance bin folder (containing falsecolor, pcomb, etc.)",
-        default="",
-        subtype="DIR_PATH",
-    )
-
     output_dir: StringProperty(
         name="Output Directory",
         description="Directory to output Radiance files",
@@ -503,15 +363,6 @@ class RadianceExporterProperties(PropertyGroup):
         update=lambda self, context: self.update_ifc_file(context),
     )
 
-    ambient_bounces: IntProperty(
-        name="Ambient Bounces",
-        description="Number of indirect light bounces. Higher = more light fills dark areas but slower. "
-        "1 is minimal, 2-3 recommended for IES-only scenes, 4+ for complex interiors",
-        min=0,
-        max=8,
-        default=2,
-    )
-
     radiance_quality: EnumProperty(
         name="Quality",
         description="Radiance rendering quality",
@@ -542,15 +393,14 @@ class RadianceExporterProperties(PropertyGroup):
         name="Output File Format",
         description="Format of the output image file",
         items=[
-            ("HDR", "HDR", "High Dynamic Range (HDR) file only"),
-            ("HDR_TIFF", "HDR + Tiff", "High Dynamic Range (HDR) and Tiff files"),
+            ("HDR", "HDR + Tiff", "High Dynamic Range"),
         ],
-        default="HDR_TIFF",
+        default="HDR",
     )
 
     use_hdr: BoolProperty(
-        name="HDR Environment Map",
-        description="Use an HDR image as the sky dome for realistic environment lighting and reflections",
+        name="Use HDR",
+        description="Use HDR image format",
         default=True,
     )
 
@@ -563,40 +413,6 @@ class RadianceExporterProperties(PropertyGroup):
         default="Noon",
     )
 
-    use_sun: BoolProperty(
-        name="Use Sun",
-        description="Use sun position data to generate sky. If disabled, generates a default sky without sun",
-        default=True,
-    )
-
-    # Sky generation parameters
-    sky_condition: EnumProperty(
-        name="Sky Condition",
-        description="Type of sky condition to generate",
-        items=[
-            ("SUNNY_WITH_SUN", "Sunny with Sun", "Clear sky with direct sun"),
-            ("SUNNY_WITHOUT_SUN", "Sunny without Sun", "Clear sky without direct sun"),
-            ("CLOUDY", "Cloudy", "Overcast sky condition"),
-        ],
-        default="SUNNY_WITH_SUN",
-    )
-
-    ground_reflectance: FloatProperty(
-        name="Ground Reflectance",
-        description="Ground reflectance value (0.0 to 1.0)",
-        min=0.0,
-        max=1.0,
-        default=0.2,
-    )
-
-    turbidity: FloatProperty(
-        name="Turbidity",
-        description="Atmospheric turbidity (1.0 to 10.0). Lower values = clearer sky",
-        min=1.0,
-        max=10.0,
-        default=3.0,
-    )
-
     use_active_camera: BoolProperty(
         name="Use Active Camera", description="Use the active camera in the scene", default=True
     )
@@ -608,90 +424,8 @@ class RadianceExporterProperties(PropertyGroup):
         poll=lambda self, object: object.type == "CAMERA",
     )
 
-    ies_lights: CollectionProperty(
-        type=IESLight,
-        name="IES Lights",
-        description="Collection of IES light fixtures mapped to scene objects",
-    )
-    active_ies_light_index: IntProperty(
-        name="Active IES Light Index",
-        description="Index of the active IES light in the collection",
-        default=-1,
-    )
-
-    # False color analysis properties
-    use_false_color: BoolProperty(
-        name="Generate False Color Image",
-        description="Generate a false color HDR image for illuminance analysis",
-        default=False,
-    )
-
-    false_color_label: EnumProperty(
-        name="Legend Label Unit",
-        description="Unit for the false color legend",
-        items=[
-            ("fc", "Foot-Candles", "US lighting standard unit"),
-            ("lux", "Lux", "International lighting standard unit"),
-            ("cd/m2", "Candela per m²", "Luminance unit"),
-        ],
-        default="fc",
-    )
-
-    false_color_scale: FloatProperty(
-        name="Scale Factor",
-        description="Maximum scale value for the false color legend",
-        min=0.1,
-        max=100000.0,
-        default=3.0,
-    )
-
-    false_color_steps: IntProperty(
-        name="Legend Steps",
-        description="Number of divisions on the legend. Contour increment = Scale / Steps. "
-        "E.g. Scale=20, Steps=10 → contours at 2, 4, 6, 8...",
-        min=2,
-        max=50,
-        default=10,
-    )
-
-    false_color_contour_lines: BoolProperty(
-        name="Enable Contour Lines",
-        description="Add contour lines to the false color image",
-        default=True,
-    )
-
-    false_color_contour_mode: EnumProperty(
-        name="Contour Mode",
-        description="Contour line display mode",
-        items=[
-            (
-                "WITH_BG",
-                "Contour Lines with Background",
-                "Show contour lines overlaid on the colored false color background",
-            ),
-            ("WITHOUT_BG", "Contour Lines Only", "Show only contour lines without the false color background"),
-        ],
-        default="WITH_BG",
-    )
-
-    false_color_multiplier: FloatProperty(
-        name="Multiplier",
-        description="Conversion multiplier (179.0 for lux, 16.6295 for foot-candles)",
-        min=0.1,
-        max=1000.0,
-        default=16.629505759940542,
-    )
-
-    false_color_output_name: StringProperty(
-        name="False Color Output Name",
-        description="Name of the false color output file (without extension)",
-        default="false_color",
-    )
-
     if TYPE_CHECKING:
         is_exporting: bool
-        is_preparing: bool
-        is_rendering: bool
         category: str
         subcategory: str
         materials: bpy.types.bpy_prop_collection_idprop[RadianceMaterial]
@@ -699,10 +433,8 @@ class RadianceExporterProperties(PropertyGroup):
         should_load_from_memory: bool
         radiance_resolution_x: int
         radiance_resolution_y: int
-        radiance_bin_dir: str
         output_dir: str
         ifc_file: str
-        ambient_bounces: int
         radiance_quality: Literal["LOW", "MEDIUM", "HIGH"]
         radiance_detail: Literal["LOW", "MEDIUM", "HIGH"]
         radiance_variability: Literal["LOW", "MEDIUM", "HIGH"]
@@ -710,22 +442,8 @@ class RadianceExporterProperties(PropertyGroup):
         output_file_format: Literal["HDR"]
         use_hdr: bool
         choose_hdr_image: Literal["Noon"]
-        use_sun: bool
-        sky_condition: Literal["SUNNY_WITH_SUN", "SUNNY_WITHOUT_SUN", "CLOUDY"]
-        ground_reflectance: float
-        turbidity: float
         use_active_camera: bool
         selected_camera: Union[bpy.types.Object, None]
-        ies_lights: bpy.types.bpy_prop_collection_idprop[IESLight]
-        active_ies_light_index: int
-        use_false_color: bool
-        false_color_label: Literal["fc", "lux", "cd/m2"]
-        false_color_scale: float
-        false_color_steps: int
-        false_color_contour_lines: bool
-        false_color_contour_mode: Literal["WITH_BG", "WITHOUT_BG"]
-        false_color_multiplier: float
-        false_color_output_name: str
 
 
 class BIMSolarProperties(PropertyGroup):
@@ -752,12 +470,11 @@ class BIMSolarProperties(PropertyGroup):
     )
     timezone: StringProperty(name="Timezone", default="Etc/GMT")
     true_north: FloatProperty(name="True North", min=-pi, max=pi, subtype="ANGLE", update=update_sun_path)
-    # Defaults are static; use the "Now" button (LightSetTimeToNow) to set current time.
-    year: IntProperty(name="Year", min=1, max=9999, default=2025, update=update_day)
-    month: IntProperty(name="Month", min=1, max=12, default=1, update=update_day)
-    day: IntProperty(name="Date", min=1, max=31, default=1, update=update_day)
-    hour: IntProperty(name="Hour", min=0, max=23, default=12, update=update_sun_path)
-    minute: IntProperty(name="Minute", min=0, max=59, default=0, update=update_sun_path)
+    year: IntProperty(name="Year", min=1, max=9999, default=now.year, update=update_sun_path)
+    month: IntProperty(name="Month", min=1, max=12, default=now.month, update=update_sun_path)
+    day: IntProperty(name="Date", min=1, max=31, default=now.day, update=update_sun_path)
+    hour: IntProperty(name="Hour", min=0, max=23, default=now.hour, update=update_sun_path)
+    minute: IntProperty(name="Minute", min=0, max=59, default=now.minute, update=update_sun_path)
     sun_position: FloatVectorProperty(name="Sun Position", subtype="XYZ", default=(0, 0, 0))
     sun_path_origin: FloatVectorProperty(name="Sun Path Origin", subtype="XYZ", default=(0, 0, 0))
     sun_path_size: FloatProperty(name="Sun Path Size", min=0.1, default=50, update=update_sun_path)

src/bonsai/bonsai/bim/module/light/render.py

@@ -1,328 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-import multiprocessing
-import os
-import subprocess
-import threading
-import time
-from pathlib import Path
-from typing import Union
-
-import bpy
-import pyradiance as pr
-
-import bonsai.bim.module.light.shared as shared
-import bonsai.tool as tool
-
-# pyradiance's bundled Radiance binaries
-_PYRAD_BIN = Path(pr.__file__).parent / "bin"
-
-
-class RadianceRender(bpy.types.Operator):
-    """Radiance Rendering (runs in background thread)"""
-
-    bl_idname = "render_scene.radiance"
-    bl_label = "Render"
-    bl_description = "Renders the scene using Radiance"
-
-    _timer = None
-    _thread: Union[threading.Thread, None] = None
-    _result_image: Union[bytes, None] = None
-    _error: Union[str, None] = None
-    _start_time: float = 0.0
-
-    @classmethod
-    def poll(cls, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        if props.is_rendering:
-            cls.poll_message_set("A render is already in progress.")
-            return False
-        if shared.scene is None:
-            cls.poll_message_set("Radiance scene not prepared. Please run 'Prepare Scene' (Step 2) first.")
-            return False
-        return True
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        resolution_x, resolution_y = props.radiance_resolution_x, props.radiance_resolution_y
-
-        context.scene.render.resolution_x = resolution_x
-        context.scene.render.resolution_y = resolution_y
-
-        quality = props.radiance_quality.upper()
-        detail = props.radiance_detail.upper()
-        variability = props.radiance_variability.upper()
-        ambient_bounces = props.ambient_bounces
-        output_dir = props.output_dir
-
-        props.is_rendering = True
-        self._start_time = time.time()
-        self._result_image = None
-        self._error = None
-
-        self._thread = threading.Thread(
-            target=self._render_worker,
-            args=(shared.scene, output_dir, resolution_x, resolution_y, quality, detail, variability, ambient_bounces),
-            daemon=True,
-        )
-        self._thread.start()
-
-        wm = context.window_manager
-        self._timer = wm.event_timer_add(0.5, window=context.window)
-        wm.modal_handler_add(self)
-
-        self.report({"INFO"}, "Radiance render started in background...")
-        context.window.cursor_set("WAIT")
-        return {"RUNNING_MODAL"}
-
-    def _render_worker(self, render_scene, output_dir, res_x, res_y, quality, detail, variability, ambient_bounces):
-        """Runs in a background thread — no Blender API calls allowed here."""
-        cwd_saved = os.getcwd()
-        try:
-            os.chdir(output_dir)
-            self._result_image = pr.render(
-                render_scene,
-                ambbounce=ambient_bounces,
-                resolution=(res_x, res_y),
-                quality=quality,
-                detail=detail,
-                variability=variability,
-                nproc=multiprocessing.cpu_count(),
-            )
-        except Exception as e:
-            self._error = str(e)
-        finally:
-            os.chdir(cwd_saved)
-
-    def modal(self, context, event):
-        if event.type == "TIMER":
-            if self._thread is not None and self._thread.is_alive():
-                return {"RUNNING_MODAL"}
-
-            self._cleanup_timer(context)
-            props = tool.Blender.get_radiance_exporter_props()
-            props.is_rendering = False
-            context.window.cursor_set("DEFAULT")
-
-            if self._error:
-                self.report({"ERROR"}, f"Radiance render failed: {self._error}")
-                return {"CANCELLED"}
-
-            elapsed = time.time() - self._start_time
-            print(f"Render completed in {elapsed:.2f} seconds")
-
-            output_dir = props.output_dir
-            output_file_name = props.output_file_name
-            output_file_format = props.output_file_format
-
-            output_hdr_path = os.path.join(output_dir, f"{output_file_name}.hdr")
-            print(f"Saving HDR output to: {output_hdr_path}")
-            with open(output_hdr_path, "wb") as wtr:
-                wtr.write(self._result_image)
-
-            if output_file_format == "HDR_TIFF":
-                print("Applying tone mapping...")
-                pcond_image = pr.pcond(hdr=output_hdr_path, human=True)
-                tiff_path = os.path.join(output_dir, f"{output_file_name}.tiff")
-                print(f"Saving TIFF output to: {tiff_path}")
-                pr.ra_tiff(inp=pcond_image, out=tiff_path, lzw=True)
-
-            print("Radiance rendering process completed successfully.")
-            self.report({"INFO"}, f"Radiance rendering completed. HDR Output: {output_hdr_path}")
-            if output_file_format == "HDR_TIFF":
-                self.report({"INFO"}, f"TIFF Output: {tiff_path}")
-
-            for area in context.screen.areas:
-                area.tag_redraw()
-
-            return {"FINISHED"}
-
-        elif event.type == "ESC":
-            self._cleanup_timer(context)
-            props = tool.Blender.get_radiance_exporter_props()
-            props.is_rendering = False
-            context.window.cursor_set("DEFAULT")
-            self.report({"WARNING"}, "Render cancelled by user. Background process may still be running.")
-            return {"CANCELLED"}
-
-        return {"PASS_THROUGH"}
-
-    def _cleanup_timer(self, context):
-        if self._timer is not None:
-            context.window_manager.event_timer_remove(self._timer)
-            self._timer = None
-
-
-class FalseColorRadiance(bpy.types.Operator):
-    """Generate false color HDR image for illuminance analysis"""
-
-    bl_idname = "render_scene.false_color_radiance"
-    bl_label = "Generate False Color Image"
-    bl_description = "Generate a false color HDR image for illuminance analysis"
-
-    @classmethod
-    def poll(cls, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        if not props.output_dir:
-            cls.poll_message_set("Output directory is not set.")
-            return False
-        return True
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        output_dir = props.output_dir
-        output_file_name = props.output_file_name
-
-        hdr_path = os.path.join(output_dir, f"{output_file_name}.hdr")
-        if not os.path.exists(hdr_path):
-            self.report(
-                {"ERROR"},
-                f"HDR file not found at: {hdr_path}. Please run 'Radiance Render' first.",
-            )
-            return {"CANCELLED"}
-
-        fc_scale = (
-            str(int(props.false_color_scale))
-            if props.false_color_scale == int(props.false_color_scale)
-            else str(props.false_color_scale)
-        )
-
-        # Multiplier converts Radiance raw values to display units
-        # fc (foot-candles) = 16.629..., lux & cd/m2 = 179.0
-        multiplier = 179.0 if props.false_color_label in ("lux", "cd/m2") else 16.629505759940542
-
-        print(
-            f"False color parameters: label={props.false_color_label}, scale={fc_scale}, "
-            f"steps={props.false_color_steps}, multiplier={multiplier}, "
-            f"contour={props.false_color_contour_lines}"
-        )
-
-        try:
-            fc_output_name = props.false_color_output_name
-            fc_hdr_path = os.path.join(output_dir, f"{fc_output_name}.hdr")
-
-            # Find falsecolor binary from user-specified Radiance bin directory
-            radiance_bin_dir = os.path.normpath(props.radiance_bin_dir) if props.radiance_bin_dir else ""
-            if radiance_bin_dir:
-                falsecolor_bin = os.path.join(radiance_bin_dir, "falsecolor.exe")
-                if not os.path.exists(falsecolor_bin):
-                    falsecolor_bin = os.path.join(radiance_bin_dir, "falsecolor")
-                if not os.path.exists(falsecolor_bin):
-                    self.report({"ERROR"}, f"falsecolor not found in: {radiance_bin_dir}")
-                    return {"CANCELLED"}
-            else:
-                import shutil
-
-                falsecolor_bin = shutil.which("falsecolor") or shutil.which("falsecolor.exe")
-                if not falsecolor_bin:
-                    self.report(
-                        {"ERROR"}, "Set the Radiance Bin path in False Color settings, or add Radiance to system PATH."
-                    )
-                    return {"CANCELLED"}
-                radiance_bin_dir = os.path.dirname(falsecolor_bin)
-
-            radiance_lib = os.path.join(os.path.dirname(radiance_bin_dir), "lib")
-            print(f"Using falsecolor: {falsecolor_bin}")
-            print(f"Radiance bin: {radiance_bin_dir}, lib: {radiance_lib}")
-
-            cmd = [falsecolor_bin]
-            cmd.extend(["-m", str(multiplier)])
-            cmd.extend(["-s", fc_scale])
-            cmd.extend(["-n", str(props.false_color_steps)])
-            cmd.extend(["-l", props.false_color_label])
-
-            if props.false_color_contour_lines:
-                cmd.append("-cl")
-                if props.false_color_contour_mode == "WITH_BG":
-                    cmd.extend(["-ip", hdr_path])
-                else:
-                    cmd.extend(["-i", hdr_path])
-            else:
-                cmd.extend(["-ip", hdr_path])
-
-            # Setup environment so falsecolor can find pcomb, psign, pcompos etc.
-            env = os.environ.copy()
-            if os.path.exists(radiance_bin_dir):
-                env["PATH"] = radiance_bin_dir + os.pathsep + env.get("PATH", "")
-            if os.path.exists(radiance_lib):
-                env["RAYPATH"] = "." + os.pathsep + radiance_lib
-
-            print(f"Running: {' '.join(cmd)}")
-            # Write output to file via redirection to avoid Windows stdout binary corruption
-            cmd_str = subprocess.list2cmdline(cmd) + f' > "{fc_hdr_path}"'
-            result = subprocess.run(cmd_str, shell=True, stderr=subprocess.PIPE, env=env, cwd=output_dir)
-            if result.returncode != 0:
-                error_msg = result.stderr.decode() if result.stderr else "Unknown error"
-                self.report({"ERROR"}, f"falsecolor failed: {error_msg}")
-                return {"CANCELLED"}
-
-            fc_size = os.path.getsize(fc_hdr_path) if os.path.exists(fc_hdr_path) else 0
-            print(f"False color HDR generated: {fc_hdr_path} ({fc_size} bytes)")
-            self.report({"INFO"}, f"False color image generated: {fc_hdr_path}")
-
-            # Generate TIFF version
-            try:
-                pcond_fc_image = pr.pcond(hdr=fc_hdr_path, human=True)
-                fc_tiff_path = os.path.join(output_dir, f"{fc_output_name}.tiff")
-                pr.ra_tiff(inp=pcond_fc_image, out=fc_tiff_path, lzw=True)
-                print(f"False color TIFF generated: {fc_tiff_path}")
-                self.report({"INFO"}, f"False color TIFF also generated: {fc_tiff_path}")
-            except Exception as e:
-                self.report({"WARNING"}, f"TIFF generation failed: {str(e)}")
-
-            return {"FINISHED"}
-
-        except subprocess.CalledProcessError as e:
-            # Clean up incomplete HDR file on failure
-            if os.path.exists(fc_hdr_path):
-                os.remove(fc_hdr_path)
-            error_msg = f"falsecolor failed: {e.stderr.decode() if e.stderr else str(e)}"
-            self.report({"ERROR"}, error_msg)
-            return {"CANCELLED"}
-        except FileNotFoundError:
-            self.report({"ERROR"}, "falsecolor not found. Please install Radiance and add it to PATH.")
-            return {"CANCELLED"}
-        except Exception as e:
-            self.report({"ERROR"}, f"Failed to generate false color image: {str(e)}")
-            import traceback
-
-            traceback.print_exc()
-            return {"CANCELLED"}
-
-
-class RADIANCE_OT_select_camera(bpy.types.Operator):
-    bl_idname = "radiance.select_camera"
-    bl_label = "Select Camera"
-    bl_description = "Select a camera from the viewport"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        return context.object is not None and context.object.type == "CAMERA"
-
-    def execute(self, context):
-        props = tool.Blender.get_radiance_exporter_props()
-        props.selected_camera = context.object
-        props.use_active_camera = False
-        return {"FINISHED"}
-
-

src/bonsai/bonsai/bim/module/light/shared.py

@@ -1,33 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-"""Shared module-level state for the light/radiance pipeline.
-
-These globals are populated by ExportOBJ, consumed by PrepareRadianceScene,
-and read by RadianceRender. They must live in a shared module so that
-all operator files can access the same state.
-"""
-
-# Collected IFC material names from the most recent export
-ifc_materials: list[str] = []
-
-# The prepared pyradiance Scene object (set by PrepareRadianceScene, read by RadianceRender)
-scene = None
-
-# Info about exported linked models: list of (obj_path, mtl_path, link_matrix_4x4)
-linked_model_exports: list[tuple[str, str, list[list[float]]]] = []

src/bonsai/bonsai/bim/module/light/solar.py

@@ -1,148 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-import webbrowser
-from datetime import datetime
-from math import radians
-from typing import TYPE_CHECKING
-
-import bpy
-import ifcopenshell.util.geolocation
-import requests
-
-import bonsai.tool as tool
-from bonsai.bim.module.light.data import SolarData
-
-
-class ImportTrueNorth(bpy.types.Operator):
-    bl_idname = "bim.import_true_north"
-    bl_label = "Import True North"
-    bl_description = "Imports the True North from your IFC geometric context"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        if not tool.Ifc.get():
-            return False
-        if not SolarData.is_loaded:
-            SolarData.load()
-        return SolarData.data["true_north"] is not None
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        for context in tool.Ifc.get().by_type("IfcGeometricRepresentationContext", include_subtypes=False):
-            if not context.TrueNorth:
-                continue
-            value = context.TrueNorth.DirectionRatios
-            props.true_north = radians(ifcopenshell.util.geolocation.yaxis2angle(*value[:2]))
-        return {"FINISHED"}
-
-
-class ImportLatLong(bpy.types.Operator):
-    bl_idname = "bim.import_lat_long"
-    bl_label = "Import Latitude / Longitude"
-    bl_description = "Imports the latitude / longitude from an IfcSite"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        site = tool.Ifc.get().by_id(int(props.sites))
-        if site.RefLatitude and site.RefLongitude:
-            props.latitude = ifcopenshell.util.geolocation.dms2dd(*site.RefLatitude)
-            props.longitude = ifcopenshell.util.geolocation.dms2dd(*site.RefLongitude)
-        return {"FINISHED"}
-
-
-class MoveSunPathTo3DCursor(bpy.types.Operator):
-    bl_idname = "bim.move_sun_path_to_3d_cursor"
-    bl_label = "Move Sun Path To 3D Cursor"
-    bl_description = "Shifts the visualisation of the Sun Path to the 3D cursor"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        assert context.scene
-        props.sun_path_origin = context.scene.cursor.location
-        tool.Blender.update_viewport()
-        return {"FINISHED"}
-
-
-class ViewFromSun(bpy.types.Operator):
-    bl_idname = "bim.view_from_sun"
-    bl_label = "View From Sun"
-    bl_description = "Views your model as if you were looking from the perspective of the sun"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        if not (camera := bpy.data.objects.get("SunPathCamera")):
-            camera = bpy.data.objects.new("SunPathCamera", bpy.data.cameras.new("SunPathCamera"))
-            assert isinstance(camera.data, bpy.types.Camera)
-            assert context.scene
-            camera.data.type = "ORTHO"
-            camera.data.ortho_scale = 100  # The default of 6m is too small
-            context.scene.collection.objects.link(camera)
-        tool.Blender.activate_camera(camera)
-        props = tool.Blender.get_solar_props()
-        props.hour = props.hour  # Just to refresh camera position
-        return {"FINISHED"}
-
-
-class LightPickCoordinates(bpy.types.Operator):
-    bl_idname = "bim.light_pick_coordinates"
-    bl_label = "Pick Coordinates"
-    bl_description = (
-        "Open web browser with Google Maps to pick coordinates (Right Mouse Click in maps to copy selected location).\n\n"
-        "ALT+Click to insert current location based on the current IP-address (using ip-api.com)."
-    )
-    bl_options = {"REGISTER", "UNDO"}
-
-    use_current_location: bpy.props.BoolProperty(options={"SKIP_SAVE"})  # pyright: ignore[reportRedeclaration]
-
-    if TYPE_CHECKING:
-        use_current_location: bool
-
-    def invoke(self, context, event):
-        if event.alt:
-            self.use_current_location = True
-        return self.execute(context)
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        if not self.use_current_location:
-            zoom = 13.5
-            url = f"https://www.google.com/maps/@{props.latitude},{props.longitude},{zoom}z"
-            webbrowser.open(url)
-            return {"FINISHED"}
-
-        response = requests.get("http://ip-api.com/json/")
-        data = response.json()
-        props.latitude = data["lat"]
-        props.longitude = data["lon"]
-        return {"FINISHED"}
-
-
-class LightSetTimeToNow(bpy.types.Operator):
-    bl_idname = "bim.light_set_time_to_now"
-    bl_label = "Now"
-    bl_description = "Set time to current local time."
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        props = tool.Blender.get_solar_props()
-        props.set_from_datetime(datetime.now())
-        return {"FINISHED"}

src/bonsai/bonsai/bim/module/light/ui.py

@@ -22,97 +22,52 @@ from typing import TYPE_CHECKING
 import bpy
 
 import bonsai.tool as tool
-from bonsai.bim.helper import prop_with_search
 from bonsai.bim.module.light.data import SolarData
 
-# ---------------------------------------------------------------------------
-# Root panel (replaces the old "Radiance Exporter" nested panel)
-# ---------------------------------------------------------------------------
-
 
 class BIM_PT_radiance_exporter(bpy.types.Panel):
+    """Creates a Panel in the render properties window"""
+
     bl_label = "Radiance Exporter"
     bl_idname = "BIM_PT_radiance_exporter"
+    bl_options = {"DEFAULT_CLOSED"}
     bl_space_type = "PROPERTIES"
     bl_region_type = "WINDOW"
     bl_context = "scene"
     bl_parent_id = "BIM_PT_tab_lighting"
-    bl_options = {"HIDE_HEADER"}
-
-    def draw(self, context):
-        pass
-
-
-# ---------------------------------------------------------------------------
-# 1. Scene Setup
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_scene_setup(bpy.types.Panel):
-    bl_label = "Scene Setup"
-    bl_idname = "BIM_PT_radiance_scene_setup"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
 
     def draw(self, context):
+        assert self.layout
         layout = self.layout
         props = tool.Blender.get_radiance_exporter_props()
 
+        if tool.Ifc.get():
+            row = self.layout.row()
+            row.prop(props, "should_load_from_memory")
+
+        if not tool.Ifc.get() or not props.should_load_from_memory:
+            row = self.layout.row(align=True)
+            row.prop(props, "ifc_file")
+
         row = layout.row()
         row.prop(props, "output_dir")
 
-        layout.separator()
-
         row = layout.row()
-        row.prop(props, "use_active_camera")
-        if not props.use_active_camera:
-            row = layout.row()
-            row.prop(props, "selected_camera")
-            row.operator("radiance.select_camera", text="", icon="EYEDROPPER")
-
-        row = layout.row(align=True)
-        row.label(text="Resolution")
-        row.prop(props, "radiance_resolution_x", text="X")
-        row.prop(props, "radiance_resolution_y", text="Y")
-
-
-# ---------------------------------------------------------------------------
-# 2. Materials
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_materials(bpy.types.Panel):
-    bl_label = "Materials"
-    bl_idname = "BIM_PT_radiance_materials"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
-    bl_options = {"DEFAULT_CLOSED"}
-
-    def draw(self, context):
-        layout = self.layout
-        props = tool.Blender.get_radiance_exporter_props()
-
-        layout.label(text="Unmapped materials default to white", icon="INFO")
-
+        layout.label(text="Info: Unmapped materials default to white")
         row = layout.row()
         row.template_list("MATERIAL_UL_radiance_materials", "", props, "materials", props, "active_material_index")
-        row.operator("radiance.open_spectraldb", text="", icon="WORLD")
-
+        row.operator("radiance.open_spectraldb", text="", icon="WORLD")  # Globe icon
         if len(props.materials) > 0:
             col = layout.column(align=True)
-            prop_with_search(col, props, "category")
+            col.prop(props, "category")
             if props.category:
-                prop_with_search(col, props, "subcategory")
+                col.prop(props, "subcategory")
 
-            if 0 <= props.active_material_index < len(props.materials):
+            if props.active_material_index >= 0 and props.active_material_index < len(props.materials):
                 active_material = props.materials[props.active_material_index]
                 if active_material.category and active_material.subcategory:
                     layout.label(
-                        text=f"Mapped: {active_material.name} -> {active_material.category} - {active_material.subcategory}"
+                        text=f"Mapped: {active_material.name} to {active_material.category} - {active_material.subcategory}"
                     )
                 else:
                     layout.label(text=f"Select category and subcategory for: {active_material.name}")
@@ -123,95 +78,28 @@ class BIM_PT_radiance_materials(bpy.types.Panel):
         row = layout.row()
         row.operator("bim.refresh_ifc_materials", text="Refresh IFC Materials")
 
+        layout.separator()
 
-# ---------------------------------------------------------------------------
-# 3. Lighting (Environment + IES)
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_lighting(bpy.types.Panel):
-    bl_label = "Lighting"
-    bl_idname = "BIM_PT_radiance_lighting"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
-
-    def draw(self, context):
-        layout = self.layout
-        props = tool.Blender.get_radiance_exporter_props()
-
-        # Environment
-        box = layout.box()
-        box.label(text="Environment", icon="WORLD")
-        row = box.row()
-        row.prop(props, "use_hdr")
-        row = box.row()
-        row.prop(props, "use_sun")
-        if props.use_sun:
-            box.prop(props, "sky_condition")
-            row = box.row()
-            row.prop(props, "ground_reflectance")
-            row = box.row()
-            row.prop(props, "turbidity")
+        row = layout.row()
+        layout.label(text="Step 1: Export geometry for simulation")
+        row = layout.row()
+        row.operator("export_scene.radiance", text="Export Geometry for Simulation")
 
         layout.separator()
 
-        # IES Light Fixtures
         box = layout.box()
-        box.label(text="IES Light Fixtures", icon="LIGHT_POINT")
+        box.label(text="Camera Settings")
         row = box.row()
-        row.template_list("MATERIAL_UL_ies_lights", "", props, "ies_lights", props, "active_ies_light_index")
-        col = row.column(align=True)
-        col.operator("radiance.add_ies_light", text="", icon="ADD")
+        row.prop(props, "use_active_camera")
+        if not props.use_active_camera:
+            row = box.row()
+            row.prop(props, "selected_camera")
+            row.operator("radiance.select_camera", text="", icon="EYEDROPPER")
 
-        if len(props.ies_lights) > 0 and 0 <= props.active_ies_light_index < len(props.ies_lights):
-            active_light = props.ies_lights[props.active_ies_light_index]
-
-            col = box.column(align=True)
-
-            row = col.row()
-            row.prop(active_light, "use_collection", text="Target Collection", icon="OUTLINER_COLLECTION")
-
-            row = col.row()
-            if active_light.use_collection:
-                row.prop(active_light, "target_collection", text="Collection")
-                if active_light.target_collection:
-                    empties = [o for o in active_light.target_collection.all_objects if o.type == "EMPTY"]
-                    row = col.row()
-                    row.label(text=f"{len(empties)} empty object(s) in collection", icon="INFO")
-            else:
-                row.prop(active_light, "target_object", text="Object")
-
-            row = col.row()
-            row.label(text="Rotation Z")
-            row.prop(active_light, "rotation_z", text="")
-
-            row = col.row()
-            row.prop(active_light, "lamp_color")
-
-            split = col.split(factor=0.5)
-            split.prop(active_light, "multiply_factor")
-            split.prop(active_light, "radius")
-
-
-# ---------------------------------------------------------------------------
-# 4. Render Settings
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_render_settings(bpy.types.Panel):
-    bl_label = "Render Settings"
-    bl_idname = "BIM_PT_radiance_render_settings"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
-    bl_options = {"DEFAULT_CLOSED"}
-
-    def draw(self, context):
-        layout = self.layout
-        props = tool.Blender.get_radiance_exporter_props()
+        row = box.row(align=True)
+        row.label(text="Resolution")
+        row.prop(props, "radiance_resolution_x", text="X")
+        row.prop(props, "radiance_resolution_y", text="Y")
 
         row = layout.row()
         row.prop(props, "radiance_quality")
@@ -222,9 +110,6 @@ class BIM_PT_radiance_render_settings(bpy.types.Panel):
         row = layout.row()
         row.prop(props, "radiance_variability")
 
-        row = layout.row()
-        row.prop(props, "ambient_bounces")
-
         layout.separator()
 
         row = layout.row()
@@ -232,94 +117,20 @@ class BIM_PT_radiance_render_settings(bpy.types.Panel):
 
         row = layout.row()
         row.prop(props, "output_file_format")
-
-
-# ---------------------------------------------------------------------------
-# 5. Pipeline (Steps 1-4 + Cleanup)
-# ---------------------------------------------------------------------------
-
-
-class BIM_PT_radiance_pipeline(bpy.types.Panel):
-    bl_label = "Pipeline"
-    bl_idname = "BIM_PT_radiance_pipeline"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_radiance_exporter"
-
-    def draw(self, context):
-        layout = self.layout
-        props = tool.Blender.get_radiance_exporter_props()
-
-        # Step 1
-        box = layout.box()
-        row = box.row()
-        row.label(text="Step 1: Export Geometry")
-        row = box.row()
-        if props.is_exporting:
-            row.label(text="Exporting...", icon="SORTTIME")
-        else:
-            row.operator("export_scene.radiance", text="Export Geometry")
-
-        # Step 2
-        box = layout.box()
-        row = box.row()
-        row.label(text="Step 2: Prepare Scene")
-        row = box.row()
-        if props.is_preparing:
-            row.label(text="Preparing scene...", icon="SORTTIME")
-        else:
-            row.operator("scene.prepare_radiance", text="Prepare Scene")
-
-        # Step 3
-        box = layout.box()
-        row = box.row()
-        row.label(text="Step 3: Render")
-        row = box.row()
-        if props.is_rendering:
-            row.label(text="Rendering...", icon="RENDER_STILL")
-        else:
-            row.operator("render_scene.radiance", text="Radiance Render")
-
-        # Step 4: False Color
-        box = layout.box()
-        row = box.row()
-        row.label(text="Step 4: False Color Analysis")
-
-        row = box.row()
-        row.prop(props, "radiance_bin_dir")
-
-        row = box.row()
-        row.prop(props, "false_color_label")
-
-        split = box.split(factor=0.5)
-        split.prop(props, "false_color_scale")
-        split.prop(props, "false_color_steps")
-
-        row = box.row()
-        row.label(text="Output Name")
-        row.prop(props, "false_color_output_name", text="")
-
-        row = box.row()
-        row.prop(props, "false_color_contour_lines")
-
-        if props.false_color_contour_lines:
-            row = box.row()
-            row.prop(props, "false_color_contour_mode")
-
-        row = box.row()
-        row.operator("render_scene.false_color_radiance", text="Generate False Color Image")
-
         layout.separator()
 
-        # Cleanup
         row = layout.row()
-        row.operator("radiance.cleanup_files", text="Cleanup Generated Files", icon="TRASH")
+        row.prop(props, "use_hdr")
 
+        if props.use_hdr:
+            row = layout.row()
+            row.prop(props, "choose_hdr_image")
 
-# ---------------------------------------------------------------------------
-# Solar Panel (unchanged)
-# ---------------------------------------------------------------------------
+        row = layout.row()
+        layout.label(text="Step 2: Run the simulation")
+        row = layout.row()
+        row.operator("render_scene.radiance", text="Radiance Render")
+        row.enabled = not props.is_exporting
 
 
 class BIM_PT_solar(bpy.types.Panel):
@@ -437,10 +248,7 @@ class BIM_PT_solar(bpy.types.Panel):
             row = self.layout.row()
             sun_props = tool.Blender.get_sun_props()
             assert sun_props
-            if sun_props.sun_object is not None and sun_props.sun_object.data is not None:
-                row.prop(sun_props.sun_object.data, "energy", text="Sun Intensity")
-            else:
-                row.label(text="Sun object not found. Toggle shadow mode to recreate.", icon="ERROR")
+            row.prop(sun_props.sun_object.data, "energy", text="Sun Intensity")
 
         row = self.layout.row(align=True)
         row.operator("bim.view_from_sun", icon="LIGHT_HEMI")

src/bonsai/bonsai/tool/blender.py

@@ -1888,7 +1888,7 @@ class Blender(bonsai.core.tool.Blender):
     @classmethod
     def get_radiance_exporter_props(cls) -> RadianceExporterProperties:
         assert (scene := bpy.context.scene)
-        return scene.BIMRadianceExporterProperties  # pyright: ignore[reportAttributeAccessIssue]
+        return scene.BIMRadianceExporeterProperies  # pyright: ignore[reportAttributeAccessIssue]
 
     @classmethod
     def get_fm_props(cls) -> BIMFMProperties:

src/bonsai/bonsai/tool/loader.py

@@ -45,6 +45,36 @@ import bonsai.bim.import_ifc
 import bonsai.core.tool
 import bonsai.tool as tool
 
+# For loading and caching remote texture images
+from pathlib import Path
+from urllib.request import urlretrieve
+from urllib.parse import urlsplit, urlunsplit, quote
+import hashlib
+
+CACHE_DIR = Path.home() / ".blender_texture_cache"
+CACHE_DIR.mkdir(exist_ok=True)
+
+
+def encode_url(url: str) -> str:
+    # make sure the URL is clean (e.g., special characters like spaces are encoded)
+    parts = urlsplit(url)
+    return urlunsplit((parts.scheme, parts.netloc, quote(parts.path), parts.query, parts.fragment))
+
+
+def get_cached_path(url: str) -> Path:
+    # Hash the URL -> unique filename
+    h = hashlib.md5(url.encode()).hexdigest()
+    ext = Path(urlsplit(url).path).suffix or ".img"
+    return CACHE_DIR / f"{h}{ext}"
+
+
+def load_image_once(path: str):
+    for img in bpy.data.images:
+        if img.filepath == path:
+            return img
+    return bpy.data.images.load(path)
+
+
 # Progressively we'll refactor loading elements into Blender objects into this
 # class. This will break down the monolithic import_ifc module and allow us to
 # partially load and unload objects for huge models, partial model editing, and
@@ -299,23 +329,44 @@ class Loader(bonsai.core.tool.Loader):
                 if texture["type"] == "IfcImageTexture":
                     # IFC2X3 uses UrlReference, IFC4+ uses URLReference.
                     original_image_url = texture.get("URLReference") or texture.get("UrlReference", "")
-                    is_relative = not os.path.isabs(original_image_url)
-                    nonlocal image_url
-                    image_url = Path(original_image_url)
-                    if is_relative:
-                        ifc_path = Path(tool.Ifc.get_path())
-                        image_url = ifc_path.parent / image_url
-                    image_url = image_url.absolute().resolve()
 
-                    if not image_url.exists():
-                        print(f"WARNING. Couldn't find texture by path {image_url}, it will be skipped.")
-                        return
+                    is_remote = original_image_url.startswith(("http://", "https://"))
 
-                    # keep url relative if it was before
-                    image_url = str(image_url)
-                    if is_relative and bpy.data.filepath:
-                        image_url = bpy.path.relpath(image_url)
-                    return bpy.data.images.load(image_url)
+                    if is_remote:
+                        try:
+                            encoded_url = encode_url(original_image_url)
+                            cache_path = get_cached_path(original_image_url)
+
+                            # Download only once
+                            if not cache_path.exists():
+                                urlretrieve(encoded_url, cache_path)
+
+                            # load via Blender
+                            return load_image_once(str(cache_path))
+
+                        except Exception as e:
+                            print(
+                                f"WARNING. Failed to load remote texture {original_image_url}, it will be skipped: {e}"
+                            )
+                            return
+                    else:
+                        is_relative = not os.path.isabs(original_image_url)
+                        nonlocal image_url
+                        image_url = Path(original_image_url)
+                        if is_relative:
+                            ifc_path = Path(tool.Ifc.get_path())
+                            image_url = ifc_path.parent / image_url
+                        image_url = image_url.absolute().resolve()
+
+                        if not image_url.exists():
+                            print(f"WARNING. Couldn't find texture by path {image_url}, it will be skipped.")
+                            return
+
+                        # keep url relative if it was before
+                        image_url = str(image_url)
+                        if is_relative and bpy.data.filepath:
+                            image_url = bpy.path.relpath(image_url)
+                        return bpy.data.images.load(image_url)
 
                 elif texture["type"] == "IfcBlobTexture":
                     # https://blender.stackexchange.com/questions/173206/how-to-efficiently-convert-a-pil-image-to-bpy-types-image

src/bonsai/docs/guides/development/maintenance.rst

@@ -61,6 +61,8 @@ When Blender ships with a new Python version:
      - What to update
    * - ``.github/workflows/ci-lint.yaml``
      - ``MIN_BLENDER_PY_VERSION``
+   * - ``.github/scripts/publish-bonsai-releases.py``
+     - ``CURRENT_PYTHON_VERSION``
    * - ``src/bonsai/Makefile``
      - ``SUPPORTED_PYVERSIONS``
    * - ``src/bonsai/scripts/dev_environment.py``
@@ -73,6 +75,18 @@ Notes:
 
 - Typically all packages are released at once using the same version schema
 - The ``README.md`` badges can serve as a visual reference for what versions have been released
+- Corrective Release (if needed after a standard release):
+
+  - Create a new branch from the release tag (e.g., from the ``ifcopenshell-0.8.5`` tag)
+  - Update ``VERSION`` with the ``-post1`` suffix (e.g., ``0.8.5-post1``, **not** ``.post1``)
+  - The hyphen is required for semantic versioning compliance; Blender will not process ``.post1`` suffixes correctly
+  - Follow the standard release process for the corrective version
+
+- Multiple Blender Python Versions:
+
+  - Blender does not allow multiple builds for the same platform with different Python versions (e.g., cannot have both ``bonsai_py311-0.8.5-windows-x64.zip`` and ``bonsai_py313-0.8.5-windows-x64.zip``)
+  - Workaround: publish different Python versions as different extension versions (e.g., py313 as ``0.8.5`` and py311 as ``0.8.5-post1``)
+  - Set the maximum Blender version on the Blender extensions platform UI to prevent conflicts (e.g., set max version ``5.1.0`` for ``0.8.5-post1``, which restricts it to versions below 5.1.0)
 
 Things to update:
 
@@ -96,10 +110,13 @@ Things to update:
 - ``.github/workflows/ci-ifcsverchok.yml`` - release ifcsverchok Blender add-on in GitHub releases
 - ``.github/workflows/ci-ifctester-pypi.yml`` - release `ifctester <https://pypi.org/project/ifctester/>`_ to PyPI
 - ``.github/workflows/ci-pyodide-wasm-release.yml`` - release pyodide wasm wheel to `wasm-wheels <https://github.com/IfcOpenShell/wasm-wheels>`_
-- Release Bonsai Blender extension - zip files from ci-bonsai.yml releases should be uploaded manually to `Blender extensions platform <https://extensions.blender.org/add-ons/bonsai/>`_
+- ``.github/workflows/publish-bonsai-releases.yml`` - publish Bonsai Blender extension to `Blender extensions platform <https://extensions.blender.org/add-ons/bonsai/>`_
+
+  - ❗ Requires ``BLENDER_EXTENSIONS_TOKEN`` secret to be set - ❗ not yet configured
+
 - Publishing documentation and websites (see `website <https://github.com/IfcOpenShell/website>`_ repository):
 
   - `ifcopenshell-docs.yml` - builds and publishes IfcOpenShell documentation to `docs.ifcopenshell.org <https://docs.ifcopenshell.org>`_ (`ifcopenshell_org_docs <https://github.com/IfcOpenShell/ifcopenshell_org_docs>`_ repo)
   - `bonsai-docs.yml` - builds and publishes Bonsai documentation to `docs.bonsaibim.org <https://docs.bonsaibim.org>`_ (`bonsaibim_org_docs <https://github.com/IfcOpenShell/bonsaibim_org_docs>`_ repo)
-  - `main.yml` - publishes `bonsaibim.org <https://bonsaibim.org>`_ (`bonsaibim_org_static_html <https://github.com/IfcOpenShell/bonsaibim_org_static_html>`_ repo) and `ifcopenshell.org <https://ifcopenshell.org>`_ (`ifcopenshell_org_static_html <https://github.com/IfcOpenShell/ifcopenshell_org_static_html>`_ repo)
+  - `publish-websites.yml` - publishes `bonsaibim.org <https://bonsaibim.org>`_ (`bonsaibim_org_static_html <https://github.com/IfcOpenShell/bonsaibim_org_static_html>`_ repo) and `ifcopenshell.org <https://ifcopenshell.org>`_ (`ifcopenshell_org_static_html <https://github.com/IfcOpenShell/ifcopenshell_org_static_html>`_ repo)
 - ``VERSION`` to the release version - **UPDATE THIS LAST** as all workflows above typically depend on it to set the version correctly

src/common.mk

@@ -1,7 +1,7 @@
 SHELL := sh
 IS_STABLE:=FALSE
-PYTHON:=python3.11
-PIP:=pip3.11
+PYTHON:=python3
+PIP:=pip3
 VERSION:=$(shell cat ../../VERSION)
 VERSION_DATE:=$(shell date '+%y%m%d')
 SED:=sed -i

src/ifcchat/ifc_worker.js

@@ -29,16 +29,7 @@ async function ensurePyodide() {
         const micropip = pyodide.pyimport("micropip");
         micropip.install("python-dateutil")
         
-        // Detect python minor version (3.12 vs 3.13) and pick a matching wheel.
-        const pyVer = pyodide.runPython(`
-import sys
-f"{sys.version_info.major}.{sys.version_info.minor}"
-    `);
-
-        const wheelUrl =
-            pyVer === "3.13"
-                ? "https://ifcopenshell.github.io/wasm-wheels/ifcopenshell-0.8.3+34a1bc6-cp313-cp313-emscripten_4_0_9_wasm32.whl"
-                : "https://ifcopenshell.github.io/wasm-wheels/ifcopenshell-0.8.2+d50e806-cp312-cp312-emscripten_3_1_58_wasm32.whl";
+        const wheelUrl = "https://ifcopenshell.github.io/wasm-wheels/ifcopenshell-0.8.5-cp313-cp313-pyodide_2025_0_wasm32.whl";
 
         await micropip.install(wheelUrl);
 

src/ifcgeom/mapping/IfcPointByDistanceExpression.cpp

@@ -52,6 +52,15 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcPointByDistanceExpression* i
    if (inst->OffsetVertical().has_value()) {
        auto offset_vertical = inst->OffsetVertical().get() * length_unit_;
        o += offset_vertical * z;
+
+       auto tmp1 = (z * offset_vertical).eval();
+       auto tmp2 = (Eigen::Vector3d(0, 0, 1) * offset_vertical).eval();
+       auto tmp3 = (tmp1 - tmp2).eval();
+
+       std::ostringstream oss;
+       oss << "local z: " << z.x() << "," << z.y() << "," << z.z() << "; delta: " << tmp3.x() << "," << tmp3.y() << "," << tmp3.z();
+       auto osss = oss.str();
+       std::wcout << osss.c_str() << std::endl;
    }
 
    if (inst->OffsetLongitudinal().has_value()) {

src/ifcopenshell-python/Makefile

@@ -5,8 +5,8 @@ VERSION_DATE:=$(shell date '+%y%m%d')
 PYVERSION:=py311
 PLATFORM:=linux64
 
-PYTHON:=python3.11
-PIP:=pip3.11
+PYTHON:=python3
+PIP:=pip3
 SED:=sed -i
 VENV_ACTIVATE:=bin/activate
 

src/ifcopenshell-python/ifcopenshell/draw.py

@@ -42,7 +42,8 @@ WHITE = numpy.array((1.0, 1.0, 1.0))
 
 DO_NOTHING = lambda *args: None
 
-ARRANGE_POLYGON_SETTINGS = W.arrange_polygon_settings() if hasattr(W, 'arrange_polygon_settings') else None
+ARRANGE_POLYGON_SETTINGS = W.arrange_polygon_settings() if hasattr(W, "arrange_polygon_settings") else None
+
 
 @dataclass
 class draw_settings:

src/svgfill/src/arrange_polygons.cpp

@@ -3256,7 +3256,7 @@ void arrange_cgal_polygons(svgfill::arrange_polygon_settings settings, const std
         double threshold;
         clean_noisy_paths(debug_output, arr, segment_lookup, threshold);
         remove_colinear_vertices(arr);
-        clean_noisy_bounds(debug_output, arr, segment_lookup, threshold);
+        // clean_noisy_bounds(debug_output, arr, segment_lookup, threshold);
     }
 
     t0.stop();