# NVF Specification

1. NVF Intro
2. Basic Structure of NVF
3. NVF Node Reference
4. Problems / Limitations

### Introduction to NVF

Whereas NIFF is designed as an intermediate format, created by converting the CG tool data, NVF is designed as a format closer to the target, meant for displaying NIFF on the N64. NIFF is converted to NVF and then stored in the N64 ROM area. The previewer (nvfview, etc.) loads NVF from the N64 ROM area into main memory and then displays the data.

Index

### The Basic Structure of NVF

#### Data Types

The following basic data types were defined in NVF:

- long
  A 4-byte integer. Uses the network byte order.
- short
  A 2-byte integer. Uses the network byte order.
- char
  A 1-byte integer.
- float
  A 4-byte floating-point. Follows the IEEE 754 format shown below:

  Byte 0 | Byte 1 | Byte 2 | Byte 3
  Sign: 1 | Exponent: 8 | Coefficient: 23

- node
  A 4-byte integer specifying the node index. However, the following values have special interpretations:
  0xFFFFFFFF
    Indicates that the node is NULL.
  0x80000000 ~ 0xFFFFFFFE
    Indicates that the node exists in an external NVF. In this case, the lower 31 bits comprise the index of the external node table.

#### Format

NVF was created based on IFF. (Although NIFF and IFF have similar names, they are completely unrelated.)

The IFF file is composed of fixed format Chunks.

CHUNK MAGIC 4 bytes
CHUNK DATA SIZE 4 bytes
DATA The length is the byte size specified by CHUNK DATA SIZE.

However, the Chunks are not enumerated as they are in the file. There is a special Chunk called 'FORM' which comprises a number of Chunks, and all the Chunks are contained in this. At the present time, one file can contain only one FORM.

CHUNK MAGIC 4 bytes ('FORM')
CHUNK DATA SIZE 4 bytes
DATA | FORM MAGIC 4 bytes 'NVFB'
CHUNK 1
CHUNK 2
....

In NVF, 1 Chunk expresses 1 node. There are various types of nodes, and each of them has its own Chunk Magic. However, there are three kinds of Chunks which are used for purposes other than nodes, as described below.

- 'NHDR'
  This is the header. It holds information relating to the entire NVF. Naturally, it appears only once in the form. The format is shown below.

  >       Header 'NHDR' {
  >         long    num_of_nodes
  >         long    num_of_root_nodes
  >         long    root_node_index[num_of_root_nodes]
  >         long    symbol_table_size
  >         char    symbol_table[symbol_table_size]
  >         long    comment_size
  >         char    comment[comment_size]
  >       }

- 'REFR'
  This Chunk describes the relationship between nodes. It appears only once in the form. The format is shown below.

  >       ReferenceList 'REFR' {
  >         long    num_of_references
  >         {
  >           short type( 0: FtoF, 1: FtoL, 2: LtoF, 3: LtoL )
  >           short size
  >           node  target
  >           short target_field
  >           short target_index
  >           node  reference
  >           short reference_field
  >           short reference_index
  >         } reference[num_of_references]
  >       }

- 'XTRN'
  This Chunk describes external nodes. It appears only once in the form. The format is shown below.

  >       ExternalSymbolList 'XTRN' {
  >         long    num_of_symbols
  >         {
  >           long   module_id
  >           long   node_name_entry
  >         } symbol[num_of_symbols]
  >       }

Index

### NVF Node Reference

AGEO | AnimatedGeometry
ANMF | Animation
CSCL | ClassicScale
FNCC | ConstantFunction
DFOG | DepthFog
DRUC | DirUpConstraint
DIRC | DirectionConstraint
LGTD | DirectionalLight
ENVG | EnvelopeGeometry
EVVC | EnvelopeVertexC
EVVN | EnvelopeVertexN
FLOT | Float
GEOM | Geometry
FNCH | HermiteFunction

LTST | LightSet
FNCL | LinearFunction
LODD | Lod
MRKR | Marker
MTRL | Material
MDUL | Module
NOPR | Nop
ORNT | Orientation
ORIC | OrientationConstraint
PCAM | PerspectiveCamera
POSC | PositionConstraint
RXYZ | RotationXYZ
ROTY | RotationY
RZXY | RotationZXY

SCAL | Scale
SHAP | Shape
SK22 | Skeleton2d2
SKP2 | SkeletonPx2
SKU2 | SkeletonUv2
SWCH | Switch
TXTR | Texture
TXIM | TextureImage
TLUT | TextureLut
XFMI | TransformInfo
XLAT | Translation
VTXI | VertexInterpolator

Index

### AnimatedGeometry

