murdle/mc-lce
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
murdle
2026-03-01 02:38:58 +02:00
commit 19250b9db4
19111 changed files with 4358159 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXCollision.h Normal file
View File

@@ -0,0 +1,339 @@
//-------------------------------------------------------------------------------------
// DirectXCollision.h -- C++ Collision 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
{
enum ContainmentType
{
DISJOINT = 0,
INTERSECTS = 1,
CONTAINS = 2,
};
enum PlaneIntersectionType
{
FRONT = 0,
INTERSECTING = 1,
BACK = 2,
};
struct BoundingBox;
struct BoundingOrientedBox;
struct BoundingFrustum;
#pragma warning(push)
#pragma warning(disable:4324 4820)
//-------------------------------------------------------------------------------------
// Bounding sphere
//-------------------------------------------------------------------------------------
struct BoundingSphere
{
XMFLOAT3 Center; // Center of the sphere.
float Radius; // Radius of the sphere.
// Creators
BoundingSphere() : Center(0,0,0), Radius( 1.f ) {}
BoundingSphere( _In_ const XMFLOAT3& center, _In_ float radius )
: Center(center), Radius(radius) { assert( radius >= 0.f ); };
BoundingSphere( _In_ const BoundingSphere& sp )
: Center(sp.Center), Radius(sp.Radius) {}
// Methods
BoundingSphere& operator=( _In_ const BoundingSphere& sp ) { Center = sp.Center; Radius = sp.Radius; return *this; }
void Transform( _Out_ BoundingSphere& Out, _In_ CXMMATRIX M ) const;
void Transform( _Out_ BoundingSphere& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation ) const;
// Transform the sphere
ContainmentType Contains( _In_ FXMVECTOR Point ) const;
ContainmentType Contains( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
ContainmentType Contains( _In_ const BoundingSphere& sh ) const;
ContainmentType Contains( _In_ const BoundingBox& box ) const;
ContainmentType Contains( _In_ const BoundingOrientedBox& box ) const;
ContainmentType Contains( _In_ const BoundingFrustum& fr ) const;
bool Intersects( _In_ const BoundingSphere& sh ) const;
bool Intersects( _In_ const BoundingBox& box ) const;
bool Intersects( _In_ const BoundingOrientedBox& box ) const;
bool Intersects( _In_ const BoundingFrustum& fr ) const;
bool Intersects( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
// Triangle-sphere test
PlaneIntersectionType Intersects( _In_ FXMVECTOR Plane ) const;
// Plane-sphere test
bool Intersects( _In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist ) const;
// Ray-sphere test
ContainmentType ContainedBy( _In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
_In_ GXMVECTOR Plane3, _In_ CXMVECTOR Plane4, _In_ CXMVECTOR Plane5 ) const;
// Test sphere against six planes (see BoundingFrustum::GetPlanes)
// Static methods
static void CreateMerged( _Out_ BoundingSphere& Out, _In_ const BoundingSphere& S1, _In_ const BoundingSphere& S2 );
static void CreateFromBoundingBox( _Out_ BoundingSphere& Out, _In_ const BoundingBox& box );
static void CreateFromBoundingBox( _Out_ BoundingSphere& Out, _In_ const BoundingOrientedBox& box );
static void CreateFromPoints( _Out_ BoundingSphere& Out, _In_ size_t Count,
_In_reads_bytes_(sizeof(XMFLOAT3)+Stride*(Count-1)) const XMFLOAT3* pPoints, _In_ size_t Stride );
static void CreateFromFrustum( _Out_ BoundingSphere& Out, _In_ const BoundingFrustum& fr );
};
//-------------------------------------------------------------------------------------
// Axis-aligned bounding box
//-------------------------------------------------------------------------------------
struct BoundingBox
{
static const size_t CORNER_COUNT = 8;
XMFLOAT3 Center; // Center of the box.
XMFLOAT3 Extents; // Distance from the center to each side.
// Creators
BoundingBox() : Center(0,0,0), Extents( 1.f, 1.f, 1.f ) {}
BoundingBox( _In_ const XMFLOAT3& center, _In_ const XMFLOAT3& extents )
: Center(center), Extents(extents) { assert(extents.x >= 0 && extents.y >= 0 && extents.z >= 0); }
BoundingBox( _In_ const BoundingBox& box ) : Center(box.Center), Extents(box.Extents) {}
// Methods
BoundingBox& operator=( _In_ const BoundingBox& box) { Center = box.Center; Extents = box.Extents; return *this; }
void Transform( _Out_ BoundingBox& Out, _In_ CXMMATRIX M ) const;
void Transform( _Out_ BoundingBox& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation ) const;
void GetCorners( _Out_writes_(8) XMFLOAT3* Corners ) const;
// Gets the 8 corners of the box
ContainmentType Contains( _In_ FXMVECTOR Point ) const;
ContainmentType Contains( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
ContainmentType Contains( _In_ const BoundingSphere& sh ) const;
ContainmentType Contains( _In_ const BoundingBox& box ) const;
ContainmentType Contains( _In_ const BoundingOrientedBox& box ) const;
ContainmentType Contains( _In_ const BoundingFrustum& fr ) const;
bool Intersects( _In_ const BoundingSphere& sh ) const;
bool Intersects( _In_ const BoundingBox& box ) const;
bool Intersects( _In_ const BoundingOrientedBox& box ) const;
bool Intersects( _In_ const BoundingFrustum& fr ) const;
bool Intersects( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
// Triangle-Box test
PlaneIntersectionType Intersects( _In_ FXMVECTOR Plane ) const;
// Plane-box test
bool Intersects( _In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist ) const;
// Ray-Box test
ContainmentType ContainedBy( _In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
_In_ GXMVECTOR Plane3, _In_ CXMVECTOR Plane4, _In_ CXMVECTOR Plane5 ) const;
// Test box against six planes (see BoundingFrustum::GetPlanes)
// Static methods
static void CreateMerged( _Out_ BoundingBox& Out, _In_ const BoundingBox& b1, _In_ const BoundingBox& b2 );
static void CreateFromSphere( _Out_ BoundingBox& Out, _In_ const BoundingSphere& sh );
static void CreateFromPoints( _Out_ BoundingBox& Out, _In_ FXMVECTOR pt1, _In_ FXMVECTOR pt2 );
static void CreateFromPoints( _Out_ BoundingBox& Out, _In_ size_t Count,
_In_reads_bytes_(sizeof(XMFLOAT3)+Stride*(Count-1)) const XMFLOAT3* pPoints, _In_ size_t Stride );
};
//-------------------------------------------------------------------------------------
// Oriented bounding box
//-------------------------------------------------------------------------------------
struct BoundingOrientedBox
{
static const size_t CORNER_COUNT = 8;
XMFLOAT3 Center; // Center of the box.
XMFLOAT3 Extents; // Distance from the center to each side.
XMFLOAT4 Orientation; // Unit quaternion representing rotation (box -> world).
// Creators
BoundingOrientedBox() : Center(0,0,0), Extents( 1.f, 1.f, 1.f ), Orientation(0,0,0, 1.f ) {}
BoundingOrientedBox( _In_ const XMFLOAT3& _Center, _In_ const XMFLOAT3& _Extents, _In_ const XMFLOAT4& _Orientation )
: Center(_Center), Extents(_Extents), Orientation(_Orientation)
{
assert(_Extents.x >= 0 && _Extents.y >= 0 && _Extents.z >= 0);
}
BoundingOrientedBox( _In_ const BoundingOrientedBox& box )
: Center(box.Center), Extents(box.Extents), Orientation(box.Orientation) {}
// Methods
BoundingOrientedBox& operator=( _In_ const BoundingOrientedBox& box ) { Center = box.Center; Extents = box.Extents; Orientation = box.Orientation; return *this; }
void Transform( _Out_ BoundingOrientedBox& Out, _In_ CXMMATRIX M ) const;
void Transform( _Out_ BoundingOrientedBox& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation ) const;
void GetCorners( _Out_writes_(8) XMFLOAT3* Corners ) const;
// Gets the 8 corners of the box
ContainmentType Contains( _In_ FXMVECTOR Point ) const;
ContainmentType Contains( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
ContainmentType Contains( _In_ const BoundingSphere& sh ) const;
ContainmentType Contains( _In_ const BoundingBox& box ) const;
ContainmentType Contains( _In_ const BoundingOrientedBox& box ) const;
ContainmentType Contains( _In_ const BoundingFrustum& fr ) const;
bool Intersects( _In_ const BoundingSphere& sh ) const;
bool Intersects( _In_ const BoundingBox& box ) const;
bool Intersects( _In_ const BoundingOrientedBox& box ) const;
bool Intersects( _In_ const BoundingFrustum& fr ) const;
bool Intersects( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
// Triangle-OrientedBox test
PlaneIntersectionType Intersects( _In_ FXMVECTOR Plane ) const;
// Plane-OrientedBox test
bool Intersects( _In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist ) const;
// Ray-OrientedBox test
ContainmentType ContainedBy( _In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
_In_ GXMVECTOR Plane3, _In_ CXMVECTOR Plane4, _In_ CXMVECTOR Plane5 ) const;
// Test OrientedBox against six planes (see BoundingFrustum::GetPlanes)
// Static methods
static void CreateFromBoundingBox( _Out_ BoundingOrientedBox& Out, _In_ const BoundingBox& box );
static void CreateFromPoints( _Out_ BoundingOrientedBox& Out, _In_ size_t Count,
_In_reads_bytes_(sizeof(XMFLOAT3)+Stride*(Count-1)) const XMFLOAT3* pPoints, _In_ size_t Stride );
};
//-------------------------------------------------------------------------------------
// Bounding frustum
//-------------------------------------------------------------------------------------
struct BoundingFrustum
{
static const size_t CORNER_COUNT = 8;
XMFLOAT3 Origin; // Origin of the frustum (and projection).
XMFLOAT4 Orientation; // Quaternion representing rotation.
float RightSlope; // Positive X slope (X/Z).
float LeftSlope; // Negative X slope.
float TopSlope; // Positive Y slope (Y/Z).
float BottomSlope; // Negative Y slope.
float Near, Far; // Z of the near plane and far plane.
// Creators
BoundingFrustum() : Origin(0,0,0), Orientation(0,0,0, 1.f), RightSlope( 1.f ), LeftSlope( -1.f ),
TopSlope( 1.f ), BottomSlope( -1.f ), Near(0), Far( 1.f ) {}
BoundingFrustum( _In_ const XMFLOAT3& _Origin, _In_ const XMFLOAT4& _Orientation,
_In_ float _RightSlope, _In_ float _LeftSlope, _In_ float _TopSlope, _In_ float _BottomSlope,
_In_ float _Near, _In_ float _Far )
: Origin(_Origin), Orientation(_Orientation),
RightSlope(_RightSlope), LeftSlope(_LeftSlope), TopSlope(_TopSlope), BottomSlope(_BottomSlope),
Near(_Near), Far(_Far) { assert( _Near <= _Far ); }
BoundingFrustum( _In_ const BoundingFrustum& fr )
: Origin(fr.Origin), Orientation(fr.Orientation), RightSlope(fr.RightSlope), LeftSlope(fr.LeftSlope),
TopSlope(fr.TopSlope), BottomSlope(fr.BottomSlope), Near(fr.Near), Far(fr.Far) {}
BoundingFrustum( _In_ CXMMATRIX Projection ) { CreateFromMatrix( *this, Projection ); }
// Methods
BoundingFrustum& operator=( _In_ const BoundingFrustum& fr ) { Origin=fr.Origin; Orientation=fr.Orientation;
RightSlope=fr.RightSlope; LeftSlope=fr.LeftSlope;
TopSlope=fr.TopSlope; BottomSlope=fr.BottomSlope;
Near=fr.Near; Far=fr.Far; return *this; }
void Transform( _Out_ BoundingFrustum& Out, _In_ CXMMATRIX M ) const;
void Transform( _Out_ BoundingFrustum& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation ) const;
void GetCorners( _Out_writes_(8) XMFLOAT3* Corners ) const;
// Gets the 8 corners of the frustum
ContainmentType Contains( _In_ FXMVECTOR Point ) const;
ContainmentType Contains( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
ContainmentType Contains( _In_ const BoundingSphere& sp ) const;
ContainmentType Contains( _In_ const BoundingBox& box ) const;
ContainmentType Contains( _In_ const BoundingOrientedBox& box ) const;
ContainmentType Contains( _In_ const BoundingFrustum& fr ) const;
// Frustum-Frustum test
bool Intersects( _In_ const BoundingSphere& sh ) const;
bool Intersects( _In_ const BoundingBox& box ) const;
bool Intersects( _In_ const BoundingOrientedBox& box ) const;
bool Intersects( _In_ const BoundingFrustum& fr ) const;
bool Intersects( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
// Triangle-Frustum test
PlaneIntersectionType Intersects( _In_ FXMVECTOR Plane ) const;
// Plane-Frustum test
bool Intersects( _In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist ) const;
// Ray-Frustum test
ContainmentType ContainedBy( _In_ FXMVECTOR Plane0, _In_ FXMVECTOR Plane1, _In_ FXMVECTOR Plane2,
_In_ GXMVECTOR Plane3, _In_ CXMVECTOR Plane4, _In_ CXMVECTOR Plane5 ) const;
// Test frustum against six planes (see BoundingFrustum::GetPlanes)
void GetPlanes( _Out_opt_ XMVECTOR* NearPlane, _Out_opt_ XMVECTOR* FarPlane, _Out_opt_ XMVECTOR* RightPlane,
_Out_opt_ XMVECTOR* LeftPlane, _Out_opt_ XMVECTOR* TopPlane, _Out_opt_ XMVECTOR* BottomPlane ) const;
// Create 6 Planes representation of Frustum
// Static methods
static void CreateFromMatrix( _Out_ BoundingFrustum& Out, _In_ CXMMATRIX Projection );
};
//-----------------------------------------------------------------------------
// Triangle intersection testing routines.
//-----------------------------------------------------------------------------
namespace TriangleTests
{
bool Intersects( _In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _In_ FXMVECTOR V0, _In_ GXMVECTOR V1, _In_ CXMVECTOR V2, _Out_ float& Dist );
// Ray-Triangle
bool Intersects( _In_ FXMVECTOR A0, _In_ FXMVECTOR A1, _In_ FXMVECTOR A2, _In_ GXMVECTOR B0, _In_ CXMVECTOR B1, _In_ CXMVECTOR B2 );
// Triangle-Triangle
PlaneIntersectionType Intersects( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2, _In_ GXMVECTOR Plane );
// Plane-Triangle
ContainmentType ContainedBy( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2,
_In_ GXMVECTOR Plane0, _In_ CXMVECTOR Plane1, _In_ CXMVECTOR Plane2,
_In_ CXMVECTOR Plane3, _In_ CXMVECTOR Plane4, _In_ CXMVECTOR Plane5 );
// Test a triangle against six planes at once (see BoundingFrustum::GetPlanes)
};
#pragma warning(pop)
/****************************************************************************
*
* Implementation
*
****************************************************************************/
#pragma warning(push)
#pragma warning(disable : 4068 4616 6001)
#pragma prefast(push)
#pragma prefast(disable : 25000, "FXMVECTOR is 16 bytes")
#include "DirectXCollision.inl"
#pragma prefast(pop)
#pragma warning(pop)
}; // namespace DirectX

4801
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXCollision.inl Normal file
View File

File diff suppressed because it is too large Load Diff

168
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXColors.h Normal file
View File

@@ -0,0 +1,168 @@
//-------------------------------------------------------------------------------------
// DirectXColors.h -- C++ Color 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 Colors
{
// Standard colors (Red/Green/Blue/Alpha)
XMGLOBALCONST XMVECTORF32 AliceBlue = {0.941176534f, 0.972549081f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 AntiqueWhite = {0.980392218f, 0.921568692f, 0.843137324f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Aqua = {0.000000000f, 1.000000000f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Aquamarine = {0.498039246f, 1.000000000f, 0.831372619f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Azure = {0.941176534f, 1.000000000f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Beige = {0.960784376f, 0.960784376f, 0.862745166f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Bisque = {1.000000000f, 0.894117713f, 0.768627524f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Black = {0.000000000f, 0.000000000f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 BlanchedAlmond = {1.000000000f, 0.921568692f, 0.803921640f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Blue = {0.000000000f, 0.000000000f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 BlueViolet = {0.541176498f, 0.168627456f, 0.886274576f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Brown = {0.647058845f, 0.164705887f, 0.164705887f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 BurlyWood = {0.870588303f, 0.721568644f, 0.529411793f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 CadetBlue = {0.372549027f, 0.619607866f, 0.627451003f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Chartreuse = {0.498039246f, 1.000000000f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Chocolate = {0.823529482f, 0.411764741f, 0.117647067f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Coral = {1.000000000f, 0.498039246f, 0.313725501f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 CornflowerBlue = {0.392156899f, 0.584313750f, 0.929411829f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Cornsilk = {1.000000000f, 0.972549081f, 0.862745166f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Crimson = {0.862745166f, 0.078431375f, 0.235294133f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Cyan = {0.000000000f, 1.000000000f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkBlue = {0.000000000f, 0.000000000f, 0.545098066f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkCyan = {0.000000000f, 0.545098066f, 0.545098066f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkGoldenrod = {0.721568644f, 0.525490224f, 0.043137256f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkGray = {0.662745118f, 0.662745118f, 0.662745118f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkGreen = {0.000000000f, 0.392156899f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkKhaki = {0.741176486f, 0.717647076f, 0.419607878f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkMagenta = {0.545098066f, 0.000000000f, 0.545098066f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkOliveGreen = {0.333333343f, 0.419607878f, 0.184313729f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkOrange = {1.000000000f, 0.549019635f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkOrchid = {0.600000024f, 0.196078449f, 0.800000072f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkRed = {0.545098066f, 0.000000000f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkSalmon = {0.913725555f, 0.588235319f, 0.478431404f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkSeaGreen = {0.560784340f, 0.737254918f, 0.545098066f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkSlateBlue = {0.282352954f, 0.239215702f, 0.545098066f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkSlateGray = {0.184313729f, 0.309803933f, 0.309803933f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkTurquoise = {0.000000000f, 0.807843208f, 0.819607913f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DarkViolet = {0.580392182f, 0.000000000f, 0.827451050f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DeepPink = {1.000000000f, 0.078431375f, 0.576470613f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DeepSkyBlue = {0.000000000f, 0.749019623f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DimGray = {0.411764741f, 0.411764741f, 0.411764741f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 DodgerBlue = {0.117647067f, 0.564705908f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Firebrick = {0.698039234f, 0.133333340f, 0.133333340f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 FloralWhite = {1.000000000f, 0.980392218f, 0.941176534f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 ForestGreen = {0.133333340f, 0.545098066f, 0.133333340f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Fuchsia = {1.000000000f, 0.000000000f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Gainsboro = {0.862745166f, 0.862745166f, 0.862745166f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 GhostWhite = {0.972549081f, 0.972549081f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Gold = {1.000000000f, 0.843137324f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Goldenrod = {0.854902029f, 0.647058845f, 0.125490203f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Gray = {0.501960814f, 0.501960814f, 0.501960814f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Green = {0.000000000f, 0.501960814f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 GreenYellow = {0.678431392f, 1.000000000f, 0.184313729f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Honeydew = {0.941176534f, 1.000000000f, 0.941176534f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 HotPink = {1.000000000f, 0.411764741f, 0.705882370f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 IndianRed = {0.803921640f, 0.360784322f, 0.360784322f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Indigo = {0.294117659f, 0.000000000f, 0.509803951f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Ivory = {1.000000000f, 1.000000000f, 0.941176534f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Khaki = {0.941176534f, 0.901960850f, 0.549019635f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Lavender = {0.901960850f, 0.901960850f, 0.980392218f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LavenderBlush = {1.000000000f, 0.941176534f, 0.960784376f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LawnGreen = {0.486274540f, 0.988235354f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LemonChiffon = {1.000000000f, 0.980392218f, 0.803921640f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightBlue = {0.678431392f, 0.847058892f, 0.901960850f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightCoral = {0.941176534f, 0.501960814f, 0.501960814f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightCyan = {0.878431439f, 1.000000000f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightGoldenrodYellow = {0.980392218f, 0.980392218f, 0.823529482f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightGreen = {0.564705908f, 0.933333397f, 0.564705908f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightGray = {0.827451050f, 0.827451050f, 0.827451050f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightPink = {1.000000000f, 0.713725507f, 0.756862819f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightSalmon = {1.000000000f, 0.627451003f, 0.478431404f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightSeaGreen = {0.125490203f, 0.698039234f, 0.666666687f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightSkyBlue = {0.529411793f, 0.807843208f, 0.980392218f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightSlateGray = {0.466666698f, 0.533333361f, 0.600000024f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightSteelBlue = {0.690196097f, 0.768627524f, 0.870588303f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LightYellow = {1.000000000f, 1.000000000f, 0.878431439f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Lime = {0.000000000f, 1.000000000f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 LimeGreen = {0.196078449f, 0.803921640f, 0.196078449f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Linen = {0.980392218f, 0.941176534f, 0.901960850f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Magenta = {1.000000000f, 0.000000000f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Maroon = {0.501960814f, 0.000000000f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumAquamarine = {0.400000036f, 0.803921640f, 0.666666687f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumBlue = {0.000000000f, 0.000000000f, 0.803921640f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumOrchid = {0.729411781f, 0.333333343f, 0.827451050f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumPurple = {0.576470613f, 0.439215720f, 0.858823597f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumSeaGreen = {0.235294133f, 0.701960802f, 0.443137288f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumSlateBlue = {0.482352972f, 0.407843173f, 0.933333397f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumSpringGreen = {0.000000000f, 0.980392218f, 0.603921592f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumTurquoise = {0.282352954f, 0.819607913f, 0.800000072f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MediumVioletRed = {0.780392230f, 0.082352944f, 0.521568656f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MidnightBlue = {0.098039225f, 0.098039225f, 0.439215720f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MintCream = {0.960784376f, 1.000000000f, 0.980392218f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 MistyRose = {1.000000000f, 0.894117713f, 0.882353008f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Moccasin = {1.000000000f, 0.894117713f, 0.709803939f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 NavajoWhite = {1.000000000f, 0.870588303f, 0.678431392f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Navy = {0.000000000f, 0.000000000f, 0.501960814f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 OldLace = {0.992156923f, 0.960784376f, 0.901960850f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Olive = {0.501960814f, 0.501960814f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 OliveDrab = {0.419607878f, 0.556862772f, 0.137254909f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Orange = {1.000000000f, 0.647058845f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 OrangeRed = {1.000000000f, 0.270588249f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Orchid = {0.854902029f, 0.439215720f, 0.839215755f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 PaleGoldenrod = {0.933333397f, 0.909803987f, 0.666666687f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 PaleGreen = {0.596078455f, 0.984313786f, 0.596078455f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 PaleTurquoise = {0.686274529f, 0.933333397f, 0.933333397f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 PaleVioletRed = {0.858823597f, 0.439215720f, 0.576470613f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 PapayaWhip = {1.000000000f, 0.937254965f, 0.835294187f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 PeachPuff = {1.000000000f, 0.854902029f, 0.725490212f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Peru = {0.803921640f, 0.521568656f, 0.247058839f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Pink = {1.000000000f, 0.752941251f, 0.796078503f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Plum = {0.866666734f, 0.627451003f, 0.866666734f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 PowderBlue = {0.690196097f, 0.878431439f, 0.901960850f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Purple = {0.501960814f, 0.000000000f, 0.501960814f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Red = {1.000000000f, 0.000000000f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 RosyBrown = {0.737254918f, 0.560784340f, 0.560784340f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 RoyalBlue = {0.254901975f, 0.411764741f, 0.882353008f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SaddleBrown = {0.545098066f, 0.270588249f, 0.074509807f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Salmon = {0.980392218f, 0.501960814f, 0.447058856f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SandyBrown = {0.956862807f, 0.643137276f, 0.376470625f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SeaGreen = {0.180392161f, 0.545098066f, 0.341176480f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SeaShell = {1.000000000f, 0.960784376f, 0.933333397f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Sienna = {0.627451003f, 0.321568638f, 0.176470593f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Silver = {0.752941251f, 0.752941251f, 0.752941251f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SkyBlue = {0.529411793f, 0.807843208f, 0.921568692f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SlateBlue = {0.415686309f, 0.352941185f, 0.803921640f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SlateGray = {0.439215720f, 0.501960814f, 0.564705908f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Snow = {1.000000000f, 0.980392218f, 0.980392218f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SpringGreen = {0.000000000f, 1.000000000f, 0.498039246f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 SteelBlue = {0.274509817f, 0.509803951f, 0.705882370f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Tan = {0.823529482f, 0.705882370f, 0.549019635f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Teal = {0.000000000f, 0.501960814f, 0.501960814f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Thistle = {0.847058892f, 0.749019623f, 0.847058892f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Tomato = {1.000000000f, 0.388235331f, 0.278431386f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Transparent = {0.000000000f, 0.000000000f, 0.000000000f, 0.000000000f};
XMGLOBALCONST XMVECTORF32 Turquoise = {0.250980407f, 0.878431439f, 0.815686345f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Violet = {0.933333397f, 0.509803951f, 0.933333397f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Wheat = {0.960784376f, 0.870588303f, 0.701960802f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 White = {1.000000000f, 1.000000000f, 1.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 WhiteSmoke = {0.960784376f, 0.960784376f, 0.960784376f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 Yellow = {1.000000000f, 1.000000000f, 0.000000000f, 1.000000000f};
XMGLOBALCONST XMVECTORF32 YellowGreen = {0.603921592f, 0.803921640f, 0.196078449f, 1.000000000f};
}; // namespace Colors
}; // namespace DirectX

1861
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXMath.h Normal file
View File

File diff suppressed because it is too large Load Diff

1962
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXMathConvert.inl Normal file
View File

File diff suppressed because it is too large Load Diff

3414
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXMathMatrix.inl Normal file
View File

File diff suppressed because it is too large Load Diff

2501
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXMathMisc.inl Normal file
View File

File diff suppressed because it is too large Load Diff

10596
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXMathVector.inl Normal file
View File

File diff suppressed because it is too large Load Diff

995
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXPackedVector.h Normal file
View File

@@ -0,0 +1,995 @@
//-------------------------------------------------------------------------------------
// 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 mantissa
typedef uint16_t HALF;
//------------------------------------------------------------------------------
// 2D Vector; 16 bit floating point components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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 components
struct 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

3545
Minecraft.Client/PS3/PS3Extras/DirectX/DirectXPackedVector.inl Normal file
View File

File diff suppressed because it is too large Load Diff

1022
Minecraft.Client/PS3/PS3Extras/DirectX/no_sal2.h Normal file
View File

File diff suppressed because it is too large Load Diff

1998
Minecraft.Client/PS3/PS3Extras/DirectX/sal.h Normal file
View File

File diff suppressed because it is too large Load Diff