Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
35 kB · 995 lines
C
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996//-------------------------------------------------------------------------------------// DirectXPackedVector.h -- SIMD C++ Math library//// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A// PARTICULAR PURPOSE.// // Copyright (c) Microsoft Corporation. All rights reserved.//-------------------------------------------------------------------------------------
#ifdef _MSC_VER#pragma once#endif
#include "DirectXMath.h"
namespace DirectX{ namespace PackedVector{
#ifdef _XM_BIGENDIAN_#pragma bitfield_order(push)#pragma bitfield_order(lsb_to_msb)#endif
#pragma warning(push)#pragma warning(disable:4201 4365 4324)
//------------------------------------------------------------------------------// ARGB Color; 8-8-8-8 bit unsigned normalized integer components packed into// a 32 bit integer. The normalized color is packed into 32 bits using 8 bit// unsigned, normalized integers for the alpha, red, green, and blue components.// The alpha component is stored in the most significant bits and the blue// component in the least significant bits (A8R8G8B8):// [32] aaaaaaaa rrrrrrrr gggggggg bbbbbbbb [0]struct XMCOLOR{ union { struct { uint8_t b; // Blue: 0/255 to 255/255 uint8_t g; // Green: 0/255 to 255/255 uint8_t r; // Red: 0/255 to 255/255 uint8_t a; // Alpha: 0/255 to 255/255 }; uint32_t c; };
XMCOLOR() {} XMCOLOR(uint32_t Color) : c(Color) {} XMCOLOR(float _r, float _g, float _b, float _a); explicit XMCOLOR(_In_reads_(4) const float *pArray);
operator uint32_t () const { return c; }
XMCOLOR& operator= (const XMCOLOR& Color) { c = Color.c; return *this; } XMCOLOR& operator= (const uint32_t Color) { c = Color; return *this; }};
//------------------------------------------------------------------------------// 16 bit floating point number consisting of a sign bit, a 5 bit biased // exponent, and a 10 bit mantissatypedef uint16_t HALF;
//------------------------------------------------------------------------------// 2D Vector; 16 bit floating point componentsstruct XMHALF2{ union { struct { HALF x; HALF y; }; uint32_t v; };
XMHALF2() {} explicit XMHALF2(uint32_t Packed) : v(Packed) {} XMHALF2(HALF _x, HALF _y) : x(_x), y(_y) {} explicit XMHALF2(_In_reads_(2) const HALF *pArray) : x(pArray[0]), y(pArray[1]) {} XMHALF2(float _x, float _y); explicit XMHALF2(_In_reads_(2) const float *pArray);
XMHALF2& operator= (const XMHALF2& Half2) { x = Half2.x; y = Half2.y; return *this; } XMHALF2& operator= (uint32_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 2D Vector; 16 bit signed normalized integer componentsstruct XMSHORTN2{ union { struct { int16_t x; int16_t y; }; uint32_t v; };
XMSHORTN2() {} explicit XMSHORTN2(uint32_t Packed) : v(Packed) {} XMSHORTN2(int16_t _x, int16_t _y) : x(_x), y(_y) {} explicit XMSHORTN2(_In_reads_(2) const int16_t *pArray) : x(pArray[0]), y(pArray[1]) {} XMSHORTN2(float _x, float _y); explicit XMSHORTN2(_In_reads_(2) const float *pArray);
XMSHORTN2& operator= (const XMSHORTN2& ShortN2) { x = ShortN2.x; y = ShortN2.y; return *this; } XMSHORTN2& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 2D Vector; 16 bit signed integer componentsstruct XMSHORT2{ union { struct { int16_t x; int16_t y; }; uint32_t v; };
XMSHORT2() {} explicit XMSHORT2(uint32_t Packed) : v(Packed) {} XMSHORT2(int16_t _x, int16_t _y) : x(_x), y(_y) {} explicit XMSHORT2(_In_reads_(2) const int16_t *pArray) : x(pArray[0]), y(pArray[1]) {} XMSHORT2(float _x, float _y); explicit XMSHORT2(_In_reads_(2) const float *pArray);
XMSHORT2& operator= (const XMSHORT2& Short2) { x = Short2.x; y = Short2.y; return *this; } XMSHORT2& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 2D Vector; 16 bit unsigned normalized integer componentsstruct XMUSHORTN2{ union { struct { uint16_t x; uint16_t y; }; uint32_t v; };
XMUSHORTN2() {} explicit XMUSHORTN2(uint32_t Packed) : v(Packed) {} XMUSHORTN2(uint16_t _x, uint16_t _y) : x(_x), y(_y) {} explicit XMUSHORTN2(_In_reads_(2) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]) {} XMUSHORTN2(float _x, float _y); explicit XMUSHORTN2(_In_reads_(2) const float *pArray);
XMUSHORTN2& operator= (const XMUSHORTN2& UShortN2) { x = UShortN2.x; y = UShortN2.y; return *this; } XMUSHORTN2& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 2D Vector; 16 bit unsigned integer componentsstruct XMUSHORT2{ union { struct { uint16_t x; uint16_t y; }; uint32_t v; };
XMUSHORT2() {} explicit XMUSHORT2(uint32_t Packed) : v(Packed) {} XMUSHORT2(uint16_t _x, uint16_t _y) : x(_x), y(_y) {} explicit XMUSHORT2(_In_reads_(2) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]) {} XMUSHORT2(float _x, float _y); explicit XMUSHORT2(_In_reads_(2) const float *pArray);
XMUSHORT2& operator= (const XMUSHORT2& UShort2) { x = UShort2.x; y = UShort2.y; return *this; } XMUSHORT2& operator= (uint32_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 2D Vector; 8 bit signed normalized integer componentsstruct XMBYTEN2{ union { struct { int8_t x; int8_t y; }; uint16_t v; };
XMBYTEN2() {} explicit XMBYTEN2(uint16_t Packed) : v(Packed) {} XMBYTEN2(int8_t _x, int8_t _y) : x(_x), y(_y) {} explicit XMBYTEN2(_In_reads_(2) const int8_t *pArray) : x(pArray[0]), y(pArray[1]) {} XMBYTEN2(float _x, float _y); explicit XMBYTEN2(_In_reads_(2) const float *pArray);
XMBYTEN2& operator= (const XMBYTEN2& ByteN2) { x = ByteN2.x; y = ByteN2.y; return *this; } XMBYTEN2& operator= (uint16_t Packed) { v = Packed; return *this; }};
// 2D Vector; 8 bit signed integer componentsstruct XMBYTE2{ union { struct { int8_t x; int8_t y; }; uint16_t v; };
XMBYTE2() {} explicit XMBYTE2(uint16_t Packed) : v(Packed) {} XMBYTE2(int8_t _x, int8_t _y) : x(_x), y(_y) {} explicit XMBYTE2(_In_reads_(2) const int8_t *pArray) : x(pArray[0]), y(pArray[1]) {} XMBYTE2(float _x, float _y); explicit XMBYTE2(_In_reads_(2) const float *pArray);
XMBYTE2& operator= (const XMBYTE2& Byte2) { x = Byte2.x; y = Byte2.y; return *this; } XMBYTE2& operator= (uint16_t Packed) { v = Packed; return *this; }};
// 2D Vector; 8 bit unsigned normalized integer componentsstruct XMUBYTEN2{ union { struct { uint8_t x; uint8_t y; }; uint16_t v; };
XMUBYTEN2() {} explicit XMUBYTEN2(uint16_t Packed) : v(Packed) {} XMUBYTEN2(uint8_t _x, uint8_t _y) : x(_x), y(_y) {} explicit XMUBYTEN2(_In_reads_(2) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]) {} XMUBYTEN2(float _x, float _y); explicit XMUBYTEN2(_In_reads_(2) const float *pArray);
XMUBYTEN2& operator= (const XMUBYTEN2& UByteN2) { x = UByteN2.x; y = UByteN2.y; return *this; } XMUBYTEN2& operator= (uint16_t Packed) { v = Packed; return *this; }};
// 2D Vector; 8 bit unsigned integer componentsstruct XMUBYTE2{ union { struct { uint8_t x; uint8_t y; }; uint16_t v; };
XMUBYTE2() {} explicit XMUBYTE2(uint16_t Packed) : v(Packed) {} XMUBYTE2(uint8_t _x, uint8_t _y) : x(_x), y(_y) {} explicit XMUBYTE2(_In_reads_(2) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]) {} XMUBYTE2(float _x, float _y); explicit XMUBYTE2(_In_reads_(2) const float *pArray);
XMUBYTE2& operator= (const XMUBYTE2& UByte2) { x = UByte2.x; y = UByte2.y; return *this; } XMUBYTE2& operator= (uint16_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 3D vector: 5/6/5 unsigned integer componentsstruct XMU565{ union { struct { uint16_t x : 5; // 0 to 31 uint16_t y : 6; // 0 to 63 uint16_t z : 5; // 0 to 31 }; uint16_t v; };
XMU565() {} explicit XMU565(uint16_t Packed) : v(Packed) {} XMU565(uint8_t _x, uint8_t _y, uint8_t _z) : x(_x), y(_y), z(_z) {} explicit XMU565(_In_reads_(3) const int8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]) {} XMU565(float _x, float _y, float _z); explicit XMU565(_In_reads_(3) const float *pArray);
operator uint16_t () const { return v; }
XMU565& operator= (const XMU565& U565) { v = U565.v; return *this; } XMU565& operator= (uint16_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 3D vector: 11/11/10 floating-point components// The 3D vector is packed into 32 bits as follows: a 5-bit biased exponent// and 6-bit mantissa for x component, a 5-bit biased exponent and// 6-bit mantissa for y component, a 5-bit biased exponent and a 5-bit// mantissa for z. The z component is stored in the most significant bits// and the x component in the least significant bits. No sign bits so// all partial-precision numbers are positive.// (Z10Y11X11): [32] ZZZZZzzz zzzYYYYY yyyyyyXX XXXxxxxx [0]struct XMFLOAT3PK{ union { struct { uint32_t xm : 6; // x-mantissa uint32_t xe : 5; // x-exponent uint32_t ym : 6; // y-mantissa uint32_t ye : 5; // y-exponent uint32_t zm : 5; // z-mantissa uint32_t ze : 5; // z-exponent }; uint32_t v; };
XMFLOAT3PK() {} explicit XMFLOAT3PK(uint32_t Packed) : v(Packed) {} XMFLOAT3PK(float _x, float _y, float _z); explicit XMFLOAT3PK(_In_reads_(3) const float *pArray);
operator uint32_t () const { return v; }
XMFLOAT3PK& operator= (const XMFLOAT3PK& float3pk) { v = float3pk.v; return *this; } XMFLOAT3PK& operator= (uint32_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 3D vector: 9/9/9 floating-point components with shared 5-bit exponent// The 3D vector is packed into 32 bits as follows: a 5-bit biased exponent// with 9-bit mantissa for the x, y, and z component. The shared exponent// is stored in the most significant bits and the x component mantissa is in// the least significant bits. No sign bits so all partial-precision numbers// are positive.// (E5Z9Y9X9): [32] EEEEEzzz zzzzzzyy yyyyyyyx xxxxxxxx [0]struct XMFLOAT3SE{ union { struct { uint32_t xm : 9; // x-mantissa uint32_t ym : 9; // y-mantissa uint32_t zm : 9; // z-mantissa uint32_t e : 5; // shared exponent }; uint32_t v; };
XMFLOAT3SE() {} explicit XMFLOAT3SE(uint32_t Packed) : v(Packed) {} XMFLOAT3SE(float _x, float _y, float _z); explicit XMFLOAT3SE(_In_reads_(3) const float *pArray);
operator uint32_t () const { return v; }
XMFLOAT3SE& operator= (const XMFLOAT3SE& float3se) { v = float3se.v; return *this; } XMFLOAT3SE& operator= (uint32_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 4D Vector; 16 bit floating point componentsstruct XMHALF4{ union { struct { HALF x; HALF y; HALF z; HALF w; }; uint64_t v; };
XMHALF4() {} explicit XMHALF4(uint64_t Packed) : v(Packed) {} XMHALF4(HALF _x, HALF _y, HALF _z, HALF _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMHALF4(_In_reads_(4) const HALF *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMHALF4(float _x, float _y, float _z, float _w); explicit XMHALF4(_In_reads_(4) const float *pArray);
XMHALF4& operator= (const XMHALF4& Half4) { x = Half4.x; y = Half4.y; z = Half4.z; w = Half4.w; return *this; } XMHALF4& operator= (uint64_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 4D Vector; 16 bit signed normalized integer componentsstruct XMSHORTN4{ union { struct { int16_t x; int16_t y; int16_t z; int16_t w; }; uint64_t v; };
XMSHORTN4() {} explicit XMSHORTN4(uint64_t Packed) : v(Packed) {} XMSHORTN4(int16_t _x, int16_t _y, int16_t _z, int16_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMSHORTN4(_In_reads_(4) const int16_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMSHORTN4(float _x, float _y, float _z, float _w); explicit XMSHORTN4(_In_reads_(4) const float *pArray);
XMSHORTN4& operator= (const XMSHORTN4& ShortN4) { x = ShortN4.x; y = ShortN4.y; z = ShortN4.z; w = ShortN4.w; return *this; } XMSHORTN4& operator= (uint64_t Packed) { v = Packed; return *this; }};
// 4D Vector; 16 bit signed integer componentsstruct XMSHORT4{ union { struct { int16_t x; int16_t y; int16_t z; int16_t w; }; uint64_t v; };
XMSHORT4() {} explicit XMSHORT4(uint64_t Packed) : v(Packed) {} XMSHORT4(int16_t _x, int16_t _y, int16_t _z, int16_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMSHORT4(_In_reads_(4) const int16_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMSHORT4(float _x, float _y, float _z, float _w); explicit XMSHORT4(_In_reads_(4) const float *pArray);
XMSHORT4& operator= (const XMSHORT4& Short4) { x = Short4.x; y = Short4.y; z = Short4.z; w = Short4.w; return *this; } XMSHORT4& operator= (uint64_t Packed) { v = Packed; return *this; }};
// 4D Vector; 16 bit unsigned normalized integer componentsstruct XMUSHORTN4{ union { struct { uint16_t x; uint16_t y; uint16_t z; uint16_t w; }; uint64_t v; };
XMUSHORTN4() {} explicit XMUSHORTN4(uint64_t Packed) : v(Packed) {} XMUSHORTN4(uint16_t _x, uint16_t _y, uint16_t _z, uint16_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMUSHORTN4(_In_reads_(4) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMUSHORTN4(float _x, float _y, float _z, float _w); explicit XMUSHORTN4(_In_reads_(4) const float *pArray);
XMUSHORTN4& operator= (const XMUSHORTN4& UShortN4) { x = UShortN4.x; y = UShortN4.y; z = UShortN4.z; w = UShortN4.w; return *this; } XMUSHORTN4& operator= (uint64_t Packed) { v = Packed; return *this; }};
// 4D Vector; 16 bit unsigned integer componentsstruct XMUSHORT4{ union { struct { uint16_t x; uint16_t y; uint16_t z; uint16_t w; }; uint64_t v; };
XMUSHORT4() {} explicit XMUSHORT4(uint64_t Packed) : v(Packed) {} XMUSHORT4(uint16_t _x, uint16_t _y, uint16_t _z, uint16_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMUSHORT4(_In_reads_(4) const uint16_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMUSHORT4(float _x, float _y, float _z, float _w); explicit XMUSHORT4(_In_reads_(4) const float *pArray);
XMUSHORT4& operator= (const XMUSHORT4& UShort4) { x = UShort4.x; y = UShort4.y; z = UShort4.z; w = UShort4.w; return *this; } XMUSHORT4& operator= (uint32_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned, // normalized integer for the w component and 10 bit signed, normalized // integers for the z, y, and x components. The w component is stored in the // most significant bits and the x component in the least significant bits// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]struct XMXDECN4{ union { struct { int32_t x : 10; // -511/511 to 511/511 int32_t y : 10; // -511/511 to 511/511 int32_t z : 10; // -511/511 to 511/511 uint32_t w : 2; // 0/3 to 3/3 }; uint32_t v; };
XMXDECN4() {} explicit XMXDECN4(uint32_t Packed) : v(Packed) {} XMXDECN4(float _x, float _y, float _z, float _w); explicit XMXDECN4(_In_reads_(4) const float *pArray);
operator uint32_t () const { return v; }
XMXDECN4& operator= (const XMXDECN4& XDecN4) { v = XDecN4.v; return *this; } XMXDECN4& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned// integer for the w component and 10 bit signed integers for the // z, y, and x components. The w component is stored in the // most significant bits and the x component in the least significant bits// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]struct XMXDEC4{ union { struct { int32_t x : 10; // -511 to 511 int32_t y : 10; // -511 to 511 int32_t z : 10; // -511 to 511 uint32_t w : 2; // 0 to 3 }; uint32_t v; };
XMXDEC4() {} explicit XMXDEC4(uint32_t Packed) : v(Packed) {} XMXDEC4(float _x, float _y, float _z, float _w); explicit XMXDEC4(_In_reads_(4) const float *pArray);
operator uint32_t () const { return v; }
XMXDEC4& operator= (const XMXDEC4& XDec4) { v = XDec4.v; return *this; } XMXDEC4& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit signed, // normalized integer for the w component and 10 bit signed, normalized // integers for the z, y, and x components. The w component is stored in the // most significant bits and the x component in the least significant bits// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]struct XMDECN4{ union { struct { int32_t x : 10; // -511/511 to 511/511 int32_t y : 10; // -511/511 to 511/511 int32_t z : 10; // -511/511 to 511/511 int32_t w : 2; // -1/1 to 1/1 }; uint32_t v; };
XMDECN4() {} explicit XMDECN4(uint32_t Packed) : v(Packed) {} XMDECN4(float _x, float _y, float _z, float _w); explicit XMDECN4(_In_reads_(4) const float *pArray);
operator uint32_t () const { return v; }
XMDECN4& operator= (const XMDECN4& DecN4) { v = DecN4.v; return *this; } XMDECN4& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer// The 4D Vector is packed into 32 bits as follows: a 2 bit signed, // integer for the w component and 10 bit signed integers for the // z, y, and x components. The w component is stored in the // most significant bits and the x component in the least significant bits// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]struct XMDEC4{ union { struct { int32_t x : 10; // -511 to 511 int32_t y : 10; // -511 to 511 int32_t z : 10; // -511 to 511 int32_t w : 2; // -1 to 1 }; uint32_t v; };
XMDEC4() {} explicit XMDEC4(uint32_t Packed) : v(Packed) {} XMDEC4(float _x, float _y, float _z, float _w); explicit XMDEC4(_In_reads_(4) const float *pArray);
operator uint32_t () const { return v; }
XMDEC4& operator= (const XMDEC4& Dec4) { v = Dec4.v; return *this; } XMDEC4& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned, // normalized integer for the w component and 10 bit unsigned, normalized // integers for the z, y, and x components. The w component is stored in the // most significant bits and the x component in the least significant bits// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]struct XMUDECN4{ union { struct { uint32_t x : 10; // 0/1023 to 1023/1023 uint32_t y : 10; // 0/1023 to 1023/1023 uint32_t z : 10; // 0/1023 to 1023/1023 uint32_t w : 2; // 0/3 to 3/3 }; uint32_t v; };
XMUDECN4() {} explicit XMUDECN4(uint32_t Packed) : v(Packed) {} XMUDECN4(float _x, float _y, float _z, float _w); explicit XMUDECN4(_In_reads_(4) const float *pArray);
operator uint32_t () const { return v; }
XMUDECN4& operator= (const XMUDECN4& UDecN4) { v = UDecN4.v; return *this; } XMUDECN4& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer// The 4D Vector is packed into 32 bits as follows: a 2 bit unsigned, // integer for the w component and 10 bit unsigned integers // for the z, y, and x components. The w component is stored in the // most significant bits and the x component in the least significant bits// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]struct XMUDEC4{ union { struct { uint32_t x : 10; // 0 to 1023 uint32_t y : 10; // 0 to 1023 uint32_t z : 10; // 0 to 1023 uint32_t w : 2; // 0 to 3 }; uint32_t v; };
XMUDEC4() {} explicit XMUDEC4(uint32_t Packed) : v(Packed) {} XMUDEC4(float _x, float _y, float _z, float _w); explicit XMUDEC4(_In_reads_(4) const float *pArray);
operator uint32_t () const { return v; }
XMUDEC4& operator= (const XMUDEC4& UDec4) { v = UDec4.v; return *this; } XMUDEC4& operator= (uint32_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 4D Vector; 8 bit signed normalized integer componentsstruct XMBYTEN4{ union { struct { int8_t x; int8_t y; int8_t z; int8_t w; }; uint32_t v; };
XMBYTEN4() {} XMBYTEN4(int8_t _x, int8_t _y, int8_t _z, int8_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMBYTEN4(uint32_t Packed) : v(Packed) {} explicit XMBYTEN4(_In_reads_(4) const int8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMBYTEN4(float _x, float _y, float _z, float _w); explicit XMBYTEN4(_In_reads_(4) const float *pArray);
XMBYTEN4& operator= (const XMBYTEN4& ByteN4) { x = ByteN4.x; y = ByteN4.y; z = ByteN4.z; w = ByteN4.w; return *this; } XMBYTEN4& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 4D Vector; 8 bit signed integer componentsstruct XMBYTE4{ union { struct { int8_t x; int8_t y; int8_t z; int8_t w; }; uint32_t v; };
XMBYTE4() {} XMBYTE4(int8_t _x, int8_t _y, int8_t _z, int8_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMBYTE4(uint32_t Packed) : v(Packed) {} explicit XMBYTE4(_In_reads_(4) const int8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMBYTE4(float _x, float _y, float _z, float _w); explicit XMBYTE4(_In_reads_(4) const float *pArray);
XMBYTE4& operator= (const XMBYTE4& Byte4) { x = Byte4.x; y = Byte4.y; z = Byte4.z; w = Byte4.w; return *this; } XMBYTE4& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 4D Vector; 8 bit unsigned normalized integer componentsstruct XMUBYTEN4{ union { struct { uint8_t x; uint8_t y; uint8_t z; uint8_t w; }; uint32_t v; };
XMUBYTEN4() {} XMUBYTEN4(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMUBYTEN4(uint32_t Packed) : v(Packed) {} explicit XMUBYTEN4(_In_reads_(4) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMUBYTEN4(float _x, float _y, float _z, float _w); explicit XMUBYTEN4(_In_reads_(4) const float *pArray);
XMUBYTEN4& operator= (const XMUBYTEN4& UByteN4) { x = UByteN4.x; y = UByteN4.y; z = UByteN4.z; w = UByteN4.w; return *this; } XMUBYTEN4& operator= (uint32_t Packed) { v = Packed; return *this; }};
// 4D Vector; 8 bit unsigned integer componentsstruct XMUBYTE4{ union { struct { uint8_t x; uint8_t y; uint8_t z; uint8_t w; }; uint32_t v; };
XMUBYTE4() {} XMUBYTE4(uint8_t _x, uint8_t _y, uint8_t _z, uint8_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMUBYTE4(uint32_t Packed) : v(Packed) {} explicit XMUBYTE4(_In_reads_(4) const uint8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMUBYTE4(float _x, float _y, float _z, float _w); explicit XMUBYTE4(_In_reads_(4) const float *pArray);
XMUBYTE4& operator= (const XMUBYTE4& UByte4) { x = UByte4.x; y = UByte4.y; z = UByte4.z; w = UByte4.w; return *this; } XMUBYTE4& operator= (uint32_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 4D vector; 4 bit unsigned integer componentsstruct XMUNIBBLE4{ union { struct { uint16_t x : 4; // 0 to 15 uint16_t y : 4; // 0 to 15 uint16_t z : 4; // 0 to 15 uint16_t w : 4; // 0 to 15 }; uint16_t v; };
XMUNIBBLE4() {} explicit XMUNIBBLE4(uint16_t Packed) : v(Packed) {} XMUNIBBLE4(int8_t _x, int8_t _y, int8_t _z, int8_t _w) : x(_x), y(_y), z(_z), w(_w) {} explicit XMUNIBBLE4(_In_reads_(4) const int8_t *pArray) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(pArray[3]) {} XMUNIBBLE4(float _x, float _y, float _z, float _w); explicit XMUNIBBLE4(_In_reads_(4) const float *pArray);
operator uint16_t () const { return v; }
XMUNIBBLE4& operator= (const XMUNIBBLE4& UNibble4) { v = UNibble4.v; return *this; } XMUNIBBLE4& operator= (uint16_t Packed) { v = Packed; return *this; }};
//------------------------------------------------------------------------------// 4D vector: 5/5/5/1 unsigned integer componentsstruct XMU555{ union { struct { uint16_t x : 5; // 0 to 31 uint16_t y : 5; // 0 to 31 uint16_t z : 5; // 0 to 31 uint16_t w : 1; // 0 or 1 }; uint16_t v; };
XMU555() {} explicit XMU555(uint16_t Packed) : v(Packed) {} XMU555(int8_t _x, int8_t _y, int8_t _z, bool _w) : x(_x), y(_y), z(_z), w(_w ? 0x1 : 0) {} XMU555(_In_reads_(3) const int8_t *pArray, _In_ bool _w) : x(pArray[0]), y(pArray[1]), z(pArray[2]), w(_w ? 0x1 : 0) {} XMU555(float _x, float _y, float _z, bool _w); XMU555(_In_reads_(3) const float *pArray, _In_ bool _w);
operator uint16_t () const { return v; }
XMU555& operator= (const XMU555& U555) { v = U555.v; return *this; } XMU555& operator= (uint16_t Packed) { v = Packed; return *this; }};
#pragma warning(pop)
#ifdef _XM_BIGENDIAN_#pragma bitfield_order(pop)#endif
/**************************************************************************** * * Data conversion operations * ****************************************************************************/
float XMConvertHalfToFloat(HALF Value);float* XMConvertHalfToFloatStream(_Out_writes_bytes_(sizeof(float)+OutputStride*(HalfCount-1)) float* pOutputStream, _In_ size_t OutputStride, _In_reads_bytes_(sizeof(HALF)+InputStride*(HalfCount-1)) const HALF* pInputStream, _In_ size_t InputStride, _In_ size_t HalfCount);HALF XMConvertFloatToHalf(float Value);HALF* XMConvertFloatToHalfStream(_Out_writes_bytes_(sizeof(HALF)+OutputStride*(FloatCount-1)) HALF* pOutputStream, _In_ size_t OutputStride, _In_reads_bytes_(sizeof(float)+InputStride*(FloatCount-1)) const float* pInputStream, _In_ size_t InputStride, _In_ size_t FloatCount);
/**************************************************************************** * * Load operations * ****************************************************************************/
XMVECTOR XMLoadColor(_In_ const XMCOLOR* pSource);
XMVECTOR XMLoadHalf2(_In_ const XMHALF2* pSource);XMVECTOR XMLoadShortN2(_In_ const XMSHORTN2* pSource);XMVECTOR XMLoadShort2(_In_ const XMSHORT2* pSource);XMVECTOR XMLoadUShortN2(_In_ const XMUSHORTN2* pSource);XMVECTOR XMLoadUShort2(_In_ const XMUSHORT2* pSource);XMVECTOR XMLoadByteN2(_In_ const XMBYTEN2* pSource);XMVECTOR XMLoadByte2(_In_ const XMBYTE2* pSource);XMVECTOR XMLoadUByteN2(_In_ const XMUBYTEN2* pSource);XMVECTOR XMLoadUByte2(_In_ const XMUBYTE2* pSource);
XMVECTOR XMLoadU565(_In_ const XMU565* pSource);XMVECTOR XMLoadFloat3PK(_In_ const XMFLOAT3PK* pSource);XMVECTOR XMLoadFloat3SE(_In_ const XMFLOAT3SE* pSource);
XMVECTOR XMLoadHalf4(_In_ const XMHALF4* pSource);XMVECTOR XMLoadShortN4(_In_ const XMSHORTN4* pSource);XMVECTOR XMLoadShort4(_In_ const XMSHORT4* pSource);XMVECTOR XMLoadUShortN4(_In_ const XMUSHORTN4* pSource);XMVECTOR XMLoadUShort4(_In_ const XMUSHORT4* pSource);XMVECTOR XMLoadXDecN4(_In_ const XMXDECN4* pSource);XMVECTOR XMLoadXDec4(_In_ const XMXDEC4* pSource);XMVECTOR XMLoadDecN4(_In_ const XMDECN4* pSource);XMVECTOR XMLoadDec4(_In_ const XMDEC4* pSource);XMVECTOR XMLoadUDecN4(_In_ const XMUDECN4* pSource);XMVECTOR XMLoadUDec4(_In_ const XMUDEC4* pSource);XMVECTOR XMLoadByteN4(_In_ const XMBYTEN4* pSource);XMVECTOR XMLoadByte4(_In_ const XMBYTE4* pSource);XMVECTOR XMLoadUByteN4(_In_ const XMUBYTEN4* pSource);XMVECTOR XMLoadUByte4(_In_ const XMUBYTE4* pSource);XMVECTOR XMLoadUNibble4(_In_ const XMUNIBBLE4* pSource);XMVECTOR XMLoadU555(_In_ const XMU555* pSource);
/**************************************************************************** * * Store operations * ****************************************************************************/
void XMStoreColor(_Out_ XMCOLOR* pDestination, _In_ FXMVECTOR V);
void XMStoreHalf2(_Out_ XMHALF2* pDestination, _In_ FXMVECTOR V);void XMStoreShortN2(_Out_ XMSHORTN2* pDestination, _In_ FXMVECTOR V);void XMStoreShort2(_Out_ XMSHORT2* pDestination, _In_ FXMVECTOR V);void XMStoreUShortN2(_Out_ XMUSHORTN2* pDestination, _In_ FXMVECTOR V);void XMStoreUShort2(_Out_ XMUSHORT2* pDestination, _In_ FXMVECTOR V);void XMStoreByteN2(_Out_ XMBYTEN2* pDestination, _In_ FXMVECTOR V);void XMStoreByte2(_Out_ XMBYTE2* pDestination, _In_ FXMVECTOR V);void XMStoreUByteN2(_Out_ XMUBYTEN2* pDestination, _In_ FXMVECTOR V);void XMStoreUByte2(_Out_ XMUBYTE2* pDestination, _In_ FXMVECTOR V);
void XMStoreU565(_Out_ XMU565* pDestination, _In_ FXMVECTOR V);void XMStoreFloat3PK(_Out_ XMFLOAT3PK* pDestination, _In_ FXMVECTOR V);void XMStoreFloat3SE(_Out_ XMFLOAT3SE* pDestination, _In_ FXMVECTOR V);
void XMStoreHalf4(_Out_ XMHALF4* pDestination, _In_ FXMVECTOR V);void XMStoreShortN4(_Out_ XMSHORTN4* pDestination, _In_ FXMVECTOR V);void XMStoreShort4(_Out_ XMSHORT4* pDestination, _In_ FXMVECTOR V);void XMStoreUShortN4(_Out_ XMUSHORTN4* pDestination, _In_ FXMVECTOR V);void XMStoreUShort4(_Out_ XMUSHORT4* pDestination, _In_ FXMVECTOR V);void XMStoreXDecN4(_Out_ XMXDECN4* pDestination, _In_ FXMVECTOR V);void XMStoreXDec4(_Out_ XMXDEC4* pDestination, _In_ FXMVECTOR V);void XMStoreDecN4(_Out_ XMDECN4* pDestination, _In_ FXMVECTOR V);void XMStoreDec4(_Out_ XMDEC4* pDestination, _In_ FXMVECTOR V);void XMStoreUDecN4(_Out_ XMUDECN4* pDestination, _In_ FXMVECTOR V);void XMStoreUDec4(_Out_ XMUDEC4* pDestination, _In_ FXMVECTOR V);void XMStoreByteN4(_Out_ XMBYTEN4* pDestination, _In_ FXMVECTOR V);void XMStoreByte4(_Out_ XMBYTE4* pDestination, _In_ FXMVECTOR V);void XMStoreUByteN4(_Out_ XMUBYTEN4* pDestination, _In_ FXMVECTOR V);void XMStoreUByte4(_Out_ XMUBYTE4* pDestination, _In_ FXMVECTOR V);void XMStoreUNibble4(_Out_ XMUNIBBLE4* pDestination, _In_ FXMVECTOR V);void XMStoreU555(_Out_ XMU555* pDestination, _In_ FXMVECTOR V);
/**************************************************************************** * * Implementation * ****************************************************************************/
#pragma warning(push)#pragma warning(disable:4068 4214 4204 4365 4616 6001)
#pragma prefast(push)#pragma prefast(disable : 25000, "FXMVECTOR is 16 bytes")
#include "DirectXPackedVector.inl"
#pragma prefast(pop)#pragma warning(pop)
}; // namespace PackedVector
}; // namespace DirectX