>       AnimatedGeometry 'AGEO' {
>         long    name_entry
>         node    vertex
>         float   time        :0
>       }

Defines geometry with attached animation.

Node Reference

### Animation

>       Animation 'ANMF' {
>         long    name_entry
>         long    num_of_elements
>         long    num_of_functions
>         long    function_index               :0
>         float   time                         :1
>         float   value[num_of_elements]       :2
>         float   diffential[num_of_elements]  :3
>         node    function[num_of_functions]
>       }

Defines floating point vector animation. num_of_elements indicates the size of vector.

Node Reference

### ClassicScale

>       ClassicalScale 'CSCL' {
>         long    name_entry
>         float3  scale               :0
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float9  scaled_orientation  :1
>       }

ClassicScale specifies the scaling rate, or degree of enlargement. All children are influenced by this coordinate transformation.

Node Reference

### ConstantFunction

>       ConstantFunction 'FNCC' {
>         long    name_entry
>         char    num_of_elements
>         char    continuity
>                 # 0: Noncontinuous
>                 # 1: C0 Continuous
>                 # 2: C1 Continuous
>         long    num_of_keys
>         float   junction
>                 # The junction point time for continuous animation.
>                 # It is ignored for noncontinuous animation.
>                 # At the present time, junction is not yet functional.
>         {
>           float time
>           float value[num_of_elements]
>         } key[num_of_keys]
>       }

Defines the animation keyframe function. ConstantFunction switches constants over time, so you could call it a zero-order interpolation function. The function node is not functional on its own. It starts functioning after being referenced from the animation node.

Node Reference

### DepthFog

>       Fog 'DFOG' {
>         long    name_entry
>         float   fog_near   :0
>         float   fog_far    :1
>         float4  fog_color  :2
>       }

Sets the Fog. The behavior when effective Fog appears in the scene graph numerous times is undefined.

Node Reference

### DirUpConstraint

>       DirUpConstraint 'DRUC' {
>         long    name_entry
>         float3  direction           :0
>         float3  up_vector           :1
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float9  global_orientation  :2
>       }

DirUpConstraint turns the X axis to the direction of the global "direction" and the Y axis to the direction of the global "up_vector." However, the Y axis is corrected so that it is at a right angle to the X axis. All children are influenced by this coordinate transformation.

Node Reference

### DirectionConstraint

>       DirConstraint 'DIRC' {
>         long    name_entry
>         float3  direction           :0
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float9  global_orientation  :1
>       }

DirConstraint turns the X axis to the direction of the global "direction." The Y axis is corrected so that it is orthogonal to the X axis. All children are influenced by this coordinate transformation.

Node Reference

### DirectionalLight

>       DirectionalLight 'LGTD' {
>         long    name_entry
>         float3  direction  :0
>         float3  color      :1
>                 # Values from 0 ~ 1.
>       }

Defines the directional light source. The light source node does not function on its own. It starts functioning after being referenced from the light source set node.

Node Reference

### EnvelopeGeometry

>       EnvelopeGeometry 'ENVG' {
>         long    name_entry
>         node    vertex
>         long    num_of_joints
>         {
>           float9 orientation  :0 (index = joint_index * 9)
>           float3 translation  :1 (index = joint_index * 3)
>           float3 scale        :2 (index = joint_index * 3)
>         } joint[num_of_joints]
>       }

Defines the geometry of the Flexible envelope. The vertex type must be either EnvelopeVertexC or EnvelopeVertexN.

Node Reference

### EnvelopeVertexC

