LAB

Posted on | In

Pipelines / mesh settings

Vertex Anim Textures

  • Two additional triangles - > bounds of sim > frame nr , padding ratio in @P data embedded in the bounds of the static mesh and automatically derived at runtime.
  • 2 uv channels (16 bit depth) instead of vert color to store Pivot pos.

Global Options

  • Input Geometry Is Cached - Is loaded from disk cache.
  • LookupTable - Typically Non-HDR “.png” / “.tga” for Lookup Table Texture to keep the memory consumption low.
  • Texture Format - Typically HDR. Only EXR and TIFF support HDR.
  • Split Positions into Two Textures - Uses 2 x 8-bit textures (when the target engine does not support 16/32-bit HDR)
  • Export Spare Color Texture - Spare Color Texture attribs point @Cd2, f@Alpha2. (for second set of animated colors). (Color Texture is multi-purpose) (Spare Color Texture is more of a pure color texture) can still write non-color data.
  • Export Static Mesh Vertex Colors - Use vertex color. Create attrib on vertices @Cd_v and @Alpha_v
    • Dynamic Remeshing (Fluid) mode does not have the concept of static vertex colors,
    • Particle Sprites (Sprite) mode only exports static vertex colors if they exist on the geometry from Custom ZX Shapes.
  • Include Hidden Debug Plane in Geometry - Recommended to turn this on.

Custom Attributes

Attribute to export through

  • In Position Alpha - Position Texture's A channel. This attribute can have any non-negative values, including values above 1.0, even when using non-HDR texture formats.
  • In Color - Color Texture's RGB channels. This attribute does not undergo any transform, conversion, or normalization. If the attribute has values outside the 0-1 range, set Texture Format to “HDR”. If you have to use a non-HDR texture, you can pre-normalize the attributes in the input geometry and manually reverse the normalization in the real-time shader.
  • In Color Alpha - Color Texture's A channel. Range 0-1

Advanced

  • Allow Splitting Positions into Two HDR Textures - Override restriction.
  • Allow Exporting Real-Time Data JSON File (Legacy) - Write data
  • Support Real-Time Instancing - In Unreal, instanced meshes’ local-space tangents are not directly accessible, so when Mode is set to “Rigid-Body Dynamics (Rigid)”, the tangents have to come from the vertex attributes “uv5” and “uv6”.

Advanced Developer Options

  • Convert to Image Format Colorspace - Image data in COPs is always linear. When writing to image formats that are not linear (sRGB, for example), this will convert the colorspace to preserve the look of the image. An 8-bit format that has an unspecified colorspace is assumed to be sRGB.

  • Raster Depth:
    • 8 Bit Integer: banding can occasionally be seen; suitable for video.
    • 16 Bit Integer: intermediate bit depth; no banding can be seen, though clipping can still occur below and above the black and white points.
    • 32 Bit Integer: generally not used for color, 32-bit integer values are used to store object IDs, counts, and other integer values with a large range.
    • 16 Bit Floating Point: high bit depth; no banding can be seen, and no clipping occurs at white and black; uses less memory than 32-bit float, however processing time for this format is slightly higher as it is not a native CPU data format; this format supports values in the range -65504 to +65504.
    • 32 Bit Floating Point: high bit depth; no banding can be seen, and no clipping occurs at white and black; uses 4 times as much memory as 8 bit, which is this format’s main drawback.
  • Black/White Points - Floating point formats always have their black point at 0 and their white point at 1, but the integer formats (8, 16 and 32 bit) can specify the raw values that the black and white points occur at. The white point must always be higher than the black point. - 8 bit - 255, 16 bit - 65535, 32 bit - 2,147,483,647
  • BC 4-Channel Split - Renders the channels separately for different data formats.

LOD

Exports a single FBX containing multiple LODs and a single set of textures compatible with all the LODs.
All non-zero LODs simply share LOD0’s textures through point-mapping (described below in requirement 1), so adding more LODs does not increase the texture memory consumption.

Number of LODs - The number of LODs to export. At least this number of LODs must be present in the input geometry.

Requirements:

  • All LODs must have the integer point attribute @lod0_ptnum (Rigid mode on packed points) . This attribute maps all the points in every non-zero LOD to a subset of points in LOD0, enabling subsequent LODs to share the point data exported with LOD0.
  • In each LOD, all the points must be assigned to the respective point group lod# with # being the LOD number starting with 0. (Rigid mode on packed points)
  • All LODs must already have the desired UVs and normals on vertices this node cannot reliably auto-generate missing UVs

Soft

Rotation texture usage

  • Rotation Texture rot tex as quat to heve add normal. tangent space nm > (tangent data to shader, with only normal they can spin around nm. (rotation texture (tan + nm ) added as quaternion (can describe both degrees of freedom simultaniousley using 4 not 6 chanles)))
  • Export Compressed Normals in Position Alpha - lossy compression resulting in medium-quality normals. more memory-efficient alternative as it bypasses the cost of sampling Rotation Texture.

