### Navigation

- index
- modules |
- next |
- previous |
- PyFFI 2.2.2 documentation »
- `pyffi` — Interfacing block structured files »
- `pyffi.formats` — File format interfaces »

# `pyffi.formats.nif` — NetImmerse/Gamebryo (.nif and .kf)

## Implementation

class `pyffi.formats.nif.``NifFormat`

  Bases: `pyffi.object_models.xml.FileFormat`

  This class contains the generated classes from the xml.

  `ARCHIVE_CLASSES` = [<class 'pyffi.formats.bsa.BsaFormat'>]
  class `ATextureRenderData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._ATextureRenderData`, `builtins.object`

    `save_as_dds`(stream)

      Save image as DDS file.

  class `NifFormat.``AVObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Used in NiDefaultAVObjectPalette.

    `av_object`

      Object reference.

    `name`

      Object name.

  class `NifFormat.``AbstractAdditionalGeometryData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

  class `NifFormat.``AdditionalDataBlock`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `block_offsets`

      Unknown

    `block_size`

      Size of Block

    `data`

      Unknown

    `data_sizes`

      Unknown

    `has_data`

      Has data

    `num_blocks`

      Unknown

    `num_data`

      Unknown

  class `NifFormat.``AdditionalDataInfo`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `block_index`

      Unsure. The block in which this channel is stored? Usually there is only one block, and so this is zero.

    `channel_offset`

      Offset (in bytes) of this channel. Sum of all num channel bytes per element of all preceeding block infos.

    `data_type`

      Type of data in this channel

    `num_channel_bytes`

      Total number of bytes of this channel (num vertices times num bytes per element)

    `num_channel_bytes_per_element`

      Number of bytes per element of this channel

    `num_total_bytes_per_element`

      Number of bytes per element in all channels together. Sum of num channel bytes per element over all block infos.

    `unknown_byte_1`

      Unknown, usually equal to 2.

  class `NifFormat.``AlphaFormat`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    An unsigned 32-bit integer, describing how transparency is handled in a texture.

    `ALPHA_BINARY` = 1
    `ALPHA_DEFAULT` = 3
    `ALPHA_NONE` = 0
    `ALPHA_SMOOTH` = 2
  class `NifFormat.``AnimationType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Animation type used on this position. This specifies the function of this position.

    `Lean` = 4
    `Sit` = 1
    `Sleep` = 2
  class `NifFormat.``ApplyMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    An unsigned 32-bit integer, describing the apply mode of a texture.

    `APPLY_DECAL` = 1
    `APPLY_HILIGHT` = 3
    `APPLY_HILIGHT2` = 4
    `APPLY_MODULATE` = 2
    `APPLY_REPLACE` = 0
  class `NifFormat.``ArkTexture`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A texture reference used by NiArkTextureExtraData.

    `texture_name`
    `texturing_property`
    `unknown_bytes`
    `unknown_int_3`
    `unknown_int_4`
  class `NifFormat.``AvoidNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Morrowind specific?

  class `NifFormat.``BSAnimNotes`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Bethesda-specific node.

    `unknown_short_1`

      Unknown

  class `NifFormat.``BSBehaviorGraphExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Links a nif with a Havok Behavior .hkx animation file

    `behaviour_graph_file`

      Name of the hkx file.

    `controls_base_skeleton`

      Unknown, has to do with blending appended bones onto an actor.

  class `NifFormat.``BSBlastNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-Specific node.

    `unknown_byte_1`

      Unknown

    `unknown_short_2`

      Unknown

  class `NifFormat.``BSBoneLODExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown

    `bone_l_o_d_count`

      Number of bone entries

    `bone_l_o_d_info`

      Bone Entry

  class `NifFormat.``BSBound`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._BSBound`, `builtins.object`

    `apply_scale`(scale)

      Scale data.

  class `NifFormat.``BSDamageStage`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-Specific node.

    `unknown_byte_1`

      Unknown

    `unknown_short_2`

      Unknown

  class `NifFormat.``BSDebrisNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-Specific node.

    `unknown_byte_1`

      Unknown

    `unknown_short_2`

      Unknown

  class `NifFormat.``BSDecalPlacementVectorExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Bethesda-specific node. (for dynamic decal projection?)

    `num_vector_blocks`

      Number of groups

    `unknown_float_1`

      Unknown

    `vector_blocks`

      Number of Blocks

  class `NifFormat.``BSDismemberBodyPartType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Biped bodypart data used for visibility control of triangles. Options are Fallout 3, except where marked for Skyrim (uses SBP prefix)Skyrim BP names are listed only for vanilla names, different creatures have different defnitions for naming.

    `BP_BRAIN` = 13
    `BP_HEAD` = 1
    `BP_HEAD2` = 2
    `BP_LEFTARM` = 3
    `BP_LEFTARM2` = 4
    `BP_LEFTLEG` = 7
    `BP_LEFTLEG2` = 8
    `BP_LEFTLEG3` = 9
    `BP_RIGHTARM` = 5
    `BP_RIGHTARM2` = 6
    `BP_RIGHTLEG` = 10
    `BP_RIGHTLEG2` = 11
    `BP_RIGHTLEG3` = 12
    `BP_SECTIONCAP_BRAIN` = 113
    `BP_SECTIONCAP_HEAD` = 101
    `BP_SECTIONCAP_HEAD2` = 102
    `BP_SECTIONCAP_LEFTARM` = 103
    `BP_SECTIONCAP_LEFTARM2` = 104
    `BP_SECTIONCAP_LEFTLEG` = 107
    `BP_SECTIONCAP_LEFTLEG2` = 108
    `BP_SECTIONCAP_LEFTLEG3` = 109
    `BP_SECTIONCAP_RIGHTARM` = 105
    `BP_SECTIONCAP_RIGHTARM2` = 106
    `BP_SECTIONCAP_RIGHTLEG` = 110
    `BP_SECTIONCAP_RIGHTLEG2` = 111
    `BP_SECTIONCAP_RIGHTLEG3` = 112
    `BP_TORSO` = 0
    `BP_TORSOCAP_BRAIN` = 213
    `BP_TORSOCAP_HEAD` = 201
    `BP_TORSOCAP_HEAD2` = 202
    `BP_TORSOCAP_LEFTARM` = 203
    `BP_TORSOCAP_LEFTARM2` = 204
    `BP_TORSOCAP_LEFTLEG` = 207
    `BP_TORSOCAP_LEFTLEG2` = 208
    `BP_TORSOCAP_LEFTLEG3` = 209
    `BP_TORSOCAP_RIGHTARM` = 205
    `BP_TORSOCAP_RIGHTARM2` = 206
    `BP_TORSOCAP_RIGHTLEG` = 210
    `BP_TORSOCAP_RIGHTLEG2` = 211
    `BP_TORSOCAP_RIGHTLEG3` = 212
    `BP_TORSOSECTION_BRAIN` = 13000
    `BP_TORSOSECTION_HEAD` = 1000
    `BP_TORSOSECTION_HEAD2` = 2000
    `BP_TORSOSECTION_LEFTARM` = 3000
    `BP_TORSOSECTION_LEFTARM2` = 4000
    `BP_TORSOSECTION_LEFTLEG` = 7000
    `BP_TORSOSECTION_LEFTLEG2` = 8000
    `BP_TORSOSECTION_LEFTLEG3` = 9000
    `BP_TORSOSECTION_RIGHTARM` = 5000
    `BP_TORSOSECTION_RIGHTARM2` = 6000
    `BP_TORSOSECTION_RIGHTLEG` = 10000
    `BP_TORSOSECTION_RIGHTLEG2` = 11000
    `BP_TORSOSECTION_RIGHTLEG3` = 12000
    `SBP_130_HEAD` = 130
    `SBP_131_HAIR` = 131
    `SBP_141_LONGHAIR` = 141
    `SBP_142_CIRCLET` = 142
    `SBP_143_EARS` = 143
    `SBP_150_DECAPITATEDHEAD` = 150
    `SBP_230_HEAD` = 230
    `SBP_30_HEAD` = 30
    `SBP_31_HAIR` = 31
    `SBP_32_BODY` = 32
    `SBP_33_HANDS` = 33
    `SBP_34_FOREARMS` = 34
    `SBP_35_AMULET` = 35
    `SBP_36_RING` = 36
    `SBP_37_FEET` = 37
    `SBP_38_CALVES` = 38
    `SBP_39_SHIELD` = 39
    `SBP_40_TAIL` = 40
    `SBP_41_LONGHAIR` = 41
    `SBP_42_CIRCLET` = 42
    `SBP_43_EARS` = 43
    `SBP_44_DRAGON_BLOODHEAD_OR_MOD_MOUTH` = 44
    `SBP_45_DRAGON_BLOODWINGL_OR_MOD_NECK` = 45
    `SBP_46_DRAGON_BLOODWINGR_OR_MOD_CHEST_PRIMARY` = 46
    `SBP_47_DRAGON_BLOODTAIL_OR_MOD_BACK` = 47
    `SBP_48_MOD_MISC1` = 48
    `SBP_49_MOD_PELVIS_PRIMARY` = 49
    `SBP_50_DECAPITATEDHEAD` = 50
    `SBP_51_DECAPITATE` = 51
    `SBP_52_MOD_PELVIS_SECONDARY` = 52
    `SBP_53_MOD_LEG_RIGHT` = 53
    `SBP_54_MOD_LEG_LEFT` = 54
    `SBP_55_MOD_FACE_JEWELRY` = 55
    `SBP_56_MOD_CHEST_SECONDARY` = 56
    `SBP_57_MOD_SHOULDER` = 57
    `SBP_58_MOD_ARM_LEFT` = 58
    `SBP_59_MOD_ARM_RIGHT` = 59
    `SBP_60_MOD_MISC2` = 60
    `SBP_61_FX01` = 61
  class `NifFormat.``BSDismemberSkinInstance`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._BSDismemberSkinInstance`, `builtins.object`

    `get_dismember_partitions`()

      Return triangles and body part indices.

  class `NifFormat.``BSDistantTreeShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderProperty`

    Bethesda-specific node.

  class `NifFormat.``BSEffectShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Skyrim non-PP shader model, used primarily for transparency effects.

    `emissive_color`

      Emissive color

    `emissive_multiple`

      Multipled Emissive Colors

    `falloff_start_angle`
    `falloff_start_opacity`

      Texture will fade in within this proximity.

    `falloff_stop_angle`
    `falloff_stop_opacity`
    `greyscale_texture`

      points to an external texture.

    `shader_flags_1`
    `shader_flags_2`
    `soft_falloff_depth`
    `source_texture`

      points to an external texture.

    `texture_clamp_mode`

      How to handle texture borders.

    `uv_offset`

      Offset UVs

    `uv_scale`

      Offset UV Scale to repeat tiling textures

  class `NifFormat.``BSEffectShaderPropertyColorController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Unkown

    `unknown_int_1`

      Unknown

  class `NifFormat.``BSEffectShaderPropertyFloatController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    This controller is used to animate variables in BSEffectShaderPropertyFloatController, target is a number in order they appear:0: Visibility?1:2:3:4: Emissive or Saturation?5: Alpha Transparency6: U Offset7: U Scale8: V Offset9: V Scale

    `target_variable`

      Unknown

  class `NifFormat.``BSFadeNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-specific fade node.

  class `NifFormat.``BSFrustumFOVController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Bethesda-specific node.

    `interpolator`

      Frustrum field of view animation interpolater and data.

  class `NifFormat.``BSFurnitureMarker`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown. Marks furniture sitting positions?

    `num_positions`

      Number of positions.

    `positions`

      Unknown. Probably has something to do with the furniture positions?

  class `NifFormat.``BSFurnitureMarkerNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSFurnitureMarker`

    Furniture Marker for actors

  class `NifFormat.``BSInvMarker`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Orientation marker for Skyrim’s inventory view.How to show the nif in the player’s inventory.Typically attached to the root node of the nif tree.If not present, then Skyrim will still show the nif in inventory,using the default values.Name should be ‘INV’ (without the quotes).For rotations, a short of “4712” appears as “4.712” but “959” appears as “0.959” meshesweaponsdaedricdaedricbowskinned.nif

    `rotation_x`
    `rotation_y`
    `rotation_z`
    `zoom`

      Zoom factor.

  class `NifFormat.``BSKeyframeController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiKeyframeController`

    An extended keyframe controller.

    `data_2`

      A link to more keyframe data.

  class `NifFormat.``BSLODTriShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriBasedGeom`

    A variation on NiTriShape, for visibility control over vertex groups.

    `level_0_size`

      Unknown

    `level_1_size`

      Unknown

    `level_2_size`

      Unknown

  class `NifFormat.``BSLagBoneController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    A controller that trails a bone behind an actor.

    `linear_rotation`

      How the bone lags rotation

    `linear_velocity`

      How long it takes to rotate about an actor back to rest position.

    `maximum_distance`

      How far bone will tail an actor.

  class `NifFormat.``BSLeafAnimNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Unknown, related to trees.

  class `NifFormat.``BSLightingShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Skyrim PP shader for assigning material/shader/texture.

    `alpha`

      The materials opacity (1=non-transparent).

    `emissive_color`

      Glow color and alpha

    `emissive_multiple`

      Multiplied emissive colors

    `environment_map_scale`

      Scales the environment/cube map. (0-??)

    `eye_cubemap_scale`

      Eye cubemap scale

    `glossiness`

      The material’s specular power, or glossiness (0-999).

    `hair_tint_color`

      Tints the base texture. Overridden by game settings.

    `left_eye_reflection_center`

      Offset to set center for left eye cubemap

    `lighting_effect_1`

      Controls strength for envmap/backlight/rim/softlight lighting effect?

    `lighting_effect_2`

      Controls strength for envmap/backlight/rim/softlight lighting effect?

    `max_passes`

      Max Passes

    `parallax_envmap_strength`

      How strong the environment/cube map is. (0-??)

    `parallax_inner_layer_texture_scale`

      Scales the inner parallax layer texture.

    `parallax_inner_layer_thickness`

      How far from the surface the inner layer appears to be.

    `parallax_refraction_scale`

      Depth of inner parallax layer effect.

    `right_eye_reflection_center`

      Offset to set center for right eye cubemap

    `scale`

      Scale

    `shader_flags_1`

      Skyrim Shader Flags for setting render/shader options.

    `shader_flags_2`

      Skyrim Shader Flags for setting render/shader options.

    `skin_tint_color`

      Tints the base texture. Overridden by game settings.

    `sparkle_parameters`

      Unknown/unused? CK lists “snow material” when used.

    `specular_color`

      Adds a colored highlight.

    `specular_strength`

      Brightness of specular highlight. (0=not visible) (0-999)

    `texture_clamp_mode`

      How to handle texture borders.

    `texture_set`

      Texture Set, can have override in an esm/esp

    `unknown_float_2`

      Unknown

    `uv_offset`

      Offset UVs

    `uv_scale`

      Offset UV Scale to repeat tiling textures, see above.

  class `NifFormat.``BSLightingShaderPropertyColorController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    `target_variable`

      Which variable in the shader to animate.

  class `NifFormat.``BSLightingShaderPropertyFloatController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    This controller is used to animate variables in BSLightingShaderPropertyFloatController, target is a number in order they appear:5: U Offset6: V Offset7: U Scale8: V Scale

    `target_variable`

      Which variable in the shader to animate.

  class `NifFormat.``BSLightingShaderPropertyShaderType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Values for configuring the shader type in a BSLightingShaderProperty

    `Default` = 0
    `Heightmap` = 3
    `WorldMap1` = 9
    `WorldMap2` = 13
    `WorldMap3` = 15
    `WorldMap4` = 18
  class `NifFormat.``BSMasterParticleSystem`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-Specific node.

    `max_emitter_objects`

      Unknown

    `num_particle_systems`

      Unknown

    `particle_systems`

      Unknown

  class `NifFormat.``BSMaterialEmittanceMultController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Bethesda-Specific node.

  class `NifFormat.``BSMultiBound`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Bethesda-specific node.

    `data`

      Unknown.

  class `NifFormat.``BSMultiBoundAABB`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSMultiBoundData`

    Bethesda-specific node.

    `extent`

      Extent of the AABB in all directions

    `position`

      Position of the AABB’s center

  class `NifFormat.``BSMultiBoundData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Abstract base type for bounding data.

  class `NifFormat.``BSMultiBoundNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-specific node.

    `multi_bound`

      Unknown.

    `unknown_int`

      Unknown

  class `NifFormat.``BSMultiBoundOBB`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSMultiBoundData`

    Oriented bounding box.

    `center`

      Center of the box.

    `rotation`

      Rotation of the bounding box.

    `size`

      Size of the box along each axis.

  class `NifFormat.``BSMultiBoundSphere`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSMultiBoundData`

    Bethesda-specific node.

    `radius`

      Radius

    `unknown_int_1`

      Unknown Flag

    `unknown_int_2`

      Unknown Flag

    `unknown_int_3`

      Unknown Flag

  class `NifFormat.``BSNiAlphaPropertyTestRefController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiAlphaController`

    Unkown

  class `NifFormat.``BSOrderedNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-Specific node.

    `alpha_sort_bound`

      Unknown

    `is_static_bound`

      Unknown

  class `NifFormat.``BSPSysArrayEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysVolumeEmitter`

    Particle emitter that uses a node, its children and subchildren to emit from. Emission will be evenly spread along points from nodes leading to their direct parents/children only.

  class `NifFormat.``BSPSysHavokUpdateModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    `modifier`

      Unknown

    `nodes`

      Group of target NiNodes?

    `num_nodes`

      Unknown

  class `NifFormat.``BSPSysInheritVelocityModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    `unknown_float_1`

      Unknown

    `unknown_float_2`

      Unknown

    `unknown_float_3`

      Unknown

    `unknown_int_1`

      Unknown

  class `NifFormat.``BSPSysLODModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    `uknown_float_1`

      Unknown

    `uknown_float_2`

      Unknown

    `uknown_float_3`

      Unknown

    `uknown_float_4`

      Unknown

  class `NifFormat.``BSPSysMultiTargetEmitterCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

    Particle system (multi?) emitter controller.

    `data`

      This controller’s data

    `unknown_int_1`

      Unknown

    `unknown_short_1`

      Unknown

    `visibility_interpolator`

      Links to a bool interpolator. Controls emitter’s visibility status?

  class `NifFormat.``BSPSysRecycleBoundModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    `unknown_float_1`

      Unknown

    `unknown_float_2`

      Unknown

    `unknown_float_3`

      Unknown

    `unknown_float_4`

      Unknown

    `unknown_float_5`

      Unknown

    `unknown_float_6`

      Unknown

    `unknown_int_1`

      Unknown

  class `NifFormat.``BSPSysScaleModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    `floats`

      Unknown

    `num_floats`
  class `NifFormat.``BSPSysSimpleColorModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Bethesda-Specific Particle node.

    `color_1_end_percent`

      Unknown

    `color_1_start_percent`

      Unknown

    `color_2_end_percent`

      Unknown

    `color_2_start_percent`

      Unknown

    `colors`

      Colors

    `fade_in_percent`

      Unknown

    `fade_out_percent`

      Unknown

  class `NifFormat.``BSPSysStripUpdateModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Bethesda-Specific (mesh?) Particle System Modifier.

    `update_delta_time`

      Unknown

  class `NifFormat.``BSPSysSubTexModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Similar to a Flip Controller, this handles particle texture animation on a single texture atlas

    `end_frame`

      Ending frame/position on atlas

    `frame_count`

      Unknown

    `frame_count_fudge`

      Unknown

    `loop_start_frame`

      Frame to start looping

    `loop_start_frame_fudge`
    `start_frame`

      Starting frame/position on atlas

    `start_frame_fudge`

      Random chance to start on a different frame?

  class `NifFormat.``BSPackedAdditionalDataBlock`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `atom_sizes`

      The sum of all of these equal num total bytes per element, so this probably describes how each data element breaks down into smaller chunks (i.e. atoms).

    `block_offsets`

      Block offsets in the data? Usually equal to zero.

    `data`

      Unknown

    `has_data`

      Has data

    `num_atoms`

      Number of atoms?

    `num_blocks`

      Number of blocks? Usually equal to one.

    `num_total_bytes`

      Total number of bytes (over all channels and all elements, equals num total bytes per element times num vertices).

    `num_total_bytes_per_element`

      Unsure, but this seems to correspond again to the number of total bytes per element.

    `unknown_int_1`
  class `NifFormat.``BSPackedAdditionalGeometryData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.AbstractAdditionalGeometryData`

    `block_infos`

      Number of additional data blocks

    `blocks`

      Number of additional data blocks

    `num_block_infos`

      Information about additional data blocks

    `num_blocks`

      Number of additional data blocks. Usually there is exactly one block.

    `num_vertices`
  class `NifFormat.``BSParentVelocityModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Particle modifier that adds a blend of object space translation and rotation to particles born in world space.

    `damping`

      Amount of blending?

  class `NifFormat.``BSPartFlag`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.bit_struct.BitStructBase`

    `pf_editor_visible`
    `pf_start_net_boneset`
    `reserved_bits_1`
  class `NifFormat.``BSProceduralLightningController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Skyrim, Paired with dummy TriShapes, this controller generates lightning shapes for special effects.First interpolator controls Generation.

    `byte_1`

      Unknown

    `byte_2`

      Unknown

    `byte_3`

      Unknown

    `distance_weight`

      How far lightning will stretch to.

    `float_2`

      Unknown

    `float_5`

      Unknown

    `fork`

      Influences forking behavior

    `interpolator_10`

      Unknown, unsure if this is actually another interpolator link.

    `interpolator_2_mutation`

      References interpolator for Mutation of strips

    `interpolator_3`

      Unknown

    `interpolator_4`

      Unknown

    `interpolator_5`

      Unknown

    `interpolator_6`

      Unknown

    `interpolator_7`

      Unknown

    `interpolator_8`

      Unknown

    `interpolator_9_arc_offset`

      References interpolator for Amplitutde control. 0=straight, 50=wide

    `strip_width`

      How wide the bolt will be

    `unknown_short_1`

      Unknown

    `unknown_short_2`

      Unknown

    `unknown_short_3`

      Unknown

  class `NifFormat.``BSRefractionFirePeriodController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Bethesda-specific node.

    `interpolator`

      Link to Interpolator.

  class `NifFormat.``BSRefractionStrengthController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Bethesda-Specific node.

  class `NifFormat.``BSRotAccumTransfInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTransformInterpolator`

  class `NifFormat.``BSSegment`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Bethesda-specific node.

    `flags`

      Geometry present in the segment

    `internal_index`

      Index multiplied by 1536 (0x0600)

    `unknown_byte_1`

      Unknown

  class `NifFormat.``BSSegmentFlags`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.bit_struct.BitStructBase`

    `bsseg_water`
    `reserved_bits_0`
  class `NifFormat.``BSSegmentedTriShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriShape`

    Bethesda-specific node.

    `num_segments`

      Number of segments in the square grid

    `segment`

      Configuration of each segment

  class `NifFormat.``BSShaderFlags`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.bit_struct.BitStructBase`

    `sf_alpha_texture`
    `sf_decal_single_pass`
    `sf_dynamic_alpha`
    `sf_dynamic_decal_single_pass`
    `sf_empty`
    `sf_environment_mapping`
    `sf_external_emittance`
    `sf_eye_environment_mapping`
    `sf_face_gen`
    `sf_fire_refraction`
    `sf_hair`
    `sf_localmap_hide_secret`
    `sf_low_detail`
    `sf_multiple_textures`
    `sf_non_projective_shadows`
    `sf_parallax_occulsion`
    `sf_parallax_shader_index_15`
    `sf_refraction`
    `sf_remappable_textures`
    `sf_shadow_frustum`
    `sf_shadow_map`
    `sf_single_pass`
    `sf_skinned`
    `sf_specular`
    `sf_tree_billboard`
    `sf_unknown_1`
    `sf_unknown_2`
    `sf_unknown_3`
    `sf_unknown_4`
    `sf_vertex_alpha`
    `sf_window_environment_mapping`
    `sf_z_buffer_test`
  class `NifFormat.``BSShaderLightingProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderProperty`

    Bethesda-specific property.

    `unknown_int_3`

      Unknown

  class `NifFormat.``BSShaderNoLightingProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderLightingProperty`

    Bethesda-specific property.

    `file_name`

      The texture glow map.

    `unknown_float_2`

      Unknown

    `unknown_float_3`

      Normally what appears to be a junk value (0xB33BBD2E). Appears to be related to glow when Unk Flags is (0x82000148).

    `unknown_float_4`

      Unknown

    `unknown_float_5`

      Unknown

  class `NifFormat.``BSShaderPPLightingProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderLightingProperty`

    Bethesda-specific Shade node.

    `emissive_color`

      Glow color and alpha

    `refraction_period`

      Rate of texture movement for refraction shader.

    `texture_set`

      Texture Set

    `unknown_float_2`

      Unknown

    `unknown_float_4`

      Unknown

    `unknown_float_5`

      Unknown

  class `NifFormat.``BSShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Bethesda-specific Property node

    `envmap_scale`

      Unknown

    `flags`

      Unknown

    `shader_flags`

      Shader Property Flags

    `shader_type`

      Unknown (Set to 0x21 for NoLighting, 0x11 for Water)

    `unknown_int_2`

      Unknown

  class `NifFormat.``BSShaderTextureSet`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Bethesda-specific Texture Set.

    `num_textures`

      Number of Textures

    `textures`

      Textures.0: Diffuse1: Normal/Gloss2: Glow/Skin/Hair3: Height/Parallax4: Environment5: Environment Mask

  class `NifFormat.``BSShaderType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The type of animation interpolation (blending) that will be used on the associated key frames.

    `SHADER_DEFAULT` = 1
    `SHADER_LIGHTING30` = 29
    `SHADER_NOLIGHTING` = 33
    `SHADER_SKIN` = 14
    `SHADER_SKY` = 10
    `SHADER_TALL_GRASS` = 0
    `SHADER_TILE` = 32
    `SHADER_WATER` = 17
  class `NifFormat.``BSSkyShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Skyrim Sky shader block.

    `shader_flags_1`
    `shader_flags_2`
    `sky_object_type`

      Sky Object Type

    `source_texture`

      points to an external texture.

    `uv_offset`

      Offset UVs. Seems to be unused, but it fits with the other Skyrim shader properties.

    `uv_scale`

      Offset UV Scale to repeat tiling textures, see above.

  class `NifFormat.``BSStripPSysData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysData`

    Bethesda-Specific (mesh?) Particle System Data.

    `unknown_byte_6`

      Unknown

    `unknown_float_8`

      Unknown

    `unknown_int_7`

      Unknown

    `unknown_short_5`

      Unknown

  class `NifFormat.``BSStripParticleSystem`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleSystem`

    Bethesda-Specific (mesh?) Particle System.

  class `NifFormat.``BSTreadTransfInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpolator`

    Bethesda-specific node.

    `data`

      Unknown float data.

    `num_tread_transforms`

      Unknown.

    `tread_transforms`

      Unknown.

  class `NifFormat.``BSTreadTransform`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Bethesda-specific node.

    `name`

      Name of affected node?

    `transform_1`

      Transform data.

    `transform_2`

      Transform data.

  class `NifFormat.``BSTreadTransformData`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Bethesda-specific node.

    `rotation`

      Rotation.

    `scale`

      Scale (usually float_min).

    `translation`

      Translation.

  class `NifFormat.``BSTreeNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Node for handling Trees, Switches branch configurations for variation?

    `bones`

      Unknown

    `bones_1`

      Unknown

    `num_bones_1`

      Unknown

    `num_bones_2`

      Unknown

  class `NifFormat.``BSValueNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-Specific node. Found on fxFire effects

    `unknown_byte`

      Unknown

    `value`

      Value

  class `NifFormat.``BSWArray`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Bethesda-specific node.

    `items`

      Unknown

    `num_items`

      Unknown

  class `NifFormat.``BSWaterShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Skyrim water shader property, different from “WaterShaderProperty” seen in Fallout.

    `shader_flags_1`
    `shader_flags_2`
    `unknown_short_3`

      Unknown, flag?

    `uv_offset`

      Offset UVs. Seems to be unused, but it fits with the other Skyrim shader properties.

    `uv_scale`

      Offset UV Scale to repeat tiling textures, see above.

    `water_direction`

      A bitflag, only the first/second bit controls water flow positive or negative along UVs.

    `water_shader_flags`

      Defines attributes for the water shader (will use SkyrimWaterShaderFlags)

  class `NifFormat.``BSWindModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Particle Modifier that uses the wind value from the gamedata to alter the path of particles.

    `strength`

      The amount of force wind will have on particles.

  class `NifFormat.``BSXFlags`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiIntegerExtraData`

    Controls animation and collision. Integer holds flags:Bit 0 : enable havok, bAnimated(Skyrim)Bit 1 : enable collision, bHavok(Skyrim)Bit 2 : is skeleton nif?, bRagdoll(Skyrim)Bit 3 : enable animation, bComplex(Skyrim)Bit 4 : FlameNodes present, bAddon(Skyrim)Bit 5 : EditorMarkers presentBit 6 : bDynamic(Skyrim)Bit 7 : bArticulated(Skyrim)Bit 8 : bIKTarget(Skyrim)Bit 9 : Unknown(Skyrim)

  class `NifFormat.``BillboardMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Determines the way the billboard will react to the camera.

    `ALWAYS_FACE_CAMERA` = 0
    `ALWAYS_FACE_CENTER` = 3
    `RIGID_FACE_CAMERA` = 2
    `RIGID_FACE_CENTER` = 4
    `ROTATE_ABOUT_UP` = 1
    `ROTATE_ABOUT_UP2` = 9
  `NifFormat.``BlockTypeIndex`

    alias of `UShort`

  class `NifFormat.``BodyPartList`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Body part list for DismemberSkinInstance

    `body_part`

      Body Part Index

    `part_flag`

      Flags related to the Body Partition

  class `NifFormat.``BoneLOD`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Stores Bone Level of Detail info in a BSBoneLODExtraData

    `bone_name`

      The bones name

    `distance`

      Distance to cull?

  class `NifFormat.``BoundVolumeType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `BASE_BV` = 4294967295
    `BOX_BV` = 1
    `CAPSULE_BV` = 2
    `HALFSPACE_BV` = 5
    `SPHERE_BV` = 0
    `UNION_BV` = 4
  class `NifFormat.``BoundingBox`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Bounding box.

    `radius`

      Radius, per direction.

    `rotation`

      Rotation matrix.

    `translation`

      Translation vector.

    `unknown_int`

      Usually 1.

  class `NifFormat.``BoundingVolume`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `box`

      Box

    `capsule`

      Capsule

    `collision_type`

      Type of collision data.

    `half_space`

      Half Space

    `sphere`

      Sphere

    `union`

      Union

  class `NifFormat.``BoxBV`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Box Bounding Volume

    `axis`

      Axis

    `center`

      Center

    `extent`

      Extent

  class `NifFormat.``ByteArray`(**kwargs)

    Bases: `pyffi.object_models.xml.basic.BasicBase`

    Array (list) of bytes. Implemented as basic type to speed up reading and also to prevent data to be dumped by __str__.

    `get_hash`(data=None)
    `get_size`(data=None)
    `get_value`()
    `read`(stream, data)
    `set_value`(value)
    `write`(stream, data)
  class `NifFormat.``ByteColor3`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A color without alpha (red, green, blue).

    `b`

      Blue color component.

    `g`

      Green color component.

    `r`

      Red color component.

  class `NifFormat.``ByteColor4`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A color with alpha (red, green, blue, alpha).

    `a`

      Alpha color component.

    `b`

      Blue color component.

    `g`

      Green color component.

    `r`

      Red color component.

  class `NifFormat.``ByteMatrix`(**kwargs)

    Bases: `pyffi.object_models.xml.basic.BasicBase`

    Matrix of bytes. Implemented as basic type to speed up reading and to prevent data being dumped by __str__.

    `get_hash`(data=None)
    `get_size`(data=None)
    `get_value`()
    `read`(stream, data)
    `set_value`(value)
    `write`(stream, data)
  class `NifFormat.``CStreamableAssetData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `root`
    `unknown_bytes`
  class `NifFormat.``CapsuleBV`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Capsule Bounding Volume

    `center`

      Center

    `origin`

      Origin

    `unknown_float_1`

      Unknown.

    `unknown_float_2`

      Unknown.

  class `NifFormat.``ChannelConvention`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `CC_COMPRESSED` = 4
    `CC_EMPTY` = 5
    `CC_FIXED` = 0
    `CC_INDEX` = 3
  class `NifFormat.``ChannelData`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Channel data

    `bits_per_channel`

      Bits per channel

    `convention`

      Data Storage Convention

    `type`

      Channel Type

    `unknown_byte_1`

      Unknown

  class `NifFormat.``ChannelType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `CHNL_ALPHA` = 3
    `CHNL_BLUE` = 2
    `CHNL_COMPRESSED` = 4
    `CHNL_EMPTY` = 19
    `CHNL_GREEN` = 1
    `CHNL_INDEX` = 16
    `CHNL_RED` = 0
  class `NifFormat.``CloningBehavior`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Sets how objects are to be cloned.

    `CLONING_BLANK_COPY` = 2
    `CLONING_COPY` = 1
    `CLONING_SHARE` = 0
  class `NifFormat.``CollisionMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `CM_NOTEST` = 3
    `CM_USE_ABV` = 2
    `CM_USE_NIBOUND` = 4
    `CM_USE_OBB` = 0
    `CM_USE_TRI` = 1
  class `NifFormat.``Color3`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A color without alpha (red, green, blue).

    `b`

      Blue color component.

    `g`

      Green color component.

    `r`

      Red color component.

  class `NifFormat.``Color4`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A color with alpha (red, green, blue, alpha).

    `a`

      Alpha.

    `b`

      Blue component.

    `g`

      Green component.

    `r`

      Red component.

  class `NifFormat.``ComponentFormat`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The data format of components.

    `F_FLOAT16_1` = 66097
    `F_FLOAT16_2` = 131634
    `F_FLOAT16_3` = 197171
    `F_FLOAT16_4` = 262708
    `F_FLOAT32_1` = 66613
    `F_FLOAT32_2` = 132150
    `F_FLOAT32_3` = 197687
    `F_FLOAT32_4` = 263224
    `F_INT16_1` = 66065
    `F_INT16_2` = 131602
    `F_INT16_3` = 197139
    `F_INT16_4` = 262676
    `F_INT32_1` = 66593
    `F_INT32_2` = 132130
    `F_INT32_3` = 197667
    `F_INT32_4` = 263204
    `F_INT8_1` = 65793
    `F_INT8_2` = 131330
    `F_INT8_3` = 196867
    `F_INT8_4` = 262404
    `F_NORMINT16_1` = 66073
    `F_NORMINT16_2` = 131610
    `F_NORMINT16_3` = 197147
    `F_NORMINT16_4` = 262684
    `F_NORMINT32_1` = 66601
    `F_NORMINT32_2` = 132138
    `F_NORMINT32_3` = 197675
    `F_NORMINT32_4` = 263212
    `F_NORMINT8_1` = 65801
    `F_NORMINT8_2` = 131338
    `F_NORMINT8_3` = 196875
    `F_NORMINT8_4` = 262412
    `F_NORMINT_10_10_10_2` = 66621
    `F_NORMINT_10_10_10_L1` = 66618
    `F_NORMINT_11_11_10` = 66619
    `F_NORMUINT16_1` = 66077
    `F_NORMUINT16_2` = 131614
    `F_NORMUINT16_3` = 197151
    `F_NORMUINT16_4` = 262688
    `F_NORMUINT32_1` = 66605
    `F_NORMUINT32_2` = 132142
    `F_NORMUINT32_3` = 197679
    `F_NORMUINT32_4` = 263216
    `F_NORMUINT8_1` = 65805
    `F_NORMUINT8_2` = 131342
    `F_NORMUINT8_3` = 196879
    `F_NORMUINT8_4` = 262416
    `F_NORMUINT8_4_BGRA` = 262460
    `F_UINT16_1` = 66069
    `F_UINT16_2` = 131606
    `F_UINT16_3` = 197143
    `F_UINT16_4` = 262680
    `F_UINT32_1` = 66597
    `F_UINT32_2` = 132134
    `F_UINT32_3` = 197671
    `F_UINT32_4` = 263208
    `F_UINT8_1` = 65797
    `F_UINT8_2` = 131334
    `F_UINT8_3` = 196871
    `F_UINT8_4` = 262408
    `F_UINT_10_10_10_2` = 66622
    `F_UINT_10_10_10_L1` = 66617
    `F_UNKNOWN` = 0
  class `NifFormat.``ConsistencyType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Used by NiGeometryData to control the volatility of the mesh. While they appear to be flags they behave as an enum.

    `CT_MUTABLE` = 0
    `CT_STATIC` = 16384
    `CT_VOLATILE` = 32768
  class `NifFormat.``ControllerLink`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._ControllerLink`, `builtins.object`

        >>> from pyffi.formats.nif import NifFormat
        >>> link = NifFormat.ControllerLink()
        >>> link.node_name_offset
        -1
        >>> link.set_node_name("Bip01")
        >>> link.node_name_offset
        0
        >>> link.get_node_name()
        b'Bip01'
        >>> link.node_name
        b'Bip01'
        >>> link.set_node_name("Bip01 Tail")
        >>> link.node_name_offset
        6
        >>> link.get_node_name()
        b'Bip01 Tail'
        >>> link.node_name
        b'Bip01 Tail'

    `get_controller_type`()
    `get_node_name`()

      Return the node name.

          >>> # a doctest
          >>> from pyffi.formats.nif import NifFormat
          >>> link = NifFormat.ControllerLink()
          >>> link.string_palette = NifFormat.NiStringPalette()
          >>> palette = link.string_palette.palette
          >>> link.node_name_offset = palette.add_string("Bip01")
          >>> link.get_node_name()
          b'Bip01'

          >>> # another doctest
          >>> from pyffi.formats.nif import NifFormat
          >>> link = NifFormat.ControllerLink()
          >>> link.node_name = "Bip01"
          >>> link.get_node_name()
          b'Bip01'

    `get_property_type`()
    `get_variable_1`()
    `get_variable_2`()
    `set_controller_type`(text)
    `set_node_name`(text)
    `set_property_type`(text)
    `set_variable_1`(text)
    `set_variable_2`(text)
  class `NifFormat.``CoordGenType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Determines the way that UV texture coordinates are generated.

    `CG_DIFFUSE_CUBE_MAP` = 4
    `CG_SPECULAR_CUBE_MAP` = 3
    `CG_SPHERE_MAP` = 2
    `CG_WORLD_PARALLEL` = 0
    `CG_WORLD_PERSPECTIVE` = 1
  class `NifFormat.``CycleType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The animation cyle behavior.

    `CYCLE_CLAMP` = 2
    `CYCLE_LOOP` = 0
    `CYCLE_REVERSE` = 1
  class `NifFormat.``Data`(version=67108866, user_version=0, user_version_2=0)

    Bases: `pyffi.object_models.Data`

    A class to contain the actual nif data.

    Note that L{header} and L{blocks} are not automatically kept in sync with the rest of the nif data, but they are resynchronized when calling L{write}.

    Variables: | version – The nif version. user_version – The nif user version. user_version_2 – The nif user version 2. roots – List of root blocks. header – The nif header. blocks – List of blocks. modification – Neo Steam (“neosteam”) or Ndoors (“ndoors”) or Joymaster Interactive Howling Sword (“jmihs1”) or Laxe Lore (“laxelore”) style nif?

    class `VersionUInt`(**kwargs)

      Bases: `pyffi.object_models.common.UInt`

      `get_detail_display`()
      `set_value`(value)
    `NifFormat.Data.``get_detail_child_names`(edge_filter=(True, True))
    `NifFormat.Data.``get_detail_child_nodes`(edge_filter=(True, True))
    `NifFormat.Data.``get_global_child_nodes`(edge_filter=(True, True))
    `NifFormat.Data.``inspect`(stream)

      Quickly checks whether the stream appears to contain nif data, and read the nif header. Resets stream to original position.

      Call this function if you only need to inspect the header of the nif.

      Parameters: | stream (`file`) – The file to inspect.

    `NifFormat.Data.``inspect_version_only`(stream)

      This function checks the version only, and is faster than the usual inspect function (which reads the full header). Sets the L{version} and L{user_version} instance variables if the stream contains a valid nif file.

      Call this function if you simply wish to check that a file is a nif file without having to parse even the header.

      Raises ValueError:
      | If the stream does not contain a nif file.
      Parameters: | stream (`file`) – The stream from which to read.

    `NifFormat.Data.``read`(stream)

      Read a nif file. Does not reset stream position.

      Parameters: | stream (`file`) – The stream from which to read.

    `NifFormat.Data.``replace_global_node`(oldbranch, newbranch, edge_filter=(True, True))
    `NifFormat.Data.``user_version`
    `NifFormat.Data.``user_version_2`
    `NifFormat.Data.``version`
    `NifFormat.Data.``write`(stream)

      Write a nif file. The L{header} and the L{blocks} are recalculated from the tree at L{roots} (e.g. list of block types, number of blocks, list of block types, list of strings, list of block sizes etc.).

      Parameters: | stream (file) – The stream to which to write.

  class `NifFormat.``DataStreamAccess`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.bit_struct.BitStructBase`

    `cpu_read`
    `cpu_write_mutable`
    `cpu_write_static`
    `cpu_write_static_inititialized`
    `cpu_write_volatile`
    `gpu_read`
    `gpu_write`
  class `NifFormat.``DataStreamUsage`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Determines how a data stream is used?

    `USAGE_SHADER_CONSTANT` = 2
    `USAGE_USER` = 3
    `USAGE_VERTEX` = 1
    `USAGE_VERTEX_INDEX` = 0
  class `NifFormat.``DeactivatorType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `DEACTIVATOR_INVALID` = 0
    `DEACTIVATOR_NEVER` = 1
    `DEACTIVATOR_SPATIAL` = 2
  class `NifFormat.``DecalVectorArray`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Array of Vectors for Decal placement in BSDecalPlacementVectorExtraData.

    `normals`

      Vector Normals

    `num_vectors`

      Number of sets

    `points`

      Vector XYZ coords

  class `NifFormat.``DecayType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Determines decay function. Used by NiPSysBombModifier.

    `DECAY_EXPONENTIAL` = 2
    `DECAY_LINEAR` = 1
    `DECAY_NONE` = 0
  class `NifFormat.``DistantLODShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderProperty`

    Bethesda-specific node.

  `NifFormat.``EPSILON` = 0.0001
  class `NifFormat.``EffectType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The type of information that’s store in a texture used by a NiTextureEffect.

    `EFFECT_ENVIRONMENT_MAP` = 2
    `EFFECT_FOG_MAP` = 3
    `EFFECT_PROJECTED_LIGHT` = 0
    `EFFECT_PROJECTED_SHADOW` = 1
  class `NifFormat.``ElementReference`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `normalize_flag`

      Whether or not to normalize the data.

    `semantic`

      The element semantic.

  class `NifFormat.``EmitFrom`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Controls which parts of the mesh that the particles are emitted from.

    `EMIT_FROM_EDGE_CENTER` = 2
    `EMIT_FROM_EDGE_SURFACE` = 4
    `EMIT_FROM_FACE_CENTER` = 1
    `EMIT_FROM_FACE_SURFACE` = 3
    `EMIT_FROM_VERTICES` = 0
  class `NifFormat.``EndianType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `ENDIAN_BIG` = 0
    `ENDIAN_LITTLE` = 1
  class `NifFormat.``ExportInfo`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Information about how the file was exported

    `creator`

      Could be the name of the creator of the NIF file?

    `export_info_1`

      Unknown. Can be something like’TriStrip Process Script’.

    `export_info_2`

      Unknown. Possibly the selected option of the export script. Can be something like’Default Export Script’.

    `unknown`

      Probably the number of strings that follow.

  class `NifFormat.``ExtraMeshDataEpicMickey`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `unknown_int_1`
    `unknown_int_2`
    `unknown_int_3`
    `unknown_int_4`
    `unknown_int_5`
    `unknown_int_6`
  class `NifFormat.``ExtraMeshDataEpicMickey2`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `end`
    `start`
    `unknown_shorts`
  class `NifFormat.``FaceDrawMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    This enum lists the different face culling options.

    `DRAW_BOTH` = 3
    `DRAW_CCW` = 1
    `DRAW_CCW_OR_BOTH` = 0
    `DRAW_CW` = 2
  class `NifFormat.``FieldType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The force field’s type.

    `FIELD_POINT` = 1
    `FIELD_WIND` = 0
  class `NifFormat.``FilePath`(**kwargs)

    Bases: `pyffi.formats.nif.string`

    A file path.

    `get_hash`(data=None)

      Returns a case insensitive hash value.

  class `NifFormat.``FileVersion`(**kwargs)

    Bases: `pyffi.object_models.common.UInt`

    `get_detail_display`()
    `read`(stream, data)
    `set_value`()
    `write`(stream, data)
  class `NifFormat.``Flags`(**kwargs)

    Bases: `pyffi.object_models.common.UShort`

  class `NifFormat.``Footer`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._Footer`, `builtins.object`

    `read`(stream, data)
    `write`(stream, data)
  class `NifFormat.``ForceType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The type of force? May be more valid values.

    `FORCE_PLANAR` = 0
    `FORCE_SPHERICAL` = 1
    `FORCE_UNKNOWN` = 2
  class `NifFormat.``FurnitureEntryPoints`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.bit_struct.BitStructBase`

    `behind`
    `front`
    `left`
    `right`
    `up`
  class `NifFormat.``FurniturePosition`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Describes a furniture position?

    `animation_type`

      Unknown

    `entry_properties`

      Unknown/unused in nif?

    `heading`

      Similar to Orientation, in float form.

    `offset`

      Offset of furniture marker.

    `orientation`

      Furniture marker orientation.

    `position_ref_1`

      Refers to a furnituremarkerxx.nif file. Always seems to be the same as Position Ref 2.

    `position_ref_2`

      Refers to a furnituremarkerxx.nif file. Always seems to be the same as Position Ref 1.

  class `NifFormat.``FxButton`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.FxWidget`

    Unknown.

  class `NifFormat.``FxRadioButton`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.FxWidget`

    Unknown.

    `buttons`

      Unknown pointers to other buttons. Maybe other buttons in a group so they can be switch off if this one is switched on?

    `num_buttons`

      Number of unknown links.

    `unknown_int_1`

      Unknown.

    `unknown_int_2`

      Unknown.

    `unknown_int_3`

      Unknown.

  class `NifFormat.``FxWidget`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Firaxis-specific UI widgets?

    `unknown_292_bytes`

      Looks like 9 links and some string data.

    `unknown_3`

      Unknown.

  class `NifFormat.``HairShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderProperty`

    Bethesda-specific node.

  class `NifFormat.``HalfSpaceBV`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `center`

      Center

    `normal`

      Normal

  class `NifFormat.``HavokMaterial`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    A material, used by havok shape objects.

    `HAV_MAT_CHAIN` = 13
    `HAV_MAT_CHAIN_STAIRS` = 28
    `HAV_MAT_CLOTH` = 1
    `HAV_MAT_CLOTH_STAIRS` = 16
    `HAV_MAT_DIRT` = 2
    `HAV_MAT_DIRT_STAIRS` = 17
    `HAV_MAT_ELEVATOR` = 30
    `HAV_MAT_GLASS` = 3
    `HAV_MAT_GLASS_STAIRS` = 18
    `HAV_MAT_GRASS` = 4
    `HAV_MAT_GRASS_STAIRS` = 19
    `HAV_MAT_HEAVY_METAL` = 11
    `HAV_MAT_HEAVY_METAL_STAIRS` = 26
    `HAV_MAT_HEAVY_STONE` = 10
    `HAV_MAT_HEAVY_STONE_STAIRS` = 25
    `HAV_MAT_HEAVY_WOOD` = 12
    `HAV_MAT_HEAVY_WOOD_STAIRS` = 27
    `HAV_MAT_METAL` = 5
    `HAV_MAT_METAL_STAIRS` = 20
    `HAV_MAT_ORGANIC` = 6
    `HAV_MAT_ORGANIC_STAIRS` = 21
    `HAV_MAT_RUBBER` = 31
    `HAV_MAT_SKIN` = 7
    `HAV_MAT_SKIN_STAIRS` = 22
    `HAV_MAT_SNOW` = 14
    `HAV_MAT_SNOW_STAIRS` = 29
    `HAV_MAT_STONE` = 0
    `HAV_MAT_STONE_STAIRS` = 15
    `HAV_MAT_WATER` = 8
    `HAV_MAT_WATER_STAIRS` = 23
    `HAV_MAT_WOOD` = 9
    `HAV_MAT_WOOD_STAIRS` = 24
  class `NifFormat.``Header`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._Header`, `builtins.object`

    `has_block_type`(block_type)

      Check if header has a particular block type.

      Raises ValueError:
      | If number of block types is zero (only nif versions 10.0.1.0 and up store block types in header).
      Parameters: | block_type (L{NifFormat.NiObject}) – The block type.
      Returns: | `True` if the header’s list of block types has the given block type, or a subclass of it. `False` otherwise.
      Return type: | `bool`

  class `NifFormat.``HeaderString`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.basic.BasicBase`

    `get_detail_display`()
    `get_hash`(data=None)
    `get_size`(data=None)
    `read`(stream, data)
    static `version_string`(version, modification=None)

      Transforms version number into a version string.

          >>> NifFormat.HeaderString.version_string(0x03000300)
          'NetImmerse File Format, Version 3.03'
          >>> NifFormat.HeaderString.version_string(0x03010000)
          'NetImmerse File Format, Version 3.1'
          >>> NifFormat.HeaderString.version_string(0x0A000100)
          'NetImmerse File Format, Version 10.0.1.0'
          >>> NifFormat.HeaderString.version_string(0x0A010000)
          'Gamebryo File Format, Version 10.1.0.0'
          >>> NifFormat.HeaderString.version_string(0x0A010000,
          ...                                       modification="neosteam")
          'NS'
          >>> NifFormat.HeaderString.version_string(0x14020008,
          ...                                       modification="ndoors")
          'NDSNIF....@....@...., Version 20.2.0.8'
          >>> NifFormat.HeaderString.version_string(0x14030009,
          ...                                       modification="jmihs1")
          'Joymaster HS1 Object Format - (JMI), Version 20.3.0.9'

    `write`(stream, data)
  class `NifFormat.``HingeDescriptor`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    This constraint allows rotation about a specified axis.

    `axle_a`

      Axis of rotation.

    `axle_b`

      Axle A in second entity coordinate system.

    `perp_2_axle_in_a_1`

      Vector in the rotation plane which defines the zero angle.

    `perp_2_axle_in_a_2`

      Vector in the rotation plane, orthogonal on the previous one, which defines the positive direction of rotation. This is always the vector product of Axle A and Perp2 Axle In A1.

    `perp_2_axle_in_b_1`

      Perp2 Axle In A1 in second entity coordinate system.

    `perp_2_axle_in_b_2`

      Perp2 Axle In A2 in second entity coordinate system.

    `pivot_a`

      Pivot point around which the object will rotate.

    `pivot_b`

      Pivot A in second entity coordinate system.

  class `NifFormat.``ImageType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Determines how the raw image data is stored in NiRawImageData.

    `RGB` = 1
    `RGBA` = 2
  class `NifFormat.``InertiaMatrix`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._InertiaMatrix`, `builtins.object`

    `as_list`()

      Return matrix as 3x3 list.

    `as_tuple`()

      Return matrix as 3x3 tuple.

    `get_copy`()

      Return a copy of the matrix.

    `is_identity`()

      Return `True` if the matrix is close to identity.

    `set_identity`()

      Set to identity matrix.

  class `NifFormat.``Key`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A generic key with support for interpolation. Type 1 is normal linear interpolation, type 2 has forward and backward tangents, and type 3 has tension, bias and continuity arguments. Note that color4 and byte always seem to be of type 1.

    `backward`

      The key backward tangent.

    `forward`

      Key forward tangent.

    `tbc`

      The key’s TBC.

    `time`

      Time of the key.

    `value`

      The key value.

  class `NifFormat.``KeyGroup`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Array of vector keys (anything that can be interpolated, except rotations).

    `interpolation`

      The key type.

    `keys`

      The keys.

    `num_keys`

      Number of keys in the array.

  class `NifFormat.``KeyType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The type of animation interpolation (blending) that will be used on the associated key frames.

    `CONST_KEY` = 5
    `LINEAR_KEY` = 1
    `QUADRATIC_KEY` = 2
    `TBC_KEY` = 3
    `XYZ_ROTATION_KEY` = 4
  class `NifFormat.``LODRange`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    The distance range where a specific level of detail applies.

    `far_extent`

      End of Range.

    `near_extent`

      Begining of range.

    `unknown_ints`

      Unknown (0,0,0).

  class `NifFormat.``LightMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    An unsigned 32-bit integer, describing how vertex colors influence lighting.

    `LIGHT_MODE_EMISSIVE` = 0
    `LIGHT_MODE_EMI_AMB_DIF` = 1
  class `NifFormat.``Lighting30ShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderPPLightingProperty`

    Bethesda-specific node.

  class `NifFormat.``LimitedHingeDescriptor`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._LimitedHingeDescriptor`, `builtins.object`

    `update_a_b`(transform)

      Update B pivot and axes from A using the given transform.

  class `NifFormat.``LineString`(**kwargs)

    Bases: `pyffi.object_models.xml.basic.BasicBase`

    Basic type for strings ending in a newline character (0x0a).

        >>> from tempfile import TemporaryFile
        >>> f = TemporaryFile()
        >>> l = NifFormat.LineString()
        >>> f.write('abcdefg\x0a'.encode())
        8
        >>> f.seek(0)
        0
        >>> l.read(f)
        >>> str(l)
        'abcdefg'
        >>> f.seek(0)
        0
        >>> l.set_value('Hi There')
        >>> l.write(f)
        >>> f.seek(0)
        0
        >>> m = NifFormat.LineString()
        >>> m.read(f)
        >>> str(m)
        'Hi There'

    `get_hash`(data=None)
    `get_size`(data=None)
    `get_value`()
    `read`(stream, data=None)
    `set_value`(value)
    `write`(stream, data=None)
  class `NifFormat.``MTransform`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `rotation`

      Rotation.

    `scale`

      Scale.

    `translation`

      Translation.

  class `NifFormat.``MatchGroup`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Group of vertex indices of vertices that match.

    `num_vertices`

      Number of vertices in this group.

    `vertex_indices`

      The vertex indices.

  class `NifFormat.``MaterialData`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Data stored per-material by NiRenderObject

    `material_extra_data`

      Extra data associated with the material?

    `material_name`

      The name of the material.

  class `NifFormat.``Matrix22`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A 2x2 matrix of float values. Stored in OpenGL column-major format.

    `m_11`

      Member 1,1 (top left)

    `m_12`

      Member 1,2 (top right)

    `m_21`

      Member 2,1 (bottom left)

    `m_22`

      Member 2,2 (bottom right)

  class `NifFormat.``Matrix33`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._Matrix33`, `builtins.object`

    `as_list`()

      Return matrix as 3x3 list.

    `as_tuple`()

      Return matrix as 3x3 tuple.

    `get_copy`()

      Return a copy of the matrix.

    `get_determinant`()

      Return determinant.

    `get_inverse`()

      Get inverse (assuming is_scale_rotation is true!).

    `get_scale`()

      Gets the scale (assuming is_scale_rotation is true!).

    `get_scale_quat`()

      Decompose matrix into scale and quaternion.

    `get_scale_rotation`()

      Decompose the matrix into scale and rotation, where scale is a float and rotation is a C{Matrix33}. Returns a pair (scale, rotation).

    `get_transpose`()

      Get transposed of the matrix.

    `is_identity`()

      Return `True` if the matrix is close to identity.

    `is_rotation`()

      Returns `True` if the matrix is a rotation matrix (a member of SO(3)).

    `is_scale_rotation`()

      Returns true if the matrix decomposes nicely into scale * rotation.

    `set_identity`()

      Set to identity matrix.

    `set_scale_rotation`(scale, rotation)

      Compose the matrix as the product of scale * rotation.

    `sup_norm`()

      Calculate supremum norm of matrix (maximum absolute value of all entries).

  class `NifFormat.``Matrix44`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._Matrix44`, `builtins.object`

    `as_list`()

      Return matrix as 4x4 list.

    `as_tuple`()

      Return matrix as 4x4 tuple.

    `get_copy`()

      Create a copy of the matrix.

    `get_inverse`(fast=True)

      Calculates inverse (fast assumes is_scale_rotation_translation is True).

    `get_matrix_33`()

      Returns upper left 3x3 part.

    `get_scale_quat_translation`()
    `get_scale_rotation_translation`()
    `get_translation`()

      Returns lower left 1x3 part.

    `is_identity`()

      Return `True` if the matrix is close to identity.

    `is_scale_rotation_translation`()
    `set_identity`()

      Set to identity matrix.

    `set_matrix_33`(m)

      Sets upper left 3x3 part.

    `set_rows`(row0, row1, row2, row3)

      Set matrix from rows.

    `set_scale_rotation_translation`(scale, rotation, translation)
    `set_translation`(translation)

      Returns lower left 1x3 part.

    `sup_norm`()

      Calculate supremum norm of matrix (maximum absolute value of all entries).

  class `NifFormat.``MeshData`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `component_semantics`

      Describes the semantic of each component.

    `is_per_instance`

      Sets whether this stream data is per-instance data for use inhardware instancing.

    `num_components`
    `num_submeshes`

      The number of submesh-to-region mappings that this data streamhas.

    `stream`

      Reference to a data stream object which holds the data used bythis reference.

    `submesh_to_region_map`

      A lookup table that maps submeshes to regions.

  class `NifFormat.``MeshPrimitiveType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Describes the type of primitives stored in a mesh object.

    `MESH_PRIMITIVE_LINESTRIPS` = 2
    `MESH_PRIMITIVE_POINTS` = 4
    `MESH_PRIMITIVE_QUADS` = 3
    `MESH_PRIMITIVE_TRIANGLES` = 0
    `MESH_PRIMITIVE_TRISTRIPS` = 1
  class `NifFormat.``MipMap`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Description of a MipMap within a NiPixelData object.

    `height`

      Height of the mipmap image.

    `offset`

      Offset into the pixel data array where this mipmap starts.

    `width`

      Width of the mipmap image.

  class `NifFormat.``MipMapFormat`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    An unsigned 32-bit integer, describing how mipmaps are handled in a texture.

    `MIP_FMT_DEFAULT` = 2
    `MIP_FMT_NO` = 0
    `MIP_FMT_YES` = 1
  class `NifFormat.``Morph`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Geometry morphing data component.

    `frame_name`

      Name of the frame.

    `interpolation`

      Unlike most objects, the presense of this value is not conditional on there being keys.

    `keys`

      The morph key frames.

    `num_keys`

      The number of morph keys that follow.

    `unknown_int`

      Unknown.

    `vectors`

      Morph vectors.

  class `NifFormat.``MorphWeight`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `interpolator`

      Interpolator

    `weight`

      Weight

  class `NifFormat.``MotionQuality`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The motion type. Determines quality of motion?

    `MO_QUAL_BULLET` = 6
    `MO_QUAL_CHARACTER` = 8
    `MO_QUAL_CRITICAL` = 5
    `MO_QUAL_DEBRIS` = 3
    `MO_QUAL_FIXED` = 1
    `MO_QUAL_INVALID` = 0
    `MO_QUAL_KEYFRAMED` = 2
    `MO_QUAL_KEYFRAMED_REPORT` = 9
    `MO_QUAL_MOVING` = 4
    `MO_QUAL_USER` = 7
  class `NifFormat.``MotionSystem`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The motion system. 4 (Box) is used for everything movable. 7 (Keyframed) is used on statics and animated stuff.

    `MO_SYS_BOX` = 4
    `MO_SYS_BOX_STABILIZED` = 5
    `MO_SYS_CHARACTER` = 9
    `MO_SYS_DYNAMIC` = 1
    `MO_SYS_FIXED` = 7
    `MO_SYS_INVALID` = 0
    `MO_SYS_KEYFRAMED` = 6
    `MO_SYS_SPHERE` = 2
    `MO_SYS_SPHERE_INERTIA` = 3
    `MO_SYS_THIN_BOX` = 8
  class `NifFormat.``MotorDescriptor`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `unknown_byte_1`

      Unknown

    `unknown_float_1`

      Unknown

    `unknown_float_2`

      Unknown

    `unknown_float_3`

      Unknown

    `unknown_float_4`

      Unknown

    `unknown_float_5`

      Unknown

    `unknown_float_6`

      Unknown

  class `NifFormat.``MultiTextureElement`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `clamp`

      May be texture clamp mode.

    `filter`

      May be texture filter mode.

    `has_image`

      Looks like a memory address, so probably a bool.

    `image`

      Link to the texture image.

    `ps_2_k`

      -75?

    `ps_2_l`

      0?

    `unknown_short_3`

      Unknown. Usually 0 but sometimes 257

    `uv_set`

      This may be the UV set counting from 1 instead of zero.

  class `NifFormat.``Ni3dsAlphaAnimator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown.

    `num_1`

      Unknown.

    `num_2`

      Unknown.

    `parent`

      The parent?

    `unknown_1`

      Unknown.

    `unknown_2`

      Unknown.

  class `NifFormat.``Ni3dsAnimationNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown. Only found in 2.3 nifs.

    `child`

      Child?

    `count`

      A count.

    `has_data`

      Unknown.

    `name`

      Name of this object.

    `unknown_array`

      Unknown.

    `unknown_floats_1`

      Unknown. Matrix?

    `unknown_floats_2`

      Unknown.

    `unknown_short`

      Unknown.

  class `NifFormat.``Ni3dsColorAnimator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown!

    `unknown_1`

      Unknown.

  class `NifFormat.``Ni3dsMorphShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown!

    `unknown_1`

      Unknown.

  class `NifFormat.``Ni3dsParticleSystem`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown!

    `unknown_1`

      Unknown.

  class `NifFormat.``Ni3dsPathController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown!

    `unknown_1`

      Unknown.

  class `NifFormat.``NiAVObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiAVObject`, `builtins.object`

        >>> from pyffi.formats.nif import NifFormat
        >>> node = NifFormat.NiNode()
        >>> prop1 = NifFormat.NiProperty()
        >>> prop1.name = "hello"
        >>> prop2 = NifFormat.NiProperty()
        >>> prop2.name = "world"
        >>> node.get_properties()
        []
        >>> node.set_properties([prop1, prop2])
        >>> [prop.name for prop in node.get_properties()]
        [b'hello', b'world']
        >>> [prop.name for prop in node.properties]
        [b'hello', b'world']
        >>> node.set_properties([])
        >>> node.get_properties()
        []
        >>> # now set them the other way around
        >>> node.set_properties([prop2, prop1])
        >>> [prop.name for prop in node.get_properties()]
        [b'world', b'hello']
        >>> [prop.name for prop in node.properties]
        [b'world', b'hello']
        >>> node.remove_property(prop2)
        >>> [prop.name for prop in node.properties]
        [b'hello']
        >>> node.add_property(prop2)
        >>> [prop.name for prop in node.properties]
        [b'hello', b'world']

    `add_property`(prop)

      Add the given property to the property list.

      Parameters: | prop (L{NifFormat.NiProperty}) – The property block to add.

    `apply_scale`(scale)

      Apply scale factor on data.

      Parameters: | scale – The scale factor.

    `get_properties`()

      Return a list of the properties of the block.

      Returns: | The list of properties.
      Return type: | `list` of L{NifFormat.NiProperty}

    `get_transform`(relative_to=None)

      Return scale, rotation, and translation into a single 4x4 matrix, relative to the C{relative_to} block (which should be another NiAVObject connecting to this block). If C{relative_to} is `None`, then returns the transform stored in C{self}, or equivalently, the target is assumed to be the parent.

      Parameters: | relative_to – The block relative to which the transform must be calculated. If `None`, the local transform is returned.

    `remove_property`(prop)

      Remove the given property to the property list.

      Parameters: | prop (L{NifFormat.NiProperty}) – The property block to remove.

    `set_properties`(proplist)

      Set the list of properties from the given list (destroys existing list).

      Parameters: | proplist (`list` of L{NifFormat.NiProperty}) – The list of property blocks to set.

    `set_transform`(m)

      Set rotation, translation, and scale, from a 4x4 matrix.

      Parameters: | m – The matrix to which the transform should be set.

  class `NifFormat.``NiAVObjectPalette`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown.

  class `NifFormat.``NiAdditionalGeometryData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.AbstractAdditionalGeometryData`

    `block_infos`

      Number of additional data blocks

    `blocks`

      Number of additional data blocks

    `num_block_infos`

      Information about additional data blocks

    `num_blocks`

      Number of additional data blocks

    `num_vertices`

      Number of vertices

  class `NifFormat.``NiAlphaController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Time controller for transparency.

    `data`

      Alpha controller data index.

  class `NifFormat.``NiAlphaProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Transparency. Flags 0x00ED.

    `flags`

      Bit 0 : alpha blending enableBits 1-4 : source blend modeBits 5-8 : destination blend modeBit 9 : alpha test enableBit 10-12 : alpha test modeBit 13 : no sorter flag ( disables triangle sorting )blend modes (glBlendFunc):0000 GL_ONE0001 GL_ZERO0010 GL_SRC_COLOR0011 GL_ONE_MINUS_SRC_COLOR0100 GL_DST_COLOR0101 GL_ONE_MINUS_DST_COLOR0110 GL_SRC_ALPHA0111 GL_ONE_MINUS_SRC_ALPHA1000 GL_DST_ALPHA1001 GL_ONE_MINUS_DST_ALPHA1010 GL_SRC_ALPHA_SATURATEtest modes (glAlphaFunc):000 GL_ALWAYS001 GL_LESS010 GL_EQUAL011 GL_LEQUAL100 GL_GREATER101 GL_NOTEQUAL110 GL_GEQUAL111 GL_NEVER

    `threshold`

      Threshold for alpha testing (see: glAlphaFunc)

    `unknown_int_2`

      Unknown

    `unknown_short_1`

      Unknown

  class `NifFormat.``NiAmbientLight`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiLight`

    Ambient light source.

  class `NifFormat.``NiArkAnimationExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown node.

    `unknown_bytes`
    `unknown_ints`
  class `NifFormat.``NiArkImporterExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown node.

    `importer_name`

      Contains a string like”Gamebryo_1_1”or”4.1.0.12”

    `unknown_bytes`
    `unknown_floats`
    `unknown_int_1`
    `unknown_int_2`
  class `NifFormat.``NiArkShaderExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown node.

    `unknown_int`
    `unknown_string`
  class `NifFormat.``NiArkTextureExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown node.

    `num_textures`
    `textures`
    `unknown_byte`
    `unknown_int_2`
    `unknown_ints_1`
  class `NifFormat.``NiArkViewportInfoExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown node.

    `unknown_bytes`
  class `NifFormat.``NiAutoNormalParticles`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticles`

    Unknown.

  class `NifFormat.``NiAutoNormalParticlesData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticlesData`

    Particle system data object (with automatic normals?).

  class `NifFormat.``NiBSAnimationNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Bethesda-specific extension of Node with animation properties stored in the flags, often 42?

  class `NifFormat.``NiBSBoneLODController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBoneLODController`

    A simple LOD controller for bones.

  class `NifFormat.``NiBSPArrayController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleSystemController`

    A particle system controller, used by BS in conjunction with NiBSParticleNode.

  class `NifFormat.``NiBSParticleNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Unknown.

  class `NifFormat.``NiBSplineBasisData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Stores the number of control points of a B-spline.

    `num_control_points`

      The number of control points of the B-spline (number of frames of animation plus degree of B-spline minus one).

  class `NifFormat.``NiBSplineCompFloatInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBSplineFloatInterpolator`

    Unknown.

    `base`

      Base value when curve not defined.

    `bias`

      Bias

    `multiplier`

      Multiplier

    `offset`

      Starting offset for the data. (USHRT_MAX for no data.)

  class `NifFormat.``NiBSplineCompPoint3Interpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBSplinePoint3Interpolator`

    Unknown.

  class `NifFormat.``NiBSplineCompTransformEvaluator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

  class `NifFormat.``NiBSplineCompTransformInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiBSplineCompTransformInterpolator`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor on data.

    `get_rotations`()

      Return an iterator over all rotation keys.

    `get_scales`()

      Return an iterator over all scale keys.

    `get_translations`()

      Return an iterator over all translation keys.

  class `NifFormat.``NiBSplineData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiBSplineData`, `builtins.object`

        >>> # a doctest
        >>> from pyffi.formats.nif import NifFormat
        >>> block = NifFormat.NiBSplineData()
        >>> block.num_short_control_points = 50
        >>> block.short_control_points.update_size()
        >>> for i in range(block.num_short_control_points):
        ...     block.short_control_points[i] = 20 - i
        >>> list(block.get_short_data(12, 4, 3))
        [(8, 7, 6), (5, 4, 3), (2, 1, 0), (-1, -2, -3)]
        >>> offset = block.append_short_data([(1,2),(4,3),(13,14),(8,2),(33,33)])
        >>> offset
        50
        >>> list(block.get_short_data(offset, 5, 2))
        [(1, 2), (4, 3), (13, 14), (8, 2), (33, 33)]
        >>> list(block.get_comp_data(offset, 5, 2, 10.0, 32767.0))
        [(11.0, 12.0), (14.0, 13.0), (23.0, 24.0), (18.0, 12.0), (43.0, 43.0)]
        >>> block.append_float_data([(1.0,2.0),(3.0,4.0),(0.5,0.25)])
        0
        >>> list(block.get_float_data(0, 3, 2))
        [(1.0, 2.0), (3.0, 4.0), (0.5, 0.25)]
        >>> block.append_comp_data([(1,2),(4,3)])
        (60, 2.5, 1.5)
        >>> list(block.get_short_data(60, 2, 2))
        [(-32767, -10922), (32767, 10922)]
        >>> list(block.get_comp_data(60, 2, 2, 2.5, 1.5))
        [(1.0, 2.00...), (4.0, 2.99...)]

    `append_comp_data`(data)

      Append data as compressed list.

      Parameters: | data – A list of elements, where each element is a tuple of integers. (Note: cannot be an interator; maybe this restriction will be removed in a future version.)
      Returns: | The offset, bias, and multiplier.

    `append_float_data`(data)

      Append data.

      Parameters: | data – A list of elements, where each element is a tuple of floats. (Note: cannot be an interator; maybe this restriction will be removed in a future version.)
      Returns: | The offset at which the data was appended.

    `append_short_data`(data)

      Append data.

      Parameters: | data – A list of elements, where each element is a tuple of integers. (Note: cannot be an interator; maybe this restriction will be removed in a future version.)
      Returns: | The offset at which the data was appended.

    `get_comp_data`(offset, num_elements, element_size, bias, multiplier)

      Get an interator to the data, converted to float with extra bias and multiplication factor. If C{x} is the short value, then the returned value is C{bias + x * multiplier / 32767.0}.

      Parameters: | offset – The offset in the data where to start. num_elements – Number of elements to get. element_size – Size of a single element. bias – Value bias. multiplier – Value multiplier.
      Returns: | A list of C{num_elements} tuples of size C{element_size}.

    `get_float_data`(offset, num_elements, element_size)

      Get an iterator to the data.

      Parameters: | offset – The offset in the data where to start. num_elements – Number of elements to get. element_size – Size of a single element.
      Returns: | A list of C{num_elements} tuples of size C{element_size}.

    `get_short_data`(offset, num_elements, element_size)

      Get an iterator to the data.

      Parameters: | offset – The offset in the data where to start. num_elements – Number of elements to get. element_size – Size of a single element.
      Returns: | A list of C{num_elements} tuples of size C{element_size}.

  class `NifFormat.``NiBSplineFloatInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBSplineInterpolator`

    Unknown.

  class `NifFormat.``NiBSplineInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiBSplineInterpolator`, `builtins.object`

    `get_times`()

      Return an iterator over all key times.

      @todo: When code for calculating the bsplines is ready, this function will return exactly self.basis_data.num_control_points - 1 time points, and not self.basis_data.num_control_points as it is now.

  class `NifFormat.``NiBSplinePoint3Interpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBSplineInterpolator`

    Unknown.

    `unknown_floats`

      Unknown.

  class `NifFormat.``NiBSplineTransformInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiBSplineTransformInterpolator`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor on data.

    `get_rotations`()

      Return an iterator over all rotation keys.

    `get_scales`()

      Return an iterator over all scale keys.

    `get_translations`()

      Return an iterator over all translation keys.

  class `NifFormat.``NiBezierMesh`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiAVObject`

    Unknown

    `bezier_triangle`

      unknown

    `count_1`

      Data count.

    `count_2`

      data count 2.

    `data_2`

      data count.

    `num_bezier_triangles`

      references.

    `points_1`

      data.

    `points_2`

      data.

    `unknown_3`

      Unknown.

    `unknown_4`

      Unknown.

    `unknown_5`

      Unknown (illegal link?).

    `unknown_6`

      unknown

  class `NifFormat.``NiBezierTriangle4`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Sub data of NiBezierMesh

    `matrix`

      unknown

    `unknown_1`

      unknown

    `unknown_2`

      unknown

    `unknown_3`

      unknown

    `unknown_4`

      unknown

    `unknown_5`

      unknown

    `unknown_6`

      unknown

    `vector_1`

      unknown

    `vector_2`

      unknown

  class `NifFormat.``NiBillboardNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    These nodes will always be rotated to face the camera creating a billboard effect for any attached objects.In pre-10.1.0.0 the Flags field is used for BillboardMode.Bit 0: hiddenBits 1-2: collision modeBit 3: unknown (set in most official meshes)Bits 5-6: billboard modeCollision modes:00 NONE01 USE_TRIANGLES10 USE_OBBS11 CONTINUEBillboard modes:00 ALWAYS_FACE_CAMERA01 ROTATE_ABOUT_UP10 RIGID_FACE_CAMERA11 ALWAYS_FACE_CENTER

    `billboard_mode`

      The way the billboard will react to the camera.

  class `NifFormat.``NiBinaryExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Binary extra data object. Used to store tangents and bitangents in Oblivion.

    `binary_data`

      The binary data.

  class `NifFormat.``NiBinaryVoxelData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Voxel data object.

    `num_unknown_bytes_2`

      Unknown.

    `num_unknown_vectors`

      Unknown.

    `unknown_5_ints`

      Unknown.

    `unknown_7_floats`

      Unknown.

    `unknown_bytes_1`

      Unknown. Always a multiple of 7.

    `unknown_bytes_2`

      Unknown.

    `unknown_short_1`

      Unknown.

    `unknown_short_2`

      Unknown.

    `unknown_short_3`

      Unknown. Is this^3 the Unknown Bytes 1 size?

    `unknown_vectors`

      Vectors on the unit sphere.

  class `NifFormat.``NiBinaryVoxelExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Voxel extra data object.

    `data`

      Link to binary voxel data.

    `unknown_int`

      Unknown. 0?

  class `NifFormat.``NiBlendBoolInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBlendInterpolator`

    An interpolator for a bool.

    `bool_value`

      The interpolated bool?

  class `NifFormat.``NiBlendFloatInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBlendInterpolator`

    An interpolator for a float.

    `float_value`

      The interpolated float?

  class `NifFormat.``NiBlendInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpolator`

    An extended type of interpolater.

    `unknown_int`

      Unknown.

    `unknown_short`

      Unknown.

  class `NifFormat.``NiBlendPoint3Interpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBlendInterpolator`

    Interpolates a point?

    `point_value`

      The interpolated point?

  class `NifFormat.``NiBlendTransformInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBlendInterpolator`

    Unknown.

  class `NifFormat.``NiBone`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    A NiNode used as a skeleton bone?

  class `NifFormat.``NiBoneLODController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Level of detail controller for bones. Priority is arranged from low to high.

    `node_groups`

      A list of node groups (each group a sequence of bones).

    `num_node_groups`

      Number of node groups.

    `num_node_groups_2`

      Number of node groups.

    `num_shape_groups`

      Number of shape groups.

    `num_shape_groups_2`

      The size of the second list of shape groups.

    `shape_groups_1`

      List of shape groups.

    `shape_groups_2`

      Group of NiTriShape indices.

    `unknown_int_1`

      Unknown.

    `unknown_int_2`

      Unknown.

    `unknown_int_3`

      Unknown.

  class `NifFormat.``NiBoolData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Timed boolean data.

    `data`

      The boolean keys.

  class `NifFormat.``NiBoolInterpController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSingleInterpController`

    A controller that interpolates floating point numbers?

  class `NifFormat.``NiBoolInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiKeyBasedInterpolator`

    Unknown.

    `bool_value`

      Value when posed? At time 0?

    `data`

      Refers to a NiBoolData object.

  class `NifFormat.``NiBoolTimelineInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBoolInterpolator`

    Unknown.

  class `NifFormat.``NiBooleanExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Boolean extra data.

    `boolean_data`

      The boolean extra data value.

  class `NifFormat.``NiCamera`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiAVObject`

    Camera object.

    `frustum_bottom`

      Frustrum bottom.

    `frustum_far`

      Frustrum far.

    `frustum_left`

      Frustrum left.

    `frustum_near`

      Frustrum near.

    `frustum_right`

      Frustrum right.

    `frustum_top`

      Frustrum top.

    `lod_adjust`

      Level of detail adjust.

    `unknown_int`

      Unknown. Changing value crashes viewer.

    `unknown_int_2`

      Unknown. Changing value crashes viewer.

    `unknown_int_3`

      Unknown.

    `unknown_link`

      Unknown.

    `unknown_short`

      Unknown.

    `use_orthographic_projection`

      Determines whether perspective is used. Orthographic means no perspective.

    `viewport_bottom`

      Viewport bottom.

    `viewport_left`

      Viewport left.

    `viewport_right`

      Viewport right.

    `viewport_top`

      Viewport top.

  class `NifFormat.``NiClod`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriBasedGeom`

    A shape node that holds continuous level of detail information.Seems to be specific to Freedom Force.

  class `NifFormat.``NiClodData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriBasedGeomData`

    Holds mesh data for continuous level of detail shapes.Pesumably a progressive mesh with triangles specified by edge splits.Seems to be specific to Freedom Force.The structure of this is uncertain and highly experimental at this point.No file with this data can currently be read properly.

    `unknown_clod_shorts_1`
    `unknown_clod_shorts_2`
    `unknown_clod_shorts_3`
    `unknown_count_1`
    `unknown_count_2`
    `unknown_count_3`
    `unknown_float`
    `unknown_short`
    `unknown_shorts`
  class `NifFormat.``NiClodSkinInstance`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSkinInstance`

    A copy of NISkinInstance for use with NiClod meshes.

  class `NifFormat.``NiCollisionData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiCollisionObject`

    Collision box.

    `bounding_volume`

      Collision data.

    `collision_mode`

      Collision Mode

    `propagation_mode`

      Propagation Mode

    `use_abv`

      Use Alternate Bounding Volume.

  class `NifFormat.``NiCollisionObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    This is the most common collision object found in NIF files. It acts as a real object thatis visible and possibly (if the body allows for it) interactive. The node itselfis simple, it only has three properties.For this type of collision object, bhkRigidBody or bhkRigidBodyT is generally used.

    `target`

      Index of the AV object referring to this collision object.

  class `NifFormat.``NiColorData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Color data for material color controller.

    `data`

      The color keys.

  class `NifFormat.``NiColorExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown.

    `data`

      RGBA Color?

  class `NifFormat.``NiControllerManager`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Unknown. Root of all controllers?

    `controller_sequences`

      Refers to a list of NiControllerSequence object.

    `cumulative`

      Designates whether animation sequences are cumulative?

    `num_controller_sequences`

      The number of controller sequence objects.

    `object_palette`

      Refers to a NiDefaultAVObjectPalette.

  class `NifFormat.``NiControllerSequence`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiControllerSequence`, `builtins.object`

    `add_controlled_block`()

      Create new controlled block, and return it.

          >>> seq = NifFormat.NiControllerSequence()
          >>> seq.num_controlled_blocks
          0
          >>> ctrlblock = seq.add_controlled_block()
          >>> seq.num_controlled_blocks
          1
          >>> isinstance(ctrlblock, NifFormat.ControllerLink)
          True

  class `NifFormat.``NiDataStream`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `access`
    `cloning_behavior`
    `component_formats`

      The format of each component in this data stream.

    `data`
    `num_bytes`

      The size in bytes of this data stream.

    `num_components`

      Number of components of the data (matches corresponding field in MeshData).

    `num_regions`

      Number of regions (such as submeshes).

    `regions`

      The regions in the mesh. Regions can be used to mark off submeshes which are independent draw calls.

    `streamable`
    `usage`
  class `NifFormat.``NiDefaultAVObjectPalette`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiAVObjectPalette`

    Unknown. Refers to a list of objects. Used by NiControllerManager.

    `num_objs`

      Number of objects.

    `objs`

      The objects.

    `unknown_int`

      Unknown.

  class `NifFormat.``NiDirectionalLight`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiLight`

    Directional light source.

  class `NifFormat.``NiDitherProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Unknown.

    `flags`

      1’s Bit: Enable dithering

  class `NifFormat.``NiDynamicEffect`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiAVObject`

    A dynamic effect such as a light or environment map.

    `affected_node_list_pointers`

      This is probably the list of affected nodes. For some reason i do not know the max exporter seems to write pointers instead of links. But it doesn’t matter because at least in version 4.0.0.2 the list is automagically updated by the engine during the load stage.

    `affected_nodes`

      The list of affected nodes?

    `num_affected_node_list_pointers`

      The number of affected nodes referenced.

    `num_affected_nodes`

      The number of affected nodes referenced.

    `switch_state`

      Turns effect on and off? Switches list to list of unaffected nodes?

  class `NifFormat.``NiEnvMappedTriShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObjectNET`

    Unknown

    `child_2`

      unknown

    `child_3`

      unknown

    `children`

      List of child node object indices.

    `num_children`

      The number of child objects.

    `unknown_1`

      unknown (=4 - 5)

    `unknown_matrix`

      unknown

  class `NifFormat.``NiEnvMappedTriShapeData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriShapeData`

    Holds mesh data using a list of singular triangles.

  class `NifFormat.``NiExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    A generic extra data object.

    `name`

      Name of this object.

    `next_extra_data`

      Block number of the next extra data object.

  class `NifFormat.``NiExtraDataController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSingleInterpController`

    An controller for extra data.

  class `NifFormat.``NiFlipController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Texture flipping controller.

    `delta`

      Time between two flips.delta = (start_time - stop_time) / sources.num_indices

    `images`

      The image sources

    `num_sources`

      The number of source objects.

    `sources`

      The texture sources.

    `texture_slot`

      Target texture slot (0=base, 4=glow).

    `unknown_int_2`

      0?

  class `NifFormat.``NiFloatData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Possibly the 1D position along a 3D path.

    `data`

      The keys.

  class `NifFormat.``NiFloatExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Float extra data.

    `float_data`

      The float data.

  class `NifFormat.``NiFloatExtraDataController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraDataController`

    Unknown.

    `controller_data`

      Refers to a NiFloatExtraData name.

    `num_extra_bytes`

      Number of extra bytes.

    `unknown_bytes`

      Unknown.

    `unknown_extra_bytes`

      Unknown.

  class `NifFormat.``NiFloatInterpController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSingleInterpController`

    A controller that interpolates floating point numbers?

  class `NifFormat.``NiFloatInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiKeyBasedInterpolator`

    Unknown.

    `data`

      Float data?

    `float_value`

      Value when posed? At time 0?

  class `NifFormat.``NiFloatsExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Unknown.

    `data`

      Float data.

    `num_floats`

      Number of floats in the next field.

  class `NifFormat.``NiFogProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Describes... fog?

    `flags`

      1’s bit: Enables Fog2’s bit: Sets Fog Function to FOG_RANGE_SQ4’s bit: Sets Fog Function to FOG_VERTEX_ALPHAIf 2’s and 4’s bit are not set, but fog is enabled, Fog function is FOG_Z_LINEAR.

    `fog_color`

      The color of the fog.

    `fog_depth`

      The thickness of the fog? Default is 1.0

  class `NifFormat.``NiFurSpringController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    `bones`

      List of all armature bones.

    `bones_2`

      List of all armature bones.

    `num_bones`

      The number of node bones referenced as influences.

    `num_bones_2`

      The number of node bones referenced as influences.

    `unknown_float`
    `unknown_float_2`
  class `NifFormat.``NiGeomMorpherController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpController`

    Time controller for geometry morphing.

    `always_update`

      Always Update

    `data`

      Geometry morphing data index.

    `extra_flags`

      Unknown.

    `interpolator_weights`

      Weighted Interpolators?

    `interpolators`

      List of interpolators.

    `num_interpolators`

      The number of interpolator objects.

    `num_unknown_ints`

      A count.

    `unknown_2`

      Unknown.

    `unknown_ints`

      Unknown.

  class `NifFormat.``NiGeometry`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiGeometry`, `builtins.object`

        >>> from pyffi.formats.nif import NifFormat
        >>> id44 = NifFormat.Matrix44()
        >>> id44.set_identity()
        >>> skelroot = NifFormat.NiNode()
        >>> skelroot.name = 'skelroot'
        >>> skelroot.set_transform(id44)
        >>> bone1 = NifFormat.NiNode()
        >>> bone1.name = 'bone1'
        >>> bone1.set_transform(id44)
        >>> bone2 = NifFormat.NiNode()
        >>> bone2.name = 'bone2'
        >>> bone2.set_transform(id44)
        >>> bone21 = NifFormat.NiNode()
        >>> bone21.name = 'bone21'
        >>> bone21.set_transform(id44)
        >>> bone22 = NifFormat.NiNode()
        >>> bone22.name = 'bone22'
        >>> bone22.set_transform(id44)
        >>> bone211 = NifFormat.NiNode()
        >>> bone211.name = 'bone211'
        >>> bone211.set_transform(id44)
        >>> skelroot.add_child(bone1)
        >>> bone1.add_child(bone2)
        >>> bone2.add_child(bone21)
        >>> bone2.add_child(bone22)
        >>> bone21.add_child(bone211)
        >>> geom = NifFormat.NiTriShape()
        >>> geom.name = 'geom'
        >>> geom.set_transform(id44)
        >>> geomdata = NifFormat.NiTriShapeData()
        >>> skininst = NifFormat.NiSkinInstance()
        >>> skindata = NifFormat.NiSkinData()
        >>> skelroot.add_child(geom)
        >>> geom.data = geomdata
        >>> geom.skin_instance = skininst
        >>> skininst.skeleton_root = skelroot
        >>> skininst.data = skindata
        >>> skininst.num_bones = 4
        >>> skininst.bones.update_size()
        >>> skininst.bones[0] = bone1
        >>> skininst.bones[1] = bone2
        >>> skininst.bones[2] = bone22
        >>> skininst.bones[3] = bone211
        >>> skindata.num_bones = 4
        >>> skindata.bone_list.update_size()
        >>> [child.name for child in skelroot.children]
        [b'bone1', b'geom']
        >>> skindata.set_transform(id44)
        >>> for bonedata in skindata.bone_list:
        ...     bonedata.set_transform(id44)
        >>> affectedbones = geom.flatten_skin()
        >>> [bone.name for bone in affectedbones]
        [b'bone1', b'bone2', b'bone22', b'bone211']
        >>> [child.name for child in skelroot.children]
        [b'geom', b'bone1', b'bone21', b'bone2', b'bone22', b'bone211']

    `add_bone`(bone, vert_weights)

      Add bone with given vertex weights. After adding all bones, the geometry skinning information should be set from the current position of the bones using the L{update_bind_position} function.

      Parameters: | bone – The bone NiNode block. vert_weights – A dictionary mapping each influenced vertex index to a vertex weight.

    `flatten_skin`()

      Reposition all bone blocks and geometry block in the tree to be direct children of the skeleton root.

      Returns list of all used bones by the skin.

    `get_skin_deformation`()

      Returns a list of vertices and normals in their final position after skinning, in geometry space.

    `get_skin_partition`()

      Return the skin partition block.

    `get_vertex_weights`()

      Get vertex weights in a convenient format: list bone and weight per vertex.

    `is_skin`()

      Returns True if geometry is skinned.

    `send_bones_to_bind_position`()

      Send all bones to their bind position.

      @deprecated: Use L{NifFormat.NiNode.send_bones_to_bind_position} instead of
        this function.
    `set_skin_partition`(skinpart)

      Set skin partition block.

    `update_bind_position`()

      Make current position of the bones the bind position for this geometry.

      Sets the NiSkinData overall transform to the inverse of the geometry transform relative to the skeleton root, and sets the NiSkinData of each bone to the geometry transform relative to the skeleton root times the inverse of the bone transform relative to the skeleton root.

  class `NifFormat.``NiGeometryData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiGeometryData`, `builtins.object`

        >>> from pyffi.formats.nif import NifFormat
        >>> geomdata = NifFormat.NiGeometryData()
        >>> geomdata.num_vertices = 3
        >>> geomdata.has_vertices = True
        >>> geomdata.has_normals = True
        >>> geomdata.has_vertex_colors = True
        >>> geomdata.num_uv_sets = 2
        >>> geomdata.vertices.update_size()
        >>> geomdata.normals.update_size()
        >>> geomdata.vertex_colors.update_size()
        >>> geomdata.uv_sets.update_size()
        >>> geomdata.vertices[0].x = 1
        >>> geomdata.vertices[0].y = 2
        >>> geomdata.vertices[0].z = 3
        >>> geomdata.vertices[1].x = 4
        >>> geomdata.vertices[1].y = 5
        >>> geomdata.vertices[1].z = 6
        >>> geomdata.vertices[2].x = 1.200001
        >>> geomdata.vertices[2].y = 3.400001
        >>> geomdata.vertices[2].z = 5.600001
        >>> geomdata.normals[0].x = 0
        >>> geomdata.normals[0].y = 0
        >>> geomdata.normals[0].z = 1
        >>> geomdata.normals[1].x = 0
        >>> geomdata.normals[1].y = 1
        >>> geomdata.normals[1].z = 0
        >>> geomdata.normals[2].x = 1
        >>> geomdata.normals[2].y = 0
        >>> geomdata.normals[2].z = 0
        >>> geomdata.vertex_colors[1].r = 0.310001
        >>> geomdata.vertex_colors[1].g = 0.320001
        >>> geomdata.vertex_colors[1].b = 0.330001
        >>> geomdata.vertex_colors[1].a = 0.340001
        >>> geomdata.uv_sets[0][0].u = 0.990001
        >>> geomdata.uv_sets[0][0].v = 0.980001
        >>> geomdata.uv_sets[0][2].u = 0.970001
        >>> geomdata.uv_sets[0][2].v = 0.960001
        >>> geomdata.uv_sets[1][0].v = 0.910001
        >>> geomdata.uv_sets[1][0].v = 0.920001
        >>> geomdata.uv_sets[1][2].v = 0.930001
        >>> geomdata.uv_sets[1][2].v = 0.940001
        >>> for h in geomdata.get_vertex_hash_generator():
        ...     print(h)
        (1000, 2000, 3000, 0, 0, 1000, 99000, 98000, 0, 92000, 0, 0, 0, 0)
        (4000, 5000, 6000, 0, 1000, 0, 0, 0, 0, 0, 310, 320, 330, 340)
        (1200, 3400, 5600, 1000, 0, 0, 97000, 96000, 0, 94000, 0, 0, 0, 0)

    `apply_scale`(scale)

      Apply scale factor on data.

    `get_vertex_hash_generator`(vertexprecision=3, normalprecision=3, uvprecision=5, vcolprecision=3)

      Generator which produces a tuple of integers for each (vertex, normal, uv, vcol), to ease detection of duplicate vertices. The precision parameters denote number of significant digits behind the comma.

      Default for uvprecision should really be high because for very large models the uv coordinates can be very close together.

      For vertexprecision, 3 seems usually enough (maybe we’ll have to increase this at some point).

      Parameters: | vertexprecision (float) – Precision to be used for vertices. normalprecision (float) – Precision to be used for normals. uvprecision (float) – Precision to be used for uvs. vcolprecision (float) – Precision to be used for vertex colors.
      Returns: | A generator yielding a hash value for each vertex.

    `update_center_radius`()

      Recalculate center and radius of the data.

  class `NifFormat.``NiGravity`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleModifier`

    A particle modifier; applies a gravitational field on the particles.

    `direction`

      The direction of the applied acceleration.

    `force`

      The strength/force of this gravity.

    `position`

      The position of the mass point relative to the particle system. (TODO: check for versions<= 3.1)

    `type`

      The force field’s type.

    `unknown_float_1`

      Unknown.

  class `NifFormat.``NiImage`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `file_name`

      The filepath to the texture.

    `image_data`

      Link to the internally stored image data.

    `unknown_float`

      Unknown. Perhaps fImageScale?

    `unknown_int`

      Unknown. Often seems to be 7. Perhaps m_uiMipLevels?

    `use_external`

      0 if the texture is internal to the NIF file.

  class `NifFormat.``NiInstancingMeshModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiMeshModifier`

  class `NifFormat.``NiIntegerExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Extra integer data.

    `integer_data`

      The value of the extra data.

  class `NifFormat.``NiIntegersExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Integers data.

    `data`

      Integers.

    `num_integers`

      Number of integers.

  class `NifFormat.``NiInterpController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    A controller capable of interpolation?

  class `NifFormat.``NiInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Interpolator objects - function unknown.

  class `NifFormat.``NiKeyBasedInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpolator`

    Interpolator objects that use keys?

  class `NifFormat.``NiKeyframeController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSingleInterpController`

    A time controller object for animation key frames.

    `data`

      Keyframe controller data index.

  class `NifFormat.``NiKeyframeData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiKeyframeData`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor on data.

  class `NifFormat.``NiLODData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Abstract class used for different types of LOD selections.

  class `NifFormat.``NiLODNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSwitchNode`

    Level of detail selector. Links to different levels of detail of the same model, used to switch a geometry at a specified distance.

    `lod_center`

      Point to calculate distance from for switching?

    `lod_level_data`

      Refers to LOD level information, either distance or screen size based.

    `lod_levels`

      The ranges of distance that each level of detail applies in.

    `num_lod_levels`

      Number of levels of detail.

  class `NifFormat.``NiLight`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiDynamicEffect`

    Light source.

    `ambient_color`

      Ambient color.

    `diffuse_color`

      Diffuse color.

    `dimmer`

      Dimmer.

    `specular_color`

      Specular color.

  class `NifFormat.``NiLightColorController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPoint3InterpController`

    Light color animation controller.

  class `NifFormat.``NiLightDimmerController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Unknown controller.

  class `NifFormat.``NiLightIntensityController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Unknown controller

  class `NifFormat.``NiLines`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriBasedGeom`

    Wireframe geometry.

  class `NifFormat.``NiLinesData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiGeometryData`

    Wireframe geometry data.

    `lines`

      Is vertex connected to other (next?) vertex?

  class `NifFormat.``NiLookAtController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Unknown. Start time is 3.4e+38 and stop time is -3.4e+38.

    `look_at_node`

      Link to the node to look at?

    `unknown_1`

      Unknown.

  class `NifFormat.``NiLookAtInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpolator`

    Unknown.

    `look_at`

      Refers to a Node to focus on.

    `rotation`

      Rotation.

    `scale`

      Scale.

    `target`

      Target node name.

    `translation`

      Translate.

    `unknown_link_1`

      Refers to NiPoint3Interpolator.

    `unknown_link_2`

      Refers to a NiFloatInterpolator.

    `unknown_link_3`

      Refers to a NiFloatInterpolator.

    `unknown_short`

      Unknown.

  class `NifFormat.``NiMaterialColorController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiMaterialColorController`, `builtins.object`

    `get_target_color`()

      Get target color (works for all nif versions).

    `set_target_color`(target_color)

      Set target color (works for all nif versions).

  class `NifFormat.``NiMaterialProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiMaterialProperty`, `builtins.object`

    `is_interchangeable`(other)

      Are the two material blocks interchangeable?

  class `NifFormat.``NiMesh`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiRenderObject`

    `bound`

      The combined bounding volume of all submeshes.

    `datas`
    `instancing_enabled`

      Sets whether hardware instancing is being used.

    `modifiers`
    `num_datas`
    `num_modifiers`
    `num_submeshes`

      The number of submeshes contained in this mesh.

    `primitive_type`

      The primitive type of the mesh, such as triangles or lines.

    `unknown_100`

      Unknown.

    `unknown_101`

      Unknown.

    `unknown_102`

      Size of additional data.

    `unknown_103`
    `unknown_200`
    `unknown_201`
    `unknown_250`
    `unknown_251`
    `unknown_300`
    `unknown_301`
    `unknown_302`
    `unknown_303`
    `unknown_350`
    `unknown_351`
    `unknown_400`
    `unknown_51`
    `unknown_52`
    `unknown_53`
    `unknown_54`
    `unknown_55`
    `unknown_56`
  class `NifFormat.``NiMeshHWInstance`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

  class `NifFormat.``NiMeshModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Base class for mesh modifiers.

    `complete_points`

      The complete points used by this mesh modifier

    `num_complete_points`

      The number of complete points used by this mesh modifier.

    `num_submit_points`

      The number of submit points used by this mesh modifier.

    `submit_points`

      The submit points used by this mesh modifier

  class `NifFormat.``NiMeshPSysData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysData`

    Particle meshes data.

    `num_unknown_ints_1`

      Unknown.

    `unknown_byte_3`

      Unknown. 0?

    `unknown_int_2`

      Unknown. Possible vertex count but probably not.

    `unknown_ints_1`

      Unknown integers

    `unknown_node`

      Unknown NiNode.

  class `NifFormat.``NiMeshParticleSystem`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleSystem`

    Particle system.

  class `NifFormat.``NiMorphController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpController`

    Unknown! Used by Daoc->’healing.nif’.

  class `NifFormat.``NiMorphData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiMorphData`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor on data.

  class `NifFormat.``NiMorphMeshModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiMeshModifier`

    Performs linear-weighted blending between a set of target data streams.

    `elements`

      Semantics and normalization of the morphing data stream elements.

    `flags`

      FLAG_RELATIVETARGETS = 0x01FLAG_UPDATENORMALS = 0x02FLAG_NEEDSUPDATE = 0x04FLAG_ALWAYSUPDATE = 0x08FLAG_NEEDSCOMPLETION = 0x10FLAG_SKINNED = 0x20FLAG_SWSKINNED = 0x40

    `num_elements`

      The number of morphing data stream elements.

    `num_targets`

      The number of morph targets.

  class `NifFormat.``NiMorphWeightsController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpController`

    `interpolators`
    `num_interpolators`
    `num_targets`

      The number of morph targets.

    `target_names`

      Name of each morph target.

    `unknown_2`
  class `NifFormat.``NiMorpherController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpController`

    Unknown! Used by Daoc.

    `data`

      This controller’s data.

  class `NifFormat.``NiMultiTargetTransformController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpController`

    Unknown.

    `extra_targets`

      NiNode Targets to be controlled.

    `num_extra_targets`

      The number of target pointers that follow.

  class `NifFormat.``NiMultiTextureProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    (note: not quite complete yet... but already reads most of the DAoC ones)

    `flags`

      Property flags.

    `texture_elements`

      Describes the various textures used by this mutli-texture property. Each slot probably has special meaning like thoes in NiTexturingProperty.

    `unknown_int`

      Unknown. Always 5 for DAoC files, and always 6 for Bridge Commander. Seems to have nothing to do with the number of Texture Element slots that follow.

  class `NifFormat.``NiNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiNode`, `builtins.object`

        >>> from pyffi.formats.nif import NifFormat
        >>> x = NifFormat.NiNode()
        >>> y = NifFormat.NiNode()
        >>> z = NifFormat.NiNode()
        >>> x.num_children =1
        >>> x.children.update_size()
        >>> y in x.children
        False
        >>> x.children[0] = y
        >>> y in x.children
        True
        >>> x.add_child(z, front = True)
        >>> x.add_child(y)
        >>> x.num_children
        2
        >>> x.children[0] is z
        True
        >>> x.remove_child(y)
        >>> y in x.children
        False
        >>> x.num_children
        1
        >>> e = NifFormat.NiSpotLight()
        >>> x.add_effect(e)
        >>> x.num_effects
        1
        >>> e in x.effects
        True

        >>> from pyffi.formats.nif import NifFormat
        >>> node = NifFormat.NiNode()
        >>> child1 = NifFormat.NiNode()
        >>> child1.name = "hello"
        >>> child_2 = NifFormat.NiNode()
        >>> child_2.name = "world"
        >>> node.get_children()
        []
        >>> node.set_children([child1, child_2])
        >>> [child.name for child in node.get_children()]
        [b'hello', b'world']
        >>> [child.name for child in node.children]
        [b'hello', b'world']
        >>> node.set_children([])
        >>> node.get_children()
        []
        >>> # now set them the other way around
        >>> node.set_children([child_2, child1])
        >>> [child.name for child in node.get_children()]
        [b'world', b'hello']
        >>> [child.name for child in node.children]
        [b'world', b'hello']
        >>> node.remove_child(child_2)
        >>> [child.name for child in node.children]
        [b'hello']
        >>> node.add_child(child_2)
        >>> [child.name for child in node.children]
        [b'hello', b'world']

        >>> from pyffi.formats.nif import NifFormat
        >>> node = NifFormat.NiNode()
        >>> effect1 = NifFormat.NiSpotLight()
        >>> effect1.name = "hello"
        >>> effect2 = NifFormat.NiSpotLight()
        >>> effect2.name = "world"
        >>> node.get_effects()
        []
        >>> node.set_effects([effect1, effect2])
        >>> [effect.name for effect in node.get_effects()]
        [b'hello', b'world']
        >>> [effect.name for effect in node.effects]
        [b'hello', b'world']
        >>> node.set_effects([])
        >>> node.get_effects()
        []
        >>> # now set them the other way around
        >>> node.set_effects([effect2, effect1])
        >>> [effect.name for effect in node.get_effects()]
        [b'world', b'hello']
        >>> [effect.name for effect in node.effects]
        [b'world', b'hello']
        >>> node.remove_effect(effect2)
        >>> [effect.name for effect in node.effects]
        [b'hello']
        >>> node.add_effect(effect2)
        >>> [effect.name for effect in node.effects]
        [b'hello', b'world']

    `add_child`(child, front=False)

      Add block to child list.

      Parameters: | child (L{NifFormat.NiAVObject}) – The child to add. front (`bool`) – Whether to add to the front or to the end of the list (default is at end).

    `add_effect`(effect)

      Add an effect to the list of effects.

      Parameters: | effect (L{NifFormat.NiDynamicEffect}) – The effect to add.

    `get_children`()

      Return a list of the children of the block.

      Returns: | The list of children.
      Return type: | `list` of L{NifFormat.NiAVObject}

    `get_effects`()

      Return a list of the effects of the block.

      Returns: | The list of effects.
      Return type: | `list` of L{NifFormat.NiDynamicEffect}

    `get_skinned_geometries`()

      This function yields all skinned geometries which have self as skeleton root.

    `merge_external_skeleton_root`(skelroot)

      Attach skinned geometry to self (which will be the new skeleton root of the nif at the given skeleton root). Use this function if you move a skinned geometry from one nif into a new nif file. The bone links will be updated to point to the tree at self, instead of to the external tree.

    `merge_skeleton_roots`()

      This function will look for other geometries whose skeleton root is a (possibly indirect) child of this node. It will then reparent those geometries to this node. For example, it will unify the skeleton roots in Morrowind’s cliffracer.nif file, or of the (official) body skins. This makes it much easier to import skeletons in for instance Blender: there will be only one skeleton root for each bone, over all geometries.

      The merge fails for those geometries whose global skin data transform does not match the inverse geometry transform relative to the skeleton root (the maths does not work out in this case!)

      Returns list of all new blocks that have been reparented (and added to the skeleton root children list), and a list of blocks for which the merge failed.

    `remove_child`(child)

      Remove a block from the child list.

      Parameters: | child (L{NifFormat.NiAVObject}) – The child to remove.

    `remove_effect`(effect)

      Remove a block from the effect list.

      Parameters: | effect (L{NifFormat.NiDynamicEffect}) – The effect to remove.

    `send_bones_to_bind_position`()

      This function will send all bones of geometries of this skeleton root to their bind position. For best results, call L{send_geometries_to_bind_position} first.

      Returns: | A number quantifying the remaining difference between bind positions.
      Return type: | `float`

    `send_detached_geometries_to_node_position`()

      Some nifs (in particular in Morrowind) have geometries that are skinned but that do not share bones. In such cases, send_geometries_to_bind_position cannot reposition them. This function will send such geometries to the position of their root node.

      Examples of such nifs are the official Morrowind skins (after merging skeleton roots).

      Returns list of detached geometries that have been moved.

    `send_geometries_to_bind_position`()

      Call this on the skeleton root of geometries. This function will transform the geometries, such that all skin data transforms coincide, or at least coincide partially.

      Returns: | A number quantifying the remaining difference between bind positions.
      Return type: | `float`

    `set_children`(childlist)

      Set the list of children from the given list (destroys existing list).

      Parameters: | childlist (`list` of L{NifFormat.NiAVObject}) – The list of child blocks to set.

    `set_effects`(effectlist)

      Set the list of effects from the given list (destroys existing list).

      Parameters: | effectlist (`list` of L{NifFormat.NiDynamicEffect}) – The list of effect blocks to set.

  class `NifFormat.``NiObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiObject`, `builtins.object`

    `apply_scale`(scale)

      Scale data in this block. This implementation does nothing. Override this method if it contains geometry data that can be scaled.

    `find`(block_name=None, block_type=None)
    `find_chain`(block, block_type=None)

      Finds a chain of blocks going from C{self} to C{block}. If found, self is the first element and block is the last element. If no branch found, returns an empty list. Does not check whether there is more than one branch; if so, the first one found is returned.

      Parameters: | block – The block to find a chain to. block_type – The type that blocks should have in this chain.

    `is_interchangeable`(other)

      Are the two blocks interchangeable?

      @todo: Rely on AnyType, SimpleType, ComplexType, etc. implementation.

    `tree`(block_type=None, follow_all=True, unique=False)

      A generator for parsing all blocks in the tree (starting from and including C{self}).

      Parameters: | block_type – If not `None`, yield only blocks of the type C{block_type}. follow_all – If C{block_type} is not `None`, then if this is `True` the function will parse the whole tree. Otherwise, the function will not follow branches that start by a non-C{block_type} block. unique – Whether the generator can return the same block twice or not.

  class `NifFormat.``NiObjectNET`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiObjectNET`, `builtins.object`

    `add_controller`(ctrlblock)

      Add block to controller chain and set target of controller to self.

    `add_extra_data`(extrablock)

      Add block to extra data list and extra data chain. It is good practice to ensure that the extra data has empty next_extra_data field when adding it to avoid loops in the hierarchy.

    `add_integer_extra_data`(name, value)

      Add a particular extra integer data block.

    `get_controllers`()

      Get a list of all controllers.

    `get_extra_datas`()

      Get a list of all extra data blocks.

    `remove_extra_data`(extrablock)

      Remove block from extra data list and extra data chain.

          >>> from pyffi.formats.nif import NifFormat
          >>> block = NifFormat.NiNode()
          >>> block.num_extra_data_list = 3
          >>> block.extra_data_list.update_size()
          >>> extrablock = NifFormat.NiStringExtraData()
          >>> block.extra_data_list[1] = extrablock
          >>> block.remove_extra_data(extrablock)
          >>> [extra for extra in block.extra_data_list]
          [None, None]

    `set_extra_datas`(extralist)

      Set all extra data blocks from given list (erases existing data).

          >>> from pyffi.formats.nif import NifFormat
          >>> node = NifFormat.NiNode()
          >>> extra1 = NifFormat.NiExtraData()
          >>> extra1.name = "hello"
          >>> extra2 = NifFormat.NiExtraData()
          >>> extra2.name = "world"
          >>> node.get_extra_datas()
          []
          >>> node.set_extra_datas([extra1, extra2])
          >>> [extra.name for extra in node.get_extra_datas()]
          [b'hello', b'world']
          >>> [extra.name for extra in node.extra_data_list]
          [b'hello', b'world']
          >>> node.extra_data is extra1
          True
          >>> extra1.next_extra_data is extra2
          True
          >>> extra2.next_extra_data is None
          True
          >>> node.set_extra_datas([])
          >>> node.get_extra_datas()
          []
          >>> # now set them the other way around
          >>> node.set_extra_datas([extra2, extra1])
          >>> [extra.name for extra in node.get_extra_datas()]
          [b'world', b'hello']
          >>> [extra.name for extra in node.extra_data_list]
          [b'world', b'hello']
          >>> node.extra_data is extra2
          True
          >>> extra2.next_extra_data is extra1
          True
          >>> extra1.next_extra_data is None
          True

      Parameters: | extralist (`list` of L{NifFormat.NiExtraData}) – List of extra data blocks to add.

  class `NifFormat.``NiPSBombForce`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `name`
    `unknown_1`
    `unknown_10`
    `unknown_2`
    `unknown_3`
    `unknown_4`
    `unknown_5`
    `unknown_6`
    `unknown_7`
    `unknown_8`
    `unknown_9`
  class `NifFormat.``NiPSBoundUpdater`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `unknown_1`
    `unknown_2`
  class `NifFormat.``NiPSBoxEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `name`
    `unknown_1`
    `unknown_10`
    `unknown_11`
    `unknown_12`
    `unknown_13`
    `unknown_14`
    `unknown_15`
    `unknown_16`
    `unknown_17`
    `unknown_18`
    `unknown_19`
    `unknown_2`
    `unknown_20`
    `unknown_21`
    `unknown_22`
    `unknown_23`
    `unknown_24`
    `unknown_25`
    `unknown_26`
    `unknown_27`
    `unknown_28`
    `unknown_29`
    `unknown_3`
    `unknown_30`
    `unknown_31`
    `unknown_32`
    `unknown_33`
    `unknown_34`
    `unknown_35`
    `unknown_36`
    `unknown_37`
    `unknown_38`
    `unknown_39`
    `unknown_4`
    `unknown_40`
    `unknown_41`
    `unknown_42`
    `unknown_43`
    `unknown_44`
    `unknown_45`
    `unknown_46`
    `unknown_47`
    `unknown_48`
    `unknown_5`
    `unknown_6`
    `unknown_7`
    `unknown_8`
    `unknown_9`
  class `NifFormat.``NiPSCylinderEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSSphereEmitter`

    `unknown_23`
  class `NifFormat.``NiPSDragForce`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `unknown_1`
    `unknown_10`
    `unknown_2`
    `unknown_3`
    `unknown_4`
    `unknown_5`
    `unknown_6`
    `unknown_7`
    `unknown_8`
    `unknown_9`
  class `NifFormat.``NiPSEmitParticlesCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysEmitterCtlr`

  class `NifFormat.``NiPSEmitterDeclinationCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

  class `NifFormat.``NiPSEmitterDeclinationVarCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSEmitterDeclinationCtlr`

  class `NifFormat.``NiPSEmitterLifeSpanCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

  class `NifFormat.``NiPSEmitterPlanarAngleCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

  class `NifFormat.``NiPSEmitterPlanarAngleVarCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSEmitterPlanarAngleCtlr`

  class `NifFormat.``NiPSEmitterRadiusCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    `interpolator`
    `unknown_2`
  class `NifFormat.``NiPSEmitterRotAngleCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

  class `NifFormat.``NiPSEmitterRotAngleVarCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSEmitterRotAngleCtlr`

  class `NifFormat.``NiPSEmitterRotSpeedCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

  class `NifFormat.``NiPSEmitterRotSpeedVarCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSEmitterRotSpeedCtlr`

  class `NifFormat.``NiPSEmitterSpeedCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    `interpolator`
    `unknown_3`
  class `NifFormat.``NiPSFacingQuadGenerator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `unknown_1`
    `unknown_10`
    `unknown_11`
    `unknown_12`
    `unknown_2`
    `unknown_3`
    `unknown_4`
    `unknown_5`
    `unknown_6`
    `unknown_7`
    `unknown_8`
    `unknown_9`
  class `NifFormat.``NiPSForceActiveCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    `interpolator`
    `unknown_2`
  class `NifFormat.``NiPSGravityForce`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `unknown_1`
    `unknown_10`
    `unknown_11`
    `unknown_12`
    `unknown_13`
    `unknown_14`
    `unknown_15`
    `unknown_16`
    `unknown_17`
    `unknown_18`
    `unknown_19`
    `unknown_2`
    `unknown_20`
    `unknown_21`
    `unknown_22`
    `unknown_23`
    `unknown_24`
    `unknown_25`
    `unknown_26`
    `unknown_27`
    `unknown_28`
    `unknown_29`
    `unknown_3`
    `unknown_30`
    `unknown_31`
    `unknown_32`
    `unknown_33`
    `unknown_34`
    `unknown_35`
    `unknown_36`

      Gravity node?

    `unknown_4`
    `unknown_5`
    `unknown_6`
    `unknown_7`
    `unknown_8`
    `unknown_9`
  class `NifFormat.``NiPSGravityStrengthCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    `unknown_2`
    `unknown_3`
  class `NifFormat.``NiPSMeshEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `name`
    `unknown_1`
    `unknown_10`
    `unknown_11`
    `unknown_12`
    `unknown_13`
    `unknown_14`
    `unknown_15`
    `unknown_16`
    `unknown_17`
    `unknown_18`
    `unknown_19`
    `unknown_2`
    `unknown_20`
    `unknown_21`
    `unknown_22`
    `unknown_23`
    `unknown_24`
    `unknown_25`
    `unknown_26`
    `unknown_27`
    `unknown_28`
    `unknown_3`
    `unknown_4`
    `unknown_5`
    `unknown_6`
    `unknown_7`
    `unknown_8`
    `unknown_9`
  class `NifFormat.``NiPSMeshParticleSystem`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSParticleSystem`

    `unknown_23`
    `unknown_24`

      Unknown - may or may not be emitted mesh?

    `unknown_25`
    `unknown_26`
  class `NifFormat.``NiPSParticleSystem`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiAVObject`

    `emitter`

      Emitter?

    `generator`

      Generator?

    `simulator`

      Simulator?

    `unknown_10`

      0?

    `unknown_11`

      0?

    `unknown_12`

      Counter?

    `unknown_15`

      Simulator?

    `unknown_16`

      Updater?

    `unknown_17`

      1?

    `unknown_19`

      0?

    `unknown_20`

      Spawner?

    `unknown_21`

      Unknown

    `unknown_22`

      Unknown

    `unknown_27`
    `unknown_28`
    `unknown_29`
    `unknown_3`

      0?

    `unknown_30`
    `unknown_31`
    `unknown_32`
    `unknown_33`
    `unknown_34`
    `unknown_35`
    `unknown_36`

      -1?

    `unknown_37`
    `unknown_38`
    `unknown_39`
    `unknown_4`

      -1?

    `unknown_5`

      0?

    `unknown_6`

      256?

    `unknown_7`

      0?

    `unknown_8`

      0?

    `unknown_9`

      0?

  class `NifFormat.``NiPSPlanarCollider`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `name`
    `unknown_byte_4`
    `unknown_floats_5`
    `unknown_int_1`
    `unknown_int_2`
    `unknown_link_6`
    `unknown_short_3`
  class `NifFormat.``NiPSResetOnLoopCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

  class `NifFormat.``NiPSSimulator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiMeshModifier`

    The mesh modifier that performs all particle system simulation.

    `num_simulation_steps`

      The number of simulation steps in this modifier.

    `simulation_steps`

      Links to the simulation steps.

  class `NifFormat.``NiPSSimulatorCollidersStep`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSSimulatorStep`

    Encapsulates a floodgate kernel that simulates particle colliders.

    `colliders`

      The colliders affecting the particle system.

    `num_colliders`

      The number of colliders affecting the particle system.

  class `NifFormat.``NiPSSimulatorFinalStep`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSSimulatorStep`

    Encapsulates a floodgate kernel that updates particle positions and ages. As indicated by its name, this step should be attached last in the NiPSSimulator mesh modifier.

  class `NifFormat.``NiPSSimulatorForcesStep`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSSimulatorStep`

    Encapsulates a floodgate kernel that simulates particle forces.

    `forces`

      The forces affecting the particle system.

    `num_forces`

      The number of forces affecting the particle system.

  class `NifFormat.``NiPSSimulatorGeneralStep`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSSimulatorStep`

    Encapsulates a floodgate kernel that updates particle size, colors, and rotations.

    `color_keys`

      The particle color keys.

    `color_loop_behavior`

      The loop behavior for the color keys.

    `grow_generation`

      Specifies the particle generation to which the grow effect should be applied. This is usually generation 0, so that newly created particles will grow.

    `grow_time`

      The the amount of time over which a particle’s size is ramped from 0.0 to 1.0 in seconds

    `num_color_keys`

      The number of color animation keys.

    `num_rotation_keys`

      The number of rotatoin animation keys.

    `num_size_keys`

      The number of size animation keys.

    `rotation_keys`

      The particle rotation keys.

    `rotation_loop_behavior`

      The loop behavior for the rotation keys.

    `shrink_generation`

      Specifies the particle generation to which the shrink effect should be applied. This is usually the highest supported generation for the particle system, so that particles will shrink immediately before getting killed.

    `shrink_time`

      The the amount of time over which a particle’s size is ramped from 1.0 to 0.0 in seconds

    `size_keys`

      The particle size keys.

    `size_loop_behavior`

      The loop behavior for the size keys.

    `unknown_1`
    `unknown_2`
    `unknown_3`
  class `NifFormat.``NiPSSimulatorMeshAlignStep`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSSimulatorStep`

    Encapsulates a floodgate kernel that updates mesh particle alignment and transforms.

    `num_rotation_keys`

      The number of rotation keys.

    `rotation_keys`

      The particle rotation keys.

    `rotation_loop_behavior`

      The loop behavior for the rotation keys.

  class `NifFormat.``NiPSSimulatorStep`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Abstract base class for a single step in the particle system simulation process. It has no seralized data.

  class `NifFormat.``NiPSSpawner`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

  class `NifFormat.``NiPSSphereEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `name`
    `unknown_10`
    `unknown_11`
    `unknown_12`
    `unknown_13`
    `unknown_14`
    `unknown_15`
    `unknown_16`
    `unknown_17`
    `unknown_18`
    `unknown_19`
    `unknown_2`
    `unknown_20`
    `unknown_21`

      Target node?

    `unknown_22`
    `unknown_3`
    `unknown_4`
    `unknown_5`
    `unknown_6`
    `unknown_7`
    `unknown_8`
    `unknown_9`
  class `NifFormat.``NiPSSphericalCollider`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `unknown_1`
    `unknown_2`
    `unknown_3`
    `unknown_4`
    `unknown_5`
    `unknown_6`
    `unknown_7`
  class `NifFormat.``NiPSysAgeDeathModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Unknown particle modifier.

    `spawn_modifier`

      Link to NiPSysSpawnModifier object?

    `spawn_on_death`

      Unknown.

  class `NifFormat.``NiPSysAirFieldAirFrictionCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for air field air friction.

  class `NifFormat.``NiPSysAirFieldInheritVelocityCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for air field inherit velocity.

  class `NifFormat.``NiPSysAirFieldModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysFieldModifier`

    Particle system modifier, used for controlling the particle velocity in a field like wind.

    `direction`

      Direction of the particle velocity

    `unknown_boolean_1`

      Unknown

    `unknown_boolean_2`

      Unknown

    `unknown_boolean_3`

      Unknown

    `unknown_float_2`

      Unknown

    `unknown_float_3`

      Unknown

    `unknown_float_4`

      Unknown

  class `NifFormat.``NiPSysAirFieldSpreadCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for air field spread.

  class `NifFormat.``NiPSysBombModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Particle modifier that uses a NiNode to use as a “Bomb Object” to alter the path of particles.

    `bomb_axis`

      Orientation of bomb object.

    `bomb_object`

      Link to a NiNode for bomb to function.

    `decay`

      Falloff rate of the bomb object.

    `decay_type`

      Decay type

    `delta_v`

      DeltaV / Strength?

    `symmetry_type`

      Shape/symmetry of the bomb object.

  class `NifFormat.``NiPSysBoundUpdateModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Unknown particle system modifier.

    `update_skip`

      Unknown.

  class `NifFormat.``NiPSysBoxEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysVolumeEmitter`

    Particle emitter that uses points within a defined Box shape to emit from..

    `depth`

      Defines the Depth of the box area.

    `height`

      Defines the Height of the box area.

    `width`

      Defines the Width of the box area.

  class `NifFormat.``NiPSysCollider`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Particle system collider.

    `bounce`

      Defines amount of bounce the collider object has.

    `collider_object`

      Links to a NiNode that will define where in object space the collider is located/oriented.

    `die_on_collide`

      Kill particles on impact if set to yes.

    `next_collider`

      The next collider.

    `parent`

      Link to parent.

    `spawn_modifier`

      Link to NiPSysSpawnModifier object?

    `spawn_on_collide`

      Unknown.

  class `NifFormat.``NiPSysColliderManager`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Particle modifier that adds a defined shape to act as a collision object for particles to interact with.

    `collider`

      Link to a NiPSysPlanarCollider or NiPSysSphericalCollider.

  class `NifFormat.``NiPSysColorModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Particle modifier that adds keyframe data to modify color/alpha values of particles over time.

    `data`

      Refers to NiColorData object.

  class `NifFormat.``NiPSysCylinderEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysVolumeEmitter`

    Particle emitter that uses points within a defined Cylinder shape to emit from.

    `height`

      Height of the cylinders shape.

    `radius`

      Radius of the cylinder shape.

  class `NifFormat.``NiPSysData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiRotatingParticlesData`

    Particle system data.

    `aspect_ratio`

      Sets aspect ratio for Subtexture Offset UV quads

    `has_subtexture_offset_u_vs`

      Boolean for Num Subtexture Offset UVs

    `has_unknown_floats_3`

      Unknown.

    `num_subtexture_offset_u_vs`

      How many quads to use in BSPSysSubTexModifier for texture atlasing

    `particle_descriptions`

      Unknown.

    `subtexture_offset_u_vs`

      Defines UV offsets

    `unknown_byte_4`

      Unknown

    `unknown_floats_3`

      Unknown.

    `unknown_int_4`

      Unknown

    `unknown_int_5`

      Unknown

    `unknown_int_6`

      Unknown

    `unknown_short_1`

      Unknown.

    `unknown_short_2`

      Unknown.

    `unknown_short_3`

      Unknown

  class `NifFormat.``NiPSysDragFieldModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysFieldModifier`

    Particle system modifier, used for controlling the particle velocity in drag space warp.

    `direction`

      Direction of the particle velocity

    `use_direction`

      Whether to use the direction field?

  class `NifFormat.``NiPSysDragModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Unknown.

    `drag_axis`

      The drag axis.

    `parent`

      Parent reference.

    `percentage`

      Drag percentage.

    `range`

      The range.

    `range_falloff`

      The range falloff.

  class `NifFormat.``NiPSysEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    A particle emitter?

    `declination`

      Declination / First axis.

    `declination_variation`

      Declination randomness / First axis.

    `initial_color`

      Defines color of a birthed particle.

    `initial_radius`

      Size of a birthed particle.

    `life_span`

      Duration until a particle dies.

    `life_span_variation`

      Adds randomness to Life Span.

    `planar_angle`

      Planar Angle / Second axis.

    `planar_angle_variation`

      Planar Angle randomness / Second axis .

    `radius_variation`

      Particle Radius randomness.

    `speed`

      Speed / Inertia of particle movement.

    `speed_variation`

      Adds an amount of randomness to Speed.

  class `NifFormat.``NiPSysEmitterCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

    Particle system emitter controller.

    `data`

      This controller’s data

    `visibility_interpolator`

      Links to a bool interpolator. Controls emitter’s visibility status?

  class `NifFormat.``NiPSysEmitterCtlrData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Particle system emitter controller data.

    `float_keys`

      Unknown.

    `num_visibility_keys`

      Number of keys.

    `visibility_keys`

      Unknown.

  class `NifFormat.``NiPSysEmitterDeclinationCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Unknown.

  class `NifFormat.``NiPSysEmitterDeclinationVarCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Unknown.

  class `NifFormat.``NiPSysEmitterInitialRadiusCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Unknown.

  class `NifFormat.``NiPSysEmitterLifeSpanCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Unknown.

  class `NifFormat.``NiPSysEmitterPlanarAngleCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for emitter planar angle.

  class `NifFormat.``NiPSysEmitterPlanarAngleVarCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for emitter planar angle variation.

  class `NifFormat.``NiPSysEmitterSpeedCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Unknown.

  class `NifFormat.``NiPSysFieldAttenuationCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for force field attenuation.

  class `NifFormat.``NiPSysFieldMagnitudeCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for force field magnitude.

  class `NifFormat.``NiPSysFieldMaxDistanceCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for force field maximum distance.

  class `NifFormat.``NiPSysFieldModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Base for all force field particle modifiers.

    `attenuation`

      Controls how quick the field diminishes

    `field_object`

      Force Field Object

    `magnitude`

      Magnitude of the force

    `max_distance`

      Maximum distance

    `use_max_distance`

      Use maximum distance

  class `NifFormat.``NiPSysGravityFieldModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysFieldModifier`

    Particle system modifier, used for controlling the particle velocity in gravity field.

    `direction`

      Direction of the particle velocity

  class `NifFormat.``NiPSysGravityModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Adds gravity to a particle system, when linked to a NiNode to use as a Gravity Object.

    `decay`

      Falloff range.

    `force_type`

      Planar or Spherical type

    `gravity_axis`

      Orientation of gravity.

    `gravity_object`

      Refers to a NiNode for gravity location.

    `strength`

      The strength of gravity.

    `turbulence`

      Adds a degree of randomness.

    `turbulence_scale`

      Range for turbulence.

    `unknown_byte`

      Unknown

  class `NifFormat.``NiPSysGravityStrengthCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Unknown.

  class `NifFormat.``NiPSysGrowFadeModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Particle modifier that controls the time it takes to grow a particle from Size=0 to the specified Size in the emitter, and then back to 0. This modifer has no control over alpha settings.

    `base_scale`

      Unknown

    `fade_generation`

      Unknown.

    `fade_time`

      Time in seconds to fade out.

    `grow_generation`

      Unknown.

    `grow_time`

      Time in seconds to fade in.

  class `NifFormat.``NiPSysInitialRotAngleCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for emitter initial rotation angle.

  class `NifFormat.``NiPSysInitialRotAngleVarCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for emitter initial rotation angle variation.

  class `NifFormat.``NiPSysInitialRotSpeedCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for emitter initial rotation speed.

  class `NifFormat.``NiPSysInitialRotSpeedVarCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierFloatCtlr`

    Particle system controller for emitter initial rotation speed variation.

  class `NifFormat.``NiPSysMeshEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysEmitter`

    Particle emitter that uses points on a specified mesh to emit from.

    `emission_axis`

      The emission axis.

    `emission_type`

      The parts of the mesh that the particles emit from.

    `emitter_meshes`

      Links to meshes used for emitting.

    `initial_velocity_type`

      The way the particles get their initial direction and speed.

    `num_emitter_meshes`

      The number of references to emitter meshes that follow.

  class `NifFormat.``NiPSysMeshUpdateModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Unknown.

    `meshes`

      Group of target NiNodes or NiTriShapes?

    `num_meshes`

      The number of object references that follow.

  class `NifFormat.``NiPSysModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Generic particle system modifier object.

    `active`

      Whether the modifier is currently in effect? Usually true.

    `name`

      The object name.

    `order`

      Modifier ID in the particle modifier chain (always a multiple of 1000)?

    `target`

      NiParticleSystem parent of this modifier.

  class `NifFormat.``NiPSysModifierActiveCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierBoolCtlr`

    Unknown.

    `data`

      This controller’s data.

  class `NifFormat.``NiPSysModifierBoolCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

    A particle system modifier controller that deals with boolean data?

  class `NifFormat.``NiPSysModifierCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSingleInterpController`

    A particle system modifier controller.

    `modifier_name`

      Refers to modifier object by its name?

  class `NifFormat.``NiPSysModifierFloatCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifierCtlr`

    A particle system modifier controller that deals with floating point data?

    `data`

      This controller’s data.

  class `NifFormat.``NiPSysPlanarCollider`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysCollider`

    Particle Collider object which particles will interact with.

    `height`

      Defines the height of the plane.

    `width`

      Defines the width of the plane.

    `x_axis`

      Defines Orientation.

    `y_axis`

      Defines Orientation.

  class `NifFormat.``NiPSysPositionModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Unknown particle system modifier.

  class `NifFormat.``NiPSysRadialFieldModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysFieldModifier`

    Particle system modifier, used for controlling the particlevelocity in force field.

    `radial_type`

      Unknown Enums?

  class `NifFormat.``NiPSysResetOnLoopCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Unknown.

  class `NifFormat.``NiPSysRotationModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Particle modifier that adds rotations to particles.

    `initial_axis`

      Unknown.

    `initial_rotation_angle`

      Sets the intial angle for particles to be birthed in.

    `initial_rotation_angle_variation`

      Adds a random range to Initial angle.

    `initial_rotation_speed`

      The initial speed of rotation.

    `initial_rotation_speed_variation`

      Adds a ranged randomness to rotation speed.

    `random_initial_axis`

      Unknown.

    `random_rot_speed_sign`

      Unknown

  class `NifFormat.``NiPSysSpawnModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysModifier`

    Unknown particle modifier.

    `life_span`

      Unknown.

    `life_span_variation`

      Unknown.

    `max_num_to_spawn`

      Unknown.

    `min_num_to_spawn`

      Unknown.

    `num_spawn_generations`

      Unknown.

    `percentage_spawned`

      Unknown.

    `spawn_dir_chaos`

      Unknown.

    `spawn_speed_chaos`

      Unknown.

    `unknown_int`

      Unknown

  class `NifFormat.``NiPSysSphereEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysVolumeEmitter`

    Particle emitter that uses points within a sphere shape to emit from.

    `radius`

      The radius of the sphere shape

  class `NifFormat.``NiPSysSphericalCollider`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysCollider`

    Particle Collider object which particles will interact with.

    `radius`

      Defines the radius of the sphere object.

  class `NifFormat.``NiPSysTrailEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysEmitter`

    Guild 2-Specific node

    `unknown_float_1`

      Unknown

    `unknown_float_2`

      Unknown

    `unknown_float_3`

      Unknown

    `unknown_float_4`

      Unknown

    `unknown_float_5`

      Unknown

    `unknown_float_6`

      Unknown

    `unknown_float_7`

      Unknown

    `unknown_int_1`

      Unknown

    `unknown_int_2`

      Unknown

    `unknown_int_3`

      Unknown

    `unknown_int_4`

      Unknown

  class `NifFormat.``NiPSysTurbulenceFieldModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysFieldModifier`

    Particle system modifier, used for controlling the particle velocity in drag space warp.

    `frequency`

      Frequency of the update.

  class `NifFormat.``NiPSysUpdateCtlr`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Particle system controller, used for ???.

  class `NifFormat.``NiPSysVolumeEmitter`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysEmitter`

    An emitter that emits meshes?

    `emitter_object`

      Node parent of this modifier?

  class `NifFormat.``NiPSysVortexFieldModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPSysFieldModifier`

    Particle system modifier, used for controlling the particle velocity in force field.

    `direction`

      Direction of the particle velocity

  class `NifFormat.``NiPalette`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    A color palette.

    `num_entries`

      The number of palette entries. Always = 256.

    `palette`

      The color palette.

    `unknown_byte`

      Unknown, Usually = 0.

  class `NifFormat.``NiParticleBomb`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleModifier`

    A particle modifier.

    `decay`

      Unknown.

    `decay_type`

      Unknown.

    `delta_v`

      Unknown.

    `direction`

      The direction of the applied acceleration?

    `duration`

      Unknown.

    `position`

      The position of the mass point relative to the particle system?

    `start`

      Unknown.

    `symmetry_type`

      Unknown.

  class `NifFormat.``NiParticleColorModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleModifier`

    Unknown.

    `color_data`

      Color data index.

  class `NifFormat.``NiParticleGrowFade`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleModifier`

    This particle system modifier controls the particle size. If it is present the particles start with size 0.0 . Then they grow to their original size and stay there until they fade to zero size again at the end of their lifetime cycle.

    `fade`

      The time from the end of the particle lifetime during which the particle fades.

    `grow`

      The time from the beginning of the particle lifetime during which the particle grows.

  class `NifFormat.``NiParticleMeshModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleModifier`

    Unknown.

    `num_particle_meshes`

      The number of particle mesh references that follow.

    `particle_meshes`

      Links to nodes of particle meshes?

  class `NifFormat.``NiParticleMeshes`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticles`

    Mesh particle node?

  class `NifFormat.``NiParticleMeshesData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiRotatingParticlesData`

    Particle meshes data.

    `unknown_link_2`

      Refers to the mesh that makes up a particle?

  class `NifFormat.``NiParticleModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    A particle system modifier.

    `controller`

      Points to the particle system controller parent.

    `next_modifier`

      Next particle modifier.

  class `NifFormat.``NiParticleRotation`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleModifier`

    Unknown.

    `initial_axis`

      Unknown.

    `random_initial_axis`

      Unknown.

    `rotation_speed`

      Unknown.

  class `NifFormat.``NiParticleSystem`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticles`

    A particle system.

    `modifiers`

      The list of particle modifiers.

    `num_modifiers`

      The number of modifier references.

    `unknown_int_1`

      Unknown

    `unknown_short_2`

      Unknown

    `unknown_short_3`

      Unknown

    `world_space`

      If true, Particles are birthed into world space. If false, Particles are birthed into object space.

  class `NifFormat.``NiParticleSystemController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    A generic particle system time controller object.

    `color_data`
    `emit_flags`

      Bit 0: Emit Rate toggle bit (0 = auto adjust, 1 = use Emit Rate value)

    `emit_rate`

      Particle emission rate (particles per second)

    `emit_start_time`

      Particle emit start time

    `emit_stop_time`

      Particle emit stop time

    `emitter`

      This index targets the particle emitter object (TODO: find out what type of object this refers to).

    `horizontal_angle`

      emitter’s horizontal opening angle

    `horizontal_direction`

      horizontal emit direction

    `lifetime`

      Particle lifetime

    `lifetime_random`

      Particle lifetime random modifier

    `num_particles`

      Size of the following array. (Maximum number of simultaneous active particles)

    `num_valid`

      Number of valid entries in the following array. (Number of active particles at the time the system was saved)

    `old_emit_rate`

      Particle emission rate in old files

    `old_speed`

      Particle speed in old files

    `particle_extra`

      Link to some optional particle modifiers (NiGravity, NiParticleGrowFade, NiParticleBomb, ...)

    `particle_lifetime`

      The particle’s age.

    `particle_link`
    `particle_timestamp`

      Timestamp of the last update.

    `particle_unknown_short`

      Unknown short

    `particle_unknown_vector`

      Unknown

    `particle_velocity`

      Particle velocity

    `particle_vertex_id`

      Particle/vertex index matches array index

    `particles`

      Individual particle modifiers?

    `size`

      Particle size

    `speed`

      Particle speed

    `speed_random`

      Particle random speed modifier

    `start_random`

      Particle random start translation vector

    `trailer`

      Trailing null byte

    `unknown_byte`

      Unknown byte, (=0)

    `unknown_color`

      Unknown.

    `unknown_float_1`
    `unknown_float_13`

      ? float=1.0 ?

    `unknown_floats_2`
    `unknown_int_1`

      ? int=1 ?

    `unknown_int_2`

      ? int=0 ?

    `unknown_link`

      unknown int (=0xffffffff)

    `unknown_link_2`

      Unknown int (=0xffffffff)

    `unknown_normal`

      Unknown.

    `unknown_short_2`

      ? short=0 ?

    `unknown_short_3`

      ? short=0 ?

    `vertical_angle`

      emitter’s vertical opening angle [radians]

    `vertical_direction`

      vertical emit direction [radians]0.0 : up1.6 : horizontal3.1416 : down

  class `NifFormat.``NiParticles`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiGeometry`

    Generic particle system node.

  class `NifFormat.``NiParticlesData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiGeometryData`

    Generic rotating particles data object.

    `has_radii`

      Is the particle size array present?

    `has_rotation_angles`

      Are the angles of rotation present?

    `has_rotation_axes`

      Are axes of rotation present?

    `has_rotations`

      Is the particle rotation array present?

    `has_sizes`

      Is the particle size array present?

    `has_uv_quadrants`

      if value is no, a single image rendered

    `num_active`

      The number of active particles at the time the system was saved. This is also the number of valid entries in the following arrays.

    `num_particles`

      The maximum number of particles (matches the number of vertices).

    `num_uv_quadrants`

      2,4,8,16,32,64 are potential values. If “Has” was no then this should be 256, which represents a 16x16 framed image, which is invalid

    `particle_radius`

      The particles’size.

    `radii`

      The individual particel sizes.

    `rotation_angles`

      Angles of rotation

    `rotation_axes`

      Unknown

    `rotations`

      The individual particle rotations.

    `sizes`

      The individual particel sizes.

    `unknown_byte_1`

      Unknown, probably a boolean.

    `unknown_byte_2`

      Unknown

    `unknown_link`

      Unknown

    `uv_quadrants`
  class `NifFormat.``NiPathController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Time controller for a path.

    `float_data`

      Path controller data index (float data). ?

    `pos_data`

      Path controller data index (position data). ?

    `unknown_float_2`

      Unknown, often 0?

    `unknown_float_3`

      Unknown, often 0?

    `unknown_int_1`

      Unknown, always 1?

    `unknown_short`

      Unknown, always 0?

    `unknown_short_2`

      Unknown.

  class `NifFormat.``NiPathInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiKeyBasedInterpolator`

    Unknown interpolator.

    `float_data`

      Links to NiFloatData.

    `pos_data`

      Links to NiPosData.

    `unknown_float_1`

      Unknown.

    `unknown_float_2`

      Unknown.

    `unknown_int`

      Unknown.

    `unknown_short`

      Unknown.

    `unknown_short_2`

      Unknown. Zero.

  class `NifFormat.``NiPersistentSrcTextureRendererData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.ATextureRenderData`

    `num_faces`

      Unknown

    `num_pixels`

      Unknown

    `pixel_data`

      Raw pixel data holding the mipmaps. Mipmap zero is the full-size texture and they get smaller by half as the number increases.

    `unknown_int_6`

      Unknown, same as the number of pixels? / number of blocks?

    `unknown_int_7`

      Unknown

  class `NifFormat.``NiPhysXActorDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown PhysX node.

    `shape_description`

      PhysX Shape Description

    `unknown_byte_1`

      Unknown

    `unknown_byte_2`

      Unknown

    `unknown_int_1`

      Unknown

    `unknown_int_2`

      Unknown

    `unknown_int_4`

      Unknown

    `unknown_int_5`

      Unknown

    `unknown_int_6`

      Unknown

    `unknown_quat_1`

      Unknown

    `unknown_quat_2`

      Unknown

    `unknown_quat_3`

      Unknown

    `unknown_ref_0`

      Unknown

    `unknown_ref_1`

      Unknown

    `unknown_ref_2`

      Unknown

    `unknown_refs_3`

      Unknown

  class `NifFormat.``NiPhysXBodyDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown PhysX node.

    `unknown_bytes`

      Unknown

  class `NifFormat.``NiPhysXD6JointDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown PhysX node.

    `unknown_bytes`

      Unknown

  class `NifFormat.``NiPhysXKinematicSrc`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown PhysX node.

    `unknown_bytes`

      Unknown

  class `NifFormat.``NiPhysXMaterialDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown node.

    `unknown_byte_1`

      Unknown

    `unknown_byte_2`

      Unknown

    `unknown_int`

      Unknown

  class `NifFormat.``NiPhysXMeshDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown PhysX node.

    `num_vertices`

      Number of mesh vertices

    `unknown_byte_1`

      Unknown

    `unknown_byte_2`

      Unknown

    `unknown_bytes_0`

      NXS

    `unknown_bytes_1`

      MESH

    `unknown_bytes_2`

      Unknown

    `unknown_bytes_3`

      Unknown

    `unknown_float_1`

      Unknown

    `unknown_float_2`

      Unknown

    `unknown_int_1`

      Unknown

    `unknown_int_2`

      Unknown

    `unknown_int_4`

      Unknown

    `unknown_ints_1`

      Unknown

    `unknown_short_1`

      Unknown

    `unknown_short_2`

      Unknown

    `unknown_shorts_1`

      Unknown

    `vertices`

      Vertices

  class `NifFormat.``NiPhysXProp`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObjectNET`

    Unknown PhysX node.

    `num_dests`

      Number of NiPhysXTransformDest references

    `prop_description`

      PhysX Property Description.

    `transform_dests`

      Unknown

    `unknown_byte`

      Unknown

    `unknown_float_1`

      Unknown

    `unknown_int`

      Unknown

    `unknown_int_1`

      Unknown

    `unknown_refs_1`

      Unknown

  class `NifFormat.``NiPhysXPropDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown PhysX node.

    `actor_descs`

      Unknown

    `joint_descs`

      PhysX Joint Descriptions

    `material_descs`

      PhysX Material Descriptions

    `num_dests`

      Number of NiPhysXActorDesc references

    `num_joints`

      Unknown

    `num_materials`

      Unknown

    `unknown_byte_6`

      Unknown

    `unknown_int_1`

      Unknown

    `unknown_int_2`

      Unknown

    `unknown_int_3`

      Unknown

    `unknown_int_5`

      Unknown

    `unknown_string_4`

      Unknown

  class `NifFormat.``NiPhysXShapeDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown PhysX node.

    `mesh_description`

      PhysX Mesh Description

    `unknown_float_1`

      Unknown

    `unknown_float_2`

      Unknown

    `unknown_float_3`

      Unknown

    `unknown_int_1`

      Unknown

    `unknown_int_2`

      Unknown

    `unknown_int_3`

      Unknown

    `unknown_int_4`

      Unknown

    `unknown_int_5`

      Unknown

    `unknown_int_7`

      Unknown

    `unknown_int_8`

      Unknown

    `unknown_quat_1`

      Unknown

    `unknown_quat_2`

      Unknown

    `unknown_quat_3`

      Unknown

    `unknown_short_1`

      Unknown

    `unknown_short_2`

      Unknown

  class `NifFormat.``NiPhysXTransformDest`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Unknown PhysX node.

    `node`

      Affected node?

    `unknown_byte_1`

      Unknown. =1?

    `unknown_byte_2`

      Unknown. =0

  class `NifFormat.``NiPixelData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.ATextureRenderData`

    A texture.

    `num_faces`

      Unknown

    `num_pixels`

      Total number of pixels

    `pixel_data`

      Raw pixel data holding the mipmaps. Mipmap zero is the full-size texture and they get smaller by half as the number increases.

  class `NifFormat.``NiPlanarCollider`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleModifier`

    Unknown.

    `unknown_float_1`

      Unknown.

    `unknown_float_10`

      Unknown.

    `unknown_float_11`

      Unknown.

    `unknown_float_12`

      Unknown.

    `unknown_float_13`

      Unknown.

    `unknown_float_14`

      Unknown.

    `unknown_float_15`

      Unknown.

    `unknown_float_16`

      Unknown.

    `unknown_float_2`

      Unknown.

    `unknown_float_3`

      Unknown.

    `unknown_float_4`

      Unknown.

    `unknown_float_5`

      Unknown.

    `unknown_float_6`

      Unknown.

    `unknown_float_7`

      Unknown.

    `unknown_float_8`

      Unknown.

    `unknown_float_9`

      Unknown.

    `unknown_short`

      Usually 0?

    `unknown_short_2`

      Unknown.

  class `NifFormat.``NiPoint3InterpController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSingleInterpController`

    A controller that interpolates point 3 data?

    `data`

      Material color controller data object index. Points to NiPosData.

    `target_color`

      Selects which color to control.

  class `NifFormat.``NiPoint3Interpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiKeyBasedInterpolator`

    Unknown.

    `data`

      Reference to NiPosData.

    `point_3_value`

      Value when posed? Value at time 0?

  class `NifFormat.``NiPointLight`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiLight`

    A point light.

    `constant_attenuation`

      Constant Attenuation

    `linear_attenuation`

      Linear Attenuation

    `quadratic_attenuation`

      Quadratic Attenuation (see glLight)

  class `NifFormat.``NiPortal`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiAVObject`

    A Portal

    `num_vertices`

      Number of vertices in this polygon

    `target`

      Target portal or room

    `unknown_flags`

      Unknown flags.

    `unknown_short_2`

      Unknown

    `vertices`

      Vertices

  class `NifFormat.``NiPosData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Position data.

    `data`

      The position keys.

  class `NifFormat.``NiProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObjectNET`

    A generic property object.

  class `NifFormat.``NiRangeLODData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiLODData`

    Describes levels of detail based on distance of object from camera.

    `lod_center`

      ?

    `lod_levels`

      The ranges of distance that each level of detail applies in.

    `num_lod_levels`

      Number of levels of detail.

  class `NifFormat.``NiRawImageData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Raw image data.

    `height`

      Image height

    `image_type`

      The format of the raw image data.

    `rgb_image_data`

      Image pixel data.

    `rgba_image_data`

      Image pixel data.

    `width`

      Image width

  class `NifFormat.``NiRenderObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiAVObject`

    An object that can be rendered.

    `active_material`

      The index of the currently active material.

    `material_data`

      Per-material data.

    `material_needs_update_default`

      The initial value for the flag that determines if the internal cached shader is valid.

    `num_materials`

      The number of materials affecting this renderable object.

  class `NifFormat.``NiRollController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSingleInterpController`

    Unknown.

    `data`

      The data for the controller.

  class `NifFormat.``NiRoom`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Grouping node for nodes in a Portal

    `in_portals`

      Number of portals into room

    `items`

      All geometry associated with room.

    `num_in_portals`

      Number of doors into room

    `num_items`

      Number of unknowns

    `num_portals_2`

      Number of doors out of room

    `num_walls`

      Number of walls in a room?

    `portals_2`

      Number of portals out of room

    `wall_plane`

      Face normal and unknown value.

  class `NifFormat.``NiRoomGroup`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Grouping node for nodes in a Portal

    `num_rooms`

      Number of rooms in this group

    `rooms`

      Rooms associated with this group.

    `shell_link`

      Outer Shell Geometry Node?

  class `NifFormat.``NiRotatingParticles`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticles`

    Unknown.

  class `NifFormat.``NiRotatingParticlesData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticlesData`

    Rotating particles data object.

    `has_rotations_2`

      Is the particle rotation array present?

    `rotations_2`

      The individual particle rotations.

  class `NifFormat.``NiScreenElements`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriShape`

    Two dimensional screen elements.

  class `NifFormat.``NiScreenElementsData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriShapeData`

    Two dimensional screen elements.

    `max_polygons`

      Maximum number of polygons?

    `num_polygons`

      Number of Polygons actually in use

    `polygon_indices`

      Polygon Indices

    `polygons`

      Polygons

    `unknown_u_short_1`

      Unknown

    `unknown_u_short_2`

      Unknown

    `unknown_u_short_3`

      Maximum number of faces

    `used_triangle_points`

      Number of in-use triangles

    `used_vertices`

      Number of in-use vertices

  class `NifFormat.``NiScreenLODData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiLODData`

    Describes levels of detail based on size of object on screen?

    `bound_center`

      The center of the bounding sphere?

    `bound_radius`

      The radius of the bounding sphere?

    `proportion_count`

      The number of screen size based LOD levels.

    `proportion_levels`

      The LOD levels based on proportion of screen size?

    `world_center`

      The center of the bounding sphere in world space?

    `world_radius`

      The radius of the bounding sphere in world space?

  class `NifFormat.``NiSequence`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Root node used in some Empire Earth II .kf files (version 4.2.2.0).

    `controlled_blocks`

      Refers to controlled objects.

    `name`

      Name of this object. This is also the name of the action associated with this file. For instance, if the original NIF file is called”demon.nif”and this animation file contains an attack sequence, then the file would be called”demon_attack1.kf”and this field would contain the string”attack1”.

    `num_controlled_blocks`

      Number of controlled objects.

    `text_keys`

      Link to NiTextKeyExtraData.

    `text_keys_name`

      Name of following referenced NiTextKeyExtraData class.

    `unknown_int_1`

      Unknown.

    `unknown_int_4`

      Unknown

    `unknown_int_5`

      Unknown

  class `NifFormat.``NiSequenceData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

  class `NifFormat.``NiSequenceStreamHelper`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObjectNET`

    Keyframe animation root node, in .kf files.

  class `NifFormat.``NiShadeProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Determines whether flat shading or smooth shading is used on a shape.

    `flags`

      1’s Bit: Enable smooth phong shading on this shape.If 1’s bit is not set, hard-edged flat shading will be used on this shape.

  class `NifFormat.``NiShadowGenerator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    `name`
    `num_unknown_links_1`
    `target`
    `unknown_flags`
    `unknown_links_1`
    `unkown_byte_5`
    `unkown_byte_9`
    `unkown_float_4`
    `unkown_int_2`
    `unkown_int_6`
    `unkown_int_7`
    `unkown_int_8`
  class `NifFormat.``NiSingleInterpController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiInterpController`

    A controller referring to a single interpolator.

    `interpolator`

      Link to interpolator.

  class `NifFormat.``NiSkinData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiSkinData`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor on data.

          >>> from pyffi.formats.nif import NifFormat
          >>> id44 = NifFormat.Matrix44()
          >>> id44.set_identity()
          >>> skelroot = NifFormat.NiNode()
          >>> skelroot.name = 'Scene Root'
          >>> skelroot.set_transform(id44)
          >>> bone1 = NifFormat.NiNode()
          >>> bone1.name = 'bone1'
          >>> bone1.set_transform(id44)
          >>> bone1.translation.x = 10
          >>> skelroot.add_child(bone1)
          >>> geom = NifFormat.NiTriShape()
          >>> geom.set_transform(id44)
          >>> skelroot.add_child(geom)
          >>> skininst = NifFormat.NiSkinInstance()
          >>> geom.skin_instance = skininst
          >>> skininst.skeleton_root = skelroot
          >>> skindata = NifFormat.NiSkinData()
          >>> skininst.data = skindata
          >>> skindata.set_transform(id44)
          >>> geom.add_bone(bone1, {})
          >>> geom.update_bind_position()
          >>> bone1.translation.x
          10.0
          >>> skindata.bone_list[0].skin_transform.translation.x
          -10.0
          >>> import pyffi.spells.nif.fix
          >>> import pyffi.spells.nif
          >>> data = NifFormat.Data()
          >>> data.roots = [skelroot]
          >>> toaster = pyffi.spells.nif.NifToaster()
          >>> toaster.scale = 0.1
          >>> pyffi.spells.nif.fix.SpellScale(data=data, toaster=toaster).recurse()
          pyffi.toaster:INFO:--- fix_scale ---
          pyffi.toaster:INFO:  scaling by factor 0.100000
          pyffi.toaster:INFO:  ~~~ NiNode [Scene Root] ~~~
          pyffi.toaster:INFO:    ~~~ NiNode [bone1] ~~~
          pyffi.toaster:INFO:    ~~~ NiTriShape [] ~~~
          pyffi.toaster:INFO:      ~~~ NiSkinInstance [] ~~~
          pyffi.toaster:INFO:        ~~~ NiSkinData [] ~~~
          >>> bone1.translation.x
          1.0
          >>> skindata.bone_list[0].skin_transform.translation.x
          -1.0

    `get_transform`()

      Return scale, rotation, and translation into a single 4x4 matrix.

    `set_transform`(mat)

      Set rotation, transform, and velocity.

  class `NifFormat.``NiSkinInstance`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Skinning instance.

    `bones`

      List of all armature bones.

    `data`

      Skinning data reference.

    `num_bones`

      The number of node bones referenced as influences.

    `skeleton_root`

      Armature root node.

    `skin_partition`

      Refers to a NiSkinPartition objects, which partitions the mesh such that every vertex is only influenced by a limited number of bones.

  class `NifFormat.``NiSkinPartition`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Skinning data, optimized for hardware skinning. The mesh is partitioned in submeshes such that each vertex of a submesh is influenced only by a limited and fixed number of bones.

    `num_skin_partition_blocks`

      Unknown.

    `skin_partition_blocks`

      Skin partition objects.

  class `NifFormat.``NiSkinningLODController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

  class `NifFormat.``NiSkinningMeshModifier`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiMeshModifier`

    `bone_bounds`

      The bounds of the bones. Only stored if the RECOMPUTE_BOUNDS bit is set.

    `bone_transforms`

      The transforms that go from bind-pose space to bone space.

    `bones`

      Pointers to the bone nodes that affect this skin.

    `flags`

      USE_SOFTWARE_SKINNING = 0x0001RECOMPUTE_BOUNDS = 0x0002

    `num_bones`

      The number of bones referenced by this mesh modifier.

    `skeleton_root`

      The root bone of the skeleton.

    `skeleton_transform`

      The transform that takes the root bone parent coordinate system into the skin coordinate system.

  class `NifFormat.``NiSortAdjustNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Unknown node. Found in Loki.

    `sorting_mode`

      Sorting

    `unknown_int_2`

      Unknown.

  class `NifFormat.``NiSourceCubeMap`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiSourceTexture`

    Unknown node. Found in Emerge Demo.

  class `NifFormat.``NiSourceTexture`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTexture`

    Describes texture source and properties.

    `alpha_format`

      Note: the NiTriShape linked to this object must have a NiAlphaProperty in its list of properties to enable material and/or texture transparency.

    `direct_render`

      Load direct to renderer

    `file_name`

      The original source filename of the image embedded by the referred NiPixelData object.

    `is_static`

      Is Static?

    `persist_render_data`

      Render data is persistant

    `pixel_data`

      Pixel data object index. NiPixelData or NiPersistentSrcTextureRendererData

    `pixel_layout`

      Specifies the way the image will be stored.

    `unknown_byte`

      Unknown. Seems to be set if Pixel Data is present?

    `unknown_link`

      Unknown.

    `use_external`

      Is the texture external?

    `use_mipmaps`

      Specifies whether mip maps are used.

  class `NifFormat.``NiSpecularProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Gives specularity to a shape. Flags 0x0001.

    `flags`

      1’s Bit = Enable specular lighting on this shape.

  class `NifFormat.``NiSphericalCollider`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiParticleModifier`

    Unknown.

    `unknown_float_1`

      Unknown.

    `unknown_float_2`

      Unknown.

    `unknown_float_3`

      Unknown.

    `unknown_float_4`

      Unknown.

    `unknown_float_5`

      Unknown.

    `unknown_short_1`

      Unknown.

    `unknown_short_2`

      Unknown.

  class `NifFormat.``NiSpotLight`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiPointLight`

    A spot.

    `cutoff_angle`

      The opening angle of the spot.

    `exponent`

      Describes the distribution of light. (see: glLight)

    `unknown_float`

      Unknown

  class `NifFormat.``NiStencilProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Allows control of stencil testing.

    `draw_mode`

      Used to enabled double sided faces. Default is 3 (DRAW_BOTH).

    `fail_action`
    `flags`

      Property flags:Bit 0: Stencil EnableBits 1-3: Fail ActionBits 4-6: Z Fail ActionBits 7-9: Pass ActionBits 10-11: Draw ModeBits 12-14: Stencil Function

    `pass_action`
    `stencil_enabled`

      Enables or disables the stencil test.

    `stencil_function`

      Selects the compare mode function (see: glStencilFunc).

    `stencil_mask`

      A bit mask. The default is 0xffffffff.

    `stencil_ref`

      Unknown. Default is 0.

    `z_fail_action`
  class `NifFormat.``NiStringExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Apparently commands for an optimizer instructing it to keep things it would normally discard.Also refers to NiNode objects (through their name) in animation .kf files.

    `bytes_remaining`

      The number of bytes left in the record. Equals the length of the following string + 4.

    `string_data`

      The string.

  class `NifFormat.``NiStringPalette`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    List of 0x00-seperated strings, which are names of controlled objects and controller types. Used in .kf files in conjunction with NiControllerSequence.

    `palette`

      A bunch of 0x00 seperated strings.

  class `NifFormat.``NiStringsExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    List of strings; for example, a list of all bone names.

    `data`

      The strings.

    `num_strings`

      Number of strings.

  class `NifFormat.``NiSwitchNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    A node used to switch between branches, such as for LOD levels?

    `unknown_flags_1`

      Flags

    `unknown_int_1`

      Index?

  class `NifFormat.``NiTextKeyExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Extra data, used to name different animation sequences.

    `num_text_keys`

      The number of text keys that follow.

    `text_keys`

      List of textual notes and at which time they take effect. Used for designating the start and stop of animations and the triggering of sounds.

    `unknown_int_1`

      Unknown. Always equals zero in all official files.

  class `NifFormat.``NiTexture`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObjectNET`

    A texture.

  class `NifFormat.``NiTextureEffect`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiDynamicEffect`

    Enables environment mapping. Should be in both the children list and effects list of the NiTriShape object. For Morrowind: the bump map can be used to bump the environment map (note that the bump map is ignored if no NiTextureEffect object is present).

    `clipping_plane`

      Determines whether a clipping plane is used. 0 means that a plane is not used.

    `coordinate_generation_type`

      The method that will be used to generate UV coordinates for the texture effect.

    `image`

      Image index.

    `model_projection_matrix`

      Model projection matrix. Always identity?

    `model_projection_transform`

      Model projection transform. Always (0,0,0)?

    `ps_2_k`

      -75?

    `ps_2_l`

      0?

    `source_texture`

      Source texture index.

    `texture_clamping`

      Texture Clamp mode.

    `texture_filtering`

      Texture Filtering mode.

    `texture_type`

      The type of effect that the texture is used for.

    `unknown`
    `unknown_float`

      Unknown. 0?

    `unknown_short`

      Unknown: 0.

    `unknown_vector`

      Unknown: (1,0,0)?

  class `NifFormat.``NiTextureModeProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Unknown

    `ps_2_k`

      -75?

    `ps_2_l`

      0?

    `unknown_ints`
    `unknown_short`

      Unknown. Either 210 or 194.

  class `NifFormat.``NiTextureProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    `flags`

      Property flags.

    `image`

      Link to the texture image.

    `unknown_ints_1`

      Property flags.

    `unknown_ints_2`

      Unknown. 0?

  class `NifFormat.``NiTextureTransformController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiFloatInterpController`

    Texture transformation controller. The target texture slot should have “Has Texture Transform” enabled.

    `data`

      Link to NiFloatData.

    `operation`

      Determines how this controller animates the UV Coordinates.

    `texture_slot`

      The target texture slot.

    `unknown_2`

      Unknown.

  class `NifFormat.``NiTexturingProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Describes an object’s textures.

    `apply_mode`

      Determines how the texture will be applied. Seems to have special functions in Oblivion.

    `base_texture`

      The base texture.

    `bump_map_luma_offset`

      Unknown.

    `bump_map_luma_scale`

      Unknown.

    `bump_map_matrix`

      Unknown.

    `bump_map_texture`

      The bump map texture.

    `dark_texture`

      The dark texture.

    `decal_0_texture`

      The decal texture.

    `decal_1_texture`

      Another decal texture.

    `decal_2_texture`

      Another decal texture.

    `decal_3_texture`

      Another decal texture. Who knows the limit.

    `detail_texture`

      The detail texture.

    `flags`

      Property flags.

    `gloss_texture`

      The gloss texture.

    `glow_texture`

      The glowing texture.

    `has_base_texture`

      Do we have a base texture?

    `has_bump_map_texture`

      Do we have a bump map texture?

    `has_dark_texture`

      Do we have a dark texture?

    `has_decal_0_texture`

      Do we have a decal 0 texture?

    `has_decal_1_texture`

      Do we have a decal 1 texture?

    `has_decal_2_texture`

      Do we have a decal 2 texture?

    `has_decal_3_texture`

      Do we have a decal 3 texture?

    `has_detail_texture`

      Do we have a detail texture?

    `has_gloss_texture`

      Do we have a gloss texture?

    `has_glow_texture`

      Do we have a glow texture?

    `has_normal_texture`

      Do we have a normal texture? (Noraml guess based on file suffix in sample files)

    `has_unknown_2_texture`

      Do we have a unknown texture 2?

    `normal_texture`

      Normal texture.

    `num_shader_textures`

      Number of Shader textures that follow.

    `shader_textures`

      Shader textures.

    `texture_count`

      Number of textures. Always 7 in versions<20.0.0.4. Can also be 8 in>= 20.0.0.4.

    `unknown_2_float`

      Unknown.

    `unknown_2_texture`

      Unknown texture 2.

  class `NifFormat.``NiTimeController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    A generic time controller object.

    `flags`

      Controller flags (usually 0x000C). Probably controls loops.Bit 0 : Anim type, 0=APP_TIME 1=APP_INITBit 1-2 : Cycle type 00=Loop 01=Reverse 10=LoopBit 3 : ActiveBit 4 : Play backwards

    `frequency`

      Frequency (is usually 1.0).

    `next_controller`

      Index of the next controller.

    `phase`

      Phase (usually 0.0).

    `start_time`

      Controller start time.

    `stop_time`

      Controller stop time.

    `target`

      Controller target (object index of the first controllable ancestor of this object).

    `unknown_integer`

      Unknown integer.

  class `NifFormat.``NiTransformController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiKeyframeController`

    NiTransformController replaces the NiKeyframeController.

  class `NifFormat.``NiTransformData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiKeyframeData`

    Mesh animation keyframe data.

  class `NifFormat.``NiTransformEvaluator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

  class `NifFormat.``NiTransformInterpolator`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiTransformInterpolator`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor <scale> on data.

  class `NifFormat.``NiTransparentProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Unknown

    `unknown`

      Unknown.

  class `NifFormat.``NiTriBasedGeom`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiTriBasedGeom`, `builtins.object`

    `get_interchangeable_tri_shape`(triangles=None)

      Returns a NiTriShape block that is geometrically interchangeable. If you do not want to set the triangles from the original shape, use the triangles argument.

    `get_interchangeable_tri_strips`(strips=None)

      Returns a NiTriStrips block that is geometrically interchangeable. If you do not want to set the strips from the original shape, use the strips argument.

    `get_tangent_space`()

      Return iterator over normal, tangent, bitangent vectors. If the block has no tangent space, then returns None.

    `update_skin_center_radius`()

      Update centers and radii of all skin data fields.

    `update_skin_partition`(maxbonesperpartition=4, maxbonespervertex=4, verbose=0, stripify=True, stitchstrips=False, padbones=False, triangles=None, trianglepartmap=None, maximize_bone_sharing=False)

      Recalculate skin partition data.

      Deprecated : | Do not use the verbose argument.
      Parameters: | maxbonesperpartition – Maximum number of bones in each partition. The num_bones field will not exceed this number. maxbonespervertex – Maximum number of bones per vertex. The num_weights_per_vertex field will be exactly equal to this number. verbose – Ignored, and deprecated. Set pyffi’s log level instead. stripify – If true, stripify the partitions, otherwise use triangles. stitchstrips – If stripify is true, then set this to true to stitch the strips. padbones – Enforces the numbones field to be equal to maxbonesperpartition. Also ensures that the bone indices are unique and sorted, per vertex. Raises an exception if maxbonespervertex is not equal to maxbonesperpartition (in that case bone indices cannot be unique and sorted). This options is required for Freedom Force vs. the 3rd Reich skin partitions. triangles – The triangles of the partition (if not specified, then this defaults to C{self.data.get_triangles()}. trianglepartmap – Maps each triangle to a partition index. Faces with different indices will never appear in the same partition. If the skin instance is a BSDismemberSkinInstance, then these indices are used as body part types, and the partitions in the BSDismemberSkinInstance are updated accordingly. Note that the faces are counted relative to L{triangles}. maximize_bone_sharing – Maximize bone sharing between partitions. This option is useful for Fallout 3.

    `update_tangent_space`(as_extra=None, vertexprecision=3, normalprecision=3)

      Recalculate tangent space data.

      Parameters: | as_extra – Whether to store the tangent space data as extra data (as in Oblivion) or not (as in Fallout 3). If not set, switches to Oblivion if an extra data block is found, otherwise does default. Set it to override this detection (for example when using this function to create tangent space data) and force behaviour.

  class `NifFormat.``NiTriBasedGeomData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiTriBasedGeomData`, `builtins.object`

    `get_triangle_indices`(triangles)

      Yield list of triangle indices (relative to self.get_triangles()) of given triangles. Degenerate triangles in the list are assigned index `None`.

          >>> from pyffi.formats.nif import NifFormat
          >>> geomdata = NifFormat.NiTriShapeData()
          >>> geomdata.set_triangles([(0,1,2),(1,2,3),(2,3,4)])
          >>> list(geomdata.get_triangle_indices([(1,2,3)]))
          [1]
          >>> list(geomdata.get_triangle_indices([(3,1,2)]))
          [1]
          >>> list(geomdata.get_triangle_indices([(2,3,1)]))
          [1]
          >>> list(geomdata.get_triangle_indices([(1,2,0),(4,2,3)]))
          [0, 2]
          >>> list(geomdata.get_triangle_indices([(0,0,0),(4,2,3)]))
          [None, 2]
          >>> list(geomdata.get_triangle_indices([(0,3,4),(4,2,3)]))
          Traceback (most recent call last):
              ...
          ValueError: ...

      Parameters: | triangles (iterator or list of tuples of three ints) – An iterable of triangles to check.

    `is_interchangeable`(other)

      Heuristically checks if two NiTriBasedGeomData blocks describe the same geometry, that is, if they can be used interchangeably in a nif file without affecting the rendering. The check is not fool proof but has shown to work in most practical cases.

      Parameters: | other (L{NifFormat.NiTriBasedGeomData} (if it has another type then the function will always return `False`)) – Another geometry data block.
      Returns: | `True` if the geometries are equivalent, `False` otherwise.

  class `NifFormat.``NiTriShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriBasedGeom`

    A shape node that refers to singular triangle data.

  class `NifFormat.``NiTriShapeData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiTriShapeData`, `builtins.object`

    Example usage:

        >>> from pyffi.formats.nif import NifFormat
        >>> block = NifFormat.NiTriShapeData()
        >>> block.set_triangles([(0,1,2),(2,1,3),(2,3,4)])
        >>> block.get_strips()
        [[0, 1, 2, 3, 4]]
        >>> block.get_triangles()
        [(0, 1, 2), (2, 1, 3), (2, 3, 4)]
        >>> block.set_strips([[1,0,1,2,3,4]])
        >>> block.get_strips() # stripifier keeps geometry but nothing else
        [[0, 2, 1, 3], [2, 4, 3]]
        >>> block.get_triangles()
        [(0, 2, 1), (1, 2, 3), (2, 4, 3)]

    `get_strips`()
    `get_triangles`()
    `set_strips`(strips)
    `set_triangles`(triangles, stitchstrips=False)
  class `NifFormat.``NiTriShapeSkinController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Old version of skinning instance.

    `bone_data`

      Contains skin weight data for each node that this skin is influenced by.

    `bones`

      List of all armature bones.

    `num_bones`

      The number of node bones referenced as influences.

    `vertex_counts`

      The number of vertex weights stored for each bone.

  class `NifFormat.``NiTriStrips`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTriBasedGeom`

    A shape node that refers to data organized into strips of triangles

  class `NifFormat.``NiTriStripsData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._NiTriStripsData`, `builtins.object`

    Example usage:

        >>> from pyffi.formats.nif import NifFormat
        >>> block = NifFormat.NiTriStripsData()
        >>> block.set_triangles([(0,1,2),(2,1,3),(2,3,4)])
        >>> block.get_strips()
        [[0, 1, 2, 3, 4]]
        >>> block.get_triangles()
        [(0, 1, 2), (1, 3, 2), (2, 3, 4)]
        >>> block.set_strips([[1,0,1,2,3,4]])
        >>> block.get_strips()
        [[1, 0, 1, 2, 3, 4]]
        >>> block.get_triangles()
        [(0, 2, 1), (1, 2, 3), (2, 4, 3)]

    `get_strips`()
    `get_triangles`()
    `set_strips`(strips)
    `set_triangles`(triangles, stitchstrips=False)
  class `NifFormat.``NiUVController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Time controller for texture coordinates.

    `data`

      Texture coordinate controller data index.

    `unknown_short`

      Always 0?

  class `NifFormat.``NiUVData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Texture coordinate data.

    `uv_groups`

      Four UV data groups. Appear to be U translation, V translation, U scaling/tiling, V scaling/tiling.

  class `NifFormat.``NiVectorExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Extra vector data.

    `unknown_float`

      Not sure whether this comes before or after the vector data.

    `vector_data`

      The vector data.

  class `NifFormat.``NiVertWeightsExtraData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiExtraData`

    Not used in skinning.Unsure of use - perhaps for morphing animation or gravity.

    `num_bytes`

      Number of bytes in this data object.

    `num_vertices`

      Number of vertices.

    `weight`

      The vertex weights.

  class `NifFormat.``NiVertexColorProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Property of vertex colors. This object is referred to by the root object of the NIF file whenever some NiTriShapeData object has vertex colors with non-default settings; if not present, vertex colors have vertex_mode=2 and lighting_mode=1.

    `flags`

      Property flags. Appears to be unused until 20.1.0.3.Bits 0-2: UnknownBit 3: Lighting Mode?Bits 4-5: Vertex Mode?

    `lighting_mode`

      The light mode. In Flags from 20.1.0.3 on.

    `vertex_mode`

      Determines how vertex and material colors are mixed.related gl function: glColorMaterialIn Flags from version 20.1.0.3 onwards.

  class `NifFormat.``NiVisController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiBoolInterpController`

    Time controller for visibility.

    `data`

      Visibility controller data object index.

  class `NifFormat.``NiVisData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiObject`

    Visibility data for a controller.

    `keys`

      The visibility keys.

    `num_keys`

      The number of visibility keys that follow.

  class `NifFormat.``NiWireframeProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    Unknown.

    `flags`

      Property flags.0 - Wireframe Mode Disabled1 - Wireframe Mode Enabled

  class `NifFormat.``NiZBufferProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiProperty`

    This Property controls the Z buffer (OpenGL: depth buffer).

    `flags`

      Bit 0 enables the z testBit 1 controls wether the Z buffer is read only (0) or read/write (1)

    `function`

      Z-Test function (see: glDepthFunc). In Flags from 20.1.0.3 on.

  exception `NifFormat.``NifError`

    Bases: `builtins.Exception`

    Standard nif exception class.

  class `NifFormat.``NodeGroup`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A group of NiNodes references.

    `nodes`

      The list of NiNode references.

    `num_nodes`

      Number of node references that follow.

  class `NifFormat.``OblivionColFilter`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Oblivion’s ColFilter property for Havok.

    `col_filter`

      The first bit sets the LINK property and controls whether this body is physically linked to others. The next bit turns collision off. Then, the next bit sets the SCALED property in Oblivion. The next five bits make up the number of this part in a linked body list.

    `layer`

      Sets mesh color in Oblivion Construction Set.

    `unknown_short`

      Unknown.

  class `NifFormat.``OblivionLayer`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Sets mesh color in Oblivion Construction Set. Anything higher than 57 is also null.

    `OL_ANIM_STATIC` = 2
    `OL_AVOID_BOX` = 21
    `OL_BACK_WEAPON` = 53
    `OL_BACK_WEAPON2` = 54
    `OL_BIPED` = 8
    `OL_BODY` = 34
    `OL_CAMERA_PICK` = 24
    `OL_CHAR_CONTROLLER` = 20
    `OL_CLOUD_TRAP` = 16
    `OL_CLUTTER` = 4
    `OL_CUSTOM_PICK_1` = 28
    `OL_CUSTOM_PICK_2` = 29
    `OL_DROPPING_PICK` = 31
    `OL_GROUND` = 17
    `OL_HEAD` = 33
    `OL_ITEM_PICK` = 25
    `OL_LINE_OF_SIGHT` = 26
    `OL_L_CALF` = 41
    `OL_L_FOOT` = 42
    `OL_L_FOREARM` = 38
    `OL_L_HAND` = 39
    `OL_L_THIGH` = 40
    `OL_L_UPPER_ARM` = 37
    `OL_NONCOLLIDABLE` = 15
    `OL_NULL` = 57
    `OL_OTHER` = 32
    `OL_PATH_PICK` = 27
    `OL_PONYTAIL` = 55
    `OL_PORTAL` = 18
    `OL_PROJECTILE` = 6
    `OL_PROPS` = 10
    `OL_QUIVER` = 52
    `OL_R_CALF` = 47
    `OL_R_FOOT` = 48
    `OL_R_FOREARM` = 44
    `OL_R_HAND` = 45
    `OL_R_THIGH` = 46
    `OL_R_UPPER_ARM` = 43
    `OL_SHIELD` = 51
    `OL_SIDE_WEAPON` = 50
    `OL_SPELL` = 7
    `OL_SPELL_EXPLOSION` = 30
    `OL_SPINE1` = 35
    `OL_SPINE2` = 36
    `OL_STAIRS` = 19
    `OL_STATIC` = 1
    `OL_TAIL` = 49
    `OL_TERRAIN` = 13
    `OL_TRANSPARENT` = 3
    `OL_TRAP` = 14
    `OL_TREES` = 9
    `OL_TRIGGER` = 12
    `OL_UNIDENTIFIED` = 0
    `OL_UNKNOWN1` = 22
    `OL_UNKNOWN2` = 23
    `OL_WATER` = 11
    `OL_WEAPON` = 5
    `OL_WING` = 56
  class `NifFormat.``OblivionSubShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Havok Information for packed TriStrip shapes.

    `col_filter`

      The first bit sets the LINK property and controls whether this body is physically linked to others. The next bit turns collision off. Then, the next bit sets the SCALED property in Oblivion. The next five bits make up the number of this part in a linked body list.

    `layer`

      Sets mesh color in Oblivion Construction Set.

    `material`

      The material of the subshape.

    `num_vertices`

      The number of vertices that form this sub shape.

    `unknown_short`

      Unknown. Perhaps the vertex wielding type?

  class `NifFormat.``OldSkinData`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Used to store skin weights in NiTriShapeSkinController.

    `unknown_vector`

      Unknown. Perhaps some sort of offset?

    `vertex_index`

      The index of the vertex that this weight applies to.

    `vertex_weight`

      The amount that this bone affects the vertex.

  class `NifFormat.``PSLoopBehavior`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `PS_LOOP_AGESCALE` = 2
    `PS_LOOP_CLAMP_BIRTH` = 0
    `PS_LOOP_CLAMP_DEATH` = 1
    `PS_LOOP_LOOP` = 3
    `PS_LOOP_REFLECT` = 4
  class `NifFormat.``Particle`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    particle array entry

    `lifespan`

      Maximum age of the particle.

    `lifetime`

      The particle’s age.

    `timestamp`

      Timestamp of the last update.

    `unknown_short`

      Unknown short

    `unknown_vector`

      Unknown

    `velocity`

      Particle velocity

    `vertex_id`

      Particle/vertex index matches array index

  class `NifFormat.``ParticleDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Particle Description.

    `translation`

      Unknown.

    `unknown_float_1`

      Unknown.

    `unknown_float_2`

      Unknown.

    `unknown_float_3`

      Unknown.

    `unknown_floats_1`

      Unknown.

    `unknown_int_1`

      Unknown.

  class `NifFormat.``PixelFormat`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Specifies the pixel format used by the NiPixelData object to store a texture.

    `PX_FMT_DXT1` = 4
    `PX_FMT_DXT5` = 5
    `PX_FMT_DXT5_ALT` = 6
    `PX_FMT_PAL8` = 2
    `PX_FMT_RGB8` = 0
    `PX_FMT_RGBA8` = 1
  class `NifFormat.``PixelLayout`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    An unsigned 32-bit integer, describing the color depth of a texture.

    `PIX_LAY_BUMPMAP` = 4
    `PIX_LAY_COMPRESSED` = 3
    `PIX_LAY_DEFAULT` = 6
    `PIX_LAY_HIGH_COLOR_16` = 1
    `PIX_LAY_PALETTISED` = 0
    `PIX_LAY_PALETTISED_4` = 5
    `PIX_LAY_TRUE_COLOR_32` = 2
  class `NifFormat.``Polygon`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Two dimensional screen elements.

    `num_triangles`

      Number of faces in this polygon

    `num_vertices`

      Number of vertices in this polygon

    `triangle_offset`

      Triangle offset in shape

    `vertex_offset`

      Vertex Offset

  class `NifFormat.``PropagationMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `PROPAGATE_ALWAYS` = 2
    `PROPAGATE_NEVER` = 3
    `PROPAGATE_ON_FAILURE` = 1
    `PROPAGATE_ON_SUCCESS` = 0
  class `NifFormat.``Ptr`(**kwargs)

    Bases: `pyffi.formats.nif.Ref`

    A weak reference to another block, used to point up the hierarchy tree. The reference is not returned by the L{get_refs} function to avoid infinite recursion.

    `get_hash`(data=None)
    `get_refs`(data=None)
    `get_value`()
    `replace_global_node`(oldbranch, newbranch, edge_filter=(True, True))
    `set_value`(value)
  class `NifFormat.``QTransform`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `rotation`

      Rotation.

    `scale`

      Scale.

    `translation`

      Translation.

  class `NifFormat.``QuatKey`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A special version of the key type used for quaternions. Never has tangents.

    `tbc`

      The TBC of the key.

    `time`

      Time the key applies.

    `value`

      Value of the key.

  class `NifFormat.``Quaternion`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A quaternion.

    `w`

      The w-coordinate.

    `x`

      The x-coordinate.

    `y`

      The y-coordinate.

    `z`

      The z-coordinate.

  class `NifFormat.``QuaternionXYZW`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A quaternion as it appears in the havok objects.

    `w`

      The w-coordinate.

    `x`

      The x-coordinate.

    `y`

      The y-coordinate.

    `z`

      The z-coordinate.

  `NifFormat.``RE_FILENAME` = <_sre.SRE_Pattern object at 0x5576900>
  class `NifFormat.``RagdollDescriptor`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._RagdollDescriptor`, `builtins.object`

    `update_a_b`(transform)

      Update B pivot and axes from A using the given transform.

  class `NifFormat.``Ref`(**kwargs)

    Bases: `pyffi.object_models.xml.basic.BasicBase`

    Reference to another block.

    `fix_links`(data)

      Fix block links.

    `get_detail_display`()
    `get_hash`(data=None)
    `get_links`(data=None)
    `get_refs`(data=None)
    `get_size`(data=None)
    `get_value`()
    `read`(stream, data)
    `replace_global_node`(oldbranch, newbranch, edge_filter=(True, True))

          >>> from pyffi.formats.nif import NifFormat
          >>> x = NifFormat.NiNode()
          >>> y = NifFormat.NiNode()
          >>> z = NifFormat.NiNode()
          >>> x.add_child(y)
          >>> x.children[0] is y
          True
          >>> x.children[0] is z
          False
          >>> x.replace_global_node(y, z)
          >>> x.children[0] is y
          False
          >>> x.children[0] is z
          True
          >>> x.replace_global_node(z, None)
          >>> x.children[0] is None
          True

    `set_value`(value)
    `write`(stream, data)

      Write block reference.

  class `NifFormat.``Region`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A range of indices, which make up a region (such as a submesh).

    `num_indices`
    `start_index`
  class `NifFormat.``RootCollisionNode`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiNode`

    Morrowind-specific node for collision mesh.

  class `NifFormat.``SemanticData`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `index`

      An extra index of the data. For example, if there are 3 uv maps,then the corresponding TEXCOORD data components would have indices0, 1, and 2, respectively.

    `name`

      Type of data (POSITION, POSITION_BP, INDEX, NORMAL, NORMAL_BP,TEXCOORD, BLENDINDICES, BLENDWEIGHT, BONE_PALETTE, COLOR, DISPLAYLIST,MORPH_POSITION, BINORMAL_BP, TANGENT_BP).

  class `NifFormat.``ShaderTexDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    An extended texture description for shader textures.

    `is_used`

      Is it used?

    `map_index`

      Map Index

    `texture_data`

      The texture data.

  class `NifFormat.``ShortString`(**kwargs)

    Bases: `pyffi.object_models.xml.basic.BasicBase`

    Another type for strings.

    `get_hash`(data=None)
    `get_size`(data=None)
    `get_value`()
    `read`(stream, data)
    `set_value`(value)
    `write`(stream, data)
  class `NifFormat.``SizedString`(**kwargs)

    Bases: `pyffi.object_models.xml.basic.BasicBase`, `pyffi.object_models.editable.EditableLineEdit`

    Basic type for strings. The type starts with an unsigned int which describes the length of the string.

        >>> from tempfile import TemporaryFile
        >>> f = TemporaryFile()
        >>> from pyffi.object_models import FileFormat
        >>> data = FileFormat.Data()
        >>> s = SizedString()
        >>> if f.write('\x07\x00\x00\x00abcdefg'.encode("ascii")): pass # ignore result for py3k
        >>> if f.seek(0): pass # ignore result for py3k
        >>> s.read(f, data)
        >>> str(s)
        'abcdefg'
        >>> if f.seek(0): pass # ignore result for py3k
        >>> s.set_value('Hi There')
        >>> s.write(f, data)
        >>> if f.seek(0): pass # ignore result for py3k
        >>> m = SizedString()
        >>> m.read(f, data)
        >>> str(m)
        'Hi There'

    `get_hash`(data=None)

      Return a hash value for this string.

      Returns: | An immutable object that can be used as a hash.

    `get_size`(data=None)

      Return number of bytes this type occupies in a file.

      Returns: | Number of bytes.

    `get_value`()

      Return the string.

      Returns: | The stored string.

    `read`(stream, data)

      Read string from stream.

      Parameters: | stream (file) – The stream to read from.

    `set_value`(value)

      Set string to C{value}.

      Parameters: | value (str) – The value to assign.

    `write`(stream, data)

      Write string to stream.

      Parameters: | stream (file) – The stream to write to.

  class `NifFormat.``SkinData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._SkinData`, `builtins.object`

    `get_transform`()

      Return scale, rotation, and translation into a single 4x4 matrix.

    `set_transform`(mat)

      Set rotation, transform, and velocity.

  class `NifFormat.``SkinPartition`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._SkinPartition`, `builtins.object`

    `get_mapped_triangles`()

      Get list of triangles of this partition (mapping into the geometry data vertex list).

    `get_triangles`()

      Get list of triangles of this partition.

  class `NifFormat.``SkinPartitionUnknownItem1`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `f_1`
    `f_2`
    `f_3`
    `f_4`
    `f_5`
    `unknown_flags`
  class `NifFormat.``SkinShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Reference to shape and skin instance.

    `shape`

      The shape.

    `skin_instance`

      Skinning instance for the shape?

  class `NifFormat.``SkinShapeGroup`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Unknown.

    `link_pairs`

      First link is a NiTriShape object.Second link is a NiSkinInstance object.

    `num_link_pairs`

      Counts unknown.

  class `NifFormat.``SkinTransform`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._SkinTransform`, `builtins.object`

    `get_transform`()

      Return scale, rotation, and translation into a single 4x4 matrix.

    `set_transform`(mat)

      Set rotation, transform, and velocity.

  class `NifFormat.``SkinWeight`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A weighted vertex.

    `index`

      The vertex index, in the mesh.

    `weight`

      The vertex weight - between 0.0 and 1.0

  class `NifFormat.``SkyObjectType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Skyrim, sets what sky function this object fulfills in BSSkyShaderProperty.

    `BSSM_SKY` = 2
    `BSSM_SKY_CLOUDS` = 3
    `BSSM_SKY_MOON_STARS_MASK` = 7
    `BSSM_SKY_STARS` = 5
    `BSSM_SKY_SUNGLARE` = 1
    `BSSM_SKY_TEXTURE` = 0
  class `NifFormat.``SkyShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderProperty`

    Bethesda-specific node? Found in Fallout3

    `file_name`

      The texture.

    `unknown_int_4`

      Unknown

    `unknown_int_5`

      Unknown

  class `NifFormat.``SkyrimHavokMaterial`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `SKY_HAV_MAT_BARREL` = 732141076
    `SKY_HAV_MAT_BROKEN_STONE` = 131151687
    `SKY_HAV_MAT_CLOTH` = 3839073443
    `SKY_HAV_MAT_DIRT` = 3106094762
    `SKY_HAV_MAT_DRAGON` = 2518321175
    `SKY_HAV_MAT_GLASS` = 3739830338
    `SKY_HAV_MAT_GRASS` = 1848600814
    `SKY_HAV_MAT_GRAVEL` = 428587608
    `SKY_HAV_MAT_HEAVY_METAL` = 2229413539
    `SKY_HAV_MAT_HEAVY_WOOD` = 3070783559
    `SKY_HAV_MAT_ICE` = 873356572
    `SKY_HAV_MAT_LIGHT_WOOD` = 365420259
    `SKY_HAV_MAT_MATERIAL_ARMOR_HEAVY` = 3708432437
    `SKY_HAV_MAT_MATERIAL_ARMOR_LIGHT` = 3424720541
    `SKY_HAV_MAT_MATERIAL_ARROW` = 3725505938
    `SKY_HAV_MAT_MATERIAL_AXE_1HAND` = 1305674443
    `SKY_HAV_MAT_MATERIAL_BASKET` = 790784366
    `SKY_HAV_MAT_MATERIAL_BLADE_1HAND` = 1060167844
    `SKY_HAV_MAT_MATERIAL_BLADE_1HAND_SMALL` = 2617944780
    `SKY_HAV_MAT_MATERIAL_BLADE_2HAND` = 2022742644
    `SKY_HAV_MAT_MATERIAL_BLUNT_2HAND` = 3969592277
    `SKY_HAV_MAT_MATERIAL_BONE` = 3049421844
    `SKY_HAV_MAT_MATERIAL_BOOK` = 1264672850
    `SKY_HAV_MAT_MATERIAL_BOTTLE_SMALL` = 2025794648
    `SKY_HAV_MAT_MATERIAL_BOULDER_LARGE` = 1885326971
    `SKY_HAV_MAT_MATERIAL_BOULDER_MEDIUM` = 4283869410
    `SKY_HAV_MAT_MATERIAL_BOWS_STAVES` = 1607128641
    `SKY_HAV_MAT_MATERIAL_CERAMIC_MEDIUM` = 781661019
    `SKY_HAV_MAT_MATERIAL_CHAIN` = 3074114406
    `SKY_HAV_MAT_MATERIAL_CHAIN_METAL` = 438912228
    `SKY_HAV_MAT_MATERIAL_COIN` = 3589100606
    `SKY_HAV_MAT_MATERIAL_SHIELD_HEAVY` = 3702389584
    `SKY_HAV_MAT_MATERIAL_SHIELD_LIGHT` = 3448167928
    `SKY_HAV_MAT_MATERIAL_SKIN_LARGE` = 2965929619
    `SKY_HAV_MAT_MATERIAL_SKIN_SMALL` = 2632367422
    `SKY_HAV_MAT_MATERIAL_STONE_AS_STAIRS` = 1886078335
    `SKY_HAV_MAT_MATERIAL_WOOD_AS_STAIRS` = 1803571212
    `SKY_HAV_MAT_MUD` = 1486385281
    `SKY_HAV_MAT_ORGANIC` = 2974920155
    `SKY_HAV_MAT_SAND` = 2168343821
    `SKY_HAV_MAT_SKIN` = 591247106
    `SKY_HAV_MAT_SNOW` = 398949039
    `SKY_HAV_MAT_SOLID_METAL` = 1288358971
    `SKY_HAV_MAT_STAIRS_BROKEN_STONE` = 2892392795
    `SKY_HAV_MAT_STAIRS_SNOW` = 1560365355
    `SKY_HAV_MAT_STAIRS_STONE` = 899511101
    `SKY_HAV_MAT_STAIRS_WOOD` = 1461712277
    `SKY_HAV_MAT_STONE` = 3741512247
    `SKY_HAV_MAT_UNKNOWN_1028101969` = 1028101969
    `SKY_HAV_MAT_UNKNOWN_1440721808` = 1440721808
    `SKY_HAV_MAT_UNKNOWN_1574477864` = 1574477864
    `SKY_HAV_MAT_UNKNOWN_1591009235` = 1591009235
    `SKY_HAV_MAT_WATER` = 1024582599
    `SKY_HAV_MAT_WOOD` = 500811281
  class `NifFormat.``SkyrimShaderPropertyFlags1`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.bit_struct.BitStructBase`

    `slsf_1_cast_shadows`
    `slsf_1_decal`
    `slsf_1_dynamic_decal`
    `slsf_1_environment_mapping`
    `slsf_1_external_emittance`
    `slsf_1_eye_environment_mapping`
    `slsf_1_face_gen_rgb_tint`
    `slsf_1_facegen_detail_map`
    `slsf_1_fire_refraction`
    `slsf_1_greyscale_to_palette_alpha`
    `slsf_1_greyscale_to_palette_color`
    `slsf_1_hair_soft_lighting`
    `slsf_1_landscape`
    `slsf_1_localmap_hide_secret`
    `slsf_1_model_space_normals`
    `slsf_1_multiple_textures`
    `slsf_1_non_projective_shadows`
    `slsf_1_own_emit`
    `slsf_1_parallax`
    `slsf_1_parallax_occlusion`
    `slsf_1_projected_uv`
    `slsf_1_recieve_shadows`
    `slsf_1_refraction`
    `slsf_1_remappable_textures`
    `slsf_1_screendoor_alpha_fade`
    `slsf_1_skinned`
    `slsf_1_soft_effect`
    `slsf_1_specular`
    `slsf_1_temp_refraction`
    `slsf_1_use_falloff`
    `slsf_1_vertex_alpha`
    `slsf_1_z_buffer_test`
  class `NifFormat.``SkyrimShaderPropertyFlags2`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.bit_struct.BitStructBase`

    `slsf_2_anisotropic_lighting`
    `slsf_2_assume_shadowmask`
    `slsf_2_back_lighting`
    `slsf_2_billboard`
    `slsf_2_cloud_lod`
    `slsf_2_double_sided`
    `slsf_2_effect_lighting`
    `slsf_2_env_map_light_fade`
    `slsf_2_fit_slope`
    `slsf_2_glow_map`
    `slsf_2_hd_lod_objects`
    `slsf_2_hide_on_local_map`
    `slsf_2_lod_landscape`
    `slsf_2_lod_objects`
    `slsf_2_multi_index_snow`
    `slsf_2_multi_layer_parallax`
    `slsf_2_no_fade`
    `slsf_2_no_lod_land_blend`
    `slsf_2_no_transparency_multisampling`
    `slsf_2_packed_tangent`
    `slsf_2_premult_alpha`
    `slsf_2_rim_lighting`
    `slsf_2_soft_lighting`
    `slsf_2_tree_anim`
    `slsf_2_uniform_scale`
    `slsf_2_unused_01`
    `slsf_2_unused_02`
    `slsf_2_vertex_colors`
    `slsf_2_vertex_lighting`
    `slsf_2_weapon_blood`
    `slsf_2_wireframe`
    `slsf_2_z_buffer_write`
  class `NifFormat.``SkyrimWaterShaderFlags`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.bit_struct.BitStructBase`

    `swsf_1_bypass_refraction_map`
    `swsf_1_enabled`
    `swsf_1_highlight_layer_toggle`
    `swsf_1_unknown_0`
    `swsf_1_unknown_3`
    `swsf_1_unknown_4`
    `swsf_1_unknown_5`
    `swsf_1_water_toggle`
  class `NifFormat.``SolverDeactivation`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    A list of possible solver deactivation settings. This value defines how thesolver deactivates objects. The solver works on a per object basis.Note: Solver deactivation does not save CPU, but reduces creeping ofmovable objects in a pile quite dramatically.

    `SOLVER_DEACTIVATION_HIGH` = 4
    `SOLVER_DEACTIVATION_INVALID` = 0
    `SOLVER_DEACTIVATION_LOW` = 2
    `SOLVER_DEACTIVATION_MAX` = 5
    `SOLVER_DEACTIVATION_MEDIUM` = 3
    `SOLVER_DEACTIVATION_OFF` = 1
  class `NifFormat.``SortingMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `SORTING_INHERIT` = 0
    `SORTING_OFF` = 1
  class `NifFormat.``SphereBV`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A sphere.

    `center`

      The sphere’s center.

    `radius`

      The sphere’s radius.

  class `NifFormat.``StencilAction`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    This enum defines the various actions used in conjunction with the stencil buffer.For a detailed description of the individual options please refer to the OpenGL docs.

    `ACTION_DECREMENT` = 4
    `ACTION_INCREMENT` = 3
    `ACTION_INVERT` = 5
    `ACTION_KEEP` = 0
    `ACTION_REPLACE` = 2
    `ACTION_ZERO` = 1
  class `NifFormat.``StencilCompareMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    This enum contains the options for doing stencil buffer tests.

    `TEST_ALWAYS` = 7
    `TEST_EQUAL` = 2
    `TEST_GREATER` = 4
    `TEST_GREATER_EQUAL` = 6
    `TEST_LESS` = 1
    `TEST_LESS_EQUAL` = 3
    `TEST_NEVER` = 0
    `TEST_NOT_EQUAL` = 5
  `NifFormat.``StringIndex`

    alias of `UInt`

  class `NifFormat.``StringOffset`(**kwargs)

    Bases: `pyffi.object_models.common.Int`

    This is just an integer with -1 as default value.

  class `NifFormat.``StringPalette`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._StringPalette`, `builtins.object`

    `add_string`(text)

      Adds string to palette (will recycle existing strings if possible) and return offset to the string in the palette.

          >>> from pyffi.formats.nif import NifFormat
          >>> pal = NifFormat.StringPalette()
          >>> pal.add_string("abc")
          0
          >>> pal.add_string("abc")
          0
          >>> pal.add_string("def")
          4
          >>> pal.add_string("")
          -1
          >>> print(pal.get_string(4).decode("ascii"))
          def

    `clear`()

      Clear all strings in the palette.

          >>> from pyffi.formats.nif import NifFormat
          >>> pal = NifFormat.StringPalette()
          >>> pal.add_string("abc")
          0
          >>> pal.add_string("def")
          4
          >>> # pal.palette.decode("ascii") needs lstrip magic for py3k
          >>> print(repr(pal.palette.decode("ascii")).lstrip("u"))
          'abc\x00def\x00'
          >>> pal.clear()
          >>> # pal.palette.decode("ascii") needs lstrip magic for py3k
          >>> print(repr(pal.palette.decode("ascii")).lstrip("u"))
          ''

    `get_all_strings`()

      Return a list of all strings.

          >>> from pyffi.formats.nif import NifFormat
          >>> pal = NifFormat.StringPalette()
          >>> pal.add_string("abc")
          0
          >>> pal.add_string("def")
          4
          >>> for x in pal.get_all_strings():
          ...     print(x.decode("ascii"))
          abc
          def
          >>> # pal.palette.decode("ascii") needs lstrip magic for py3k
          >>> print(repr(pal.palette.decode("ascii")).lstrip("u"))
          'abc\x00def\x00'

    `get_string`(offset)

      Return string at given offset.

          >>> from pyffi.formats.nif import NifFormat
          >>> pal = NifFormat.StringPalette()
          >>> pal.add_string("abc")
          0
          >>> pal.add_string("def")
          4
          >>> print(pal.get_string(0).decode("ascii"))
          abc
          >>> print(pal.get_string(4).decode("ascii"))
          def
          >>> pal.get_string(5)
          pyffi.nif.stringpalette:WARNING:StringPalette: no string starts at offset 5 (string is b'ef', preceeding character is b'd')
          b'ef'
          >>> pal.get_string(100)
          Traceback (most recent call last):
              ...
          ValueError: ...

  class `NifFormat.``SymmetryType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Determines symetry type used by NiPSysBombModifier.

    `CYLINDRICAL_SYMMETRY` = 1
    `PLANAR_SYMMETRY` = 2
    `SPHERICAL_SYMMETRY` = 0
  class `NifFormat.``SyncPoint`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Specifies the time when an application must syncronize for some reason.

    `SYNC_ANY` = 32768
    `SYNC_PHYSICS_COMPLETED` = 32864
    `SYNC_PHYSICS_SIMULATE` = 32848
    `SYNC_POST_UPDATE` = 32800
    `SYNC_REFLECTIONS` = 32880
    `SYNC_RENDER` = 32832
    `SYNC_UPDATE` = 32784
    `SYNC_VISIBLE` = 32816
  class `NifFormat.``TBC`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Tension, bias, continuity.

    `b`

      Bias.

    `c`

      Continuity.

    `t`

      Tension.

  class `NifFormat.``TallGrassShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderProperty`

    Bethesda-specific node.

    `file_name`

      Texture file name

  class `NifFormat.``TargetColor`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Used by NiPoint3InterpControllers to select which type of color in the controlled object that will be animated.

    `TC_AMBIENT` = 0
    `TC_DIFFUSE` = 1
    `TC_SELF_ILLUM` = 3
    `TC_SPECULAR` = 2
  class `NifFormat.``TexClampMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Specifies the availiable texture clamp modes. That is, the behavior of pixels outside the range of the texture.

    `CLAMP_S_CLAMP_T` = 0
    `CLAMP_S_WRAP_T` = 1
    `WRAP_S_CLAMP_T` = 2
    `WRAP_S_WRAP_T` = 3
  class `NifFormat.``TexCoord`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._TexCoord`, `builtins.object`

    `as_list`()
    `normalize`()
  class `NifFormat.``TexDesc`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Texture description.

    `center_offset`

      The offset from the origin?

    `clamp_mode`

      0=clamp S clamp T, 1=clamp S wrap T, 2=wrap S clamp T, 3=wrap S wrap T

    `filter_mode`

      0=nearest, 1=bilinear, 2=trilinear, 3=..., 4=..., 5=...

    `flags`

      Texture mode flags; clamp and filter mode stored in upper byte with 0xYZ00 = clamp mode Y, filter mode Z.

    `has_texture_transform`

      Determines whether or not the texture’s coordinates are transformed.

    `ps_2_k`

      PS2 only; from the Freedom Force docs,”The K value is used as an offset into the mipmap levels and can range from -2047 to 2047. Positive values push the mipmap towards being blurry and negative values make the mipmap sharper.”-75 for most v4.0.0.2 meshes.

    `ps_2_l`

      PS2 only; from the Freedom Force docs,”L values can range from 0 to 3 and are used to specify how fast a texture gets blurry”.

    `source`

      NiSourceTexture object index.

    `tiling`

      The number of times the texture is tiled in each direction?

    `transform_type`

      The texture transform type? Doesn’t seem to do anything.

    `translation`

      The amount to translate the texture coordinates in each direction?

    `unknown_1`

      Unknown, 0 or 0x0101?

    `unknown_short`

      Unknown, seems to always be 1

    `uv_set`

      The texture coordinate set in NiGeometryData that this texture slot will use.

    `w_rotation`

      2D Rotation of texture image around third W axis after U and V.

  class `NifFormat.``TexFilterMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Specifies the availiable texture filter modes. That is, the way pixels within a texture are blended together when textures are displayed on the screen at a size other than their original dimentions.

    `FILTER_BILERP` = 1
    `FILTER_BILERP_MIPNEAREST` = 5
    `FILTER_NEAREST` = 0
    `FILTER_NEAREST_MIPLERP` = 4
    `FILTER_NEAREST_MIPNEAREST` = 3
    `FILTER_TRILERP` = 2
  class `NifFormat.``TexSource`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A texture source.

    `file_name`

      The original source filename of the image embedded by the referred NiPixelData object.

    `pixel_data`

      Pixel data object index.

    `unknown_byte`

      Unknown.

    `unknown_link`

      Unknown.

    `use_external`

      Is the texture external?

  class `NifFormat.``TexTransform`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Determines how a NiTextureTransformController animates the UV coordinates.

    `TT_ROTATE` = 2
    `TT_SCALE_U` = 3
    `TT_SCALE_V` = 4
    `TT_TRANSLATE_U` = 0
    `TT_TRANSLATE_V` = 1
  class `NifFormat.``TexType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    The type of texture.

    `BASE_MAP` = 0
    `BUMP_MAP` = 5
    `DARK_MAP` = 1
    `DECAL_0_MAP` = 8
    `DECAL_1_MAP` = 9
    `DECAL_2_MAP` = 10
    `DECAL_3_MAP` = 11
    `DETAIL_MAP` = 2
    `GLOSS_MAP` = 3
    `GLOW_MAP` = 4
    `NORMAL_MAP` = 6
    `UNKNOWN2_MAP` = 7
  class `NifFormat.``TileShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderLightingProperty`

    Bethesda-specific node.

    `file_name`

      Texture file name

  class `NifFormat.``Triangle`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    List of three vertex indices.

    `v_1`

      First vertex index.

    `v_2`

      Second vertex index.

    `v_3`

      Third vertex index.

  class `NifFormat.``UnionBV`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `bounding_volumes`

      Bounding Volume.

    `num_bv`

      Number of Bounding Volumes.

  class `NifFormat.``Vector3`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._Vector3`, `builtins.object`

    `as_list`()
    `as_tuple`()
    `crossproduct`(x)
    `get_copy`()
    `norm`(sqrt=<built-in function sqrt>)
    `normalize`(ignore_error=False, sqrt=<built-in function sqrt>)
    `normalized`(ignore_error=False)
  class `NifFormat.``Vector4`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._Vector4`, `builtins.object`

        >>> from pyffi.formats.nif import NifFormat
        >>> vec = NifFormat.Vector4()
        >>> vec.x = 1.0
        >>> vec.y = 2.0
        >>> vec.z = 3.0
        >>> vec.w = 4.0
        >>> print(vec)
        [  1.000  2.000  3.000  4.000 ]
        >>> vec.as_list()
        [1.0, 2.0, 3.0, 4.0]
        >>> vec.as_tuple()
        (1.0, 2.0, 3.0, 4.0)
        >>> print(vec.get_vector_3())
        [  1.000  2.000  3.000 ]
        >>> vec2 = NifFormat.Vector4()
        >>> vec == vec2
        False
        >>> vec2.x = 1.0
        >>> vec2.y = 2.0
        >>> vec2.z = 3.0
        >>> vec2.w = 4.0
        >>> vec == vec2
        True

    `as_list`()
    `as_tuple`()
    `get_copy`()
    `get_vector_3`()
  class `NifFormat.``VelocityType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    Controls the way the a particle mesh emitter determines the starting speed and direction of the particles that are emitted.

    `VELOCITY_USE_DIRECTION` = 2
    `VELOCITY_USE_NORMALS` = 0
    `VELOCITY_USE_RANDOM` = 1
  class `NifFormat.``VertMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    An unsigned 32-bit integer, which describes how to apply vertex colors.

    `VERT_MODE_SRC_AMB_DIF` = 2
    `VERT_MODE_SRC_EMISSIVE` = 1
    `VERT_MODE_SRC_IGNORE` = 0
  class `NifFormat.``VolumetricFogShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderProperty`

    Bethesda-specific node.

  class `NifFormat.``WaterShaderProperty`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.BSShaderProperty`

    Bethesda-specific node? Found in Fallout3

  class `NifFormat.``ZCompareMode`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    This enum contains the options for doing z buffer tests.

    `ZCOMP_ALWAYS` = 0
    `ZCOMP_EQUAL` = 2
    `ZCOMP_GREATER` = 4
    `ZCOMP_GREATER_EQUAL` = 6
    `ZCOMP_LESS` = 1
    `ZCOMP_LESS_EQUAL` = 3
    `ZCOMP_NEVER` = 7
    `ZCOMP_NOT_EQUAL` = 5
  class `NifFormat.``bhkAabbPhantom`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkShapePhantom`

    Bethesda-specific node.

    `unknown_ints_1`
  class `NifFormat.``bhkBallAndSocketConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkConstraint`

    A Ball and Socket Constraint.

    `unknown_4_bytes`

      Unknown

    `unknown_floats_1`

      Unknown

    `unknown_floats_2`

      Unknown

    `unknown_int_1`

      Unknown

  class `NifFormat.``bhkBallSocketConstraintChain`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkSerializable`

    A Ball and Socket Constraint chain.

    `floats_1`

      Unknown

    `links`

      Unknown

    `links_2`

      Unknown

    `num_floats`

      Unknown

    `num_links`

      Number of links in the chain

    `num_links_2`

      Number of links in the chain

    `unknown_float_1`

      Unknown

    `unknown_float_2`

      Unknown

    `unknown_int_1`

      Unknown

    `unknown_int_2`

      Unknown

    `unknown_int_3`

      Unknown

  class `NifFormat.``bhkBlendCollisionObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkCollisionObject`

    Unknown.

    `unknown_float_1`

      Blending parameter?

    `unknown_float_2`

      Another blending parameter?

  class `NifFormat.``bhkBlendController`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiTimeController`

    Unknown. Is apparently only used in skeleton.nif files.

    `unknown_int`

      Seems to be always zero.

  class `NifFormat.``bhkBoxShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkBoxShape`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor C{scale} on data.

    `get_mass_center_inertia`(density=1, solid=True)

      Return mass, center, and inertia tensor.

  class `NifFormat.``bhkBreakableConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkConstraint`

    Bethesda-Specific node.

    `entities_2`

      The entities affected by this constraint.

    `num_entities_2`

      Number of bodies affected by this constraint.

    `position`

      Unknown

    `priority_2`

      Usually 1. Higher values indicate higher priority of this constraint?

    `remove_if_broken`

      Unknown

    `rotation`

      Unknown

    `threshold`

      Unknown

    `unknown_float_1`

      Unknown

    `unknown_int_1`

      A count or flag?

    `unknown_int_2`

      Unknown

    `unknown_int_3`

      Unknown

    `unknown_ints_1`
    `unknown_short_1`

      Unknown

  class `NifFormat.``bhkBvTreeShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkShape`

    A tree-like Havok data structure stored in an assembly-like binary code?

  class `NifFormat.``bhkCMSDBigTris`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Triangle indices used in pair with “Big Verts” in a bhkCompressedMeshShapeData.

    `triangle_1`
    `triangle_2`
    `triangle_3`
    `unknown_int_1`

      Always 0?

    `unknown_short_1`
  class `NifFormat.``bhkCMSDChunk`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    Defines subshape chunks in bhkCompressedMeshShapeData

    `indices`
    `indices_2`

      Compressed

    `material_index`

      Index of material in bhkCompressedMeshShapeData::Chunk Materials

    `num_indices`
    `num_indices_2`

      Number of

    `num_strips`

      Number of compressed strips

    `num_vertices`

      Number of compressed vertices

    `strips`

      Compressed strips

    `transform_index`

      Index of transformation in bhkCompressedMeshShapeData::Chunk Transforms

    `translation`

      Local translation

    `unknown_short_1`

      Always 65535?

    `vertices`

      Compressed vertices

  class `NifFormat.``bhkCMSDMaterial`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    per-chunk material, used in bhkCompressedMeshShapeData

    `skyrim_material`

      Material.

    `unknown_integer`

      Always 1?

  class `NifFormat.``bhkCMSDTransform`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A set of transformation data: translation and rotation

    `rotation`

      Rotation. Reference point for rotation is bhkRigidBody translation.

    `translation`

      A vector that moves the chunk by the specified amount. W is not used.

  class `NifFormat.``bhkCapsuleShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkCapsuleShape`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor <scale> on data.

    `get_mass_center_inertia`(density=1, solid=True)

      Return mass, center, and inertia tensor.

  class `NifFormat.``bhkCollisionObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkNiCollisionObject`

    Havok related collision object?

  class `NifFormat.``bhkCompressedMeshShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkShape`

    Compressed collision mesh.

    `data`

      The collision mesh data.

    `radius`

      A shell with that radius is added around the shape.

    `scale`

      Scale

    `skyrim_material`

      The shape’s material.

    `target`

      Points to root node?

    `unknown_4_bytes`

      Unknown.

    `unknown_float_1`

      Unknown.

    `unknown_float_3`

      Unknown

    `unknown_float_4`

      Unknown

    `unknown_float_5`

      Unknown

    `unknown_floats_1`

      Unknown

  class `NifFormat.``bhkCompressedMeshShapeData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkRefObject`

    A compressed mesh shape for collision in Skyrim.

    `big_tris`

      Unknown

    `big_verts`

      Compressed Vertices?

    `bits_per_index`

      Number of bits in the shape-key reserved for a triangle index

    `bits_per_w_index`

      Number of bits in the shape-key reserved for a triangle index and its winding

    `bounds_max`

      The maximum boundary of the AABB (the coordinates of the corner with the highest numerical values)

    `bounds_min`

      The minimum boundary of the AABB (the coordinates of the corner with the lowest numerical values)

    `chunk_materials`

      Table (array) with sets of materials. Chunks refers to this table by index.

    `chunk_transforms`

      Table (array) with sets of transformations. Chunks refers to this table by index.

    `chunks`
    `error`

      The radius of the storage mesh shape? Quantization error?

    `mask_index`

      Mask used to get the triangle index from a shape-key (common: 131071 = 0x1ffff)

    `mask_w_index`

      Mask used to get the triangle index and winding from a shape-key (common: 262143 = 0x3ffff)

    `num_big_tris`

      Unknown

    `num_big_verts`

      Unknown

    `num_chunks`

      Unknown

    `num_materials`

      Number of chunk materials

    `num_transforms`

      Number of chunk transformations

    `unknown_byte_1`

      Unknown

    `unknown_byte_2`

      Unknown

    `unknown_int_12`

      Unknown, end of block.

    `unknown_int_3`

      Unknown

    `unknown_int_4`

      Unknown

    `unknown_int_5`

      Unknown

    `unknown_int_6`

      Unknown

  class `NifFormat.``bhkConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkConstraint`, `builtins.object`

    `get_transform_a_b`(parent)

      Returns the transform of the first entity relative to the second entity. Root is simply a nif block that is a common parent to both blocks.

  class `NifFormat.``bhkConvexListShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkShape`

    A havok shape.A list of convex shapes.Do not put a bhkPackedNiTriStripsShape in the Sub Shapes. Use aseparate collision nodes without a list shape for those.Also, shapes collected in a bhkListShape may not have the correctwalking noise, so only use it for non-walkable objects.

    `material`

      The shape’s material.

    `num_sub_shapes`

      The number of sub shapes referenced.

    `skyrim_material`

      The shape’s material.

    `sub_shapes`

      List of shapes.

    `unknown_byte_1`

      Unknown Flag

    `unknown_float_1`

      Unknown Flag

    `unknown_floats`

      Unknown. Set to (0.0,0.0,-0.0,0.0,0.0,-0.0), where -0.0 is 0x80000000 in hex.

  class `NifFormat.``bhkConvexShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkSphereRepShape`

    A havok shape.

  class `NifFormat.``bhkConvexTransformShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkTransformShape`

    A convex transformed shape?

  class `NifFormat.``bhkConvexVerticesShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkConvexVerticesShape`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor on data.

    `get_mass_center_inertia`(density=1, solid=True)

      Return mass, center, and inertia tensor.

  class `NifFormat.``bhkEntity`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkWorldObject`

    A havok node, describes physical properties.

  class `NifFormat.``bhkHingeConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkConstraint`

    A hinge constraint.

    `hinge`

      Hinge constraing.

  class `NifFormat.``bhkLimitedHingeConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkLimitedHingeConstraint`, `builtins.object`

    `apply_scale`(scale)

      Scale data.

    `update_a_b`(parent)

      Update the B data from the A data. The parent argument is simply a common parent to the entities.

  class `NifFormat.``bhkLiquidAction`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkSerializable`

    Bethesda-specific node.

    `unknown_float_1`

      Unknown Flag

    `unknown_float_2`

      Unknown Flag

    `unknown_float_3`

      Unknown Flag

    `unknown_float_4`

      Unknown Flag

    `unknown_int_1`

      Unknown Flag

    `unknown_int_2`

      Unknown Flag

    `unknown_int_3`

      Unknown Flag

  class `NifFormat.``bhkListShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkListShape`, `builtins.object`

    `add_shape`(shape, front=False)

      Add shape to list.

    `get_mass_center_inertia`(density=1, solid=True)

      Return center of gravity and area.

    `remove_shape`(shape)

      Remove a shape from the shape list.

  class `NifFormat.``bhkMalleableConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkMalleableConstraint`, `builtins.object`

    `apply_scale`(scale)

      Scale data.

    `update_a_b`(parent)

      Update the B data from the A data.

  class `NifFormat.``bhkMeshShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkShape`

    `num_strips_data`

      The number of strips data objects referenced.

    `num_unknown_floats`
    `strips_data`

      Refers to a bunch of NiTriStripsData objects that make up this shape.

    `unknown_1`
    `unknown_2`
    `unknown_floats`
  class `NifFormat.``bhkMoppBvTreeShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkMoppBvTreeShape`, `builtins.object`

    `get_mass_center_inertia`(density=1, solid=True)

      Return mass, center of gravity, and inertia tensor.

    `mopp_from_tree`(tree)
    `parse_mopp`(start=0, depth=0, toffset=0, verbose=False)

      The mopp data is printed to the debug channel while parsed. Returns list of indices into mopp data of the bytes processed and a list of triangle indices encountered.

      The verbose argument is ignored (and is deprecated).

    `split_triangles`(ts, bbox, dir=0)

      Direction 0=X, 1=Y, 2=Z

    `update_mopp`()

      Update the MOPP data, scale, and origin, and welding info.

      @deprecated: use update_mopp_welding instead

    `update_mopp_welding`()

      Update the MOPP data, scale, and origin, and welding info.

    `update_origin_scale`()

      Update scale and origin.

  class `NifFormat.``bhkMultiSphereShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkMultiSphereShape`, `builtins.object`

    `get_mass_center_inertia`(density=1, solid=True)

      Return center of gravity and area.

  class `NifFormat.``bhkNiCollisionObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.NiCollisionObject`

    Havok related collision object?

    `body`

      Links to the collision object data

    `flags`

      Set to 1 for most objects, and to 41 for animated objects (OL_ANIM_STATIC). Bits: 0=Active 2=Notify 3=Set Local 6=Reset.

  class `NifFormat.``bhkNiTriStripsShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkNiTriStripsShape`, `builtins.object`

    `get_interchangeable_packed_shape`()

      Returns a bhkPackedNiTriStripsShape block that is geometrically interchangeable.

    `get_mass_center_inertia`(density=1, solid=True)

      Return mass, center, and inertia tensor.

  class `NifFormat.``bhkOrientHingedBodyAction`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkSerializable`

    Bethesda-Specific node.

    `unknown_ints_1`
  class `NifFormat.``bhkPCollisionObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkNiCollisionObject`

    Unknown.

  class `NifFormat.``bhkPackedNiTriStripsShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkPackedNiTriStripsShape`, `builtins.object`

    `add_shape`(triangles, normals, vertices, layer=0, material=0)

      Pack the given geometry.

    `get_mass_center_inertia`(density=1, solid=True)

      Return mass, center, and inertia tensor.

    `get_sub_shapes`()

      Return sub shapes (works for both Oblivion and Fallout 3).

    `get_triangle_hash_generator`()

      Generator which produces a tuple of integers, or None in degenerate case, for each triangle to ease detection of duplicate triangles.

          >>> shape = NifFormat.bhkPackedNiTriStripsShape()
          >>> data = NifFormat.hkPackedNiTriStripsData()
          >>> shape.data = data
          >>> data.num_triangles = 6
          >>> data.triangles.update_size()
          >>> data.triangles[0].triangle.v_1 = 0
          >>> data.triangles[0].triangle.v_2 = 1
          >>> data.triangles[0].triangle.v_3 = 2
          >>> data.triangles[1].triangle.v_1 = 2
          >>> data.triangles[1].triangle.v_2 = 1
          >>> data.triangles[1].triangle.v_3 = 3
          >>> data.triangles[2].triangle.v_1 = 3
          >>> data.triangles[2].triangle.v_2 = 2
          >>> data.triangles[2].triangle.v_3 = 1
          >>> data.triangles[3].triangle.v_1 = 3
          >>> data.triangles[3].triangle.v_2 = 1
          >>> data.triangles[3].triangle.v_3 = 2
          >>> data.triangles[4].triangle.v_1 = 0
          >>> data.triangles[4].triangle.v_2 = 0
          >>> data.triangles[4].triangle.v_3 = 3
          >>> data.triangles[5].triangle.v_1 = 1
          >>> data.triangles[5].triangle.v_2 = 3
          >>> data.triangles[5].triangle.v_3 = 4
          >>> list(shape.get_triangle_hash_generator())
          [(0, 1, 2), (1, 3, 2), (1, 3, 2), (1, 2, 3), None, (1, 3, 4)]

      Returns: | A generator yielding a hash value for each triangle.

    `get_vertex_hash_generator`(vertexprecision=3, subshape_index=None)

      Generator which produces a tuple of integers for each vertex to ease detection of duplicate/close enough to remove vertices. The precision parameter denote number of significant digits behind the comma.

      For vertexprecision, 3 seems usually enough (maybe we’ll have to increase this at some point).

          >>> shape = NifFormat.bhkPackedNiTriStripsShape()
          >>> data = NifFormat.hkPackedNiTriStripsData()
          >>> shape.data = data
          >>> shape.num_sub_shapes = 2
          >>> shape.sub_shapes.update_size()
          >>> data.num_vertices = 3
          >>> shape.sub_shapes[0].num_vertices = 2
          >>> shape.sub_shapes[1].num_vertices = 1
          >>> data.vertices.update_size()
          >>> data.vertices[0].x = 0.0
          >>> data.vertices[0].y = 0.1
          >>> data.vertices[0].z = 0.2
          >>> data.vertices[1].x = 1.0
          >>> data.vertices[1].y = 1.1
          >>> data.vertices[1].z = 1.2
          >>> data.vertices[2].x = 2.0
          >>> data.vertices[2].y = 2.1
          >>> data.vertices[2].z = 2.2
          >>> list(shape.get_vertex_hash_generator())
          [(0, (0, 100, 200)), (0, (1000, 1100, 1200)), (1, (2000, 2100, 2200))]
          >>> list(shape.get_vertex_hash_generator(subshape_index=0))
          [(0, 100, 200), (1000, 1100, 1200)]
          >>> list(shape.get_vertex_hash_generator(subshape_index=1))
          [(2000, 2100, 2200)]

      Parameters: | vertexprecision (float) – Precision to be used for vertices.
      Returns: | A generator yielding a hash value for each vertex.

  class `NifFormat.``bhkPhantom`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkWorldObject`

    Havok object that do not react with other objects when they collide (causing deflection, etc.) but still trigger collision notifications to the game. Possible uses are traps, portals, AI fields, etc.

  class `NifFormat.``bhkPrismaticConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkConstraint`

    A prismatic constraint.

    `friction`

      Friction.

    `max_distance`

      Describe the max distance the object is able to travel.

    `min_distance`

      Describe the min distance the object is able to travel.

    `pivot_a`

      Pivot.

    `pivot_b`

      Pivot in B coordinates.

    `plane_a`

      Plane normal. Describes the plane the object is able to move on.

    `plane_b`

      Plane normal. Describes the plane the object is able to move on in B coordinates.

    `rotation_a`

      Rotation axis.

    `rotation_b`

      Rotation axis.

    `rotation_matrix_a`

      4x4 rotation matrix, rotates the child entity.

    `sliding_a`

      Describes the axis the object is able to travel along. Unit vector.

    `sliding_b`

      Describes the axis the object is able to travel along in B coordinates. Unit vector.

    `unknown_byte_1`

      Unknown. Do not set this to anything over 0 as it will crash the game.

  class `NifFormat.``bhkRagdollConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkRagdollConstraint`, `builtins.object`

    `apply_scale`(scale)

      Scale data.

    `update_a_b`(parent)

      Update the B data from the A data.

  class `NifFormat.``bhkRefObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkRefObject`, `builtins.object`

    `get_shape_mass_center_inertia`(density=1, solid=True)

      Return mass, center of gravity, and inertia tensor of this object’s shape, if self.shape is not None.

      If self.shape is None, then returns zeros for everything.

  class `NifFormat.``bhkRigidBody`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkRigidBody`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor <scale> on data.

    `update_mass_center_inertia`(density=1, solid=True, mass=None)

      Look at all the objects under this rigid body and update the mass, center of gravity, and inertia tensor accordingly. If the C{mass} parameter is given then the C{density} argument is ignored.

  class `NifFormat.``bhkRigidBodyT`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkRigidBody`

    Unknown.

  class `NifFormat.``bhkSPCollisionObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkPCollisionObject`

    Unknown.

  class `NifFormat.``bhkSerializable`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkRefObject`

    Havok objects that can be saved and loaded from disk?

  class `NifFormat.``bhkShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkSerializable`

    A Havok Shape?

  class `NifFormat.``bhkShapeCollection`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkShape`

    Havok collision object that uses multiple shapes?

  class `NifFormat.``bhkShapePhantom`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkPhantom`

    A Havok phantom that uses a Havok shape object for its collision volume instead of just a bounding box.

  class `NifFormat.``bhkSimpleShapePhantom`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkShapePhantom`

    Unknown shape.

    `unknown_float`

      Unknown.

    `unknown_floats_2`

      Unknown. (1,0,0,0,0) x 3.

    `unkown_floats`

      Unknown.

  class `NifFormat.``bhkSphereRepShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkShape`

    A havok shape, perhaps with a bounding sphere for quick rejection in addition to more detailed shape data?

    `material`

      The shape’s material.

    `radius`

      The radius of the sphere that encloses the shape.

    `skyrim_material`

      The shape’s material.

  class `NifFormat.``bhkSphereShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkSphereShape`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor <scale> on data.

    `get_mass_center_inertia`(density=1, solid=True)

      Return mass, center, and inertia tensor.

  class `NifFormat.``bhkStiffSpringConstraint`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkConstraint`

    A spring constraint.

    `length`

      Length.

    `pivot_a`

      Pivot A.

    `pivot_b`

      Pivot B.

  class `NifFormat.``bhkTransformShape`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._bhkTransformShape`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor <scale> on data.

    `get_mass_center_inertia`(density=1, solid=True)

      Return mass, center, and inertia tensor.

  class `NifFormat.``bhkWorldObject`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif.bhkSerializable`

    Havok objects that have a position in the world?

    `col_filter`

      The first bit sets the LINK property and controls whether this body is physically linked to others. The next bit turns collision off. Then, the next bit sets the SCALED property in Oblivion. The next five bits make up the number of this part in a linked body list.

    `layer`

      Sets mesh color in Oblivion Construction Set.

    `shape`

      Link to the body for this collision object.

    `unknown_short`

      Unknown.

  class `NifFormat.``bool`(**kwargs)

    Bases: `pyffi.object_models.xml.basic.BasicBase`, `pyffi.object_models.editable.EditableBoolComboBox`

    Basic implementation of a 32-bit (8-bit for versions > 4.0.0.2) boolean type.

        >>> i = NifFormat.bool()
        >>> i.set_value('false')
        >>> i.get_value()
        False
        >>> i.set_value('true')
        >>> i.get_value()
        True

    `get_hash`(data=None)
    `get_size`(data=None)
    `get_value`()
    `read`(stream, data)
    `set_value`(value)
    `write`(stream, data)
  `NifFormat.``byte`

    alias of `UByte`

  `NifFormat.``char`

    alias of `Char`

  `NifFormat.``float`

    alias of `Float`

  `NifFormat.``games` = {'Red Ocean': [167903232], 'Entropia Universe': [167837696], 'Freedom Force': [67108864, 67108866], 'Wildlife Park 2': [167837696, 167903232], 'Dark Age of Camelot': [33751040, 50332416, 50397184, 67174412, 67240192, 67240448, 167837696], 'Star Trek: Bridge Commander': [50331648, 50397184], 'KrazyRain': [335872000, 335937536], 'NeoSteam': [167837696], 'Fallout 3': [335675399], 'Howling Sword': [335740937], 'Axis and Allies': [167837696], 'Divinity 2': [335740937], 'Empire Earth II': [67240448, 167837696], 'Skyrim': [335675399], 'Bully SE': [335740937], 'Worldshift': [167903233, 168034305], '?': [167772419], 'The Guild 2': [167837696], 'Zoo Tycoon 2': [167772416], 'Epic Mickey': [335938816], "Sid Meier's Railroads": [335544324], 'Megami Tensei: Imagine': [335609859], 'Culpa Innata': [67240448], 'Oblivion': [50528269, 167772416, 167772418, 167837797, 167837802, 167903232, 335544324, 335544325], 'Warhammer': [335740937], 'Atlantica': [335675400], 'Morrowind': [67108866], 'Emerge': [335675399, 335675400, 335740929, 335740930, 335740931, 335740934, 503316482], 'Civilization IV': [67239938, 67240192, 67240448, 167772416, 167837696, 167903232, 335544324], 'Kohan 2': [167837696], 'Pro Cycling Manager': [167903232], 'Prison Tycoon': [167903232], 'Lazeska': [335740937], 'Freedom Force vs. the 3rd Reich': [167837696], 'Loki': [167903232], 'Empire Earth III': [335675399, 335675400]}
  class `NifFormat.``hkPackedNiTriStripsData`(template=None, argument=None, parent=None)

    Bases: `pyffi.formats.nif._hkPackedNiTriStripsData`, `builtins.object`

    `apply_scale`(scale)

      Apply scale factor on data.

  class `NifFormat.``hkResponseType`(**kwargs)

    Bases: `pyffi.object_models.xml.enum.EnumBase`

    `RESPONSE_INVALID` = 0
    `RESPONSE_NONE` = 3
    `RESPONSE_REPORTING` = 2
    `RESPONSE_SIMPLE_CONTACT` = 1
  class `NifFormat.``hkTriangle`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    A triangle with extra data used for physics.

    `normal`

      This is the triangle’s normal.

    `triangle`

      The triangle.

    `welding_info`

      Additional havok information on how triangles are welded.

  `NifFormat.``int`

    alias of `Int`

  class `NifFormat.``physXMaterialRef`(template=None, argument=None, parent=None)

    Bases: `pyffi.object_models.xml.struct_.StructBase`

    `material_desc`

      PhysX Material Description

    `number`

      Unknown

    `unknown_byte_1`

      Unknown

  `NifFormat.``short`

    alias of `Short`

  class `NifFormat.``string`(**kwargs)

    Bases: `pyffi.object_models.common.SizedString`

    `get_hash`(data=None)
    `get_size`(data=None)
    `get_strings`(data)
    `read`(stream, data)
    `write`(stream, data)
  `NifFormat.``uint`

    alias of `UInt`

  `NifFormat.``ulittle32`

    alias of `ULittle32`

  `NifFormat.``ushort`

    alias of `UShort`

  static `NifFormat.``version_number`(version_str)

    Converts version string into an integer.

    Parameters: | version_str (str) – The version string.
    Returns: | A version integer.

        >>> hex(NifFormat.version_number('3.14.15.29'))
        '0x30e0f1d'
        >>> hex(NifFormat.version_number('1.2'))
        '0x1020000'
        >>> hex(NifFormat.version_number('3.03'))
        '0x3000300'
        >>> hex(NifFormat.version_number('NS'))
        '0xa010000'

  `NifFormat.``versions` = {'20.6.5.0': 335938816, '10.1.0.101': 167837797, '3.0': 50331648, '3.1': 50397184, '2.3': 33751040, '20.3.0.3': 335740931, '20.3.0.1': 335740929, '20.1.0.3': 335609859, '4.1.0.12': 67174412, '20.5.0.0': 335872000, '20.3.0.9': 335740937, '30.0.0.2': 503316482, '20.3.0.6': 335740934, '3.03': 50332416, '3.3.0.13': 50528269, '10.0.1.0': 167772416, '10.4.0.1': 168034305, '10.0.1.2': 167772418, '10.0.1.3': 167772419, '4.2.1.0': 67240192, '20.0.0.4': 335544324, '20.0.0.5': 335544325, '10.1.0.0': 167837696, '20.3.0.2': 335740930, '10.2.0.1': 167903233, '10.2.0.0': 167903232, '4.2.2.0': 67240448, '4.2.0.2': 67239938, '4.0.0.0': 67108864, '4.0.0.2': 67108866, '20.2.0.8': 335675400, '20.2.0.7': 335675399, '10.1.0.106': 167837802, '20.6.0.0': 335937536}
  `NifFormat.``xml_alias` = []
  `NifFormat.``xml_bit_struct` = [<class 'pyffi.formats.nif.BSSegmentFlags'>, <class 'pyffi.formats.nif.FurnitureEntryPoints'>, <class 'pyffi.formats.nif.BSPartFlag'>, <class 'pyffi.formats.nif.BSShaderFlags'>, <class 'pyffi.formats.nif.SkyrimShaderPropertyFlags1'>, <class 'pyffi.formats.nif.SkyrimShaderPropertyFlags2'>, <class 'pyffi.formats.nif.SkyrimWaterShaderFlags'>, <class 'pyffi.formats.nif.DataStreamAccess'>]
  `NifFormat.``xml_enum` = [<class 'pyffi.formats.nif.AlphaFormat'>, <class 'pyffi.formats.nif.ApplyMode'>, <class 'pyffi.formats.nif.TexType'>, <class 'pyffi.formats.nif.KeyType'>, <class 'pyffi.formats.nif.LightMode'>, <class 'pyffi.formats.nif.HavokMaterial'>, <class 'pyffi.formats.nif.SkyrimHavokMaterial'>, <class 'pyffi.formats.nif.OblivionLayer'>, <class 'pyffi.formats.nif.MipMapFormat'>, <class 'pyffi.formats.nif.PixelFormat'>, <class 'pyffi.formats.nif.PixelLayout'>, <class 'pyffi.formats.nif.TexClampMode'>, <class 'pyffi.formats.nif.TexFilterMode'>, <class 'pyffi.formats.nif.VertMode'>, <class 'pyffi.formats.nif.CycleType'>, <class 'pyffi.formats.nif.FieldType'>, <class 'pyffi.formats.nif.BillboardMode'>, <class 'pyffi.formats.nif.StencilCompareMode'>, <class 'pyffi.formats.nif.ZCompareMode'>, <class 'pyffi.formats.nif.StencilAction'>, <class 'pyffi.formats.nif.FaceDrawMode'>, <class 'pyffi.formats.nif.MotionSystem'>, <class 'pyffi.formats.nif.DeactivatorType'>, <class 'pyffi.formats.nif.SolverDeactivation'>, <class 'pyffi.formats.nif.MotionQuality'>, <class 'pyffi.formats.nif.ForceType'>, <class 'pyffi.formats.nif.TexTransform'>, <class 'pyffi.formats.nif.DecayType'>, <class 'pyffi.formats.nif.SymmetryType'>, <class 'pyffi.formats.nif.VelocityType'>, <class 'pyffi.formats.nif.EmitFrom'>, <class 'pyffi.formats.nif.EffectType'>, <class 'pyffi.formats.nif.CoordGenType'>, <class 'pyffi.formats.nif.EndianType'>, <class 'pyffi.formats.nif.TargetColor'>, <class 'pyffi.formats.nif.ConsistencyType'>, <class 'pyffi.formats.nif.SortingMode'>, <class 'pyffi.formats.nif.PropagationMode'>, <class 'pyffi.formats.nif.CollisionMode'>, <class 'pyffi.formats.nif.BoundVolumeType'>, <class 'pyffi.formats.nif.hkResponseType'>, <class 'pyffi.formats.nif.BSDismemberBodyPartType'>, <class 'pyffi.formats.nif.BSLightingShaderPropertyShaderType'>, <class 'pyffi.formats.nif.AnimationType'>, <class 'pyffi.formats.nif.ImageType'>, <class 'pyffi.formats.nif.ChannelType'>, <class 'pyffi.formats.nif.ChannelConvention'>, <class 'pyffi.formats.nif.BSShaderType'>, <class 'pyffi.formats.nif.SkyObjectType'>, <class 'pyffi.formats.nif.CloningBehavior'>, <class 'pyffi.formats.nif.ComponentFormat'>, <class 'pyffi.formats.nif.DataStreamUsage'>, <class 'pyffi.formats.nif.MeshPrimitiveType'>, <class 'pyffi.formats.nif.SyncPoint'>, <class 'pyffi.formats.nif.PSLoopBehavior'>]
  `NifFormat.``xml_file_name` = 'nif.xml'
  `NifFormat.``xml_file_path` = [None, '/usr/lib/python3.2/site-packages/pyffi/formats/nif/nifxml']
  `NifFormat.``xml_struct` = [<class 'pyffi.formats.nif.Color3'>, <class 'pyffi.formats.nif.ByteColor3'>, <class 'pyffi.formats.nif.Color4'>, <class 'pyffi.formats.nif.ByteColor4'>, <class 'pyffi.formats.nif._Footer'>, <class 'pyffi.formats.nif.LODRange'>, <class 'pyffi.formats.nif.MatchGroup'>, <class 'pyffi.formats.nif._Vector3'>, <class 'pyffi.formats.nif._Vector4'>, <class 'pyffi.formats.nif.Quaternion'>, <class 'pyffi.formats.nif.QuaternionXYZW'>, <class 'pyffi.formats.nif.Matrix22'>, <class 'pyffi.formats.nif._Matrix33'>, <class 'pyffi.formats.nif._Matrix44'>, <class 'pyffi.formats.nif.MipMap'>, <class 'pyffi.formats.nif.NodeGroup'>, <class 'pyffi.formats.nif.ns keylin'>, <class 'pyffi.formats.nif.ns keyarray'>, <class 'pyffi.formats.nif.ns keytan'>, <class 'pyffi.formats.nif.SkinShape'>, <class 'pyffi.formats.nif.SkinShapeGroup'>, <class 'pyffi.formats.nif.SkinWeight'>, <class 'pyffi.formats.nif.AVObject'>, <class 'pyffi.formats.nif._ControllerLink'>, <class 'pyffi.formats.nif.ExportInfo'>, <class 'pyffi.formats.nif._Header'>, <class 'pyffi.formats.nif._StringPalette'>, <class 'pyffi.formats.nif.TBC'>, <class 'pyffi.formats.nif.Key'>, <class 'pyffi.formats.nif.KeyGroup'>, <class 'pyffi.formats.nif.ns keytbc'>, <class 'pyffi.formats.nif.ns keyvecarray'>, <class 'pyffi.formats.nif.ns keyrotsub'>, <class 'pyffi.formats.nif.ns keyrotarray'>, <class 'pyffi.formats.nif.ns keyvecarraytyp'>, <class 'pyffi.formats.nif.QuatKey'>, <class 'pyffi.formats.nif._TexCoord'>, <class 'pyffi.formats.nif.TexDesc'>, <class 'pyffi.formats.nif.ShaderTexDesc'>, <class 'pyffi.formats.nif.TexSource'>, <class 'pyffi.formats.nif.Triangle'>, <class 'pyffi.formats.nif._SkinPartition'>, <class 'pyffi.formats.nif.SkinPartitionUnknownItem1'>, <class 'pyffi.formats.nif.QTransform'>, <class 'pyffi.formats.nif.MTransform'>, <class 'pyffi.formats.nif._SkinTransform'>, <class 'pyffi.formats.nif.BoundingBox'>, <class 'pyffi.formats.nif.FurniturePosition'>, <class 'pyffi.formats.nif.hkTriangle'>, <class 'pyffi.formats.nif.Morph'>, <class 'pyffi.formats.nif.Particle'>, <class 'pyffi.formats.nif._SkinData'>, <class 'pyffi.formats.nif.SphereBV'>, <class 'pyffi.formats.nif.OblivionColFilter'>, <class 'pyffi.formats.nif.OblivionSubShape'>, <class 'pyffi.formats.nif.MotorDescriptor'>, <class 'pyffi.formats.nif._RagdollDescriptor'>, <class 'pyffi.formats.nif._LimitedHingeDescriptor'>, <class 'pyffi.formats.nif.HingeDescriptor'>, <class 'pyffi.formats.nif.OldSkinData'>, <class 'pyffi.formats.nif.MultiTextureElement'>, <class 'pyffi.formats.nif.BoxBV'>, <class 'pyffi.formats.nif.CapsuleBV'>, <class 'pyffi.formats.nif.HalfSpaceBV'>, <class 'pyffi.formats.nif.BoundingVolume'>, <class 'pyffi.formats.nif.UnionBV'>, <class 'pyffi.formats.nif.MorphWeight'>, <class 'pyffi.formats.nif.ArkTexture'>, <class 'pyffi.formats.nif._InertiaMatrix'>, <class 'pyffi.formats.nif.DecalVectorArray'>, <class 'pyffi.formats.nif.BodyPartList'>, <class 'pyffi.formats.nif.BSSegment'>, <class 'pyffi.formats.nif.BoneLOD'>, <class 'pyffi.formats.nif.bhkCMSDMaterial'>, <class 'pyffi.formats.nif.bhkCMSDBigTris'>, <class 'pyffi.formats.nif.bhkCMSDTransform'>, <class 'pyffi.formats.nif.bhkCMSDChunk'>, <class 'pyffi.formats.nif._NiObject'>, <class 'pyffi.formats.nif.Ni3dsAlphaAnimator'>, <class 'pyffi.formats.nif.Ni3dsAnimationNode'>, <class 'pyffi.formats.nif.Ni3dsColorAnimator'>, <class 'pyffi.formats.nif.Ni3dsMorphShape'>, <class 'pyffi.formats.nif.Ni3dsParticleSystem'>, <class 'pyffi.formats.nif.Ni3dsPathController'>, <class 'pyffi.formats.nif.NiParticleModifier'>, <class 'pyffi.formats.nif.NiPSysCollider'>, <class 'pyffi.formats.nif._bhkRefObject'>, <class 'pyffi.formats.nif.bhkSerializable'>, <class 'pyffi.formats.nif.bhkWorldObject'>, <class 'pyffi.formats.nif.bhkPhantom'>, <class 'pyffi.formats.nif.bhkShapePhantom'>, <class 'pyffi.formats.nif.bhkSimpleShapePhantom'>, <class 'pyffi.formats.nif.bhkEntity'>, <class 'pyffi.formats.nif._bhkRigidBody'>, <class 'pyffi.formats.nif.bhkRigidBodyT'>, <class 'pyffi.formats.nif._bhkConstraint'>, <class 'pyffi.formats.nif._bhkLimitedHingeConstraint'>, <class 'pyffi.formats.nif._bhkMalleableConstraint'>, <class 'pyffi.formats.nif.bhkStiffSpringConstraint'>, <class 'pyffi.formats.nif._bhkRagdollConstraint'>, <class 'pyffi.formats.nif.bhkPrismaticConstraint'>, <class 'pyffi.formats.nif.bhkHingeConstraint'>, <class 'pyffi.formats.nif.bhkBallAndSocketConstraint'>, <class 'pyffi.formats.nif.bhkBallSocketConstraintChain'>, <class 'pyffi.formats.nif.bhkShape'>, <class 'pyffi.formats.nif._bhkTransformShape'>, <class 'pyffi.formats.nif.bhkSphereRepShape'>, <class 'pyffi.formats.nif.bhkConvexShape'>, <class 'pyffi.formats.nif._bhkSphereShape'>, <class 'pyffi.formats.nif._bhkCapsuleShape'>, <class 'pyffi.formats.nif._bhkBoxShape'>, <class 'pyffi.formats.nif._bhkConvexVerticesShape'>, <class 'pyffi.formats.nif.bhkConvexTransformShape'>, <class 'pyffi.formats.nif._bhkMultiSphereShape'>, <class 'pyffi.formats.nif.bhkBvTreeShape'>, <class 'pyffi.formats.nif._bhkMoppBvTreeShape'>, <class 'pyffi.formats.nif.bhkShapeCollection'>, <class 'pyffi.formats.nif._bhkListShape'>, <class 'pyffi.formats.nif.bhkMeshShape'>, <class 'pyffi.formats.nif._bhkPackedNiTriStripsShape'>, <class 'pyffi.formats.nif._bhkNiTriStripsShape'>, <class 'pyffi.formats.nif.NiExtraData'>, <class 'pyffi.formats.nif.NiInterpolator'>, <class 'pyffi.formats.nif.NiKeyBasedInterpolator'>, <class 'pyffi.formats.nif.NiFloatInterpolator'>, <class 'pyffi.formats.nif._NiTransformInterpolator'>, <class 'pyffi.formats.nif.NiPoint3Interpolator'>, <class 'pyffi.formats.nif.NiPathInterpolator'>, <class 'pyffi.formats.nif.NiBoolInterpolator'>, <class 'pyffi.formats.nif.NiBoolTimelineInterpolator'>, <class 'pyffi.formats.nif.NiBlendInterpolator'>, <class 'pyffi.formats.nif._NiBSplineInterpolator'>, <class 'pyffi.formats.nif._NiObjectNET'>, <class 'pyffi.formats.nif.NiCollisionObject'>, <class 'pyffi.formats.nif.NiCollisionData'>, <class 'pyffi.formats.nif.bhkNiCollisionObject'>, <class 'pyffi.formats.nif.bhkCollisionObject'>, <class 'pyffi.formats.nif.bhkBlendCollisionObject'>, <class 'pyffi.formats.nif.bhkPCollisionObject'>, <class 'pyffi.formats.nif.bhkSPCollisionObject'>, <class 'pyffi.formats.nif._NiAVObject'>, <class 'pyffi.formats.nif.NiDynamicEffect'>, <class 'pyffi.formats.nif.NiLight'>, <class 'pyffi.formats.nif.NiProperty'>, <class 'pyffi.formats.nif.NiTransparentProperty'>, <class 'pyffi.formats.nif.NiPSysModifier'>, <class 'pyffi.formats.nif.NiPSysEmitter'>, <class 'pyffi.formats.nif.NiPSysVolumeEmitter'>, <class 'pyffi.formats.nif.NiTimeController'>, <class 'pyffi.formats.nif.NiInterpController'>, <class 'pyffi.formats.nif.NiMultiTargetTransformController'>, <class 'pyffi.formats.nif.NiGeomMorpherController'>, <class 'pyffi.formats.nif.NiMorphController'>, <class 'pyffi.formats.nif.NiMorpherController'>, <class 'pyffi.formats.nif.NiSingleInterpController'>, <class 'pyffi.formats.nif.NiKeyframeController'>, <class 'pyffi.formats.nif.NiTransformController'>, <class 'pyffi.formats.nif.NiPSysModifierCtlr'>, <class 'pyffi.formats.nif.NiPSysEmitterCtlr'>, <class 'pyffi.formats.nif.NiPSysModifierBoolCtlr'>, <class 'pyffi.formats.nif.NiPSysModifierActiveCtlr'>, <class 'pyffi.formats.nif.NiPSysModifierFloatCtlr'>, <class 'pyffi.formats.nif.NiPSysEmitterDeclinationCtlr'>, <class 'pyffi.formats.nif.NiPSysEmitterDeclinationVarCtlr'>, <class 'pyffi.formats.nif.NiPSysEmitterInitialRadiusCtlr'>, <class 'pyffi.formats.nif.NiPSysEmitterLifeSpanCtlr'>, <class 'pyffi.formats.nif.NiPSysEmitterSpeedCtlr'>, <class 'pyffi.formats.nif.NiPSysGravityStrengthCtlr'>, <class 'pyffi.formats.nif.NiFloatInterpController'>, <class 'pyffi.formats.nif.NiFlipController'>, <class 'pyffi.formats.nif.NiAlphaController'>, <class 'pyffi.formats.nif.NiTextureTransformController'>, <class 'pyffi.formats.nif.NiLightDimmerController'>, <class 'pyffi.formats.nif.NiBoolInterpController'>, <class 'pyffi.formats.nif.NiVisController'>, <class 'pyffi.formats.nif.NiPoint3InterpController'>, <class 'pyffi.formats.nif._NiMaterialColorController'>, <class 'pyffi.formats.nif.NiLightColorController'>, <class 'pyffi.formats.nif.NiExtraDataController'>, <class 'pyffi.formats.nif.NiFloatExtraDataController'>, <class 'pyffi.formats.nif.NiBoneLODController'>, <class 'pyffi.formats.nif.NiBSBoneLODController'>, <class 'pyffi.formats.nif._NiGeometry'>, <class 'pyffi.formats.nif._NiTriBasedGeom'>, <class 'pyffi.formats.nif._NiGeometryData'>, <class 'pyffi.formats.nif.AbstractAdditionalGeometryData'>, <class 'pyffi.formats.nif._NiTriBasedGeomData'>, <class 'pyffi.formats.nif.bhkBlendController'>, <class 'pyffi.formats.nif._BSBound'>, <class 'pyffi.formats.nif.BSFurnitureMarker'>, <class 'pyffi.formats.nif.BSParentVelocityModifier'>, <class 'pyffi.formats.nif.BSPSysArrayEmitter'>, <class 'pyffi.formats.nif.BSWindModifier'>, <class 'pyffi.formats.nif._hkPackedNiTriStripsData'>, <class 'pyffi.formats.nif.NiAlphaProperty'>, <class 'pyffi.formats.nif.NiAmbientLight'>, <class 'pyffi.formats.nif.NiParticlesData'>, <class 'pyffi.formats.nif.NiRotatingParticlesData'>, <class 'pyffi.formats.nif.NiAutoNormalParticlesData'>, <class 'pyffi.formats.nif.ParticleDesc'>, <class 'pyffi.formats.nif.NiPSysData'>, <class 'pyffi.formats.nif.NiMeshPSysData'>, <class 'pyffi.formats.nif.NiBinaryExtraData'>, <class 'pyffi.formats.nif.NiBinaryVoxelExtraData'>, <class 'pyffi.formats.nif.NiBinaryVoxelData'>, <class 'pyffi.formats.nif.NiBlendBoolInterpolator'>, <class 'pyffi.formats.nif.NiBlendFloatInterpolator'>, <class 'pyffi.formats.nif.NiBlendPoint3Interpolator'>, <class 'pyffi.formats.nif.NiBlendTransformInterpolator'>, <class 'pyffi.formats.nif.NiBoolData'>, <class 'pyffi.formats.nif.NiBooleanExtraData'>, <class 'pyffi.formats.nif.NiBSplineBasisData'>, <class 'pyffi.formats.nif.NiBSplineFloatInterpolator'>, <class 'pyffi.formats.nif.NiBSplineCompFloatInterpolator'>, <class 'pyffi.formats.nif.NiBSplinePoint3Interpolator'>, <class 'pyffi.formats.nif.NiBSplineCompPoint3Interpolator'>, <class 'pyffi.formats.nif._NiBSplineTransformInterpolator'>, <class 'pyffi.formats.nif._NiBSplineCompTransformInterpolator'>, <class 'pyffi.formats.nif.BSRotAccumTransfInterpolator'>, <class 'pyffi.formats.nif._NiBSplineData'>, <class 'pyffi.formats.nif.NiCamera'>, <class 'pyffi.formats.nif.NiColorData'>, <class 'pyffi.formats.nif.NiColorExtraData'>, <class 'pyffi.formats.nif.NiControllerManager'>, <class 'pyffi.formats.nif.NiSequence'>, <class 'pyffi.formats.nif._NiControllerSequence'>, <class 'pyffi.formats.nif.NiAVObjectPalette'>, <class 'pyffi.formats.nif.NiDefaultAVObjectPalette'>, <class 'pyffi.formats.nif.NiDirectionalLight'>, <class 'pyffi.formats.nif.NiDitherProperty'>, <class 'pyffi.formats.nif.NiRollController'>, <class 'pyffi.formats.nif.NiFloatData'>, <class 'pyffi.formats.nif.NiFloatExtraData'>, <class 'pyffi.formats.nif.NiFloatsExtraData'>, <class 'pyffi.formats.nif.NiFogProperty'>, <class 'pyffi.formats.nif.NiGravity'>, <class 'pyffi.formats.nif.NiIntegerExtraData'>, <class 'pyffi.formats.nif.BSXFlags'>, <class 'pyffi.formats.nif.NiIntegersExtraData'>, <class 'pyffi.formats.nif.BSKeyframeController'>, <class 'pyffi.formats.nif._NiKeyframeData'>, <class 'pyffi.formats.nif.NiLookAtController'>, <class 'pyffi.formats.nif.NiLookAtInterpolator'>, <class 'pyffi.formats.nif._NiMaterialProperty'>, <class 'pyffi.formats.nif._NiMorphData'>, <class 'pyffi.formats.nif._NiNode'>, <class 'pyffi.formats.nif.NiBone'>, <class 'pyffi.formats.nif.AvoidNode'>, <class 'pyffi.formats.nif.FxWidget'>, <class 'pyffi.formats.nif.FxButton'>, <class 'pyffi.formats.nif.FxRadioButton'>, <class 'pyffi.formats.nif.NiBillboardNode'>, <class 'pyffi.formats.nif.NiBSAnimationNode'>, <class 'pyffi.formats.nif.NiBSParticleNode'>, <class 'pyffi.formats.nif.NiSwitchNode'>, <class 'pyffi.formats.nif.NiLODNode'>, <class 'pyffi.formats.nif.NiPalette'>, <class 'pyffi.formats.nif.NiParticleBomb'>, <class 'pyffi.formats.nif.NiParticleColorModifier'>, <class 'pyffi.formats.nif.NiParticleGrowFade'>, <class 'pyffi.formats.nif.NiParticleMeshModifier'>, <class 'pyffi.formats.nif.NiParticleRotation'>, <class 'pyffi.formats.nif.NiParticles'>, <class 'pyffi.formats.nif.NiAutoNormalParticles'>, <class 'pyffi.formats.nif.NiParticleMeshes'>, <class 'pyffi.formats.nif.NiParticleMeshesData'>, <class 'pyffi.formats.nif.NiParticleSystem'>, <class 'pyffi.formats.nif.NiMeshParticleSystem'>, <class 'pyffi.formats.nif.NiParticleSystemController'>, <class 'pyffi.formats.nif.NiBSPArrayController'>, <class 'pyffi.formats.nif.NiPathController'>, <class 'pyffi.formats.nif.ChannelData'>, <class 'pyffi.formats.nif._ATextureRenderData'>, <class 'pyffi.formats.nif.NiPersistentSrcTextureRendererData'>, <class 'pyffi.formats.nif.NiPixelData'>, <class 'pyffi.formats.nif.NiPlanarCollider'>, <class 'pyffi.formats.nif.NiPointLight'>, <class 'pyffi.formats.nif.NiPosData'>, <class 'pyffi.formats.nif.NiPSysAgeDeathModifier'>, <class 'pyffi.formats.nif.NiPSysBombModifier'>, <class 'pyffi.formats.nif.NiPSysBoundUpdateModifier'>, <class 'pyffi.formats.nif.NiPSysBoxEmitter'>, <class 'pyffi.formats.nif.NiPSysColliderManager'>, <class 'pyffi.formats.nif.NiPSysColorModifier'>, <class 'pyffi.formats.nif.NiPSysCylinderEmitter'>, <class 'pyffi.formats.nif.NiPSysDragModifier'>, <class 'pyffi.formats.nif.NiPSysEmitterCtlrData'>, <class 'pyffi.formats.nif.NiPSysGravityModifier'>, <class 'pyffi.formats.nif.NiPSysGrowFadeModifier'>, <class 'pyffi.formats.nif.NiPSysMeshEmitter'>, <class 'pyffi.formats.nif.NiPSysMeshUpdateModifier'>, <class 'pyffi.formats.nif.BSPSysInheritVelocityModifier'>, <class 'pyffi.formats.nif.BSPSysHavokUpdateModifier'>, <class 'pyffi.formats.nif.BSPSysRecycleBoundModifier'>, <class 'pyffi.formats.nif.BSPSysSubTexModifier'>, <class 'pyffi.formats.nif.NiPSysPlanarCollider'>, <class 'pyffi.formats.nif.NiPSysSphericalCollider'>, <class 'pyffi.formats.nif.NiPSysPositionModifier'>, <class 'pyffi.formats.nif.NiPSysResetOnLoopCtlr'>, <class 'pyffi.formats.nif.NiPSysRotationModifier'>, <class 'pyffi.formats.nif.NiPSysSpawnModifier'>, <class 'pyffi.formats.nif.NiPSysSphereEmitter'>, <class 'pyffi.formats.nif.NiPSysUpdateCtlr'>, <class 'pyffi.formats.nif.NiPSysFieldModifier'>, <class 'pyffi.formats.nif.NiPSysVortexFieldModifier'>, <class 'pyffi.formats.nif.NiPSysGravityFieldModifier'>, <class 'pyffi.formats.nif.NiPSysDragFieldModifier'>, <class 'pyffi.formats.nif.NiPSysTurbulenceFieldModifier'>, <class 'pyffi.formats.nif.BSPSysLODModifier'>, <class 'pyffi.formats.nif.BSPSysScaleModifier'>, <class 'pyffi.formats.nif.NiPSysFieldMagnitudeCtlr'>, <class 'pyffi.formats.nif.NiPSysFieldAttenuationCtlr'>, <class 'pyffi.formats.nif.NiPSysFieldMaxDistanceCtlr'>, <class 'pyffi.formats.nif.NiPSysAirFieldAirFrictionCtlr'>, <class 'pyffi.formats.nif.NiPSysAirFieldInheritVelocityCtlr'>, <class 'pyffi.formats.nif.NiPSysAirFieldSpreadCtlr'>, <class 'pyffi.formats.nif.NiPSysInitialRotSpeedCtlr'>, <class 'pyffi.formats.nif.NiPSysInitialRotSpeedVarCtlr'>, <class 'pyffi.formats.nif.NiPSysInitialRotAngleCtlr'>, <class 'pyffi.formats.nif.NiPSysInitialRotAngleVarCtlr'>, <class 'pyffi.formats.nif.NiPSysEmitterPlanarAngleCtlr'>, <class 'pyffi.formats.nif.NiPSysEmitterPlanarAngleVarCtlr'>, <class 'pyffi.formats.nif.NiPSysAirFieldModifier'>, <class 'pyffi.formats.nif.NiPSysTrailEmitter'>, <class 'pyffi.formats.nif.NiLightIntensityController'>, <class 'pyffi.formats.nif.NiPSysRadialFieldModifier'>, <class 'pyffi.formats.nif.NiLODData'>, <class 'pyffi.formats.nif.NiRangeLODData'>, <class 'pyffi.formats.nif.NiScreenLODData'>, <class 'pyffi.formats.nif.NiRotatingParticles'>, <class 'pyffi.formats.nif.NiSequenceStreamHelper'>, <class 'pyffi.formats.nif.NiShadeProperty'>, <class 'pyffi.formats.nif._NiSkinData'>, <class 'pyffi.formats.nif.NiSkinInstance'>, <class 'pyffi.formats.nif.NiTriShapeSkinController'>, <class 'pyffi.formats.nif.NiClodSkinInstance'>, <class 'pyffi.formats.nif.NiSkinPartition'>, <class 'pyffi.formats.nif.NiTexture'>, <class 'pyffi.formats.nif.NiSourceTexture'>, <class 'pyffi.formats.nif.NiSpecularProperty'>, <class 'pyffi.formats.nif.NiSphericalCollider'>, <class 'pyffi.formats.nif.NiSpotLight'>, <class 'pyffi.formats.nif.NiStencilProperty'>, <class 'pyffi.formats.nif.NiStringExtraData'>, <class 'pyffi.formats.nif.NiStringPalette'>, <class 'pyffi.formats.nif.NiStringsExtraData'>, <class 'pyffi.formats.nif.NiTextKeyExtraData'>, <class 'pyffi.formats.nif.NiTextureEffect'>, <class 'pyffi.formats.nif.NiTextureModeProperty'>, <class 'pyffi.formats.nif.NiImage'>, <class 'pyffi.formats.nif.NiTextureProperty'>, <class 'pyffi.formats.nif.NiMultiTextureProperty'>, <class 'pyffi.formats.nif.NiTexturingProperty'>, <class 'pyffi.formats.nif.NiTransformData'>, <class 'pyffi.formats.nif.NiTriShape'>, <class 'pyffi.formats.nif._NiTriShapeData'>, <class 'pyffi.formats.nif.NiTriStrips'>, <class 'pyffi.formats.nif._NiTriStripsData'>, <class 'pyffi.formats.nif.NiEnvMappedTriShape'>, <class 'pyffi.formats.nif.NiEnvMappedTriShapeData'>, <class 'pyffi.formats.nif.NiBezierTriangle4'>, <class 'pyffi.formats.nif.NiBezierMesh'>, <class 'pyffi.formats.nif.NiClod'>, <class 'pyffi.formats.nif.NiClodData'>, <class 'pyffi.formats.nif.NiUVController'>, <class 'pyffi.formats.nif.NiUVData'>, <class 'pyffi.formats.nif.NiVectorExtraData'>, <class 'pyffi.formats.nif.NiVertexColorProperty'>, <class 'pyffi.formats.nif.NiVertWeightsExtraData'>, <class 'pyffi.formats.nif.NiVisData'>, <class 'pyffi.formats.nif.NiWireframeProperty'>, <class 'pyffi.formats.nif.NiZBufferProperty'>, <class 'pyffi.formats.nif.RootCollisionNode'>, <class 'pyffi.formats.nif.NiRawImageData'>, <class 'pyffi.formats.nif.NiSortAdjustNode'>, <class 'pyffi.formats.nif.NiSourceCubeMap'>, <class 'pyffi.formats.nif.NiPhysXProp'>, <class 'pyffi.formats.nif.physXMaterialRef'>, <class 'pyffi.formats.nif.NiPhysXPropDesc'>, <class 'pyffi.formats.nif.NiPhysXActorDesc'>, <class 'pyffi.formats.nif.NiPhysXBodyDesc'>, <class 'pyffi.formats.nif.NiPhysXD6JointDesc'>, <class 'pyffi.formats.nif.NiPhysXShapeDesc'>, <class 'pyffi.formats.nif.NiPhysXMeshDesc'>, <class 'pyffi.formats.nif.NiPhysXMaterialDesc'>, <class 'pyffi.formats.nif.NiPhysXKinematicSrc'>, <class 'pyffi.formats.nif.NiPhysXTransformDest'>, <class 'pyffi.formats.nif.NiArkAnimationExtraData'>, <class 'pyffi.formats.nif.NiArkImporterExtraData'>, <class 'pyffi.formats.nif.NiArkTextureExtraData'>, <class 'pyffi.formats.nif.NiArkViewportInfoExtraData'>, <class 'pyffi.formats.nif.NiArkShaderExtraData'>, <class 'pyffi.formats.nif.NiLines'>, <class 'pyffi.formats.nif.NiLinesData'>, <class 'pyffi.formats.nif.Polygon'>, <class 'pyffi.formats.nif.NiScreenElementsData'>, <class 'pyffi.formats.nif.NiScreenElements'>, <class 'pyffi.formats.nif.NiRoomGroup'>, <class 'pyffi.formats.nif.NiRoom'>, <class 'pyffi.formats.nif.NiPortal'>, <class 'pyffi.formats.nif.BSFadeNode'>, <class 'pyffi.formats.nif.BSShaderProperty'>, <class 'pyffi.formats.nif.BSShaderLightingProperty'>, <class 'pyffi.formats.nif.BSShaderNoLightingProperty'>, <class 'pyffi.formats.nif.BSShaderPPLightingProperty'>, <class 'pyffi.formats.nif.BSEffectShaderPropertyFloatController'>, <class 'pyffi.formats.nif.BSEffectShaderPropertyColorController'>, <class 'pyffi.formats.nif.BSLightingShaderPropertyFloatController'>, <class 'pyffi.formats.nif.BSLightingShaderPropertyColorController'>, <class 'pyffi.formats.nif.BSNiAlphaPropertyTestRefController'>, <class 'pyffi.formats.nif.BSProceduralLightningController'>, <class 'pyffi.formats.nif.BSShaderTextureSet'>, <class 'pyffi.formats.nif.WaterShaderProperty'>, <class 'pyffi.formats.nif.SkyShaderProperty'>, <class 'pyffi.formats.nif.TileShaderProperty'>, <class 'pyffi.formats.nif.DistantLODShaderProperty'>, <class 'pyffi.formats.nif.BSDistantTreeShaderProperty'>, <class 'pyffi.formats.nif.TallGrassShaderProperty'>, <class 'pyffi.formats.nif.VolumetricFogShaderProperty'>, <class 'pyffi.formats.nif.HairShaderProperty'>, <class 'pyffi.formats.nif.Lighting30ShaderProperty'>, <class 'pyffi.formats.nif.BSLightingShaderProperty'>, <class 'pyffi.formats.nif.BSEffectShaderProperty'>, <class 'pyffi.formats.nif.BSWaterShaderProperty'>, <class 'pyffi.formats.nif.BSSkyShaderProperty'>, <class 'pyffi.formats.nif._BSDismemberSkinInstance'>, <class 'pyffi.formats.nif.BSDecalPlacementVectorExtraData'>, <class 'pyffi.formats.nif.BSPSysSimpleColorModifier'>, <class 'pyffi.formats.nif.BSValueNode'>, <class 'pyffi.formats.nif.BSStripParticleSystem'>, <class 'pyffi.formats.nif.BSStripPSysData'>, <class 'pyffi.formats.nif.BSPSysStripUpdateModifier'>, <class 'pyffi.formats.nif.BSMaterialEmittanceMultController'>, <class 'pyffi.formats.nif.BSMasterParticleSystem'>, <class 'pyffi.formats.nif.BSPSysMultiTargetEmitterCtlr'>, <class 'pyffi.formats.nif.BSRefractionStrengthController'>, <class 'pyffi.formats.nif.BSOrderedNode'>, <class 'pyffi.formats.nif.BSBlastNode'>, <class 'pyffi.formats.nif.BSDamageStage'>, <class 'pyffi.formats.nif.BSRefractionFirePeriodController'>, <class 'pyffi.formats.nif.bhkConvexListShape'>, <class 'pyffi.formats.nif.BSTreadTransformData'>, <class 'pyffi.formats.nif.BSTreadTransform'>, <class 'pyffi.formats.nif.BSTreadTransfInterpolator'>, <class 'pyffi.formats.nif.BSAnimNotes'>, <class 'pyffi.formats.nif.bhkLiquidAction'>, <class 'pyffi.formats.nif.BSMultiBoundNode'>, <class 'pyffi.formats.nif.BSMultiBound'>, <class 'pyffi.formats.nif.BSMultiBoundData'>, <class 'pyffi.formats.nif.BSMultiBoundOBB'>, <class 'pyffi.formats.nif.BSMultiBoundSphere'>, <class 'pyffi.formats.nif.BSSegmentedTriShape'>, <class 'pyffi.formats.nif.BSMultiBoundAABB'>, <class 'pyffi.formats.nif.AdditionalDataInfo'>, <class 'pyffi.formats.nif.AdditionalDataBlock'>, <class 'pyffi.formats.nif.BSPackedAdditionalDataBlock'>, <class 'pyffi.formats.nif.NiAdditionalGeometryData'>, <class 'pyffi.formats.nif.BSPackedAdditionalGeometryData'>, <class 'pyffi.formats.nif.BSWArray'>, <class 'pyffi.formats.nif.bhkAabbPhantom'>, <class 'pyffi.formats.nif.BSFrustumFOVController'>, <class 'pyffi.formats.nif.BSDebrisNode'>, <class 'pyffi.formats.nif.bhkBreakableConstraint'>, <class 'pyffi.formats.nif.bhkOrientHingedBodyAction'>, <class 'pyffi.formats.nif.Region'>, <class 'pyffi.formats.nif.NiDataStream'>, <class 'pyffi.formats.nif.SemanticData'>, <class 'pyffi.formats.nif.MeshData'>, <class 'pyffi.formats.nif.MaterialData'>, <class 'pyffi.formats.nif.NiRenderObject'>, <class 'pyffi.formats.nif.NiMeshModifier'>, <class 'pyffi.formats.nif.ExtraMeshDataEpicMickey'>, <class 'pyffi.formats.nif.ExtraMeshDataEpicMickey2'>, <class 'pyffi.formats.nif.NiMesh'>, <class 'pyffi.formats.nif.NiMorphWeightsController'>, <class 'pyffi.formats.nif.ElementReference'>, <class 'pyffi.formats.nif.NiMorphMeshModifier'>, <class 'pyffi.formats.nif.NiSkinningMeshModifier'>, <class 'pyffi.formats.nif.NiInstancingMeshModifier'>, <class 'pyffi.formats.nif.NiSkinningLODController'>, <class 'pyffi.formats.nif.NiPSParticleSystem'>, <class 'pyffi.formats.nif.NiPSMeshParticleSystem'>, <class 'pyffi.formats.nif.NiPSEmitParticlesCtlr'>, <class 'pyffi.formats.nif.NiPSForceActiveCtlr'>, <class 'pyffi.formats.nif.NiPSSimulator'>, <class 'pyffi.formats.nif.NiPSSimulatorStep'>, <class 'pyffi.formats.nif.NiPSSimulatorGeneralStep'>, <class 'pyffi.formats.nif.NiPSSimulatorForcesStep'>, <class 'pyffi.formats.nif.NiPSSimulatorCollidersStep'>, <class 'pyffi.formats.nif.NiPSSimulatorMeshAlignStep'>, <class 'pyffi.formats.nif.NiPSSimulatorFinalStep'>, <class 'pyffi.formats.nif.NiPSFacingQuadGenerator'>, <class 'pyffi.formats.nif.NiShadowGenerator'>, <class 'pyffi.formats.nif.NiPSBoundUpdater'>, <class 'pyffi.formats.nif.NiPSDragForce'>, <class 'pyffi.formats.nif.NiPSGravityForce'>, <class 'pyffi.formats.nif.NiPSBoxEmitter'>, <class 'pyffi.formats.nif.NiPSMeshEmitter'>, <class 'pyffi.formats.nif.NiPSGravityStrengthCtlr'>, <class 'pyffi.formats.nif.NiPSPlanarCollider'>, <class 'pyffi.formats.nif.NiPSEmitterSpeedCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterRadiusCtlr'>, <class 'pyffi.formats.nif.NiPSResetOnLoopCtlr'>, <class 'pyffi.formats.nif.NiPSSphereEmitter'>, <class 'pyffi.formats.nif.NiPSCylinderEmitter'>, <class 'pyffi.formats.nif.NiPSEmitterDeclinationCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterDeclinationVarCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterPlanarAngleCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterPlanarAngleVarCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterRotAngleCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterRotAngleVarCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterRotSpeedCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterRotSpeedVarCtlr'>, <class 'pyffi.formats.nif.NiPSEmitterLifeSpanCtlr'>, <class 'pyffi.formats.nif.NiPSBombForce'>, <class 'pyffi.formats.nif.NiPSSphericalCollider'>, <class 'pyffi.formats.nif.NiPSSpawner'>, <class 'pyffi.formats.nif.NiSequenceData'>, <class 'pyffi.formats.nif.NiTransformEvaluator'>, <class 'pyffi.formats.nif.NiBSplineCompTransformEvaluator'>, <class 'pyffi.formats.nif.NiMeshHWInstance'>, <class 'pyffi.formats.nif.NiFurSpringController'>, <class 'pyffi.formats.nif.CStreamableAssetData'>, <class 'pyffi.formats.nif.bhkCompressedMeshShape'>, <class 'pyffi.formats.nif.bhkCompressedMeshShapeData'>, <class 'pyffi.formats.nif.BSInvMarker'>, <class 'pyffi.formats.nif.BSBoneLODExtraData'>, <class 'pyffi.formats.nif.BSBehaviorGraphExtraData'>, <class 'pyffi.formats.nif.BSLagBoneController'>, <class 'pyffi.formats.nif.BSLODTriShape'>, <class 'pyffi.formats.nif.BSFurnitureMarkerNode'>, <class 'pyffi.formats.nif.BSLeafAnimNode'>, <class 'pyffi.formats.nif.BSTreeNode'>]

