// ***************************************************************************
void CMaterial::decompUserTexMat(uint stage, float &uTrans, float &vTrans, float &wRot, float &uScale, float &vScale)
{
nlassert(stage < IDRV_MAT_MAXTEXTURES);
nlassert(isUserTexMatEnabled(stage)); // must activate animated texture matrix for this stage
CMatrix convMat; // exported v are already inverted (todo: optim this...)
convMat.setRot(CVector::I, -CVector::J, CVector::K);
convMat.setPos(CVector::J);
const NLMISC::CMatrix texMat = convMat * _TexUserMat->TexMat[stage] * convMat;
/// find the rotation around w
NLMISC::CVector i = texMat.getI();
NLMISC::CVector j = texMat.getJ();
uScale = sqrtf(i.x * i.x + j.x * j.x);
vScale = sqrtf(i.y * i.y + j.y * j.y);
//
i.normalize();
//
float angle = acosf(i.x / i.norm());
if (i.y < 0)
{
angle = 2.f * (float) NLMISC::Pi - angle;
}
wRot = angle;
// compute position
CMatrix InvSR;
InvSR.setRot(texMat.getI(), texMat.getJ(), texMat.getK());
InvSR.invert();
CVector half(0.5f, 0.5f, 0.f);
CVector offset = half + InvSR * (texMat.getPos() -half);
uTrans = - offset.x;
vTrans = - offset.y;
}
/*
* Get the orientation vectors
*/
void CListenerAL::getOrientation( NLMISC::CVector& front, NLMISC::CVector& up ) const
{
// Forward then up
ALfloat v[6];
alGetListenerfv( AL_ORIENTATION, v );
alTestError();
// Coordsys conversion
front.set( v[0], -v[2], v[1] );
up.set( v[3], -v[5], v[4] );
}
/*
* Set the direction vector (3D mode only, ignored in stereo mode) (default: (0,0,0) as non-directional)
*/
void CStreamSource::setDirection(const NLMISC::CVector& dir)
{
CAutoMutex<CMutex> autoMutex(m_BufferMutex);
CSourceCommon::setDirection(dir);
// Set the direction
if (hasPhysicalSource())
{
if (!m_Buffers[0]->isStereo())
{
static bool coneset = false;
if (dir.isNull()) // workaround // For what?
{
getPhysicalSource()->setCone(float(Pi * 2), float(Pi * 2), 1.0f); // because the direction with 0 is not enough for a non-directional source!
getPhysicalSource()->setDirection(CVector::I); // Don't send a 0 vector, DSound will complain. Send (1,0,0), it's omnidirectional anyway.
coneset = false;
}
else
{
// if (!coneset)
{
getPhysicalSource()->setCone(m_StreamSound->getConeInnerAngle(), m_StreamSound->getConeOuterAngle(), m_StreamSound->getConeOuterGain());
coneset = true;
}
getPhysicalSource()->setDirection(dir);
}
}
}
}
void CDirectionEdit::selectNewVect(const CPoint &point)
{
const float epsilon = 10E-3f;
NLMISC::CVector v = _Wrapper->get();
if (point.x > CornerDist && point.y > CornerDist && point.x < (CornerDist + BasisSize) && point.y < (CornerDist + BasisSize))
{
ScreenToVect(v.x, v.z, point.x, point.y, CornerDist, CornerDist, BasisSize);
float d = v.x * v.x + v.z * v.z;
float f;
if (fabsf(d > epsilon))
{
f = sqrtf((1.f - v.y * v.y) / d);
}
else
{
f = 1;
}
v.x *= f;
v.z *= f;
}
if (point.x > CornerDist && point.y > (BasisGap + BasisSize + CornerDist) && point.x < (CornerDist + BasisSize) && point.y < (CornerDist + BasisGap + 2 * BasisSize))
{
ScreenToVect(v.y, v.z, point.x, point.y, CornerDist, CornerDist + BasisGap + BasisSize, BasisSize);
float d = v.y * v.y + v.z * v.z;
float f;
if (fabsf(d > epsilon))
{
f = sqrtf((1.f - v.x * v.x) / d);
}
else
{
f = 1;
}
v.y *= f;
v.z *= f;
}
v.normalize();
_Wrapper->setAndUpdateModifiedFlag(v);
Invalidate();
}
void CDirectionWidget::setNewVecYZ(float x, float y)
{
const float epsilon = 10E-3f;
NLMISC::CVector v = _value;
v.y = x;
v.z = y;
float d = v.y * v.y + v.z * v.z;
float f;
if (fabs(d) > epsilon)
f = sqrt((1.f - v.x * v.x) / d);
else
f = 1;
v.y *= f;
v.z *= f;
v.normalize();
setValue(v);
}
/*
* Get the velocity vector
*/
void CListenerAL::getVelocity( NLMISC::CVector& vel ) const
{
#ifdef NL_OS_WINDOWS
// Coordsys conversion
float glposz;
alGetListener3f( AL_VELOCITY, &vel.x, &vel.z, &glposz );
vel.y = - glposz;
#else
float velarray [3];
alGetListenerfv( AL_VELOCITY, velarray );
// Coordsys conversion
vel.set( velarray[0], -velarray[2], velarray[1] );
#endif
alTestError();
}
void CDirectionWidget::setNewVecYZ(float x, float y)
{
const float epsilon = 10E-3f;
NLMISC::CVector v = _Wrapper->get();
v.y = x;
v.z = y;
float d = v.y * v.y + v.z * v.z;
float f;
if (fabs(d) > epsilon)
f = sqrt((1.f - v.x * v.x) / d);
else
f = 1;
v.y *= f;
v.z *= f;
v.normalize();
_Wrapper->setAndUpdateModifiedFlag(v);
_ui.xzWidget->setVector(_Wrapper->get().x, _Wrapper->get().z);
_ui.yzWidget->setVector(_Wrapper->get().y, _Wrapper->get().z);
}
// ***************************************************************************
void CExportNel::getNELBoneLocalScale(INode &node, TimeValue time, NLMISC::CVector &nelScale)
{
// To get the correct local Scale, we use an other bone as reference (if present)
INode *referenceNode= getNELScaleReferenceNode(node);
// get the Max local pos.
Matrix3 localTM (TRUE);
getLocalMatrix (localTM, node, time);
NLMISC::CVector maxScale;
NLMISC::CQuat maxRot;
NLMISC::CVector maxPos;
decompMatrix (maxScale, maxRot, maxPos, localTM);
// Biped node case, take the scale from ratio with the reference node.
if(isBipedNode(node))
{
// Replace scale with ratio from reference value, if possible
if (referenceNode)
{
ScaleValue scaleValue;
// get my Offset scale.
CVector myScale;
scaleValue = node.GetObjOffsetScale();
myScale.x= scaleValue.s.x;
myScale.y= scaleValue.s.y;
myScale.z= scaleValue.s.z;
// get its Offset scale.
CVector refScale;
scaleValue = referenceNode->GetObjOffsetScale();
refScale.x= scaleValue.s.x;
refScale.y= scaleValue.s.y;
refScale.z= scaleValue.s.z;
// Get The ratio as the result
nelScale.x= myScale.x / refScale.x;
nelScale.y= myScale.y / refScale.y;
nelScale.z= myScale.z / refScale.z;
}
else
{
// Not present, suppose no scale.
nelScale.set(1,1,1);
}
}
// get the scale from std way.
else
{
// We are a normal node here, not biped.
/* If this node do not inherit scale (ie must unherit), then we must not take the localScale computed
with getLocalMatrix. In this case, the local Scale is simply the NodeTM scale.
*/
if( getNELUnHeritFatherScale(node) )
{
Matrix3 nodeTM;
nodeTM = node.GetNodeTM (time);
decompMatrix (maxScale, maxRot, maxPos, nodeTM);
// Get the scale from worldMatrix.
nelScale= maxScale;
}
else
{
// Get the scale from localMatrix.
nelScale= maxScale;
}
}
}