Dynamic

Dynamic Remeshing (Fluid) mode requires you to render output files in two separate passes. (After the first pass is complete, change this to “Second Pass” and press Render All again).

  • First Pass - renders Geometry, Lookup Table Texture, and optionally the Real-Time Data JSON file
  • Second Pass - renders the animation data textures (i.e. Position, Rotation, Color Texture, etc.), which are much smaller in size than Lookup Table Texture.

Unreal: Consider turning on Use Full Precision UVs in Mesh Editor.

Attributes
  • Required: point: @P
  • Optional: point: @Cd, @Alpha , vert: @uv, @N, @tangentu
  • Spare Color: @Cd2, @Alpha2

Rotation texture usage

  • Export Compressed Normals in Position Alpha - Compresses vector to float. Stores them in Position Texture's A channel. Lossy compression.

Unreal: Check export compressed normals in position A & use compressed normals

Uv’s

Can UV generation method specified on the Input tab.

  • not checked…..
  • Export Surface UVs in Position Alpha and Color Alpha - Exports the animated UV attributes through Position Texture's A channel and Color Texture's A channel.
  • Export Surface UVs in Color Red and Green - Exports the animated UV attributes through Color Texture's R & G channels.

Fuse

Turn this off if you do not want to fuse any points.

  • Fuse Point Group - Use the !group_name or * ^group_a_name ^group_b_name
  • Fuse Distance - Fuses together points within this distance to one another in the input geometry. This helps to remove tiny triangles that are a waste of resources and potentially problematic.

Blur

Export velo in color

Rigid

v@P, v@pivot, p@orient - at packed points

Packed pieces with RBD simulation data.

Rigid-Body Dynamics (Rigid) mode expects the primitive intrinsic @pivot to not change more than once during the animation. Geometry Spreadsheet > Primitives > Intrinsics and select “pivot” to check if the values are changing

  • RBD solver make sure pieces are packed before solver
  • Transform Pieces SOP make sure they are packed before (not after) that SOP

Accuracy of the pivot

  • High use if vertex shader is a performance bottleneck; uses two 16-bit UV channels to store unencoded pivots; the overall cheapest option
  • Very High recommended; uses two 16-bit UV channels to store encoded pivots; deploys two split-encoding formats and dynamically pick the better format for each piece, producing an accuracy very close to that of “Maximum” at only half of the latter’s memory footprint; costs more vertex shader instructions.
  • Maximum uses two 32-bit UV channels to store unencoded pivots; (Use Full Precision UVs in Mesh Editor). Because Rigid-Body Dynamics (Rigid) mode requires 4-6 UV channels on the exported mesh, turning on Use Full Precision UVs doubles the memory footprints for all of them.

Rotation Interpolation

  • Accurate Multi-RPF Slerp with Angular Velocity - Default. allows you to freely dilate time in real-time playbacks & multi rotation. Use unless no @w If your input geometry comes from a RBD simulation, angular velocity is directly available. @w- point attrib. (angular-velocity-assisted spherical linear interpolation (slerp) algorithm to fairly accurately interpolate rotations of fast-spinning pieces)
  • Basic Short-Path Slerp without Angular Velocity - uses the standard short-path spherical linear interpolation (slerp) algorithm.

Support Smoothly Interpolated Trajectories:

  • This requires you to export Color Texture and set Texture Format to HDR. It recomputes accelerations and exports them through the RGB channels of Color Texture. Using accelerations, the shader can reconstruct curved interframe trajectories in a more realistic way which take velocites into account, instead of constructing straight paths to connect adjacent-frame positions.
    • Max RPF Allowed - 50 Limit revolutions per frame ( too high may affect the accuracy of the rotation interpolation for all pieces due to floating point precision limitations )
    • Slerp Edge Case Offset - (Do not set this value too low, or the real-time shader may suffer from numerical errors. )
    • Slerp Edge Case Seed - generating random degrees by which to rotate edge-case pieces. (extremely unlikely that you will need to change this parameter. Only change it if the node displays an error message that asks you to do so.)

Rigid not from sim

  • not throu solver , njo rdb data : orient, pivot Use transform pieces:
  • packed pieces:
  • first frame freez (ref)
  • extract transform
  • transform pieces. Attribute to copy: pivot, orient

Piece scale multiply

  • by vector
  • can scale by velo with MF_TransformVelocity (localspaceVeloInUnreal Out) > (localspacePieceScaleMultiplayer) in FM_VAT_RigidbodyDynamics

Particle

  • Support Particle Interframe Interpolation - Arrange data on the output textures to make it possible to interpolate particle attributes in real time. This requires the input geometry to have the point attribute @id.

