/*
==================
Blits a bounding line
==================
*/
void DirectXRender::BlitGridLine(int pPosX1, int pPosY1, int pPosX2, int pPosY2, BYTE pR, BYTE pG, BYTE pB, BYTE pA, D3DXMATRIX pWorldMatrix) {
setTransform2d(0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0);
// Untransformed Points
D3DXVECTOR2 mP1Untransformed((float) pPosX1, (float) pPosY1);
D3DXVECTOR2 mP2Untransformed((float) pPosX2, (float) pPosY2);
D3DXVECTOR4 mP1, mP2;
D3DXVec2Transform(&mP1, &mP1Untransformed, &pWorldMatrix);
D3DXVec2Transform(&mP2, &mP2Untransformed, &pWorldMatrix);
// Color
setRainbow2d(IND_OPAQUE, 1, 0, 0, IND_FILTER_POINT, pR, pG, pB, pA, 0, 0, 0, 255, 0, 0);
// Color
_info._device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
// Pixel format
_info._device->SetFVF(D3DFVF_PIXEL);
// Filling pixels
fillPixel(&_pixels [0], (int) mP1.x, (int) mP1.y, pR, pG, pB);
fillPixel(&_pixels [1], (int) mP2.x, (int) mP2.y, pR, pG, pB);
// Blitting line
_info._device->DrawPrimitiveUP(D3DPT_LINESTRIP, 1, &_pixels, sizeof(PIXEL));
}
/**
@brief 바운딩박스를 계산해 돌려준다.
*/
XE::xRECT XLayerImage::GetBoundBox( const D3DXMATRIX& mParent ) const
{
// 이미지의 4귀퉁이를 이 매트릭스로 트랜스폼
XSprite *pSpr = m_pSpriteCurr;
if( pSpr ) {
const D3DXVECTOR2 vAdj = pSpr->GetAdjust();
const auto vSize = pSpr->GetSize();
D3DXVECTOR2 vLT = vAdj;
D3DXVECTOR2 vRT = D3DXVECTOR2( vAdj.x + vSize.w, vAdj.y );
D3DXVECTOR2 vLB = D3DXVECTOR2( vAdj.x , vAdj.y + vSize.h );
D3DXVECTOR2 vRB = D3DXVECTOR2( vAdj.x + vSize.w, vAdj.y + vSize.h );
XE::VEC2 vtLT, vtRT, vtLB, vtRB;
D3DXVECTOR4 vResult;
const auto mWorld = GetMatrix() * mParent;
D3DXVec2Transform( &vResult, &vLT, &mWorld ); vtLT.Set( vResult.x, vResult.y );
D3DXVec2Transform( &vResult, &vRT, &mWorld ); vtRT.Set( vResult.x, vResult.y );
D3DXVec2Transform( &vResult, &vLB, &mWorld ); vtLB.Set( vResult.x, vResult.y );
D3DXVec2Transform( &vResult, &vRB, &mWorld ); vtRB.Set( vResult.x, vResult.y );
XE::xRECT rectBB;
rectBB.UpdateBoundBox( vtLT );
rectBB.UpdateBoundBox( vtRT );
rectBB.UpdateBoundBox( vtLB );
rectBB.UpdateBoundBox( vtRB );
return rectBB;
}
return XE::xRECT();
}
/*
==================
Blits a bounding line
==================
*/
inline void IND_Render::BlitCollisionLine (int pPosX1, int pPosY1, int pPosX2, int pPosY2, byte pR, byte pG, byte pB, byte pA, IND_Matrix pIndWorldMatrix)
{
SetTransform2d (0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0);
D3DXMATRIX mWorldMatrix;
GetD3DMatrix (pIndWorldMatrix, &mWorldMatrix);
// Untransformed points
D3DXVECTOR2 mP1Untransformed ((float) pPosX1, (float) pPosY1);
D3DXVECTOR2 mP2Untransformed ((float) pPosX2, (float) pPosY2);
D3DXVECTOR4 mP1, mP2;
D3DXVec2Transform (&mP1, &mP1Untransformed, &mWorldMatrix);
D3DXVec2Transform (&mP2, &mP2Untransformed, &mWorldMatrix);
// Color
SetRainbow2d (IND_OPAQUE, 1, 0, 0, IND_FILTER_POINT, pR, pG, pB, pA, 0, 0, 0, 255, 0, 0);
// Color
mInfo.mDevice->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
// Pixel format
mInfo.mDevice->SetFVF (D3DFVF_PIXEL);
// Filling pixels
FillPixel (&mPixels [0], (int) mP1.x, (int) mP1.y, pR, pG, pB);
FillPixel (&mPixels [1], (int) mP2.x, (int) mP2.y, pR, pG, pB);
// Blitting line
mInfo.mDevice->DrawPrimitiveUP (D3DPT_LINESTRIP, 1, &mPixels, sizeof (PIXEL));
}
void XLayerImage::Draw( float x, float y, const D3DXMATRIX &m, XSprObj *pParentSprObj )
{
XSprite *pSpr = m_pSpriteCurr;
if( pSpr )
{
const XE::VEC2 vLocal = GetcnPos().m_vPos;
pSpr->SetAdjustAxis( GetfAdjustAxisX(), GetfAdjustAxisY() ); // 회전축을 보정함
pSpr->SetRotateZ( GetcnRot().fAngle );
pSpr->SetScale( GetcnScale().vScale );
pSpr->SetFlipHoriz( (GetcnEffect().dwDrawFlag & EFF_FLIP_HORIZ) ? TRUE : FALSE );
pSpr->SetFlipVert( (GetcnEffect().dwDrawFlag & EFF_FLIP_VERT) ? TRUE : FALSE );
pSpr->SetDrawMode( GetcnEffect().DrawMode );
pSpr->SetfAlpha( GetcnEffect().fAlpha );
//
if( TOOL->GetspSelLayer()
&& TOOL->GetspSelLayer()->getid() == getid() ) {
D3DXVECTOR4 vOut;
D3DXVECTOR2 dvLocal = vLocal;
D3DXVec2Transform( &vOut, &dvLocal, &m );
XE::VEC2 vLT = vLocal + pSpr->GetAdjust();
XE::VEC2 vRB = vLT + pSpr->GetSize();
D3DXVECTOR2 dvLT = vLT;
D3DXVECTOR2 dvRB = vRB;
D3DXVec2Transform( &vOut, &dvLT, &m ); dvLT.x = vOut.x; dvLT.y = vOut.y;
D3DXVec2Transform( &vOut, &dvRB, &m ); dvRB.x = vOut.x; dvRB.y = vOut.y;
vLT = dvLT;
vRB = dvRB;
if( SPROBJ->IsPause() ) {
XE::DrawRectangle( vLT, vRB, XCOLOR_WHITE );
}
}
//
pSpr->Draw( vLocal, m );
}
}
void ColliderBoxAA2D::LateUpdate()
{
D3DXVECTOR4 buffer;
D3DXVec2Transform(&buffer, &m_startMin, m_obj->GetTransform()->GetWorld());
m_min = D3DXVECTOR2(buffer);
D3DXVec2Transform(&buffer, &m_startMax, m_obj->GetTransform()->GetWorld());
m_max = D3DXVECTOR2(buffer);
}
DWORD XLayerImage::GetPixel( const D3DXMATRIX& mCamera,
const D3DXVECTOR2& mv,
BYTE *pa, BYTE *pr, BYTE *pg, BYTE *pb ) const
{
XSprite *pSpr = m_pSpriteCurr;
if( pSpr )
{
const XE::VEC2 vLocal = GetcnPos().m_vPos;
pSpr->SetAdjustAxis( GetfAdjustAxisX(), GetfAdjustAxisY() ); // 회전축을 보정함
pSpr->SetRotateZ( GetcnRot().fAngle );
pSpr->SetScale( GetcnScale().vScale );
pSpr->SetFlipHoriz( ( GetcnEffect().dwDrawFlag & EFF_FLIP_HORIZ ) ? TRUE : FALSE );
pSpr->SetFlipVert( ( GetcnEffect().dwDrawFlag & EFF_FLIP_VERT ) ? TRUE : FALSE );
D3DXMATRIX mWorld;
pSpr->GetMatrix( &mWorld, vLocal.x, vLocal.y );
D3DXMATRIX mInv;
mWorld = mWorld * mCamera;
D3DXMatrixInverse( &mInv, nullptr, &mWorld ); // 이제까지 반영된 모든 매트릭스를 역행렬로 만든다
D3DXVECTOR4 vInv;
D3DXVec2Transform( &vInv, &mv, &mInv ); // 최종 매트릭스 기준 좌표가 나온다.
DWORD pixel = pSpr->GetPixel( vInv.x, vInv.y, pa, pr, pg, pb );
pSpr->SetScale( 1.0f, 1.0f );
pSpr->SetRotate( 0, 0, 0 );
return pixel;
}
return 0;
}
// lx, ly는 0,0기준 로컬좌표
DWORD XLayerImage::GetPixel( float cx, float cy, float mx, float my, const D3DXMATRIX &m, BYTE *pa, BYTE *pr, BYTE *pg, BYTE *pb ) const
{
XSprite *pSpr = m_pSpriteCurr;
if( pSpr )
{
XE::VEC2 vLocal = GetcnPos().m_vPos;
// float lx = GetcnPos().x;
// float ly = GetcnPos().y;
pSpr->SetAdjustAxis( GetvAdjustAxis() ); // 회전축을 보정함
pSpr->SetRotateZ( GetcnRot().fAngle );
pSpr->SetScale( GetcnScale().vScale );
pSpr->SetFlipHoriz( (GetcnEffect().dwDrawFlag & EFF_FLIP_HORIZ) ? TRUE : FALSE );
pSpr->SetFlipVert( (GetcnEffect().dwDrawFlag & EFF_FLIP_VERT) ? TRUE : FALSE );
// DWORD pixel = pSpr->GetPixel( lx, ly, m, pa, pr, pg, pb );
D3DXMATRIX mWorld;
pSpr->GetMatrix( &mWorld, vLocal.x, vLocal.y );
// mWorld *= m; // 부모의행렬과 스프라이트의 로컬행렬을곱함
D3DXMATRIX mInv;
// D3DXMatrixInverse( &mInv, nullptr, &mWorld ); // 이제까지 반영된 모든 매트릭스를 역행렬로 만든다
D3DXMatrixInverse( &mInv, nullptr, &m ); // 이제까지 반영된 모든 매트릭스를 역행렬로 만든다
D3DXVECTOR2 v = D3DXVECTOR2( mx, my ); // 마우스 클릭한 좌표
D3DXVECTOR4 vInv;
D3DXVec2Transform( &vInv, &v, &mInv ); // 최종 매트릭스 기준 좌표가 나온다.
DWORD pixel = pSpr->GetPixel( vInv.x, vInv.y, pa, pr, pg, pb );
pSpr->SetScale( 1.0f, 1.0f );
pSpr->SetRotate( 0, 0, 0 );
return pixel;
}
return 0;
}
Vec2 Graphics::WorldToScreenSpace(Vec2 worldPosition)
{
Vec4 screenSpacePosition( worldPosition.x, worldPosition.y, 0, 0 );
D3DXVec2Transform( &screenSpacePosition, &worldPosition, &ViewProjMatrix );
screenSpacePosition.y *= -1;
screenSpacePosition += Vec4(1, 1, 0, 0);
screenSpacePosition /= 2.0f;
screenSpacePosition.x *= SurfaceSize.x;
screenSpacePosition.y *= SurfaceSize.y;
return Vec2( screenSpacePosition.x, screenSpacePosition.y );
}
/*************************************************************************
* D3DXVec2TransformArray
*
* Transform an array of vectors by a matrix.
*/
D3DXVECTOR4* WINAPI D3DXVec2TransformArray(
D3DXVECTOR4* out, UINT outstride, CONST D3DXVECTOR2* in, UINT instride,
CONST D3DXMATRIX* matrix, UINT elements)
{
UINT i;
TRACE("\n");
for (i = 0; i < elements; ++i) {
D3DXVec2Transform(
(D3DXVECTOR4*)((char*)out + outstride * i),
(CONST D3DXVECTOR2*)((const char*)in + instride * i),
matrix);
}
return out;
}
/*
==================
Creates a bounding rectangle surronding the block for discarding it using frustum culling
==================
*/
void DirectXRender::Transform4Vertices(float pX1, float pY1,
float pX2, float pY2,
float pX3, float pY3,
float pX4, float pY4,
D3DXVECTOR4 *mP1Res,
D3DXVECTOR4 *mP2Res,
D3DXVECTOR4 *mP3Res,
D3DXVECTOR4 *mP4Res) {
// ----- Transform 4 vertices of the quad into world space coordinates -----
D3DXMATRIX mMatWorld;
_info._device->GetTransform(D3DTS_WORLD, &mMatWorld);
D3DXVECTOR2 mP1(pX1, pY1);
D3DXVECTOR2 mP2(pX2, pY2);
D3DXVECTOR2 mP3(pX3, pY3);
D3DXVECTOR2 mP4(pX4, pY4);
D3DXVECTOR4 mP1_f, mP2_f, mP3_f, mP4_f;
D3DXVec2Transform(mP1Res, &mP1, &mMatWorld);
D3DXVec2Transform(mP2Res, &mP2, &mMatWorld);
D3DXVec2Transform(mP3Res, &mP3, &mMatWorld);
D3DXVec2Transform(mP4Res, &mP4, &mMatWorld);
}
Vec2 Graphics::ScreenToWorldSpace(Vec2 screenPosition)
{
//Convert to normalized screen space 0 to 1
screenPosition.x /= SurfaceSize.x;
screenPosition.y /= SurfaceSize.y;
//Convert to projected space -1 to 1
screenPosition *= 2.0f;
screenPosition -= Vec2(1,1);
screenPosition.y *= -1;
//Unproject the point by applying the inverse
//of the ViewProjection matrix
Mat4 inverseViewProjection;
float det;
D3DXMatrixInverse(&inverseViewProjection,&det,&ViewProjMatrix);
Vec4 worldSpacePosition;
D3DXVec2Transform(&worldSpacePosition,&screenPosition,&inverseViewProjection);
return Vec2(worldSpacePosition.x,worldSpacePosition.y);
}
/*
==================
Blits a bounding circle area
==================
*/
inline void IND_Render::BlitCollisionCircle (int pPosX, int pPosY, int pRadius, float pScale, byte pR, byte pG, byte pB, byte pA, IND_Matrix pIndWorldMatrix)
{
if (pScale != 1.0f) pRadius = (int) (pRadius * pScale);
SetTransform2d (0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0);
D3DXMATRIX mWorldMatrix;
GetD3DMatrix (pIndWorldMatrix, &mWorldMatrix);
// Untransformed points
D3DXVECTOR2 mP1Untransformed ((float) pPosX, (float) pPosY);
D3DXVECTOR4 mP1;
D3DXVec2Transform (&mP1, &mP1Untransformed, &mWorldMatrix);
// Color
SetRainbow2d (IND_OPAQUE, 1, 0, 0, IND_FILTER_POINT, pR, pG, pB, pA, 0, 0, 0, 255, 0, 0);
// Color
mInfo.mDevice->SetTextureStageState (0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
// Pixel format
mInfo.mDevice->SetFVF (D3DFVF_PIXEL);
// Blitting
int x, y, i;
for (i = 0; i < 30; i++)
{
float c = i * 2 * (float) (PI / 30);
x = (int) ( mP1.x + (pRadius * cos (c + D3DXToRadian (0))) );
y = (int) ( mP1.y + (pRadius * sin (c + D3DXToRadian (0))) );
FillPixel (&mPixels [i], x, y, pR, pG, pB);
}
FillPixel (&mPixels [i], (int) mP1.x + (int) (pRadius * cos (D3DXToRadian (0))), (int) mP1.y + (int) (pRadius * sin (D3DXToRadian (0))), pR, pG, pB);
// Blitting circle
mInfo.mDevice->DrawPrimitiveUP (D3DPT_LINESTRIP, i, &mPixels, sizeof (PIXEL));
}