## Regression tests

These tests are used to check for functionality and bugs in the library. They also provide code examples which you may find useful.

### Read a NIF file

    >>> stream = open('tests/nif/test.nif', 'rb')
    >>> data = NifFormat.Data()
    >>> # inspect is optional; it will not read the actual blocks
    >>> data.inspect(stream)
    >>> hex(data.version)
    '0x14010003'
    >>> data.user_version
    0
    >>> for blocktype in data.header.block_types:
    ...     print(blocktype.decode("ascii"))
    NiNode
    NiTriShape
    NiTriShapeData
    >>> data.roots # blocks have not been read yet, so this is an empty list
    []
    >>> data.read(stream)
    >>> for root in data.roots:
    ...     for block in root.tree():
    ...         if isinstance(block, NifFormat.NiNode):
    ...             print(block.name.decode("ascii"))
    test
    >>> stream.close()

### Parse all NIF files in a directory tree

    >>> for stream, data in NifFormat.walkData('tests/nif'):
    ...     try:
    ...         # the replace call makes the doctest also pass on windows
    ...         print("reading %s" % stream.name.replace("\\", "/"))
    ...         data.read(stream)
    ...     except Exception:
    ...         print(
    ...             "Warning: read failed due corrupt file,"
    ...             " corrupt format description, or bug.")
    reading tests/nif/invalid.nif
    Warning: read failed due corrupt file, corrupt format description, or bug.
    reading tests/nif/nds.nif
    reading tests/nif/neosteam.nif
    reading tests/nif/test.nif
    reading tests/nif/test_centerradius.nif
    reading tests/nif/test_check_tangentspace1.nif
    reading tests/nif/test_check_tangentspace2.nif
    reading tests/nif/test_check_tangentspace3.nif
    reading tests/nif/test_check_tangentspace4.nif
    reading tests/nif/test_convexverticesshape.nif
    reading tests/nif/test_dump_tex.nif
    reading tests/nif/test_fix_clampmaterialalpha.nif
    reading tests/nif/test_fix_cleanstringpalette.nif
    reading tests/nif/test_fix_detachhavoktristripsdata.nif
    reading tests/nif/test_fix_disableparallax.nif
    reading tests/nif/test_fix_ffvt3rskinpartition.nif
    reading tests/nif/test_fix_mergeskeletonroots.nif
    reading tests/nif/test_fix_tangentspace.nif
    reading tests/nif/test_fix_texturepath.nif
    reading tests/nif/test_grid_128x128.nif
    reading tests/nif/test_grid_64x64.nif
    reading tests/nif/test_mopp.nif
    reading tests/nif/test_opt_collision_complex_mopp.nif
    reading tests/nif/test_opt_collision_mopp.nif
    reading tests/nif/test_opt_collision_packed.nif
    reading tests/nif/test_opt_collision_to_boxshape.nif
    reading tests/nif/test_opt_collision_to_boxshape_notabox.nif
    reading tests/nif/test_opt_collision_unpacked.nif
    reading tests/nif/test_opt_delunusedbones.nif
    reading tests/nif/test_opt_dupgeomdata.nif
    reading tests/nif/test_opt_dupverts.nif
    reading tests/nif/test_opt_emptyproperties.nif
    reading tests/nif/test_opt_grid_layout.nif
    reading tests/nif/test_opt_mergeduplicates.nif
    reading tests/nif/test_opt_vertex_cache.nif
    reading tests/nif/test_opt_zeroscale.nif
    reading tests/nif/test_skincenterradius.nif
    reading tests/nif/test_vertexcolor.nif