Card Shape

  • Custom ZX Shapes - Replaces the default shape options with your own designs. The custom shape geometry has to be flat on the ZX plane. You can merge multiple shape variants together and point this parameter to the path of the combined geometry. See the tooltip of Multiple Shape Variants with Shape ID Attribute.
  • Shape Input Type - The custom shapes can either be filled polygons or simply outlines defined by closed curves with no interiors. The hollow outlines will be automatically filled. For performance reasons, consider using a Fuse SOP to reduce the number of points used to define the input custom shapes.
  • Multiple Shape Variants with Shape ID Attribute - When you merge multiple shape variants together (because Custom ZX Shapes only accepts one geometry path), they can still be uniquely identified if you assign each shape a unique shape ID value.
  • Shape ID Attribute - A point or primitive integer attribute to distinguish different shape variants.
  • Shape Weight Attribute - A point or primitive float attribute to determine the distribution of the shape variants. Each variant’s likelihood of adoption by a particle is this variant’s weight divided by the aggregate weight of all variants.
  • Preserve Relative Scales of Different Shapes - Preserves the relative scale differences between multiple variants. Turn this off if you want to scale (the width-to-height ratio will be locked) different shape variants to have the same bounding square size.
  • Reverse Custom Card Normals - Turn this on only if the particle cards have the wrong normals in your real-time engine, in which case, they may appear to be invisible but if you select the object, you can see the outlines. This is unlikely to happen, however.

Looping particles

  • make loop SOP > last frame shorter
  • can spin with nm
  • steer by velocity (export velo and apply )

Unreal Settings

Texture Settings

Filter: Nearest
Texture group: 8 bit Data
Mip: No Compression: vectorDisplacementMap (RGBA8) sRGB: [] not checked

Filter: Nearest
Texture group: 16 bit Data
Mip: No Compression: HDR (RGBA16) sRGB: [] not checked

  1. In Content Browser, select multiple textures.
  2. Rght-click on any selected textures and go to Scripted Asset Actions.
  3. Select either “SideFX VAT Set HDR Textures” or “SideFX VAT Set Non HDR Textures” to match what is selected on VAT ROP > Settings > All Modes > Texture Format.
  4. Hit Ctrl+S on selected textures to confirm. You can quickly verify that the correct settings have been applied by hovering your cursor above a texture and see if Filter has been set to “Nearest”. If it has, then everything else will have been set correctly too.
  5. In Unreal Engine, sometimes there are issues with power-of-two textures that have data in their alpha channels, in which case, consider using “SideFX VAT Set HDR Textures” even if you exported those textures in non-HDR formats in Houdini.

Real-Time Data File

  1. On the VAT ROP, go to Advanced, turn on Support Real-Time Instancing.
  2. Render your assets.
  3. In the UE Material Instance, turn on Support Legacy Parameters and Instancing.
  4. Enable all six parameters now appearing below Support Legacy Parameters and Instancing.
  5. Follow their tooltip to batch-set their values (all six bound parameters share the same tooltip).

Support for ISM & HISM

also mesh particles or 4h2 ? - H: support real time instancing checkbox - H export tab: Include: geo, pos, rot , col / realtime data - U: import data table, support table check - U: use scripted action under RMB

Motion blur

Normal Texture is deprecated and replaced by Rotation Texture describes both normals and tangents. Position Texture 2 and Spare Color Texture are not directly enabled/disabled here. They depend on parameters in the Settings tab. you cannot export Position Texture 2 without Position Texture 1, and you cannot export Spare Color Texture without Color Texture.

Pivot Paint

V1

geometry s@name points pivot points s@name points v@N points

V2

on both:
s@hierarchy

on points:
v@N

Parent Index (Int as float)
Number of steps from Root
Random 0-1 Value
BoundingBoxDiameter
Selection Order (Int as float) - i@selectionIndex
Normalized 0-1 Hierarchy Position
Object X,Y,Z
Parent Index (Float up to 2048)

comprezssion texture:
hdr , no srgb, nearest filter

Unreal: ma_CalculateMeshElementIndex ms_Decode8BitAlphaAxisExtent ms_DecodeAxisVector ms_DecodePosition ms_ReturnParentTextureInfo ms_UnpackIntegerasFloat 2FoliageShader

`s@hierarchy = 'root/' + itoa(@ptnum);`   
`s@hierarchy = 'root/branch/' + itoa(@ptnum);`

Houdini Niagara

Particle ID, age, life

Impostors:

  • camera rig
  • ROP impostor

Flipbook

dense smoke - more detail enviro lighting

Motion v R8G8 MV’s by side fx. < decoded

MDC Map - multi directional contribution normalized depth maps -

Flow Maps

Bake

Motion Vectors

ROP Vector fields

ROP Volume Textures

\

https://wakumoku.com/2021/12/19/texture-sheets%e3%82%92%e6%a4%9c%e8%a8%bc%e3%81%97%e3%81%a6%e3%81%bf%e3%82%8b/