>       EnvelopeVertexC 'EVVC' {
>         long    name_entry
>         long    segment
>         short   num_of_joints
>         short   num_of_rigid_groups
>         short   num_of_morph_groups
>         short   num_of_combine_groups
>         long    num_of_vertex_groups

>         # The following is the description for all rigid groups:
>         {
>           short  joint_index
>           short  num_of_vertices
>           {
>             short3  coord
>             char4   normal/color
>             short2  tex_coord
>           } vtx[num_of_vertices]
>         } rigid_group[num_of_rigid_groups]

>         # The following is the description for all morph groups:
>         {
>           short  primary_joint_index
>           short  secondary_joint_index
>           short  num_of_vertices
>           short  num_of_coords
>           short  table_size
>                  # At present, 9, 17, 33 and 65 are supported.
>           {
>             float3  coord[num_of_coords]
>           } table[table_size]
>           {
>             short   coord_index
>             char4   color
>             short2  tex_coord
>           } vtx[num_of_vertices]
>         } morph_group[num_of_morph_groups]

>         # The following is the description for all combine groups:
>         {
>           short  num_of_vertices
>           short  num_of_coords
>           short  num_of_joint_groups
>           {
>             short  joint_index
>             short  num_of_joint_vertices
>             {
>               short   vtx_index
>               float3  coord
>                       # The result of multiplying the actual "coord" by "weight"
>               float   weight
>             } joint_vertex[num_of_joint_vertices]
>           } joint_group[num_of_joint_groups]
>           {
>             short   coord_index
>             char4   color
>             short2  tex_coord
>           } vtx[num_of_vertices]
>         } combine_group[num_of_combine_groups]

>         # The following is information for triangle setup:
>         {
>           short   rigid_group_index
>           short   rigid_vtx_offset
>           char    rigid_vtx_cache_offset
>           char    rigid_vtx_load_count
>           short   morph_group_index
>           short   morph_vtx_offset
>           char    morph_vtx_cache_offset
>           char    morph_vtx_load_count
>           short   combine_group_index
>           short   combine_vtx_offset
>           char    combine_vtx_cache_offset
>           char    combine_vtx_load_count
>           long    num_of_modification_group
>           {
>             char    num_of_rgba_modification
>             char    num_of_st_modification
>             char    num_of_xy_modification
>             char    num_of_z_modification
>             long    num_of_triangles
>             {
>               char    vertex_index
>               char4   rgba
>             } rgba_modification[num_of_rgba_modification]
>             {
>               char    vertex_index
>               short2  st
>             } st_modification[num_of_st_modification]
>             {
>               char    vertex_index
>               short2  xy
>             } xy_modification[num_of_xy_modification]
>             {
>               char    vertex_index
>               long    z
>             } z_modification[num_of_z_modification]
>             char3   triangle[num_of_triangles]
>           } modification_group[num_of_modification_group]
>         } vertex_group[num_of_vertex_groups]
>       }

Defines the vertices of the Flexible Envelope. However, normals are not calculated. (Therefore, lighting is impossible.) The vertices of the Flexible Envelope are classified into three types: rigid vertex, morph vertex and combine vertex.

1. A rigid vertex is a vertex which has 100% weight for any and every joint.
2. A morph vertex is a vertex which has weight for only two joints. The inner product of the x axes of the two joints works as a parameter to change the weight.
3. A combine vertex refers to all other vertices.

The method for calculating each type of vertex is explained below.

- Rigid vertex
  The transformation matrix of the joint is used for the coordinate transformation, just like in a conventional coordinate transformation.
- Morph vertex
  The angles of the two joints are used as parameters for morphing. A table is created in degree units of 180/(the number of tables - 1).
- Combine vertex
  The basic implementation for weighted vertices.

Node Reference

### EnvelopeVertexN

>       EnvelopeVertexN 'EVVN' {
>         long    name_entry
>         long    segment
>         short   num_of_joints
>         short   num_of_rigid_groups
>         short   num_of_morph_groups
>         short   num_of_combine_groups
>         long    num_of_vertex_groups

>         # The following is the description for all rigid groups:
>         {
>           short  joint_index
>           short  num_of_vertices
>           {
>             short3  coord
>             char4   normal/color
>             short2  tex_coord
>           } vtx[num_of_vertices]
>         } rigid_group[num_of_rigid_groups]

>         # The following is the description for all morph groups:
>         {
>           short  primary_joint_index
>           short  secondary_joint_index
>           short  num_of_vertices
>           short  num_of_coords
>           short  num_of_normals
>           short  table_size
>                  # At present, 9, 17, 33 and 65 are supported.
>           {
>             float3  coord[num_of_coords]
>             float3  normal[num_of_normals]
>           } table[table_size]
>           {
>             short   coord_index
>             short   normal_index
>             short2  tex_coord
>           } vtx[num_of_vertices]
>         } morph_group[num_of_morph_groups]

>         # The following is the description for all combine groups:
>         {
>           short  num_of_vertices
>           short  num_of_coords
>           short  num_of_normals
>           short  num_of_joint_groups
>           {
>             short  joint_index
>             short  num_of_joint_coords
>             short  num_of_joint_normals
>             {
>               short   coord_index
>               float3  coord
>                       #  The result of multiplying the actual "coord" by "weight"
>               float   weight
>             } joint_vertex[num_of_joint_coords]
>             {
>               short   normal_index
>               float3  normal
>                       #  The result of multiplying the actual "normal" by "weight"
>             } joint_vertex[num_of_joint_normals]
>           } joint_group[num_of_joint_groups]
>           {
>             short   coord_index
>             short   normal_index
>             short2  tex_coord
>           } vtx[num_of_vertices]
>         } combine_group[num_of_combine_groups]

>         # The following is the information for triangle setup:
>         {
>           short   rigid_group_index
>           short   rigid_vtx_offset
>           char    rigid_vtx_cache_offset
>           char    rigid_vtx_load_count
>           short   morph_group_index
>           short   morph_vtx_offset
>           char    morph_vtx_cache_offset
>           char    morph_vtx_load_count
>           short   combine_group_index
>           short   combine_vtx_offset
>           char    combine_vtx_cache_offset
>           char    combine_vtx_load_count
>           long    num_of_modification_group
>           {
>             char    num_of_rgba_modification
>             char    num_of_st_modification
>             char    num_of_xy_modification
>             char    num_of_z_modification
>             long    num_of_triangles
>             {
>               char    vertex_index
>               char4   rgba
>             } rgba_modification[num_of_rgba_modification]
>             {
>               char    vertex_index
>               short2  st
>             } st_modification[num_of_st_modification]
>             {
>               char    vertex_index
>               short2  xy
>             } xy_modification[num_of_xy_modification]
>             {
>               char    vertex_index
>               long    z
>             } z_modification[num_of_z_modification]
>             char3   triangle[num_of_triangles]
>           } modification_group[num_of_modification_group]
>         } vertex_group[num_of_vertex_groups]
>       }

