You probably have the UV Coords toggle enabled in the viewport's Display Options.

octavio.halo
Any chance for a Python 3.11 version?

https://github.com/shycats/PyVirtuCamera/releases [github.com]

I would love to update it, but the latest version of the available API is still 3.10 https://github.com/shycats/PyVirtuCamera/releases [github.com]

If you'd like to use just kelvins without luminance, you can apply them using Color Picker.

If you have Kelvins + Luminance Chart [physicallybased.info], you can make a VEX wrangle to convert Temperature + Luminance to XYZ universal color space and then to linear sRGB;

The first screenshot shows that you're using XPU with Principle Shader. Karma CPU works with both Principal Shader and MaterialX, while Karma XPU works with MaterialX only. Houdini is doing some basic conversion from Principal Shader to MaterialX in the background, but you shouldn't rely on it, as it leads to unexpected results.

HristoVelev
Any chance to get it to work with a full commercial license and not just indie?

I can try to upload it on orbolt because I don't have a full commercial license. Or maybe I could connect to you and rebuild it on your license if needed. The asset isn't very complex; it's mostly a Python module with an interface.

I forgot to say the plugin only works with the Python 3.10 build of Houdini due to API restrictions.

Hi, Hristo.
I have just updated the bridge plugin between Houdini 20.5 and the VirtuCamera app for iOS. The plugin might be even clunkier than Unreal due to how the screen is captured and the lengthy post-recording of transformations to the camera keyframes. I have some ideas/tests on how to make a recording of transformation faster, but other projects are currently a priority.
You can read more about it and watch a video here in the topic [www.sidefx.com].
And download the latest version here on GitHub [github.com]
Feel free to contact me if you need help with testing this out.

VirtuCamera plugin: Update to Houdini 20.5
HDA Version 1.3, VirtuCamera API version 2.1.2

Works only with the Python 3.10 version of Houdini due to API compatibility.
Added a Display Preset dropdown menu for 4K and Full HD displays.

Download it from my GitHub repository: VirtuCameraHoudini-api-2.1.2-version-1.3-py310 [github.com]

Tested on Windows 11, Houdini 20.5.278 Py310, Iphone 11

DirtyVibeMedia
any chance we can get this for Mac? would be super sick! thank you in advance

Sorry, I can't do this; I don't have a Mac.

It looks very natural and realistic! The APEX tree is impressive as well. Is it intended that brunches disappear during growth?

I guess modern engines with PBR shaders have deliberately moved away from calculating the complex IOR with an imaginary part (k) for non-metals because the values for non-metals are too small to make a significant difference. When comparing the imaginary refractive indices of metals and glass, the range for metals can vary from 1 to 14, while for glass, it ranges from 2.8607E-06 to 8.1300E-06 (0.0000028607 to 0.0000081300). These are incredibly small values, and I doubt whether rendering engines even calculate to such precision, as these minuscule differences likely don’t have a noticeable impact on the final render.

In the Physically Based Rendering book [pbr-book.org], it is clear that the Fresnel function for conductors (metals) uses the complex refractive index, including the imaginary part k, which accounts for light absorption.
In contrast, FresnelDielectric function is not using it.
So, this likely applies to all engines that implement similar technology, as using the imaginary part for dielectrics does not provide significant benefits and only increases computational overhead.

art3mis
Thanks for sharing!
Minor corrections I believe are needed on the MtlxImage node signatures in the example .hip. For Roughness and Height maps I believe you should change the Signature to Float from Color.

And if using a Normal map, use Vector instead of Color.

Thank you! I fixed this in the updated example file.

Hakobus
Hey FaitelTech,

The node pack looks extremely useful, but it doesn't seem to work with Houdini 20.5. Any chance you might look at updating the pack for 20.5?

The quick update to run MaterialX Essentials Nodes on Houdini 20.5

Note: To see custom nodes inside Material Builder subnet, add "FaitelTech*" at the beginning of Tab Menu Mask parameter on Karma Material node or MaterialX Builder



https://github.com/Faitel/MaterialXEssentials [github.com]

Yeah, that sometimes happens to me, too.

Those utility tools are awesome; they look like they should be part of the standard Apex toolkit.

You guys are rock; keep it up! As much as I'd like to test the foliage with delayed evaluation, I'd like to see tutorials and examples of APEX usage in a non-rigging environment.

A way to do it is by baking color with a render engine like Karma CPU. COPs-based maps baker only supports transferring texture color, not the component color of the high-poly model.
I'm attaching an example of baking points scattered on a 'Rubber Toy' onto a UV-unwrapped Rubber Toy model.
The example based on the hip from the post [www.sidefx.com] by pablo_lukaszewicz [www.sidefx.com]:

ivanmalek
Hi,
I'm struggling a bit with a larger scene, where I'm using the Instancer to scatter grass.

Try to use point instances instead of native instances.

Konstantin Magnus
Great overview!

You could also compress your node tree to a single volume wrangle containing all sorts of distance functions and a multiparm block:

