// creates a button in the desired geometry shape
public void Create(SmoothCockpitTracker tracker, Cockpit cockpit)
{
this.tracker = tracker;
this.cockpit = cockpit;
fGameObject cockpitGO = cockpit.RootGameObject;
Frame3f cockpitF = cockpitGO.GetWorldFrame();
matFixed = MaterialUtil.CreateStandardMaterialF(ColorUtil.ForestGreen);
matTracking = MaterialUtil.CreateStandardMaterialF(ColorUtil.SelectionGold);
matHover = MaterialUtil.CreateStandardMaterialF(ColorUtil.Lighten(ColorUtil.ForestGreen, 0.1f));
matLocked = MaterialUtil.CreateStandardMaterialF(ColorUtil.CgRed);
matLockedHover = MaterialUtil.CreateStandardMaterialF(ColorUtil.Lighten(ColorUtil.CgRed, 0.1f));
indicator = UnityUtil.CreatePrimitiveGO("tracking_indicator", UnityEngine.PrimitiveType.Capsule, matFixed, true);
MaterialUtil.DisableShadows(indicator);
UnityUtil.SetLayerRecursive(indicator, FPlatform.HUDLayer);
indicator.SetLocalScale(0.025f * Vector3f.One);
indicator.RotateD(Vector3f.AxisZ, 90.0f);
Vector3f vDir = (1.0f * cockpitF.Z - 1.0f * cockpitF.Y).Normalized;
indicator.SetPosition(cockpitF.Origin + IndicatorDistance * vDir);
AppendExistingGO(indicator);
//indicator.transform.SetParent(cockpit.RootGameObject.transform, true);
}
public void Create(SOMaterial useMaterial, fGameObject parent)
{
if (curve == null)
{
curve = new DCurve3();
}
meshObject = GameObjectFactory.CreateMeshGO("mesh_tube_preview");
//meshObject.SetMesh(new fMesh())
meshObject.SetMaterial(MaterialUtil.ToMaterialf(useMaterial));
bUpdatePending = true;
parent.AddChild(meshObject, false);
}
public TwoPointFaceSelectionTool(FScene scene, DMeshSO target) : base(scene)
{
TargetSO = target;
indicators = new ToolIndicatorSet(this, scene);
have_source = have_extent = false;
selection_valid = false;
selectionCache = new MeshFaceSelectionCache(target.Mesh);
selectionCache.ChunkMeshMaterial = MaterialUtil.CreateStandardMaterialF(Colorf.Gold);
targetTrackingGO = GameObjectFactory.CreateTrackingGO("track_target", target.RootGameObject);
scene.TransientObjectsParent.AddChild(targetTrackingGO, false);
selectionCache.ChunkMeshParent = targetTrackingGO;
}
public virtual ToolpathSO Create(ToolpathSet toolpaths, SingleMaterialFFFSettings settings, SOMaterial setMaterial)
{
AssignSOMaterial(setMaterial); // need to do this to setup BaseSO material stack
parentGO = GameObjectFactory.CreateParentGO(UniqueNames.GetNext("Toolpath"));
Toolpaths = toolpaths;
Settings = settings;
polylines_valid = false;
PolylinePool = new fGameObjectPool <fPolylineGameObject>(allocate_polyline_go);
PolylinePool.FreeF = (go) => {
//go.SetVertices(EmptyToolpathCurve, false, true);
};
return(this);
}
public void Create(SOMaterial useMaterial, fGameObject parent, int nLayer = -1)
{
if (curve == null)
{
curve = new DCurve3();
}
axis = Frame3f.Identity;
meshObject = GameObjectFactory.CreateMeshGO("revolve_preview");
meshObject.SetMaterial(MaterialUtil.ToMaterialf(useMaterial), true);
if (nLayer != -1)
{
meshObject.SetLayer(nLayer);
}
bUpdatePending = true;
meshObject.SetParent(parent, false);
meshObject.SetLocalScale(1.001f * Vector3f.One);
}
public virtual void initialize(fGameObject go, Colorf color)
{
// ugly...
__VectrosityConfig.Configure();
if (go.GetComponent <MeshFilter>() == null)
{
go.AddComponent <MeshFilter>();
}
if (go.GetComponent <MeshRenderer>() == null)
{
go.AddComponent <MeshRenderer>();
}
List <Vector3> vertices = new List <Vector3>()
{
Vector3f.Zero, Vector3f.Zero
};
vectorLine = new VectorLine(go.GetName() + "_vline", vertices, 1.0f, LineType.Continuous);
VectorManager.ObjectSetup(go, vectorLine, Visibility.Dynamic, Brightness.None);
vectorLine.SetColor(color);
}
public BoundaryCurveSet(fGameObject parentGO, fMaterial curveMaterial)
{
this.parentGO = parentGO;
this.curveMaterial = curveMaterial;
}
public IEnumerator UpdateGeometryOnMainThread()
{
if (Deviation == null)
{
yield break;
}
if (Deviation.DeviationPoints.Count == 0)
{
yield break;
}
if (is_disconnected)
{
yield break;
}
if (internalSO == null)
{
internalSO = new GOWrapperSO();
internalSO.Create(GameObjectFactory.CreateParentGO("toolpath_deviation_so"));
CC.ActiveScene.AddSceneObject(internalSO);
internalSO.SetLocalFrame(SO.GetLocalFrame(CoordSpace.SceneCoords), CoordSpace.SceneCoords);
SOFrameLink link = new SOFrameLink(internalSO, SO);
CC.ActiveScene.LinkManager.AddLink(link);
}
var settings = SO.GetSettings();
double nozzleDiam = settings.Machine.NozzleDiamMM;
double tolerance = nozzleDiam * 0.5 + DeviationToleranceMM;
float layerHeight = (float)settings.LayerHeightMM;
float ptWidth = (float)nozzleDiam * 0.5f;
// probably should just make a mesh for all these...
int counter = 0;
int N = Deviation.DeviationPoints.Count;
for (int i = 0; i < N; ++i)
{
if (is_disconnected)
{
yield break;
}
DeviationPt pt = Deviation.DeviationPoints[i];
fMaterial useMaterial = HighDeviationMaterial;
if (pt.dist < tolerance * 1.5)
{
useMaterial = LowDeviationMaterial;
}
//else if (pt.dist < tolerance * 1.2)
// useMaterial = LowDeviationMaterial;
fGameObject go = GameObjectFactory.CreateBoxGO("deviation", ptWidth, layerHeight, ptWidth, useMaterial, true, false);
go.SetLocalPosition((Vector3f)pt.pos);
internalSO.AppendNewGO(go, internalSO.RootGameObject, false);
go.SetLayer(FPlatform.WidgetOverlayLayer);
PointGOs.Add(go);
if (counter++ == 10)
{
counter = 0;
yield return(null);
}
}
}
public void UpdateTracking(Cockpit cockpit, fCamera camera)
{
fGameObject cockpitGO = cockpit.RootGameObject;
if (!bInitialized)
{
currentFrame = cockpit.GetLevelViewFrame(CoordSpace.WorldCoords);
currentFrame.ConstrainedAlignAxis(2, Vector3f.AxisZ, Vector3f.AxisY);
bInitialized = true;
}
Vector3f vCamFW = camera.Forward();
vCamFW[1] = 0; vCamFW.Normalize(); // I don't think this is strictly necessary but
// better to be safe for now...
Vector3f vCamPos = camera.GetPosition();
//if (tracking_debug == null)
// tracking_debug = UnityUtil.CreatePrimitiveGO("tracking_indicator", PrimitiveType.Sphere, MaterialUtil.CreateStandardMaterial(Color.green), false);
//tracking_debug.transform.position = vCamPos + 15.0f * vCamFW;
//if (tracking_avg == null) {
// tracking_avg = UnityUtil.CreatePrimitiveGO("tracking_indicator", PrimitiveType.Sphere, MaterialUtil.CreateStandardMaterial(Color.blue), false);
// tracking_avg.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
//}
//tracking_avg.transform.position = vCamPos + 10.0f * vSlowViewDirTrack;
//tracking_debug.SetVisible(false);
//tracking_avg.SetVisible(false);
if (vSlowViewDirTrack == Vector3f.Zero)
{
vSlowViewDirTrack = vCamFW;
}
float slowTrackSpeed = 0.05f;
vSlowViewDirTrack = VRUtil.AngleLerp(vSlowViewDirTrack, vCamFW, slowTrackSpeed);
// head position tracking
if (IsLocked == false)
{
cockpitGO.SetPosition(vCamPos);
}
//Vector3 vDelta = (camera.transform.position - RootGameObject.transform.position);
//if (vDelta.magnitude > 0.2f)
// RootGameObject.transform.position = camera.transform.position;
////else if ( vDelta.magnitude > 0.05f)
//else
// RootGameObject.transform.position =
// (1.0f - TrackingSpeed) * RootGameObject.transform.position +
// (TrackingSpeed) * camera.transform.position;
float RotationSpeed = 200.0f;
float WarmupTrackingAngleThresh = 55.0f;
float ImmediateTrackingAngleThresh = 65.0f;
float StopTrackingAngleThresh = 5.0f;
float TrackingWarmupDelay = 2.0f;
float TrackingCooldownDelay = 0.75f;
//Vector3 vCockpitFW = cockpitGO.transform.forward;
Vector3f vCockpitFW = currentFrame.Z;
float fSlowHDeviation = VRUtil.PlaneAngle(vCockpitFW, vSlowViewDirTrack);
float fActualViewDeviation = VRUtil.PlaneAngle(vCockpitFW, vCamFW);
bool bDoTrack = false;
if (eState == TrackingState.NotTracking)
{
//tracking_debug.GetComponent<Renderer>().material = MaterialUtil.CreateStandardMaterial(Color.green);
if (fSlowHDeviation > WarmupTrackingAngleThresh)
{
set_tracking_state(TrackingState.TrackingWarmup);
stateChangeStartTime = FPlatform.RealTime();
}
}
else if (eState == TrackingState.TrackingWarmup)
{
//tracking_debug.GetComponent<Renderer>().material = MaterialUtil.CreateStandardMaterial(Color.yellow);
if (fSlowHDeviation > ImmediateTrackingAngleThresh)
{
set_tracking_state(TrackingState.Tracking);
}
else if (fSlowHDeviation > WarmupTrackingAngleThresh)
{
if ((FPlatform.RealTime() - stateChangeStartTime) > TrackingWarmupDelay)
{
set_tracking_state(TrackingState.Tracking);
}
}
else
{
set_tracking_state(TrackingState.NotTracking);
}
}
else if (eState == TrackingState.Tracking)
{
bDoTrack = true;
//tracking_debug.GetComponent<Renderer>().material = MaterialUtil.CreateStandardMaterial(Color.red);
if (fActualViewDeviation < StopTrackingAngleThresh)
{
set_tracking_state(TrackingState.TrackingCooldown);
stateChangeStartTime = FPlatform.RealTime();
}
}
else if (eState == TrackingState.TrackingCooldown)
{
bDoTrack = true;
//tracking_debug.GetComponent<Renderer>().material = MaterialUtil.CreateStandardMaterial(Color.gray);
if (fActualViewDeviation < StopTrackingAngleThresh)
{
if ((FPlatform.RealTime() - stateChangeStartTime) > TrackingCooldownDelay)
{
set_tracking_state(TrackingState.NotTracking);
bDoTrack = false;
}
}
else
{
set_tracking_state(TrackingState.Tracking);
}
}
if (IsLocked)
{
bDoTrack = false;
set_tracking_state(TrackingState.NotTracking);
}
if (bDoTrack)
{
float dt = (float)(FPlatform.RealTime() - animation_last_time);
float fDelta = RotationSpeed * dt;
Vector3f vCurrent = new Vector3f(vCockpitFW[0], 0, vCockpitFW[2]).Normalized;
Vector3f vTarget = new Vector3f(vSlowViewDirTrack[0], 0, vSlowViewDirTrack[2]).Normalized;
//Vector3 vTarget = new Vector3(vCamFW[0], 0, vCamFW[2]).normalized;
Vector3f c = Vector3f.Cross(vCurrent, vTarget);
float a = Vector3f.AngleD(vCurrent, vTarget);
float fSign = (c[1] < 0) ? -1.0f : 1.0f;
float fRotAngle = Math.Min(a, fDelta) * fSign;
currentFrame.Rotate(Quaternionf.AxisAngleD(Vector3f.AxisY, fRotAngle));
}
cockpitGO.SetRotation(currentFrame.Rotation);
animation_last_time = FPlatform.RealTime();
if (indicator == null)
{
indicator = new CockpitTrackingWidget();
indicator.Create(this, cockpit);
cockpit.AddUIElement(indicator, false);
}
indicator.EnableIndicator = show_indicator;
}
public virtual void initialize(fGameObject go, fMaterial material, bool bSharedMaterial)
{
initialize(go, material.color);
}