Defines the vertices of the Flexible Envelope. Unlike EnvelopeVertexC, normal lines are also calculated. (In other words, Lighting is possible.) The data contents are almost the same as for EnvelopeVertexC.

Node Reference

### Float

>       Float 'FLOT' {
>         long    name_entry
>         long    num_of_elements
>         float   value[ num_of_elements ]  :0
>       }

This does nothing except hold floating point values. It is convenient for collectively managing the values set in the time field of Animation, etc..

Node Reference

### Geometry

>       Geometry 'GEOM' {
>         long    name_entry
>         long    segment
>         long    num_of_vertices
>         {
>           short3  coord
>           char4   normal/color
>           short2  tex_coord
>         } vtx[num_of_vertices]
>         long    num_of_vertex_groups
>         {
>           short   vertex_offset
>           char    vertex_cache_offset
>           char    vertex_load_count
>                   # The above three parameters are for vertex loading.
>           long    num_of_modification_group
>           {
>             char    num_of_rgba_modification
>             char    num_of_st_modification
>             char    num_of_xy_modification
>             char    num_of_z_modification
>             long    num_of_triangles
>             {
>               char    vertex_index
>               char4   rgba
>             } rgba_modification[num_of_rgba_modification]
>             {
>               char    vertex_index
>               short2  st
>             } st_modification[num_of_st_modification]
>             {
>               char    vertex_index
>               short2  xy
>             } xy_modification[num_of_xy_modification]
>             {
>               char    vertex_index
>               long    z
>             } z_modification[num_of_z_modification]
>               # The above parameters are the vertex-change parameters.
>             char3   triangle[num_of_triangles]
>           } modification_group[num_of_modifi_group]
>         } vertex_group[num_of_vertex_groups]
>       }

Defines the geometry. In Geometry, triangles are classified according to their modification_group. A number of modification_groups are then gathered together forming a vertex_group. The Geometry drawing process is illustrated below.

>       for each vertex_group do
>         Read vertices into vertex cache.
>         for each modification_group do
>           Changes the vertices in accordance with the vertex-change parameters.
>           Draw triangles.
>         done
>       done

Node Reference

### HermiteFunction

>       HermiteFunction 'FNCH' {
>         long    name_entry
>         char    num_of_elements
>         char    continuity
>                 # 0: Discontinuous
>                 # 1: C0 Continuous
>                 # 2: C1 Continuous
>         long    num_of_keys
>         float   junction
>                 # At present, junction is not yet functional.
>         {
>           float time
>           float value[num_of_elements]
>           float differential[num_of_elements]
>         } key[num_of_keys]
>       }

Defines a key frame function of animation. HermiteFunction is a trilinear interpolation function. A function node does not function alone. It will function only after it is referenced from an animation node. The interpolation formula is as follows:

then

Node Reference

### LightSet

>       LightSet 'LTST' {
>         long    name_entry
>         float3  ambient  :0
>                 # Values from 0 ~ 1.
>         long    num_of_lights
>         node    lights[num_of_lights]
>       }

Defines a set of light sources. This node is related to the material node and performs lighting.

Node Reference

### LinearFunction

>       LinearFunction 'FNCL' {
>         long    name_entry
>         char    num_of_elements
>         char    continuity
>                 # 0: Discontinuous
>                 # 1: C0 Continuous
>                 # 2: C1 Continuous
>         long    num_of_keys
>         float   junction
>                 # At present, junction is not yet functional.
>         {
>           float time
>           float value[num_of_elements]
>         } key[num_of_keys]
>       }