https://procegen.konstantinmagnus.de/constructive-solid-geometry-tool [procegen.konstantinmagnus.de]

Great website, thanks for sharing!

You need to select all nodes and place them into subnet (Shift+C), then select the subnet node and create a digital asset from it.

People in the Modeler for Houdini [discord.gg] Discord group were interested in SDF boolean operations, so I decided to create a simple example of SDF usage and share some notes.

At the bottom of this post, I have attached two versions of the same example file:
VDB_SDF_Modeling.hiplc - The original file, but it contains nodes from the Modeler 2023.4 plugin.
VDB_SDF_Modeling_Stashed.hiplc - A copy of the first file in which I replaced all operations from the Modeler 2023.4 plugin with Stash nodes.
If you do not have the Modeler [alexeyvanzhula.gumroad.com] plugin, then download the second file and you can still get an idea of boolean operations using SDF volumes.

The file contains examples of using the following nodes and operations:
VDB from Polygons (for converting polygonal geometry to SDF volume).
VDB Smooth SDF (for smoothing the edges of geometry similar to the results from polygonal round bevel).
VDB Resample (for changing voxel density to increase object detail).
VDB Combine (for boolean operations: SDF Union, SDF Difference, SDF Intersection).
VDB Reshape SDF (for expanding or narrowing voxel shapes, similar to the Peak operation).
VDB Convert (for converting SDF to polygonal geometry).
Volume Deform (for deforming voxel shapes, by using Lattice from Volume node in conjunction with Bend node to deform point grid which represents voxel grid).
Name and Attribute Edit String (for building hierarchy of LOP primitives while working in SOP)

Notes about using SDF nodes:

1. Increase voxel density only when necessary. Generally, I used a voxel size of 0.02 when converting geometry through VDB to Polygons and could move shapes interactivly. However, in some cases, I needed narrower or smaller bevels and increased density to 0.01 voxel per unit in exchange to performance.
   
2. After all operations, you can also increase voxel density through VDB Resample to get a denser and more detailed polygonal mesh from Convert VDB.
   
3. Use different smoothing modes to maintain performance. Instead of increasing the number of smoothing iterations in VDB Smooth SDF, try to change the type of operation: Mean Value for normal smoothing, Gaussian for strong smoothing, Mean Curvature Flow for weak smoothing or smoothing small details.
   
4. If you need to place one object inside another, for example a button in a housing, use VDB Reshape SDF to expand the SDF before boolean subtraction.
   
5. I didn't find a way to store color in SDF and pass it through boolean operations, so after converting to polygons by Convert VDB I used Bounding Volume in Group node to select the area that I want to color using SDF volume.
   
6. Deform objects in voxels through Volume deform instead of deforming them in polygons. This is convenient because the bend deformer when used on polygons will not be able to bend the area where there is not enough geometry, but through Volume deform, you bend a point grid, so you can bend and deform even each pair of voxels.
   

Notes on modeling in SOPs within LOPs:

1. To improve performance, prevent SOP from the constant transferring of data to LOPs. To do this, place Output node inside the SOP and connect the geometry to it only when you want to transfer it to the LOP, otherwise keep geometry disconnected.
   
2. The same goes for working inside Component Geometry node: connect geometry to the default, proxy, and simproxy output nodes only when necessary, otherwise, the entire node tree will be recalculated with every change.
   
3. Start building hierarchy of LOP primitives while still in SOPs. Hierarchy construction will occur from top to bottom, from leaf to root. At the very beginning (for leaves), add Name node that will create the corresponding attribute and enter the geometry name into it, for example, Mesh. Then add an Attribute Edit String node, specify that you want to edit Name attribute, and in Editor tab, set "*" (all existing names) in From parameter. To the To parameter add the name of the LOP primitive where you want to place the geometry, like "Primitive/*". Thus, the Name attribute will become "Primitive/Mesh". Further, continue to add Attribute Edit String nodes with the same parameters to assign more parents or to group primitives after merging. The last Attribute Edit String will have "/*" name set in To parameter and will close the path (for example, "/Gamepad/Triggers/Primitive1/Mesh").
   

I've used the video [youtu.be] as reference for the model.

tamte

goldleaf
The MtlX TSC may prefer some of them to be lower-level, and implemented in code for their codegen targets

how does one implement a new node that works for all MtlX renderers?
I assume implementing codegen targets will not make it work for Karma since we've been told Karma is not using any of those languages
But if Nodegraph doesn't have many basic functions what are the options if we don't want to implement basic libraries (like random, matrix math, quaternions, ...) using only available very elemental math functions from scratch?

As far as I understand, Materialx takes care of transliterating the code itself, and it's unlikely that we will get access to the level of shader languages.
https://materialx.org/assets/ASWF_OSD2021_MaterialX_slides_final.pdf [materialx.org] Page 82

It seems that it makes sense to cooperate more around developers of the standard rather than dcc or render engine, at least until we have enough low-level functions.