private void CreateControllerVisual(int index, ControllerVisualType visualType)
{
GameObject visualGo = ControllerVisualFactory.CreateControllerVisualObject(visualType);
if (visualGo == null)
{
return;
}
m_ControllerVisuals[index] = visualGo.GetComponent <IControllerVisual>();
if (m_ControllerVisuals[index] != null)
{
ControllerAnchorEnum ancherEnum = (index == 0 ? ControllerAnchorEnum.RightModelAnchor : ControllerAnchorEnum.LeftModelAnchor);
visualGo.transform.parent = NRInput.AnchorsHelper.GetAnchor(ancherEnum);
visualGo.transform.localPosition = Vector3.zero;
visualGo.transform.localRotation = Quaternion.identity;
visualGo.transform.localScale = Vector3.one;
}
else
{
NRDebugger.LogError("The ControllerVisual prefab:" + visualGo.name + " does not contain IControllerVisual interface");
Destroy(visualGo);
}
}
private IEnumerator StartUp()
{
var virtualDisplay = GameObject.FindObjectOfType <NRVirtualDisplayer>();
while (virtualDisplay == null || !virtualDisplay.IsPlaying)
{
NRDebugger.Log("[NRRender] Wait virtual display ready...");
yield return(new WaitForEndOfFrame());
if (virtualDisplay == null)
{
virtualDisplay = GameObject.FindObjectOfType <NRVirtualDisplayer>();
}
}
yield return(new WaitForEndOfFrame());
yield return(new WaitForEndOfFrame());
yield return(new WaitForEndOfFrame());
NRDebugger.Log("[NRRender] StartUp");
CreateRenderTextures();
leftCamera.enabled = true;
rightCamera.enabled = true;
#if !UNITY_EDITOR
m_NativeRenderring = new NativeRenderring();
m_NativeRenderring.Create();
#if !UNITY_STANDALONE_WIN
m_NativeRenderring.InitColorSpace();
#endif
StartCoroutine(RenderCoroutine());
#endif
m_CurrentState = RendererState.Running;
GL.IssuePluginEvent(RenderThreadHandlePtr, STARTNATIVERENDEREVENT);
}
/// <summary>
/// Initialize the render pipleline.
/// </summary>
/// <param name="leftcamera">Left Eye.</param>
/// <param name="rightcamera">Right Eye.</param>
/// <param name="poseprovider">provide the pose of camera every frame.</param>
public void Initialize(Camera leftcamera, Camera rightcamera)
{
NRDebugger.Log("[NRRender] Initialize");
if (m_CurrentState != RendererState.UnInitialized)
{
return;
}
NRSessionManager.SetAppSettings(true);
leftCamera = leftcamera;
rightCamera = rightcamera;
#if !UNITY_EDITOR
leftCamera.depthTextureMode = DepthTextureMode.Depth;
rightCamera.depthTextureMode = DepthTextureMode.Depth;
leftCamera.rect = new Rect(0, 0, 1, 1);
rightCamera.rect = new Rect(0, 0, 1, 1);
leftCamera.enabled = false;
rightCamera.enabled = false;
m_CurrentState = RendererState.Initialized;
StartCoroutine(StartUp());
#endif
}
// only worked at 3dof mode
public void Recenter()
{
var result = NativeApi.NRTrackingRecenter(m_TrackingHandle);
NRDebugger.Log("[NativeSession Recenter] :" + result.ToString());
}
void LateUpdate()
{
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
UpdateControllerRotateByInput();
}
if (Input.GetMouseButtonDown(0))
{
SetConfirmButton(true);
ImageConfirm.SetActive(true);
}
if (Input.GetMouseButtonUp(0))
{
SetConfirmButton(false);
ImageConfirm.SetActive(false);
}
if (Input.GetMouseButtonDown(2))
{
SetAppButton(true);
ImageApp.SetActive(true);
}
if (Input.GetMouseButtonUp(2))
{
SetAppButton(false);
ImageApp.SetActive(false);
}
if (Input.GetMouseButtonDown(1))
{
SetHomeButton(true);
ImageHome.SetActive(true);
}
if (Input.GetMouseButtonUp(1))
{
SetHomeButton(false);
ImageHome.SetActive(false);
}
if (m_TouchAction != TouchActionState.Idle)
{
UpdateTouchAction();
}
else
{
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
ImageLeft.SetActive(true);
m_TouchAction = TouchActionState.Left;
}
else if (Input.GetKeyDown(KeyCode.RightArrow))
{
ImageRight.SetActive(true);
m_TouchAction = TouchActionState.Right;
}
else if (Input.GetKeyDown(KeyCode.UpArrow))
{
ImageUp.SetActive(true);
m_TouchAction = TouchActionState.Up;
}
else if (Input.GetKeyDown(KeyCode.DownArrow))
{
ImageDown.SetActive(true);
m_TouchAction = TouchActionState.Down;
}
else if (Input.GetKeyUp(KeyCode.DownArrow)
| Input.GetKeyUp(KeyCode.UpArrow)
| Input.GetKeyUp(KeyCode.RightArrow)
| Input.GetKeyUp(KeyCode.LeftArrow))
{
NREmulatorManager.Instance.NativeEmulatorApi.SetControllerIsTouching(false);
}
}
NREmulatorManager.Instance.NativeEmulatorApi.SetControllerSubmit();
if (NRInput.GetButtonDown(ControllerButton.TRIGGER))
{
NRDebugger.Log("Click down Trigger button !!!");
}
else if (NRInput.GetButtonDown(ControllerButton.APP))
{
NRDebugger.Log("Click down App button !!!");
}
else if (NRInput.GetButtonDown(ControllerButton.HOME))
{
NRDebugger.Log("Click down Home button !!!");
}
}
void OnDestroy()
{
NRDebugger.Log("[SessionBehaviour OnDestroy DestroySession]");
NRSessionManager.Instance.DestroySession();
}
void OnDisable()
{
NRDebugger.Log("[SessionBehaviour OnDisable: DisableSession]");
NRSessionManager.Instance.DisableSession();
}
void Start()
{
NRDebugger.Log("[SessionBehaviour DelayStart: StartSession]");
NRSessionManager.Instance.StartSession();
NRSessionManager.Instance.SetConfiguration(SessionConfig);
}
public void ParserControllerState(ControllerState state)
{
try
{
_touch_status = (Mathf.Abs(state.touchPos.x) > PRECISION || Mathf.Abs(state.touchPos.y) > PRECISION);
if (!_touch_status)
{
_touch.x = 0f;
_touch.y = 0f;
}
else
{
_touch.x = state.touchPos.x;
_touch.y = state.touchPos.y;
}
UpdateCurrentTouchArea();
lock (_buttons)
{
lock (_down)
{
for (int i = 0; i < _buttons.Length; ++i)
{
_down[i] = _buttons[i];
}
}
_physical_button_down = _physical_button;
_physical_button = state.GetButton(ControllerButton.TRIGGER);
if (_current_down_btn != -1)
{
_buttons[_current_down_btn] = _physical_button;
if (!_buttons[_current_down_btn])
{
_current_down_btn = -1;
}
}
else
{
_buttons[0] = false; //Trigger
_buttons[1] = false; //App
_buttons[2] = false; //Home
bool _is_down = !_physical_button_down & _physical_button;
if (_currentTouchArea == TouchAreaEnum.Center)
{
_buttons[0] = _physical_button && _is_down;
}
else if (_currentTouchArea == TouchAreaEnum.Up)
{
_buttons[1] = _physical_button && _is_down;
}
else if (_currentTouchArea == TouchAreaEnum.Down)
{
_buttons[2] = _physical_button && _is_down;
}
_current_down_btn = -1;
for (int i = 0; i < 3; i++)
{
if (_buttons[i])
{
_current_down_btn = i;
break;
}
}
}
lock (_buttons_up)
{
lock (_buttons_down)
{
for (int i = 0; i < _buttons.Length; ++i)
{
_buttons_up[i] = (_down[i] & !_buttons[i]);
_buttons_down[i] = (!_down[i] & _buttons[i]);
}
}
}
}
}
catch (Exception e)
{
NRDebugger.LogError("Controller Data Error :" + e.ToString());
}
state.isTouching = _touch_status;
state.touchPos = _touch;
state.buttonsState =
(_buttons[0] ? ControllerButton.TRIGGER : 0)
| (_buttons[1] ? ControllerButton.APP : 0)
| (_buttons[2] ? ControllerButton.HOME : 0);
state.buttonsDown =
(_buttons_down[0] ? ControllerButton.TRIGGER : 0)
| (_buttons_down[1] ? ControllerButton.APP : 0)
| (_buttons_down[2] ? ControllerButton.HOME : 0);
state.buttonsUp =
(_buttons_up[0] ? ControllerButton.TRIGGER : 0)
| (_buttons_up[1] ? ControllerButton.APP : 0)
| (_buttons_up[2] ? ControllerButton.HOME : 0);
}
private void OnHMDPoseReady()
{
NRDebugger.Log("[SlamStateNotification] OnHMDPoseReady.");
m_CurrentState = SlamState.TrackingReady;
}
public void UpdateConfig(NRSessionConfig config)
{
if (m_ConfigHandle == 0)
{
m_ConfigHandle = this.Create();
}
if (m_ConfigHandle == 0)
{
NRDebugger.LogError("Faild to Create ARSessionConfig!!!");
return;
}
var plane_find_mode = this.GetPlaneFindMode(m_ConfigHandle);
if (plane_find_mode != config.PlaneFindingMode)
{
SetPlaneFindMode(m_ConfigHandle, config.PlaneFindingMode);
}
if (config.ImageTrackingMode != m_ImageTrackingMode)
{
//Trackable Image
switch (config.ImageTrackingMode)
{
case TrackableImageFindingMode.DISABLE:
if (m_DatabaseHandle != 0)
{
m_NativeTrackableImage.DestroyDataBase(m_DatabaseHandle);
m_DatabaseHandle = 0;
}
else
{
var result = SetTrackableImageDataBase(m_ConfigHandle, 0);
NRDebugger.Log("[Disable trackable image] result : " + result);
}
break;
case TrackableImageFindingMode.ENABLE:
if (m_DatabaseHandle == 0)
{
if (config.TrackingImageDatabase != null)
{
m_DatabaseHandle = m_NativeTrackableImage.CreateDataBase();
bool result = m_NativeTrackableImage.LoadDataBase(m_DatabaseHandle, config.TrackingImageDatabase.TrackingImageDataPath);
NRDebugger.Log("[LoadDataBase] result : " + result);
result = SetTrackableImageDataBase(m_ConfigHandle, m_DatabaseHandle);
NRDebugger.Log("[SetTrackableImageDataBase] result : " + result);
}
else
{
var result = SetTrackableImageDataBase(m_ConfigHandle, 0);
NRDebugger.Log("[Disable trackable image] result : " + result);
}
}
break;
default:
break;
}
m_ImageTrackingMode = config.ImageTrackingMode;
}
}
/// <summary> Executes the 'dirty quality jobs' operation. </summary>
/// <param name="database"> The database.</param>
private static void RunDirtyQualityJobs(NRTrackingImageDatabase database)
{
if (database == null)
{
NRDebugger.Info("database is null");
return;
}
if (m_DatabaseForQualityJobs != database)
{
// If another database is already running quality evaluation,
// stop all pending jobs to prioritise the current database.
if (m_DatabaseForQualityJobs != null)
{
m_QualityBackgroundExecutor.RemoveAllPendingJobs();
}
m_DatabaseForQualityJobs = database;
}
UpdateDatabaseQuality(database);
// Set database dirty to refresh inspector UI for each frame that there are still pending jobs.
// Otherwise if there exists one frame with no newly finished jobs, the UI will never get refreshed.
// EditorUtility.SetDirty can only be called from main thread.
if (m_QualityBackgroundExecutor.PendingJobsCount > 0)
{
EditorUtility.SetDirty(database);
return;
}
List <NRTrackingImageDatabaseEntry> dirtyEntries = database.GetDirtyQualityEntries();
if (dirtyEntries.Count == 0)
{
return;
}
string cliBinaryPath;
if (!NRTrackingImageDatabase.FindCliBinaryPath(out cliBinaryPath))
{
return;
}
string outpath = NRTools.GetTrackingImageDataGenPath() + database.GUID + "/";
if (!Directory.Exists(outpath))
{
Directory.CreateDirectory(outpath);
}
var resultjson = database.TrackingImageDataPath + "markers.json";
for (int i = 0; i < dirtyEntries.Count; ++i)
{
NRTrackingImageDatabaseEntry image = dirtyEntries[i];
var imagePath = AssetDatabase.GetAssetPath(image.Texture);
imagePath = Application.dataPath.Substring(0, Application.dataPath.Length - 6) + imagePath;
m_QualityBackgroundExecutor.PushJob(() =>
{
BuildImage(cliBinaryPath, image, imagePath, outpath, resultjson);
});
}
}
/// <summary> Builds data base. </summary>
/// <param name="database"> The database.</param>
public static void BuildDataBase(NRTrackingImageDatabase database)
{
NRDebugger.Info("Start to build database...");
if (database == null)
{
NRDebugger.Info("database is null");
return;
}
List <NRTrackingImageDatabaseEntry> dirtyEntries = database.GetDirtyQualityEntries();
if (database.isCliUpdated)
{
dirtyEntries = database.GetAllEntries();
}
if (dirtyEntries.Count == 0)
{
return;
}
NRDebugger.Info("dirtyEntries count:" + dirtyEntries.Count);
string cliBinaryPath;
if (!NRTrackingImageDatabase.FindCliBinaryPath(out cliBinaryPath))
{
return;
}
string outpath = NRTools.GetTrackingImageDataGenPath() + database.GUID + "/";
if (!Directory.Exists(outpath))
{
Directory.CreateDirectory(outpath);
}
var resultjson = database.TrackingImageDataPath + "markers.json";
for (int i = 0; i < dirtyEntries.Count; ++i)
{
NRTrackingImageDatabaseEntry image = dirtyEntries[i];
var imagePath = AssetDatabase.GetAssetPath(image.Texture);
BuildImage(cliBinaryPath, image, imagePath, outpath, resultjson);
}
if (File.Exists(resultjson))
{
var json_data = File.ReadAllText(resultjson);
var json_obj = JsonMapper.ToObject(json_data);
for (int i = 0; i < dirtyEntries.Count; i++)
{
NRTrackingImageDatabaseEntry image = dirtyEntries[i];
var textureGUID = image.TextureGUID;
//NRDebugger.Info("update quality dict " + image.Name);
var image_info = json_obj[image.Name];
m_UpdatedQualityScores.Remove(textureGUID);
m_UpdatedQualityScores.Add(textureGUID, image_info);
}
UpdateDatabaseQuality(database);
for (int i = 0; i < database.Count; i++)
{
NRTrackingImageDatabaseEntry image = database[i];
NRDebugger.Info(image.ToString());
}
}
}