### Create a NIF model from scratch and write to file

    >>> root = NifFormat.NiNode()
    >>> root.name = 'Scene Root'
    >>> blk = NifFormat.NiNode()
    >>> root.add_child(blk)
    >>> blk.name = 'new block'
    >>> blk.scale = 2.4
    >>> blk.translation.x = 3.9
    >>> blk.rotation.m_11 = 1.0
    >>> blk.rotation.m_22 = 1.0
    >>> blk.rotation.m_33 = 1.0
    >>> ctrl = NifFormat.NiVisController()
    >>> ctrl.flags = 0x000c
    >>> ctrl.target = blk
    >>> blk.add_controller(ctrl)
    >>> blk.add_controller(NifFormat.NiAlphaController())
    >>> strips = NifFormat.NiTriStrips()
    >>> root.add_child(strips, front = True)
    >>> strips.name = "hello world"
    >>> strips.rotation.m_11 = 1.0
    >>> strips.rotation.m_22 = 1.0
    >>> strips.rotation.m_33 = 1.0
    >>> data = NifFormat.NiTriStripsData()
    >>> strips.data = data
    >>> data.num_vertices = 5
    >>> data.has_vertices = True
    >>> data.vertices.update_size()
    >>> for i, v in enumerate(data.vertices):
    ...     v.x = 1.0+i/10.0
    ...     v.y = 0.2+1.0/(i+1)
    ...     v.z = 0.03
    >>> data.update_center_radius()
    >>> data.num_strips = 2
    >>> data.strip_lengths.update_size()
    >>> data.strip_lengths[0] = 3
    >>> data.strip_lengths[1] = 4
    >>> data.has_points = True
    >>> data.points.update_size()
    >>> data.points[0][0] = 0
    >>> data.points[0][1] = 1
    >>> data.points[0][2] = 2
    >>> data.points[1][0] = 1
    >>> data.points[1][1] = 2
    >>> data.points[1][2] = 3
    >>> data.points[1][3] = 4
    >>> data.num_uv_sets = 1
    >>> data.has_uv = True
    >>> data.uv_sets.update_size()
    >>> for i, v in enumerate(data.uv_sets[0]):
    ...     v.u = 1.0-i/10.0
    ...     v.v = 1.0/(i+1)
    >>> data.has_normals = True
    >>> data.normals.update_size()
    >>> for i, v in enumerate(data.normals):
    ...     v.x = 0.0
    ...     v.y = 0.0
    ...     v.z = 1.0
    >>> strips.update_tangent_space()
    >>> from tempfile import TemporaryFile
    >>> stream = TemporaryFile()
    >>> nifdata = NifFormat.Data(version=0x14010003, user_version=10)
    >>> nifdata.roots = [root]
    >>> nifdata.write(stream)
    >>> stream.close()

