public bool UpdateCapture(ITransformable target, Ray worldRay)
{
// ray-hit with plane perpendicular to rotateAxisW
Vector3 planeHit = raycastFrame.RayPlaneIntersection(worldRay.origin, worldRay.direction, 2);
// find angle of hitpos in 2D plane perp to rotateAxis, and compute delta-angle
Vector3 dv = planeHit - rotateFrameW.Origin;
int iX = (nRotationAxis + 1) % 3;
int iY = (nRotationAxis + 2) % 3;
float fX = Vector3.Dot(dv, rotateFrameW.GetAxis(iX));
float fY = Vector3.Dot(dv, rotateFrameW.GetAxis(iY));
float fNewAngle = (float)Math.Atan2(fY, fX);
float fDeltaAngle = (fNewAngle - fRotateStartAngle);
// construct new frame for target that is rotated around axis
Vector3 rotateAxisL = rotateFrameL.GetAxis(nRotationAxis);
Quaternion q = Quaternion.AngleAxis(fDeltaAngle * Mathf.Rad2Deg, rotateAxisL);
Frame3 newFrame = rotateFrameL;
newFrame.Rotation = q * newFrame.Rotation; // order matters here!
// update target
target.SetLocalFrame(newFrame, CoordSpace.ObjectCoords);
return(true);
}
public void SetLocalFrame(Frame3 newFrame, CoordSpace eSpace)
{
Debug.Assert(eSpace == CoordSpace.ObjectCoords);
Frame3 updateFrame = objectFrame;
curRotation = newFrame.Rotation;
updateFrame.Rotation = curRotation * objectFrame.Rotation;
updateFrame.Origin = newFrame.Origin;
target.SetLocalFrame(updateFrame, eSpace);
}
Vector3 vInitialHitPos; // initial hit position in frame
public bool BeginCapture(ITransformable target, Ray worldRay, UIRayHit hit)
{
// save local and world frames
translateFrameL = target.GetLocalFrame(CoordSpace.ObjectCoords);
translateFrameW = target.GetLocalFrame(CoordSpace.WorldCoords);
// save initial hitpos in translation plane
vInitialHitPos = translateFrameW.RayPlaneIntersection(worldRay.origin, worldRay.direction, nTranslationPlaneNormal);
return(true);
}
static public void EmitDebugFrame(string name, Frame3 f, float fAxisLength, float diameter = 0.05f)
{
GameObject frame = new GameObject(name);
GameObject x = EmitDebugLine(name + "_x", f.Origin, f.Origin + fAxisLength * f.X, diameter, Color.red);
x.transform.parent = frame.transform;
GameObject y = EmitDebugLine(name + "_y", f.Origin, f.Origin + fAxisLength * f.Y, diameter, Color.green);
y.transform.parent = frame.transform;
GameObject z = EmitDebugLine(name + "_z", f.Origin, f.Origin + fAxisLength * f.Z, diameter, Color.blue);
z.transform.parent = frame.transform;
}
public bool EndCapture(Ray ray)
{
if (activeWidget != null)
{
// update widget frame in case we want to do something like stay scene-aligned...
targetWrapper.DoneTransformation();
Frame3 widgetFrame = targetWrapper.GetLocalFrame(CoordSpace.ObjectCoords);
gizmo.transform.localPosition = widgetFrame.Origin;
gizmo.transform.localRotation = widgetFrame.Rotation;
activeWidget = null;
}
return(true);
}
public bool UpdateCapture(Ray worldRay)
{
// update capture if we have an active widget
if (activeWidget != null)
{
if (activeWidget.UpdateCapture(targetWrapper, worldRay))
{
// keep widget synced with object frame of target
Frame3 widgetFrame = targetWrapper.GetLocalFrame(CoordSpace.ObjectCoords);
gizmo.transform.localPosition = widgetFrame.Origin;
gizmo.transform.localRotation = widgetFrame.Rotation;
}
return(true);
}
return(false);
}
public Frame3 GetLocalFrame(CoordSpace eSpace)
{
Frame3 targetFrame = target.GetLocalFrame(eSpace);
if (eSpace == CoordSpace.WorldCoords)
{
return(new Frame3(targetFrame.Origin, parentScene.RootGameObject.transform.rotation));
}
else if (eSpace == CoordSpace.SceneCoords)
{
return(new Frame3(targetFrame.Origin, parentScene.RootGameObject.transform.localRotation));
}
else
{
return(new Frame3(targetFrame.Origin, curRotation * Quaternion.identity));
}
}
void SetActiveFrame(FrameType eFrame)
{
if (eFrame == FrameType.LocalFrame)
{
targetWrapper = new PassThroughWrapper(target);
}
else
{
targetWrapper = new SceneFrameWrapper(parentScene, target);
}
// update gizmo transform to match target frame
Frame3 widgetFrame = targetWrapper.GetLocalFrame(CoordSpace.ObjectCoords);
gizmo.transform.localPosition = widgetFrame.Origin;
gizmo.transform.localRotation = widgetFrame.Rotation;
}
public void Initialize(Cockpit cockpit)
{
Frame3 cockpitF = cockpit.GetLocalFrame(CoordSpace.WorldCoords);
float fHUDRadius = 0.7f;
Color bgColor = new Color(0.7f, 0.7f, 1.0f);
Material bgMaterial = MaterialUtil.CreateTransparentMaterial(bgColor, 0.7f);
Material primMaterial = MaterialUtil.CreateStandardMaterial(Color.yellow);
HUDButton addCylinderButton = new HUDButton()
{
Radius = 0.08f
};
addCylinderButton.Create(PrimitiveType.Cylinder, bgMaterial, primMaterial);
Frame3 cylFrame = addCylinderButton.GetObjectFrame();
Frame3 cylHUDFrame = make_hud_sphere_frame(fHUDRadius, -45.0f, 0.0f);
addCylinderButton.SetObjectFrame(
cylFrame.Translated(cylHUDFrame.Origin)
.Rotated(Quaternion.FromToRotation(cylFrame.Z, cylHUDFrame.Z)));
addCylinderButton.OnClicked += (s, e) => {
cockpit.Parent.Scene.AddCylinder();
};
cockpit.AddUIElement(addCylinderButton, true);
HUDButton addBoxButton = new HUDButton()
{
Radius = 0.08f
};
addBoxButton.Create(PrimitiveType.Cube, bgMaterial, primMaterial);
Frame3 boxFrame = addBoxButton.GetObjectFrame();
Frame3 boxHUDFrame = make_hud_sphere_frame(fHUDRadius, -45.0f, -15.0f);
addBoxButton.SetObjectFrame(
boxFrame.Translated(boxHUDFrame.Origin)
.Rotated(Quaternion.FromToRotation(boxFrame.Z, boxHUDFrame.Z)));
addBoxButton.OnClicked += (s, e) => {
cockpit.Parent.Scene.AddBox();
};
cockpit.AddUIElement(addBoxButton, true);
}
public static void SetGameObjectFrame(GameObject go, Frame3 newFrame, CoordSpace eSpace)
{
if (eSpace == CoordSpace.WorldCoords)
{
go.transform.position = newFrame.Origin;
go.transform.rotation = newFrame.Rotation;
}
else if (eSpace == CoordSpace.ObjectCoords)
{
go.transform.localPosition = newFrame.Origin;
go.transform.localRotation = newFrame.Rotation;
}
else
{
// [RMS] cannot do this w/o handle to scene...
Debug.Log("[MathUtil.SetGameObjectFrame] unsupported!\n");
throw new ArgumentException("not possible without refernce to scene!");
}
}
public bool UpdateCapture(ITransformable target, Ray worldRay)
{
// ray-hit with plane that contains translation axis
Vector3 planeHit = raycastFrame.RayPlaneIntersection(worldRay.origin, worldRay.direction, 2);
// figure out new T-value along axis, then our translation update is delta-t
float fNewT = MathUtil.ClosestPointOnLineT(translateFrameW.Origin, translateAxisW, planeHit);
float fDeltaT = (fNewT - fTranslateStartT);
// construct new frame translated along axis (in local space)
Frame3 newFrame = translateFrameL;
newFrame.Origin += fDeltaT * translateFrameL.GetAxis(nTranslationAxis);
// update target
target.SetLocalFrame(newFrame, CoordSpace.ObjectCoords);
return(true);
}
float fTranslateStartT; // start T-value along translateAxisW
public bool BeginCapture(ITransformable target, Ray worldRay, UIRayHit hit)
{
// save local and world frames
translateFrameL = target.GetLocalFrame(CoordSpace.ObjectCoords);
translateFrameW = target.GetLocalFrame(CoordSpace.WorldCoords);
translateAxisW = translateFrameW.GetAxis(nTranslationAxis);
// save t-value of closest point on translation axis, so we can find delta-t
Vector3 vWorldHitPos = hit.hitPos;
fTranslateStartT = MathUtil.ClosestPointOnLineT(
translateFrameW.Origin, translateAxisW, vWorldHitPos);
// construct plane we will ray-intersect with in UpdateCapture()
Vector3 vForward = Vector3.Cross(Camera.main.transform.up, translateAxisW);
raycastFrame = new Frame3(vWorldHitPos, vForward);
return(true);
}
public bool BeginCapture(ITransformable target, Ray worldRay, UIRayHit hit)
{
// save local and world frames
rotateFrameL = target.GetLocalFrame(CoordSpace.ObjectCoords);
rotateFrameW = target.GetLocalFrame(CoordSpace.WorldCoords);
rotateAxisW = rotateFrameW.GetAxis(nRotationAxis);
// save angle of hitpos in 2D plane perp to rotateAxis, so we can find delta-angle later
Vector3 vWorldHitPos = hit.hitPos;
Vector3 dv = vWorldHitPos - rotateFrameW.Origin;
int iX = (nRotationAxis + 1) % 3;
int iY = (nRotationAxis + 2) % 3;
float fX = Vector3.Dot(dv, rotateFrameW.GetAxis(iX));
float fY = Vector3.Dot(dv, rotateFrameW.GetAxis(iY));
fRotateStartAngle = (float)Math.Atan2(fY, fX);
// construct plane we will ray-intersect with in UpdateCapture()
raycastFrame = new Frame3(vWorldHitPos, rotateAxisW);
return(true);
}
public bool UpdateCapture(ITransformable target, Ray worldRay)
{
// ray-hit with world-space translation plane
Vector3 planeHit = translateFrameW.RayPlaneIntersection(worldRay.origin, worldRay.direction, nTranslationPlaneNormal);
int e0 = (nTranslationPlaneNormal + 1) % 3;
int e1 = (nTranslationPlaneNormal + 2) % 3;
// construct delta in world space and project into frame coordinates
Vector3 delta = (planeHit - vInitialHitPos);
float dx = Vector3.Dot(delta, translateFrameW.GetAxis(e0));
float dy = Vector3.Dot(delta, translateFrameW.GetAxis(e1));
// construct new local frame translated along plane axes
Frame3 newFrame = translateFrameL;
newFrame.Origin += dx * translateFrameL.GetAxis(e0) + dy * translateFrameL.GetAxis(e1);
// update target
target.SetLocalFrame(newFrame, CoordSpace.ObjectCoords);
return(true);
}
public void SetLocalFrame(Frame3 newFrame, CoordSpace eSpace)
{
// note: SceneCoords not supported!
MathUtil.SetGameObjectFrame(RootGameObject, newFrame, eSpace);
}
public Frame3 SceneToWorldF(Frame3 sceneFrame)
{
return(new Frame3(
sceneo.transform.TransformPoint(sceneFrame.Origin),
sceneo.transform.rotation * sceneFrame.Rotation));
}
public Frame3 WorldToSceneF(Frame3 worldFrame)
{
return(new Frame3(
worldFrame.Origin - sceneo.transform.localPosition,
Quaternion.Inverse(sceneo.transform.localRotation) * worldFrame.Rotation));
}
public virtual void SetLocalFrame(Frame3 newFrame, CoordSpace eSpace)
{
MathUtil.SetGameObjectFrame(gameobject, newFrame, eSpace);
}
public void SetObjectFrame(Frame3 value)
{
MathUtil.SetGameObjectFrame(RootGameObject, value, CoordSpace.ObjectCoords);
}
public void SetLocalFrame(Frame3 newFrame, CoordSpace eSpace)
{
target.SetLocalFrame(newFrame, eSpace);
}
public void BeginTransformation()
{
objectFrame = target.GetLocalFrame(CoordSpace.ObjectCoords);
curRotation = Quaternion.identity;
}
public Frame3(Frame3 copy)
{
this.rotation = copy.rotation;
this.origin = copy.origin;
}
