Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added GPU SoftBody constraint solvers for DirectX 11 (Direct Compute) and OpenCL, thanks to AMD.

Browse Source 
See also http://code.google.com/p/bullet/issues/detail?id=390
Added Demos/DX11ClothDemo
(an OpenCL cloth demo will follow soon)
This commit is contained in:
erwin.coumans
2010-07-20 16:09:53 +00:00
parent 5fd08505ba
commit 11fa2e8b43
99 changed files with 117195 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

227
Demos/DX11ClothDemo/DXUT/Optional/DXUTLockFreePipe.h Normal file
View File

@@ -0,0 +1,227 @@
//--------------------------------------------------------------------------------------
// DXUTLockFreePipe.h
//
// See the "Lockless Programming Considerations for Xbox 360 and Microsoft Windows"
// article in the DirectX SDK for more details.
//
// http://msdn2.microsoft.com/en-us/library/bb310595.aspx
//
// XNA Developer Connection
// Copyright (C) Microsoft Corporation. All rights reserved.
//--------------------------------------------------------------------------------------
#pragma once
#include <sal.h>
#ifdef _XBOX_VER
// Prevent the CPU from rearranging loads
// and stores, sufficiently for read-acquire
// and write-release.
#define DXUTImportBarrier __lwsync
#define DXUTExportBarrier __lwsync
#else
#pragma pack(push)
#pragma pack(8)
#include <windows.h>
#pragma pack (pop)
extern "C"
void _ReadWriteBarrier();
#pragma intrinsic(_ReadWriteBarrier)
// Prevent the compiler from rearranging loads
// and stores, sufficiently for read-acquire
// and write-release. This is sufficient on
// x86 and x64.
#define DXUTImportBarrier _ReadWriteBarrier
#define DXUTExportBarrier _ReadWriteBarrier
#endif
//
// Pipe class designed for use by at most two threads: one reader, one writer.
// Access by more than two threads isn't guaranteed to be safe.
//
// In order to provide efficient access the size of the buffer is passed
// as a template parameter and restricted to powers of two less than 31.
//
template <BYTE cbBufferSizeLog2> class DXUTLockFreePipe
{
public:
DXUTLockFreePipe() : m_readOffset( 0 ),
m_writeOffset( 0 )
{
}
DWORD GetBufferSize() const
{
return c_cbBufferSize;
}
__forceinline unsigned long BytesAvailable() const
{
return m_writeOffset - m_readOffset;
}
bool __forceinline Read( void* pvDest, unsigned long cbDest )
{
// Store the read and write offsets into local variables--this is
// essentially a snapshot of their values so that they stay constant
// for the duration of the function (and so we don't end up with cache
// misses due to false sharing).
DWORD readOffset = m_readOffset;
DWORD writeOffset = m_writeOffset;
// Compare the two offsets to see if we have anything to read.
// Note that we don't do anything to synchronize the offsets here.
// Really there's not much we *can* do unless we're willing to completely
// synchronize access to the entire object. We have to assume that as we
// read, someone else may be writing, and the write offset we have now
// may be out of date by the time we read it. Fortunately that's not a
// very big deal. We might miss reading some data that was just written.
// But the assumption is that we'll be back before long to grab more data
// anyway.
//
// Note that this comparison works because we're careful to constrain
// the total buffer size to be a power of 2, which means it will divide
// evenly into ULONG_MAX+1. That, and the fact that the offsets are
// unsigned, means that the calculation returns correct results even
// when the values wrap around.
DWORD cbAvailable = writeOffset - readOffset;
if( cbDest > cbAvailable )
{
return false;
}
// The data has been made available, but we need to make sure
// that our view on the data is up to date -- at least as up to
// date as the control values we just read. We need to prevent
// the compiler or CPU from moving any of the data reads before
// the control value reads. This import barrier serves this
// purpose, on Xbox 360 and on Windows.
// Reading a control value and then having a barrier is known
// as a "read-acquire."
DXUTImportBarrier();
unsigned char* pbDest = ( unsigned char* )pvDest;
unsigned long actualReadOffset = readOffset & c_sizeMask;
unsigned long bytesLeft = cbDest;
//
// Copy from the tail, then the head. Note that there's no explicit
// check to see if the write offset comes between the read offset
// and the end of the buffer--that particular condition is implicitly
// checked by the comparison with AvailableToRead(), above. If copying
// cbDest bytes off the tail would cause us to cross the write offset,
// then the previous comparison would have failed since that would imply
// that there were less than cbDest bytes available to read.
//
unsigned long cbTailBytes = min( bytesLeft, c_cbBufferSize - actualReadOffset );
memcpy( pbDest, m_pbBuffer + actualReadOffset, cbTailBytes );
bytesLeft -= cbTailBytes;
if( bytesLeft )
{
memcpy( pbDest + cbTailBytes, m_pbBuffer, bytesLeft );
}
// When we update the read offset we are, effectively, 'freeing' buffer
// memory so that the writing thread can use it. We need to make sure that
// we don't free the memory before we have finished reading it. That is,
// we need to make sure that the write to m_readOffset can't get reordered
// above the reads of the buffer data. The only way to guarantee this is to
// have an export barrier to prevent both compiler and CPU rearrangements.
DXUTExportBarrier();
// Advance the read offset. From the CPUs point of view this is several
// operations--read, modify, store--and we'd normally want to make sure that
// all of the operations happened atomically. But in the case of a single
// reader, only one thread updates this value and so the only operation that
// must be atomic is the store. That's lucky, because 32-bit aligned stores are
// atomic on all modern processors.
//
readOffset += cbDest;
m_readOffset = readOffset;
return true;
}
bool __forceinline Write( const void* pvSrc, unsigned long cbSrc )
{
// Reading the read offset here has the same caveats as reading
// the write offset had in the Read() function above.
DWORD readOffset = m_readOffset;
DWORD writeOffset = m_writeOffset;
// Compute the available write size. This comparison relies on
// the fact that the buffer size is always a power of 2, and the
// offsets are unsigned integers, so that when the write pointer
// wraps around the subtraction still yields a value (assuming
// we haven't messed up somewhere else) between 0 and c_cbBufferSize - 1.
DWORD cbAvailable = c_cbBufferSize - ( writeOffset - readOffset );
if( cbSrc > cbAvailable )
{
return false;
}
// It is theoretically possible for writes of the data to be reordered
// above the reads to see if the data is available. Improbable perhaps,
// but possible. This barrier guarantees that the reordering will not
// happen.
DXUTImportBarrier();
// Write the data
const unsigned char* pbSrc = ( const unsigned char* )pvSrc;
unsigned long actualWriteOffset = writeOffset & c_sizeMask;
unsigned long bytesLeft = cbSrc;
// See the explanation in the Read() function as to why we don't
// explicitly check against the read offset here.
unsigned long cbTailBytes = min( bytesLeft, c_cbBufferSize - actualWriteOffset );
memcpy( m_pbBuffer + actualWriteOffset, pbSrc, cbTailBytes );
bytesLeft -= cbTailBytes;
if( bytesLeft )
{
memcpy( m_pbBuffer, pbSrc + cbTailBytes, bytesLeft );
}
// Now it's time to update the write offset, but since the updated position
// of the write offset will imply that there's data to be read, we need to
// make sure that the data all actually gets written before the update to
// the write offset. The writes could be reordered by the compiler (on any
// platform) or by the CPU (on Xbox 360). We need a barrier which prevents
// the writes from being reordered past each other.
//
// Having a barrier and then writing a control value is called "write-release."
DXUTExportBarrier();
// See comments in Read() as to why this operation isn't interlocked.
writeOffset += cbSrc;
m_writeOffset = writeOffset;
return true;
}
private:
// Values derived from the buffer size template parameter
//
const static BYTE c_cbBufferSizeLog2 = min( cbBufferSizeLog2, 31 );
const static DWORD c_cbBufferSize = ( 1 << c_cbBufferSizeLog2 );
const static DWORD c_sizeMask = c_cbBufferSize - 1;
// Leave these private and undefined to prevent their use
DXUTLockFreePipe( const DXUTLockFreePipe& );
DXUTLockFreePipe& operator =( const DXUTLockFreePipe& );
// Member data
//
BYTE m_pbBuffer[c_cbBufferSize];
// Note that these offsets are not clamped to the buffer size.
// Instead the calculations rely on wrapping at ULONG_MAX+1.
// See the comments in Read() for details.
volatile DWORD __declspec( align( 4 ) ) m_readOffset;
volatile DWORD __declspec( align( 4 ) ) m_writeOffset;
};

5663
Demos/DX11ClothDemo/DXUT/Optional/DXUTShapes.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

24
Demos/DX11ClothDemo/DXUT/Optional/DXUTShapes.h Normal file
View File

@@ -0,0 +1,24 @@
//--------------------------------------------------------------------------------------
// File: DXUTShapes.h
//
// Shape creation functions for DXUT
//
// Copyright (c) Microsoft Corporation. All rights reserved
//--------------------------------------------------------------------------------------
#pragma once
#ifndef DXUT_SHAPES_H
#define DXUT_SHAPES_H
#include <d3d10.h>
#include <d3dx10.h>
HRESULT WINAPI DXUTCreateBox( ID3D10Device* pDevice, float fWidth, float fHeight, float fDepth, ID3DX10Mesh** ppMesh );
HRESULT WINAPI DXUTCreateCylinder( ID3D10Device* pDevice, float fRadius1, float fRadius2, float fLength, UINT uSlices,
UINT uStacks, ID3DX10Mesh** ppMesh );
HRESULT WINAPI DXUTCreatePolygon( ID3D10Device* pDevice, float fLength, UINT uSides, ID3DX10Mesh** ppMesh );
HRESULT WINAPI DXUTCreateSphere( ID3D10Device* pDevice, float fRadius, UINT uSlices, UINT uStacks,
ID3DX10Mesh** ppMesh );
HRESULT WINAPI DXUTCreateTorus( ID3D10Device* pDevice, float fInnerRadius, float fOuterRadius, UINT uSides,
UINT uRings, ID3DX10Mesh** ppMesh );
HRESULT WINAPI DXUTCreateTeapot( ID3D10Device* pDevice, ID3DX10Mesh** ppMesh );
#endif

1525
Demos/DX11ClothDemo/DXUT/Optional/DXUTcamera.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

517
Demos/DX11ClothDemo/DXUT/Optional/DXUTcamera.h Normal file
View File