### Get list of versions and games

    >>> for vnum in sorted(NifFormat.versions.values()):
    ...     print('0x%08X' % vnum)
    0x02030000
    0x03000000
    0x03000300
    0x03010000
    0x0303000D
    0x04000000
    0x04000002
    0x0401000C
    0x04020002
    0x04020100
    0x04020200
    0x0A000100
    0x0A000102
    0x0A000103
    0x0A010000
    0x0A010065
    0x0A01006A
    0x0A020000
    0x0A020001
    0x0A040001
    0x14000004
    0x14000005
    0x14010003
    0x14020007
    0x14020008
    0x14030001
    0x14030002
    0x14030003
    0x14030006
    0x14030009
    0x14050000
    0x14060000
    0x14060500
    0x1E000002
    >>> for game, versions in sorted(NifFormat.games.items(), key=lambda x: x[0]):
    ...     print("%s " % game + " ".join('0x%08X' % vnum for vnum in versions))
    ? 0x0A000103
    Atlantica 0x14020008
    Axis and Allies 0x0A010000
    Bully SE 0x14030009
    Civilization IV 0x04020002 0x04020100 0x04020200 0x0A000100 0x0A010000 0x0A020000 0x14000004
    Culpa Innata 0x04020200
    Dark Age of Camelot 0x02030000 0x03000300 0x03010000 0x0401000C 0x04020100 0x04020200 0x0A010000
    Divinity 2 0x14030009
    Emerge 0x14020007 0x14020008 0x14030001 0x14030002 0x14030003 0x14030006 0x1E000002
    Empire Earth II 0x04020200 0x0A010000
    Empire Earth III 0x14020007 0x14020008
    Entropia Universe 0x0A010000
    Epic Mickey 0x14060500
    Fallout 3 0x14020007
    Freedom Force 0x04000000 0x04000002
    Freedom Force vs. the 3rd Reich 0x0A010000
    Howling Sword 0x14030009
    Kohan 2 0x0A010000
    KrazyRain 0x14050000 0x14060000
    Lazeska 0x14030009
    Loki 0x0A020000
    Megami Tensei: Imagine 0x14010003
    Morrowind 0x04000002
    NeoSteam 0x0A010000
    Oblivion 0x0303000D 0x0A000100 0x0A000102 0x0A010065 0x0A01006A 0x0A020000 0x14000004 0x14000005
    Prison Tycoon 0x0A020000
    Pro Cycling Manager 0x0A020000
    Red Ocean 0x0A020000
    Sid Meier's Railroads 0x14000004
    Skyrim 0x14020007
    Star Trek: Bridge Commander 0x03000000 0x03010000
    The Guild 2 0x0A010000
    Warhammer 0x14030009
    Wildlife Park 2 0x0A010000 0x0A020000
    Worldshift 0x0A020001 0x0A040001
    Zoo Tycoon 2 0x0A000100

