Palladio - CityEngine Plugin for Houdini

Palladio is a plugin for SideFX Houdini. It provides operator nodes which enable the execution of CityEngine ‘rules’ within Houdini networks. Therefore, a 3D environment artist does not have to leave their familiar Houdini toolset anymore to make use of CityEngine’s procedural modeling power. Complicated export-import pipelines are no longer needed, which also means that the procedural building models do not need to be “baked” anymore. The buildings stay procedural during the entire modeling workflow (optionally even at render time). Consequently, the 3D environment artist can change the height, style and appearance of buildings easily with a parametric interface at any point during production.

Palladio requires so-called rule packages (RPK) as input, which are authored in CityEngine. An RPK includes assets and a CGA rule file which encodes an architectural style. Comprehensive RPK examples are available below and can be used “out-of-the-box” in Palladio.

Palladio is well suited for managing the procedural generation of architectural 3D content in digital sets. However, Palladio is restricted to the procedural generation of single buildings / objects. Palladio does not include the city layouting and street network editing tools of CityEngine i.e. the rich CityEngine toolset to design a city from scratch (or based on geographic data) is still needed.

Quick Start

1. Download the latest Palladio binary from the release page.

2. Extract the archive into your <home>\Documents\houdiniX.Y (Windows) or <home>/houdiniX.Y (Linux) directory, so that the files end up in the corresponding config, dso and packages sub-directories.

3. Start Houdini and you will find the new pldAssign and pldGenerate nodes in the OBJ operator menu under custom.

4. In Houdini, create a quad as initial shape by setting up a grid node with 2 cols/rows.

5. Open the geometry node in the network editor and connect the mesh output to a new pldAssign node.

6. Create a new pldGenerate node and connect the input to the ouput of the previous pldAssign node.

7. Make the pldGenerate node the active render node.

8. Download the Parthenon rule package. Or alternatively, in CityEngine, download Tutorial 9 and export the "Parthenon" CGA rule to a RPK (see Creating a Rule Package).

9. Select the pldAssign node and set the Rule Package parameter in the parameter editor to the path of the previously exported RPK.

10. The model should generate and rule attributes should now be editable inside the parameter editor.

    

Table of Contents

• User Manual
• Downloads
• Examples
• Developer Manual
• Release Notes
• Licensing Information

External documentation:

• CityEngine Tutorials
• CityEngine CGA Reference
• CityEngine Manual
• CityEngine SDK API Reference
• Houdini HDK Reference

User Manual

Please refer to the release notes for the supported CityEngine version.

Installation

Software Requirements (Latest Release)

• Windows 10 or 11 (64bit)
• RedHat Enterprise Linux 8 or 9 and compatible (CentOS, Alma Linux, Rocky Linux, ...)
• Houdini 18.5, 19.0 or 19.5
• See release notes for compatible CityEngine versions and requirements for commercial work.

From Pre-Built Binaries

1. Download the latest Palladio binary from the release page.
2. Extract the archive into your <home>\Documents\houdiniX.Y (Windows) or <home>/houdiniX.Y (Linux) directory, so that the files end up in the config, dso and packages sub-directories.
3. Start Houdini and you will find the new pldAssign and pldGenerate nodes in the OBJ operator menu under custom.

Note: it is NOT necessary to modify the system PATH environment variable.

From Source

1. Build Palladio
2. The install step should automatically copy all required files into your <home>\Documents\houdiniX.Y (Windows) or <home>/houdiniX.Y (Linux) directory and Palladio is ready to run.

Using Palladio

Palladio adds the two new geometry (SOP) nodes pldAssign and pldGenerate to Houdini in the 'Custom' category. These can be created inside of any geometry object in the Network Editor.

pldAssign Node

The pldAssign node is designed to create the required metadata to the input geometry (as primitive attributes) such that the pldGenerate operator can procedurally generate the geometry. When selected, a RPK (rule package), seed and corresponding CGA attributes can directly be set in the parameter editor. When evaluated, the pldAssign node attaches the required metadata to the geometry (in the form of primitive attributes) and updates the CGA attributes in the parameter editor accordingly. The primitive attributes can also be overwritten before the geometry is passed to a pldGenerate node (i.e using an Attribute Create node).

pldGenerate Node