@@ -0,0 +1,517 @@
//--------------------------------------------------------------------------------------
// File: Camera.h
//
// Helper functions for Direct3D programming.
//
// Copyright (c) Microsoft Corporation. All rights reserved
//--------------------------------------------------------------------------------------
#pragma once
#ifndef CAMERA_H
#define CAMERA_H
//--------------------------------------------------------------------------------------
class CD3DArcBall
{
public:
CD3DArcBall();
// Functions to change behavior
void Reset();
void SetTranslationRadius( FLOAT fRadiusTranslation )
{
m_fRadiusTranslation = fRadiusTranslation;
}
void SetWindow( INT nWidth, INT nHeight, FLOAT fRadius = 0.9f )
{
m_nWidth = nWidth; m_nHeight = nHeight; m_fRadius = fRadius;
m_vCenter = D3DXVECTOR2( m_nWidth / 2.0f, m_nHeight / 2.0f );
}
void SetOffset( INT nX, INT nY )
{
m_Offset.x = nX; m_Offset.y = nY;
}
// Call these from client and use GetRotationMatrix() to read new rotation matrix
void OnBegin( int nX, int nY ); // start the rotation (pass current mouse position)
void OnMove( int nX, int nY ); // continue the rotation (pass current mouse position)
void OnEnd(); // end the rotation
// Or call this to automatically handle left, middle, right buttons
LRESULT HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
// Functions to get/set state
const D3DXMATRIX* GetRotationMatrix()
{
return D3DXMatrixRotationQuaternion( &m_mRotation, &m_qNow );
};
const D3DXMATRIX* GetTranslationMatrix() const
{
return &m_mTranslation;
}
const D3DXMATRIX* GetTranslationDeltaMatrix() const
{
return &m_mTranslationDelta;
}
bool IsBeingDragged() const
{
return m_bDrag;
}
D3DXQUATERNION GetQuatNow() const
{
return m_qNow;
}
void SetQuatNow( D3DXQUATERNION q )
{
m_qNow = q;
}
static D3DXQUATERNION WINAPI QuatFromBallPoints( const D3DXVECTOR3& vFrom, const D3DXVECTOR3& vTo );
protected:
D3DXMATRIXA16 m_mRotation; // Matrix for arc ball's orientation
D3DXMATRIXA16 m_mTranslation; // Matrix for arc ball's position
D3DXMATRIXA16 m_mTranslationDelta; // Matrix for arc ball's position
POINT m_Offset; // window offset, or upper-left corner of window
INT m_nWidth; // arc ball's window width
INT m_nHeight; // arc ball's window height
D3DXVECTOR2 m_vCenter; // center of arc ball
FLOAT m_fRadius; // arc ball's radius in screen coords
FLOAT m_fRadiusTranslation; // arc ball's radius for translating the target
D3DXQUATERNION m_qDown; // Quaternion before button down
D3DXQUATERNION m_qNow; // Composite quaternion for current drag
bool m_bDrag; // Whether user is dragging arc ball
POINT m_ptLastMouse; // position of last mouse point
D3DXVECTOR3 m_vDownPt; // starting point of rotation arc
D3DXVECTOR3 m_vCurrentPt; // current point of rotation arc
D3DXVECTOR3 ScreenToVector( float fScreenPtX, float fScreenPtY );
};
//--------------------------------------------------------------------------------------
// used by CCamera to map WM_KEYDOWN keys
//--------------------------------------------------------------------------------------
enum D3DUtil_CameraKeys
{
CAM_STRAFE_LEFT = 0,
CAM_STRAFE_RIGHT,
CAM_MOVE_FORWARD,
CAM_MOVE_BACKWARD,
CAM_MOVE_UP,
CAM_MOVE_DOWN,
CAM_RESET,
CAM_CONTROLDOWN,
CAM_MAX_KEYS,
CAM_UNKNOWN = 0xFF
};
#define KEY_WAS_DOWN_MASK 0x80
#define KEY_IS_DOWN_MASK 0x01
#define MOUSE_LEFT_BUTTON 0x01
#define MOUSE_MIDDLE_BUTTON 0x02
#define MOUSE_RIGHT_BUTTON 0x04
#define MOUSE_WHEEL 0x08
//--------------------------------------------------------------------------------------
// Simple base camera class that moves and rotates. The base class
// records mouse and keyboard input for use by a derived class, and
// keeps common state.
//--------------------------------------------------------------------------------------
class CBaseCamera
{
public:
CBaseCamera();
// Call these from client and use Get*Matrix() to read new matrices
virtual LRESULT HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
virtual void FrameMove( FLOAT fElapsedTime ) = 0;
// Functions to change camera matrices
virtual void Reset();
virtual void SetViewParams( D3DXVECTOR3* pvEyePt, D3DXVECTOR3* pvLookatPt );
virtual void SetProjParams( FLOAT fFOV, FLOAT fAspect, FLOAT fNearPlane, FLOAT fFarPlane );
// Functions to change behavior
virtual void SetDragRect( RECT& rc )
{
m_rcDrag = rc;
}
void SetInvertPitch( bool bInvertPitch )
{
m_bInvertPitch = bInvertPitch;
}
void SetDrag( bool bMovementDrag, FLOAT fTotalDragTimeToZero = 0.25f )
{
m_bMovementDrag = bMovementDrag; m_fTotalDragTimeToZero = fTotalDragTimeToZero;
}
void SetEnableYAxisMovement( bool bEnableYAxisMovement )
{
m_bEnableYAxisMovement = bEnableYAxisMovement;
}
void SetEnablePositionMovement( bool bEnablePositionMovement )
{
m_bEnablePositionMovement = bEnablePositionMovement;
}
void SetClipToBoundary( bool bClipToBoundary, D3DXVECTOR3* pvMinBoundary,
D3DXVECTOR3* pvMaxBoundary )
{
m_bClipToBoundary = bClipToBoundary; if( pvMinBoundary ) m_vMinBoundary = *pvMinBoundary;
if( pvMaxBoundary ) m_vMaxBoundary = *pvMaxBoundary;
}
void SetScalers( FLOAT fRotationScaler = 0.01f, FLOAT fMoveScaler = 5.0f )
{
m_fRotationScaler = fRotationScaler; m_fMoveScaler = fMoveScaler;
}
void SetNumberOfFramesToSmoothMouseData( int nFrames )
{
if( nFrames > 0 ) m_fFramesToSmoothMouseData = ( float )nFrames;
}
void SetResetCursorAfterMove( bool bResetCursorAfterMove )
{
m_bResetCursorAfterMove = bResetCursorAfterMove;
}
// Functions to get state
const D3DXMATRIX* GetViewMatrix() const
{
return &m_mView;
}
const D3DXMATRIX* GetProjMatrix() const
{
return &m_mProj;
}
const D3DXVECTOR3* GetEyePt() const
{
return &m_vEye;
}
const D3DXVECTOR3* GetLookAtPt() const
{
return &m_vLookAt;
}
float GetNearClip() const
{
return m_fNearPlane;
}
float GetFarClip() const
{
return m_fFarPlane;
}
bool IsBeingDragged() const
{
return ( m_bMouseLButtonDown || m_bMouseMButtonDown || m_bMouseRButtonDown );
}
bool IsMouseLButtonDown() const
{
return m_bMouseLButtonDown;
}
bool IsMouseMButtonDown() const
{
return m_bMouseMButtonDown;
}
bool IsMouseRButtonDown() const
{
return m_bMouseRButtonDown;
}
protected:
// Functions to map a WM_KEYDOWN key to a D3DUtil_CameraKeys enum
virtual D3DUtil_CameraKeys MapKey( UINT nKey );
bool IsKeyDown( BYTE key ) const
{
return( ( key & KEY_IS_DOWN_MASK ) == KEY_IS_DOWN_MASK );
}
bool WasKeyDown( BYTE key ) const
{
return( ( key & KEY_WAS_DOWN_MASK ) == KEY_WAS_DOWN_MASK );
}
void ConstrainToBoundary( D3DXVECTOR3* pV );
void UpdateMouseDelta();
void UpdateVelocity( float fElapsedTime );
void GetInput( bool bGetKeyboardInput, bool bGetMouseInput, bool bGetGamepadInput,
bool bResetCursorAfterMove );
D3DXMATRIX m_mView; // View matrix
D3DXMATRIX m_mProj; // Projection matrix
DXUT_GAMEPAD m_GamePad[DXUT_MAX_CONTROLLERS]; // XInput controller state
D3DXVECTOR3 m_vGamePadLeftThumb;
D3DXVECTOR3 m_vGamePadRightThumb;
double m_GamePadLastActive[DXUT_MAX_CONTROLLERS];
int m_cKeysDown; // Number of camera keys that are down.
BYTE m_aKeys[CAM_MAX_KEYS]; // State of input - KEY_WAS_DOWN_MASK|KEY_IS_DOWN_MASK
D3DXVECTOR3 m_vKeyboardDirection; // Direction vector of keyboard input
POINT m_ptLastMousePosition; // Last absolute position of mouse cursor
bool m_bMouseLButtonDown; // True if left button is down
bool m_bMouseMButtonDown; // True if middle button is down
bool m_bMouseRButtonDown; // True if right button is down
int m_nCurrentButtonMask; // mask of which buttons are down
int m_nMouseWheelDelta; // Amount of middle wheel scroll (+/-)
D3DXVECTOR2 m_vMouseDelta; // Mouse relative delta smoothed over a few frames
float m_fFramesToSmoothMouseData; // Number of frames to smooth mouse data over
D3DXVECTOR3 m_vDefaultEye; // Default camera eye position
D3DXVECTOR3 m_vDefaultLookAt; // Default LookAt position
D3DXVECTOR3 m_vEye; // Camera eye position
D3DXVECTOR3 m_vLookAt; // LookAt position
float m_fCameraYawAngle; // Yaw angle of camera
float m_fCameraPitchAngle; // Pitch angle of camera
RECT m_rcDrag; // Rectangle within which a drag can be initiated.
D3DXVECTOR3 m_vVelocity; // Velocity of camera
bool m_bMovementDrag; // If true, then camera movement will slow to a stop otherwise movement is instant
D3DXVECTOR3 m_vVelocityDrag; // Velocity drag force
FLOAT m_fDragTimer; // Countdown timer to apply drag
FLOAT m_fTotalDragTimeToZero; // Time it takes for velocity to go from full to 0
D3DXVECTOR2 m_vRotVelocity; // Velocity of camera
float m_fFOV; // Field of view
float m_fAspect; // Aspect ratio
float m_fNearPlane; // Near plane
float m_fFarPlane; // Far plane
float m_fRotationScaler; // Scaler for rotation
float m_fMoveScaler; // Scaler for movement
bool m_bInvertPitch; // Invert the pitch axis
bool m_bEnablePositionMovement; // If true, then the user can translate the camera/model
bool m_bEnableYAxisMovement; // If true, then camera can move in the y-axis
bool m_bClipToBoundary; // If true, then the camera will be clipped to the boundary
D3DXVECTOR3 m_vMinBoundary; // Min point in clip boundary
D3DXVECTOR3 m_vMaxBoundary; // Max point in clip boundary
bool m_bResetCursorAfterMove;// If true, the class will reset the cursor position so that the cursor always has space to move
};
//--------------------------------------------------------------------------------------
// Simple first person camera class that moves and rotates.
// It allows yaw and pitch but not roll. It uses WM_KEYDOWN and
// GetCursorPos() to respond to keyboard and mouse input and updates the
// view matrix based on input.
//--------------------------------------------------------------------------------------
class CFirstPersonCamera : public CBaseCamera
{
public:
CFirstPersonCamera();
// Call these from client and use Get*Matrix() to read new matrices
virtual void FrameMove( FLOAT fElapsedTime );
// Functions to change behavior
void SetRotateButtons( bool bLeft, bool bMiddle, bool bRight, bool bRotateWithoutButtonDown = false );
// Functions to get state
D3DXMATRIX* GetWorldMatrix()
{
return &m_mCameraWorld;
}
const D3DXVECTOR3* GetWorldRight() const
{
return ( D3DXVECTOR3* )&m_mCameraWorld._11;
}
const D3DXVECTOR3* GetWorldUp() const
{
return ( D3DXVECTOR3* )&m_mCameraWorld._21;
}
const D3DXVECTOR3* GetWorldAhead() const
{
return ( D3DXVECTOR3* )&m_mCameraWorld._31;
}
const D3DXVECTOR3* GetEyePt() const
{
return ( D3DXVECTOR3* )&m_mCameraWorld._41;
}
protected:
D3DXMATRIX m_mCameraWorld; // World matrix of the camera (inverse of the view matrix)
int m_nActiveButtonMask; // Mask to determine which button to enable for rotation
bool m_bRotateWithoutButtonDown;
};
//--------------------------------------------------------------------------------------
// Simple model viewing camera class that rotates around the object.
//--------------------------------------------------------------------------------------
class CModelViewerCamera : public CBaseCamera
{
public:
CModelViewerCamera();
// Call these from client and use Get*Matrix() to read new matrices
virtual LRESULT HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
virtual void FrameMove( FLOAT fElapsedTime );
// Functions to change behavior
virtual void SetDragRect( RECT& rc );
void Reset();
void SetViewParams( D3DXVECTOR3* pvEyePt, D3DXVECTOR3* pvLookatPt );
void SetButtonMasks( int nRotateModelButtonMask = MOUSE_LEFT_BUTTON, int nZoomButtonMask = MOUSE_WHEEL,
int nRotateCameraButtonMask = MOUSE_RIGHT_BUTTON )
{
m_nRotateModelButtonMask = nRotateModelButtonMask, m_nZoomButtonMask = nZoomButtonMask;
m_nRotateCameraButtonMask = nRotateCameraButtonMask;
}
void SetAttachCameraToModel( bool bEnable = false )
{
m_bAttachCameraToModel = bEnable;
}
void SetWindow( int nWidth, int nHeight, float fArcballRadius=0.9f )
{
m_WorldArcBall.SetWindow( nWidth, nHeight, fArcballRadius );
m_ViewArcBall.SetWindow( nWidth, nHeight, fArcballRadius );
}
void SetRadius( float fDefaultRadius=5.0f, float fMinRadius=1.0f, float fMaxRadius=FLT_MAX )
{
m_fDefaultRadius = m_fRadius = fDefaultRadius; m_fMinRadius = fMinRadius; m_fMaxRadius = fMaxRadius;
m_bDragSinceLastUpdate = true;
}
void SetModelCenter( D3DXVECTOR3 vModelCenter )
{
m_vModelCenter = vModelCenter;
}
void SetLimitPitch( bool bLimitPitch )
{
m_bLimitPitch = bLimitPitch;
}
void SetViewQuat( D3DXQUATERNION q )
{
m_ViewArcBall.SetQuatNow( q ); m_bDragSinceLastUpdate = true;
}
void SetWorldQuat( D3DXQUATERNION q )
{
m_WorldArcBall.SetQuatNow( q ); m_bDragSinceLastUpdate = true;
}
// Functions to get state
const D3DXMATRIX* GetWorldMatrix() const
{
return &m_mWorld;
}
void SetWorldMatrix( D3DXMATRIX& mWorld )
{
m_mWorld = mWorld; m_bDragSinceLastUpdate = true;
}
protected:
CD3DArcBall m_WorldArcBall;
CD3DArcBall m_ViewArcBall;
D3DXVECTOR3 m_vModelCenter;
D3DXMATRIX m_mModelLastRot; // Last arcball rotation matrix for model
D3DXMATRIX m_mModelRot; // Rotation matrix of model
D3DXMATRIX m_mWorld; // World matrix of model
int m_nRotateModelButtonMask;
int m_nZoomButtonMask;
int m_nRotateCameraButtonMask;
bool m_bAttachCameraToModel;
bool m_bLimitPitch;
float m_fRadius; // Distance from the camera to model
float m_fDefaultRadius; // Distance from the camera to model
float m_fMinRadius; // Min radius
float m_fMaxRadius; // Max radius
bool m_bDragSinceLastUpdate; // True if mouse drag has happened since last time FrameMove is called.
D3DXMATRIX m_mCameraRotLast;
};
//--------------------------------------------------------------------------------------
// Manages the mesh, direction, mouse events of a directional arrow that
// rotates around a radius controlled by an arcball
//--------------------------------------------------------------------------------------
class CDXUTDirectionWidget
{
public:
CDXUTDirectionWidget();
static HRESULT WINAPI StaticOnD3D9CreateDevice( IDirect3DDevice9* pd3dDevice );
HRESULT OnD3D9ResetDevice( const D3DSURFACE_DESC* pBackBufferSurfaceDesc );
HRESULT OnRender9( D3DXCOLOR color, const D3DXMATRIX* pmView, const D3DXMATRIX* pmProj,
const D3DXVECTOR3* pEyePt );
LRESULT HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
static void WINAPI StaticOnD3D9LostDevice();
static void WINAPI StaticOnD3D9DestroyDevice();
static HRESULT WINAPI StaticOnD3D11CreateDevice( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext );
HRESULT OnRender11( D3DXCOLOR color, const D3DXMATRIX* pmView, const D3DXMATRIX* pmProj,
const D3DXVECTOR3* pEyePt );
static void WINAPI StaticOnD3D11DestroyDevice();
D3DXVECTOR3 GetLightDirection()
{
return m_vCurrentDir;
};
void SetLightDirection( D3DXVECTOR3 vDir )
{
m_vDefaultDir = m_vCurrentDir = vDir;
};
void SetButtonMask( int nRotate = MOUSE_RIGHT_BUTTON )
{
m_nRotateMask = nRotate;
}
float GetRadius()
{
return m_fRadius;
};
void SetRadius( float fRadius )
{
m_fRadius = fRadius;
};
bool IsBeingDragged()
{
return m_ArcBall.IsBeingDragged();
};
protected:
HRESULT UpdateLightDir();
// D3D9 objects
static IDirect3DDevice9* s_pd3d9Device;
static ID3DXEffect* s_pD3D9Effect;
static ID3DXMesh* s_pD3D9Mesh;
static D3DXHANDLE s_hRenderWith1LightNoTexture;
static D3DXHANDLE s_hMaterialDiffuseColor;
static D3DXHANDLE s_hLightDir;
static D3DXHANDLE s_hWorldViewProjection;
static D3DXHANDLE s_hWorld;
// D3D10 objects
//static ID3D10Device* s_pd3d10Device;
//static ID3D10Effect* s_pD3D10Effect;
//TODO: add some sort of d3d10 mesh object here
//static ID3D10InputLayout* s_pVertexLayout;
//static ID3D10EffectTechnique* s_pRenderTech;
//static ID3D10EffectVectorVariable* g_pMaterialDiffuseColor;
//static ID3D10EffectVectorVariable* g_pLightDir;
//static ID3D10EffectMatrixVariable* g_pmWorld;
//static ID3D10EffectMatrixVariable* g_pmWorldViewProjection;
D3DXMATRIXA16 m_mRot;
D3DXMATRIXA16 m_mRotSnapshot;
float m_fRadius;
int m_nRotateMask;
CD3DArcBall m_ArcBall;
D3DXVECTOR3 m_vDefaultDir;
D3DXVECTOR3 m_vCurrentDir;
D3DXMATRIX m_mView;
};
#endif

7241
Demos/DX11ClothDemo/DXUT/Optional/DXUTgui.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1383
Demos/DX11ClothDemo/DXUT/Optional/DXUTgui.h Normal file
View File

File diff suppressed because it is too large Load Diff

990
Demos/DX11ClothDemo/DXUT/Optional/DXUTguiIME.cpp Normal file
View File

