/*----------------------------------------------------------------------
ApplyYToAllBoxes : Recursivly apply the property
----------------------------------------------------------------------*/
static void ApplyYToAllBoxes (PtrAbstractBox pAb, float result)
{
PtrBox pBox;
PtrElement El;
PtrTransform Trans = NULL;
int doc, view;
while (pAb)
{
pBox = pAb->AbBox;
pBox->VisibleModification = TRUE;
if (pAb->AbElement->ElSystemOrigin)
{
El = pAb->AbElement;
if (El->ElTransform)
Trans = GetTransformation (El->ElTransform, PtElTranslate);
if (Trans == NULL)
{
Trans = (PtrTransform)TtaNewTransformTranslate (0, result);
FrameToView (Animated_Frame, &doc, &view);
TtaReplaceTransform ((Element) El, Trans, doc);
}
Trans->YScale = result;
}
else
{
if (pAb->AbLeafType == LtText)
result -= BoxFontBase (pBox->BxFont);
pBox->BxYOrg = (int)result;
ApplyYToAllBoxes (pAb->AbFirstEnclosed, result);
}
pAb = pAb->AbNext;
}
}
void ezConeAngleGizmo::SetAngle(ezAngle angle)
{
m_Angle = angle;
m_fAngleScale = ezMath::Tan(m_Angle * 0.5f);
// update the scale
OnTransformationChanged(GetTransformation());
}
Ogre::Vector3 Box::GetClosestPoint(Vector3 const& p) const
{
// transform into local space
Vector3 op = GetTransformation().inverseAffine()*p;
Vector3 hs = GetHalfSize();
if(fabs(op.x) < hs.x && fabs(op.y) < hs.y && fabs(op.z) < hs.z)
{
// point inside box
return p;
}
Vector3 oc = Vector3(
std::min(std::max(op.x, -hs.x), hs.x),
std::min(std::max(op.y, -hs.y), hs.y),
std::min(std::max(op.z, -hs.z), hs.z));
return GetTransformation()*oc;
}
Matrix3 RigidBody::GetInverseInertialTensor() const
{
Vector3 diagonal = GetLocalInverseInertialTensor();
Matrix3 localInverseTensor = Matrix3::ZERO;
localInverseTensor[0][0] = diagonal.x;
localInverseTensor[1][1] = diagonal.y;
localInverseTensor[2][2] = diagonal.z;
Matrix3 rotation;
GetTransformation().extract3x3Matrix(rotation);
return rotation.Transpose() * localInverseTensor * rotation;
}
void JSprite::Draw() const
{
glPushMatrix();
if ( !useCamera )
glLoadIdentity();
glMultMatrixf( GetTransformation().Transpose() );
glBegin( GL_QUADS );
glTexCoord2f( textureCoord.left, textureCoord.top ); glVertex2f( 0.0f, 0.0f );
glTexCoord2f( textureCoord.right, textureCoord.top ); glVertex2f( 1.0f, 0.0f );
glTexCoord2f( textureCoord.right, textureCoord.bottom ); glVertex2f( 1.0f, 1.0f );
glTexCoord2f( textureCoord.left, textureCoord.bottom); glVertex2f( 0.0f, 1.0f );
glEnd();
glPopMatrix();
}
void Box::GetExtentsAlongAxis(Vector4 const& v, float & a, float & b) const
{
// The implementation of this function is optimized to the point of opacity.
// If you're interested in its inner workings, contact me directly.
// transform v into object space.
Vector4 ov = TransformPlane(v, GetTransformation().inverseAffine());
Vector3 ov3(ov.x, ov.y, ov.z);
// note: ov3 is unit length
// distance from center of box to plane
float dc = ov.w;
// distances along ov from center to each of the positive three faces, abs'ed and summed
float extDist = GetHalfSize().absDotProduct(ov3);
a = dc - extDist;
b = dc + extDist;
}
Ray Camera::ScreenPointToRay(const Vector2 point) const {
Matrix4x4 view = GetTransformation()->GetAccumulatedMatrix();
Vector3 camPos = Vector3(view.Get(3,0), view.Get(3,1), view.Get(3,2));
Matrix4x4 vp = GetProjectionMatrix() * view;
if (!Invert(vp)) Debug::LogError("Failed to invert view projection matrix");
// Convert from screen space to viewport space and to [-1;1] range.
float viewportX = (point.Get(0) - rect.x) * 2.0f / float(rect.width) - 1.0f;
float viewportY = (point.Get(1) - rect.y) * 2.0f / float(rect.height) - 1.0f;
Vector4 viewportPoint = Vector4(viewportX, viewportY, 1.0f, 1.0f);
Vector4 worldPos = vp * viewportPoint;
Vector3 rayEnd = Vector3(worldPos.Get(0) / worldPos.Get(3),
worldPos.Get(1) / worldPos.Get(3),
worldPos.Get(2) / worldPos.Get(3));
return Ray(camPos, Normalize(rayEnd - camPos));
}
ezEditorInput ezConeAngleGizmo::DoMouseMoveEvent(QMouseEvent* e)
{
if (!IsActiveInputContext())
return ezEditorInput::MayBeHandledByOthers;
const ezTime tNow = ezTime::Now();
if (tNow - m_LastInteraction < ezTime::Seconds(1.0 / 25.0))
return ezEditorInput::WasExclusivelyHandled;
m_LastInteraction = tNow;
const ezVec2I32 vNewMousePos = ezVec2I32(e->globalPos().x(), e->globalPos().y());
const ezVec2I32 vDiff = vNewMousePos - m_LastMousePos;
m_LastMousePos = UpdateMouseMode(e);
const float fSpeed = 0.02f;
const ezAngle aSpeed = ezAngle::Degree(1.0f);
{
m_Angle += vDiff.x * aSpeed;
m_Angle -= vDiff.y * aSpeed;
m_Angle = ezMath::Clamp(m_Angle, ezAngle(), ezAngle::Degree(179.0f));
m_fAngleScale = ezMath::Tan(m_Angle * 0.5f);
}
// update the scale
OnTransformationChanged(GetTransformation());
ezGizmoEvent ev;
ev.m_pGizmo = this;
ev.m_Type = ezGizmoEvent::Type::Interaction;
m_GizmoEvents.Broadcast(ev);
return ezEditorInput::WasExclusivelyHandled;
}
/// \brief
/// Copies essential data to passed-in instance, e.g. initial name and transformation, etc..
///
/// \param inst
/// Instance to copy data to
virtual void CopyEssentialsToInstance(VGInstance& inst) const {
inst.SetName(GetName());
inst.SetTransformation(GetTransformation());
}
void Cube::Paint (Renderer *renderer) {
renderer->RenderCube (GetTransformation (), color, GetSelectionPointer ());
Widget::Paint (renderer);
}
/*----------------------------------------------------------------------
animate_box_transformation : animate the scale, translate, skew, rotate...
----------------------------------------------------------------------*/
static void animate_box_transformation (PtrElement El,
Animated_Element *animated,
AnimTime current_time)
{
int doc, view;
float fx, fy, tx, ty, rotf, rott;
float result;
long int trans_type;
PtrTransform Trans = NULL;
char* ptr;
if (animated->AttrName == NULL)
return;
trans_type = (long int)(animated->AttrName);
/*translate, scale, rotate_, skewX, skewY*/
switch (trans_type)
{
case 1 : /* translate */
FrameToView (Animated_Frame, &doc, &view);
tx = ty = fx = fy = 0; /* default values */
/* parse the "to" attribute */
ptr = (char *) animated->to;
ptr = skipWsp (ptr);
tx = T_atof (ptr);
ptr = skipNumber (ptr);
ptr = skipCommaWsp (ptr);
if (*ptr == EOS)
ty = tx;
else
ty = T_atof (ptr);
/* parse the "from" attribute */
ptr = (char *) animated->from;
ptr = skipWsp (ptr);
fx = T_atof (ptr);
ptr = skipNumber (ptr);
ptr = skipCommaWsp (ptr);
if (*ptr == EOS)
fy = fx;
else
fy = T_atof (ptr);
tx = (float) interpolate_double_value (fx,
tx,
current_time,
animated->duration);
ty = (float) interpolate_double_value (fy,
ty,
current_time,
animated->duration);
if (El->ElTransform)
Trans = GetTransformation (El->ElTransform,
PtElTranslate);
if (Trans == NULL)
{
Trans = (PtrTransform)TtaNewTransformTranslate (tx, ty);
TtaReplaceTransform ((Element) El, Trans, doc);
}
Trans->XScale = tx;
Trans->YScale = ty;
break;
case 2 : /* scale */
FrameToView (Animated_Frame, &doc, &view);
tx = ty = fx = fy = 0; /* default values */
/* parse the "to" attribute */
ptr = (char *) animated->to;
ptr = skipWsp (ptr);
tx = T_atof (ptr);
ptr = skipNumber (ptr);
ptr = skipCommaWsp (ptr);
if (*ptr == EOS)
ty = tx;
else
ty = T_atof (ptr);
/* parse the "from" attribute */
ptr = (char *) animated->from;
ptr = skipWsp (ptr);
fx = T_atof (ptr);
ptr = skipNumber (ptr);
ptr = skipCommaWsp (ptr);
if (*ptr == EOS)
fy = fx;
else
fy = T_atof (ptr);
tx = (float) interpolate_double_value (fx,
tx,
current_time,
animated->duration);
ty = (float) interpolate_double_value (fy,
ty,
current_time,
animated->duration);
if (El->ElTransform)
Trans = GetTransformation (El->ElTransform,
PtElScale);
if (Trans == NULL)
{
Trans = (PtrTransform)TtaNewTransformScale (tx, ty);
TtaReplaceTransform ((Element) El, Trans, doc);
}
Trans->XScale = tx;
Trans->YScale = ty;
break;
case 3 : /* Rotate */
FrameToView (Animated_Frame, &doc, &view);
rott = tx = ty = rotf = fx = fy = 0; /* default values */
/* parse the "to" attribute */
ptr = (char *) animated->to;
ptr = skipWsp (ptr);
rott = T_atof (ptr); /* angle */
ptr = skipNumber (ptr);
ptr = skipCommaWsp (ptr);
if (*ptr != EOS)
{
tx = T_atof (ptr); /* x coord. of center of rotation */
ptr = skipNumber (ptr);
ptr = skipCommaWsp (ptr);
ty = T_atof (ptr); /* y coord. of center of rotation */
}
/* parse the "from" attribute */
ptr = (char *) animated->from;
ptr = skipWsp (ptr);
rotf = T_atof (ptr); /* angle */
ptr = skipNumber (ptr);
ptr = skipCommaWsp (ptr);
if (*ptr != EOS)
{
fx = T_atof (ptr); /* x coord. of center of rotation */
ptr = skipNumber (ptr);
ptr = skipCommaWsp (ptr);
fy = T_atof (ptr); /* y coord. of center of rotation */
}
if (tx && fx)
tx = (float) interpolate_double_value (fx,
tx,
current_time,
animated->duration);
if (ty && fy)
ty = (float) interpolate_double_value (fy,
ty,
current_time,
animated->duration);
rott = (float)interpolate_double_value (rotf,
rott,
current_time,
animated->duration);
if (El->ElTransform)
Trans = GetTransformation (El->ElTransform,
PtElRotate);
if (Trans == NULL)
{
Trans = (PtrTransform)TtaNewTransformRotate (rott, tx, ty);
TtaReplaceTransform ((Element) El, Trans, doc);
}
Trans->TrAngle = rott;
Trans->XRotate = tx;
Trans->YRotate = ty;
break;
case 4 : /* skewX */
FrameToView (Animated_Frame, &doc, &view);
/* parse the "to" attribute */
ptr = (char *) animated->to;
ptr = skipWsp (ptr);
tx = T_atof (ptr);
/* parse the "from" attribute */
ptr = (char *) animated->from;
ptr = skipWsp (ptr);
fx = T_atof (ptr);
result = (float)interpolate_double_value (fx,
tx,
current_time,
animated->duration);
if (El->ElTransform)
Trans = GetTransformation (El->ElTransform,
PtElSkewX);
if (Trans == NULL)
{
Trans = (PtrTransform)TtaNewTransformSkewX (result);
TtaReplaceTransform ((Element) El, Trans, doc);
}
Trans->TrFactor = result;
break;
case 5 : /* skewY */
FrameToView (Animated_Frame, &doc, &view);
/* parse the "to" attribute */
ptr = (char *) animated->to;
ptr = skipWsp (ptr);
ty = T_atof (ptr);
/* parse the "from" attribute */
ptr = (char *) animated->from;
ptr = skipWsp (ptr);
fy = T_atof (ptr);
result = (float)interpolate_double_value (fy,
ty,
current_time,
animated->duration);
if (El->ElTransform)
Trans = GetTransformation (El->ElTransform,
PtElSkewY);
if (Trans == NULL)
{
Trans = (PtrTransform)TtaNewTransformSkewY (result);
TtaReplaceTransform ((Element) El, Trans, doc);
}
Trans->TrFactor = result;
break;
}
}
/*----------------------------------------------------------------------
animate_box_motion : Animate the position of a box using a path
----------------------------------------------------------------------*/
static void animate_box_motion (PtrElement El, Animated_Element *animated,
AnimTime current_time)
{
AnimPath *pop_path;
float *proportion;
float result;
float x,y,x1,y1,x2,y2;
int doc, view,i;
PtrAbstractBox pAb = NULL;
PtrTransform Trans = NULL;
pop_path = (AnimPath *) animated->from;
proportion = pop_path->Proportion;
result = (float) interpolate_double_value (0, 1,
current_time,
animated->duration);
i = 0;
while (result > proportion[i] && i < (pop_path->npoints - 1))
i++;
if (i > 0)
{
x2 = (float)pop_path->Path[i].x;
y2 = (float)pop_path->Path[i].y;
x1 = (float)pop_path->Path[i-1].x;
y1 = (float)pop_path->Path[i-1].y;
result = (result - proportion[i-1]) / (proportion[i] - proportion[i-1]);
x = x1 + (result*(x2 -x1));
y = y1 + (result*(y2 -y1));
FrameToView (Animated_Frame, &doc, &view);
pAb = El->ElAbstractBox[view - 1];
if (pAb)
if (pAb->AbFirstEnclosed)
{
ApplyXToAllBoxes (pAb->AbFirstEnclosed, 0);
ApplyYToAllBoxes (pAb->AbFirstEnclosed, 0);
if (El->ElTransform)
Trans = GetTransformation (El->ElTransform,
PtElAnimTranslate);
if (Trans == NULL)
{
Trans = (PtrTransform)TtaNewTransformAnimTranslate (x, y);
TtaReplaceTransform ((Element) El, Trans, doc);
}
Trans->XScale = x;
Trans->YScale = y;
}
/*calculate normals to the path and rotate accordingly*/
if (0)
{
if (El->ElTransform)
Trans = GetTransformation (El->ElTransform,
PtElAnimRotate);
if (Trans == NULL)
{
Trans = (PtrTransform)TtaNewTransformAnimRotate (pop_path->Tangent_angle[i], 0, 0);
TtaReplaceTransform ((Element) El, Trans, doc);
}
Trans->TrAngle = pop_path->Tangent_angle[i];
Trans->XRotate = 0;
Trans->YRotate = 0;
}
}
}