### Reading an unsupported nif file

    >>> stream = open('tests/nif/invalid.nif', 'rb')
    >>> data = NifFormat.Data()
    >>> data.inspect(stream) # the file seems ok on inspection
    >>> data.read(stream)
    Traceback (most recent call last):
        ...
    ValueError: ...
    >>> stream.close()

### Template types

    >>> block = NifFormat.NiTextKeyExtraData()
    >>> block.num_text_keys = 1
    >>> block.text_keys.update_size()
    >>> block.text_keys[0].time = 1.0
    >>> block.text_keys[0].value = 'hi'

### Links

    >>> NifFormat.NiNode._has_links
    True
    >>> NifFormat.NiBone._has_links
    True
    >>> skelroot = NifFormat.NiNode()
    >>> geom = NifFormat.NiTriShape()
    >>> geom.skin_instance = NifFormat.NiSkinInstance()
    >>> geom.skin_instance.skeleton_root = skelroot
    >>> [block.__class__.__name__ for block in geom.get_refs()]
    ['NiSkinInstance']
    >>> [block.__class__.__name__ for block in geom.get_links()]
    ['NiSkinInstance']
    >>> [block.__class__.__name__ for block in geom.skin_instance.get_refs()]
    []
    >>> [block.__class__.__name__ for block in geom.skin_instance.get_links()]
    ['NiNode']

### Strings

    >>> extra = NifFormat.NiTextKeyExtraData()
    >>> extra.num_text_keys = 2
    >>> extra.text_keys.update_size()
    >>> extra.text_keys[0].time = 0.0
    >>> extra.text_keys[0].value = "start"
    >>> extra.text_keys[1].time = 2.0
    >>> extra.text_keys[1].value = "end"
    >>> for extrastr in extra.get_strings(None):
    ...     print(extrastr.decode("ascii"))
    start
    end

### Navigation

- index
- modules |
- next |
- previous |
- PyFFI 2.2.2 documentation »
- `pyffi` — Interfacing block structured files »
- `pyffi.formats` — File format interfaces »