@@ -0,0 +1,990 @@
//--------------------------------------------------------------------------------------
// File: DXUTguiIME.cpp
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//--------------------------------------------------------------------------------------
#include "DXUT.h"
#include "DXUTgui.h"
#include "DXUTsettingsDlg.h"
#include "DXUTres.h"
#include "DXUTgui.h"
#include "DXUTguiIME.h"
#undef min // use __min instead
#undef max // use __max instead
#define DXUT_NEAR_BUTTON_DEPTH 0.6f
//--------------------------------------------------------------------------------------
// CDXUTIMEEditBox class
//--------------------------------------------------------------------------------------
// IME constants
POINT CDXUTIMEEditBox::s_ptCompString; // Composition string position. Updated every frame.
int CDXUTIMEEditBox::s_nFirstTargetConv; // Index of the first target converted char in comp string. If none, -1.
CUniBuffer CDXUTIMEEditBox::s_CompString = CUniBuffer( 0 );
DWORD CDXUTIMEEditBox::s_adwCompStringClause[MAX_COMPSTRING_SIZE];
WCHAR CDXUTIMEEditBox::s_wszReadingString[32];
CDXUTIMEEditBox::CCandList CDXUTIMEEditBox::s_CandList; // Data relevant to the candidate list
bool CDXUTIMEEditBox::s_bImeFlag = true;
#if defined(DEBUG) || defined(_DEBUG)
bool CDXUTIMEEditBox::m_bIMEStaticMsgProcCalled = false;
#endif
//--------------------------------------------------------------------------------------
HRESULT CDXUTIMEEditBox::CreateIMEEditBox( CDXUTDialog* pDialog, int ID, LPCWSTR strText, int x, int y, int width,
int height, bool bIsDefault, CDXUTIMEEditBox** ppCreated )
{
CDXUTIMEEditBox* pEditBox = new CDXUTIMEEditBox( pDialog );
if( ppCreated != NULL )
*ppCreated = pEditBox;
if( pEditBox == NULL )
return E_OUTOFMEMORY;
// Set the ID and position
pEditBox->SetID( ID );
pEditBox->SetLocation( x, y );
pEditBox->SetSize( width, height );
pEditBox->m_bIsDefault = bIsDefault;
if( strText )
pEditBox->SetText( strText );
return S_OK;
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::InitDefaultElements( CDXUTDialog* pDialog )
{
//-------------------------------------
// CDXUTIMEEditBox
//-------------------------------------
CDXUTElement Element;
RECT rcTexture;
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 0, 0, 0 ), DT_LEFT | DT_TOP );
// Assign the style
SetRect( &rcTexture, 14, 90, 241, 113 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 0, &Element );
SetRect( &rcTexture, 8, 82, 14, 90 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 1, &Element );
SetRect( &rcTexture, 14, 82, 241, 90 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 2, &Element );
SetRect( &rcTexture, 241, 82, 246, 90 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 3, &Element );
SetRect( &rcTexture, 8, 90, 14, 113 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 4, &Element );
SetRect( &rcTexture, 241, 90, 246, 113 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 5, &Element );
SetRect( &rcTexture, 8, 113, 14, 121 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 6, &Element );
SetRect( &rcTexture, 14, 113, 241, 121 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 7, &Element );
SetRect( &rcTexture, 241, 113, 246, 121 );
Element.SetTexture( 0, &rcTexture );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 8, &Element );
// Element 9 for IME text, and indicator button
SetRect( &rcTexture, 0, 0, 136, 54 );
Element.SetTexture( 0, &rcTexture );
Element.SetFont( 0, D3DCOLOR_ARGB( 255, 0, 0, 0 ), DT_CENTER | DT_VCENTER );
pDialog->SetDefaultElement( DXUT_CONTROL_IMEEDITBOX, 9, &Element );
}
//--------------------------------------------------------------------------------------
CDXUTIMEEditBox::CDXUTIMEEditBox( CDXUTDialog* pDialog )
{
m_Type = DXUT_CONTROL_IMEEDITBOX;
m_pDialog = pDialog;
m_nIndicatorWidth = 0;
m_ReadingColor = D3DCOLOR_ARGB( 188, 255, 255, 255 );
m_ReadingWinColor = D3DCOLOR_ARGB( 128, 0, 0, 0 );
m_ReadingSelColor = D3DCOLOR_ARGB( 255, 255, 0, 0 );
m_ReadingSelBkColor = D3DCOLOR_ARGB( 128, 80, 80, 80 );
m_CandidateColor = D3DCOLOR_ARGB( 255, 200, 200, 200 );
m_CandidateWinColor = D3DCOLOR_ARGB( 128, 0, 0, 0 );
m_CandidateSelColor = D3DCOLOR_ARGB( 255, 255, 255, 255 );
m_CandidateSelBkColor = D3DCOLOR_ARGB( 128, 158, 158, 158 );
m_CompColor = D3DCOLOR_ARGB( 255, 200, 200, 255 );
m_CompWinColor = D3DCOLOR_ARGB( 198, 0, 0, 0 );
m_CompCaretColor = D3DCOLOR_ARGB( 255, 255, 255, 255 );
m_CompTargetColor = D3DCOLOR_ARGB( 255, 255, 255, 255 );
m_CompTargetBkColor = D3DCOLOR_ARGB( 255, 150, 150, 150 );
m_CompTargetNonColor = D3DCOLOR_ARGB( 255, 255, 255, 0 );
m_CompTargetNonBkColor = D3DCOLOR_ARGB( 255, 150, 150, 150 );
m_IndicatorImeColor = D3DCOLOR_ARGB( 255, 255, 255, 255 );
m_IndicatorEngColor = D3DCOLOR_ARGB( 255, 0, 0, 0 );
m_IndicatorBkColor = D3DCOLOR_ARGB( 255, 128, 128, 128 );
}
//--------------------------------------------------------------------------------------
CDXUTIMEEditBox::~CDXUTIMEEditBox()
{
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::SendKey( BYTE nVirtKey )
{
keybd_event( nVirtKey, 0, 0, 0 );
keybd_event( nVirtKey, 0, KEYEVENTF_KEYUP, 0 );
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::UpdateRects()
{
// Temporary adjust m_width so that CDXUTEditBox can compute
// the correct rects for its rendering since we need to make space
// for the indicator button
int nWidth = m_width;
m_width -= m_nIndicatorWidth + m_nBorder * 2; // Make room for the indicator button
CDXUTEditBox::UpdateRects();
m_width = nWidth; // Restore
// Compute the indicator button rectangle
SetRect( &m_rcIndicator, m_rcBoundingBox.right, m_rcBoundingBox.top, m_x + m_width, m_rcBoundingBox.bottom );
// InflateRect( &m_rcIndicator, -m_nBorder, -m_nBorder );
m_rcBoundingBox.right = m_rcBoundingBox.left + m_width;
}
//--------------------------------------------------------------------------------------
// GetImeId( UINT uIndex )
// returns
// returned value:
// 0: In the following cases
// - Non Chinese IME input locale
// - Older Chinese IME
// - Other error cases
//
// Othewise:
// When uIndex is 0 (default)
// bit 31-24: Major version
// bit 23-16: Minor version
// bit 15-0: Language ID
// When uIndex is 1
// pVerFixedInfo->dwFileVersionLS
//
// Use IMEID_VER and IMEID_LANG macro to extract version and language information.
//
// We define the locale-invariant ID ourselves since it doesn't exist prior to WinXP
// For more information, see the CompareString() reference.
#define LCID_INVARIANT MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT)
//--------------------------------------------------------------------------------------
// Enable/disable the entire IME system. When disabled, the default IME handling
// kicks in.
void CDXUTIMEEditBox::EnableImeSystem( bool bEnable )
{
ImeUi_EnableIme( bEnable );
}
//--------------------------------------------------------------------------------------
// Resets the composition string.
void CDXUTIMEEditBox::ResetCompositionString()
{
s_CompString.SetText( L"" );
}
//--------------------------------------------------------------------------------------
// This function is used only briefly in CHT IME handling,
// so accelerator isn't processed.
void CDXUTIMEEditBox::PumpMessage()
{
MSG msg;
while( PeekMessageW( &msg, NULL, 0, 0, PM_NOREMOVE ) )
{
if( !GetMessageW( &msg, NULL, 0, 0 ) )
{
PostQuitMessage( ( int )msg.wParam );
return;
}
TranslateMessage( &msg );
DispatchMessageA( &msg );
}
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::OnFocusIn()
{
ImeUi_EnableIme( s_bImeFlag );
CDXUTEditBox::OnFocusIn();
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::OnFocusOut()
{
ImeUi_FinalizeString();
ImeUi_EnableIme( false );
CDXUTEditBox::OnFocusOut();
}
//--------------------------------------------------------------------------------------
bool CDXUTIMEEditBox::StaticMsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !ImeUi_IsEnabled() )
return false;
#if defined(DEBUG) || defined(_DEBUG)
m_bIMEStaticMsgProcCalled = true;
#endif
switch( uMsg )
{
case WM_INPUTLANGCHANGE:
DXUTTRACE( L"WM_INPUTLANGCHANGE\n" );
{
}
return true;
case WM_IME_SETCONTEXT:
DXUTTRACE( L"WM_IME_SETCONTEXT\n" );
//
// We don't want anything to display, so we have to clear this
//
lParam = 0;
return false;
// Handle WM_IME_STARTCOMPOSITION here since
// we do not want the default IME handler to see
// this when our fullscreen app is running.
case WM_IME_STARTCOMPOSITION:
DXUTTRACE( L"WM_IME_STARTCOMPOSITION\n" );
ResetCompositionString();
// Since the composition string has its own caret, we don't render
// the edit control's own caret to avoid double carets on screen.
s_bHideCaret = true;
return true;
case WM_IME_ENDCOMPOSITION:
DXUTTRACE( L"WM_IME_ENDCOMPOSITION\n" );
s_bHideCaret = false;
return false;
case WM_IME_COMPOSITION:
DXUTTRACE( L"WM_IME_COMPOSITION\n" );
return false;
}
return false;
}
//--------------------------------------------------------------------------------------
bool CDXUTIMEEditBox::HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
switch( uMsg )
{
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
DXUTFontNode* pFont = m_pDialog->GetFont( m_Elements.GetAt( 9 )->iFont );
// Check if this click is on top of the composition string
int nCompStrWidth;
s_CompString.CPtoX( s_CompString.GetTextSize(), FALSE, &nCompStrWidth );
if( s_ptCompString.x <= pt.x &&
s_ptCompString.y <= pt.y &&
s_ptCompString.x + nCompStrWidth > pt.x &&
s_ptCompString.y + pFont->nHeight > pt.y )
{
int nCharBodyHit, nCharHit;
int nTrail;
// Determine the character clicked on.
s_CompString.XtoCP( pt.x - s_ptCompString.x, &nCharBodyHit, &nTrail );
if( nTrail && nCharBodyHit < s_CompString.GetTextSize() )
nCharHit = nCharBodyHit + 1;
else
nCharHit = nCharBodyHit;
switch( GetPrimaryLanguage() )
{
case LANG_JAPANESE:
// For Japanese, there are two cases. If s_nFirstTargetConv is
// -1, the comp string hasn't been converted yet, and we use
// s_nCompCaret. For any other value of s_nFirstTargetConv,
// the string has been converted, so we use clause information.
if( s_nFirstTargetConv != -1 )
{
int nClauseClicked = 0;
while( ( int )s_adwCompStringClause[nClauseClicked + 1] <= nCharBodyHit )
++nClauseClicked;
int nClauseSelected = 0;
while( ( int )s_adwCompStringClause[nClauseSelected + 1] <= s_nFirstTargetConv )
++nClauseSelected;
BYTE nVirtKey = nClauseClicked > nClauseSelected ? VK_RIGHT : VK_LEFT;
int nSendCount = abs( nClauseClicked - nClauseSelected );
while( nSendCount-- > 0 )
SendKey( nVirtKey );
return true;
}
// Not converted case. Fall thru to Chinese case.
case LANG_CHINESE:
{
// For Chinese, use s_nCompCaret.
BYTE nVirtKey = nCharHit > ( int )ImeUi_GetImeCursorChars() ? VK_RIGHT : VK_LEFT;
int nSendCount = abs( nCharHit - ( int )ImeUi_GetImeCursorChars() );
while( nSendCount-- > 0 )
SendKey( nVirtKey );
break;
}
}
return true;
}
// Check if the click is on top of the candidate window
if( ImeUi_IsShowCandListWindow() && PtInRect( &s_CandList.rcCandidate, pt ) )
{
if( ImeUi_IsVerticalCand() )
{
// Vertical candidate window
// Compute the row the click is on
int nRow = ( pt.y - s_CandList.rcCandidate.top ) / pFont->nHeight;
if( nRow < ( int )ImeUi_GetCandidateCount() )
{
// nRow is a valid entry.
// Now emulate keystrokes to select the candidate at this row.
switch( GetPrimaryLanguage() )
{
case LANG_CHINESE:
case LANG_KOREAN:
// For Chinese and Korean, simply send the number keystroke.
SendKey( ( BYTE )( '0' + nRow + 1 ) );
break;
case LANG_JAPANESE:
// For Japanese, move the selection to the target row,
// then send Right, then send Left.
BYTE nVirtKey;
if( nRow > ( int )ImeUi_GetCandidateSelection() )
nVirtKey = VK_DOWN;
else
nVirtKey = VK_UP;
int nNumToHit = abs( int( nRow - ImeUi_GetCandidateSelection() ) );
for( int nStrike = 0; nStrike < nNumToHit; ++nStrike )
SendKey( nVirtKey );
// Do this to close the candidate window without ending composition.
SendKey( VK_RIGHT );
SendKey( VK_LEFT );
break;
}
}
}
else
{
// Horizontal candidate window
// Determine which the character the click has hit.
int nCharHit;
int nTrail;
s_CandList.HoriCand.XtoCP( pt.x - s_CandList.rcCandidate.left, &nCharHit, &nTrail );
// Determine which candidate string the character belongs to.
int nCandidate = ImeUi_GetCandidateCount() - 1;
int nEntryStart = 0;
for( UINT i = 0; i < ImeUi_GetCandidateCount(); ++i )
{
if( nCharHit >= nEntryStart )
{
// Haven't found it.
nEntryStart += lstrlenW( ImeUi_GetCandidate( i ) ) + 1; // plus space separator
}
else
{
// Found it. This entry starts at the right side of the click point,
// so the char belongs to the previous entry.
nCandidate = i - 1;
break;
}
}
// Now emulate keystrokes to select the candidate entry.
switch( GetPrimaryLanguage() )
{
case LANG_CHINESE:
case LANG_KOREAN:
// For Chinese and Korean, simply send the number keystroke.
SendKey( ( BYTE )( '0' + nCandidate + 1 ) );
break;
}
}
return true;
}
}
}
// If we didn't care for the msg, let the parent process it.
return CDXUTEditBox::HandleMouse( uMsg, pt, wParam, lParam );
}
//--------------------------------------------------------------------------------------
bool CDXUTIMEEditBox::MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if( !m_bEnabled || !m_bVisible )
return false;
#if defined(DEBUG) || defined(_DEBUG)
// DXUT.cpp used to call CDXUTIMEEditBox::StaticMsgProc() so that, but now
// this is the application's responsiblity. To do this, call
// CDXUTDialogResourceManager::MsgProc() before calling this function.
assert( m_bIMEStaticMsgProcCalled && L"To fix, call CDXUTDialogResourceManager::MsgProc() first" );
#endif
switch( uMsg )
{
case WM_DESTROY:
ImeUi_Uninitialize();
break;
}
bool trappedData;
bool* trapped = &trappedData;
*trapped = false;
if( !ImeUi_IsEnabled() )
return CDXUTEditBox::MsgProc( uMsg, wParam, lParam );
ImeUi_ProcessMessage( DXUTGetHWND(), uMsg, wParam, lParam, trapped );
if( *trapped == false )
CDXUTEditBox::MsgProc( uMsg, wParam, lParam );
return *trapped;
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::RenderCandidateReadingWindow( float fElapsedTime, bool bReading )
{
RECT rc;
UINT nNumEntries = bReading ? 4 : MAX_CANDLIST;
D3DCOLOR TextColor, TextBkColor, SelTextColor, SelBkColor;
int nX, nXFirst, nXComp;
m_Buffer.CPtoX( m_nCaret, FALSE, &nX );
m_Buffer.CPtoX( m_nFirstVisible, FALSE, &nXFirst );
if( bReading )
{
TextColor = m_ReadingColor;
TextBkColor = m_ReadingWinColor;
SelTextColor = m_ReadingSelColor;
SelBkColor = m_ReadingSelBkColor;
}
else
{
TextColor = m_CandidateColor;
TextBkColor = m_CandidateWinColor;
SelTextColor = m_CandidateSelColor;
SelBkColor = m_CandidateSelBkColor;
}
// For Japanese IME, align the window with the first target converted character.
// For all other IMEs, align with the caret. This is because the caret
// does not move for Japanese IME.
if( GetLanguage() == MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL ) && !GetImeId() )
nXComp = 0;
else if( GetPrimaryLanguage() == LANG_JAPANESE )
s_CompString.CPtoX( s_nFirstTargetConv, FALSE, &nXComp );
else
s_CompString.CPtoX( ImeUi_GetImeCursorChars(), FALSE, &nXComp );
// Compute the size of the candidate window
int nWidthRequired = 0;
int nHeightRequired = 0;
int nSingleLineHeight = 0;
if( ( ImeUi_IsVerticalCand() && !bReading ) ||
( !ImeUi_IsHorizontalReading() && bReading ) )
{
// Vertical window
for( UINT i = 0; i < nNumEntries; ++i )
{
if( *( ImeUi_GetCandidate( i ) ) == L'\0' )
break;
SetRect( &rc, 0, 0, 0, 0 );
m_pDialog->CalcTextRect( ImeUi_GetCandidate( i ), m_Elements.GetAt( 1 ), &rc );
nWidthRequired = __max( nWidthRequired, rc.right - rc.left );
nSingleLineHeight = __max( nSingleLineHeight, rc.bottom - rc.top );
}
nHeightRequired = nSingleLineHeight * nNumEntries;
}
else
{
// Horizontal window
SetRect( &rc, 0, 0, 0, 0 );
if( bReading )
m_pDialog->CalcTextRect( s_wszReadingString, m_Elements.GetAt( 1 ), &rc );
else
{
WCHAR wszCand[256] = L"";
s_CandList.nFirstSelected = 0;
s_CandList.nHoriSelectedLen = 0;
for( UINT i = 0; i < MAX_CANDLIST; ++i )
{
if( *ImeUi_GetCandidate( i ) == L'\0' )
break;
WCHAR wszEntry[32];
swprintf_s( wszEntry, 32, L"%s ", ImeUi_GetCandidate( i ) );
// If this is the selected entry, mark its char position.
if( ImeUi_GetCandidateSelection() == i )
{
s_CandList.nFirstSelected = lstrlen( wszCand );
s_CandList.nHoriSelectedLen = lstrlen( wszEntry ) - 1; // Minus space
}
wcscat_s( wszCand, 256, wszEntry );
}
wszCand[lstrlen( wszCand ) - 1] = L'\0'; // Remove the last space
s_CandList.HoriCand.SetText( wszCand );
m_pDialog->CalcTextRect( s_CandList.HoriCand.GetBuffer(), m_Elements.GetAt( 1 ), &rc );
}
nWidthRequired = rc.right - rc.left;
nSingleLineHeight = nHeightRequired = rc.bottom - rc.top;
}
// Now that we have the dimension, calculate the location for the candidate window.
// We attempt to fit the window in this order:
// bottom, top, right, left.
bool bHasPosition = false;
// Bottom
SetRect( &rc, s_ptCompString.x + nXComp, s_ptCompString.y + m_rcText.bottom - m_rcText.top,
s_ptCompString.x + nXComp + nWidthRequired, s_ptCompString.y + m_rcText.bottom - m_rcText.top +
nHeightRequired );
// if the right edge is cut off, move it left.
if( rc.right > m_pDialog->GetWidth() )
{
rc.left -= rc.right - m_pDialog->GetWidth();
rc.right = m_pDialog->GetWidth();
}
if( rc.bottom <= m_pDialog->GetHeight() )
bHasPosition = true;
// Top
if( !bHasPosition )
{
SetRect( &rc, s_ptCompString.x + nXComp, s_ptCompString.y - nHeightRequired,
s_ptCompString.x + nXComp + nWidthRequired, s_ptCompString.y );
// if the right edge is cut off, move it left.
if( rc.right > m_pDialog->GetWidth() )
{
rc.left -= rc.right - m_pDialog->GetWidth();
rc.right = m_pDialog->GetWidth();
}
if( rc.top >= 0 )
bHasPosition = true;
}
// Right
if( !bHasPosition )
{
int nXCompTrail;
s_CompString.CPtoX( ImeUi_GetImeCursorChars(), TRUE, &nXCompTrail );
SetRect( &rc, s_ptCompString.x + nXCompTrail, 0,
s_ptCompString.x + nXCompTrail + nWidthRequired, nHeightRequired );
if( rc.right <= m_pDialog->GetWidth() )
bHasPosition = true;
}
// Left
if( !bHasPosition )
{
SetRect( &rc, s_ptCompString.x + nXComp - nWidthRequired, 0,
s_ptCompString.x + nXComp, nHeightRequired );
if( rc.right >= 0 )
bHasPosition = true;
}
if( !bHasPosition )
{
// The dialog is too small for the candidate window.
// Fall back to render at 0, 0. Some part of the window
// will be cut off.
rc.left = 0;
rc.right = nWidthRequired;
}
// If we are rendering the candidate window, save the position
// so that mouse clicks are checked properly.
if( !bReading )
s_CandList.rcCandidate = rc;
// Render the elements
m_pDialog->DrawRect( &rc, TextBkColor );
if( ( ImeUi_IsVerticalCand() && !bReading ) ||
( !ImeUi_IsHorizontalReading() && bReading ) )
{
// Vertical candidate window
for( UINT i = 0; i < nNumEntries; ++i )
{
// Here we are rendering one line at a time
rc.bottom = rc.top + nSingleLineHeight;
// Use a different color for the selected string
if( ImeUi_GetCandidateSelection() == i )
{
m_pDialog->DrawRect( &rc, SelBkColor );
m_Elements.GetAt( 1 )->FontColor.Current = SelTextColor;
}
else
m_Elements.GetAt( 1 )->FontColor.Current = TextColor;
m_pDialog->DrawText( ImeUi_GetCandidate( i ), m_Elements.GetAt( 1 ), &rc );
rc.top += nSingleLineHeight;
}
}
else
{
// Horizontal candidate window
m_Elements.GetAt( 1 )->FontColor.Current = TextColor;
if( bReading )
m_pDialog->DrawText( s_wszReadingString, m_Elements.GetAt( 1 ), &rc );
else
m_pDialog->DrawText( s_CandList.HoriCand.GetBuffer(), m_Elements.GetAt( 1 ), &rc );
// Render the selected entry differently
if( !bReading )
{
int nXLeft, nXRight;
s_CandList.HoriCand.CPtoX( s_CandList.nFirstSelected, FALSE, &nXLeft );
s_CandList.HoriCand.CPtoX( s_CandList.nFirstSelected + s_CandList.nHoriSelectedLen, FALSE, &nXRight );
rc.right = rc.left + nXRight;
rc.left += nXLeft;
m_pDialog->DrawRect( &rc, SelBkColor );
m_Elements.GetAt( 1 )->FontColor.Current = SelTextColor;
m_pDialog->DrawText( s_CandList.HoriCand.GetBuffer() + s_CandList.nFirstSelected,
m_Elements.GetAt( 1 ), &rc, false, s_CandList.nHoriSelectedLen );
}
}
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::RenderComposition( float fElapsedTime )
{
s_CompString.SetText( ImeUi_GetCompositionString() );
RECT rcCaret =
{
0, 0, 0, 0
};
int nX, nXFirst;
m_Buffer.CPtoX( m_nCaret, FALSE, &nX );
m_Buffer.CPtoX( m_nFirstVisible, FALSE, &nXFirst );
CDXUTElement* pElement = m_Elements.GetAt( 1 );
// Get the required width
RECT rc =
{
m_rcText.left + nX - nXFirst, m_rcText.top,
m_rcText.left + nX - nXFirst, m_rcText.bottom
};
m_pDialog->CalcTextRect( s_CompString.GetBuffer(), pElement, &rc );
// If the composition string is too long to fit within
// the text area, move it to below the current line.
// This matches the behavior of the default IME.
if( rc.right > m_rcText.right )
OffsetRect( &rc, m_rcText.left - rc.left, rc.bottom - rc.top );
// Save the rectangle position for processing highlighted text.
RECT rcFirst = rc;
// Update s_ptCompString for RenderCandidateReadingWindow().
s_ptCompString.x = rc.left; s_ptCompString.y = rc.top;
D3DCOLOR TextColor = m_CompColor;
// Render the window and string.
// If the string is too long, we must wrap the line.
pElement->FontColor.Current = TextColor;
const WCHAR* pwszComp = s_CompString.GetBuffer();
int nCharLeft = s_CompString.GetTextSize();
for(; ; )
{
// Find the last character that can be drawn on the same line.
int nLastInLine;
int bTrail;
s_CompString.XtoCP( m_rcText.right - rc.left, &nLastInLine, &bTrail );
int nNumCharToDraw = __min( nCharLeft, nLastInLine );
m_pDialog->CalcTextRect( pwszComp, pElement, &rc, nNumCharToDraw );
// Draw the background
// For Korean IME, blink the composition window background as if it
// is a cursor.
if( GetPrimaryLanguage() == LANG_KOREAN )
{
if( m_bCaretOn )
{
m_pDialog->DrawRect( &rc, m_CompWinColor );
}
else
{
// Not drawing composition string background. We
// use the editbox's text color for composition
// string text.
TextColor = m_Elements.GetAt( 0 )->FontColor.States[DXUT_STATE_NORMAL];
}
}
else
{
// Non-Korean IME. Always draw composition background.
m_pDialog->DrawRect( &rc, m_CompWinColor );
}
// Draw the text
pElement->FontColor.Current = TextColor;
m_pDialog->DrawText( pwszComp, pElement, &rc, false, nNumCharToDraw );
// Advance pointer and counter
nCharLeft -= nNumCharToDraw;
pwszComp += nNumCharToDraw;
if( nCharLeft <= 0 )
break;
// Advance rectangle coordinates to beginning of next line
OffsetRect( &rc, m_rcText.left - rc.left, rc.bottom - rc.top );
}
// Load the rect for the first line again.
rc = rcFirst;
// Inspect each character in the comp string.
// For target-converted and target-non-converted characters,
// we display a different background color so they appear highlighted.
int nCharFirst = 0;
nXFirst = 0;
s_nFirstTargetConv = -1;
BYTE* pAttr;
const WCHAR* pcComp;
for( pcComp = s_CompString.GetBuffer(), pAttr = ImeUi_GetCompStringAttr();
*pcComp != L'\0'; ++pcComp, ++pAttr )
{
D3DCOLOR bkColor;
// Render a different background for this character
int nXLeft, nXRight;
s_CompString.CPtoX( int( pcComp - s_CompString.GetBuffer() ), FALSE, &nXLeft );
s_CompString.CPtoX( int( pcComp - s_CompString.GetBuffer() ), TRUE, &nXRight );
// Check if this character is off the right edge and should
// be wrapped to the next line.
if( nXRight - nXFirst > m_rcText.right - rc.left )
{
// Advance rectangle coordinates to beginning of next line
OffsetRect( &rc, m_rcText.left - rc.left, rc.bottom - rc.top );
// Update the line's first character information
nCharFirst = int( pcComp - s_CompString.GetBuffer() );
s_CompString.CPtoX( nCharFirst, FALSE, &nXFirst );
}
// If the caret is on this character, save the coordinates
// for drawing the caret later.
if( ImeUi_GetImeCursorChars() == ( DWORD )( pcComp - s_CompString.GetBuffer() ) )
{
rcCaret = rc;
rcCaret.left += nXLeft - nXFirst - 1;
rcCaret.right = rcCaret.left + 2;
}
// Set up color based on the character attribute
if( *pAttr == ATTR_TARGET_CONVERTED )
{
pElement->FontColor.Current = m_CompTargetColor;
bkColor = m_CompTargetBkColor;
}
else if( *pAttr == ATTR_TARGET_NOTCONVERTED )
{
pElement->FontColor.Current = m_CompTargetNonColor;
bkColor = m_CompTargetNonBkColor;
}
else
{
continue;
}
RECT rcTarget =
{
rc.left + nXLeft - nXFirst, rc.top, rc.left + nXRight - nXFirst, rc.bottom
};
m_pDialog->DrawRect( &rcTarget, bkColor );
m_pDialog->DrawText( pcComp, pElement, &rcTarget, false, 1 );
// Record the first target converted character's index
if( -1 == s_nFirstTargetConv )
s_nFirstTargetConv = int( pAttr - ImeUi_GetCompStringAttr() );
}
// Render the composition caret
if( m_bCaretOn )
{
// If the caret is at the very end, its position would not have
// been computed in the above loop. We compute it here.
if( ImeUi_GetImeCursorChars() == ( DWORD )s_CompString.GetTextSize() )
{
s_CompString.CPtoX( ImeUi_GetImeCursorChars(), FALSE, &nX );
rcCaret = rc;
rcCaret.left += nX - nXFirst - 1;
rcCaret.right = rcCaret.left + 2;
}
m_pDialog->DrawRect( &rcCaret, m_CompCaretColor );
}
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::RenderIndicator( float fElapsedTime )
{
CDXUTElement* pElement = m_Elements.GetAt( 9 );
pElement->TextureColor.Blend( DXUT_STATE_NORMAL, fElapsedTime );
m_pDialog->DrawSprite( pElement, &m_rcIndicator, DXUT_NEAR_BUTTON_DEPTH );
RECT rc = m_rcIndicator;
InflateRect( &rc, -m_nSpacing, -m_nSpacing );
pElement->FontColor.Current = m_IndicatorImeColor;
RECT rcCalc =
{
0, 0, 0, 0
};
// If IME system is off, draw English indicator.
WCHAR* pwszIndicator = ImeUi_IsEnabled() ? ImeUi_GetIndicatior() : L"En";
m_pDialog->CalcTextRect( pwszIndicator, pElement, &rcCalc );
m_pDialog->DrawText( pwszIndicator, pElement, &rc );
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::Render( float fElapsedTime )
{
if( m_bVisible == false )
return;
// If we have not computed the indicator symbol width,
// do it.
if( !m_nIndicatorWidth )
{
RECT rc =
{
0, 0, 0, 0
};
m_pDialog->CalcTextRect( L"En", m_Elements.GetAt( 9 ), &rc );
m_nIndicatorWidth = rc.right - rc.left;
// Update the rectangles now that we have the indicator's width
UpdateRects();
}
// Let the parent render first (edit control)
CDXUTEditBox::Render( fElapsedTime );
CDXUTElement* pElement = GetElement( 1 );
if( pElement )
{
s_CompString.SetFontNode( m_pDialog->GetFont( pElement->iFont ) );
s_CandList.HoriCand.SetFontNode( m_pDialog->GetFont( pElement->iFont ) );
}
//
// Now render the IME elements
//
ImeUi_RenderUI();
if( m_bHasFocus )
{
// Render the input locale indicator
RenderIndicator( fElapsedTime );
// Display the composition string.
// This method should also update s_ptCompString
// for RenderCandidateReadingWindow.
RenderComposition( fElapsedTime );
// Display the reading/candidate window. RenderCandidateReadingWindow()
// uses s_ptCompString to position itself. s_ptCompString must have
// been filled in by RenderComposition().
if( ImeUi_IsShowReadingWindow() )
// Reading window
RenderCandidateReadingWindow( fElapsedTime, true );
else if( ImeUi_IsShowCandListWindow() )
// Candidate list window
RenderCandidateReadingWindow( fElapsedTime, false );
}
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::SetImeEnableFlag( bool bFlag )
{
s_bImeFlag = bFlag;
}
//--------------------------------------------------------------------------------------
void CDXUTIMEEditBox::Initialize( HWND hWnd )
{
ImeUiCallback_DrawRect = NULL;
ImeUiCallback_Malloc = malloc;
ImeUiCallback_Free = free;
ImeUiCallback_DrawFans = NULL;
ImeUi_Initialize( hWnd );
s_CompString.SetBufferSize( MAX_COMPSTRING_SIZE );
ImeUi_EnableIme( true );
}

141
Demos/DX11ClothDemo/DXUT/Optional/DXUTguiIME.h Normal file
View File

@@ -0,0 +1,141 @@
//--------------------------------------------------------------------------------------
// File: DXUTguiIME.h
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//--------------------------------------------------------------------------------------
#pragma once
#ifndef DXUT_IME_H
#define DXUT_IME_H
#include <usp10.h>
#include <dimm.h>
#include <ImeUi.h>
//--------------------------------------------------------------------------------------
// Forward declarations
//--------------------------------------------------------------------------------------
class CDXUTIMEEditBox;
//-----------------------------------------------------------------------------
// IME-enabled EditBox control
//-----------------------------------------------------------------------------
#define MAX_COMPSTRING_SIZE 256
class CDXUTIMEEditBox : public CDXUTEditBox
{
public:
static HRESULT CreateIMEEditBox( CDXUTDialog* pDialog, int ID, LPCWSTR strText, int x, int y, int width,
int height, bool bIsDefault=false, CDXUTIMEEditBox** ppCreated=NULL );
CDXUTIMEEditBox( CDXUTDialog* pDialog = NULL );
virtual ~CDXUTIMEEditBox();
static void InitDefaultElements( CDXUTDialog* pDialog );
static void WINAPI Initialize( HWND hWnd );
static void WINAPI Uninitialize();
static HRESULT WINAPI StaticOnCreateDevice();
static bool WINAPI StaticMsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
static void WINAPI SetImeEnableFlag( bool bFlag );
virtual void Render( float fElapsedTime );
virtual bool MsgProc( UINT uMsg, WPARAM wParam, LPARAM lParam );
virtual bool HandleMouse( UINT uMsg, POINT pt, WPARAM wParam, LPARAM lParam );
virtual void UpdateRects();
virtual void OnFocusIn();
virtual void OnFocusOut();
void PumpMessage();
virtual void RenderCandidateReadingWindow( float fElapsedTime, bool bReading );
virtual void RenderComposition( float fElapsedTime );
virtual void RenderIndicator( float fElapsedTime );
protected:
static void WINAPI EnableImeSystem( bool bEnable );
static WORD WINAPI GetLanguage()
{
return ImeUi_GetLanguage();
}
static WORD WINAPI GetPrimaryLanguage()
{
return ImeUi_GetPrimaryLanguage();
}
static void WINAPI SendKey( BYTE nVirtKey );
static DWORD WINAPI GetImeId( UINT uIndex = 0 )
{
return ImeUi_GetImeId( uIndex );
};
static void WINAPI CheckInputLocale();
static void WINAPI CheckToggleState();
static void WINAPI SetupImeApi();
static void WINAPI ResetCompositionString();
static void SetupImeUiCallback();
protected:
enum
{
INDICATOR_NON_IME,
INDICATOR_CHS,
INDICATOR_CHT,
INDICATOR_KOREAN,
INDICATOR_JAPANESE
};
struct CCandList
{
CUniBuffer HoriCand; // Candidate list string (for horizontal candidate window)
int nFirstSelected; // First character position of the selected string in HoriCand
int nHoriSelectedLen; // Length of the selected string in HoriCand
RECT rcCandidate; // Candidate rectangle computed and filled each time before rendered
};
static POINT s_ptCompString; // Composition string position. Updated every frame.
static int s_nFirstTargetConv; // Index of the first target converted char in comp string. If none, -1.
static CUniBuffer s_CompString; // Buffer to hold the composition string (we fix its length)
static DWORD s_adwCompStringClause[MAX_COMPSTRING_SIZE];
static CCandList s_CandList; // Data relevant to the candidate list
static WCHAR s_wszReadingString[32];// Used only with horizontal reading window (why?)
static bool s_bImeFlag; // Is ime enabled
// Color of various IME elements
D3DCOLOR m_ReadingColor; // Reading string color
D3DCOLOR m_ReadingWinColor; // Reading window color
D3DCOLOR m_ReadingSelColor; // Selected character in reading string
D3DCOLOR m_ReadingSelBkColor; // Background color for selected char in reading str
D3DCOLOR m_CandidateColor; // Candidate string color
D3DCOLOR m_CandidateWinColor; // Candidate window color
D3DCOLOR m_CandidateSelColor; // Selected candidate string color
D3DCOLOR m_CandidateSelBkColor; // Selected candidate background color
D3DCOLOR m_CompColor; // Composition string color
D3DCOLOR m_CompWinColor; // Composition string window color
D3DCOLOR m_CompCaretColor; // Composition string caret color
D3DCOLOR m_CompTargetColor; // Composition string target converted color
D3DCOLOR m_CompTargetBkColor; // Composition string target converted background
D3DCOLOR m_CompTargetNonColor; // Composition string target non-converted color
D3DCOLOR m_CompTargetNonBkColor;// Composition string target non-converted background
D3DCOLOR m_IndicatorImeColor; // Indicator text color for IME
D3DCOLOR m_IndicatorEngColor; // Indicator text color for English
D3DCOLOR m_IndicatorBkColor; // Indicator text background color
// Edit-control-specific data
int m_nIndicatorWidth; // Width of the indicator symbol
RECT m_rcIndicator; // Rectangle for drawing the indicator button
#if defined(DEBUG) || defined(_DEBUG)
static bool m_bIMEStaticMsgProcCalled;
#endif
};
#endif // DXUT_IME_H

8338
Demos/DX11ClothDemo/DXUT/Optional/DXUTres.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

18
Demos/DX11ClothDemo/DXUT/Optional/DXUTres.h Normal file
View File

@@ -0,0 +1,18 @@
//----------------------------------------------------------------------------
// File: dxutres.h
//
// Functions to create DXUT media from arrays in memory
//
// Copyright (c) Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#pragma once
#ifndef DXUT_RES_H
#define DXUT_RES_H
HRESULT WINAPI DXUTCreateGUITextureFromInternalArray9( LPDIRECT3DDEVICE9 pd3dDevice, IDirect3DTexture9** ppTexture,
D3DXIMAGE_INFO* pInfo );
HRESULT WINAPI DXUTCreateGUITextureFromInternalArray11( ID3D11Device* pd3dDevice, ID3D11Texture2D** ppTexture,
D3DX11_IMAGE_INFO* pInfo );
HRESULT WINAPI DXUTCreateArrowMeshFromInternalArray( LPDIRECT3DDEVICE9 pd3dDevice, ID3DXMesh** ppMesh );
#endif

2853
Demos/DX11ClothDemo/DXUT/Optional/DXUTsettingsdlg.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

248
Demos/DX11ClothDemo/DXUT/Optional/DXUTsettingsdlg.h Normal file
View File

@@ -0,0 +1,248 @@
//--------------------------------------------------------------------------------------
// File: DXUTSettingsDlg.cpp
//
// Copyright (c) Microsoft Corporation. All rights reserved
//--------------------------------------------------------------------------------------
#pragma once
#ifndef DXUT_SETTINGS_H
#define DXUT_SETTINGS_H
//--------------------------------------------------------------------------------------
// Header Includes
//--------------------------------------------------------------------------------------
#include "DXUTgui.h"
//--------------------------------------------------------------------------------------
// Control IDs
//--------------------------------------------------------------------------------------
#define DXUTSETTINGSDLG_STATIC -1
#define DXUTSETTINGSDLG_OK 1
#define DXUTSETTINGSDLG_CANCEL 2
#define DXUTSETTINGSDLG_ADAPTER 3
#define DXUTSETTINGSDLG_DEVICE_TYPE 4
#define DXUTSETTINGSDLG_WINDOWED 5
#define DXUTSETTINGSDLG_FULLSCREEN 6
#define DXUTSETTINGSDLG_ADAPTER_FORMAT 7
#define DXUTSETTINGSDLG_ADAPTER_FORMAT_LABEL 8
#define DXUTSETTINGSDLG_RESOLUTION 9
#define DXUTSETTINGSDLG_RESOLUTION_LABEL 10
#define DXUTSETTINGSDLG_REFRESH_RATE 11
#define DXUTSETTINGSDLG_REFRESH_RATE_LABEL 12
#define DXUTSETTINGSDLG_BACK_BUFFER_FORMAT 13
#define DXUTSETTINGSDLG_BACK_BUFFER_FORMAT_LABEL 14
#define DXUTSETTINGSDLG_DEPTH_STENCIL 15
#define DXUTSETTINGSDLG_DEPTH_STENCIL_LABEL 16
#define DXUTSETTINGSDLG_MULTISAMPLE_TYPE 17
#define DXUTSETTINGSDLG_MULTISAMPLE_TYPE_LABEL 18
#define DXUTSETTINGSDLG_MULTISAMPLE_QUALITY 19
#define DXUTSETTINGSDLG_MULTISAMPLE_QUALITY_LABEL 20
#define DXUTSETTINGSDLG_VERTEX_PROCESSING 21
#define DXUTSETTINGSDLG_VERTEX_PROCESSING_LABEL 22
#define DXUTSETTINGSDLG_PRESENT_INTERVAL 23
#define DXUTSETTINGSDLG_PRESENT_INTERVAL_LABEL 24
#define DXUTSETTINGSDLG_DEVICECLIP 25
#define DXUTSETTINGSDLG_RESOLUTION_SHOW_ALL 26
#define DXUTSETTINGSDLG_API_VERSION 27
#define DXUTSETTINGSDLG_D3D11_ADAPTER_OUTPUT 28
#define DXUTSETTINGSDLG_D3D11_ADAPTER_OUTPUT_LABEL 29
#define DXUTSETTINGSDLG_D3D11_RESOLUTION 30
#define DXUTSETTINGSDLG_D3D11_RESOLUTION_LABEL 31
#define DXUTSETTINGSDLG_D3D11_REFRESH_RATE 32
#define DXUTSETTINGSDLG_D3D11_REFRESH_RATE_LABEL 33
#define DXUTSETTINGSDLG_D3D11_BACK_BUFFER_FORMAT 34
#define DXUTSETTINGSDLG_D3D11_BACK_BUFFER_FORMAT_LABEL 35
#define DXUTSETTINGSDLG_D3D11_MULTISAMPLE_COUNT 36
#define DXUTSETTINGSDLG_D3D11_MULTISAMPLE_COUNT_LABEL 37
#define DXUTSETTINGSDLG_D3D11_MULTISAMPLE_QUALITY 38
#define DXUTSETTINGSDLG_D3D11_MULTISAMPLE_QUALITY_LABEL 39
#define DXUTSETTINGSDLG_D3D11_PRESENT_INTERVAL 40
#define DXUTSETTINGSDLG_D3D11_PRESENT_INTERVAL_LABEL 41
#define DXUTSETTINGSDLG_D3D11_DEBUG_DEVICE 42
#define DXUTSETTINGSDLG_D3D11_FEATURE_LEVEL 43
#define DXUTSETTINGSDLG_D3D11_FEATURE_LEVEL_LABEL 44
#define DXUTSETTINGSDLG_MODE_CHANGE_ACCEPT 58
#define DXUTSETTINGSDLG_MODE_CHANGE_REVERT 59
#define DXUTSETTINGSDLG_STATIC_MODE_CHANGE_TIMEOUT 60
#define DXUTSETTINGSDLG_WINDOWED_GROUP 0x0100
#define TOTAL_FEATURE_LEVLES 6
//--------------------------------------------------------------------------------------
// Dialog for selection of device settings
// Use DXUTGetD3DSettingsDialog() to access global instance
// To control the contents of the dialog, use the CD3D9Enumeration class.
//--------------------------------------------------------------------------------------
class CD3DSettingsDlg
{
public:
CD3DSettingsDlg();
~CD3DSettingsDlg();
void Init( CDXUTDialogResourceManager* pManager );
void Init( CDXUTDialogResourceManager* pManager, LPCWSTR szControlTextureFileName );
void Init( CDXUTDialogResourceManager* pManager, LPCWSTR pszControlTextureResourcename,
HMODULE hModule );
HRESULT Refresh();
void OnRender( float fElapsedTime );
void OnRender9( float fElapsedTime );
void OnRender10( float fElapsedTime );
void OnRender11( float fElapsedTime );
HRESULT OnD3D9CreateDevice( IDirect3DDevice9* pd3dDevice );
HRESULT OnD3D9ResetDevice();
void OnD3D9LostDevice();
void OnD3D9DestroyDevice();
HRESULT OnD3D11CreateDevice( ID3D11Device* pd3dDevice );
HRESULT OnD3D11ResizedSwapChain( ID3D11Device* pd3dDevice,
const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc );
void OnD3D11DestroyDevice();
CDXUTDialog* GetDialogControl()
{
return &m_Dialog;
}
bool IsActive()
{
return m_bActive;
}
void SetActive( bool bActive )
{
m_bActive = bActive; if( bActive ) Refresh();
}
void ShowControlSet( DXUTDeviceVersion ver );
LRESULT MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
protected:
friend CD3DSettingsDlg* WINAPI DXUTGetD3DSettingsDialog();
void CreateControls();
HRESULT SetDeviceSettingsFromUI();
void SetSelectedD3D11RefreshRate( DXGI_RATIONAL RefreshRate );
HRESULT UpdateD3D11Resolutions();
void OnEvent( UINT nEvent, int nControlID, CDXUTControl* pControl );
static void WINAPI StaticOnEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserData );
static void WINAPI StaticOnModeChangeTimer( UINT nIDEvent, void* pUserContext );
CD3D9EnumAdapterInfo* GetCurrentAdapterInfo();
CD3D9EnumDeviceInfo* GetCurrentDeviceInfo();
CD3D9EnumDeviceSettingsCombo* GetCurrentDeviceSettingsCombo();
CD3D11EnumAdapterInfo* GetCurrentD3D11AdapterInfo();
CD3D11EnumDeviceInfo* GetCurrentD3D11DeviceInfo();
CD3D11EnumOutputInfo* GetCurrentD3D11OutputInfo();
CD3D11EnumDeviceSettingsCombo* GetCurrentD3D11DeviceSettingsCombo();
void AddAPIVersion( DXUTDeviceVersion version );
DXUTDeviceVersion GetSelectedAPIVersion();
void AddAdapter( const WCHAR* strDescription, UINT iAdapter );
UINT GetSelectedAdapter();
void AddDeviceType( D3DDEVTYPE devType );
D3DDEVTYPE GetSelectedDeviceType();
void SetWindowed( bool bWindowed );
bool IsWindowed();
void AddAdapterFormat( D3DFORMAT format );
D3DFORMAT GetSelectedAdapterFormat();
void AddResolution( DWORD dwWidth, DWORD dwHeight );
void GetSelectedResolution( DWORD* pdwWidth, DWORD* pdwHeight );
void AddRefreshRate( DWORD dwRate );
DWORD GetSelectedRefreshRate();
void AddBackBufferFormat( D3DFORMAT format );
D3DFORMAT GetSelectedBackBufferFormat();
void AddDepthStencilBufferFormat( D3DFORMAT format );
D3DFORMAT GetSelectedDepthStencilBufferFormat();
void AddMultisampleType( D3DMULTISAMPLE_TYPE type );
D3DMULTISAMPLE_TYPE GetSelectedMultisampleType();
void AddMultisampleQuality( DWORD dwQuality );
DWORD GetSelectedMultisampleQuality();
void AddVertexProcessingType( DWORD dwType );
DWORD GetSelectedVertexProcessingType();
DWORD GetSelectedPresentInterval();
void SetDeviceClip( bool bDeviceClip );
bool IsDeviceClip();
// D3D11
void AddD3D11DeviceType( D3D_DRIVER_TYPE devType );
D3D_DRIVER_TYPE GetSelectedD3D11DeviceType();
void AddD3D11AdapterOutput( const WCHAR* strName, UINT nOutput );
UINT GetSelectedD3D11AdapterOutput();
void AddD3D11Resolution( DWORD dwWidth, DWORD dwHeight );
void GetSelectedD3D11Resolution( DWORD* pdwWidth, DWORD* pdwHeight );
void AddD3D11FeatureLevel(D3D_FEATURE_LEVEL);
D3D_FEATURE_LEVEL GetSelectedFeatureLevel();
void AddD3D11RefreshRate( DXGI_RATIONAL RefreshRate );
DXGI_RATIONAL GetSelectedD3D11RefreshRate();
void AddD3D11BackBufferFormat( DXGI_FORMAT format );
DXGI_FORMAT GetSelectedD3D11BackBufferFormat();
void AddD3D11MultisampleCount( UINT count );
UINT GetSelectedD3D11MultisampleCount();
void AddD3D11MultisampleQuality( UINT Quality );
UINT GetSelectedD3D11MultisampleQuality();
DWORD GetSelectedD3D11PresentInterval();
bool GetSelectedDebugDeviceValue();
HRESULT OnD3D11ResolutionChanged ();
HRESULT OnAPIVersionChanged( bool bRefresh=false );
HRESULT OnFeatureLevelChanged();
HRESULT OnAdapterChanged();
HRESULT OnDeviceTypeChanged();
HRESULT OnWindowedFullScreenChanged();
HRESULT OnAdapterOutputChanged();
HRESULT OnAdapterFormatChanged();
HRESULT OnResolutionChanged();
HRESULT OnRefreshRateChanged();
HRESULT OnBackBufferFormatChanged();
HRESULT OnDepthStencilBufferFormatChanged();
HRESULT OnMultisampleTypeChanged();
HRESULT OnMultisampleQualityChanged();
HRESULT OnVertexProcessingChanged();
HRESULT OnPresentIntervalChanged();
HRESULT OnDebugDeviceChanged();
HRESULT OnDeviceClipChanged();
void UpdateModeChangeTimeoutText( int nSecRemaining );
IDirect3DStateBlock9* m_pStateBlock;
CDXUTDialog* m_pActiveDialog;
CDXUTDialog m_Dialog;
CDXUTDialog m_RevertModeDialog;
int m_nRevertModeTimeout;
UINT m_nIDEvent;
bool m_bActive;
D3D_FEATURE_LEVEL m_Levels[TOTAL_FEATURE_LEVLES];
};
CD3DSettingsDlg* WINAPI DXUTGetD3DSettingsDialog();
#endif

3662
Demos/DX11ClothDemo/DXUT/Optional/ImeUi.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

124
Demos/DX11ClothDemo/DXUT/Optional/ImeUi.h Normal file
View File

@@ -0,0 +1,124 @@
//--------------------------------------------------------------------------------------
// File: ImeUi.h
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//--------------------------------------------------------------------------------------
#ifndef _IMEUI_H_
#define _IMEUI_H_
#if _WIN32_WINNT < 0x0400
#error IMEUI requires _WIN32_WINNT to be 0x0400 or higher. Please add "_WIN32_WINNT=0x0400" to your project's preprocessor setting.
#endif
#include <windows.h>
class CImeUiFont_Base
{
public:
virtual void SetHeight( UINT uHeight )
{
uHeight;
}; // for backward compatibility
virtual void SetColor( DWORD color ) = 0;
virtual void SetPosition( int x, int y ) = 0;
virtual void GetTextExtent( LPCTSTR szText, DWORD* puWidth, DWORD* puHeight ) = 0;
virtual void DrawText( LPCTSTR pszText ) = 0;
};
typedef struct
{
// symbol (Henkan-kyu)
DWORD symbolColor;
DWORD symbolColorOff;
DWORD symbolColorText;
BYTE symbolHeight;
BYTE symbolTranslucence;
BYTE symbolPlacement;
CImeUiFont_Base* symbolFont;
// candidate list
DWORD candColorBase;
DWORD candColorBorder;
DWORD candColorText;
// composition string
DWORD compColorInput;
DWORD compColorTargetConv;
DWORD compColorConverted;
DWORD compColorTargetNotConv;
DWORD compColorInputErr;
BYTE compTranslucence;
DWORD compColorText;
// caret
BYTE caretWidth;
BYTE caretYMargin;
} IMEUI_APPEARANCE;
typedef struct // D3DTLVERTEX compatible
{
float sx;
float sy;
float sz;
float rhw;
DWORD color;
DWORD specular;
float tu;
float tv;
} IMEUI_VERTEX;
// IME States
#define IMEUI_STATE_OFF 0
#define IMEUI_STATE_ON 1
#define IMEUI_STATE_ENGLISH 2
// IME const
#define MAX_CANDLIST 10
// IME Flags
#define IMEUI_FLAG_SUPPORT_CARET 0x00000001
bool ImeUi_Initialize( HWND hwnd, bool bDisable = false );
void ImeUi_Uninitialize();
void ImeUi_SetAppearance( const IMEUI_APPEARANCE* pia );
void ImeUi_GetAppearance( IMEUI_APPEARANCE* pia );
bool ImeUi_IgnoreHotKey( const MSG* pmsg );
LPARAM ImeUi_ProcessMessage( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM& lParam, bool* trapped );
void ImeUi_SetScreenDimension( UINT width, UINT height );
void ImeUi_RenderUI( bool bDrawCompAttr = true, bool bDrawOtherUi = true );
void ImeUi_SetCaretPosition( UINT x, UINT y );
void ImeUi_SetCompStringAppearance( CImeUiFont_Base* pFont, DWORD color, const RECT* prc );
bool ImeUi_GetCaretStatus();
void ImeUi_SetInsertMode( bool bInsert );
void ImeUi_SetState( DWORD dwState );
DWORD ImeUi_GetState();
void ImeUi_EnableIme( bool bEnable );
bool ImeUi_IsEnabled( void );
void ImeUi_FinalizeString( bool bSend = false );
void ImeUi_ToggleLanguageBar( BOOL bRestore );
bool ImeUi_IsSendingKeyMessage();
void ImeUi_SetWindow( HWND hwnd );
UINT ImeUi_GetInputCodePage();
DWORD ImeUi_GetFlags();
void ImeUi_SetFlags( DWORD dwFlags, bool bSet );
WORD ImeUi_GetPrimaryLanguage();
DWORD ImeUi_GetImeId( UINT uIndex );
WORD ImeUi_GetLanguage();
LPTSTR ImeUi_GetIndicatior();
bool ImeUi_IsShowReadingWindow();
bool ImeUi_IsShowCandListWindow();
bool ImeUi_IsVerticalCand();
bool ImeUi_IsHorizontalReading();
TCHAR* ImeUi_GetCandidate( UINT idx );
TCHAR* ImeUi_GetCompositionString();
DWORD ImeUi_GetCandidateSelection();
DWORD ImeUi_GetCandidateCount();
BYTE* ImeUi_GetCompStringAttr();
DWORD ImeUi_GetImeCursorChars();
extern void ( CALLBACK*ImeUiCallback_DrawRect )( int x1, int y1, int x2, int y2, DWORD color );
extern void* ( __cdecl*ImeUiCallback_Malloc )( size_t bytes );
extern void ( __cdecl*ImeUiCallback_Free )( void* ptr );
extern void ( CALLBACK*ImeUiCallback_DrawFans )( const IMEUI_VERTEX* paVertex, UINT uNum );
extern void ( CALLBACK*ImeUiCallback_OnChar )( WCHAR wc );
#endif //_IMEUI_H_

2348
Demos/DX11ClothDemo/DXUT/Optional/SDKmesh.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

589
Demos/DX11ClothDemo/DXUT/Optional/SDKmesh.h Normal file
View File

@@ -0,0 +1,589 @@
//--------------------------------------------------------------------------------------
// File: SDKMesh.h
//
// Disclaimer:
// The SDK Mesh format (.sdkmesh) is not a recommended file format for shipping titles.
// It was designed to meet the specific needs of the SDK samples. Any real-world
// applications should avoid this file format in favor of a destination format that
// meets the specific needs of the application.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//--------------------------------------------------------------------------------------
#pragma once
#ifndef _SDKMESH_
#define _SDKMESH_
//--------------------------------------------------------------------------------------
// Hard Defines for the various structures
//--------------------------------------------------------------------------------------
#define SDKMESH_FILE_VERSION 101
#define MAX_VERTEX_ELEMENTS 32
#define MAX_VERTEX_STREAMS 16
#define MAX_FRAME_NAME 100
#define MAX_MESH_NAME 100
#define MAX_SUBSET_NAME 100
#define MAX_MATERIAL_NAME 100
#define MAX_TEXTURE_NAME MAX_PATH
#define MAX_MATERIAL_PATH MAX_PATH
#define INVALID_FRAME ((UINT)-1)
#define INVALID_MESH ((UINT)-1)
#define INVALID_MATERIAL ((UINT)-1)
#define INVALID_SUBSET ((UINT)-1)
#define INVALID_ANIMATION_DATA ((UINT)-1)
#define INVALID_SAMPLER_SLOT ((UINT)-1)
#define ERROR_RESOURCE_VALUE 1
template<typename TYPE> BOOL IsErrorResource( TYPE data )
{
if( ( TYPE )ERROR_RESOURCE_VALUE == data )
return TRUE;
return FALSE;
}
//--------------------------------------------------------------------------------------
// Enumerated Types. These will have mirrors in both D3D9 and D3D11
//--------------------------------------------------------------------------------------
enum SDKMESH_PRIMITIVE_TYPE
{
PT_TRIANGLE_LIST = 0,
PT_TRIANGLE_STRIP,
PT_LINE_LIST,
PT_LINE_STRIP,
PT_POINT_LIST,
PT_TRIANGLE_LIST_ADJ,
PT_TRIANGLE_STRIP_ADJ,
PT_LINE_LIST_ADJ,
PT_LINE_STRIP_ADJ,
PT_QUAD_PATCH_LIST,
PT_TRIANGLE_PATCH_LIST,
};
enum SDKMESH_INDEX_TYPE
{
IT_16BIT = 0,
IT_32BIT,
};
enum FRAME_TRANSFORM_TYPE
{
FTT_RELATIVE = 0,
FTT_ABSOLUTE, //This is not currently used but is here to support absolute transformations in the future
};
//--------------------------------------------------------------------------------------
// Structures. Unions with pointers are forced to 64bit.
//--------------------------------------------------------------------------------------
struct SDKMESH_HEADER
{
//Basic Info and sizes
UINT Version;
BYTE IsBigEndian;
UINT64 HeaderSize;
UINT64 NonBufferDataSize;
UINT64 BufferDataSize;
//Stats
UINT NumVertexBuffers;
UINT NumIndexBuffers;
UINT NumMeshes;
UINT NumTotalSubsets;
UINT NumFrames;
UINT NumMaterials;
//Offsets to Data
UINT64 VertexStreamHeadersOffset;
UINT64 IndexStreamHeadersOffset;
UINT64 MeshDataOffset;
UINT64 SubsetDataOffset;
UINT64 FrameDataOffset;
UINT64 MaterialDataOffset;
};
struct SDKMESH_VERTEX_BUFFER_HEADER
{
UINT64 NumVertices;
UINT64 SizeBytes;
UINT64 StrideBytes;
D3DVERTEXELEMENT9 Decl[MAX_VERTEX_ELEMENTS];
union
{
UINT64 DataOffset; //(This also forces the union to 64bits)
IDirect3DVertexBuffer9* pVB9;
ID3D11Buffer* pVB11;
};
};
struct SDKMESH_INDEX_BUFFER_HEADER
{
UINT64 NumIndices;
UINT64 SizeBytes;
UINT IndexType;
union
{
UINT64 DataOffset; //(This also forces the union to 64bits)
IDirect3DIndexBuffer9* pIB9;
ID3D11Buffer* pIB11;
};
};
struct SDKMESH_MESH
{
char Name[MAX_MESH_NAME];
BYTE NumVertexBuffers;
UINT VertexBuffers[MAX_VERTEX_STREAMS];
UINT IndexBuffer;
UINT NumSubsets;
UINT NumFrameInfluences; //aka bones
D3DXVECTOR3 BoundingBoxCenter;
D3DXVECTOR3 BoundingBoxExtents;
union
{
UINT64 SubsetOffset; //Offset to list of subsets (This also forces the union to 64bits)
UINT* pSubsets; //Pointer to list of subsets
};
union
{
UINT64 FrameInfluenceOffset; //Offset to list of frame influences (This also forces the union to 64bits)
UINT* pFrameInfluences; //Pointer to list of frame influences
};
};
struct SDKMESH_SUBSET
{
char Name[MAX_SUBSET_NAME];
UINT MaterialID;
UINT PrimitiveType;
UINT64 IndexStart;
UINT64 IndexCount;
UINT64 VertexStart;
UINT64 VertexCount;
};
struct SDKMESH_FRAME
{
char Name[MAX_FRAME_NAME];
UINT Mesh;
UINT ParentFrame;
UINT ChildFrame;
UINT SiblingFrame;
D3DXMATRIX Matrix;
UINT AnimationDataIndex; //Used to index which set of keyframes transforms this frame
};
struct SDKMESH_MATERIAL
{
char Name[MAX_MATERIAL_NAME];
// Use MaterialInstancePath
char MaterialInstancePath[MAX_MATERIAL_PATH];
// Or fall back to d3d8-type materials
char DiffuseTexture[MAX_TEXTURE_NAME];
char NormalTexture[MAX_TEXTURE_NAME];
char SpecularTexture[MAX_TEXTURE_NAME];
D3DXVECTOR4 Diffuse;
D3DXVECTOR4 Ambient;
D3DXVECTOR4 Specular;
D3DXVECTOR4 Emissive;
FLOAT Power;
union
{
UINT64 Force64_1; //Force the union to 64bits
IDirect3DTexture9* pDiffuseTexture9;
ID3D11Texture2D* pDiffuseTexture11;
};
union
{
UINT64 Force64_2; //Force the union to 64bits
IDirect3DTexture9* pNormalTexture9;
ID3D11Texture2D* pNormalTexture11;
};
union
{
UINT64 Force64_3; //Force the union to 64bits
IDirect3DTexture9* pSpecularTexture9;
ID3D11Texture2D* pSpecularTexture11;
};
union
{
UINT64 Force64_4; //Force the union to 64bits
ID3D11ShaderResourceView* pDiffuseRV11;
};
union
{
UINT64 Force64_5; //Force the union to 64bits
ID3D11ShaderResourceView* pNormalRV11;
};
union
{
UINT64 Force64_6; //Force the union to 64bits
ID3D11ShaderResourceView* pSpecularRV11;
};
};
struct SDKANIMATION_FILE_HEADER
{
UINT Version;
BYTE IsBigEndian;
UINT FrameTransformType;
UINT NumFrames;
UINT NumAnimationKeys;
UINT AnimationFPS;
UINT64 AnimationDataSize;
UINT64 AnimationDataOffset;
};
struct SDKANIMATION_DATA
{
D3DXVECTOR3 Translation;
D3DXVECTOR4 Orientation;
D3DXVECTOR3 Scaling;
};
struct SDKANIMATION_FRAME_DATA
{
char FrameName[MAX_FRAME_NAME];
union
{
UINT64 DataOffset;
SDKANIMATION_DATA* pAnimationData;
};
};
#ifndef _CONVERTER_APP_
//--------------------------------------------------------------------------------------
// AsyncLoading callbacks
//--------------------------------------------------------------------------------------
typedef void ( CALLBACK*LPCREATETEXTUREFROMFILE9 )( IDirect3DDevice9* pDev, char* szFileName,
IDirect3DTexture9** ppTexture, void* pContext );
typedef void ( CALLBACK*LPCREATEVERTEXBUFFER9 )( IDirect3DDevice9* pDev, IDirect3DVertexBuffer9** ppBuffer,
UINT iSizeBytes, DWORD Usage, DWORD FVF, D3DPOOL Pool, void* pData,
void* pContext );
typedef void ( CALLBACK*LPCREATEINDEXBUFFER9 )( IDirect3DDevice9* pDev, IDirect3DIndexBuffer9** ppBuffer,
UINT iSizeBytes, DWORD Usage, D3DFORMAT ibFormat, D3DPOOL Pool,
void* pData, void* pContext );
struct SDKMESH_CALLBACKS9
{
LPCREATETEXTUREFROMFILE9 pCreateTextureFromFile;
LPCREATEVERTEXBUFFER9 pCreateVertexBuffer;
LPCREATEINDEXBUFFER9 pCreateIndexBuffer;
void* pContext;
};
typedef void ( CALLBACK*LPCREATETEXTUREFROMFILE11 )( ID3D11Device* pDev, char* szFileName,
ID3D11ShaderResourceView** ppRV, void* pContext );
typedef void ( CALLBACK*LPCREATEVERTEXBUFFER11 )( ID3D11Device* pDev, ID3D11Buffer** ppBuffer,
D3D11_BUFFER_DESC BufferDesc, void* pData, void* pContext );
typedef void ( CALLBACK*LPCREATEINDEXBUFFER11 )( ID3D11Device* pDev, ID3D11Buffer** ppBuffer,
D3D11_BUFFER_DESC BufferDesc, void* pData, void* pContext );
struct SDKMESH_CALLBACKS11
{
LPCREATETEXTUREFROMFILE11 pCreateTextureFromFile;
LPCREATEVERTEXBUFFER11 pCreateVertexBuffer;
LPCREATEINDEXBUFFER11 pCreateIndexBuffer;
void* pContext;
};
//--------------------------------------------------------------------------------------
// CDXUTSDKMesh class. This class reads the sdkmesh file format for use by the samples
//--------------------------------------------------------------------------------------
class CDXUTSDKMesh
{
private:
UINT m_NumOutstandingResources;
bool m_bLoading;
//BYTE* m_pBufferData;
HANDLE m_hFile;
HANDLE m_hFileMappingObject;
CGrowableArray <BYTE*> m_MappedPointers;
IDirect3DDevice9* m_pDev9;
ID3D11Device* m_pDev11;
ID3D11DeviceContext* m_pDevContext11;
protected:
//These are the pointers to the two chunks of data loaded in from the mesh file
BYTE* m_pStaticMeshData;
BYTE* m_pHeapData;
BYTE* m_pAnimationData;
BYTE** m_ppVertices;
BYTE** m_ppIndices;
//Keep track of the path
WCHAR m_strPathW[MAX_PATH];
char m_strPath[MAX_PATH];
//General mesh info
SDKMESH_HEADER* m_pMeshHeader;
SDKMESH_VERTEX_BUFFER_HEADER* m_pVertexBufferArray;
SDKMESH_INDEX_BUFFER_HEADER* m_pIndexBufferArray;
SDKMESH_MESH* m_pMeshArray;
SDKMESH_SUBSET* m_pSubsetArray;
SDKMESH_FRAME* m_pFrameArray;
SDKMESH_MATERIAL* m_pMaterialArray;
// Adjacency information (not part of the m_pStaticMeshData, so it must be created and destroyed separately )
SDKMESH_INDEX_BUFFER_HEADER* m_pAdjacencyIndexBufferArray;
//Animation (TODO: Add ability to load/track multiple animation sets)
SDKANIMATION_FILE_HEADER* m_pAnimationHeader;
SDKANIMATION_FRAME_DATA* m_pAnimationFrameData;
D3DXMATRIX* m_pBindPoseFrameMatrices;
D3DXMATRIX* m_pTransformedFrameMatrices;
D3DXMATRIX* m_pWorldPoseFrameMatrices;
protected:
void LoadMaterials( ID3D11Device* pd3dDevice, SDKMESH_MATERIAL* pMaterials,
UINT NumMaterials, SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );
void LoadMaterials( IDirect3DDevice9* pd3dDevice, SDKMESH_MATERIAL* pMaterials,
UINT NumMaterials, SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );
HRESULT CreateVertexBuffer( ID3D11Device* pd3dDevice,
SDKMESH_VERTEX_BUFFER_HEADER* pHeader, void* pVertices,
SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );
HRESULT CreateVertexBuffer( IDirect3DDevice9* pd3dDevice,
SDKMESH_VERTEX_BUFFER_HEADER* pHeader, void* pVertices,
SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );
HRESULT CreateIndexBuffer( ID3D11Device* pd3dDevice, SDKMESH_INDEX_BUFFER_HEADER* pHeader,
void* pIndices, SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );
HRESULT CreateIndexBuffer( IDirect3DDevice9* pd3dDevice,
SDKMESH_INDEX_BUFFER_HEADER* pHeader, void* pIndices,
SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );
virtual HRESULT CreateFromFile( ID3D11Device* pDev11,
IDirect3DDevice9* pDev9,
LPCTSTR szFileName,
bool bCreateAdjacencyIndices,
SDKMESH_CALLBACKS11* pLoaderCallbacks11 = NULL,
SDKMESH_CALLBACKS9* pLoaderCallbacks9 = NULL );
virtual HRESULT CreateFromMemory( ID3D11Device* pDev11,
IDirect3DDevice9* pDev9,
BYTE* pData,
UINT DataBytes,
bool bCreateAdjacencyIndices,
bool bCopyStatic,
SDKMESH_CALLBACKS11* pLoaderCallbacks11 = NULL,
SDKMESH_CALLBACKS9* pLoaderCallbacks9 = NULL );
//frame manipulation
void TransformBindPoseFrame( UINT iFrame, D3DXMATRIX* pParentWorld );
void TransformFrame( UINT iFrame, D3DXMATRIX* pParentWorld, double fTime );
void TransformFrameAbsolute( UINT iFrame, double fTime );
//Direct3D 11 rendering helpers
void RenderMesh( UINT iMesh,
bool bAdjacent,
ID3D11DeviceContext* pd3dDeviceContext,
UINT iDiffuseSlot,
UINT iNormalSlot,
UINT iSpecularSlot );
void RenderFrame( UINT iFrame,
bool bAdjacent,
ID3D11DeviceContext* pd3dDeviceContext,
UINT iDiffuseSlot,
UINT iNormalSlot,
UINT iSpecularSlot );
//Direct3D 9 rendering helpers
void RenderMesh( UINT iMesh,
LPDIRECT3DDEVICE9 pd3dDevice,
LPD3DXEFFECT pEffect,
D3DXHANDLE hTechnique,
D3DXHANDLE htxDiffuse,
D3DXHANDLE htxNormal,
D3DXHANDLE htxSpecular );
void RenderFrame( UINT iFrame,
LPDIRECT3DDEVICE9 pd3dDevice,
LPD3DXEFFECT pEffect,
D3DXHANDLE hTechnique,
D3DXHANDLE htxDiffuse,
D3DXHANDLE htxNormal,
D3DXHANDLE htxSpecular );
public:
CDXUTSDKMesh();
virtual ~CDXUTSDKMesh();
virtual HRESULT Create( ID3D11Device* pDev11, LPCTSTR szFileName, bool bCreateAdjacencyIndices=
false, SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );
virtual HRESULT Create( IDirect3DDevice9* pDev9, LPCTSTR szFileName, bool bCreateAdjacencyIndices=
false, SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );
virtual HRESULT Create( ID3D11Device* pDev11, BYTE* pData, UINT DataBytes,
bool bCreateAdjacencyIndices=false, bool bCopyStatic=false,
SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );
virtual HRESULT Create( IDirect3DDevice9* pDev9, BYTE* pData, UINT DataBytes,
bool bCreateAdjacencyIndices=false, bool bCopyStatic=false,
SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );
virtual HRESULT LoadAnimation( WCHAR* szFileName );
virtual void Destroy();
//Frame manipulation
void TransformBindPose( D3DXMATRIX* pWorld );
void TransformMesh( D3DXMATRIX* pWorld, double fTime );
//Direct3D 11 Rendering
virtual void Render( ID3D11DeviceContext* pd3dDeviceContext,
UINT iDiffuseSlot = INVALID_SAMPLER_SLOT,
UINT iNormalSlot = INVALID_SAMPLER_SLOT,
UINT iSpecularSlot = INVALID_SAMPLER_SLOT );
virtual void RenderAdjacent( ID3D11DeviceContext* pd3dDeviceContext,
UINT iDiffuseSlot = INVALID_SAMPLER_SLOT,
UINT iNormalSlot = INVALID_SAMPLER_SLOT,
UINT iSpecularSlot = INVALID_SAMPLER_SLOT );
//Direct3D 9 Rendering
virtual void Render( LPDIRECT3DDEVICE9 pd3dDevice,
LPD3DXEFFECT pEffect,
D3DXHANDLE hTechnique,
D3DXHANDLE htxDiffuse = 0,
D3DXHANDLE htxNormal = 0,
D3DXHANDLE htxSpecular = 0 );
//Helpers (D3D11 specific)
static D3D11_PRIMITIVE_TOPOLOGY GetPrimitiveType11( SDKMESH_PRIMITIVE_TYPE PrimType );
DXGI_FORMAT GetIBFormat11( UINT iMesh );
ID3D11Buffer* GetVB11( UINT iMesh, UINT iVB );
ID3D11Buffer* GetIB11( UINT iMesh );
SDKMESH_INDEX_TYPE GetIndexType( UINT iMesh );
ID3D11Buffer* GetAdjIB11( UINT iMesh );
//Helpers (D3D9 specific)
static D3DPRIMITIVETYPE GetPrimitiveType9( SDKMESH_PRIMITIVE_TYPE PrimType );
D3DFORMAT GetIBFormat9( UINT iMesh );
IDirect3DVertexBuffer9* GetVB9( UINT iMesh, UINT iVB );
IDirect3DIndexBuffer9* GetIB9( UINT iMesh );
//Helpers (general)
char* GetMeshPathA();
WCHAR* GetMeshPathW();
UINT GetNumMeshes();
UINT GetNumMaterials();
UINT GetNumVBs();
UINT GetNumIBs();
ID3D11Buffer* GetVB11At( UINT iVB );
ID3D11Buffer* GetIB11At( UINT iIB );
IDirect3DVertexBuffer9* GetVB9At( UINT iVB );
IDirect3DIndexBuffer9* GetIB9At( UINT iIB );
BYTE* GetRawVerticesAt( UINT iVB );
BYTE* GetRawIndicesAt( UINT iIB );
SDKMESH_MATERIAL* GetMaterial( UINT iMaterial );
SDKMESH_MESH* GetMesh( UINT iMesh );
UINT GetNumSubsets( UINT iMesh );
SDKMESH_SUBSET* GetSubset( UINT iMesh, UINT iSubset );
UINT GetVertexStride( UINT iMesh, UINT iVB );
UINT GetNumFrames();
SDKMESH_FRAME* GetFrame( UINT iFrame );
SDKMESH_FRAME* FindFrame( char* pszName );
UINT64 GetNumVertices( UINT iMesh, UINT iVB );
UINT64 GetNumIndices( UINT iMesh );
D3DXVECTOR3 GetMeshBBoxCenter( UINT iMesh );
D3DXVECTOR3 GetMeshBBoxExtents( UINT iMesh );
UINT GetOutstandingResources();
UINT GetOutstandingBufferResources();
bool CheckLoadDone();
bool IsLoaded();
bool IsLoading();
void SetLoading( bool bLoading );
BOOL HadLoadingError();
//Animation
UINT GetNumInfluences( UINT iMesh );
const D3DXMATRIX* GetMeshInfluenceMatrix( UINT iMesh, UINT iInfluence );
UINT GetAnimationKeyFromTime( double fTime );
const D3DXMATRIX* GetWorldMatrix( UINT iFrameIndex );
const D3DXMATRIX* GetInfluenceMatrix( UINT iFrameIndex );
bool GetAnimationProperties( UINT* pNumKeys, FLOAT* pFrameTime );
};
//-----------------------------------------------------------------------------
// Name: class CDXUTXFileMesh
// Desc: Class for loading and rendering file-based meshes
//-----------------------------------------------------------------------------
class CDXUTXFileMesh
{
public:
WCHAR m_strName[512];
LPD3DXMESH m_pMesh; // Managed mesh
// Cache of data in m_pMesh for easy access
IDirect3DVertexBuffer9* m_pVB;
IDirect3DIndexBuffer9* m_pIB;
IDirect3DVertexDeclaration9* m_pDecl;
DWORD m_dwNumVertices;
DWORD m_dwNumFaces;
DWORD m_dwBytesPerVertex;
DWORD m_dwNumMaterials; // Materials for the mesh
D3DMATERIAL9* m_pMaterials;
CHAR (*m_strMaterials )[MAX_PATH];
IDirect3DBaseTexture9** m_pTextures;
bool m_bUseMaterials;
public:
// Rendering
HRESULT Render( LPDIRECT3DDEVICE9 pd3dDevice,
bool bDrawOpaqueSubsets = true,
bool bDrawAlphaSubsets = true );
HRESULT Render( ID3DXEffect* pEffect,
D3DXHANDLE hTexture = NULL,
D3DXHANDLE hDiffuse = NULL,
D3DXHANDLE hAmbient = NULL,
D3DXHANDLE hSpecular = NULL,
D3DXHANDLE hEmissive = NULL,
D3DXHANDLE hPower = NULL,
bool bDrawOpaqueSubsets = true,
bool bDrawAlphaSubsets = true );
// Mesh access
LPD3DXMESH GetMesh()
{
return m_pMesh;
}
// Rendering options
void UseMeshMaterials( bool bFlag )
{
m_bUseMaterials = bFlag;
}
HRESULT SetFVF( LPDIRECT3DDEVICE9 pd3dDevice, DWORD dwFVF );
HRESULT SetVertexDecl( LPDIRECT3DDEVICE9 pd3dDevice, const D3DVERTEXELEMENT9* pDecl,
bool bAutoComputeNormals = true, bool bAutoComputeTangents = true,
bool bSplitVertexForOptimalTangents = false );
// Initializing
HRESULT RestoreDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice );
HRESULT InvalidateDeviceObjects();
// Creation/destruction
HRESULT Create( LPDIRECT3DDEVICE9 pd3dDevice, LPCWSTR strFilename );
HRESULT Create( LPDIRECT3DDEVICE9 pd3dDevice, LPD3DXFILEDATA pFileData );
HRESULT Create( LPDIRECT3DDEVICE9 pd3dDevice, ID3DXMesh* pInMesh, D3DXMATERIAL* pd3dxMaterials,
DWORD dwMaterials );
HRESULT CreateMaterials( LPCWSTR strPath, IDirect3DDevice9* pd3dDevice, D3DXMATERIAL* d3dxMtrls,
DWORD dwNumMaterials );
HRESULT Destroy();
CDXUTXFileMesh( LPCWSTR strName = L"CDXUTXMeshFile_Mesh" );
virtual ~CDXUTXFileMesh();
};
#endif
#endif

1684
Demos/DX11ClothDemo/DXUT/Optional/SDKmisc.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

368
Demos/DX11ClothDemo/DXUT/Optional/SDKmisc.h Normal file
View File

@@ -0,0 +1,368 @@
//--------------------------------------------------------------------------------------
// File: SDKMisc.h
//
// Various helper functionality that is shared between SDK samples
//
// Copyright (c) Microsoft Corporation. All rights reserved
//--------------------------------------------------------------------------------------
#pragma once
#ifndef SDKMISC_H
#define SDKMISC_H
//-----------------------------------------------------------------------------
// Resource cache for textures, fonts, meshs, and effects.
// Use DXUTGetGlobalResourceCache() to access the global cache
//-----------------------------------------------------------------------------
enum DXUTCACHE_SOURCELOCATION
{
DXUTCACHE_LOCATION_FILE,
DXUTCACHE_LOCATION_RESOURCE
};
struct DXUTCache_Texture
{
DXUTCACHE_SOURCELOCATION Location;
WCHAR wszSource[MAX_PATH];
HMODULE hSrcModule;
UINT Width;
UINT Height;
UINT Depth;
UINT MipLevels;
UINT MiscFlags;
union
{
DWORD Usage9;
D3D11_USAGE Usage11;
};
union
{
D3DFORMAT Format9;
DXGI_FORMAT Format;
};
union
{
D3DPOOL Pool9;
UINT CpuAccessFlags;
};
union
{
D3DRESOURCETYPE Type9;
UINT BindFlags;
};
IDirect3DBaseTexture9* pTexture9;
ID3D11ShaderResourceView* pSRV11;
DXUTCache_Texture()
{
pTexture9 = NULL;
pSRV11 = NULL;
}
};
struct DXUTCache_Font : public D3DXFONT_DESC
{
ID3DXFont* pFont;
};
struct DXUTCache_Effect
{
DXUTCACHE_SOURCELOCATION Location;
WCHAR wszSource[MAX_PATH];
HMODULE hSrcModule;
DWORD dwFlags;
ID3DXEffect* pEffect;
};
class CDXUTResourceCache
{
public:
~CDXUTResourceCache();
HRESULT CreateTextureFromFile( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile,
LPDIRECT3DTEXTURE9* ppTexture );
HRESULT CreateTextureFromFile( LPDIRECT3DDEVICE9 pDevice, LPCSTR pSrcFile,
LPDIRECT3DTEXTURE9* ppTexture );
HRESULT CreateTextureFromFile( ID3D11Device* pDevice, ID3D11DeviceContext *pContext, LPCTSTR pSrcFile,
ID3D11ShaderResourceView** ppOutputRV, bool bSRGB=false );
HRESULT CreateTextureFromFile( ID3D11Device* pDevice, ID3D11DeviceContext *pContext, LPCSTR pSrcFile,
ID3D11ShaderResourceView** ppOutputRV, bool bSRGB=false );
HRESULT CreateTextureFromFileEx( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, UINT Width,
UINT Height, UINT MipLevels, DWORD Usage, D3DFORMAT Format,
D3DPOOL Pool, DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey,
D3DXIMAGE_INFO* pSrcInfo, PALETTEENTRY* pPalette,
LPDIRECT3DTEXTURE9* ppTexture );
HRESULT CreateTextureFromFileEx( ID3D11Device* pDevice, ID3D11DeviceContext* pContext, LPCTSTR pSrcFile,
D3DX11_IMAGE_LOAD_INFO* pLoadInfo, ID3DX11ThreadPump* pPump,
ID3D11ShaderResourceView** ppOutputRV, bool bSRGB );
HRESULT CreateTextureFromResource( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule,
LPCTSTR pSrcResource, LPDIRECT3DTEXTURE9* ppTexture );
HRESULT CreateTextureFromResourceEx( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule,
LPCTSTR pSrcResource, UINT Width, UINT Height, UINT MipLevels,
DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter,
DWORD MipFilter, D3DCOLOR ColorKey, D3DXIMAGE_INFO* pSrcInfo,
PALETTEENTRY* pPalette, LPDIRECT3DTEXTURE9* ppTexture );
HRESULT CreateCubeTextureFromFile( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile,
LPDIRECT3DCUBETEXTURE9* ppCubeTexture );
HRESULT CreateCubeTextureFromFileEx( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, UINT Size,
UINT MipLevels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool,
DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey,
D3DXIMAGE_INFO* pSrcInfo, PALETTEENTRY* pPalette,
LPDIRECT3DCUBETEXTURE9* ppCubeTexture );
HRESULT CreateCubeTextureFromResource( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule,
LPCTSTR pSrcResource,
LPDIRECT3DCUBETEXTURE9* ppCubeTexture );
HRESULT CreateCubeTextureFromResourceEx( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule,
LPCTSTR pSrcResource, UINT Size, UINT MipLevels,
DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter,
DWORD MipFilter, D3DCOLOR ColorKey,
D3DXIMAGE_INFO* pSrcInfo, PALETTEENTRY* pPalette,
LPDIRECT3DCUBETEXTURE9* ppCubeTexture );
HRESULT CreateVolumeTextureFromFile( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile,
LPDIRECT3DVOLUMETEXTURE9* ppVolumeTexture );
HRESULT CreateVolumeTextureFromFileEx( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, UINT Width,
UINT Height, UINT Depth, UINT MipLevels, DWORD Usage,
D3DFORMAT Format, D3DPOOL Pool, DWORD Filter,
DWORD MipFilter, D3DCOLOR ColorKey,
D3DXIMAGE_INFO* pSrcInfo, PALETTEENTRY* pPalette,
LPDIRECT3DVOLUMETEXTURE9* ppTexture );
HRESULT CreateVolumeTextureFromResource( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule,
LPCTSTR pSrcResource,
LPDIRECT3DVOLUMETEXTURE9* ppVolumeTexture );
HRESULT CreateVolumeTextureFromResourceEx( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule,
LPCTSTR pSrcResource, UINT Width, UINT Height,
UINT Depth, UINT MipLevels, DWORD Usage,
D3DFORMAT Format, D3DPOOL Pool, DWORD Filter,
DWORD MipFilter, D3DCOLOR ColorKey,
D3DXIMAGE_INFO* pSrcInfo, PALETTEENTRY* pPalette,
LPDIRECT3DVOLUMETEXTURE9* ppVolumeTexture );
HRESULT CreateFont( LPDIRECT3DDEVICE9 pDevice, UINT Height, UINT Width, UINT Weight,
UINT MipLevels, BOOL Italic, DWORD CharSet, DWORD OutputPrecision,
DWORD Quality, DWORD PitchAndFamily, LPCTSTR pFacename, LPD3DXFONT* ppFont );
HRESULT CreateFontIndirect( LPDIRECT3DDEVICE9 pDevice, CONST D3DXFONT_DESC *pDesc, LPD3DXFONT *ppFont );
HRESULT CreateEffectFromFile( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile,
const D3DXMACRO* pDefines, LPD3DXINCLUDE pInclude, DWORD Flags,
LPD3DXEFFECTPOOL pPool, LPD3DXEFFECT* ppEffect,
LPD3DXBUFFER* ppCompilationErrors );
HRESULT CreateEffectFromResource( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule,
LPCTSTR pSrcResource, const D3DXMACRO* pDefines,
LPD3DXINCLUDE pInclude, DWORD Flags, LPD3DXEFFECTPOOL pPool,
LPD3DXEFFECT* ppEffect, LPD3DXBUFFER* ppCompilationErrors );
public:
HRESULT OnCreateDevice( IDirect3DDevice9* pd3dDevice );
HRESULT OnResetDevice( IDirect3DDevice9* pd3dDevice );
HRESULT OnLostDevice();
HRESULT OnDestroyDevice();
protected:
friend CDXUTResourceCache& WINAPI DXUTGetGlobalResourceCache();
friend HRESULT WINAPI DXUTInitialize3DEnvironment();
friend HRESULT WINAPI DXUTReset3DEnvironment();
friend void WINAPI DXUTCleanup3DEnvironment( bool bReleaseSettings );
CDXUTResourceCache()
{
}
CGrowableArray <DXUTCache_Texture> m_TextureCache;
CGrowableArray <DXUTCache_Effect> m_EffectCache;
CGrowableArray <DXUTCache_Font> m_FontCache;
};
CDXUTResourceCache& WINAPI DXUTGetGlobalResourceCache();
//--------------------------------------------------------------------------------------
// Manages the insertion point when drawing text
//--------------------------------------------------------------------------------------
class CDXUTDialogResourceManager;
class CDXUTTextHelper
{
public:
CDXUTTextHelper( ID3DXFont* pFont9 = NULL, ID3DXSprite* pSprite9 = NULL,
int nLineHeight = 15 );
CDXUTTextHelper( ID3D11Device* pd3d11Device, ID3D11DeviceContext* pd3dDeviceContext, CDXUTDialogResourceManager* pManager, int nLineHeight );
~CDXUTTextHelper();
void Init( ID3DXFont* pFont9 = NULL, ID3DXSprite* pSprite9 = NULL,
int nLineHeight = 15 );
void SetInsertionPos( int x, int y )
{
m_pt.x = x; m_pt.y = y;
}
void SetForegroundColor( D3DXCOLOR clr )
{
m_clr = clr;
}
void Begin();
HRESULT DrawFormattedTextLine( const WCHAR* strMsg, ... );
HRESULT DrawTextLine( const WCHAR* strMsg );
HRESULT DrawFormattedTextLine( RECT& rc, DWORD dwFlags, const WCHAR* strMsg, ... );
HRESULT DrawTextLine( RECT& rc, DWORD dwFlags, const WCHAR* strMsg );
void End();
protected:
ID3DXFont* m_pFont9;
ID3DXSprite* m_pSprite9;
D3DXCOLOR m_clr;
POINT m_pt;
int m_nLineHeight;
// D3D11 font
ID3D11Device* m_pd3d11Device;
ID3D11DeviceContext* m_pd3d11DeviceContext;
CDXUTDialogResourceManager* m_pManager;
};
//--------------------------------------------------------------------------------------
// Manages a persistent list of lines and draws them using ID3DXLine
//--------------------------------------------------------------------------------------
class CDXUTLineManager
{
public:
CDXUTLineManager();
~CDXUTLineManager();
HRESULT OnCreatedDevice( IDirect3DDevice9* pd3dDevice );
HRESULT OnResetDevice();
HRESULT OnRender();
HRESULT OnLostDevice();
HRESULT OnDeletedDevice();
HRESULT AddLine( int* pnLineID, D3DXVECTOR2* pVertexList, DWORD dwVertexListCount, D3DCOLOR Color, float fWidth,
float fScaleRatio, bool bAntiAlias );
HRESULT AddRect( int* pnLineID, RECT rc, D3DCOLOR Color, float fWidth, float fScaleRatio, bool bAntiAlias );
HRESULT RemoveLine( int nLineID );
HRESULT RemoveAllLines();
protected:
struct LINE_NODE
{
int nLineID;
D3DCOLOR Color;
float fWidth;
bool bAntiAlias;
float fScaleRatio;
D3DXVECTOR2* pVertexList;
DWORD dwVertexListCount;
};
CGrowableArray <LINE_NODE*> m_LinesList;
IDirect3DDevice9* m_pd3dDevice;
ID3DXLine* m_pD3DXLine;
};
//--------------------------------------------------------------------------------------
// Shared code for samples to ask user if they want to use a REF device or quit
//--------------------------------------------------------------------------------------
void WINAPI DXUTDisplaySwitchingToREFWarning( DXUTDeviceVersion ver );
//--------------------------------------------------------------------------------------
// Tries to finds a media file by searching in common locations
//--------------------------------------------------------------------------------------
HRESULT WINAPI DXUTFindDXSDKMediaFileCch( __in_ecount(cchDest) WCHAR* strDestPath,
int cchDest,
__in LPCWSTR strFilename );
HRESULT WINAPI DXUTSetMediaSearchPath( LPCWSTR strPath );
LPCWSTR WINAPI DXUTGetMediaSearchPath();
//--------------------------------------------------------------------------------------
// Returns a view matrix for rendering to a face of a cubemap.
//--------------------------------------------------------------------------------------
D3DXMATRIX WINAPI DXUTGetCubeMapViewMatrix( DWORD dwFace );
//--------------------------------------------------------------------------------------
// Simple helper stack class
//--------------------------------------------------------------------------------------
template <class T> class CDXUTStack
{
private:
UINT m_MemorySize;
UINT m_NumElements;
T* m_pData;
bool EnsureStackSize( UINT64 iElements )
{
if( m_MemorySize > iElements )
return true;
T* pTemp = new T[ ( size_t )( iElements * 2 + 256 ) ];
if( !pTemp )
return false;
if( m_NumElements )
{
CopyMemory( pTemp, m_pData, ( size_t )( m_NumElements * sizeof( T ) ) );
}
if( m_pData ) delete []m_pData;
m_pData = pTemp;
return true;
}
public:
CDXUTStack()
{
m_pData = NULL; m_NumElements = 0; m_MemorySize = 0;
}
~CDXUTStack()
{
if( m_pData ) delete []m_pData;
}
UINT GetCount()
{
return m_NumElements;
}
T GetAt( UINT i )
{
return m_pData[i];
}
T GetTop()
{
if( m_NumElements < 1 )
return NULL;
return m_pData[ m_NumElements - 1 ];
}
T GetRelative( INT i )
{
INT64 iVal = m_NumElements - 1 + i;
if( iVal < 0 )
return NULL;
return m_pData[ iVal ];
}
bool Push( T pElem )
{
if( !EnsureStackSize( m_NumElements + 1 ) )
return false;
m_pData[m_NumElements] = pElem;
m_NumElements++;
return true;
}
T Pop()
{
if( m_NumElements < 1 )
return NULL;
m_NumElements --;
return m_pData[m_NumElements];
}
};
#endif

1053
Demos/DX11ClothDemo/DXUT/Optional/SDKsound.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

124
Demos/DX11ClothDemo/DXUT/Optional/SDKsound.h Normal file
View File

@@ -0,0 +1,124 @@
//-----------------------------------------------------------------------------
// File: DXUTsound.h
//
// Copyright (c) Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#ifndef DXUTSOUND_H
#define DXUTSOUND_H
//-----------------------------------------------------------------------------
// Header Includes
//-----------------------------------------------------------------------------
#include <dsound.h>
#include <ks.h>
//-----------------------------------------------------------------------------
// Classes used by this header
//-----------------------------------------------------------------------------
class CSoundManager;
class CSound;
class CStreamingSound;
class CWaveFile;
//-----------------------------------------------------------------------------
// Typing macros
//-----------------------------------------------------------------------------
#define DXUT_StopSound(s) { if(s) s->Stop(); }
#define DXUT_PlaySound(s) { if(s) s->Play( 0, 0 ); }
#define DXUT_PlaySoundLooping(s) { if(s) s->Play( 0, DSBPLAY_LOOPING ); }
//-----------------------------------------------------------------------------
// Name: class CSoundManager
// Desc:
//-----------------------------------------------------------------------------
class CSoundManager
{
protected:
IDirectSound8* m_pDS;
public:
CSoundManager();
~CSoundManager();
HRESULT Initialize( HWND hWnd, DWORD dwCoopLevel );
inline LPDIRECTSOUND8 GetDirectSound()
{
return m_pDS;
}
HRESULT SetPrimaryBufferFormat( DWORD dwPrimaryChannels, DWORD dwPrimaryFreq,
DWORD dwPrimaryBitRate );
HRESULT Get3DListenerInterface( LPDIRECTSOUND3DLISTENER* ppDSListener );
HRESULT Create( CSound** ppSound, LPWSTR strWaveFileName, DWORD dwCreationFlags = 0,
GUID guid3DAlgorithm = GUID_NULL, DWORD dwNumBuffers = 1 );
HRESULT CreateFromMemory( CSound** ppSound, BYTE* pbData, ULONG ulDataSize, LPWAVEFORMATEX pwfx,
DWORD dwCreationFlags = 0, GUID guid3DAlgorithm = GUID_NULL,
DWORD dwNumBuffers = 1 );
HRESULT CreateStreaming( CStreamingSound** ppStreamingSound, LPWSTR strWaveFileName,
DWORD dwCreationFlags, GUID guid3DAlgorithm, DWORD dwNotifyCount,
DWORD dwNotifySize, HANDLE hNotifyEvent );
};
//-----------------------------------------------------------------------------
// Name: class CSound
// Desc: Encapsulates functionality of a DirectSound buffer.
//-----------------------------------------------------------------------------
class CSound
{
protected:
LPDIRECTSOUNDBUFFER* m_apDSBuffer;
DWORD m_dwDSBufferSize;
CWaveFile* m_pWaveFile;
DWORD m_dwNumBuffers;
DWORD m_dwCreationFlags;
HRESULT RestoreBuffer( LPDIRECTSOUNDBUFFER pDSB, BOOL* pbWasRestored );
public:
CSound( LPDIRECTSOUNDBUFFER* apDSBuffer, DWORD dwDSBufferSize, DWORD dwNumBuffers,
CWaveFile* pWaveFile, DWORD dwCreationFlags );
virtual ~CSound();
HRESULT Get3DBufferInterface( DWORD dwIndex, LPDIRECTSOUND3DBUFFER* ppDS3DBuffer );
HRESULT FillBufferWithSound( LPDIRECTSOUNDBUFFER pDSB, BOOL bRepeatWavIfBufferLarger );
LPDIRECTSOUNDBUFFER GetFreeBuffer();
LPDIRECTSOUNDBUFFER GetBuffer( DWORD dwIndex );
HRESULT Play( DWORD dwPriority = 0, DWORD dwFlags = 0, LONG lVolume = 0, LONG lFrequency = -1,
LONG lPan = 0 );
HRESULT Play3D( LPDS3DBUFFER p3DBuffer, DWORD dwPriority = 0, DWORD dwFlags = 0, LONG lFrequency = 0 );
HRESULT Stop();
HRESULT Reset();
BOOL IsSoundPlaying();
};
//-----------------------------------------------------------------------------
// Name: class CStreamingSound
// Desc: Encapsulates functionality to play a wave file with DirectSound.
// The Create() method loads a chunk of wave file into the buffer,
// and as sound plays more is written to the buffer by calling
// HandleWaveStreamNotification() whenever hNotifyEvent is signaled.
//-----------------------------------------------------------------------------
class CStreamingSound : public CSound
{
protected:
DWORD m_dwLastPlayPos;
DWORD m_dwPlayProgress;
DWORD m_dwNotifySize;
DWORD m_dwNextWriteOffset;
BOOL m_bFillNextNotificationWithSilence;
public:
CStreamingSound( LPDIRECTSOUNDBUFFER pDSBuffer, DWORD dwDSBufferSize, CWaveFile* pWaveFile,
DWORD dwNotifySize );
~CStreamingSound();
HRESULT HandleWaveStreamNotification( BOOL bLoopedPlay );
HRESULT Reset();
};
#endif // DXUTSOUND_H

539
Demos/DX11ClothDemo/DXUT/Optional/SDKwavefile.cpp Normal file
View File

@@ -0,0 +1,539 @@
//-----------------------------------------------------------------------------
// File: SDKWaveFile.cpp
//
// Desc: Classes for reading and writing wav files. Feel free to use this class
// as a starting point for adding extra functionality.
//
// XNA Developer Connection
//
// Copyright (c) Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#define STRICT
#include "DXUT.h"
#include "SDKwavefile.h"
#undef min // use __min instead
#undef max // use __max instead
//-----------------------------------------------------------------------------
// Name: CWaveFile::CWaveFile()
// Desc: Constructs the class. Call Open() to open a wave file for reading.
// Then call Read() as needed. Calling the destructor or Close()
// will close the file.
//-----------------------------------------------------------------------------
CWaveFile::CWaveFile()
{
m_pwfx = NULL;
m_hmmio = NULL;
m_pResourceBuffer = NULL;
m_dwSize = 0;
m_bIsReadingFromMemory = FALSE;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::~CWaveFile()
// Desc: Destructs the class
//-----------------------------------------------------------------------------
CWaveFile::~CWaveFile()
{
Close();
if( !m_bIsReadingFromMemory )
SAFE_DELETE_ARRAY( m_pwfx );
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::Open()
// Desc: Opens a wave file for reading
//-----------------------------------------------------------------------------
HRESULT CWaveFile::Open( LPWSTR strFileName, WAVEFORMATEX* pwfx, DWORD dwFlags )
{
HRESULT hr;
m_dwFlags = dwFlags;
m_bIsReadingFromMemory = FALSE;
if( m_dwFlags == WAVEFILE_READ )
{
if( strFileName == NULL )
return E_INVALIDARG;
SAFE_DELETE_ARRAY( m_pwfx );
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF | MMIO_READ );
if( NULL == m_hmmio )
{
HRSRC hResInfo;
HGLOBAL hResData;
DWORD dwSize;
VOID* pvRes;
// Loading it as a file failed, so try it as a resource
if( NULL == ( hResInfo = FindResource( NULL, strFileName, L"WAVE" ) ) )
{
if( NULL == ( hResInfo = FindResource( NULL, strFileName, L"WAV" ) ) )
return DXTRACE_ERR( L"FindResource", E_FAIL );
}
if( NULL == ( hResData = LoadResource( GetModuleHandle( NULL ), hResInfo ) ) )
return DXTRACE_ERR( L"LoadResource", E_FAIL );
if( 0 == ( dwSize = SizeofResource( GetModuleHandle( NULL ), hResInfo ) ) )
return DXTRACE_ERR( L"SizeofResource", E_FAIL );
if( NULL == ( pvRes = LockResource( hResData ) ) )
return DXTRACE_ERR( L"LockResource", E_FAIL );
m_pResourceBuffer = new CHAR[ dwSize ];
if( m_pResourceBuffer == NULL )
return DXTRACE_ERR( L"new", E_OUTOFMEMORY );
memcpy( m_pResourceBuffer, pvRes, dwSize );
MMIOINFO mmioInfo;
ZeroMemory( &mmioInfo, sizeof( mmioInfo ) );
mmioInfo.fccIOProc = FOURCC_MEM;
mmioInfo.cchBuffer = dwSize;
mmioInfo.pchBuffer = ( CHAR* )m_pResourceBuffer;
m_hmmio = mmioOpen( NULL, &mmioInfo, MMIO_ALLOCBUF | MMIO_READ );
}
if( FAILED( hr = ReadMMIO() ) )
{
// ReadMMIO will fail if its an not a wave file
mmioClose( m_hmmio, 0 );
return DXTRACE_ERR( L"ReadMMIO", hr );
}
if( FAILED( hr = ResetFile() ) )
return DXTRACE_ERR( L"ResetFile", hr );
// After the reset, the size of the wav file is m_ck.cksize so store it now
m_dwSize = m_ck.cksize;
}
else
{
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF |
MMIO_READWRITE |
MMIO_CREATE );
if( NULL == m_hmmio )
return DXTRACE_ERR( L"mmioOpen", E_FAIL );
if( FAILED( hr = WriteMMIO( pwfx ) ) )
{
mmioClose( m_hmmio, 0 );
return DXTRACE_ERR( L"WriteMMIO", hr );
}
if( FAILED( hr = ResetFile() ) )
return DXTRACE_ERR( L"ResetFile", hr );
}
return hr;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::OpenFromMemory()
// Desc: copy data to CWaveFile member variable from memory
//-----------------------------------------------------------------------------
HRESULT CWaveFile::OpenFromMemory( BYTE* pbData, ULONG ulDataSize,
WAVEFORMATEX* pwfx, DWORD dwFlags )
{
m_pwfx = pwfx;
m_ulDataSize = ulDataSize;
m_pbData = pbData;
m_pbDataCur = m_pbData;
m_bIsReadingFromMemory = TRUE;
if( dwFlags != WAVEFILE_READ )
return E_NOTIMPL;
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::ReadMMIO()
// Desc: Support function for reading from a multimedia I/O stream.
// m_hmmio must be valid before calling. This function uses it to
// update m_ckRiff, and m_pwfx.
//-----------------------------------------------------------------------------
HRESULT CWaveFile::ReadMMIO()
{
MMCKINFO ckIn; // chunk info. for general use.
PCMWAVEFORMAT pcmWaveFormat; // Temp PCM structure to load in.
m_pwfx = NULL;
if( ( 0 != mmioDescend( m_hmmio, &m_ckRiff, NULL, 0 ) ) )
return DXTRACE_ERR( L"mmioDescend", E_FAIL );
// Check to make sure this is a valid wave file
if( ( m_ckRiff.ckid != FOURCC_RIFF ) ||
( m_ckRiff.fccType != mmioFOURCC( 'W', 'A', 'V', 'E' ) ) )
return DXTRACE_ERR( L"mmioFOURCC", E_FAIL );
// Search the input file for for the 'fmt ' chunk.
ckIn.ckid = mmioFOURCC( 'f', 'm', 't', ' ' );
if( 0 != mmioDescend( m_hmmio, &ckIn, &m_ckRiff, MMIO_FINDCHUNK ) )
return DXTRACE_ERR( L"mmioDescend", E_FAIL );
// Expect the 'fmt' chunk to be at least as large as <PCMWAVEFORMAT>;
// if there are extra parameters at the end, we'll ignore them
if( ckIn.cksize < ( LONG )sizeof( PCMWAVEFORMAT ) )
return DXTRACE_ERR( L"sizeof(PCMWAVEFORMAT)", E_FAIL );
// Read the 'fmt ' chunk into <pcmWaveFormat>.
if( mmioRead( m_hmmio, ( HPSTR )&pcmWaveFormat,
sizeof( pcmWaveFormat ) ) != sizeof( pcmWaveFormat ) )
return DXTRACE_ERR( L"mmioRead", E_FAIL );
// Allocate the waveformatex, but if its not pcm format, read the next
// word, and thats how many extra bytes to allocate.
if( pcmWaveFormat.wf.wFormatTag == WAVE_FORMAT_PCM )
{
m_pwfx = ( WAVEFORMATEX* )new CHAR[ sizeof( WAVEFORMATEX ) ];
if( NULL == m_pwfx )
return DXTRACE_ERR( L"m_pwfx", E_FAIL );
// Copy the bytes from the pcm structure to the waveformatex structure
memcpy( m_pwfx, &pcmWaveFormat, sizeof( pcmWaveFormat ) );
m_pwfx->cbSize = 0;
}
else
{
// Read in length of extra bytes.
WORD cbExtraBytes = 0L;
if( mmioRead( m_hmmio, ( CHAR* )&cbExtraBytes, sizeof( WORD ) ) != sizeof( WORD ) )
return DXTRACE_ERR( L"mmioRead", E_FAIL );
m_pwfx = ( WAVEFORMATEX* )new CHAR[ sizeof( WAVEFORMATEX ) + cbExtraBytes ];
if( NULL == m_pwfx )
return DXTRACE_ERR( L"new", E_FAIL );
// Copy the bytes from the pcm structure to the waveformatex structure
memcpy( m_pwfx, &pcmWaveFormat, sizeof( pcmWaveFormat ) );
m_pwfx->cbSize = cbExtraBytes;
// Now, read those extra bytes into the structure, if cbExtraAlloc != 0.
if( mmioRead( m_hmmio, ( CHAR* )( ( ( BYTE* )&( m_pwfx->cbSize ) ) + sizeof( WORD ) ),
cbExtraBytes ) != cbExtraBytes )
{
SAFE_DELETE( m_pwfx );
return DXTRACE_ERR( L"mmioRead", E_FAIL );
}
}
// Ascend the input file out of the 'fmt ' chunk.
if( 0 != mmioAscend( m_hmmio, &ckIn, 0 ) )
{
SAFE_DELETE( m_pwfx );
return DXTRACE_ERR( L"mmioAscend", E_FAIL );
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::GetSize()
// Desc: Retuns the size of the read access wave file
//-----------------------------------------------------------------------------
DWORD CWaveFile::GetSize()
{
return m_dwSize;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::ResetFile()
// Desc: Resets the internal m_ck pointer so reading starts from the
// beginning of the file again
//-----------------------------------------------------------------------------
HRESULT CWaveFile::ResetFile()
{
if( m_bIsReadingFromMemory )
{
m_pbDataCur = m_pbData;
}
else
{
if( m_hmmio == NULL )
return CO_E_NOTINITIALIZED;
if( m_dwFlags == WAVEFILE_READ )
{
// Seek to the data
if( -1 == mmioSeek( m_hmmio, m_ckRiff.dwDataOffset + sizeof( FOURCC ),
SEEK_SET ) )
return DXTRACE_ERR( L"mmioSeek", E_FAIL );
// Search the input file for the 'data' chunk.
m_ck.ckid = mmioFOURCC( 'd', 'a', 't', 'a' );
if( 0 != mmioDescend( m_hmmio, &m_ck, &m_ckRiff, MMIO_FINDCHUNK ) )
return DXTRACE_ERR( L"mmioDescend", E_FAIL );
}
else
{
// Create the 'data' chunk that holds the waveform samples.
m_ck.ckid = mmioFOURCC( 'd', 'a', 't', 'a' );
m_ck.cksize = 0;
if( 0 != mmioCreateChunk( m_hmmio, &m_ck, 0 ) )
return DXTRACE_ERR( L"mmioCreateChunk", E_FAIL );
if( 0 != mmioGetInfo( m_hmmio, &m_mmioinfoOut, 0 ) )
return DXTRACE_ERR( L"mmioGetInfo", E_FAIL );
}
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::Read()
// Desc: Reads section of data from a wave file into pBuffer and returns
// how much read in pdwSizeRead, reading not more than dwSizeToRead.
// This uses m_ck to determine where to start reading from. So
// subsequent calls will be continue where the last left off unless
// Reset() is called.
//-----------------------------------------------------------------------------
HRESULT CWaveFile::Read( BYTE* pBuffer, DWORD dwSizeToRead, DWORD* pdwSizeRead )
{
if( m_bIsReadingFromMemory )
{
if( m_pbDataCur == NULL )
return CO_E_NOTINITIALIZED;
if( pdwSizeRead != NULL )
*pdwSizeRead = 0;
if( ( BYTE* )( m_pbDataCur + dwSizeToRead ) >
( BYTE* )( m_pbData + m_ulDataSize ) )
{
dwSizeToRead = m_ulDataSize - ( DWORD )( m_pbDataCur - m_pbData );
}
#pragma warning( disable: 4616 ) // disable warning about warning number '22104' being out of range
#pragma warning( disable: 22104 ) // disable PREfast warning during static code analysis
CopyMemory( pBuffer, m_pbDataCur, dwSizeToRead );
#pragma warning( default: 22104 )
#pragma warning( default: 4616 )
if( pdwSizeRead != NULL )
*pdwSizeRead = dwSizeToRead;
return S_OK;
}
else
{
MMIOINFO mmioinfoIn; // current status of m_hmmio
if( m_hmmio == NULL )
return CO_E_NOTINITIALIZED;
if( pBuffer == NULL || pdwSizeRead == NULL )
return E_INVALIDARG;
*pdwSizeRead = 0;
if( 0 != mmioGetInfo( m_hmmio, &mmioinfoIn, 0 ) )
return DXTRACE_ERR( L"mmioGetInfo", E_FAIL );
UINT cbDataIn = dwSizeToRead;
if( cbDataIn > m_ck.cksize )
cbDataIn = m_ck.cksize;
m_ck.cksize -= cbDataIn;
for( DWORD cT = 0; cT < cbDataIn; cT++ )
{
// Copy the bytes from the io to the buffer.
if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead )
{
if( 0 != mmioAdvance( m_hmmio, &mmioinfoIn, MMIO_READ ) )
return DXTRACE_ERR( L"mmioAdvance", E_FAIL );
if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead )
return DXTRACE_ERR( L"mmioinfoIn.pchNext", E_FAIL );
}
// Actual copy.
*( ( BYTE* )pBuffer + cT ) = *( ( BYTE* )mmioinfoIn.pchNext );
mmioinfoIn.pchNext++;
}
if( 0 != mmioSetInfo( m_hmmio, &mmioinfoIn, 0 ) )
return DXTRACE_ERR( L"mmioSetInfo", E_FAIL );
*pdwSizeRead = cbDataIn;
return S_OK;
}
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::Close()
// Desc: Closes the wave file
//-----------------------------------------------------------------------------
HRESULT CWaveFile::Close()
{
if( m_dwFlags == WAVEFILE_READ )
{
mmioClose( m_hmmio, 0 );
m_hmmio = NULL;
SAFE_DELETE_ARRAY( m_pResourceBuffer );
}
else
{
m_mmioinfoOut.dwFlags |= MMIO_DIRTY;
if( m_hmmio == NULL )
return CO_E_NOTINITIALIZED;
if( 0 != mmioSetInfo( m_hmmio, &m_mmioinfoOut, 0 ) )
return DXTRACE_ERR( L"mmioSetInfo", E_FAIL );
// Ascend the output file out of the 'data' chunk -- this will cause
// the chunk size of the 'data' chunk to be written.
if( 0 != mmioAscend( m_hmmio, &m_ck, 0 ) )
return DXTRACE_ERR( L"mmioAscend", E_FAIL );
// Do this here instead...
if( 0 != mmioAscend( m_hmmio, &m_ckRiff, 0 ) )
return DXTRACE_ERR( L"mmioAscend", E_FAIL );
mmioSeek( m_hmmio, 0, SEEK_SET );
if( 0 != ( INT )mmioDescend( m_hmmio, &m_ckRiff, NULL, 0 ) )
return DXTRACE_ERR( L"mmioDescend", E_FAIL );
m_ck.ckid = mmioFOURCC( 'f', 'a', 'c', 't' );
if( 0 == mmioDescend( m_hmmio, &m_ck, &m_ckRiff, MMIO_FINDCHUNK ) )
{
DWORD dwSamples = 0;
mmioWrite( m_hmmio, ( HPSTR )&dwSamples, sizeof( DWORD ) );
mmioAscend( m_hmmio, &m_ck, 0 );
}
// Ascend the output file out of the 'RIFF' chunk -- this will cause
// the chunk size of the 'RIFF' chunk to be written.
if( 0 != mmioAscend( m_hmmio, &m_ckRiff, 0 ) )
return DXTRACE_ERR( L"mmioAscend", E_FAIL );
mmioClose( m_hmmio, 0 );
m_hmmio = NULL;
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::WriteMMIO()
// Desc: Support function for reading from a multimedia I/O stream
// pwfxDest is the WAVEFORMATEX for this new wave file.
// m_hmmio must be valid before calling. This function uses it to
// update m_ckRiff, and m_ck.
//-----------------------------------------------------------------------------
HRESULT CWaveFile::WriteMMIO( WAVEFORMATEX* pwfxDest )
{
DWORD dwFactChunk; // Contains the actual fact chunk. Garbage until WaveCloseWriteFile.
MMCKINFO ckOut1;
dwFactChunk = ( DWORD )-1;
// Create the output file RIFF chunk of form type 'WAVE'.
m_ckRiff.fccType = mmioFOURCC( 'W', 'A', 'V', 'E' );
m_ckRiff.cksize = 0;
if( 0 != mmioCreateChunk( m_hmmio, &m_ckRiff, MMIO_CREATERIFF ) )
return DXTRACE_ERR( L"mmioCreateChunk", E_FAIL );
// We are now descended into the 'RIFF' chunk we just created.
// Now create the 'fmt ' chunk. Since we know the size of this chunk,
// specify it in the MMCKINFO structure so MMIO doesn't have to seek
// back and set the chunk size after ascending from the chunk.
m_ck.ckid = mmioFOURCC( 'f', 'm', 't', ' ' );
m_ck.cksize = sizeof( PCMWAVEFORMAT );
if( 0 != mmioCreateChunk( m_hmmio, &m_ck, 0 ) )
return DXTRACE_ERR( L"mmioCreateChunk", E_FAIL );
// Write the PCMWAVEFORMAT structure to the 'fmt ' chunk if its that type.
if( pwfxDest->wFormatTag == WAVE_FORMAT_PCM )
{
if( mmioWrite( m_hmmio, ( HPSTR )pwfxDest,
sizeof( PCMWAVEFORMAT ) ) != sizeof( PCMWAVEFORMAT ) )
return DXTRACE_ERR( L"mmioWrite", E_FAIL );
}
else
{
// Write the variable length size.
if( ( UINT )mmioWrite( m_hmmio, ( HPSTR )pwfxDest,
sizeof( *pwfxDest ) + pwfxDest->cbSize ) !=
( sizeof( *pwfxDest ) + pwfxDest->cbSize ) )
return DXTRACE_ERR( L"mmioWrite", E_FAIL );
}
// Ascend out of the 'fmt ' chunk, back into the 'RIFF' chunk.
if( 0 != mmioAscend( m_hmmio, &m_ck, 0 ) )
return DXTRACE_ERR( L"mmioAscend", E_FAIL );
// Now create the fact chunk, not required for PCM but nice to have. This is filled
// in when the close routine is called.
ckOut1.ckid = mmioFOURCC( 'f', 'a', 'c', 't' );
ckOut1.cksize = 0;
if( 0 != mmioCreateChunk( m_hmmio, &ckOut1, 0 ) )
return DXTRACE_ERR( L"mmioCreateChunk", E_FAIL );
if( mmioWrite( m_hmmio, ( HPSTR )&dwFactChunk, sizeof( dwFactChunk ) ) !=
sizeof( dwFactChunk ) )
return DXTRACE_ERR( L"mmioWrite", E_FAIL );
// Now ascend out of the fact chunk...
if( 0 != mmioAscend( m_hmmio, &ckOut1, 0 ) )
return DXTRACE_ERR( L"mmioAscend", E_FAIL );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::Write()
// Desc: Writes data to the open wave file
//-----------------------------------------------------------------------------
HRESULT CWaveFile::Write( UINT nSizeToWrite, BYTE* pbSrcData, UINT* pnSizeWrote )
{
UINT cT;
if( m_bIsReadingFromMemory )
return E_NOTIMPL;
if( m_hmmio == NULL )
return CO_E_NOTINITIALIZED;
if( pnSizeWrote == NULL || pbSrcData == NULL )
return E_INVALIDARG;
*pnSizeWrote = 0;
for( cT = 0; cT < nSizeToWrite; cT++ )
{
if( m_mmioinfoOut.pchNext == m_mmioinfoOut.pchEndWrite )
{
m_mmioinfoOut.dwFlags |= MMIO_DIRTY;
if( 0 != mmioAdvance( m_hmmio, &m_mmioinfoOut, MMIO_WRITE ) )
return DXTRACE_ERR( L"mmioAdvance", E_FAIL );
}
*( ( BYTE* )m_mmioinfoOut.pchNext ) = *( ( BYTE* )pbSrcData + cT );
( BYTE* )m_mmioinfoOut.pchNext++;
( *pnSizeWrote )++;
}
return S_OK;
}

59
Demos/DX11ClothDemo/DXUT/Optional/SDKwavefile.h Normal file
View File

@@ -0,0 +1,59 @@
//-----------------------------------------------------------------------------
// File: WaveFile.h
//
// Copyright (c) Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#ifndef DXUTWAVEFILE_H
#define DXUTWAVEFILE_H
//-----------------------------------------------------------------------------
// Typing macros
//-----------------------------------------------------------------------------
#define WAVEFILE_READ 1
#define WAVEFILE_WRITE 2
//-----------------------------------------------------------------------------
// Name: class CWaveFile
// Desc: Encapsulates reading or writing sound data to or from a wave file
//-----------------------------------------------------------------------------
class CWaveFile
{
public:
WAVEFORMATEX* m_pwfx; // Pointer to WAVEFORMATEX structure
HMMIO m_hmmio; // MM I/O handle for the WAVE
MMCKINFO m_ck; // Multimedia RIFF chunk
MMCKINFO m_ckRiff; // Use in opening a WAVE file
DWORD m_dwSize; // The size of the wave file
MMIOINFO m_mmioinfoOut;
DWORD m_dwFlags;
BOOL m_bIsReadingFromMemory;
BYTE* m_pbData;
BYTE* m_pbDataCur;
ULONG m_ulDataSize;
CHAR* m_pResourceBuffer;
protected:
HRESULT ReadMMIO();
HRESULT WriteMMIO( WAVEFORMATEX* pwfxDest );
public:
CWaveFile();
~CWaveFile();
HRESULT Open( LPWSTR strFileName, WAVEFORMATEX* pwfx, DWORD dwFlags );
HRESULT OpenFromMemory( BYTE* pbData, ULONG ulDataSize, WAVEFORMATEX* pwfx, DWORD dwFlags );
HRESULT Close();
HRESULT Read( BYTE* pBuffer, DWORD dwSizeToRead, DWORD* pdwSizeRead );
HRESULT Write( UINT nSizeToWrite, BYTE* pbData, UINT* pnSizeWrote );
DWORD GetSize();
HRESULT ResetFile();
WAVEFORMATEX* GetFormat()
{
return m_pwfx;
};
};
#endif // DXUTWAVEFILE_H

BIN
Demos/DX11ClothDemo/DXUT/Optional/directx.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 25 KiB