The pldGenerate node is used to generate the final geometry. It takes an initial shape geometry with metadata as input (i.e. the output of a pldAssign node) and executes the CityEngine rule to generate a 3D model. In the parameter editor we have the options to:

• Re-emit modified CGA attributes (off by default)
• Emit material attributes (off by default)
• Emit CGA reports (off by default)
• Triangulate polygons with holes (on by default). If disabled, Palladio will create "holes with bridges" similar to the Hole geometry node.

Execute a simple CityEngine Rule

1. In CityEngine, create the following rule file and share it as a rule package (RPK) to disk somewhere (or download one of the provided examples and share it as a RPK (see Creating a Rule Package)):

   attr height = 1
   
   @StartRule
   Init -->
      extrude(height)
   

   (Instead you can also directly use this RPK)

2. In Houdini, in a new scene, add a grid node.

3. Enter the grid node, set the Rows and Columns parameters to two and add the two Palladio nodes pldAssign and pldGenerate. Connect them like this:

   

4. Select the pldAssign node and set the Rule Package parameter to the path of the previously exported RPK in the parameter editor.

5. Make the pldGenerate node the active render node, this will trigger a "cooking" of the assign and generate nodes and execute the CityEngine Rule. You should now see a cuboid:

   

Overriding Rule Attributes

In the previous section we've used the default value for the height attribute. Let's use Houdini tools to modify the rule attribute prior to execution.

Using Parameter Editor

1. Make sure the pldAssign is evaluated by making the connected pldGenerate the active render node

2. Edit the rule attribute in the parameter editor by changing the value in the generated handle (a rule attribute can be reset by calling revert to Defaults or pressing ctrl + MMB on the rule name)

   

Manual Override

1. Add an AttributeCreate node between pldAssign and pldGenerate.

2. Set the attribute name to height and the Class to Primitive. The extrusion vanishes because the default value is 0.

3. Increase the value for height to see an actual extrusion:

   

Please note the steps for the general case:

1. See the CGA file (or CityEngine) for the available attributes and their data types (number, string, boolean).
2. In the AttributeCreate node, set name to the name of the CGA attribute (make sure to check Encode Invalid Attribute Names).
3. Set class to Primitive.
4. Set type to Float for CGA number attributes, String for CGA strings and Integer with 8 bit precision for CGA booleans.

Working with multiple Assign Nodes

In this section, we are going to showcase how we can use multiple pldAssign nodes with a single pldGenerate node.

1. Duplicate the grid and pldAssign nodes.

2. Set the Center of the second grid node to (15, 0, 0).

3. Add a new Attribute Create node between the new grid and pldAssign nodes.

4. Set the attribute name to "primCls", change the Class to primitive and change its value to 1. This value needs to be set such that the pldGenerate node later knows which initial faces should be generated together or separately.

   

5. Merge the output of both assign nodes with a merge node and feed the output to the previous generate node like this:

   

6. You can now change the rule files and attributes of both pldAssign nodes and it should generate them correctly

   

Working with Material Attributes

In this section, we are going to connect a material attribute generated by pldGenerate with a Mantra shader (the same mechanism can also be used for Viewport materials).

Using provided HDA

1. Download the ready-made Houdini Digital Asset with a CityEngine Material for Mantra.

2. Import the HDA to your current project (File>Import>Houdini Digital Asset) and click install.

3. Select the pldGenerate node and check the Emit material attributes check box. Open the spreadsheet to observe a number of material primitive attributes now being emitted by pldGenerate.

4. Create a new PalladioCityEngineMaterial node and connect it to the pldGenerate node. Make it the active render node.

5. Hit Mantra render and you should see a red box in the render view.

   

Creating a new custom Shader

1. Extend the rule from the previous section with a color statement and re-export it:

   attr height = 1
   
   @StartRule
   Init -->
      color(1,0,0)
      extrude(height)
   

   (Instead you can also directly use this RPK)

2. In Houdini, select the pldGenerate node and check the Emit material attributes check box. Open the spreadsheet to observe a number of material primitive attributes now being emitted by pldGenerate.

3. Add a Material node and connect it to the pldGenerate node. Make it the active render node:

   

4. In the Material Palette, create a new Principled Shader instance (by dragging it from the navigator to the \mat window) and rename it to CityEngineShader:

   