Defines the animation keyframe function. LinearFunction is a first-order interpolation function. The function node is not functional on its own. It starts functioning after being referenced from the animation node.

Node Reference

### Lod

>       LOD 'LODD' {
>         long    name_entry
>         char    group( 0 ~ 31 )
>         char    num_of_levels
>         float   range[num_of_levels-1]
>         node    level[num_of_levels]
>       }

The LOD node selects the appropriate node from the nodes enumerated in "level" corresponding to the present distance between the global_translation and the camera. The LOD node is not evaluated until evaluation of the active camera is finished.

Node Reference

### Marker

>       Marker 'MRKR' {
>         long  name_entry
>         short type
>         short group_index
>       }

This node is used for displaying the coordinate icons. The red coordinate icon corresponds to the X axis, the green to the Y axis, and the blue to the Z axis.

Node Reference

### Material

>       Material 'MTRL' {
>         long    name_entry
>         node    light_set
>         float4  ambient              :0
>                 # Value from 0 ~ 255.
>         float4  emission             :1
>                 # Value from 0 ~ 255.
>         float4  diffuse              :2
>                 # Value from 0 ~ 255.
>         float4  primitive_color      :3
>                 # Value from 0 ~ 255.
>         float4  primitive_color_fog  :4
>                 # Value from 0 ~ 255.
>         char    lighting
>                 # 0: No lighting.
>                 # 1: With lighting.
>         char    shade_model
>                 # 0: flat
>                 # 1: smooth
>         char    effect
>                 # 0: none
>                 # 1: specular
>                 # 2: reflection
>         char    env_color_mode
>                 # &1: emission
>                 # &2: ambient
>                 # Specifies which components to add to env_color.  The components added to
>                 # env_color are not added to shade_color.
>         {
>           char4   CC0color
>                   # In order of A, B, C,D.
>                   #  0: CombColor
>                   #  1: Tex0Color
>                   #  2: Tex1Color
>                   #  3: PrimColor
>                   #  4: ShadeColor
>                   #  5: EnvColor
>                   #  6: KeyCenter(B only),KeyScale(C only),1.0(A,D only)
>                   #  7: CombAlpha(C only),Noise(A only),K4(B only),0.0(D only)
>                   #  8: Tex0Alpha(C only)
>                   #  9: Tex1Alpha(C only)
>                   # 10: PrimAlpha(C only)
>                   # 11: ShadeAlpha(C only)
>                   # 12: EnvAlpha(C only)
>                   # 13: LODFrac(C only)
>                   # 14: PrimLODFrac(C only)
>                   # 15: K5(C only)
>                   # 31: 0.0
>           char4   CC0alpha
>                   # In order of A, B, C, D.
>                   #  0: CombAlpha(A,B,D only),LODFrac(C only)
>                   #  1: Tex0Alpha
>                   #  2: Tex1Alpha
>                   #  3: PrimAlpha
>                   #  4: ShadeAlpha
>                   #  5: EnvAlpha
>                   #  6: PrimLODFrac(C only),1.0(A,B,D only)
>                   #  7: 0.0
>           char4   CC1color
>                   # The same as CC0color.
>           char4   CC1alpha
>                   # The same as CC0alpha.
>         } cc_mode[2]
>       }

Defines the material. The material mechanism has been changed significantly since NIFF1.0. In NIFF1.0, shade was monochrome, but in NIFF2.0, colors were added in consideration of ambient, emission, and diffuse. Because of this change, the method for setting the color combiner is also different. Shade is calculated using the following expression.

>       shade = mat_emission + light_ambient*mat_ambient + light[0]*mat_diffuse[0]*d[0] + ....

Here, d[I] is the "diffuse" coefficient determined from the direction of light source "I" and the normal line of the vertex.

Node Reference

### Module

>       Module 'MDUL' {
>         long    name_entry
>         long    module_id
>       }

Defines Module. The Module behaves as if the whole Module has become a child of this node.

Node Reference

### Nop

>       Nop 'NOPR' {
>         long    name_entry
>         long    num_of_children
>         node    child[num_of_children]
>       }

Does nothing.

Node Reference

### Orientation

>       Orientation 'ORNT' {
>         long    name_entry
>         float3  ex                  :0
>         float3  ey                  :1
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float9  global_orientation  :2
>       }

Orientation specifies the direction of the X axis and the direction of the Y axis to create a rotation matrix. The Y axis is corrected so that it is orthogonal to the X axis. All children are influenced by this coordinate transformation. In addition, ex and ey are assured to be stored in a contiguous area, and ex[3] is handled in the same manner as ey[0]. By utilizing this, it becomes possible to attach 6-element animation. If you use 6-element animation the keyframe compression rate will probably be lower than with 3-element animation, but the tradeoff is a boost in processing speed.

