public SearchWorker(Search search, InnerResult rootResult, Game game, SearchResults searchResults)
{
_game = game;
_search = search;
_searchResults = searchResults;
_parentResult = new Trackable<InnerResult>(rootResult).Initialize(game.ChangeTracker);
_moveIndex.Initialize(game.ChangeTracker);
}
private Trackable trackable; // 생성된 타겟 정보. 한 번에 하나만 가능
#endregion Fields
#region Methods
public void Awake()
{
mTargetBuildingBehaviour = GetComponent<UserDefinedTargetBuildingBehaviour>();
if (mTargetBuildingBehaviour)
{
mTargetBuildingBehaviour.RegisterEventHandler(this);
Debug.Log("Registering to the events of IUserDefinedTargetEventHandler");
}
trackable = null;
}
// 생성된 스테이지 타겟정보와 타겟 오브젝트를 지운다.
public void ClearTarget()
{
mImageTracker.DeactivateDataSet(mBuiltDataSet);
mBuiltDataSet.Destroy(trackable, true);
trackable = null;
objTarget = null;
mImageTracker.ActivateDataSet(mBuiltDataSet);
}
public Blocker(Card card, Attacker attacker, Game game)
{
Card = card;
Game = game;
_attacker = new Trackable<Attacker>(attacker);
_attacker.Initialize(ChangeTracker);
_assignedDamage.Initialize(ChangeTracker);
_damageAssignmentOrder.Initialize(ChangeTracker);
}
void ICopyContributor.AfterMemberCopy(object original)
{
_steps = CreateStepNodes();
var currentStep = _steps.First(x => x.Step == Turn.Step);
var currentState = currentStep.States.First(x => x.Id == Turn.State);
_currentStep = new Trackable<StepNode>(currentStep);
_currentState = new Trackable<StateNode>(currentState);
_currentStep.Initialize(ChangeTracker);
_currentState.Initialize(ChangeTracker);
}
public void GetTrackables <T>(List <T> trackables, TrackableQueryFilter filter) where T : Trackable
{
if (m_LastUpdateFrame < Time.frameCount)
{
// Get trackables updated this frame.
m_NativeSession.FrameApi.GetUpdatedTrackables(m_UpdatedTrackables);
// Get all the trackables in the session.
m_NativeSession.SessionApi.GetAllTrackables(m_AllTrackables);
// Find trackables that are not in the hashset (new).
m_NewTrackables.Clear();
for (int i = 0; i < m_AllTrackables.Count; i++)
{
Trackable trackable = m_AllTrackables[i];
if (!m_OldTrackables.Contains(trackable))
{
m_NewTrackables.Add(trackable);
m_OldTrackables.Add(trackable);
}
}
m_LastUpdateFrame = Time.frameCount;
}
trackables.Clear();
if (filter == TrackableQueryFilter.All)
{
for (int i = 0; i < m_AllTrackables.Count; i++)
{
_SafeAdd <T>(m_AllTrackables[i], trackables);
}
}
else if (filter == TrackableQueryFilter.New)
{
for (int i = 0; i < m_NewTrackables.Count; i++)
{
_SafeAdd <T>(m_NewTrackables[i], trackables);
}
}
else if (filter == TrackableQueryFilter.Updated)
{
for (int i = 0; i < m_UpdatedTrackables.Count; i++)
{
_SafeAdd <T>(m_UpdatedTrackables[i], trackables);
}
}
}
protected void Reset()
{
vehicle = GetComponent <Vehicle>();
characterController = GetComponent <RigidbodyCharacterController>();
m_Animator = GetComponent <Animator>();
trackable = GetComponent <Trackable>();
m_Animator = GetComponent <Animator>();
capsuleCollider = GetComponent <CapsuleCollider>();
Collider[] collidersArray = transform.GetComponentsInChildren <Collider>();
foreach (Collider collider in collidersArray)
{
bodyColliders.Add(collider);
}
}
private void MoveTrackedObjectToPose(Trackable plane, Pose pose)
{
//move the object to the center of tracked plane.
trackedObject.transform.position = pose.position;
trackedObject.transform.rotation = pose.rotation;
//make the object look at the camera.
Vector3 camPos = firstPersonCamera.transform.position;
camPos.y = trackedObject.transform.position.y;
trackedObject.transform.LookAt(camPos);
//spawn anchor and parent object to it
var anchor = plane.CreateAnchor(pose);
trackedObject.transform.parent = anchor.transform;
}
protected void Awake()
{
trackables = transform.GetComponentsInChildren <Trackable>();
if (trackables.Length > 0)
{
originalTeam = trackables[0].Team;
}
rootTrackable = GetComponent <Trackable>();
targetSelectors = transform.GetComponentsInChildren <TargetSelector>();
vehicle.onEntered.AddListener(OnVehicleEntered);
vehicle.onExited.AddListener(OnVehicleExited);
}
public ActionResult Edit(TrackableViewModel trackableViewModel)
{
if (ModelState.IsValid)
{
Trackable trackable = Mapper.Map <TrackableViewModel, Trackable>(trackableViewModel);
_trackablesServices.UpdateTrackable(trackable);
return(RedirectToAction("Index"));
}
else
{
return(View(trackableViewModel));
}
}
/// <summary>
/// Set the target.
/// </summary>
/// <param name="target">The new target.</param>
public virtual void SetTarget(Trackable target)
{
if (targetLocker != null)
{
targetLocker.SetTarget(target);
}
if (targetLeader != null)
{
targetLeader.SetTarget(target);
}
if (targetProximityTrigger != null)
{
targetProximityTrigger.SetTarget(target);
}
}
/// <summary>
/// Takes a new trackable source and adds it to the dataset
/// This gets called automatically as soon as you 'BuildNewTarget with UserDefinedTargetBuildingBehaviour
/// </summary>
public void OnNewTrackableSource(TrackableSource trackableSource)
{
mTargetCounter++;
// deactivates the dataset first
mObjectTracker.DeactivateDataSet(mBuiltDataSet);
// Destroy the oldest target if the dataset is full or the dataset
// already contains five user-defined targets.
if (mBuiltDataSet.HasReachedTrackableLimit() || mBuiltDataSet.GetTrackables().Count() >= 5)
{
IEnumerable <Trackable> trackables = mBuiltDataSet.GetTrackables();
Trackable oldest = null;
foreach (Trackable trackable in trackables)
{
if (oldest == null || trackable.ID < oldest.ID)
{
oldest = trackable;
}
}
if (oldest != null)
{
Debug.Log("Destroying oldest trackable in UDT dataset: " + oldest.Name);
mBuiltDataSet.Destroy(oldest, true);
}
}
// get predefined trackable and instantiate it
ImageTargetBehaviour imageTargetCopy = (ImageTargetBehaviour)Instantiate(ImageTargetTemplate);
imageTargetCopy.gameObject.name = "UserDefinedTarget-" + mTargetCounter;
// add the duplicated trackable to the data set and activate it
mBuiltDataSet.CreateTrackable(trackableSource, imageTargetCopy.gameObject);
// activate the dataset again
mObjectTracker.ActivateDataSet(mBuiltDataSet);
//Extended Tracking with user defined targets only works with the most recently defined target.
//If tracking is enabled on previous target, it will not work on newly defined target.
//Don't need to call this if you don't care about extended tracking.
StopExtendedTracking();
mObjectTracker.Stop();
mObjectTracker.ResetExtendedTracking();
mObjectTracker.Start();
}
public void Add(TKey key, TValue value)
{
TR.Enter();
if (dictionary.TryGetValue(key, out Trackable trackable) && trackable.State != TrackState.Deleted)
{
TR.Exit();
throw new ArgumentException();
}
dictionary[key] = new Trackable
{
Key = key,
Item = value,
State = trackable == null ? TrackState.Added : TrackState.Changed
};
TR.Exit();
}
void Update()
{
DisableAllTrackables();
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
TrackingResult trackingResult = state.GetTrackingResult();
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
for (int i = 0; i < trackingResult.GetCount(); i++)
{
Trackable trackable = trackingResult.GetTrackable(i);
imageTrackablesMap[trackable.GetName()].OnTrackSuccess(
trackable.GetId(), trackable.GetName(), trackable.GetPose());
}
}
public void StopTrack(Trackable trackable)
{
//Ensure node exists
Node2D node = trackable.GetTrackingNode();
if (node == null)
{
GD.Print("CameraTrack.StopTracking(Trackable): Trackable.GetTrackingNode() did not return a valid Node2D");
return;
}
if (!this.tracking.Remove(node))
{
GD.Print("CameraTrack.StopTracking(Trackable): Unable to find Trackable.GetTrackingNode() in this.tracking");
}
}
/// <summary>
/// Called when a new target is tracked.
/// </summary>
/// <param name="newTarget">The new target.</param>
public virtual void OnStartedTrackingTarget(Trackable target)
{
if (hostileTeams.Contains(target.Team))
{
// If a hostile is not currently detected, raise the alarm
if (numHostilesTracked == 0)
{
if (hostileTeamDetectedAudio != null)
{
hostileTeamDetectedAudio.PlayDelayed(hostileAlarmDelay);
}
}
numHostilesTracked += 1;
}
}
public void OnNewTrackableSource(TrackableSource trackableSource)
{
this.targetCounter++;
//deactivate dataset first
this.objectTracker.DeactivateDataSet(this.userDefinedSet);
// Destroy the oldest target if the dataset is full or the dataset
// already contains five user-defined targets.
if (this.userDefinedSet.HasReachedTrackableLimit() || this.userDefinedSet.GetTrackables().Count() >= MAX_UD_TARGETS)
{
IEnumerable <Trackable> trackables = this.userDefinedSet.GetTrackables();
Trackable oldest = null;
foreach (Trackable trackable in trackables)
{
if (oldest == null || trackable.ID < oldest.ID)
{
oldest = trackable;
}
}
if (oldest != null)
{
Debug.Log("Destroying oldest trackable in UDT dataset: " + oldest.Name);
this.userDefinedSet.Destroy(oldest, false);
}
}
// Get predefined trackable and instantiate it
//ImageTargetBehaviour imageTargetCopy = Instantiate(this.imageTargetTemplate);
//imageTargetCopy.gameObject.name = "UserDefinedTarget-" + this.targetCounter;
// Add the duplicated trackable to the data set and activate it
this.userDefinedSet.CreateTrackable(trackableSource, this.imageTargetTemplate.gameObject);
// Activate the dataset again
this.objectTracker.ActivateDataSet(this.userDefinedSet);
this.objectTracker.Stop();
this.imageTargetTemplate.ImageTarget.StartExtendedTracking();
this.objectTracker.ResetExtendedTracking();
this.objectTracker.Start();
// Make sure TargetBuildingBehaviour keeps scanning...
this.buildingBehaviour.StartScanning();
}
/// <summary>
/// Try to Get a specific key from current cached dictionary.
/// Otherwise, tries to get from internal data with TryGetInternal.
/// </summary>
/// <param name="key">Key to be searched.</param>
/// <param name="factory">Function that may replace current object stored.
/// If object already exists the factory passed as parameter will not be used.
/// </param>
public TValue GetAndChange(TKey key, Func <TValue> factory = null)
{
lock (dictionary)
{
if (dictionary.TryGetValue(key, out Trackable trackable))
{
if (trackable.State == TrackState.Deleted)
{
if (factory == null)
{
return(null);
}
trackable.Item = factory();
trackable.State = TrackState.Changed;
}
else if (trackable.State == TrackState.None)
{
trackable.State = TrackState.Changed;
changeSet.Add(key);
}
}
else
{
trackable = new Trackable
{
Key = key,
Item = TryGetInternal(key)
};
if (trackable.Item == null)
{
if (factory == null)
{
return(null);
}
trackable.Item = factory();
trackable.State = TrackState.Added;
}
else
{
trackable.State = TrackState.Changed;
}
dictionary.Add(key, trackable);
changeSet.Add(key);
}
return(trackable.Item);
}
}
void Update()
{
DisableAllTrackables();
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
TrackingResult trackingResult = state.GetTrackingResult();
for (int i = 0; i < trackingResult.GetCount(); i++)
{
Trackable trackable = trackingResult.GetTrackable(i);
//Debug.Log("Trackable add: " + trackable.GetName());
bool isNotFound = true;
foreach (var key in QrCodeTrackablesMap.Keys)
{
if (key.Length < 1)
{
continue;
}
if (trackable.GetName().Contains(key))
{
foreach (var qrCodeTrackable in QrCodeTrackablesMap[key])
{
qrCodeTrackable.OnTrackSuccess(
"", trackable.GetName(), trackable.GetPose());
}
isNotFound = false;
break;
}
}
if (isNotFound && QrCodeTrackablesMap.ContainsKey(defaultSearchingWords))
{
foreach (var qrCodeTrackable in QrCodeTrackablesMap[defaultSearchingWords])
{
qrCodeTrackable.OnTrackSuccess(
"", trackable.GetName(), trackable.GetPose());
}
}
}
}
void Update()
{
DisableAllTrackables();
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
if (state == null)
{
return;
}
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
int fusionState = TrackerManager.GetInstance().GetFusionTrackingState();
if (fusionState == -1)
{
guideView.SetActive(true);
return;
}
else
{
guideView.SetActive(false);
}
TrackingResult trackingResult = state.GetTrackingResult();
string recognizedID = null;
for (int i = 0; i < trackingResult.GetCount(); i++)
{
Trackable trackable = trackingResult.GetTrackable(i);
int markerId = -1;
if (int.TryParse(trackable.GetName(), out markerId))
{
if (markerTrackableMap.ContainsKey(markerId))
{
markerTrackableMap[markerId].OnTrackSuccess(
trackable.GetId(), trackable.GetName(), trackable.GetPose());
recognizedID += trackable.GetId().ToString() + ", ";
}
}
}
Debug.Log("Recognized Marker id : " + recognizedID);
}
/// <summary>
/// This method must not be called while the dataset is active or it will return false.
/// </summary>
public override bool Destroy(Trackable trackable, bool destroyGameObject)
{
if (QCARWrapper.Instance.DataSetDestroyTrackable(mDataSetPtr, trackable.ID) == 0)
{
Debug.LogError("Could not destroy trackable with id " + trackable.ID + ".");
return(false);
}
mTrackablesDict.Remove(trackable.ID);
if (destroyGameObject)
{
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
stateManager.DestroyTrackableBehavioursForTrackable(trackable);
}
return(true);
}
/// <summary>
/// Creates an Anchor at the given <c>Pose</c> that is attached to the given Trackable where semantics of the
/// attachment relationship are defined by the subcass of Trackable (e.g. TrackedPlane). Note that the
/// relative offset between the Pose of multiple Anchors attached to the same Trackable may change
/// over time as ARCore refines its understanding of the world.
/// </summary>
/// <param name="trackable">The trackable (e.g detected plane) that the anchor is going to be attached to.</param>
/// <param name="pose">The Pose of the location to create the anchor.</param>
/// <returns>An Anchor attached to the Trackable at <c>Pose</c>. The anchor is disabled automatically when ARCore is simulated in the editor</returns>
public static Anchor CreateAnchor(Trackable trackable, Pose pose)
{
if (isSimulated)
{
GameObject anchorObj = new GameObject("Anchor");
anchorObj.transform.position = pose.position;
anchorObj.transform.rotation = pose.rotation;
Anchor anchor = anchorObj.AddComponent <Anchor>();
anchor.enabled = false;
return(anchor);
}
else
{
return(trackable.CreateAnchor(pose));
}
}
private void Update()
{
#if UNITY_EDITOR
var center = new Pose(transform.position, transform.rotation);
GetBoundaryPolygon(transform, m_PosList);
#else
var center = Trackable.GetCenterPose();
((NRTrackablePlane)Trackable).GetBoundaryPolygon(m_PosList);
#endif
this.DrawFromCenter(center, m_PosList);
#if !UNITY_EDITOR
if (Trackable.GetTrackingState() == TrackingState.Stopped)
{
Destroy(gameObject);
}
#endif
}
/// <summary>
/// Try to Add a specific key, with associated value, to the current cached dictionary.
/// It will not read from internal state.
/// However, if previously cached into Dictionary, request may fail.
/// </summary>
/// <param name="key">Key to be possible added.
/// Key will not be added if value exists cached and the modification was not a Deleted one.
/// </param>
/// <param name="value">Corresponding value to be added, in the case of sucess.</param>
/// <exception cref="ArgumentException">If cached on dictionary, with any state rather than `Deleted`, an Exception will be raised.</exception>
public void Add(TKey key, TValue value)
{
lock (dictionary)
{
if (dictionary.TryGetValue(key, out Trackable trackable) && trackable.State != TrackState.Deleted)
{
throw new ArgumentException();
}
dictionary[key] = new Trackable
{
Key = key,
Item = value,
State = trackable == null ? TrackState.Added : TrackState.Changed
};
changeSet.Add(key);
}
}
void Update()
{
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
if (state == null)
{
return;
}
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
int fusionState = TrackerManager.GetInstance().GetFusionTrackingState();
if (fusionState == -1)
{
guideView.SetActive(true);
return;
}
else
{
guideView.SetActive(false);
}
TrackingResult trackingResult = state.GetTrackingResult();
if (trackingResult.GetCount() == 0)
{
instantTrackable.OnTrackFail();
return;
}
if (Input.touchCount > 0)
{
UpdateTouchDelta(Input.GetTouch(0).position);
}
if (instantTrackable == null)
{
return;
}
Trackable trackable = trackingResult.GetTrackable(0);
Matrix4x4 poseMatrix = trackable.GetPose() * Matrix4x4.Translate(touchSumPosition);
instantTrackable.OnTrackSuccess(trackable.GetId(), trackable.GetName(), poseMatrix);
}
public Foot(string footName, Trackable calibrationTrackable)
{
this.footName = footName;
//this.calibrationMarker = calibrationMarker;
//previousTrackable = calibrationTrackable;
if (footName == "left") currentID = 1;
if (footName == "right") currentID = 2;
footdown_yCoordinate = calibrationTrackable.yCoordinate;
xDirection = 0;// -1 -> indicates heading in -x direction
yDirection = 0;// +1 -> +y direction etc
zDirection = 0;// +1 (+z) is forwards, towards screen; -1 -> moving towards back of treadmill
xPrevDirection = 0;
yPrevDirection = 0;
zPrevDirection = 0;
Stromohab_MCE_Connection.TCPProcessor.TrackableListReceivedEvent +=
new TCPProcessor.TrackableListReceivedHandler(TCPProcessor_TrackableListReceivedEvent);
}
/// <summary>
/// Takes a new trackable source and adds it to the dataset
/// This gets called automatically as soon as you 'BuildNewTarget with UserDefinedTargetBuildingBehaviour
/// </summary>
public void OnNewTrackableSource(TrackableSource trackableSource)
{
// Deactivates the dataset first
m_ObjectTracker.DeactivateDataSet(m_UDT_DataSet);
// Destroy the oldest target if the dataset is full or the dataset
// already contains five user-defined targets.
if (m_UDT_DataSet.HasReachedTrackableLimit() || m_UDT_DataSet.GetTrackables().Count() >= MAX_TARGETS)
{
IEnumerable <Trackable> trackables = m_UDT_DataSet.GetTrackables();
Trackable oldest = null;
foreach (Trackable trackable in trackables)
{
if (oldest == null || trackable.ID < oldest.ID)
{
oldest = trackable;
}
}
if (oldest != null)
{
Debug.Log("Destroying oldest trackable in UDT dataset: " + oldest.Name);
m_UDT_DataSet.Destroy(oldest, true);
}
}
// Get predefined trackable and instantiate it
ImageTargetBehaviour imageTargetCopy = Instantiate(ImageTargetTemplate, transform.parent);
imageTargetCopy.gameObject.name = "UserDefinedTarget-" + m_TargetCounter;
//imageTargetCopy.transform.parent = transform.parent;
// Add the duplicated trackable to the data set and activate it
m_UDT_DataSet.CreateTrackable(trackableSource, imageTargetCopy.gameObject);
// Activate the dataset again
m_ObjectTracker.ActivateDataSet(m_UDT_DataSet);
// Make sure TargetBuildingBehaviour keeps scanning...
m_TargetBuildingBehaviour.StartScanning();
m_TargetCounter++;
}
public TValue GetAndChange(TKey key, Func <TValue> factory = null)
{
TR.Enter();
if (dictionary.TryGetValue(key, out Trackable trackable))
{
if (trackable.State == TrackState.Deleted)
{
if (factory == null)
{
TR.Exit();
throw new KeyNotFoundException();
}
trackable.Item = factory();
trackable.State = TrackState.Changed;
}
else if (trackable.State == TrackState.None)
{
trackable.State = TrackState.Changed;
}
}
else
{
trackable = new Trackable
{
Key = key,
Item = TryGetInternal(key)
};
if (trackable.Item == null)
{
if (factory == null)
{
TR.Exit();
throw new KeyNotFoundException();
}
trackable.Item = factory();
trackable.State = TrackState.Added;
}
else
{
trackable.State = TrackState.Changed;
}
dictionary.Add(key, trackable);
}
return(TR.Exit(trackable.Item));
}
public TValue GetAndChange(TKey key, Func <TValue> factory = null)
{
Trackable trackable;
if (dictionary.ContainsKey(key))
{
trackable = dictionary[key];
if (trackable.State == TrackState.Deleted)
{
if (factory == null)
{
throw new KeyNotFoundException();
}
trackable.Item = factory();
trackable.State = TrackState.Added;
}
else if (trackable.State == TrackState.None)
{
trackable.State = TrackState.Changed;
}
}
else
{
trackable = new Trackable
{
Key = key,
Item = TryGetInternal(key)
};
if (trackable.Item == null)
{
if (factory == null)
{
throw new KeyNotFoundException();
}
trackable.Item = factory();
trackable.State = TrackState.Added;
}
else
{
trackable.State = TrackState.Changed;
}
dictionary.Add(key, trackable);
}
return(trackable.Item);
}
/// <summary>
/// Destroys all the TrackableBehaviours for the given Trackable
/// </summary>
public void DestroyTrackableBehavioursForTrackable(Trackable trackable, bool destroyGameObjects = true)
{
TrackableBehaviour trackableBehaviour;
if (mTrackableBehaviours.TryGetValue(trackable.ID, out trackableBehaviour))
{
mTrackableBehaviours.Remove(trackable.ID);
if (destroyGameObjects)
{
Object.Destroy(trackableBehaviour.gameObject);
}
else
{
IEditorTrackableBehaviour editorTrackableBehaviour = trackableBehaviour;
editorTrackableBehaviour.UnregisterTrackable();
}
}
}
internal override bool InitializeTarget(Trackable trackable, bool applyTargetScaleToBehaviour)
{
base.InitializeTarget(trackable, applyTargetScaleToBehaviour);
MultiTargetImpl multiTargetImpl = trackable as MultiTargetImpl;
if (multiTargetImpl == null)
{
return(false);
}
this.mTrackable = (this.mMultiTarget = multiTargetImpl);
this.mTrackableName = multiTargetImpl.Name;
this.mDataSetPath = multiTargetImpl.DataSet.Path;
if (this.mExtendedTracking)
{
this.mMultiTarget.StartExtendedTracking();
}
return(true);
}
void Update()
{
DisableAllTrackables();
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
if (state == null)
{
return;
}
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
int fusionState = TrackerManager.GetInstance().GetFusionTrackingState();
if (fusionState == -1)
{
guideView.SetActive(true);
return;
}
else
{
guideView.SetActive(false);
}
TrackingResult trackingResult = state.GetTrackingResult();
GuideInfo guideInfo = TrackerManager.GetInstance().GetGuideInfo();
TagAnchor[] anchors = guideInfo.GetTagAnchors();
for (int i = 0; i < trackingResult.GetCount(); i++)
{
Trackable trackable = trackingResult.GetTrackable(i);
if (!objectTrackablesMap.ContainsKey(trackable.GetName()))
{
return;
}
objectTrackablesMap[trackable.GetName()].OnTrackSuccess(trackable.GetId(), trackable.GetName(),
trackable.GetPose());
}
}
/// <summary>
/// Takes a new trackable source and adds it to the dataset
/// This gets called automatically as soon as you 'BuildNewTarget with UserDefinedTargetBuildingBehaviour
/// </summary>
public void OnNewTrackableSource(TrackableSource trackableSource)
{
mTargetCounter++;
// Deactivates the dataset first
mObjectTracker.DeactivateDataSet(mBuiltDataSet);
// Destroy the oldest target if the dataset is full or the dataset
// already contains five user-defined targets.
if (mBuiltDataSet.HasReachedTrackableLimit() || mBuiltDataSet.GetTrackables().Count() >= MAX_TARGETS)
{
IEnumerable <Trackable> trackables = mBuiltDataSet.GetTrackables();
Trackable oldest = null;
foreach (Trackable trackable in trackables)
{
if (oldest == null || trackable.ID < oldest.ID)
{
oldest = trackable;
}
}
if (oldest != null)
{
Debug.Log("Destroying oldest trackable in UDT dataset: " + oldest.Name);
mBuiltDataSet.Destroy(oldest, true);
}
}
// Get predefined trackable and instantiate it
ImageTargetBehaviour imageTargetCopy = (ImageTargetBehaviour)Instantiate(ImageTargetTemplate);
imageTargetCopy.gameObject.name = "UserDefinedTarget-" + mTargetCounter;
// Add the duplicated trackable to the data set and activate it
mBuiltDataSet.CreateTrackable(trackableSource, imageTargetCopy.gameObject);
// Activate the dataset again
mObjectTracker.ActivateDataSet(mBuiltDataSet);
mObjectTracker.Stop();
mObjectTracker.ResetExtendedTracking();
mObjectTracker.Start();
}
public static AnchorWrapper GetAnchorForTrackable(Trackable trackable, Pose pose)
{
var trackableHashCode = trackable.GetHashCode();
AnchorWrapper anchorToReturn;
if (AnchorsDictionary.TryGetValue(trackableHashCode, out anchorToReturn))
{
AnchorsDictionary[trackableHashCode].numberOfUsers++;
anchorToReturn = AnchorsDictionary[trackableHashCode];
}
else
{
AnchorsDictionary.Add(trackableHashCode,
anchorToReturn = new AnchorWrapper(trackable, pose, trackableHashCode));
anchorToReturn.numberOfUsers++;
}
return(anchorToReturn);
}
/// <summary>
/// Initialize the visual effect.
/// </summary>
/// <param name="trackable">The Trackable that's associated to this object.</param>
public void InitializeWithTrackable(Trackable trackable)
{
if (trackable is InstantPlacementPoint)
{
_instantPlacementPoint = trackable as InstantPlacementPoint;
_isOn = _instantPlacementPoint.TrackingMethod !=
InstantPlacementPointTrackingMethod.FullTracking;
}
else
{
_isOn = false;
}
if (_isOn)
{
var renderer = GetComponent <MeshRenderer>();
renderer.materials = HolographicMaterials;
}
}
public void UpdateTrackable(Trackable trackable)
{
using (var connection = new SqlConnection(_connectionString))
{
var cmd = new SqlCommand("UpdateTrackable", connection)
{
CommandType = CommandType.StoredProcedure
};
cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int));
cmd.Parameters["@Id"].Value = trackable.Id;
cmd.Parameters.Add(new SqlParameter("@Name", SqlDbType.VarChar, 255));
cmd.Parameters["@Name"].Value = trackable.Name;
connection.Open();
cmd.ExecuteNonQuery();
}
}
/// <summary> /// Destroys all the TrackableBehaviours for the given Trackable /// </summary> public abstract void DestroyTrackableBehavioursForTrackable(Trackable trackable, bool destroyGameObjects = true);
public Life(int value)
{
_value = new Trackable<int>(value);
_score = new Trackable<int>(ScoreCalculator.CalculateLifeScore(value));
}
private static bool LeftFoot(Trackable t)
{
if (t.ID == 1)
return true;
else
return false;
}
public RawData(Trackable calibrationTrackable)
{
//Stromohab_MCE_Connection.TCPProcessor.TrackableListReceivedEvent +=
// new TCPProcessor.TrackableListReceivedHandler(TCPProcessor_TrackableListReceivedEvent);
}
private static bool RightFoot(Trackable t)
{
if (t.ID == 2)
return true;
else
return false;
}
public static void Register(Trackable component)
{
EntityTracking entityTracking = ActorSystem.instance.Find ("EntityTracking") as EntityTracking;
entityTracking.trackable = component;
ActorSystem.instance.InvokeRepeating (entityTracking, "UpdateTracking");
}
public Damage(int amount, bool isCombat, Card source)
{
_amount = new Trackable<int>(amount);
IsCombat = isCombat;
Source = source;
}
/// <summary>
/// Marks the TrackableBehaviours for the given Trackable as "not found"
/// </summary>
public void SetTrackableBehavioursForTrackableToNotFound(Trackable trackable)
{
TrackableBehaviour trackableBehaviour;
if (mTrackableBehaviours.TryGetValue(trackable.ID, out trackableBehaviour))
{
trackableBehaviour.OnTrackerUpdate(TrackableBehaviour.Status.NOT_FOUND);
}
}
/// <summary>
/// Destroys all the TrackableBehaviours for the given Trackable
/// </summary>
public void DestroyTrackableBehavioursForTrackable(Trackable trackable, bool destroyGameObjects = true)
{
TrackableBehaviour trackableBehaviour;
if (mTrackableBehaviours.TryGetValue(trackable.ID, out trackableBehaviour))
{
mTrackableBehaviours.Remove(trackable.ID);
if (destroyGameObjects)
Object.Destroy(trackableBehaviour.gameObject);
else
{
IEditorTrackableBehaviour editorTrackableBehaviour = trackableBehaviour;
editorTrackableBehaviour.UnregisterTrackable();
}
}
}
/// <summary>
/// This method must not be called while the dataset is active or it will return false.
/// </summary>
public override bool Destroy(Trackable trackable, bool destroyGameObject)
{
if (QCARWrapper.Instance.DataSetDestroyTrackable(mDataSetPtr, trackable.ID) == 0)
{
Debug.LogError("Could not destroy trackable with id " + trackable.ID + ".");
return false;
}
mTrackablesDict.Remove(trackable.ID);
if (destroyGameObject)
{
StateManagerImpl stateManager = (StateManagerImpl)TrackerManager.Instance.GetStateManager();
stateManager.DestroyTrackableBehavioursForTrackable(trackable);
}
return true;
}
/// <summary> /// Checks if the given trackable is contained in the DataSet /// </summary> public abstract bool Contains(Trackable trackable);
/// <summary>
/// Destroys all the TrackableBehaviours for the given Trackable
/// </summary>
public override void DestroyTrackableBehavioursForTrackable(Trackable trackable, bool destroyGameObjects = true)
{
TrackableBehaviour trackableBehaviour;
if (mTrackableBehaviours.TryGetValue(trackable.ID, out trackableBehaviour))
{
if (destroyGameObjects)
{
mBehavioursMarkedForDeletion.Add(mTrackableBehaviours[trackable.ID]);
Object.Destroy(trackableBehaviour.gameObject);
}
else
{
IEditorTrackableBehaviour editorTrackableBehaviour = trackableBehaviour;
editorTrackableBehaviour.UnregisterTrackable();
}
mTrackableBehaviours.Remove(trackable.ID);
mAutomaticallyCreatedBehaviours.Remove(trackable.ID);
}
}
/// <summary>
/// Checks if the given trackable is contained in the DataSet
/// </summary>
public override bool Contains(Trackable trackable)
{
return mTrackablesDict.ContainsValue(trackable);
}
/// <summary>
/// Sets the enabled flag for TrackableBehaviours for a given Trackable
/// </summary>
public void EnableTrackableBehavioursForTrackable(Trackable trackable, bool enabled)
{
TrackableBehaviour trackableBehaviour;
if (mTrackableBehaviours.TryGetValue(trackable.ID, out trackableBehaviour))
{
if (trackableBehaviour != null)
trackableBehaviour.enabled = enabled;
}
}
public void OnNewTrackableSource(TrackableSource trackableSource)
{
if (trackable != null) { return; } // 이미 있으면 새로 생성하지 않는다.
// deactivates the dataset first
mImageTracker.DeactivateDataSet(mBuiltDataSet);
// 타겟 템플릿을 복제해 실제 추적할 타겟을 만든다.
ImageTargetBehaviour targetTemplate = GetTargetTemplate(lastTargetType);
if (targetTemplate == null) { return; }
GameObject objCopy = Instantiate(targetTemplate.gameObject) as GameObject;
ImageTargetBehaviour imageTargetCopy = objCopy.GetComponent<ImageTargetBehaviour>();
imageTargetCopy.gameObject.name = targetTemplate.TrackableName + "_Created";
// 추적 정보를 생성하고, 생성된 정보를 유지
DataSetTrackableBehaviour created = mBuiltDataSet.CreateTrackable(trackableSource, imageTargetCopy.gameObject);
trackable = created.Trackable;
objTarget = imageTargetCopy.gameObject;
// activate the dataset again
mImageTracker.ActivateDataSet(mBuiltDataSet);
}
public PreventNextDamageToTarget(int amount, object creatureOrPlayer)
{
_amount = new Trackable<int>(amount);
_creatureOrPlayer = creatureOrPlayer;
}
/// <summary> /// This method must not be called while the dataset is active or it will return false. /// </summary> public abstract bool Destroy(Trackable trackable, bool destroyGameObject);
