const bool Test_Matrix_ScalingMatrix()
{
const TMatrix4d kScaleMatrix_d = ScalingMatrix(TMatrix4d(), 1.0, 2.0, 3.0);
const TVector4d kTransformedPoint_d = VectorMultiply(TVector4d(), kScaleMatrix_d, TVector4d{1.0, 1.0, 1.0, 1.0});
const bool kbPass_d = Equal(kTransformedPoint_d, TVector4d{1.0, 2.0, 3.0, 1.0}, s_kdEpsilon);
const TMatrix4f kScaleMatrix_f = ScalingMatrix(TMatrix4f(), 1.0f, 2.0f, 3.0f);
const TVector4f kTransformedPoint_f = VectorMultiply(TVector4f(), kScaleMatrix_f, TVector4f{1.0f, 1.0f, 1.0f, 1.0f});
const bool kbPass_f = Equal(kTransformedPoint_f, TVector4f{1.0f, 2.0f, 3.0f, 1.0f}, s_kfEpsilon);
return(kbPass_d && kbPass_f);
}
const bool Test_Matrix_TransformationMatrix()
{
const TVector3d kTranslate_d{1.0, 2.0, 3.0};
const TVector3d kAxis_d = Normalize(TVector3d(), TVector3d{1.0, 1.0, 1.0});
const double kdAngle = s_kdTau / 8.0;
const TVector4d kQuatOrient_d = AxisAngleQuaternion(TVector4d(), kAxis_d, kdAngle);
const double kdScale = 2.0;
const TMatrix4d kTranslation_d = TranslationMatrix(TMatrix4d(), kTranslate_d);
const TMatrix4d kOrientation_d = RotationMatrix(TMatrix4d(), kQuatOrient_d);
const TMatrix4d kScaling_d = ScalingMatrix(TMatrix4d(), kdScale, kdScale, kdScale);
const TMatrix4d kTransformA_d = Multiply(TMatrix4d(), kScaling_d, kOrientation_d);
const TMatrix4d kTransformB_d = Multiply(TMatrix4d(), kTranslation_d, kTransformA_d);
const TVector3d kBasisX_d = QuaternionRotate(TVector3d(), TVector3d{kdScale, 0.0, 0.0}, kQuatOrient_d);
const TVector3d kBasisY_d = QuaternionRotate(TVector3d(), TVector3d{0.0, kdScale, 0.0}, kQuatOrient_d);
const TVector3d kBasisZ_d = QuaternionRotate(TVector3d(), TVector3d{0.0, 0.0, kdScale}, kQuatOrient_d);
const TMatrix4d kTransformC_d = TransformationMatrix(TMatrix4d(), kBasisX_d, kBasisY_d, kBasisZ_d, kTranslate_d);
const bool kbPass_d = Equal(kTransformC_d, kTransformB_d, s_kdEpsilon);
//
const TVector3f kTranslate_f{1.0f, 2.0f, 3.0f};
const TVector3f kAxis_f = Normalize(TVector3f(), TVector3f{1.0f, 1.0f, 1.0f});
const float kfAngle = s_kfTau / 8.0f;
const TVector4f kQuatOrient_f = AxisAngleQuaternion(TVector4f(), kAxis_f, kfAngle);
const float kfScale = 2.0f;
const TMatrix4f kTranslation_f = TranslationMatrix(TMatrix4f(), kTranslate_f);
const TMatrix4f kOrientation_f = RotationMatrix(TMatrix4f(), kQuatOrient_f);
const TMatrix4f kScaling_f = ScalingMatrix(TMatrix4f(), kfScale, kfScale, kfScale);
const TMatrix4f kTransformA_f = Multiply(TMatrix4f(), kScaling_f, kOrientation_f);
const TMatrix4f kTransformB_f = Multiply(TMatrix4f(), kTranslation_f, kTransformA_f);
const TVector3f kBasisX_f = QuaternionRotate(TVector3f(), TVector3f{kfScale, 0.0f, 0.0f}, kQuatOrient_f);
const TVector3f kBasisY_f = QuaternionRotate(TVector3f(), TVector3f{0.0f, kfScale, 0.0f}, kQuatOrient_f);
const TVector3f kBasisZ_f = QuaternionRotate(TVector3f(), TVector3f{0.0f, 0.0f, kfScale}, kQuatOrient_f);
const TMatrix4f kTransformC_f = TransformationMatrix(TMatrix4f(), kBasisX_f, kBasisY_f, kBasisZ_f, kTranslate_f);
const bool kbPass_f = Equal(kTransformC_f, kTransformB_f, s_kfEpsilon);
return(kbPass_d && kbPass_f);
}
bool ZEffectBillboardTexAniList::Draw()
{
if(!m_pVB) return false;
if( size()==0 ) return true;
BeginState();
RSetFog(FALSE);
HRESULT hr;
DWORD dwRemainNum = (DWORD)size();
iterator itr = begin();
while(dwRemainNum)
{
if(m_dwBase >= EFFECTBASE_DISCARD_COUNT)
m_dwBase = 0;
DWORD dwThisNum = min( dwRemainNum , static_cast<DWORD>(BILLBOARD_FLUSH_COUNT) );
dwThisNum = min( dwThisNum , EFFECTBASE_DISCARD_COUNT - m_dwBase );
BYTE *pVertices;
if( FAILED( hr = m_pVB->Lock( m_dwBase * sizeof(ZEFFECTCUSTOMVERTEX) * 4, dwThisNum * sizeof(ZEFFECTCUSTOMVERTEX) * 4,
(VOID**)&pVertices, m_dwBase ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) ) )
{
return false;
}
BYTE *pInd;
if( FAILED( hr = m_pIB->Lock( m_dwBase * sizeof(WORD) * 6, dwThisNum * sizeof(WORD) * 6,
(VOID**)&pInd, m_dwBase ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) ) )
{
return false;
}
int nRenderCnt = 0;
ZCharacter* pChar = NULL;
for(DWORD j=0;j<dwThisNum;j++)
{
ZEFFECTBILLBOARDTEXANIITEM *p = (ZEFFECTBILLBOARDTEXANIITEM*)*itr;
if(p->fElapsedTime < p->fAddTime ) {
itr++;
continue;
}
pChar = ZGetCharacterManager()->Find(p->CharUID);
if( pChar ) {
if( pChar->m_pVMesh ) {
if( pChar->m_pVMesh->m_bIsRender==false) {
itr++;
continue;
}
}
}
nRenderCnt++;
// Transform
rmatrix matTranslation;
rmatrix matScaling;
rmatrix matWorld;
rvector dir = p->normal;
rvector up = p->up;
rvector right;
if (IS_EQ(dir.z, 1.f)) up = rvector(1, 0, 0);
right = Normalized(CrossProduct(up, dir));
up = Normalized(CrossProduct(right, dir));
rmatrix mat;
GetIdentityMatrix(mat);
mat._11 = right.x; mat._12 = right.y; mat._13 = right.z;
mat._21 = up.x; mat._22 = up.y; mat._23 = up.z;
mat._31 = dir.x; mat._32 = dir.y; mat._33 = dir.z;
rvector pos = p->position;
float fInt = min(1.f, max(0.f, (p->fLifeTime - p->fElapsedTime) / p->fLifeTime));
float fScale=p->fStartSize * fInt + p->fEndSize * (1.f - fInt);
matScaling = ScalingMatrix(fScale * m_Scale);
matTranslation = TranslationMatrix(pos);
matWorld = matScaling * mat;
matWorld *= matTranslation;
DWORD color = ((DWORD)(p->fOpacity * 255))<<24 | p->dwColor;
static ZEFFECTCUSTOMVERTEX v[] = {
{{-1, -1, 0}, 0xFFFFFFFF, 1, 0 },
{{-1, 1, 0}, 0xFFFFFFFF, 1, 1},
{{ 1, 1, 0}, 0xFFFFFFFF, 0, 1},
{{ 1, -1, 0}, 0xFFFFFFFF, 0, 0},
};
static rvector sv[4] = { rvector(-1,-1,0) , rvector(-1,1,0) , rvector(1,1,0) , rvector(1,-1,0) };
GetFrameUV( min( p->frame,m_nMaxFrame-1) );
v[0].tu = m_fUV[0];
v[0].tv = m_fUV[1];
v[1].tu = m_fUV[2];
v[1].tv = m_fUV[3];
v[2].tu = m_fUV[4];
v[2].tv = m_fUV[5];
v[3].tu = m_fUV[6];
v[3].tv = m_fUV[7];
for (size_t i{}; i < 4; ++i)
v[i].pos = TransformCoord(sv[i], matWorld);
v[0].color=v[1].color=v[2].color=v[3].color=color;
memcpy(pVertices,v,sizeof(ZEFFECTCUSTOMVERTEX)*4);
pVertices+=sizeof(ZEFFECTCUSTOMVERTEX)*4;
WORD inds[] = { 0,1,2,0,2,3 };
for(int k=0;k<6;k++)
{
inds[k]+=(m_dwBase+j)*4;
}
memcpy(pInd,inds,sizeof(inds));
pInd+=sizeof(inds);
itr++;
}
m_pVB->Unlock();
m_pIB->Unlock();
if(FAILED( hr = RGetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,m_dwBase*4,nRenderCnt*4,m_dwBase*6,nRenderCnt*2) ))
return false;
m_dwBase+=dwThisNum;
dwRemainNum-=dwThisNum;
}
RGetDevice()->SetStreamSource( 0, NULL , 0,0 );
RGetDevice()->SetIndices(NULL);
if(ZGetWorld()) {
ZGetWorld()->SetFog(true);
}
EndState();
return true;
}
bool ZEffectBillboardList::Draw()
{
if(!m_pVB) return false;
if( size()==0 ) return true;
BeginState();
HRESULT hr;
DWORD dwRemainNum = (DWORD)size();
iterator itr=begin();
while(dwRemainNum)
{
if(m_dwBase >= EFFECTBASE_DISCARD_COUNT)
m_dwBase = 0;
DWORD dwThisNum = min( dwRemainNum , static_cast<DWORD>(BILLBOARD_FLUSH_COUNT) );
dwThisNum = min( dwThisNum , EFFECTBASE_DISCARD_COUNT - m_dwBase );
BYTE *pVertices;
if( FAILED( hr = m_pVB->Lock( m_dwBase * sizeof(ZEFFECTCUSTOMVERTEX) * 4, dwThisNum * sizeof(ZEFFECTCUSTOMVERTEX) * 4,
(VOID**)&pVertices, m_dwBase ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) ) )
{
return false;
}
BYTE *pInd;
if( FAILED( hr = m_pIB->Lock( m_dwBase * sizeof(WORD) * 6, dwThisNum * sizeof(WORD) * 6,
(VOID**)&pInd, m_dwBase ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) ) )
{
return false;
}
for(DWORD j=0;j<dwThisNum;j++)
{
ZEFFECTBILLBOARDITEM *p = (ZEFFECTBILLBOARDITEM*)*itr;
// Transform
rmatrix matTranslation;
rmatrix matScaling;
rmatrix matWorld;
rvector dir = p->normal;
rvector up=p->up;
rvector right;
if(IS_EQ(dir.z,1.f)) up=rvector(1,0,0);
right = Normalized(CrossProduct(up, dir));
up = Normalized(CrossProduct(right, dir));
rmatrix mat;
GetIdentityMatrix(mat);
mat._11=right.x;mat._12=right.y;mat._13=right.z;
mat._21=up.x;mat._22=up.y;mat._23=up.z;
mat._31=dir.x;mat._32=dir.y;mat._33=dir.z;
rvector pos=p->position;
float fInt = min(1.f, max(0.f, (p->fLifeTime - p->fElapsedTime) / p->fLifeTime));
float fScale=p->fStartSize * fInt + p->fEndSize * (1.f - fInt);
if( p->bUseTrainSmoke ) {
float fRatio = GetLifeRatio(p);
float fAddScale = (p->fEndSize - p->fStartSize) / p->fLifeTime;
if(fRatio < 0.1f ) {
fAddScale *= 0.001f;
}
else if(fRatio < 0.4) {
fAddScale *= 0.02f;
}
else {
fAddScale *= 0.05f;
}
p->fCurScale += fAddScale;
if(p->fCurScale > p->fEndSize)
p->fCurScale = p->fEndSize;
fScale = p->fCurScale;
}
matScaling = ScalingMatrix(fScale * m_Scale);
matTranslation = TranslationMatrix(pos);
matWorld = matScaling * mat;
matWorld *= matTranslation;
DWORD color = ((DWORD)(p->fOpacity * 255))<<24 | p->dwColor;
static ZEFFECTCUSTOMVERTEX v[] = {
{{-1, -1, 0}, 0xFFFFFFFF, 1, 0 },
{{-1, 1, 0}, 0xFFFFFFFF, 1, 1 },
{{ 1, 1, 0 }, 0xFFFFFFFF, 0, 1},
{ { 1, -1, 0}, 0xFFFFFFFF, 0, 0 },
};
static const rvector sv[4] = { rvector(-1,-1,0) , rvector(-1,1,0) , rvector(1,1,0) , rvector(1,-1,0) };
for (size_t i{}; i < 4; ++i)
v[i].pos = TransformCoord(sv[i], matWorld);
v[0].color=v[1].color=v[2].color=v[3].color=color;
memcpy(pVertices,v,sizeof(ZEFFECTCUSTOMVERTEX)*4);
pVertices+=sizeof(ZEFFECTCUSTOMVERTEX)*4;
WORD inds[] = { 0,1,2,0,2,3 };
for(int k=0;k<6;k++)
{
inds[k]+=(m_dwBase+j)*4;
}
memcpy(pInd,inds,sizeof(inds));
pInd+=sizeof(inds);
itr++;
}
m_pVB->Unlock();
m_pIB->Unlock();
if(FAILED( hr = RGetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,m_dwBase*4,dwThisNum*4,m_dwBase*6,dwThisNum*2) ))
return false;
m_dwBase+=dwThisNum;
dwRemainNum-=dwThisNum;
}
RGetDevice()->SetStreamSource( 0, NULL , 0,0 );
RGetDevice()->SetIndices(NULL);
EndState();
return true;
}