Node Reference

### OrientationConstraint

>       OriConstraint 'ORIC' {
>         long    name_entry
>         float9  orientation         :0
>         long    num_of_children
>         node    child[num_of_children]
>       }

OriConstraint specifies the rotation matrix as a global matrix. All children are influenced by this coordinate transformation.

Node Reference

### PerspectiveCamera

>       PerspectiveCamera 'PCAM' {
>         long    name_entry
>         float   field_of_view_y  :0
>         float   aspect_ratio     :1
>         float   clip_near        :2
>         float   clip_far         :3
>         float   tan_clip_left    :4
>         float   tan_clip_right   :5
>         float   tan_clip_top     :6
>         float   tan_clip_bottom  :7
>         long    group_mask
>       }

Defines the camera perspective. field_of_view_y is specified in degrees.

Node Reference

### PositionConstraint

>       PositionConstraint 'POSC' {
>         long    name_entry
>         float3  translation      :0
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float3  global_position  :1
>       }

PositionConstraint specifies the translation with global vectors. All children are influenced by this coordinate transformation.

Node Reference

### RotationXYZ

>       RotationXYZ 'RXYZ' {
>         long    name_entry
>         float3  rotation            :0
>                 # radian value
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float9  global_orientation  :1
>       }

RotationXYZ rotates in order around the X, Y and Z axes. All children are influenced by this coordinate transformation.

Node Reference

### RotationY

>       RotationY 'ROTY' {
>         long    name_entry
>         float   rotation            :0
>                 # radian value
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float9  global_orientation  :1
>       }

RotationY rotates around the Y axis. All children are influenced by this coordinate transformation.

Node Reference

### RotationZXY

>       RotationZXY 'RZXY' {
>         long    name_entry
>         float3  rotation            :0
>                 # radian value
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float9  global_orientation  :1
>       }

RotationZXY rotates in order around the Z, X and Y axes. All children are influenced by this coordinate transformation.

Node Reference

### Scale

>       Scale 'SCAL' {
>         long    name_entry
>         float3  scale         :0
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float3  global_scale  :1
>       }

Scale specifies the SOFTIMAGE format scale of enlargement. This method of enlargement is particularly effective with character animation. All children are influenced by this coordinate transformation.

Node Reference

### Shape

>       Shape 'SHAP' {
>         long    name_entry
>         char    group( 0 ~ 31 )
>         char    cull_face( &1:front face, &2:back face )
>         char    vertex_mode
>                 # &1: use_vertex_color
>                 # &2: use_vertex_alpha
>         char    z_enable;
>                 # 0: Do not use ZBUFFER.
>                 # 1: Use ZBUFFER.
>         char    cycle[2]( 0:fill, 1:1 cyc., 2:2 cyc. 3:copy )
>         {
>           char4   BL0
>                   # In order of P, A, M, B
>                   # For P, M
>                   #  0: InColor
>                   #  1: MemColor
>                   #  2: BlendColor
>                   #  3: FogColor
>                   # For A
>                   #  0: InAlpha
>                   #  1: FogAlpha
>                   #  2: ShadeAlpha
>                   #  3: 0.0
>                   # For B
>                   #  0: 1-A
>                   #  1: MemAlpha
>                   #  2: 1.0
>                   #  3: 0.0
>           char4   BL1
>                   # The same as BL0
>           short   render_mode
>                   # &8: AA_EN
>                   # &0x10: Z_CMP
>                   # &0x20: Z_UPD
>                   # &0x40: IM_RD
>                   # &0x80: CLR_ON_CVG
>                   # &0x300 = 0x000: CVG_DST_CLAMP
>                   # &0x300 = 0x100: CVG_DST_WRAP
>                   # &0x300 = 0x200: CVG_DST_FULL
>                   # &0x300 = 0x300: CVG_DST_SAVE
>                   # &0xC00 = 0x000: ZMODE_OPA
>                   # &0xC00 = 0x400: ZMODE_INTER
>                   # &0xC00 = 0x800: ZMODE_XLU
>                   # &0xC00 = 0xC00: ZMODE_DEC
>                   # &0x1000: CVG_X_ALPHA
>                   # &0x2000: ALPHA_CVG_SEL
>                   # &0x4000: FORCE_BL
>         } render_mode[2]
>         node    geometry
>         node    material
>         node    texture
>       }

Integrates geometry, material and texture, and creates the drawing object.

Node Reference

