enums.cpp

void NifStream( SortingMode const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, SortingMode const & val ) {
	switch ( val ) {
		case SORTING_INHERIT: return out << "SORTING_INHERIT";
		case SORTING_OFF: return out << "SORTING_OFF";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--CoordGenType--//

void NifStream( CoordGenType & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = CoordGenType(temp);
}

void NifStream( CoordGenType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, CoordGenType const & val ) {
	switch ( val ) {
		case CG_WORLD_PARALLEL: return out << "CG_WORLD_PARALLEL";
		case CG_WORLD_PERSPECTIVE: return out << "CG_WORLD_PERSPECTIVE";
		case CG_SPHERE_MAP: return out << "CG_SPHERE_MAP";
		case CG_SPECULAR_CUBE_MAP: return out << "CG_SPECULAR_CUBE_MAP";
		case CG_DIFFUSE_CUBE_MAP: return out << "CG_DIFFUSE_CUBE_MAP";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--BSShaderType--//

void NifStream( BSShaderType & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = BSShaderType(temp);
}

void NifStream( BSShaderType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, BSShaderType const & val ) {
	switch ( val ) {
		case SHADER_TALL_GRASS: return out << "SHADER_TALL_GRASS";
		case SHADER_DEFAULT: return out << "SHADER_DEFAULT";
		case SHADER_SKY: return out << "SHADER_SKY";
		case SHADER_SKIN: return out << "SHADER_SKIN";
		case SHADER_WATER: return out << "SHADER_WATER";
		case SHADER_LIGHTING30: return out << "SHADER_LIGHTING30";
		case SHADER_TILE: return out << "SHADER_TILE";
		case SHADER_NOLIGHTING: return out << "SHADER_NOLIGHTING";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--ApplyMode--//

void NifStream( ApplyMode & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = ApplyMode(temp);
}

void NifStream( ApplyMode const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, ApplyMode const & val ) {
	switch ( val ) {
		case APPLY_REPLACE: return out << "APPLY_REPLACE";
		case APPLY_DECAL: return out << "APPLY_DECAL";
		case APPLY_MODULATE: return out << "APPLY_MODULATE";
		case APPLY_HILIGHT: return out << "APPLY_HILIGHT";
		case APPLY_HILIGHT2: return out << "APPLY_HILIGHT2";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--MotionSystem--//

void NifStream( MotionSystem & val, istream& in, const NifInfo & info ) {
	byte temp;
	NifStream( temp, in, info );
	val = MotionSystem(temp);
}

void NifStream( MotionSystem const & val, ostream& out, const NifInfo & info ) {
	NifStream( (byte)(val), out, info );
}

ostream & operator<<( ostream & out, MotionSystem const & val ) {
	switch ( val ) {
		case MO_SYS_INVALID: return out << "MO_SYS_INVALID";
		case MO_SYS_DYNAMIC: return out << "MO_SYS_DYNAMIC";
		case MO_SYS_SPHERE: return out << "MO_SYS_SPHERE";
		case MO_SYS_SPHERE_INERTIA: return out << "MO_SYS_SPHERE_INERTIA";
		case MO_SYS_BOX: return out << "MO_SYS_BOX";
		case MO_SYS_BOX_STABILIZED: return out << "MO_SYS_BOX_STABILIZED";
		case MO_SYS_KEYFRAMED: return out << "MO_SYS_KEYFRAMED";
		case MO_SYS_FIXED: return out << "MO_SYS_FIXED";
		case MO_SYS_THIN_BOX: return out << "MO_SYS_THIN_BOX";
		case MO_SYS_CHARACTER: return out << "MO_SYS_CHARACTER";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--BillboardMode--//

void NifStream( BillboardMode & val, istream& in, const NifInfo & info ) {
	unsigned short temp;
	NifStream( temp, in, info );
	val = BillboardMode(temp);
}

void NifStream( BillboardMode const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned short)(val), out, info );
}

ostream & operator<<( ostream & out, BillboardMode const & val ) {
	switch ( val ) {
		case ALWAYS_FACE_CAMERA: return out << "ALWAYS_FACE_CAMERA";
		case ROTATE_ABOUT_UP: return out << "ROTATE_ABOUT_UP";
		case RIGID_FACE_CAMERA: return out << "RIGID_FACE_CAMERA";
		case ALWAYS_FACE_CENTER: return out << "ALWAYS_FACE_CENTER";
		case RIGID_FACE_CENTER: return out << "RIGID_FACE_CENTER";
		case ROTATE_ABOUT_UP2: return out << "ROTATE_ABOUT_UP2";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--ZCompareMode--//

void NifStream( ZCompareMode & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = ZCompareMode(temp);
}

void NifStream( ZCompareMode const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, ZCompareMode const & val ) {
	switch ( val ) {
		case ZCOMP_ALWAYS: return out << "ZCOMP_ALWAYS";
		case ZCOMP_LESS: return out << "ZCOMP_LESS";
		case ZCOMP_EQUAL: return out << "ZCOMP_EQUAL";
		case ZCOMP_LESS_EQUAL: return out << "ZCOMP_LESS_EQUAL";
		case ZCOMP_GREATER: return out << "ZCOMP_GREATER";
		case ZCOMP_NOT_EQUAL: return out << "ZCOMP_NOT_EQUAL";
		case ZCOMP_GREATER_EQUAL: return out << "ZCOMP_GREATER_EQUAL";
		case ZCOMP_NEVER: return out << "ZCOMP_NEVER";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--TargetColor--//

void NifStream( TargetColor & val, istream& in, const NifInfo & info ) {
	unsigned short temp;
	NifStream( temp, in, info );
	val = TargetColor(temp);
}

void NifStream( TargetColor const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned short)(val), out, info );
}

ostream & operator<<( ostream & out, TargetColor const & val ) {
	switch ( val ) {
		case TC_AMBIENT: return out << "TC_AMBIENT";
		case TC_DIFFUSE: return out << "TC_DIFFUSE";
		case TC_SPECULAR: return out << "TC_SPECULAR";
		case TC_SELF_ILLUM: return out << "TC_SELF_ILLUM";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--SkyrimHavokMaterial--//

void NifStream( SkyrimHavokMaterial & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = SkyrimHavokMaterial(temp);
}

void NifStream( SkyrimHavokMaterial const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, SkyrimHavokMaterial const & val ) {
	switch ( val ) {
		case SKY_HAV_MAT_LIGHT_WOOD: return out << "SKY_HAV_MAT_LIGHT_WOOD";
		case SKY_HAV_MAT_BROKEN_STONE: return out << "SKY_HAV_MAT_BROKEN_STONE";
		case SKY_HAV_MAT_SNOW: return out << "SKY_HAV_MAT_SNOW";
		case SKY_HAV_MAT_GRAVEL: return out << "SKY_HAV_MAT_GRAVEL";
		case SKY_HAV_MAT_MATERIAL_CHAIN_METAL: return out << "SKY_HAV_MAT_MATERIAL_CHAIN_METAL";
		case SKY_HAV_MAT_WOOD: return out << "SKY_HAV_MAT_WOOD";
		case SKY_HAV_MAT_SKIN: return out << "SKY_HAV_MAT_SKIN";
		case SKY_HAV_MAT_BARREL: return out << "SKY_HAV_MAT_BARREL";
		case SKY_HAV_MAT_MATERIAL_CERAMIC_MEDIUM: return out << "SKY_HAV_MAT_MATERIAL_CERAMIC_MEDIUM";
		case SKY_HAV_MAT_MATERIAL_BASKET: return out << "SKY_HAV_MAT_MATERIAL_BASKET";
		case SKY_HAV_MAT_ICE: return out << "SKY_HAV_MAT_ICE";
		case SKY_HAV_MAT_STAIRS_STONE: return out << "SKY_HAV_MAT_STAIRS_STONE";
		case SKY_HAV_MAT_MATERIAL_BLADE_1HAND: return out << "SKY_HAV_MAT_MATERIAL_BLADE_1HAND";
		case SKY_HAV_MAT_WATER: return out << "SKY_HAV_MAT_WATER";
		case SKY_HAV_MAT_UNKNOWN_1028101969: return out << "SKY_HAV_MAT_UNKNOWN_1028101969";
		case SKY_HAV_MAT_MATERIAL_BOOK: return out << "SKY_HAV_MAT_MATERIAL_BOOK";
		case SKY_HAV_MAT_SOLID_METAL: return out << "SKY_HAV_MAT_SOLID_METAL";
		case SKY_HAV_MAT_MATERIAL_AXE_1HAND: return out << "SKY_HAV_MAT_MATERIAL_AXE_1HAND";
		case SKY_HAV_MAT_UNKNOWN_1440721808: return out << "SKY_HAV_MAT_UNKNOWN_1440721808";
		case SKY_HAV_MAT_STAIRS_WOOD: return out << "SKY_HAV_MAT_STAIRS_WOOD";
		case SKY_HAV_MAT_MUD: return out << "SKY_HAV_MAT_MUD";
		case SKY_HAV_MAT_STAIRS_SNOW: return out << "SKY_HAV_MAT_STAIRS_SNOW";
		case SKY_HAV_MAT_UNKNOWN_1574477864: return out << "SKY_HAV_MAT_UNKNOWN_1574477864";
		case SKY_HAV_MAT_UNKNOWN_1591009235: return out << "SKY_HAV_MAT_UNKNOWN_1591009235";
		case SKY_HAV_MAT_MATERIAL_BOWS_STAVES: return out << "SKY_HAV_MAT_MATERIAL_BOWS_STAVES";
		case SKY_HAV_MAT_MATERIAL_WOOD_AS_STAIRS: return out << "SKY_HAV_MAT_MATERIAL_WOOD_AS_STAIRS";
		case SKY_HAV_MAT_GRASS: return out << "SKY_HAV_MAT_GRASS";
		case SKY_HAV_MAT_MATERIAL_BOULDER_LARGE: return out << "SKY_HAV_MAT_MATERIAL_BOULDER_LARGE";
		case SKY_HAV_MAT_MATERIAL_STONE_AS_STAIRS: return out << "SKY_HAV_MAT_MATERIAL_STONE_AS_STAIRS";
		case SKY_HAV_MAT_MATERIAL_BLADE_2HAND: return out << "SKY_HAV_MAT_MATERIAL_BLADE_2HAND";
		case SKY_HAV_MAT_MATERIAL_BOTTLE_SMALL: return out << "SKY_HAV_MAT_MATERIAL_BOTTLE_SMALL";
		case SKY_HAV_MAT_SAND: return out << "SKY_HAV_MAT_SAND";
		case SKY_HAV_MAT_HEAVY_METAL: return out << "SKY_HAV_MAT_HEAVY_METAL";
		case SKY_HAV_MAT_DRAGON: return out << "SKY_HAV_MAT_DRAGON";
		case SKY_HAV_MAT_MATERIAL_BLADE_1HAND_SMALL: return out << "SKY_HAV_MAT_MATERIAL_BLADE_1HAND_SMALL";
		case SKY_HAV_MAT_MATERIAL_SKIN_SMALL: return out << "SKY_HAV_MAT_MATERIAL_SKIN_SMALL";
		case SKY_HAV_MAT_STAIRS_BROKEN_STONE: return out << "SKY_HAV_MAT_STAIRS_BROKEN_STONE";
		case SKY_HAV_MAT_MATERIAL_SKIN_LARGE: return out << "SKY_HAV_MAT_MATERIAL_SKIN_LARGE";
		case SKY_HAV_MAT_ORGANIC: return out << "SKY_HAV_MAT_ORGANIC";
		case SKY_HAV_MAT_MATERIAL_BONE: return out << "SKY_HAV_MAT_MATERIAL_BONE";
		case SKY_HAV_MAT_HEAVY_WOOD: return out << "SKY_HAV_MAT_HEAVY_WOOD";
		case SKY_HAV_MAT_MATERIAL_CHAIN: return out << "SKY_HAV_MAT_MATERIAL_CHAIN";
		case SKY_HAV_MAT_DIRT: return out << "SKY_HAV_MAT_DIRT";
		case SKY_HAV_MAT_MATERIAL_ARMOR_LIGHT: return out << "SKY_HAV_MAT_MATERIAL_ARMOR_LIGHT";
		case SKY_HAV_MAT_MATERIAL_SHIELD_LIGHT: return out << "SKY_HAV_MAT_MATERIAL_SHIELD_LIGHT";
		case SKY_HAV_MAT_MATERIAL_COIN: return out << "SKY_HAV_MAT_MATERIAL_COIN";
		case SKY_HAV_MAT_MATERIAL_SHIELD_HEAVY: return out << "SKY_HAV_MAT_MATERIAL_SHIELD_HEAVY";
		case SKY_HAV_MAT_MATERIAL_ARMOR_HEAVY: return out << "SKY_HAV_MAT_MATERIAL_ARMOR_HEAVY";
		case SKY_HAV_MAT_MATERIAL_ARROW: return out << "SKY_HAV_MAT_MATERIAL_ARROW";
		case SKY_HAV_MAT_GLASS: return out << "SKY_HAV_MAT_GLASS";
		case SKY_HAV_MAT_STONE: return out << "SKY_HAV_MAT_STONE";
		case SKY_HAV_MAT_CLOTH: return out << "SKY_HAV_MAT_CLOTH";
		case SKY_HAV_MAT_MATERIAL_BLUNT_2HAND: return out << "SKY_HAV_MAT_MATERIAL_BLUNT_2HAND";
		case SKY_HAV_MAT_MATERIAL_BOULDER_MEDIUM: return out << "SKY_HAV_MAT_MATERIAL_BOULDER_MEDIUM";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--ChannelConvention--//

void NifStream( ChannelConvention & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = ChannelConvention(temp);
}

void NifStream( ChannelConvention const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, ChannelConvention const & val ) {
	switch ( val ) {
		case CC_FIXED: return out << "CC_FIXED";
		case CC_INDEX: return out << "CC_INDEX";
		case CC_COMPRESSED: return out << "CC_COMPRESSED";
		case CC_EMPTY: return out << "CC_EMPTY";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--ImageType--//

void NifStream( ImageType & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = ImageType(temp);
}

void NifStream( ImageType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, ImageType const & val ) {
	switch ( val ) {
		case RGB: return out << "RGB";
		case RGBA: return out << "RGBA";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--PixelLayout--//

void NifStream( PixelLayout & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = PixelLayout(temp);
}

void NifStream( PixelLayout const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, PixelLayout const & val ) {
	switch ( val ) {
		case PIX_LAY_PALETTISED: return out << "PIX_LAY_PALETTISED";
		case PIX_LAY_HIGH_COLOR_16: return out << "PIX_LAY_HIGH_COLOR_16";
		case PIX_LAY_TRUE_COLOR_32: return out << "PIX_LAY_TRUE_COLOR_32";
		case PIX_LAY_COMPRESSED: return out << "PIX_LAY_COMPRESSED";
		case PIX_LAY_BUMPMAP: return out << "PIX_LAY_BUMPMAP";
		case PIX_LAY_PALETTISED_4: return out << "PIX_LAY_PALETTISED_4";
		case PIX_LAY_DEFAULT: return out << "PIX_LAY_DEFAULT";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--ConsistencyType--//

void NifStream( ConsistencyType & val, istream& in, const NifInfo & info ) {
	unsigned short temp;
	NifStream( temp, in, info );
	val = ConsistencyType(temp);
}

void NifStream( ConsistencyType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned short)(val), out, info );
}

ostream & operator<<( ostream & out, ConsistencyType const & val ) {
	switch ( val ) {
		case CT_MUTABLE: return out << "CT_MUTABLE";
		case CT_STATIC: return out << "CT_STATIC";
		case CT_VOLATILE: return out << "CT_VOLATILE";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--TexClampMode--//

void NifStream( TexClampMode & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = TexClampMode(temp);
}

void NifStream( TexClampMode const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, TexClampMode const & val ) {
	switch ( val ) {
		case CLAMP_S_CLAMP_T: return out << "CLAMP_S_CLAMP_T";
		case CLAMP_S_WRAP_T: return out << "CLAMP_S_WRAP_T";
		case WRAP_S_CLAMP_T: return out << "WRAP_S_CLAMP_T";
		case WRAP_S_WRAP_T: return out << "WRAP_S_WRAP_T";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--ComponentFormat--//

void NifStream( ComponentFormat & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = ComponentFormat(temp);
}

void NifStream( ComponentFormat const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, ComponentFormat const & val ) {
	switch ( val ) {
		case F_UNKNOWN: return out << "F_UNKNOWN";
		case F_INT8_1: return out << "F_INT8_1";
		case F_INT8_2: return out << "F_INT8_2";
		case F_INT8_3: return out << "F_INT8_3";
		case F_INT8_4: return out << "F_INT8_4";
		case F_UINT8_1: return out << "F_UINT8_1";
		case F_UINT8_2: return out << "F_UINT8_2";
		case F_UINT8_3: return out << "F_UINT8_3";
		case F_UINT8_4: return out << "F_UINT8_4";
		case F_NORMINT8_1: return out << "F_NORMINT8_1";
		case F_NORMINT8_2: return out << "F_NORMINT8_2";
		case F_NORMINT8_3: return out << "F_NORMINT8_3";
		case F_NORMINT8_4: return out << "F_NORMINT8_4";
		case F_NORMUINT8_1: return out << "F_NORMUINT8_1";
		case F_NORMUINT8_2: return out << "F_NORMUINT8_2";
		case F_NORMUINT8_3: return out << "F_NORMUINT8_3";
		case F_NORMUINT8_4: return out << "F_NORMUINT8_4";
		case F_INT16_1: return out << "F_INT16_1";
		case F_INT16_2: return out << "F_INT16_2";
		case F_INT16_3: return out << "F_INT16_3";
		case F_INT16_4: return out << "F_INT16_4";
		case F_UINT16_1: return out << "F_UINT16_1";
		case F_UINT16_2: return out << "F_UINT16_2";
		case F_UINT16_3: return out << "F_UINT16_3";
		case F_UINT16_4: return out << "F_UINT16_4";
		case F_NORMINT16_1: return out << "F_NORMINT16_1";
		case F_NORMINT16_2: return out << "F_NORMINT16_2";
		case F_NORMINT16_3: return out << "F_NORMINT16_3";
		case F_NORMINT16_4: return out << "F_NORMINT16_4";
		case F_NORMUINT16_1: return out << "F_NORMUINT16_1";
		case F_NORMUINT16_2: return out << "F_NORMUINT16_2";
		case F_NORMUINT16_3: return out << "F_NORMUINT16_3";
		case F_NORMUINT16_4: return out << "F_NORMUINT16_4";
		case F_INT32_1: return out << "F_INT32_1";
		case F_INT32_2: return out << "F_INT32_2";
		case F_INT32_3: return out << "F_INT32_3";
		case F_INT32_4: return out << "F_INT32_4";
		case F_UINT32_1: return out << "F_UINT32_1";
		case F_UINT32_2: return out << "F_UINT32_2";
		case F_UINT32_3: return out << "F_UINT32_3";
		case F_UINT32_4: return out << "F_UINT32_4";
		case F_NORMINT32_1: return out << "F_NORMINT32_1";
		case F_NORMINT32_2: return out << "F_NORMINT32_2";
		case F_NORMINT32_3: return out << "F_NORMINT32_3";
		case F_NORMINT32_4: return out << "F_NORMINT32_4";
		case F_NORMUINT32_1: return out << "F_NORMUINT32_1";
		case F_NORMUINT32_2: return out << "F_NORMUINT32_2";
		case F_NORMUINT32_3: return out << "F_NORMUINT32_3";
		case F_NORMUINT32_4: return out << "F_NORMUINT32_4";
		case F_FLOAT16_1: return out << "F_FLOAT16_1";
		case F_FLOAT16_2: return out << "F_FLOAT16_2";
		case F_FLOAT16_3: return out << "F_FLOAT16_3";
		case F_FLOAT16_4: return out << "F_FLOAT16_4";
		case F_FLOAT32_1: return out << "F_FLOAT32_1";
		case F_FLOAT32_2: return out << "F_FLOAT32_2";
		case F_FLOAT32_3: return out << "F_FLOAT32_3";
		case F_FLOAT32_4: return out << "F_FLOAT32_4";
		case F_UINT_10_10_10_L1: return out << "F_UINT_10_10_10_L1";
		case F_NORMINT_10_10_10_L1: return out << "F_NORMINT_10_10_10_L1";
		case F_NORMINT_11_11_10: return out << "F_NORMINT_11_11_10";
		case F_NORMUINT8_4_BGRA: return out << "F_NORMUINT8_4_BGRA";
		case F_NORMINT_10_10_10_2: return out << "F_NORMINT_10_10_10_2";
		case F_UINT_10_10_10_2: return out << "F_UINT_10_10_10_2";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--MotionQuality--//

void NifStream( MotionQuality & val, istream& in, const NifInfo & info ) {
	byte temp;
	NifStream( temp, in, info );
	val = MotionQuality(temp);
}

void NifStream( MotionQuality const & val, ostream& out, const NifInfo & info ) {
	NifStream( (byte)(val), out, info );
}

ostream & operator<<( ostream & out, MotionQuality const & val ) {
	switch ( val ) {
		case MO_QUAL_INVALID: return out << "MO_QUAL_INVALID";
		case MO_QUAL_FIXED: return out << "MO_QUAL_FIXED";
		case MO_QUAL_KEYFRAMED: return out << "MO_QUAL_KEYFRAMED";
		case MO_QUAL_DEBRIS: return out << "MO_QUAL_DEBRIS";
		case MO_QUAL_MOVING: return out << "MO_QUAL_MOVING";
		case MO_QUAL_CRITICAL: return out << "MO_QUAL_CRITICAL";
		case MO_QUAL_BULLET: return out << "MO_QUAL_BULLET";
		case MO_QUAL_USER: return out << "MO_QUAL_USER";
		case MO_QUAL_CHARACTER: return out << "MO_QUAL_CHARACTER";
		case MO_QUAL_KEYFRAMED_REPORT: return out << "MO_QUAL_KEYFRAMED_REPORT";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--CloningBehavior--//

void NifStream( CloningBehavior & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = CloningBehavior(temp);
}

void NifStream( CloningBehavior const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, CloningBehavior const & val ) {
	switch ( val ) {
		case CLONING_SHARE: return out << "CLONING_SHARE";
		case CLONING_COPY: return out << "CLONING_COPY";
		case CLONING_BLANK_COPY: return out << "CLONING_BLANK_COPY";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--PropagationMode--//

void NifStream( PropagationMode & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = PropagationMode(temp);
}

void NifStream( PropagationMode const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, PropagationMode const & val ) {
	switch ( val ) {
		case PROPAGATE_ON_SUCCESS: return out << "PROPAGATE_ON_SUCCESS";
		case PROPAGATE_ON_FAILURE: return out << "PROPAGATE_ON_FAILURE";
		case PROPAGATE_ALWAYS: return out << "PROPAGATE_ALWAYS";
		case PROPAGATE_NEVER: return out << "PROPAGATE_NEVER";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--PixelFormat--//

void NifStream( PixelFormat & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = PixelFormat(temp);
}

void NifStream( PixelFormat const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, PixelFormat const & val ) {
	switch ( val ) {
		case PX_FMT_RGB8: return out << "PX_FMT_RGB8";
		case PX_FMT_RGBA8: return out << "PX_FMT_RGBA8";
		case PX_FMT_PAL8: return out << "PX_FMT_PAL8";
		case PX_FMT_DXT1: return out << "PX_FMT_DXT1";
		case PX_FMT_DXT5: return out << "PX_FMT_DXT5";
		case PX_FMT_DXT5_ALT: return out << "PX_FMT_DXT5_ALT";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--CycleType--//

void NifStream( CycleType & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = CycleType(temp);
}

void NifStream( CycleType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, CycleType const & val ) {
	switch ( val ) {
		case CYCLE_LOOP: return out << "CYCLE_LOOP";
		case CYCLE_REVERSE: return out << "CYCLE_REVERSE";
		case CYCLE_CLAMP: return out << "CYCLE_CLAMP";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--FieldType--//

void NifStream( FieldType & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = FieldType(temp);
}

void NifStream( FieldType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, FieldType const & val ) {
	switch ( val ) {
		case FIELD_WIND: return out << "FIELD_WIND";
		case FIELD_POINT: return out << "FIELD_POINT";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--BSLightingShaderPropertyShaderType--//

void NifStream( BSLightingShaderPropertyShaderType & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = BSLightingShaderPropertyShaderType(temp);
}

void NifStream( BSLightingShaderPropertyShaderType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, BSLightingShaderPropertyShaderType const & val ) {
	switch ( val ) {
		case DEFAULT: return out << "Default";
		case ENVIRONMENT_MAP: return out << "Environment Map";
		case GLOW_SHADER: return out << "Glow Shader";
		case HEIGHTMAP: return out << "Heightmap";
		case FACE_TINT: return out << "Face Tint";
		case SKIN_TINT: return out << "Skin Tint";
		case HAIR_TINT: return out << "Hair Tint";
		case PARALLAX_OCC_MATERIAL: return out << "Parallax Occ Material";
		case WORLD_MULTITEXTURE: return out << "World Multitexture";
		case WORLDMAP1: return out << "WorldMap1";
		case UNKNOWN_10: return out << "Unknown 10";
		case MULTILAYER_PARALLAX: return out << "MultiLayer Parallax";
		case UNKNOWN_12: return out << "Unknown 12";
		case WORLDMAP2: return out << "WorldMap2";
		case SPARKLE_SNOW: return out << "Sparkle Snow";
		case WORLDMAP3: return out << "WorldMap3";
		case EYE_ENVMAP: return out << "Eye Envmap";
		case UNKNOWN_17: return out << "Unknown 17";
		case WORLDMAP4: return out << "WorldMap4";
		case WORLD_LOD_MULTITEXTURE: return out << "World LOD Multitexture";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--DecayType--//

void NifStream( DecayType & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = DecayType(temp);
}

void NifStream( DecayType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, DecayType const & val ) {
	switch ( val ) {
		case DECAY_NONE: return out << "DECAY_NONE";
		case DECAY_LINEAR: return out << "DECAY_LINEAR";
		case DECAY_EXPONENTIAL: return out << "DECAY_EXPONENTIAL";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--EmitFrom--//

void NifStream( EmitFrom & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = EmitFrom(temp);
}

void NifStream( EmitFrom const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, EmitFrom const & val ) {
	switch ( val ) {
		case EMIT_FROM_VERTICES: return out << "EMIT_FROM_VERTICES";
		case EMIT_FROM_FACE_CENTER: return out << "EMIT_FROM_FACE_CENTER";
		case EMIT_FROM_EDGE_CENTER: return out << "EMIT_FROM_EDGE_CENTER";
		case EMIT_FROM_FACE_SURFACE: return out << "EMIT_FROM_FACE_SURFACE";
		case EMIT_FROM_EDGE_SURFACE: return out << "EMIT_FROM_EDGE_SURFACE";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--SkyrimWaterShaderFlags--//

void NifStream( SkyrimWaterShaderFlags & val, istream& in, const NifInfo & info ) {
	byte temp;
	NifStream( temp, in, info );
	val = SkyrimWaterShaderFlags(temp);
}

void NifStream( SkyrimWaterShaderFlags const & val, ostream& out, const NifInfo & info ) {
	NifStream( (byte)(val), out, info );
}

ostream & operator<<( ostream & out, SkyrimWaterShaderFlags const & val ) {
	switch ( val ) {
		case SWSF1_UNKNOWN0: return out << "SWSF1_UNKNOWN0";
		case SWSF1_BYPASS_REFRACTION_MAP: return out << "SWSF1_Bypass_Refraction_Map";
		case SWSF1_WATER_TOGGLE: return out << "SWSF1_Water_Toggle";
		case SWSF1_UNKNOWN3: return out << "SWSF1_UNKNOWN3";
		case SWSF1_UNKNOWN4: return out << "SWSF1_UNKNOWN4";
		case SWSF1_UNKNOWN5: return out << "SWSF1_UNKNOWN5";
		case SWSF1_HIGHLIGHT_LAYER_TOGGLE: return out << "SWSF1_Highlight_Layer_Toggle";
		case SWSF1_ENABLED: return out << "SWSF1_Enabled";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--SkyrimShaderPropertyFlags1--//

void NifStream( SkyrimShaderPropertyFlags1 & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = SkyrimShaderPropertyFlags1(temp);
}

void NifStream( SkyrimShaderPropertyFlags1 const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, SkyrimShaderPropertyFlags1 const & val ) {
	switch ( val ) {
		case SLSF1_SPECULAR: return out << "SLSF1_Specular";
		case SLSF1_SKINNED: return out << "SLSF1_Skinned";
		case SLSF1_TEMP_REFRACTION: return out << "SLSF1_Temp_Refraction";
		case SLSF1_VERTEX_ALPHA: return out << "SLSF1_Vertex_Alpha";
		case SLSF1_GREYSCALE_TO_PALETTECOLOR: return out << "SLSF1_Greyscale_To_PaletteColor";
		case SLSF1_GREYSCALE_TO_PALETTEALPHA: return out << "SLSF1_Greyscale_To_PaletteAlpha";
		case SLSF1_USE_FALLOFF: return out << "SLSF1_Use_Falloff";
		case SLSF1_ENVIRONMENT_MAPPING: return out << "SLSF1_Environment_Mapping";
		case SLSF1_RECIEVE_SHADOWS: return out << "SLSF1_Recieve_Shadows";
		case SLSF1_CAST_SHADOWS: return out << "SLSF1_Cast_Shadows";
		case SLSF1_FACEGEN_DETAIL_MAP: return out << "SLSF1_Facegen_Detail_Map";
		case SLSF1_PARALLAX: return out << "SLSF1_Parallax";
		case SLSF1_MODEL_SPACE_NORMALS: return out << "SLSF1_Model_Space_Normals";
		case SLSF1_NON_PROJECTIVE_SHADOWS: return out << "SLSF1_Non_Projective_Shadows";
		case SLSF1_LANDSCAPE: return out << "SLSF1_Landscape";
		case SLSF1_REFRACTION: return out << "SLSF1_Refraction";
		case SLSF1_FIRE_REFRACTION: return out << "SLSF1_Fire_Refraction";
		case SLSF1_EYE_ENVIRONMENT_MAPPING: return out << "SLSF1_Eye_Environment_Mapping";
		case SLSF1_HAIR_SOFT_LIGHTING: return out << "SLSF1_Hair_Soft_Lighting";
		case SLSF1_SCREENDOOR_ALPHA_FADE: return out << "SLSF1_Screendoor_Alpha_Fade";
		case SLSF1_LOCALMAP_HIDE_SECRET: return out << "SLSF1_Localmap_Hide_Secret";
		case SLSF1_FACEGEN_RGB_TINT: return out << "SLSF1_FaceGen_RGB_Tint";
		case SLSF1_OWN_EMIT: return out << "SLSF1_Own_Emit";
		case SLSF1_PROJECTED_UV: return out << "SLSF1_Projected_UV";
		case SLSF1_MULTIPLE_TEXTURES: return out << "SLSF1_Multiple_Textures";
		case SLSF1_REMAPPABLE_TEXTURES: return out << "SLSF1_Remappable_Textures";
		case SLSF1_DECAL: return out << "SLSF1_Decal";
		case SLSF1_DYNAMIC_DECAL: return out << "SLSF1_Dynamic_Decal";
		case SLSF1_PARALLAX_OCCLUSION: return out << "SLSF1_Parallax_Occlusion";
		case SLSF1_EXTERNAL_EMITTANCE: return out << "SLSF1_External_Emittance";
		case SLSF1_SOFT_EFFECT: return out << "SLSF1_Soft_Effect";
		case SLSF1_ZBUFFER_TEST: return out << "SLSF1_ZBuffer_Test";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--BSShaderFlags--//

void NifStream( BSShaderFlags & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = BSShaderFlags(temp);
}

void NifStream( BSShaderFlags const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, BSShaderFlags const & val ) {
	switch ( val ) {
		case SF_SPECULAR: return out << "SF_Specular";
		case SF_SKINNED: return out << "SF_Skinned";
		case SF_LOWDETAIL: return out << "SF_LowDetail";
		case SF_VERTEX_ALPHA: return out << "SF_Vertex_Alpha";
		case SF_UNKNOWN_1: return out << "SF_Unknown_1";
		case SF_SINGLE_PASS: return out << "SF_Single_Pass";
		case SF_EMPTY: return out << "SF_Empty";
		case SF_ENVIRONMENT_MAPPING: return out << "SF_Environment_Mapping";
		case SF_ALPHA_TEXTURE: return out << "SF_Alpha_Texture";
		case SF_UNKNOWN_2: return out << "SF_Unknown_2";
		case SF_FACEGEN: return out << "SF_FaceGen";
		case SF_PARALLAX_SHADER_INDEX_15: return out << "SF_Parallax_Shader_Index_15";
		case SF_UNKNOWN_3: return out << "SF_Unknown_3";
		case SF_NON_PROJECTIVE_SHADOWS: return out << "SF_Non_Projective_Shadows";
		case SF_UNKNOWN_4: return out << "SF_Unknown_4";
		case SF_REFRACTION: return out << "SF_Refraction";
		case SF_FIRE_REFRACTION: return out << "SF_Fire_Refraction";
		case SF_EYE_ENVIRONMENT_MAPPING: return out << "SF_Eye_Environment_Mapping";
		case SF_HAIR: return out << "SF_Hair";
		case SF_DYNAMIC_ALPHA: return out << "SF_Dynamic_Alpha";
		case SF_LOCALMAP_HIDE_SECRET: return out << "SF_Localmap_Hide_Secret";
		case SF_WINDOW_ENVIRONMENT_MAPPING: return out << "SF_Window_Environment_Mapping";
		case SF_TREE_BILLBOARD: return out << "SF_Tree_Billboard";
		case SF_SHADOW_FRUSTUM: return out << "SF_Shadow_Frustum";
		case SF_MULTIPLE_TEXTURES: return out << "SF_Multiple_Textures";
		case SF_REMAPPABLE_TEXTURES: return out << "SF_Remappable_Textures";
		case SF_DECAL_SINGLE_PASS: return out << "SF_Decal_Single_Pass";
		case SF_DYNAMIC_DECAL_SINGLE_PASS: return out << "SF_Dynamic_Decal_Single_Pass";
		case SF_PARALLAX_OCCULSION: return out << "SF_Parallax_Occulsion";
		case SF_EXTERNAL_EMITTANCE: return out << "SF_External_Emittance";
		case SF_SHADOW_MAP: return out << "SF_Shadow_Map";
		case SF_ZBUFFER_TEST: return out << "SF_ZBuffer_Test";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--FurnitureEntryPoints--//

void NifStream( FurnitureEntryPoints & val, istream& in, const NifInfo & info ) {
	unsigned short temp;
	NifStream( temp, in, info );
	val = FurnitureEntryPoints(temp);
}

void NifStream( FurnitureEntryPoints const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned short)(val), out, info );
}

ostream & operator<<( ostream & out, FurnitureEntryPoints const & val ) {
	switch ( val ) {
		case FRONT: return out << "Front";
		case BEHIND: return out << "Behind";
		case RIGHT: return out << "Right";
		case LEFT: return out << "Left";
		case UP: return out << "Up";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--BSPartFlag--//

void NifStream( BSPartFlag & val, istream& in, const NifInfo & info ) {
	unsigned short temp;
	NifStream( temp, in, info );
	val = BSPartFlag(temp);
}

void NifStream( BSPartFlag const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned short)(val), out, info );
}

ostream & operator<<( ostream & out, BSPartFlag const & val ) {
	switch ( val ) {
		case PF_EDITOR_VISIBLE: return out << "PF_EDITOR_VISIBLE";
		case PF_START_NET_BONESET: return out << "PF_START_NET_BONESET";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--DataStreamAccess--//

void NifStream( DataStreamAccess & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = DataStreamAccess(temp);
}

void NifStream( DataStreamAccess const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, DataStreamAccess const & val ) {
	switch ( val ) {
		case CPU_READ: return out << "CPU Read";
		case CPU_WRITE_STATIC: return out << "CPU Write Static";
		case CPU_WRITE_MUTABLE: return out << "CPU Write Mutable";
		case CPU_WRITE_VOLATILE: return out << "CPU Write Volatile";
		case GPU_READ: return out << "GPU Read";
		case GPU_WRITE: return out << "GPU Write";
		case CPU_WRITE_STATIC_INITITIALIZED: return out << "CPU Write Static Inititialized";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--SkyrimShaderPropertyFlags2--//

void NifStream( SkyrimShaderPropertyFlags2 & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = SkyrimShaderPropertyFlags2(temp);
}

void NifStream( SkyrimShaderPropertyFlags2 const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, SkyrimShaderPropertyFlags2 const & val ) {
	switch ( val ) {
		case SLSF2_ZBUFFER_WRITE: return out << "SLSF2_ZBuffer_Write";
		case SLSF2_LOD_LANDSCAPE: return out << "SLSF2_LOD_Landscape";
		case SLSF2_LOD_OBJECTS: return out << "SLSF2_LOD_Objects";
		case SLSF2_NO_FADE: return out << "SLSF2_No_Fade";
		case SLSF2_DOUBLE_SIDED: return out << "SLSF2_Double_Sided";
		case SLSF2_VERTEX_COLORS: return out << "SLSF2_Vertex_Colors";
		case SLSF2_GLOW_MAP: return out << "SLSF2_Glow_Map";
		case SLSF2_ASSUME_SHADOWMASK: return out << "SLSF2_Assume_Shadowmask";
		case SLSF2_PACKED_TANGENT: return out << "SLSF2_Packed_Tangent";
		case SLSF2_MULTI_INDEX_SNOW: return out << "SLSF2_Multi_Index_Snow";
		case SLSF2_VERTEX_LIGHTING: return out << "SLSF2_Vertex_Lighting";
		case SLSF2_UNIFORM_SCALE: return out << "SLSF2_Uniform_Scale";
		case SLSF2_FIT_SLOPE: return out << "SLSF2_Fit_Slope";
		case SLSF2_BILLBOARD: return out << "SLSF2_Billboard";
		case SLSF2_NO_LOD_LAND_BLEND: return out << "SLSF2_No_LOD_Land_Blend";
		case SLSF2_ENVMAP_LIGHT_FADE: return out << "SLSF2_EnvMap_Light_Fade";
		case SLSF2_WIREFRAME: return out << "SLSF2_Wireframe";
		case SLSF2_WEAPON_BLOOD: return out << "SLSF2_Weapon_Blood";
		case SLSF2_HIDE_ON_LOCAL_MAP: return out << "SLSF2_Hide_On_Local_Map";
		case SLSF2_PREMULT_ALPHA: return out << "SLSF2_Premult_Alpha";
		case SLSF2_CLOUD_LOD: return out << "SLSF2_Cloud_LOD";
		case SLSF2_ANISOTROPIC_LIGHTING: return out << "SLSF2_Anisotropic_Lighting";
		case SLSF2_NO_TRANSPARENCY_MULTISAMPLING: return out << "SLSF2_No_Transparency_Multisampling";
		case SLSF2_UNUSED01: return out << "SLSF2_Unused01";
		case SLSF2_MULTI_LAYER_PARALLAX: return out << "SLSF2_Multi_Layer_Parallax";
		case SLSF2_SOFT_LIGHTING: return out << "SLSF2_Soft_Lighting";
		case SLSF2_RIM_LIGHTING: return out << "SLSF2_Rim_Lighting";
		case SLSF2_BACK_LIGHTING: return out << "SLSF2_Back_Lighting";
		case SLSF2_UNUSED02: return out << "SLSF2_Unused02";
		case SLSF2_TREE_ANIM: return out << "SLSF2_Tree_Anim";
		case SLSF2_EFFECT_LIGHTING: return out << "SLSF2_Effect_Lighting";
		case SLSF2_HD_LOD_OBJECTS: return out << "SLSF2_HD_LOD_Objects";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}


//--BSSegmentFlags--//

void NifStream( BSSegmentFlags & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = BSSegmentFlags(temp);
}

void NifStream( BSSegmentFlags const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, BSSegmentFlags const & val ) {
	switch ( val ) {
		case BSSEG_WATER: return out << "BSSEG_WATER";
		default: return out << "Invalid Value! - " << (unsigned int)(val);
	}
}

//--MoppDataBuildType--//

void NifStream( MoppDataBuildType & val, istream& in, const NifInfo & info ) {
	byte temp;
	NifStream( temp, in, info );
	val = MoppDataBuildType(temp);
}

void NifStream( MoppDataBuildType const & val, ostream& out, const NifInfo & info ) {
	NifStream( (byte)(val), out, info );
}

ostream & operator<<( ostream & out, MoppDataBuildType const & val ) {
	switch ( val ) {
		case BUILT_WITH_CHUNK_SUBDIVISION: return out << "BUILT_WITH_CHUNK_SUBDIVISION";
		case BUILT_WITHOUT_CHUNK_SUBDIVISION: return out << "BUILT_WITHOUT_CHUNK_SUBDIVISION";
		case BUILD_NOT_SET: return out << "BUILD_NOT_SET";
		default: return out << "Invalid Value! - " << (byte)(val);
	}
}

//---ShaderControlled---//

void NifStream( EffectShaderControlledVariable & val, istream& in, const NifInfo & info ) {
	unsigned int temp;
	NifStream( temp, in, info );
	val = EffectShaderControlledVariable(temp);
}

void NifStream( EffectShaderControlledVariable const & val, ostream& out, const NifInfo & info ) {
	NifStream( (unsigned int)(val), out, info );
}

ostream & operator<<( ostream & out, EffectShaderControlledVariable const & val ) {
	switch ( val ) {
		case ESCV_EMISSIVEMULTIPLE: return out << "ESCV_EMISSIVEMULTIPLE";
		case ESCV_FALLOFF_START_ANGLE: return out << "ESCV_FALLOFF_START_ANGLE";
		case ESCV_FALLOFF_STOP_ANGLE: return out << "ESCV_FALLOFF_STOP_ANGLE";
		case ESCV_FALLOFF_START_OPACITY: return out << "ESCV_FALLOFF_START_OPACITY";
		case ESCV_FALLOFF_STOP_OPACITY: return out << "ESCV_FALLOFF_STOP_OPACITY";
		case ESCV_ALPHA_TRANSPARENCY: return out << "ESCV_ALPHA_TRANSPARENCY";