argonjs / argon Goto Github PK

the argon manager and custom realities use web apis (deviceOrientation and geolocation) if they exist to position and rotate reality

If the current platform doesn't support them, by default there's no way to move and rotate. Some realities support custom keyboard/mouse input (e.g., streetview), but you need to "switch to the reality" and then understand how that works.

We should detect inside an app if these api's exist. If not, the app could provide simple orbit controls and/or WASD movement. The data would get sent to the manager, which would route it to the reality, which would then use it as if it was the real device data, resulting in the reality moving/rotating and the correct pose data being sent back to all apps.

Essentially, send a simulatedOrientation and simulatedLocation to argon, and let it figure out what to do.

Also, and app should be able to override the controls, so (for example) could use threejs orbit or other ui controls.

Currently the geopose sample for Argonjs does not set an altitude for the gatech cesium entity. This works but it reports a false distance because it defaults to sea level if no altitude is entered. This also causes the buzz cube to be located below ground.

ios 10.2 iphone6

Refreshing the pages is finicky and often requires closing down the app and clearing the cache before a page will be reloaded.

Hello,

We have created a developer licence, encrypted using the PGP Encryptor.

Using Argon iphone app we get the error "vuforia failed to initialize: invalid input data".

How can we solve it?

Thanks!

It worked well yesterday but today it reported error in console:
Failed to load resource: the server responded with a status of 502 (Proxy Error)
Fetch API cannot load https://pgp.mit.edu/pks/lookup?op=get&options=mr&search=secure%40argonjs.io. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://docs.argonjs.io' is therefore not allowed access. The response had HTTP status code 502.
Uncaught (in promise) TypeError: Failed to fetch(…)

When I tried writing my own example, Vuforia doesn't load in Argon4. My code looks like this:

this.app.vuforia.init({
        encryptedLicenseData: ...
      }).then(
  (api) => {console.log('yes'); ...},
  (err) => {console.log('no'); ...});

I see neither of these outputs (not 'yes', not 'no'). Instead, I get this (when viewing the console in Argon4):

ERROR Error {
  __proto__: Error
}

Any ideas? I have tried with and without an allowed origin set. I see my 3D object positioned to the north, so the basics are working, but not Vuforia. (It did work OK when I tried viewing the Vuforia sample on the Argon site, just not with my code.)

I realize I can register a promise for when the dataset has loaded, but I'd like to also get the progress event. Since large datasets could take a while, it would be good to know how the download is progressing (so a progress UI can be created)

Problem:

GPS on mobile devices updates slowly (~1 report / second) and is inaccurate (sometimes 10+ meters of error. When using GPS as the location of the AR user, this leads to nearby content (even things a few hundred meters away) appearing to jump suddenly each second.

The first time someone sees this effect, they find it distracting and would like to find a way to deal with it.

Possible Approach

The underlying issue cannot be fixed through software: if it was possible for the mobile GPS accuracy to be improved, it would already be done at the system level. Use of WIFI to improve location, for example, is common in modern operating systems.

The most commonly suggested solution is that argon.js smooth the GPS changes: when a new report arrives, we could smoothly change to it over a short period of time, by interpolating from the "current" location to the newly reported location.

There are different ways of doing this, each of which has pros and cons:

• transitioning over a fixed time (such as 1/4 second) would eliminate the sudden "jump" and ensure the location is updated in a timely manner, but since the GPS error varies over time (with some changes being small, others being large, and occasionally large outliers in the data) this would do little to eliminate large occasional errors.
• transitioning with a maximum rate (such as 1 meter / second) would smooth out jumps and eliminate problematic transient errors that are large, but would be problematic if the user is actually moving at a high speed
• using some sort of easing function (slow in, slow out) to make changes less jarring
• move at a maximum rate until the different between the GPS and the user is greater than some amount for some number of reports
• using the GPS reported speed and heading to figure out a maximum interpolation speed.

None of these solutions would be perfect, but they would eliminate the sudden jumps.

Doing these adjustments at the application level is problematic, as developers would implement different solutions, and the result (if multiple channels are displayed at once) would be problematic.

Also, as we being getting high precision local sensors (Tango, Hololens) that we want to combine with geolocation (e.g., by anchoring the coordinate frames of those sensors in the world using the geolocation of the device), the sudden GPS changes will be less visible, and application-side smoothing may interfere with local tracking. Smoothing (or not) the GPS reports themselves, before they are using argon.js, would be the only "correct" solution.

Proposal

We could add a one or more smoothing functions to argon.js, which could be turned on/off by the end user via a menu item. The menu item would be in Argon4's menu, or the argon.js menu displayed in non-Argon4 browsers.

The advantage of this solution is that we also educate users to the underlying problem, helping set user expectations.

There is a slight downwards shift in webgl rendered content along the viewport plane in the portrait axis. Not sure why (yet), but the shift is visible when both of the directions samples are loaded (webgl and css) and zoomed out. (It’s a little less obvious with the text from the webgl sample, but the text is supposed to be centered on the same directions as the circles from the css sample, and it’s slightly off).

While we've been thinking about the web apps as things that happen on one page, that's not a very general model. Consider something like amazon, that you can log into and move between pages.

Similarly, we need to be able to initialize argon and then move between pages without losing the state of the system.

Perhaps some kind of use of cookies or something will facilitate this. If it was just about "state" (that can be reset quickly) you could imagine this would fall on the client/server app (like Amazon); but, things like vuforia take far to long to "set up again". Plus, we want a way for the apps to behave smoothly as they move from page to page, with no extra flashes or whatever.

Perhaps something simply like having a bit of data that could be stored in a cookie, and if you supply this data to argonInit, the state of the web page is maintained from page-to-page in Argon4? Perhaps even on non-Argon4, argon.js could store the client state somewhere so it could re-create things?

Argon4 needs a way to launch from the normal device browser (e.g.: from iOS Safari) maybe using a protocol like argon4://my_url...

This would allow so many more users with iOS to be able to instantly and effortlessly switch to Argon4 browser whenever they go on a AR-related web page, given they already have the Argon4 browser installed, of course. We could even have Javascript detect the Safari browser and redirect to the App Store to install Argon4 when it's not installed yet.

So if my UI wants to do something with multi touch, I can disable pinch when I get multiple touches I want to do something with, and re-enable pinch when I'm done. May need to have the app keep track so that when it gets a "disable" it can undo a bit of zoom it might already have done

Reminder. I'm putting this here because the "work" is in argon.js, although the app will be "part" of this. When we are displaying a non-AR web page, that covers the screen, the app needs to

• turn off video, compass, etc so that we don't chew through people's batteries. Huge issue people complain about.
• make the background of that web view the normal default (white?) rather than transparent

It's an open question what we should display when there are no web pages. I think we should turn off the video, etc., there too.

First of all, thanks to people working on this project, it's very nice to see a peek preview of the technology standards that the next version Safari might finally be able to comply with... and if not, then Argon beautifully fills this gap!

OK now, about the performances of Argon4 browser app on iOS (might be the same on other platforms, did not check yet) is there a reason why it's slower by a factor of 200% to 250% ? I mean without the AR stuff, just the WebGL stuff alone. Safari to Argon4, same page, same WebGL features, nothing AR related at the moment. On Safari I get for example 34-40fps, on Argon4 the same exact page gets 11-16fps...

Any reason for this and could we improve?

Thanks.

In order to support WebVR, we have to use a reference frame that the camera can be positioned relative to, other than the FIXED frame. We can repurpose the localOrigin frame for this, however the fact that we support multiple representations of "reality" makes things a little bit more complicated (not to mention the fact that the reality can manipulate the user pose as appropriate). Particularly, the general problem we have not really solved as of yet is that we want to be able to expose any tracked object within the current "reality", though still make it possible to access the "raw" pose of tracked objects for various purposes.

After discussing with @blairmacintyre, the solution we came up with is to put these reference frames in two categories, "view" frames which allow you to use these reference frames within the current reality, and "device" frames which allow you to access or recover the "raw" pose. These are managed by a ViewService class and the DeviceService class respectively. In general, most apps should not care about the DeviceService class unless they explicitly need to know where the user physically is in the world.

The following is what this would look like:

class DeviceService {
  /**
  The device `localOrigin` is a platform dependent coordinate system which anchors any tracked
  objects that the system knows about. If geolocation is known, then the device `localOrigin` is 
  positioned in relation to the FIXED frame and oriented such that it represents an East-North-Up
  coordinate system at that geolocation.
  */
  localOrigin:Entity;

  /** 
  The `user` entity represents the physical pose of the user in relation to the `localOrigin`. 
  */
  user:Entity; // alternate names: eye ? camera ?

  /** 
   If device frames are needed in relation to FIXED, 
   geolocation must be subscribed to with this function
  */
  subscribeGeolocation(); // alternate name: subscribeFIXED?
  unsubscribeGeolocation();
}

class ViewService {
  /** 
  The view `localOrigin` entity represents the device `localOrigin`, though relocated 
  for the current reality
  */
  localOrigin:Entity;

  /** 
  The view `user` entity represents the view presented by the current reality
  */
  user:Entity; // alternate names: eye ? camera ?

  /**
  Represents a foot/floor-level plane located below the user. 
  */
  stage:Entity; // alternate names: floor ? deck? 

  /** 
  Represents the visual representation of the ground plane as presented within the current reality.  
  For now, this may just be the same as stage, but eventually we want to allow 
  a reality to specify where the ground is in relation to the user. 
  */
  ground:Entity; // alternate names: floor ? 

  /** 
  If view frames are needed in relation to FIXED, 
   geolocation must be subscribed to with this function
  */
  subscribeGeolocation(); // alternate name: subscribeFIXED?
  unsubscribeGeolocation();
}

The ViewService needs it's own localOrigin in order to represent tracked objects in the current reality. Likewise, it also needs it's own user entity because in certain situations a RealityViewer may not use the device user pose when presenting a view of reality. The stage is meant to define the physical floor plane, which depending on the platform we may have to provide a "best-guess" and or user-configurable setting.

These classes would be accessed on the ArgonSystem instance returned by Argon.init() like so:

const app = Argon.init();
app.device.localOrigin;
app.device.user;
app.view.localOrigin;
app.view.user;
app.view.stage;
app.view.ground;

Anyway, comments / feedback welcome!

---- Update ----

We decided to keep most of the entities on the ContextService class, leaving the ViewService class for getting the current view configuration (viewports / subview projection matrices, etc). E.g.:

const app = Argon.init();
app.device.localOrigin;
app.device.user;
app.context.localOrigin;
app.context.user;
app.context.stage;
app.context.ground;

Other than this detail, all other changes remain as discussed (built-in entities are now to be categorized into two groups, namely "device" entities and "context" entities, provided by the DeviceService and ContextService, respectively)

I've been thinking about what it's going to mean to have something like argon.js running on more capable devices, like Google Tango or Microsoft Hololens, or using realities that have a lot more structural information about the "world".

In all cases, it occurs to me that we might want to have a standard interface to ask "What is the 3D value in the world under this x,y value on the display?". Akin to what Hololens programs use to figure out where to draw the cursor or pick points in the world.

Thoughts?

1. Remove url parameter from VuforiaAPI.objectTracker.createDataSet
2. Add url parameter to DataSet.load
3. Move the dataSet.fetch functionality somewhere that it can be used independent of a DataSet instance, perhaps on the VuforiaAPI instance directly (api.fetchDataSetFiles()).

We need a way to specify the geolocation of vuforia targets (i.e., where a billboard or mural or sign is), and then use that for geolocation of Argon when it's accuracy is better than the GPS.

If you are on a phone, which already has geolocation, but look at a target that is more precisely geolocated, argon should choose the "path to FIXED" in the graph that has the least error.

Not sure what this entails, and to do it right we'd need to revive some of the OSGAR error computation code. But it will be important for some apps.

Hi,

I'm trying to integrate argonjs library in my ionic 2 app. I followed the method which is given in http://docs.argonjs.io/start/setup/.
I installed argonjs using npm npm install @argonjs/argon@^1.0.
Imported in my ts file, import * as Argon from '@argonjs/argon'.
I'm getting Cannot find module "." error when I called init method (Argon.init()).

I am using,
Ionic Framework: 2.0.0-rc.5
Ionic Native: 2.2.11
Ionic App Scripts: 1.0.0
Angular Core: 2.2.1
Angular Compiler CLI: 2.2.1
Node: 6.9.1
OS Platform: Windows 7

tsconfig.json:
{
"compilerOptions": {
"allowSyntheticDefaultImports": true,
"declaration": false,
"emitDecoratorMetadata": true,
"experimentalDecorators": true,
"lib": [
"dom",
"es2015"
],
"module": "es2015",
"moduleResolution": "node",
"sourceMap": true,
"target": "es5"
},
"include": [
"src/**/*.ts"
],
"exclude": [
"node_modules"
],
"compileOnSave": false,
"atom": {
"rewriteTsconfig": false
}
}

Error message:
Runtime Error
Cannot find module "."
Stack
Error: Cannot find module "."
at webpackMissingModule (http://localhost:8100/build/main.js:97112:3910)
at http://localhost:8100/build/main.js:97112:3988
at Object. (http://localhost:8100/build/main.js:97112:4534)
at Object. (http://localhost:8100/build/main.js:118068:30)
at webpack_require (http://localhost:8100/build/main.js:20:30)
at Object. (http://localhost:8100/build/main.js:55840:73)
at webpack_require (http://localhost:8100/build/main.js:20:30)
at Object. (http://localhost:8100/build/main.js:118078:75)
at webpack_require (http://localhost:8100/build/main.js:20:30)
at Object. (http://localhost:8100/build/main.js:85858:73)

Please let me know what I'm doing wrong here...

Fresh install, gives these warnings:
npm WARN package.json [email protected] No repository field.
npm WARN package.json [email protected] No license field.
npm WARN deprecated [email protected]: lodash@<3.0.0 is no longer maintained. Upgrade to lodash@^4.0.0.
npm WARN deprecated [email protected]: graceful-fs version 3 and before will fail on newer node releases. Please update to graceful-fs@^4.0.0 as soon as possible.

First two are easy to fix. For the other two: can you edit the package file to give a less explicit version of those packages, if new version work?

In argon-aframe, I had the render function set up this way for a while to try and make the app more responsive when the content being rendered was too much for the device:

    argonRender: {
       value: function (frame) {
        if (!this.animationFrameID) {
          var app = this.argonApp;

          this.rAFviewport = app.view.getViewport();
          this.rAFsubViews = app.view.getSubviews();
          this.animationFrameID = requestAnimationFrame(this.rAFRenderFunc.bind(this));
        }
      },
      writable: true 
    },

    rAFRenderFunc: {
      value: function () {

The idea was twofold:

1. it appeared, on some devices like iOS, that wrapping ensuring the rendering happened directly inside a rAF callback prevented extra DOM repair if the DOM changed (such as with the CSS renderer).
2. if the render callbacks happened faster than we could render, we'd ignore the extra ones (instead of them getting queued and just rendering later). Specifically, by skipping then, we hope to ensure we only render when we can render immediately (rather than slightly delayed). (reducing frame rate, possibly, but improving perceived latency). Otherwise, we could find ourselves in the situation where we are always rendering slightly behind.

I need to remove this, though, for cases where we use native WebVR for rendering, since we don't want to introduce a rAF call from within a webVR high-performance rAF call (it results in rendering only occurring at a very slow frame rate).

So it would be nice if this sort of thing might be integrated in the right place inside argon, for those cases where it matters.

Sorry, I'm not sure where to post issues with the Argon4 app itself...

I have HTML like this:

<head>
  <base href="/">
</head>
<body>
  <script type="text/javascript" src="inline.cb1bd35e2bccd5ae57d2.bundle.js">
</body>

If that JavaScript file doesn't exist, or doesn't exist relative to the specified "base", then a desktop browser shows a 404 error in the console (e.g. Failed to load resource: the server responded with a status of 404 (Not Found)).

Argon4 shows no console output. Without the script(s) the page is (in my case) largely empty and unresponsive, and I can't tell whether it's taking forever to load content or broken or what.

It would be really helpful to see the 404 errors in the console. I just need it to give me the "duh" moment so I can fix the base or whatever. :)

We need to be able to create custom realities that leverage the native video / view.

Example: I would like to create a custom live video reality where the user's location is fixed (e.g., I've told them to stand at a certain place) or where I heavily smooth (or freeze) GPS location data while the user is doing something in my app.

When we eventually support devices like Tango, I can imagine wanting to leverage the local sensor data in the reality, in ways that are shared across apps.

Seems like this should be possible, but would want to make sure it's efficient.

Hello,

Can we get the argon4 browser app code?

Thanks in advance!

I used aframe texture to incorporate video
The video plays fine on safari. However on Argon it does not play even though I have set the video to auto play.

On safari

On Argon

We need to support AR in a div; especially important on the iPad, or on desktop (Where AR might be done with a pano or video or streetview).

We will need to provide an example showing people that they will need to NOT set the background color of the body, but instead set up a table or something so they can set the background of everything-but the AR part.

We could, possibly, provide a way to set the background color at the base layer (since we need to render "something" when we position the video in a small area).

This is just something I noticed while testing out the application on my iPhone. In the iOS app, when I'm in the Live-Reality mode and I try to refresh the view by clicking on the refresh icon, it freezes and the camera no longer provides a live feed. I believe what it should be doing is reload the view and continue as before but it seems to be getting stuck somewhere.

Argon4 browser reports as Safari and this is somewhat of a problem, because some server-side scripts (PHP, ASP or Java) might want to customize their output to the browser depending on the user-agent, so it needs to say something like: Argon4 or Argon version 4.0 or something standard like that. This may also be seen as unethical that Argon4 reports as Safari for the sole reason it is not exactly Safari.

This example does not work on iOS, all values stay at zero and no GeoTracking is done. http://argonjs.io/samples/code/geopose/index.html

If I run the webgl directions sample in mobile safari, I think the world is rotated by 180 degrees with north showing up in the south directions.

Probably need someone to more methodically work through orientation in native web browsers. I tried a sample on a Surface Pro in Edge last year, and it didn't work at all.

I need to be able to have a web app that loads argon.js, but does NOT start in AR mode. And, There needs to be a way to switch AR on/off. Combine this with being able to have the argon div fullscreen or not.

May be worth looking at WebVR, to see how they do it. The webVR demos are generally in a canvas, but can switch in and out of "VR mode".

We should distinguish between entities that have an unknown pose ('null' entity state updates), and entities that haven't changed their state (simply not sending a state update). Not sending down updates for entities that haven't moved just requires a little more bookkeeping, as we still have to make sure that any new subscriptions to an entity get an initial entity state.

I gather this is usually caused by calling require with a variable instead of a string:

WARNING in ./~/@argonjs/argon/dist/argon.js
1:3743-3750 Critical dependency: require function is used in a way in
which dependencies cannot be statically extracted

WARNING in ./~/@argonjs/argon/dist/argon.js
1:3789-3796 Critical dependency: require function is used in a way in
which dependencies cannot be statically extracted

It appears to be correct when the phone is in portrait.

But in landscape it's wrong, and on the desktop browser, it's wrong (unless the browser is resized to be similar shape to the phone in landscape).

Add the possibility to clear any cache such as local/session-Storage, cookies etc, either via the App itself (in the dropdown menu perhaps?) or through settings in iOS.

Hello,

I'm playing with geopose sample and trying to integrate some Cesium sample like this one.

So, I tried to replace the highlighted code snippet from geopose sample for..

function computeCircle(radius) {
    var positions = [];
    for (var i = 0; i < 360; i++) {
        var radians = CesiumMath.toRadians(i);
        positions.push(new Cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
    }
    return positions;
}

var gatechGeoEntity = new Cesium.Entity({
    name : 'Red tube with rounded corners',
    polylineVolume : {
        positions : Cartesian3.fromDegreesArray([-85.0, 32.0,
                                                        -85.0, 36.0,
                                                        -89.0, 36.0]),
        shape : computeCircle(100.0),
	orientation: Cesium.Quaternion.IDENTITY
    }
});

..and am receiving the following error in browser console:

Right-hand side of 'instanceof' is not callable, when instantiating the modified gatechGeoEntity.

Any ideas on how to proceed?

Thanks

There are a few resources libraries in samples and argon-aframe that are things people may want to "rely on", and that should be synchronized with argon.js

right now these include: ArgonSunMoon.js, CSS3DArgonHUD.js and CSS3DArgonRenderer.js, and are in the code/resources/lib directory in the samples repo. Should we just leave them there, or move them here, and have the URLs point here.

We should start being more careful to help people know what these are, and use the right versions. We should also avoid duplication. Right now these are in argon-aframe, too, for example.

It would be preferable that when the user enters WebVR and then returns, the camera properties (pose, and field of view) are reset to what they were before entering VR.

I think this would have to change in the Empty reality, that gets used on the WebVR-capable browsers. But, eventually, other realities might need to do this too.

When integrating argon with a non-trivial library, like AFrame, it is awkward to have the pose of the camera in each view specified absolutely. For example, there are components in AFrame that want to know where the "camera" is, which all assume the camera is attached to an entity and has it's position/orientation set.

So, I'm having to create an entity with a camera, put it in the scene graph, and set it's pose to the user. BUT, the AFrame graph has the pose of the entity on a THREE.Group which contains the THREE.PerspectiveCamera. Since the THREE renderers pay attention to the scene graph parent/child relationships, if I just use the subview camera directly, I get the pose of ar.user and THEN the pose of the subview camera, which is wrong. So, I'm subtracting the position and orientation of parent, which is a waste of effort.

If we simply make the subview cameras be relative to one pose (ar.user?), we just need to create a parent for the camera that we set that pose to. Since most of our examples already "get" the pose of user, this will be no extra effort.

jspm build src/argon.ts .tmp/argon-build.js --node --format umd --global-name Argon --skip-source-maps && derequire .tmp/argon-build.js > dist/argon.core.js

 Creating the single-file build for src/argon.ts...

err Error on translate for src/argon.ts at file:///Users/abc/work/argon/src/argon.ts
(SystemJS) ENOENT: no such file or directory, open '/Users/abc/work/argon/jspm_packages/npm/[email protected]'
Error: ENOENT: no such file or directory, open '/Users/abc/work/argon/jspm_packages/npm/[email protected]'
Error loading /Users/abc/work/argon/jspm_packages/npm/[email protected]
Unable to load transpiler to transpile /Users/abc/work/argon/src/argon.ts

npm ERR! Darwin 16.4.0
npm ERR! argv "/usr/local/Cellar/node/7.4.0/bin/node" "/usr/local/bin/npm" "run" "build:core"
npm ERR! node v7.4.0
npm ERR! npm v4.0.5
npm ERR! code ELIFECYCLE
npm ERR! @argonjs/[email protected] build:core: jspm build src/argon.ts .tmp/argon-build.js --node --format umd --global-name Argon --skip-source-maps && derequire .tmp/argon-build.js > dist/argon.core.js
npm ERR! Exit status 1
npm ERR!
npm ERR! Failed at the @argonjs/[email protected] build:core script 'jspm build src/argon.ts .tmp/argon-build.js --node --format umd --global-name Argon --skip-source-maps && derequire .tmp/argon-build.js > dist/argon.core.js'.
npm ERR! Make sure you have the latest version of node.js and npm installed.
npm ERR! If you do, this is most likely a problem with the @argonjs/argon package,
npm ERR! not with npm itself.
npm ERR! Tell the author that this fails on your system:
npm ERR! jspm build src/argon.ts .tmp/argon-build.js --node --format umd --global-name Argon --skip-source-maps && derequire .tmp/argon-build.js > dist/argon.core.js
npm ERR! You can get information on how to open an issue for this project with:
npm ERR! npm bugs @argonjs/argon
npm ERR! Or if that isn't available, you can get their info via:
npm ERR! npm owner ls @argonjs/argon
npm ERR! There is likely additional logging output above.

npm ERR! Please include the following file with any support request:
npm ERR! /Users/abc/work/argon/npm-debug.log

npm ERR! Darwin 16.4.0
npm ERR! argv "/usr/local/Cellar/node/7.4.0/bin/node" "/usr/local/bin/npm" "run" "build"
npm ERR! node v7.4.0
npm ERR! npm v4.0.5
npm ERR! code ELIFECYCLE
npm ERR! @argonjs/[email protected] prebuild: npm run build:core && npm run build:browser && uglifyjs dist/argon.js -b -o dist/argon.js
npm ERR! Exit status 1
npm ERR!
npm ERR! Failed at the @argonjs/[email protected] prebuild script 'npm run build:core && npm run build:browser && uglifyjs dist/argon.js -b -o dist/argon.js'.
npm ERR! Make sure you have the latest version of node.js and npm installed.
npm ERR! If you do, this is most likely a problem with the @argonjs/argon package,
npm ERR! not with npm itself.
npm ERR! Tell the author that this fails on your system:
npm ERR! npm run build:core && npm run build:browser && uglifyjs dist/argon.js -b -o dist/argon.js
npm ERR! You can get information on how to open an issue for this project with:
npm ERR! npm bugs @argonjs/argon
npm ERR! Or if that isn't available, you can get their info via:
npm ERR! npm owner ls @argonjs/argon
npm ERR! There is likely additional logging output above.

npm ERR! Please include the following file with any support request:
npm ERR! /Users/abc/work/argon/npm-debug.log

Especially if that reality is the video camera

Perhaps do something like rAF, requestRealityImage(), where you can provide a callback along with configuration options: sub-rectangle of the video, a sampling amount to get lower res, etc.

Custom realities could provide a method to do this, or we could fall back to grabbing the image from the native reality surface

If we're going to compute things about the platform, they should be exposed somehow.

Things that would be useful

• isMobile
• OS (iOS, android, windows, etc)
• phone or tablet or laptop or desktop (whatever you can tell)
• platform supports location
• platform supports orientation
• mouse or touch

Probably other things.

Anything else?

The edge browser appears to be giving argon orientation info, but the orientation data is bad (on my surface book), so it's pointing "down-ish" but not rotating in any reasonable way.

Would be lovely if it used it, but it doesn't appear to work.

Please fix the QUICK START guide, poor newbies scratching their head 🙀

1. Begin with fixing argon.min.js file path which seems to have changed location. It leads to a 404 error page on GitHub from this page, at the top first link: http://docs.argonjs.io/start/setup/

2. A couple typos (or recommendations if not typos) in the sample code for beginners on: http://docs.argonjs.io/tutorial/part1/
   -- At a couple places, the code refers to "Cesium." and that should be changed to "Argon.Cesium" for total compatibility. I know in my case I'm not using require.js and that may cause namespace problems, but at least be consistent because sometimes the code reads "Argon.Cesium." other times "Cesium." and other times "Cartesian3." which is a member-object of "Cesium" so that's 3 different namespace calls in the same code example! 😮 I'm especially targeting these 2 sample code boxes on the page, oh and "ReferenceFrame" should be set to "Argon.Cesium.ReferenceFrame" for the same reason:

var boxGeoEntity = new Argon.Cesium.Entity({ name: "I have a box", position: Cartesian3.ZERO, orientation: Cesium.Quaternion.IDENTITY });

... and...

`
// the updateEvent is called each time the 3D world should be
// rendered, before the renderEvent. The state of your application
// should be updated here.
var boxInit = false;

app.updateEvent.addEventListener(function (frame) {
// get the position and orientation (the 'pose') of the user
// in the local coordinate frame.
var userPose = app.context.getEntityPose(app.context.user);

// assuming we know the user's pose, set the position of our 
// THREE user object to match it
if (userPose.poseStatus & Argon.PoseStatus.KNOWN) {
    userLocation.position.copy(userPose.position);
}
else {
    // if we don't know the user pose we can't do anything
    return;
}
// the first time through, we create a geospatial position for
// the box somewhere near us 
if (!boxInit) {
    var defaultFrame = app.context.getDefaultReferenceFrame();

    // set the box's position to 10 meters away from the user.
    // First, clone the userPose postion, and add 10 to the X
    var boxPos_1 = userPose.position.clone();
    boxPos_1.x += 10;

    // set the value of the box Entity to this local position, by
    // specifying the frame of reference to our local frame
    boxGeoEntity.position.setValue(boxPos_1, defaultFrame);

    // orient the box according to the local world frame
    boxGeoEntity.orientation.setValue(Cesium.Quaternion.IDENTITY);

    // now, we want to move the box's coordinates to the FIXED frame, so
    // the box doesn't move if the local coordinate system origin changes.
    if (Argon.convertEntityReferenceFrame(boxGeoEntity, frame.time, ReferenceFrame.FIXED)) {
        scene.add(boxGeoObject);
        boxInit = true;            
    }
}
// get the local coordinates of the local box, and set the THREE object
var boxPose = app.context.getEntityPose(boxGeoEntity);
boxGeoObject.position.copy(boxPose.position);
boxGeoObject.quaternion.copy(boxPose.orientation);

// rotate the boxes at a constant speed, independent of frame rates     
// to make it a little less boring
box.rotateY(3 * frame.deltaTime / 10000);

});
`

[Sorry, GitHub does not seem to allow very long code excerpts, weird that it cuts top and bottom lol...]

Just to clarify, the example would NOT run without making it consistent with the namespace, in other words I had to replace all those with "Argon.Cesium." and then it worked flawlessly so I suggest to make it easier for newbies to change it in the QUICK START guide so that at least examples run straight the first time without adjusments required ;-)

Thanks

Need a reality that puts video in the background (via getUserMedia) and perhaps does some tracking (via something like https://trackingjs.com).

Will need to create a method (and UI) for approximating the field of view of the camera. Whomever is doing this should talk to me, I have some ideas on this.

Running the Vuforia sample on an iPad Pro, I get all of the following in the console. None of it stops anything from working.

Unhandled Error: ReferenceError: Can't find variable: __ARGON_PORT__ (undefined: 1)
...
Recalculating device params.
User agent: Mozilla/5.0 (iPad; ...
Pixel width: 2048
Pixel height: 1536
No DPDB device match.
New device parameters:
null
Failed to recalculate device parameters
...
Unhandled Error: TypeError: undefined is not an object (evaluating 'originalDescGet.apply') (undefined: 2802)
...
Invalid timestamps detected.  Time step between successive gyroscope sensor samples is very small or not monotonic

That last one I've seen a few times, but it doesn't happen on every run, and I haven't seen it more than once per run. (This latest time I noticed that my lighting stopped working, and the light is positioned in my render event listener, so it's possible the listener stopped working after the not monotonic error, but I haven't done much diagnosis on the lighting thing so it might also be unrelated.)

When the geolocation api does not provide altitude, we currently fallback on the value 0, which is actually really bad, as 0 is the surface off the ellipsoid, which is not necessarily the ground level at any given geolocation. Instead, we should be using a terrain server. We can probably use the one that Cesium/AGI provides: https://cesiumjs.org/Cesium/Build/Documentation/sampleTerrain.html

We also need to make sure that we make it easy for people to create geo reference frames that have an accurate altitude, so probably want to make a request to the terrain server for each geo reference frame that is created. We can probably add an api that abstracts these details away (Argon.createGeoReferenceFrame(lon, lat)).

Right now when you update the app.js or index.html or any other file that loads as part of an argon application, it won't show the update from the webserver, since the file gets stored in the ios app cache. this should be fixed. Alternatively if its possible to fix this on the webserver side that work around should be documented.

Two related bugs:

1. Problem that seems to be between the new argonjs and argon-aframe.
   artnotart.org/jdbolter/ar-frame/panorama/show2.html
   artnotart.org/jdbolter/ar-frame/panorama/show2a.html

The only difference between show2 and show2a is that show2 uses the previous version of argonjs and show2a uses the latest version. What is supposed to happen: four panos are loaded and the first is shown. There is a disk with the Malmö logo on it in the scene. When the user holds the cursor over the disk for 1.5 secs, the next pano should be shown, and so on through all four panos. Show2 works in Argon. Show2a shows the first pano, but when the user holds the cursor over the disk, the next pano appears but the disk is now stuck to the screen rather than in the 3d space. It is no longer possible to move the cursor over it.

In addition if you load show2a into the Safari browser on the iPhone, no panorama shows at all.

2. Problem that predates switch to new argonjs
   Just using show2.html. This works in Argon. However, if you load it into the Safari browser, the first pano appears. When you move the cursor over the Malmö disk, the screen goes black. No further panos appear.

The code for show2 and show2a are found here.:
https://github.com/jdbolter/argon-aframe-tests/tree/dev/panorama

When running the Vuforia sample, I get a number of deprecation warnings: createDataSet, subscribeToEntityById, and getEntityPose

I'm having trouble figuring out the "correct" usage. Here's what I tried:

this.app.vuforia.init(...)
.then((api) => {
  this.vuforiaAPI = api;
  return this.vuforiaAPI.objectTracker.createDataSetFromURI("foo.xml");
}).then((dataSetId) => {
  this.vuforiaDataSetId = dataSetId;
  return this.vuforiaAPI.objectTracker.loadDataSet(dataSetId);
}).then((trackables) => {
  return this.app.context.subscribe(trackables["foo"].id);
}).then((targetEntity) => {
 ...
}).catch(...);

And I get this error:

Request 'ar.vuforia.objectTrackerLoadDataSet' rejected with reason:
Unable to handle message ar.vuforia.objectTrackerLoadDataSet

with an alert that says

No handlers are available for topic
ar.vuforia.objectTrackerLoadDataSet

Any advice?