/// <summary>
/// Gets all information about users but the one being edited
/// </summary>
/// <returns>a list of found users</returns>
public List <tblUser> GetAllManagers(int userID)
{
List <tblUser> tblUsers = GetAllUsers();
try
{
using (WorkerContext context = new WorkerContext())
{
List <tblUser> listButSelected = new List <tblUser>();
listButSelected = (from x in context.tblUsers select x).ToList();
bool isUser = IsUserID(userID);
if (isUser == true)
{
// find the user before removing them from the list
tblUser userToDelete = (from r in context.tblUsers where r.UserID == userID select r).First();
listButSelected.Remove(userToDelete);
}
return(listButSelected);
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception" + ex.Message.ToString());
return(null);
}
}
private void RefreshCollections(WorkerContext ctx = null)
{
try
{
if (ctx == null)
{
databaseManager.FlushCache();
}
else
{
databaseManager.FlushCache(PsStreamEventHandlers.GetUIHandlers(ctx));
ctx.s = StatusCode.OK;
}
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Exception", MessageBoxButtons.OK);
if (ctx != null)
{
ctx.s = StatusCode.FAILED;
}
return;
}
RefreshUI();
}
/// <summary>
/// Gets all information about locations from the database
/// </summary>
/// <returns>a list of found locations</returns>
public List <tblLocation> GetAllLocations()
{
ReadWriteFile rwf = new ReadWriteFile();
List <tblLocation> list = new List <tblLocation>();
try
{
using (WorkerContext context = new WorkerContext())
{
list = (from x in context.tblLocations select x).OrderBy(x => x.LocationAddress).ToList();
// If the location list is empty
if (!list.Any())
{
rwf.ReadLocationFromFile(list);
}
return(list);
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception" + ex.Message.ToString());
return(null);
}
}
public ActionResult Login(LoginModel model)
{
if (ModelState.IsValid)
{
Worker worker = null;
using (WorkerContext db = new WorkerContext())
{
string sha1pass = HashSHA1Decryption(model.Password).ToLower();
worker = db.Workers.FirstOrDefault(u => u.Login == model.Login && u.PassHash == sha1pass);
}
if (worker != null)
{
//FormsAuthentication.SetAuthCookie(model.Login, true);
FormsAuthentication.SetAuthCookie(worker.Name, true);
Log.Info(User.Identity.Name, "Account/Login|[HttpPost]");
return(RedirectToAction("Index", "Home"));
}
else
{
Log.Error(model.Login + "|failed login attempt");
ModelState.AddModelError("", "Пользователя с таким логином и паролем нет");
}
}
return(View(model));
}
public void Run()
{
var inboundAddress = Configuration["inboundAddress"];
if(String.IsNullOrWhiteSpace(inboundAddress))
throw new InvalidOperationException("Configuration must contain an \"inboundAddress\" entry");
Console.Title = String.Format("Worker Host - {0}", inboundAddress);
var inboundHwm = Configuration.GetValue<ulong>("inboundHWM", 1000);
using(var zmqContext = new ZMQ.Context())
using(var inboundSocket = zmqContext.Socket(ZMQ.SocketType.PULL))
{
inboundSocket.HWM = inboundHwm;
inboundSocket.Connect(inboundAddress);
var workerContext = new WorkerContext(zmqContext, inboundSocket, Configuration);
while(true)
{
var workerType = inboundSocket.Recv<Type>();
Console.WriteLine("Creating a new instance of {0}", workerType.Name);
using(var worker = (IWorker)Activator.CreateInstance(workerType))
worker.MessageReceived(workerContext);
}
}
}
static void Main(string[] args)
{
UserCommands Yandex = new UserCommands();
List <Worker> newWorkers = new List <Worker>();
Worker Kristina = Yandex.CreateWorker("Кристина");
Worker Andrey = Yandex.CreateWorker("Andrey");
Worker Fredi = Yandex.CreateWorker("Алексей");
newWorkers.Add(Kristina);
newWorkers.Add(Andrey);
Yandex.GiveWorkeres("Алексей", newWorkers);
using (WorkerContext db = new WorkerContext())
{
var workers = db.Workers;
Console.WriteLine("Список объектов:");
foreach (Worker u in workers)
{
Console.WriteLine("{0}-{1}", u.Id, u.Name);
}
}
Yandex.PrintWorkersHierarchy();
}
public void LockAndLockAsync_PreventConcurrentExecution()
{
WorkerContext context = new WorkerContext();
int taskCount = 20;
Task[] tasks = new Task[taskCount];
for (int i = 0; i < taskCount; i += 2)
{
// Start one task that will use the lock in async environment.
tasks[i] = Task.Run(async() => { await this.LockAndLockAsync_PreventConcurrentExecution_TaskProcAsync(context); });
int delay = context.Rng.Next(500);
Thread.Sleep(delay);
// Start one task that will use the lock in non-async environment.
tasks[i + 1] = Task.Run(() => this.LockAndLockAsync_PreventConcurrentExecution_TaskProc(context));
delay = context.Rng.Next(200);
Thread.Sleep(delay);
}
Task.WaitAll(tasks);
Assert.False(context.Error);
context.Lock.Dispose();
}
private async Task <WorkerContext> prepareDb()
{
var options = new DbContextOptionsBuilder <WorkerContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var workerContext = new WorkerContext(options);
workerContext.Database.EnsureCreated();
if (await workerContext.Positions.CountAsync() <= 0)
{
for (int i = 1; i <= 10; i++)
{
workerContext.Positions.Add(new Workers.Models.Position()
{
Name = "Sprzatacz",
PositionID = i,
Amount = 2000
});
await workerContext.SaveChangesAsync();
}
}
return(workerContext);
}
public void DefaultWorkerProcessFactory_Returns_ExpectedProcess(WorkerContext workerContext)
{
Environment.SetEnvironmentVariable("TestEnv", "TestVal");
DefaultWorkerProcessFactory defaultWorkerProcessFactory = new DefaultWorkerProcessFactory(_testEnvironment, _loggerFactory);
Process childProcess = defaultWorkerProcessFactory.CreateWorkerProcess(workerContext);
var expectedEnvVars = workerContext.EnvironmentVariables;
var actualEnvVars = childProcess.StartInfo.EnvironmentVariables;
var parentProessEnvVars = Environment.GetEnvironmentVariables();
Assert.True(expectedEnvVars.Count + parentProessEnvVars.Count == actualEnvVars.Count);
foreach (var envVar in expectedEnvVars)
{
Assert.Equal(expectedEnvVars[envVar.Key], actualEnvVars[envVar.Key]);
}
if (workerContext is RpcWorkerContext)
{
Assert.Equal(" httpvalue1 TestVal httpvalue2 --host localhost --port 80 --workerId testWorkerId --requestId testId --grpcMaxMessageLength 2147483647", childProcess.StartInfo.Arguments);
}
else
{
Assert.Equal(" httpvalue1 TestVal httpvalue2", childProcess.StartInfo.Arguments);
}
childProcess.Dispose();
Environment.SetEnvironmentVariable("TestEnv", string.Empty);
}
/// <summary>
/// Deletes user if the uderID exists
/// </summary>
/// <param name="userID">the user that is being deleted</param>
public void DeleteUser(int userID)
{
List <tblUser> tblUsers = GetAllUsers();
try
{
using (WorkerContext context = new WorkerContext())
{
bool isUser = IsUserID(userID);
if (isUser == true)
{
// find the user before removing them
tblUser userToDelete = (from r in context.tblUsers where r.UserID == userID select r).First();
context.tblUsers.Remove(userToDelete);
context.SaveChanges();
}
else
{
MessageBox.Show("Cannot delete the user");
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception" + ex.Message.ToString());
}
}
public override Task TeardownAsync(WorkerContext context)
{
Console.WriteLine("Teardown");
_cts.Cancel();
_cts.Dispose();
return(Task.CompletedTask);
}
public void DeleteDB()
{
using (var db = new WorkerContext())
{
db.Database.Delete();
}
}
/// <summary>
/// Procedure for testing the lock in async environment.
/// </summary>
/// <param name="workerContext">Shared information the worker needs for the task.</param>
private async Task LockAndLockAsync_PreventConcurrentExecution_TaskProcAsync(WorkerContext workerContext)
{
using (await workerContext.Lock.LockAsync())
{
await this.CriticalSectionLockedAsync(workerContext);
}
}
public void CopyCtor_CorrectlyCopies_AllPropertyValues()
{
var context = CreateContext();
var contextCopy = new WorkerContext(context);
Assert.Equal(context.WorkerNumber, contextCopy.WorkerNumber);
}
public AddWorkerVM()
{
Title = "Добавление";
Worker = new Worker();
WorkerContext = new WorkerContext();
OnPropertyChanged(nameof(Title));
}
/// <summary>
/// Procedure for testing the lock in non-async environment.
/// <para>
/// The worker periodically sets the shared value to its ID and waits.
/// If another thread enters the critical section, the shared value will be modified
/// and the worker reports an error.
/// </para>
/// </summary>
/// <param name="workerContext">Shared information the worker needs for the task.</param>
private void LockAndLockAsync_PreventConcurrentExecution_TaskProc(WorkerContext workerContext)
{
using (workerContext.Lock.Lock())
{
this.CriticalSectionLocked(workerContext);
}
}
/// <summary>
/// Initializes a new instance of <see cref="ComponentMap{T}"/>.
/// </summary>
/// <param name="dispatcher">
/// Optional. Dispatcher for the ComponentMap to use. If left null, the map will attempt to use the dispatcher
/// from the current <see cref="WorkerContext"/>.
/// </param>
/// <param name="disableEvents">
/// Optional. Events to disable. Can pass in multiple flags using bitwise OR. For example,
/// AddComponent | UpdateComponent.
/// </param>
public ComponentMap(IDispatcher dispatcher = null, ComponentMapEvent?disableEvents = null)
{
_authority = new HashSet <EntityId>();
_authorityLossImminent = new HashSet <EntityId>();
_components = new Dictionary <EntityId, IComponentData <T> >();
dispatcher = dispatcher ?? WorkerContext.GetInstance().GetDispatcher();
if (!HasFlag(disableEvents, ComponentMapEvent.AddComponent))
{
dispatcher.OnAddComponent <T>(AddComponent);
}
if (!HasFlag(disableEvents, ComponentMapEvent.RemoveEntity))
{
dispatcher.OnRemoveEntity(RemoveEntity);
}
if (!HasFlag(disableEvents, ComponentMapEvent.UpdateComponent))
{
dispatcher.OnComponentUpdate <T>(UpdateComponent);
}
if (!HasFlag(disableEvents, ComponentMapEvent.AuthorityChange))
{
dispatcher.OnAuthorityChange <T>(SetAuthority);
}
}
public void ReadLocationFromFile(List <tblLocation> location)
{
string file = @"~\..\..\..\Locations.txt";
int id = 0;
using (WorkerContext context = new WorkerContext())
{
if (File.Exists(file))
{
string[] readFile = File.ReadAllLines(file);
for (int i = 0; i < readFile.Length; i++)
{
if (!string.IsNullOrEmpty(readFile[i]))
{
string[] trim = readFile[i].Split(',');
string address = trim[0];
string city = trim[1];
string country = trim[2];
id++;
tblLocation s = new tblLocation(id, address, city, country);
location.Add(s);
context.tblLocations.Add(s);
context.SaveChanges();
}
}
}
}
}
private static void WorkerContextTeardown(WorkerContext context)
{
UnityEngine.Debug.Log("Tearing down PSMove Tracking Context");
// Delete the controllers
for (int psmove_id = 0; psmove_id < context.PSMoves.Length; psmove_id++)
{
if (context.PSMoves[psmove_id] != IntPtr.Zero)
{
UnityEngine.Debug.Log(string.Format("Disconnecting PSMove controller {0}", psmove_id));
context.WorkerControllerDataArray[psmove_id].IsConnected = false;
context.WorkerControllerDataArray[psmove_id].IsEnabled = false;
PSMoveAPI.psmove_disconnect(context.PSMoves[psmove_id]);
context.PSMoves[psmove_id] = IntPtr.Zero;
}
}
// Delete the tracking fusion state
if (context.PSMoveFusion != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove fusion disposed");
PSMoveAPI.psmove_fusion_free(context.PSMoveFusion);
context.PSMoveFusion = IntPtr.Zero;
}
// Delete the tracker state
if (context.PSMoveTracker != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove tracker disposed");
PSMoveAPI.psmove_tracker_free(context.PSMoveTracker);
context.PSMoveTracker = IntPtr.Zero;
}
context.Reset();
}
public override async Task ExecuteAsync(WorkerContext context)
{
var randI = (int)new Random().Next(1, 3999);
//Console.WriteLine($"Enqueue from {Environment.MachineName} {context.WorkerId}: {randI}");
await queue.EnqueueAsync(randI);
}
// add a worker
public bool WorkerAdd(string IdCard, string FirstName, string SirName, string Phone, string Mail)
{
bool k = false; // checks if worker was added
bool helper = true; // checks if worker exists in DB
using (var db = new WorkerContext())
{
foreach (var item in db.Workers)
{
if (IdCard == item.IdCard)
{
helper = false;
}
}
if (helper)
{
db.Workers.Add(new Worker {
IdCard = IdCard, FirstName = FirstName, SirName = SirName, Phone = Phone, Mail = Mail, UserDetail = AddUser(IdCard, Phone)
});
db.SaveChanges();
k = true;
}
}
return(k);
}
private static void WorkerContextTeardownTracking(WorkerContext context)
{
// Disable tracking on all active controllers
for (int psmove_id = 0; psmove_id < context.PSMoves.Length; psmove_id++)
{
if (context.PSMoves[psmove_id] != IntPtr.Zero &&
context.WorkerControllerDataArray[psmove_id].IsTrackingEnabled)
{
UnityEngine.Debug.Log(string.Format("Disabling tracking on PSMove controller {0}", psmove_id));
context.WorkerControllerDataArray[psmove_id].IsTrackingEnabled = false;
}
}
// Delete the tracking fusion state
if (context.PSMoveFusion != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove fusion disposed");
PSMoveAPI.psmove_fusion_free(context.PSMoveFusion);
context.PSMoveFusion = IntPtr.Zero;
}
// Delete the tracker state
if (context.PSMoveTracker != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove tracker disposed");
PSMoveAPI.psmove_tracker_free(context.PSMoveTracker);
context.PSMoveTracker = IntPtr.Zero;
}
}
/// <summary>
/// Edits a new user depending if the uderID already exists
/// </summary>
/// <param name="user">the user that is being added</param>
/// <param name="sector">the sector that is being added</param>
/// <returns>a new user</returns>
public tblUser AddUser(tblUser user, tblSector sector)
{
InputCalculator iv = new InputCalculator();
try
{
using (WorkerContext context = new WorkerContext())
{
if (user.UserID == 0)
{
user.DateOfBirth = iv.CountDateOfBirth(user.JMBG);
tblUser newUser = new tblUser();
newUser.FirstName = user.FirstName;
newUser.LastName = user.LastName;
newUser.JMBG = user.JMBG;
newUser.IDCard = user.IDCard;
newUser.DateOfBirth = user.DateOfBirth;
newUser.Gender = user.Gender;
newUser.PhoneNumber = user.PhoneNumber;
newUser.SectorID = sector.SectorID;
newUser.LocationID = user.LocationID;
newUser.MenagerID = user.MenagerID;
context.tblUsers.Add(newUser);
context.SaveChanges();
user.UserID = newUser.UserID;
return(user);
}
else
{
tblUser usersToEdit = (from ss in context.tblUsers where ss.UserID == user.UserID select ss).First();
// Get the date of birth
user.DateOfBirth = iv.CountDateOfBirth(user.JMBG);
usersToEdit.FirstName = user.FirstName;
usersToEdit.LastName = user.LastName;
usersToEdit.JMBG = user.JMBG;
usersToEdit.IDCard = user.IDCard;
usersToEdit.DateOfBirth = user.DateOfBirth;
usersToEdit.Gender = user.Gender;
usersToEdit.PhoneNumber = user.PhoneNumber;
usersToEdit.SectorID = sector.SectorID;
usersToEdit.LocationID = user.LocationID;
usersToEdit.MenagerID = user.MenagerID;
usersToEdit.UserID = user.UserID;
context.SaveChanges();
return(user);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception" + ex.Message.ToString());
return(null);
}
}
public override async Task SetupAsync(WorkerContext context)
{
_channel = new Channel(_host, 12346, ChannelCredentials.Insecure);
var receiver = new EchoReceiver(_channel);
_client = StreamingHubClient.Connect <IEchoHub, IEchoHubReceiver>(_channel, receiver);
receiver.Client = _client;
}
public void giveWorkers(string ChiefName)
{
using (WorkerContext db = new WorkerContext())
{
Chief = db.Workers.Find(ChiefName);
}
Action();
}
public void CreateWorkerSupervisor_CreatesAWorkerSupervisorWithGivenParameters()
{
var manager = new WorkerManager(_sharedContext, WorkerCount);
var context = new WorkerContext(_sharedContext, 1);
var worker = manager.CreateWorkerSupervisor(context);
Assert.NotNull(worker);
}
/// <summary>
/// Constructs a GenericWorker. Initializes a <see cref="WorkerContext"/> given the parameters.
/// </summary>
/// <param name="workerType">Type of worker</param>
/// <param name="workerId">Unique ID of worker</param>
/// <param name="hostname">SpatialOS deployment hostname</param>
/// <param name="port">SpatialOS deployment port</param>
protected GenericWorker(string workerType, string workerId, string hostname, ushort port)
{
_workerId = workerId;
_workerType = workerType;
WorkerContext.GetInstance().Init(workerType, workerId, hostname, port);
_logger.Info("Initialized Deployment Context");
}
public void Action(string ChiefName, string WorkerName)
{
using (WorkerContext db = new WorkerContext())
{
Chief = db.Workers.Find(ChiefName);
Person = db.Workers.Find(WorkerName);
}
Action();
}
public Worker Action()
{
using WorkerContext db = new WorkerContext();
Chief.SubWorkers.Add(Person);
db.Entry(Chief).State = EntityState.Modified;
Person.Chief = Chief;
db.Entry(Person).State = EntityState.Modified;
db.SaveChanges();
return(Chief);
}
public void SearchByEdit(string name)
{
using (WorkerContext db = new WorkerContext())
{
foreach (var task in db.Workers.Where(worker => worker.Name == name)
.Select(worker => System.SearchByEdit(worker).ReturnTasks()).SelectMany(newList => newList))
{
Console.WriteLine($"Имя задачи {task.TaskName}");
}
}
}
public void OnCreating(CreatingContext filterContext)
{
IContextoAplicacao contexto = ObterContexto();
if (contexto != null)
{
var contextoTransiente = new WorkerContext();
contextoTransiente.AtribuirContexto(contexto);
filterContext.SetJobParameter("contextoAplicacao", contextoTransiente);
}
}
private static bool WorkerContextIsTrackingSetup(WorkerContext context)
{
return context.TrackerCount > 0;
}
private static void WorkerContextTeardown(WorkerContext context)
{
// Delete the controllers
for (int psmove_id = 0; psmove_id < context.PSMoves.Length; psmove_id++)
{
if (context.PSMoves[psmove_id] != IntPtr.Zero)
{
UnityEngine.Debug.Log(string.Format("Disconnecting PSMove controller {0}", psmove_id));
context.WorkerControllerDataArray[psmove_id].IsConnected = false;
context.WorkerControllerDataArray[psmove_id].IsTrackingEnabled = false;
PSMoveAPI.psmove_disconnect(context.PSMoves[psmove_id]);
context.PSMoves[psmove_id] = IntPtr.Zero;
}
}
// Delete the tracker
WorkerContextTeardownTracking(context);
context.Reset();
}
private static bool WorkerContextSetupTracking(
PSMoveWorkerSettings WorkerSettings,
WorkerContext context)
{
bool success = true;
// Clear out the tracking state
// Reset the shared worker data
context.Reset();
UnityEngine.Debug.Log("Setting up PSMove Tracking Context");
// Initialize and configure the psmove_tracker.
{
PSMoveAPI.PSMoveTrackerSettings settings = new PSMoveAPI.PSMoveTrackerSettings();
PSMoveAPI.psmove_tracker_settings_set_default(ref settings);
settings.color_mapping_max_age = 0; // Don't used cached color mapping file
if (WorkerSettings.bUseManualExposure)
{
settings.exposure_mode = PSMoveTracker_Exposure.Exposure_MANUAL;
settings.camera_exposure =
(int)(Math.Max(Math.Min(WorkerSettings.ManualExposureValue, 1.0f), 0.0f) * 65535.0f);
}
else
{
settings.exposure_mode = PSMoveTracker_Exposure.Exposure_LOW;
}
settings.use_fitEllipse = 1;
settings.filter_do_2d_r = 0;
settings.filter_do_2d_xy = 0;
settings.camera_mirror = PSMove_Bool.PSMove_True;
settings.color_list_start_ind = (int)WorkerSettings.InitialTrackingColor;
context.TrackerCount = 0;
for (int tracker_index = 0; tracker_index < WorkerContext.MAX_TRACKER_COUNT; ++tracker_index)
{
context.PSMoveTrackers[tracker_index] =
PSMoveAPI.psmove_tracker_new_with_camera_and_settings(tracker_index, ref settings);
if (context.PSMoveTrackers[tracker_index] != IntPtr.Zero)
{
UnityEngine.Debug.Log(string.Format("PSMove tracker({0}) initialized.", tracker_index));
++context.TrackerCount;
PSMoveAPI.psmove_tracker_get_size(
context.PSMoveTrackers[tracker_index],
ref context.TrackerWidth, ref context.TrackerHeight);
UnityEngine.Debug.Log(string.Format("Camera Dimensions: {0} x {1}", context.TrackerWidth, context.TrackerHeight));
}
else
{
PSMoveTracker_ErrorCode errorCode = PSMoveAPI.psmove_tracker_get_last_error();
UnityEngine.Debug.Log(string.Format("PSMove tracker({0}) not available: {1}",
tracker_index, errorCode.ToString()));
break;
}
}
if (context.TrackerCount <= 0)
{
UnityEngine.Debug.LogError(string.Format("Failed to open any trackers"));
success = false;
}
}
// Initialize fusion API if the tracker started
if (success)
{
for (int tracker_index = 0; tracker_index < context.TrackerCount; ++tracker_index)
{
context.PSMoveFusions[tracker_index] =
PSMoveAPI.psmove_fusion_new(context.PSMoveTrackers[tracker_index], 1.0f, 1000.0f);
if (context.PSMoveFusions[tracker_index] != IntPtr.Zero)
{
UnityEngine.Debug.Log(string.Format("PSMove fusion({0}) initialized.", tracker_index));
}
else
{
UnityEngine.Debug.LogError(string.Format("PSMove fusion({0}) failed to initialize.", tracker_index));
success = false;
break;
}
}
}
// Initialize a position filter to smooth out the tracking data
if (success)
{
context.PSMovePositionFilter = PSMoveAPI.psmove_position_filter_new();
if (context.PSMovePositionFilter != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove position filter initialized.");
PSMoveAPI.PSMove_3AxisVector initial_position = new PSMoveAPI.PSMove_3AxisVector()
{
x = 0.0f,
y = 0.0f,
z = 0.0f,
};
PSMoveAPI.PSMovePositionFilterSettings filter_settings = new PSMoveAPI.PSMovePositionFilterSettings();
PSMoveAPI.psmove_position_filter_get_default_settings(ref filter_settings);
filter_settings.filter_type = WorkerSettings.FilterType;
PSMoveAPI.psmove_position_filter_init(ref filter_settings, ref initial_position, context.PSMovePositionFilter);
}
else
{
UnityEngine.Debug.LogError(string.Format("Failed to allocate PSMove Position Filter"));
success = false;
}
}
if (!success)
{
WorkerContextTeardownTracking(context);
}
return success;
}
private static void WorkerContextTeardownTracking(WorkerContext context)
{
// Disable tracking on all active controllers
for (int psmove_id = 0; psmove_id < context.PSMoves.Length; psmove_id++)
{
if (context.PSMoves[psmove_id] != IntPtr.Zero &&
context.WorkerControllerDataArray[psmove_id].IsTrackingEnabled)
{
UnityEngine.Debug.Log(string.Format("Disabling tracking on PSMove controller {0}", psmove_id));
context.WorkerControllerDataArray[psmove_id].IsTrackingEnabled = false;
}
}
for (int tracker_index = 0; tracker_index < WorkerContext.MAX_TRACKER_COUNT; ++tracker_index)
{
// Delete the tracking fusion state
if (context.PSMoveFusions[tracker_index] != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove fusion disposed");
PSMoveAPI.psmove_fusion_free(context.PSMoveFusions[tracker_index]);
context.PSMoveFusions[tracker_index] = IntPtr.Zero;
}
// Delete the tracker state
if (context.PSMoveTrackers[tracker_index] != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove tracker disposed");
PSMoveAPI.psmove_tracker_free(context.PSMoveTrackers[tracker_index]);
context.PSMoveTrackers[tracker_index] = IntPtr.Zero;
}
}
context.TrackerCount = 0;
// Delete the position filter
if (context.PSMovePositionFilter != IntPtr.Zero)
{
PSMoveAPI.psmove_position_filter_free(context.PSMovePositionFilter);
context.PSMovePositionFilter = IntPtr.Zero;
}
}
public void ThreadSetup()
{
// Maintains the following psmove state on the stack
// * psmove tracking state
// * psmove fusion state
// * psmove controller state
// Tracking state is only initialized when we have a non-zero number of tracking contexts
Context = new WorkerContext(WorkerControllerDataArray, WorkerSettings);
if (PSMoveAPI.psmove_init(PSMoveAPI.PSMove_Version.PSMOVE_CURRENT_VERSION) == PSMove_Bool.PSMove_False)
{
throw new Exception("PS Move API init failed (wrong version?)");
}
}
private static bool WorkerContextSetupTracking(
PSMoveWorkerSettings WorkerSettings,
WorkerContext context)
{
bool success = true;
// Clear out the tracking state
// Reset the shared worker data
context.Reset();
UnityEngine.Debug.Log("Setting up PSMove Tracking Context");
// Initialize and configure the psmove_tracker.
{
PSMoveAPI.PSMoveTrackerSettings settings = new PSMoveAPI.PSMoveTrackerSettings();
PSMoveAPI.psmove_tracker_settings_set_default(ref settings);
settings.color_mapping_max_age = 0; // Don't used cached color mapping file
if (WorkerSettings.UseManualExposure)
{
settings.exposure_mode = PSMoveTracker_Exposure.Exposure_MANUAL;
settings.camera_exposure =
(int)(Math.Max(Math.Min(WorkerSettings.ManualExposureValue, 1.0f), 0.0f) * 65535.0f);
}
else
{
settings.exposure_mode = PSMoveTracker_Exposure.Exposure_LOW;
}
settings.use_fitEllipse = 1;
settings.camera_mirror = PSMove_Bool.PSMove_True;
settings.camera_api = WorkerSettings.CameraAPI;
settings.path_to_cleye_server_exe = WorkerSettings.ApplicationDataPath + "/Plugins/x86_64";
settings.color_list_start_ind = (int)WorkerSettings.InitialTrackingColor;
context.PSMoveTracker = PSMoveAPI.psmove_tracker_new_with_settings(ref settings);
}
if (context.PSMoveTracker != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove tracker initialized.");
PSMoveAPI.PSMoveTrackerSmoothingSettings smoothing_settings = new PSMoveAPI.PSMoveTrackerSmoothingSettings();
PSMoveAPI.psmove_tracker_get_smoothing_settings(context.PSMoveTracker, ref smoothing_settings);
smoothing_settings.filter_do_2d_r = 0;
smoothing_settings.filter_do_2d_xy = 0;
smoothing_settings.filter_3d_type = WorkerSettings.Filter3DType;
PSMoveAPI.psmove_tracker_set_smoothing_settings(context.PSMoveTracker, ref smoothing_settings);
PSMoveAPI.psmove_tracker_get_size(context.PSMoveTracker, ref context.TrackerWidth, ref context.TrackerHeight);
UnityEngine.Debug.Log(string.Format("Camera Dimensions: {0} x {1}", context.TrackerWidth, context.TrackerHeight));
}
else
{
PSMoveTracker_ErrorCode errorCode= PSMoveAPI.psmove_tracker_get_last_error();
UnityEngine.Debug.LogError(string.Format("PSMove tracker failed to initialize: {0}", errorCode.ToString()));
success = false;
}
// Initialize fusion API if the tracker started
if (success)
{
context.PSMoveFusion = PSMoveAPI.psmove_fusion_new(context.PSMoveTracker, 1.0f, 1000.0f);
if (context.PSMoveFusion != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove fusion initialized.");
}
else
{
UnityEngine.Debug.LogError("PSMove failed to initialize.");
success = false;
}
}
if (!success)
{
WorkerContextTeardown(context);
}
return success;
}
private static bool WorkerContextIsTrackingSetup(WorkerContext context)
{
return context.PSMoveTracker != IntPtr.Zero && context.PSMoveFusion != IntPtr.Zero;
}
private static bool WorkerContextUpdateControllerConnections(WorkerContext context)
{
bool controllerCountChanged = false;
System.Diagnostics.Debug.Assert(WorkerContextIsTrackingSetup(context));
if (context.moveCountCheckTimer.ElapsedMilliseconds >= WorkerContext.CONTROLLER_COUNT_POLL_INTERVAL)
{
// Update the number
int newcount = PSMoveAPI.psmove_count_connected();
if (context.PSMoveCount != newcount)
{
UnityEngine.Debug.Log(string.Format("PSMove Controllers count changed: {0} -> {1}.", context.PSMoveCount, newcount));
context.PSMoveCount = newcount;
controllerCountChanged = true;
}
// Refresh the connection and tracking state of every controller entry
for (int psmove_id = 0; psmove_id < context.PSMoves.Length; psmove_id++)
{
if (psmove_id < context.PSMoveCount)
{
if (context.PSMoves[psmove_id] == IntPtr.Zero)
{
// The controller should be connected
context.PSMoves[psmove_id] = PSMoveAPI.psmove_connect_by_id(psmove_id);
if (context.PSMoves[psmove_id] != IntPtr.Zero)
{
PSMoveAPI.psmove_enable_orientation(context.PSMoves[psmove_id], PSMove_Bool.PSMove_True);
System.Diagnostics.Debug.Assert(PSMoveAPI.psmove_has_orientation(context.PSMoves[psmove_id]) == PSMove_Bool.PSMove_True);
context.WorkerControllerDataArray[psmove_id].IsConnected = true;
}
else
{
context.WorkerControllerDataArray[psmove_id].IsConnected = false;
UnityEngine.Debug.LogError(string.Format("Failed to connect to PSMove controller {0}", psmove_id));
}
}
if (!context.WorkerSettings.DisableTracking &&
context.PSMoves[psmove_id] != IntPtr.Zero &&
context.WorkerControllerDataArray[psmove_id].IsEnabled == false)
{
// The controller is connected, but not tracking yet
// Enable tracking for this controller with next available color.
if (PSMoveAPI.psmove_tracker_enable(
context.PSMoveTracker,
context.PSMoves[psmove_id]) == PSMoveTracker_Status.Tracker_CALIBRATED)
{
context.WorkerControllerDataArray[psmove_id].IsEnabled = true;
}
else
{
UnityEngine.Debug.LogError(string.Format("Failed to enable tracking for PSMove controller {0}", psmove_id));
}
}
}
else
{
// The controller should no longer be tracked
if (context.PSMoves[psmove_id] != IntPtr.Zero)
{
PSMoveAPI.psmove_disconnect(context.PSMoves[psmove_id]);
context.PSMoves[psmove_id] = IntPtr.Zero;
context.WorkerControllerDataArray[psmove_id].IsEnabled = false;
context.WorkerControllerDataArray[psmove_id].IsConnected = false;
}
}
}
// Remember the last time we polled the move count
context.moveCountCheckTimer.Reset();
context.moveCountCheckTimer.Start();
}
return controllerCountChanged;
}
private static void WorkerContextTeardown(WorkerContext context)
{
UnityEngine.Debug.Log("Tearing down PSMove Tracking Context");
// Delete the controllers
for (int psmove_id = 0; psmove_id < context.PSMoves.Length; psmove_id++)
{
if (context.PSMoves[psmove_id] != IntPtr.Zero)
{
UnityEngine.Debug.Log(string.Format("Disconnecting PSMove controller {0}", psmove_id));
context.WorkerControllerDataArray[psmove_id].IsConnected = false;
context.WorkerControllerDataArray[psmove_id].IsEnabled = false;
PSMoveAPI.psmove_disconnect(context.PSMoves[psmove_id]);
context.PSMoves[psmove_id] = IntPtr.Zero;
}
}
// Delete the tracking fusion state
if (context.PSMoveFusion != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove fusion disposed");
PSMoveAPI.psmove_fusion_free(context.PSMoveFusion);
context.PSMoveFusion = IntPtr.Zero;
}
// Delete the tracker state
if (context.PSMoveTracker != IntPtr.Zero)
{
UnityEngine.Debug.Log("PSMove tracker disposed");
PSMoveAPI.psmove_tracker_free(context.PSMoveTracker);
context.PSMoveTracker = IntPtr.Zero;
}
context.Reset();
}