5. Enter the CityEngineShader node and connect a Parameter node to the Surface/basecolor input:

   

6. Set the name of the Parameter node to diffuseColor and also set the type to Color. This name will match the primitive attribute emitted by pldGenerate.

   

7. Back in the network of the grid node, select the Material node and select /mat/CityEngineShader for the Material parameter.

8. Hit Mantra render and you should see a red box in the render view.

   

Tips and Tricks

How to export an Alembic from CityEngine as input to Palladio

This short CityEngine guide explains how to include the random seed and start rule assignments when exporting input geometry to Alembic.

1. Run the following Python script on your scene objects to assign the random seed as object attributes:

   from scripting import *
   
   ce = CE()
   
   shapes = ce.getObjectsFrom(ce.scene(), ce.isShape)
   for s in shapes:
       seed = ce.getAttribute(s, "/ce/rule/randomSeed")
       ce.setAttribute(s, "seed", seed)

2. Assign this CGA script to the desired shapes to report out seed and rule (the start rule):

   version "2019.0"
   
   attr seed = 0
   
   Lot --> R
   LotInner --> R
   Street --> R
   Sidewalk --> R
   Crossing --> R
   OpenSpace --> R
   Joint --> R
   R -->
       report("seed", seed)
       report("rule", initialShape.startRule)
   

   The seed rule attribute should have been connected to the previously assigned seed object attribute.

3. Export the shapes to Alembic, the two report values are now attached as user properties to the meshes.

Keep CityEngine Rule Packages in the Houdini Project

It can be useful to put RPKs into an rpk sub-directory of your current Houdini project. If you use $HIP to refer to the RPK in the pldAssign node, your Houdini project will stay relocatable.

Environment Variables

• CITYENGINE_LOG_LEVEL: controls the global (minimal) log level for all assign and generate nodes. Valid values are "debug", "info", "warning", "error", "fatal". The default is "error". Additionally, the log level can be controlled for each pldAssign and pldGenerate instance.
• HOUDINI_DSO_ERROR: useful to debug loading issues, see https://www.sidefx.com/docs/houdini/ref/env

Developer Manual

Supported Operating Systems

• Windows 10 or 11 (64bit)
• RedHat Enterprise Linux 8 or 9 and compatible (CentOS, Alma Linux, Rocky Linux, ...)

Required Toolchain & Compiler

• cmake 3.13 or later
• conan 1.20 or later
• Linux: GCC 9.3 or later
• Windows: Visual Studio 2019 (MSVC 14.27) or later

Required Build Dependencies (Latest Release)