### Skeleton2d2

>       Skeleton2D2 'SK22' {
>         long    name_entry
>         long    flip
>         float   bone_length[2]  :0
>         float3  effector_pos    :1
>         float3  axis            :2
>       output:
>         float9  orientation1    :3
>         float3  translation1    :4
>         float9  orientation2    :5
>         float3  translation2    :6
>       }

Defines Skeleton. Skeleton is the node used for processing inverse kinematics. "axis" is a vector indicating the extent to which the Z axis differs from its original direction. The inverse kinematics algorithm is omitted here.

Node Reference

### SkeletonPx2

>       SkeletonPX2 'SKP2' {
>         long    name_entry
>         long    flip
>         float   bone_length[2]  :0
>         float3  effector_pos    :1
>         float3  z_pos           :2
>         float3  axis            :3
>       output:
>         float9  orientation1    :4
>         float3  translation1    :5
>         float9  orientation2    :6
>         float3  translation2    :7
>       }

Defines Skeleton. Skeleton is the node used for processing inverse kinematics. "axis" is a vector indicating the extent to which the Z axis differs from its original direction. The difference between SkeletonPx2 and Skeleton2d2 is that SkeletonPx2 can specify the Z axis direction by using z_pos. The inverse kinematics algorithm is omitted here.

Node Reference

### SkeletonUv2

>       SkeletonUV2 'SKU2' {
>         long    name_entry
>         long    flip
>         float   bone_length[2]  :0
>         float3  effector_pos    :1
>         float3  resplane_pos    :2
>         float3  axis            :3
>       output:
>         float9  orientation1    :4
>         float3  translation1    :5
>         float9  orientation2    :6
>         float3  translation2    :7
>       }

Defines Skeleton. Skeleton is the node used for processing inverse kinematics. "axis" is a vector indicating the extent to which the Z axis differs from its original direction. The difference between SkeletonUv2 and Skeleton2d2 is that SkeletonUv2 can specify the Y axis direction by using resplane_pos. The inverse kinematics algorithm is omitted here.

Node Reference

### Switch

>       Switch 'SWCH' {
>         long    name_entry
>         long    num_of_choice
>         long    which_choice  :0
>         node    choice[num_of_choice]
>       }

Switch selects the node specified by which_choice. When which_choice is 0xFFFFFFFF, no "choice" is selected.

Node Reference

### Texture

>       Texture 'TXTR' {
>         long    name_entry
>         node    image
>         node    lut
>         short   scaling_s
>         short   scaling_t
>         char    mipmap
>                 # 0: Do not use MipMap.
>                 # 1: Use MipMap.
>         char    texture_detail
>                 # 0: clamp
>                 # 1: sharp
>                 # 2: detail
>         char    filter
>                 # 0: nearest
>                 # 1: bilinear
>                 # 2: average
>         char    perspective_correction
>                 # 0: No perspective correction.
>                 # 1: Perspective correction.
>         char    yuv_color_convert
>                 # 0: Do not use YUV color conversion.
>                 # 1: Use YUV color conversion.
>         char    num_of_tiles
>     	    # The maximum is 7 tiles.  (For the sake of "run time" optimization.)
>         {
>           long    texel_offset
>           char    format
>                   # 0: I4
>                   # 1: I8
>                   # 2: IA31
>                   # 3: IA44
>                   # 4: IA88
>                   # 5: RGBA5551
>                   # 6: RGBA8888
>                   # 7: YUV
>                   # 8: CI4
>                   # 9: CI8
>           char    lut_offset
>                   # The actual LUT offset is the sum of the Texture's lut_offset
>                   # and the tile's lut_offset.
>           short   stride
>                   # The width of the tile in "word" units
>           short   s0
>           short   t0
>           short   s1
>           short   t1
>           char    clamp_mode_s
>                   # &1: mirror
>                   # &2: clamp
>           char    clamp_mode_t
>                   # The same as clamp_mode_s.
>           char    shift_s
>           char    shift_t
>           char    mask_s
>           char    mask_t
>         } tile[num_of_tiles]
>       }

Defines the Texture. The image and the color table are not defined in the Texture node. What mainly is defined is tile-related information.

Node Reference

### TextureImage

>       TextureImage 'TXIM' {
>         long    name_entry
>         long    segment
>         long    texel_size
>         char8   texel[texel_size]
>       }

Defines the texture image.

Node Reference

### TextureLut

>       TextureLUT 'TLUT' {
>         long    name_entry
>         char    segment
>         char    format
>                 # 0:RGBA5551
>                 # 1:IA88
>         short   lut_size
>         short   lut[lut_size]
>       }

Defines the texture color table.

Node Reference

