/*---------------------------------------------------------------------- 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; } } }