• Installation of Houdini 18.5, 19.0 or 19.5 (see https://sidefx.com/download)

The following will be automatically fetched via the bootstrap steps below:

• CityEngine SDK
• SideFX Houdini HDK

Build Instructions

Default is Houdini 19.5. See below how to build for different Houdini versions.

Bootstrap

The below steps will populate your local Conan repository with dependencies for the Palladio build system. You only need to work through this section once (or if you want to upgrade one of the dependencies).

Linux

1. Checkout Palladio: git clone git@github.com:esri/palladio.git && cd palladio
2. Download CityEngine SDK: conan create -pr conan/profiles/linux-gcc93 conan/cesdk cesdk/3.0.8905@esri-rd-zurich/stable
3. Extract and package the HDK from your local Houdini 19.5 installation (adjust Z to your Houdini version): conan create -pr conan/profiles/linux-gcc93 conan/houdini houdini/19.5.Z@sidefx/stable (Note: use the option -e HOUDINI_INSTALL=/path/to/your/hfs19.5.Z, if Houdini is not installed at the standard location, e.g. at /opt/hfs19.5.Z for Linux).

Windows

1. Checkout Palladio: git clone git@github.com:esri/palladio.git
2. Open a Windows command shell and cd to the Palladio git repository
3. Download CityEngine SDK: conan create -pr conan/profiles/windows-v142 conan/cesdk cesdk/3.0.8905@esri-rd-zurich/stable
4. Extract and package the HDK from your local Houdini installation (adjust Z to your Houdini version): conan create -pr conan/profiles/windows-v142 conan/houdini houdini/19.5.Z@sidefx/stable (Note: use the option -e HOUDINI_INSTALL=C:/path/to/your/houdini/installation, if Houdini is not installed at the standard location for Windows).

Building Palladio

Note: to build for another Houdini version, add the cmake argument -DPLD_HOUDINI_VERSION=X.Y.

Linux

1. Ensure GCC 9.3 is active.
2. cd into your Palladio git repository
3. mkdir -p build/release && cd build/release
4. cmake -DCMAKE_BUILD_TYPE=Release ../../src
5. make install (the plugin will be installed into your ~/houdini19.5/dso directory)

Windows

1. Open a MSVC 14.27 x64 shell (Visual Studio 2019) and cd to the Palladio git repository
2. mkdir build/release
3. cd build/release
4. cmake -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release ../../src
5. nmake install (the plugin will be installed into your %USERPROFILE%/Documents/houdini19.5/dso directory)

Debugging Palladio

For the best debugging UX, please use the build type RelWithDebInfo when running CMake (or in Visual Studio). The Debug mode does not work as it will result in incompatible ABI between Houdini, PRT and the Palladio client code.

Running Palladio

See Quick Start how to launch Houdini with Palladio.

Building and Running Unit Tests

Linux

1. Ensure GCC 9.3 is active.
2. cd into your Palladio git repository
3. mkdir -p build/relTest && cd build/relTest
4. cmake -DCMAKE_BUILD_TYPE=Release -DPLD_TEST=1 ../../src
5. make palladio_test
6. Run bin/palladio_test

Windows

1. Open a MSVC 14.27 x64 shell (Visual Studio 2019) and cd to the Palladio git repository
2. mkdir build/relTest
3. cd build/relTest
4. cmake -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release -DPLD_TEST=1 ../../src
5. nmake palladio_test
6. Run bin\palladio_test

Release Notes

v2.0.0 (Jul 1, 2023)

• Compatible CityEngine versions: 2023.0 or older
• For commercial work, a license for CityEngine 2022.0 or later is required.

Added:

• Option to disable default triangulation on polygons with holes

Changed:

• Updated Procedural Runtime (PRT) to 3.0.8905 (corresponds to CityEngine 2023.0)
• Fixed lookup of textures within USDZ assets in RPKs

v2.0.0 Beta 2 (Mar 27, 2023)

Required CityEngine version: 2022.1 or older

Changed:

• Changed indexing of generated meshes: all vertex attributes now have separate indices. This improves mesh connectivity and sharing of points.
• Fixed rule attribute overrides for multiple initial shapes
• Fixed two bugs in the "FileSystem Helper" when reading textures from RPKs (fixes rendering with Mantra)
• Updated Procedural Runtime (PRT) to 2.7.8538 (corresponds to CityEngine 2022.1)

Development:

• Turned off optimization for config RelWithDebInfo to have better debugger experience
• Added workaround for Conan/CMake and the Visual Studio CMake generator
• Added tests to generated Visual Studio solution. Tests can now be started and debugged in Visual Studio by setting the test project as startup project.
• Updated cmake-conan integration to 0.18.1
• Updated developer docs

v2.0.0 Beta 1 (Nov 22, 2022)

Required CityEngine version: 2022.0 or older

Added:

• Support for Houdini 19 and 19.5
• Rule attribute parameters to directly edit them in the parameter editor of the pldAssign node
  • Rule attribute handles dynamically update when the pldAssign node is evaluated
  • Rule attribute values can be reset to the default value
  • CGA annotations will create different UI widgets, for example a color picker or file browser
• Seed parameter to change the seed value in the pldAssign node
• Icon to Palladio nodes

Changed:

• Updated Procedural Runtime (PRT) to 2.6.8300 (corresponds to CityEngine 2022.0)
• Rule attribute names can now be encoded using Houdini's string encoding
• Fixed issues with rule package paths containing white spaces
• Fixed loading of rule packages embedded in HDAs (Houdini Digital Assets)
• Updated and restructured user manual

Development:

• Updated compilers (now using C++ 17)
• Linux version is now compiled with GCC 9.3 by default
• Updated test framework and build system
• Cleaned up CMake files

Removed

• Support for Houdini 18.0 and older

v1.9.0 (Dec 7, 2020)

• No functional changes compared to Beta 2.

v1.9.0 Beta 2 (Dec 2, 2020)

• Updated doc section for "overriding rule attributes".
• General doc cleanup.

v1.9.0 Beta 1 (Nov 16, 2020)

• Update default CityEngine SDK to 2.3 (CityEngine 2020.1).
• Added support for Houdini 18.5.
• Add error message to assign node in case of e.g. invalid rule package (#159).

v1.8.0 (Oct 5, 2020)

• No functional changes compared to Beta 1.

v1.8.0 Beta 1 (Aug 23, 2020)

• Update default CityEngine SDK to 2.2 (CityEngine 2020.0) (#146).
• Added support for CGA array attributes (#146).
• Added per-node control of log level (#30).
• At startup, print Palladio version on console if log level is "info" or lower.
• Development
  • On Windows, building Palladio now requires MSVC 14.2 (#146).
  • Various code cleanups and adoption of clang-format rules from Serlio.
  • Pruned releasing for Houdini 17.0 (you can still build yourself for 17.0).
  • Relaxed Python/Conan version requirements.

v1.7.0 (June 14, 2020)

• No functional changes compared to Beta 1

v1.7.0 Beta 1 (Dec 9, 2019)

• Added support for Houdini 18 and removed Houdini 16 (#143).
• Updated built artifacts to latest Houdini versions (#139).
• Filter unnecessary components of PRT from release (#141).
• Fixed pipeline to not install files outside of the install directory (#138).

v1.7.0 Pre-Release (Oct 20, 2019)

• Improved setting start rule from primitive attribute (i.e. do not prepend style to start rule if it is already present).
• Improved installation experience (avoid setting OS PATH on Windows).
• Update default CityEngine SDK version to 2.1 (CityEngine 2019.1).
• Only pass non-default rule attribute values to PRT. This fixes setting inter-dependent rule attributes.

v1.6.3 (July 27, 2019)

• Optimized cooking time of pldGenerate (e.g. Parthenon example from CityEngine tutorial 9 cooks 7x faster)
• Added "tips and tricks" section with guide how to export Alembics from CityEngine for Palladio

v1.6.2 (June 22, 2019)

• Fixed broken texture coordinates in the generated Houdini geometry in case not all PRT meshes had any (#118).

v1.6.1 (June 7, 2019)

• Added support for texture coordinates on incoming initial shapes (#112).
• Assign SOP: do not overwrite main attributes like pldStartRule if they are already present on the incoming geometry (#111).
• Assign SOP: fixed rule attribute default value evaluation (each primitive can have different main attributes) (#111).
• Fixed support for PolygonSoup primitives as initial shapes (#110).

v1.6.0 (May 8, 2019)

• Added support for PRT 2
• Removed technical requirement for CityEngine license.
• Added support for new PRT PBR material attributes.
• Various build system improvements (supports both PRT 1.x and 2.x).

v1.5.0 (May 7, 2019)

• No functional change to beta 2.

v1.5.0 Beta 2 (Mar 19, 2019)

• Fixed crash in pldAssign node if no RPK is set.

v1.5.0 Beta 1 (Mar 14, 2019)

• Added support for Rule Packages (RPK) embedded in Houdini Digital Assets (HDA)
• Added support for Houdini 17.5

v1.4.1 (Mar 11, 2019)

• Always use UV set 0 as a fallback (mimics CityEngine behavior).
• Internal cleanup: Simplified UV coordinate transport between PRT and Palladio.

v1.4.0 (Feb 27, 2019)

• Generated material primitive attributes now use the "generic names" instead of the "CGA names" (see PRT reference for file prtx/Material.h for details).
• Fixed wrong texture paths for assets that originated in another CityEngine project (e.g. ESRI.lib) at RPK creation time.

v1.3.1 (Feb 20, 2019)

• Added a workaround to prevent a crash in PRT 1.9 when using an invalid CGB path in the assign node.

v1.3.0 (Jan 20, 2019)

• Update build system to support both Houdini 16.5 and 17.0.
• For Houdini 17, use bundled boost libraries.

v1.2.0 (Jan 17, 2019)

• Build System changes to improve continuous integration support (Jenkins).
• Updated required cmake version to 3.13 (preparation for Houdini 17 support).
• Added pipenv script for easier access to conan.
• Reduced Houdini package size.

v1.2.0 RC 1 (Jun 11, 2018)

• Support for inter-shape occlusion queries (#33).

v1.1.1 (Apr 16, 2018)

• Fixed asset loading issues in Windows build (#88).

v1.1 (Apr 7, 2018)

• Added support for Windows (#85).
• Raised minimal Houdini version to 16.5.x (#85).
• Added support to reload RPKs (#58).

v1.0 (Jan 26, 2018)

• Renamed project to "Palladio" (#68).
• Updated documentation (#38).
• Published demo scene (#74).

v0.9 (Jan 18, 2018)

• Add support for writing out primitive attributes from rule/generic CGA attributes (#40).
• Removed random seed parameter UI, read it from incoming primitive attributes instead. Added centroid-based random seed as fallback.
• Correctly update assign node parameters from RPK (#62).
• Make primitive group creation optional and based on primitive classifier (#67).
• Add support for CityEngine network licensing (#41).
• Fixed crash when handling invalid RPK paths.
• Remove style prefix on primitive attribute names.

v0.8 (Dec 19, 2017)

• Added support for multiple UV sets (#36).
• Added support for CGA reports (#39).
• Properly use Houdini input mesh connectivity (make CGA operation "isClosedSurface" work correctly) (#49).
• Refactored assign node to correctly use incoming geometry to evaluate default rule attribute values.

v0.7.1 (Nov 27, 2017)

• Proper support for UVs and material attributes.
• Introduced Conan to handle 3rd party packages in the build system (Houdini, CityEngine).
• Updated to CityEngine SDK 2017.1 (CE SDK 1.9).

v0.7 (Sep 19, 2017)

• Split plugin into two SOPs ("assign" and "generate") to support proper evaluation of rule attribute default values.
• Abandoned rule param UI, purely rely on Houdini attribute tools (e.g. "AttributeCreate") to create/modify rule attributes (= no need for complicated UI on assign node).
• Updated to Houdini 16 and CityEngine 2017.
• Dropped Windows/macOS support temporarily.

v0.6 (Mar 15, 2016)

• Support for rule attribute UI via Houdini multi-parameter.
• Experimental support for Windows/macOS.
• Updated to Houdini 15 and CityEngine 2016.

v0.4 (Oct 22, 2015)

• Working geometry generation from CityEngine rule packages
• Support to read rule attributes from primitive attributes
• Implemented rule execution as single surface operator (SOP).
• Updated to Houdini 13 and CityEngine 2015.

v0.1 - v0.3 (Spring 2015)

• Early experiments with Houdini 12 and CityEngine 2014.

Community

Palladio is maintained as an open-source project by Matthias Buehler (vrbn studios) and Simon Haegler (Esri R&D Zurich). Matthias is focusing on UX/UI topics and use-cases, while Simon is focusing on the implementation and procedural modelling technology.

Our goal is to bring as many Houdini and CityEngine users and developers on board as possible. Anyone is invited to submit issues and/or to fork and contribute to this project.

Join us on Slack at palladio-houdini-ce.slack.com!

Our thanks also go to the fine folks at Esri R&D Zurich and vrbn studios which provided valuable comments and feedback.

History

Palladio has been invented by Matthias Buehler and Simon Haegler in early 2015. It started out as a research project at Esri R&D Zurich to get to a tighter integration of CityEngine and Houdini than just via file-based import/export of assets. Early results were promising, so we slowly cooked the project to v1.0 in our spare time. In December 2017, we decided to open-source Palladio with an Apache 2.0 license.

Licensing Information

Palladio is free for personal, educational, and non-commercial use. Commercial use requires at least one commercial license of the latest CityEngine version installed in the organization. Redistribution or web service offerings are not allowed unless expressly permitted.

Palladio is under the same license as the included CityEngine SDK. An exception is the Palladio source code (without CityEngine SDK, binaries, or object code), which is licensed under the Apache License, Version 2.0 (the “License”); you may not use this work except in compliance with the License. You may obtain a copy of the License at https://www.apache.org/licenses/LICENSE-2.0.

All content in the "Examples" directory/section is licensed under the APACHE 2.0 license as well.

The "Favela" example data is copyrighted by vrbn studios. Please contact vrbn_studios for commercial licensing options.

For questions or enquiries, please contact the Esri CityEngine team (cityengine-info@esri.com).