### TransformInfo

>       TransformInfo 'XFMI' {
>         long    name_entry
>       output:
>         float3  global_scale        :0
>         float3  global_cls_scale    :1
>         float3  global_position     :2
>         float9  global_orientation  :3
>       }

This does nothing, but it is used when referencing the coordinate transformation information.

Node Reference

### Translation

>       Translation 'XLAT' {
>         long    name_entry
>         float3  translation      :0
>         long    num_of_children
>         node    child[num_of_children]
>       output:
>         float3  global_position  :1
>       }

Translation specifies the translation. All children are influenced by this coordinate transformation.

Node Reference

### VertexInterpolator

>       VertexInterpolator 'VTXI' {
>         long    name_entry
>         long    segment
>     	    # The segment number of the vertex storage buffer.
>         short   num_of_vertices

>         # The following is the coordinate information
>         short   coord_interpolation_type;
>                 # 0: constant
>                 # 1: linear
>         short   num_of_coord_tables
>                 # When num_of_coord_tables is set to 1, the coord component is not interpolated.
>         short   num_of_coords
>         {
>           float   key
>           short3  coord[num_of_coords]
>         } coord_table[num_of_coord_tables]

>         # The following is the normal line information
>         short   normal_interpolation_type;
>                 # 0: constant
>                 # 1: linear
>         short   num_of_normal_tables
>                 # When num_of_normal_tables is set to 1,
>                 # the normal component is not interpolated.
>         short   num_of_normals
>         {
>           float   key
>           char4  normal[num_of_normals]
>         } normal_table[num_of_normal_tables]

>         # The following is the texture coordinate information
>         short   tex_coord_interpolation_type;
>                 # 0: constant
>                 # 1: linear
>         short   num_of_tex_coord_tables
>                 # When num_of_tex_coord_tables is set to 1,
>                 # the tex_coord component is not interpolated.
>         short   num_of_tex_coords
>         {
>           float   key
>           short2  tex_coord[num_of_tex_coords]
>         } tex_coord_table[num_of_tex_coord_tables]

>         # The following information is for vertex set-up
>         {
>           short   coord_index
>           short   normal_index
>           short   tex_coord_index
>         } index[num_of_vertices]

>         # The following information is for triangle set-up
>         long    num_of_vertex_groups
>         {
>           short   vertex_offset
>           char    vertex_cache_offset
>           char    vertex_load_count
>           long    num_of_modification_group
>           {
>             char    num_of_rgba_modification
>             char    num_of_st_modification
>             char    num_of_xy_modification
>             char    num_of_z_modification
>             long    num_of_triangles
>             {
>               char    vertex_index
>               char4   rgba
>             } rgba_modification[num_of_rgba_modification]
>             {
>               char    vertex_index
>               short2  st
>             } st_modification[num_of_st_modification]
>             {
>               char    vertex_index
>               short2  xy
>             } xy_modification[num_of_xy_modification]
>             {
>               char    vertex_index
>               long    z
>             } z_modification[num_of_z_modification]
>             char3   triangle[num_of_triangle]
>           } modification_group[num_of_modifi_group]
>         } vertex_group[num_of_vertex_groups]
>       }

Defines the interpolation vertices. These are used in AnimatedGeometry.

Node Reference

### Problems / Limitations

#### Material Compatibility

- EnvColor/TriColor
  EnvColor and TriColor are handled differently in nvfview than they are in n64prev. In nvfview, ambient and emission may be used for EnvColor, and TriColor is not used. In addition, NVF has parameters that cannot be specified by NIFF1.0, but they are interpreted as follows by niff2nvf.

  ambient | 255 | 255 | 255 | 255
  diffuse | 255 | 255 | 255 | 255
  emission | 255 | 255 | 255 | 255
  env_color_mode | emission is output to env_color

  In other words, TriColor is always white.

- Color Combiner
  Since all shading results are stored in ShadeColor/VtxColor with NIFF2.0 material, there is no longer any need to use PrimitiveColor.

#### Large textures

In NVF, textures which exceed 4KB cannot be used. Such large textures are split by converters like niff2nvf.

#### Increased number of nodes

NVF displays a scene by taking nodes with very small functions and combining them together. Therefore, a scene which is simply converted from NIFF to NVF has many meaningless nodes. This increase in the number of nodes leads to an increase in processing time by the viewer's CPU and lowers the viewer's frame rate.

#### The applicable range of ClassicScale

Most Skeletons and Constraints are not influenced by ClassicScale. Rather, these nodes are influenced by Scale.

Index

Copyright 1998-1999 NINTENDO Co.,Ltd./MONEGI CORPORATION All rights reserved.