eudk

Assertion wrapper function that's only executed in development builds.

The condition that needs to be true. The message to log.

Assertion wrapper function that's executed in release and development builds.

The message to log.

Geo Transform class to provide latitude, longitude and altitude based control over game objects.

TODO(mscharer): Add rotation calculations to all operations.

Reference to the relocation service.

The altitude in meters.

Transformation matrix between globe and this GeoTransform to update the transform based on EUDKPlugin._StartFromGlobe, respecting changes to viewer scale, heading, anchor offsets and the start space's Lla

The latitude in degrees.

The longitude in degrees.

The orientation of this GeoTransform relative to the current East-Up-North reference frame.

The unity world-space orientation of said East-Up-North reference frame is cached in _cachedGeoFrameOrientationInUnityWorldSpace.

The cached orientation of the local East-Up-North reference frame in unity world-space. This cache is updated whenever the latitude and/or longitude of this GeoTransform change, as well as during a relocation event. We cache this frame here such that multiple calls to SetGeoOrientation will not recompute this frame every time.

Sets this GeoTransform's new location for all 3 geo coordinates in a single step.

The GeoTransform's new latitude in degrees. The GeoTransform's new longitude in degrees. The GeoTransform's new altitude in meters. Returns true, if the longitude was altered by +/-180 degrees due to exceeding latitude -90 / 90 degrees.

Sets this GeoTransform's new geoOrientation, which is a quaternion describing the orientation of the object relative to the East-Up-North reference frame at its current LLA location.

The new orientation of this GameObject relative to the local East-Up-North reference frame.

Transform a direction vector from Unity world coordinates to LLA coordinates at the LLA location of this GeoTransform.

The direction vector in Unity world space. Latitude component in degrees of the direction in LLA space. Longitude compoment in degrees of the direction in LLA space. Altitude component in meters of the direction in LLA space. If the output values of this method are used as arguments for GeoTransform.Translate, this GeoTransform's new LLA location will be such that, if transformed to Unity world space, the new world position is the same as if the original worldDirection would have been used as argument for UnityEngine.Transform.Translate(). The difference is that, by translating in LLA space, the LLA relative orientation will be preserved.

Translates the GeoTransform by a given amount in LLA. Translate will automatically handle the wrapping of latitude to [-90,90] and longitude to [-180,180].

The latitude difference in degrees by which to translate the GeoTransform. The longitude difference in degrees by which to translate the GeoTransform. The altitude difference in meters by which to translate the GeoTransform. Returns true, if the heading towards north was rotated by 180 degrees due to crossing the north or south pole (latitude +- 90).

Updates this GeoTransforms LLA coordinates and geoOrientation based on the current Unity.Transform of this object.

Whether to update the LLA location based on the Unity Transform. Only set this to false when you are going to overwrite _longitude, _latitude and _altitude right after this call. Whether to update _geoOrientation based on the Unity Transform. Only set this to false when you are going to overwrite _geoOrientation right after this call.

Initializes this geo transform.

Updates the globeFromGeoTransform matrix.

Wraps the provided Lla values and provides the resulting new Lla as out parameters. The return value is true, if the heading around the Up direction was flipped.

The latitude to wrap. The longitude to wrap. The altitude to wrap. The new, wrapped latitude. The new, wrapped longitude. The new, wrapped altitude. True if the orientation around the Up direction was flipped.

Called by Unity when this component is disabled.

Called by Unity when this component is enabled.

Called by the relocation manager before the world has been relocated.

Called by the relocation manager after the world has been relocated.

True position of the GeoTransform in Unity cartesian world coordinates

The GeoTransform position

Gets and sets the GameObject's altitude in meters in LLA space.

The altitude in meters.

Gets and sets the GameObject's latitude in degrees in LLA space.

The latitude in degrees.

Gets and sets the GameObject's longitude in degrees in LLA space.

The longitude in degrees.

Gets and sets the GameObject's geoOrientation, which is a quaternion describing the orientation of the object relative to the East-Up-North reference frame at its current LLA location.

Component to move a GeoTransform in LLA coordinates. The component uses Time.deltaTime to calculate the change per frame to apply.

The amount in degrees by which the latitude shall change per second.

The amount in degrees by which the longitude shall change per second.

The amount in meters by which the altitude shall change per second.

Cached reference to the Transform component on this game object for fast access.

Cached reference to the GeoTransform component on this game object for fast access.

Called by Unity upon activation of this component.

Called by Unity upon deactivation of this component.

Called by Unity upon initialization of this component.

Called at the end of Unity's main loop prior to rendering. Used to calculate if a world relocation is required.

Unity class to calculate coordinate space transformations between different coordinate spaces.

Gets the geo location of a transform in Unity world space.

The Unity world position to convert into Lla space. The latitude in degrees for this position in Lla space. The longitude in degrees for this position in Lla space. The altitude in meters for this position in Lla space.

Gets the world position of a set of latitude, longitude and altitude in Lla space.

The desired Lla space latitude in degrees. The desired Lla spacelongitude in degrees. The desired Lla spacelatitude in meters.

Returns a quaternion that encodes the current Unity world-space orientation of the East-Up-North reference frame at the given lat/long. The particular axis order (East-Up-North) is chosen such that, if applied to a regular unity Transform, the GameObjects' local X axis will point east, the Y axis will point towards the sky and the Z axis will point north.

The LLA space latitude in degrees. The LLA space longitude in degrees. A quaternion q for which the following holds: q * Vector3.right equals a unit vector in unity world space that points east at the given latitude/longitude. q * Vector3.up equals a unit vector in unity world space that points skywards at the given latitude/longitude. q * Vector3.forward equals a unit vector in unity world space that points north at the given latitude/longitude.

Debug output delegate for debug output pushed from the EUDK native plugin to Unity.

The debug message written to the unity log.

Callback called by the EUDK native plugin to remove RockNodes from Unity.

The node path of the RockNode.

Callback called by the EUDK native plugin to push rock proto buffers into Unity.

The proto buffer data. Size of the proto buffer data. The url of the rock node. The node path of the RockNode.

Callback called by the EUDK native plugin to push RockMeshes into Unity.

Pointer to ProtoRockStruct struct that cointains RockMesh data. The url of the rock node. The node path of the RockNode.

Represents the up direction of the EUDK native plugin coordinate space.

The definition of the enum values need to match the same enum in plugin binary.

The up direction points to the sky. That is the inverse of the gravity.

The up direction points to the local north, used for maps for example.

Bindings to native EUDKPlugin for EUDK.

The native plugin's library name used for DllImport.

The epoch, representing the start point in time for timestamp calculation.

Computes the new transformation matrix that maps from Globe coordinates to Unity world coordinates based on a geoView that encodes the new start space coordinates.

The geo view containing the geo view we want to convert. The resulting Matrix4x4d transformation matrix.

Calculates LLA coordinates from a point in Unity world space. This function is relative to the EUDK native plugin anchor.

The point in Unity World space we want to convert. Latitude in degrees for the specified world space. Longitude in degrees for the specified world space. Altitude in meters for the specified world space.

Calculates a point in Unity world coordinates from given LLA coordinates. This function is relative to the EUDK native plugin anchor.

Latitude in degrees we want to convert. Longitude in degrees we want to convert. Altitude in meters we want to convert. The resulting point in Unity world coordinates.

Gets the North, East and Sky unit vectors in unity world space at a specific LLA coordinate.

Latitude in degrees. Longitude in degrees. Altitude over sea level in meters. Resulting north direction in unity world space. Resulting east direction in unity world space. Resulting sky direction in unity world space.

Calculates if a given ray intersects with rock mesh geometry and if so, where it intersected.

The ray for which we want to test the intersection. The distance of the intersection point from the ray.origin. The latitude of the intersection point. The longitude of the intersection point. The altitude of the intersection point. Returns true if the ray intersected with a rock mesh.

Method to convert between Unity world space and GVR Start space: both spaces use real world meters with +Y-axis pointing upwards (reverse of gravity vector), but with opposite handedness.

The vector to convert in Unity world space. The resulting converted coordinate in GVR start space.

Method to convert between Unity world space and GVR Start space: both spaces use real world meters with +Y-axis pointing upwards (reverse of gravity vector), but with opposite handedness.

The vector to convert in Unity world space. The resulting converted coordinate in GVR start space.

Method to convert between Unity world space and GVR Start space: both spaces use real world meters with +Y-axis pointing upwards (reverse of gravity vector), but with opposite handedness.

The vector to convert in GVR start space. The resulting converted coordinate in Unity world space.

Method to convert between Unity world space and GVR Start space: both spaces use real world meters with +Y-axis pointing upwards (reverse of gravity vector), but with opposite handedness.

The vector to convert in GVR start space. The resulting converted coordinate in Unity world space.

Double precision function to convert degrees to radians.

Degrees to convert to radians. The radian representation for the provided degrees.

Clears the required clip planes.

Gets the approximate terrain elevation from memory for a given latitude longitude pair.

Latitude in degrees. Longitude in degrees.

Gets the clip planes in eye space.

The received near plane. The received far plane.

Computes the start space coordinates from the keyhole matrix.

GeoView representing the start space coordinate. The keyhole matrix to convert.

Gets the allowed clip planes in head space. If there is a conflict with required clipping planes, the allowance takes precedence i.e. the actual range used for rendering never lies outside of the allowed clip planes.

The received near plane in head space. The received far plane in head space.

Gets the required clip planes in head space. The actually used range will contain these planes (but may be larger), unless these required clip planes lie outside of the range defined by the allowed clipping planes, in which case the respective allowed clip plane will be used.

The received near plane in head space. The received far plane in head space.

Gets the current date and time of the data.

Timestamp in seconds since EPOCH.

Calculates the geo location from a point in start space.

Note this method is private since we have wrapper functions using Ray and Vector3 instead of float arrays. Point in start space we want to convert to geo location. Resulting points latitude in degrees. Resulting points longitude in degrees. Resulting points altitude in meters.

Gets the current geo view.

Reference to the geo view that's to be filled with the data.

Calculates a point in start space from LLA coordinates.

Note this method is private since we have wrapper functions that return the point in Unity world space and as Vector3d rather than as double array. Latitude in degrees. Longitude in degrees. Altitude in meters. Resulting points coordinates in start space.

Gets the North, East and Sky unit vectors in start space at specific LLA coordinates.

Latitude in degrees. Longitude in degrees. Altitude over sea level in meters. Resulting north direction in start space. Resulting east direction in start space. Resulting sky direction in start space.

Requests the render event function from the plugin.

Native pointer to the event function.

Fetches the currently visible traversal result from the EUDK native plugin.

Pointer to the EUDKNativePluginData.TraversalResult containing the data.

This is invoked when the GameObject of a RockNode is created.

The node path of the RockNode.

Initializes the EUDK native plugin.

This function is not used on Windows.

Private function called by the IntersectWithRay wrapper function.

Note this method is private since we have wrapper functions using Ray and Vector3 instead of float arrays. Ray origin in start space coordinates. Ray direction in start space coordinates. Intersection points distance in start space. Intersection points latitude in degrees. Intersection points longitude in degrees. Intersection points altitude in meters. true if an intersection took place.

Prepares the plugin for multisample rendering.

Sets the allowed clip planes in head space. If there is a conflict with required clipping planes, the allowance takes precedence i.e. the actual range used for rendering never lies outside of the allowed clip planes.

The near plane in head space. The far plane in head space.

Sets the date and time of the data.

Timestamp in seconds since EPOCH.

Sets the target earth LoD bias.

The new target lod bias.

Sets the current geo view.

Reference to the geo view data of the new state.

Sets the maximum ammout of memory the EUDK native plugin is allowed to use in MB.

Maximum cache size in MB.

Sets the maximum render duration in seconds.

Maximum render duration in seconds.

Defines which eye is to be rendered next, left (0) or right (1).

The id of the eye to be rendered next.

Sets the required clip planes in head space. The actually used range will contain these planes (but may be larger), unless these required clip planes lie outside of the range defined by the allowed clipping planes, in which case the respective allowed clip plane will be used.

The near plane in head space. The far plane in head space.

Sets the callback for the Unity debug output function.

Reference to the function.

Sets the callback to the EUDK native plugin to call Unity when RockNodes get removed.

Reference to the function.

When enabled, the EUDK native plugin sends raw protobuffers to Unity. Otherwise, protos are decoded and sent to Unity in EUDKNativePluginData.ProtoRockStruct.

True if raw protobuffer should be sent to Unity.

Sets the callback to the EUDK native plugin to deliver loaded RockMeshes.

Reference to the function.

Sets the callback to the EUDK native plugin to deliver loaded protobuffers of RockNodes.

Reference to the function.

Starts the EUDK native plugin with the specified width, height and refresh rate.

Width of the view rect. Height of the view rect. Output refresh rate in Hz. The absolute path to the EUDK native plugin cache. The keyhole server URL to load the RockTree from. The epoch to be used on the KeyHole server.

Stops the plugin.

Updates the plugin from Unity.

The start from head matrix. The eye viewport width. The eye viewport height. The head from left eye matrix. The head from right eye matrix. The eye vertical field of view in degrees. The eye aspect ratio.

Extern debug message function to write debug messages to the EUDK native plugin.

The debug message to write out.

Structure to hold the geo location data for interaction with the EUDK native plugin.

The latitude in degrees.

The longitude in degrees.

The altitude in meters.

Structure to hold the geo view data for interaction with the EUDK native plugin.

The geo view's geolocation.

The earth anchor point in Start Space (right-handed).

Initial view orientation around _UpDirection in degrees.

The viewer world scale.

The earth up direction.

Explicitly use 32-bit integer instead of enum for robust argument passing between C# and C++.

Represents a 3d point in double precision X, Y, Z coordinates.

The 3d point's X coordinate.

The 3d point's Y coordinate.

The 3d point's Z coordinate.

Marshals an array of data of given type and returns the newly created array. Also frees the memory allocated for the structures on native side.

Struct to hold the necessary data from the asynchronously received proto data.

Measured buffer marshalling time.

The received globe from mesh matrix.

How much unmanaged memory got allocated to free by Unity.

The received meshes.

The rock proto's NodePath.

The received proto buffer data from the plugin.

The rock proto's node url.

Struct to hold meta information about a rock node sent from the EUDK native plugin.

The octant path sent from the plugin. TODO(bergerb): replace this with NodePath structure.

The pointer to globe matrix sent from the EUDK native plugin (double array length 16).

The pointer to the array of ProtoRockStructMesh sent from the EUDK native plugin.

Number of meshes sent from the EUDK native plugin in the pointer _Meshes.

How much unmanaged memory got allocated to free by Unity.

Struct to hold information about a mesh of a node sent by the EUDK native plugin.

Pointer to float array of vertices sent from the EUDK native plugin.

Number of vertices in _VerticesPtr.

Pointers to float array of normals sent from the EUDK native plugin.

Pointer to float array of texture coordinates sent from the EUDK native plugin.

Number of texture coordinats in _TextureCoordinatesPtr.

Pointer to int array of mesh indices sent from the EUDK native plugin.

Number of indices in _IndicesPtr.

Pointer to byte array of raw texture sent from the EUDK native plugin.

Size in number of bytes of the content in _TexturePtr.

Format of the texture in _TexturePtr.

Width in pixels of the texture in _TexturePtr.

Height in pixels of the texture in _TexturePtr.

Struct of Arrays used to send traversal results from the unmanaged to the managed side. Corresponds to unity::TraversalResult defined in plugin.h.

Pointer to the uint64 array of major arguments for the EUDK.NodePath constructor.

Pointer to the uint64 array of minor arguments for the EUDK.NodePath constructor.

Pointer to the int array of numDigits arguments for the EUDK.NodePath constructor.

Pointer to the float array of node opacities for unpopping.

Pointer to the byte array of octant masks.

Main access point to Google Earth imagery.

Integer id that can be used instead of the property string to set shader property values. Value is assigned in Awake() method.

This is not const because the value can be queried earliest in Awake().

Lock the lists of rocknode addition and removals.

Storage for asynchronously received proto buffer objects.

Storage for asynchronously received remvoals of RockNodes.

Keeps track of number of removals from the EUDK native plguin to RockPaths with no RockNode in Unity. (b/37890295)

Reference to the currently active relocation service.

Changes the target size of the EUDK native plugin's in-memory cache, in MB. DEVELOPERS, PLEASE READ FULLY: As an optimization, the EUDK native plugin will hold on to meshes, textures, etc. that it has loaded to improve performance when navigating back to a previously viewed area. The app can set a "target memory limit" to control how large this in-memory cache can grow. For example, if the app sets _maxEUDKNativeMemory to 2048, then the EUDK native plugin may store up to 2GB of data in its in-memory cache. But, there is an IMPORTANT nuance to this target memory limit: The EUDK native plugin will always try to fully draw the current scene based on the current rendering settings. Objects required to draw the scene get stored in the in-memory cache (this makes them available later). As a consequence, it is possible that the current scene requires more memory than the target memory limit specified by the application. In this situation, the in-memory cache will grow as necessary to draw the current scene. This means that if the application does SetMemoryCacheTargetMb(1), the EUDK native plugin won't just use 1MB in its cache. It'll cache what's needed to draw the current scene. This might be 100MB or more. The application can use GetCurrentMemoryCacheSizeMb() to inspect the current runtime size of the cache. Some tips for reducing memory: - Reduce the cache size with this method. - Reduce the level-of-detail for the current mode. - Render into a smaller viewport. - Instantiate an EarthMemoryManager to tune cache and LOD settings in Earth mode.

Sets the cache size in MB to the EUDK native plugin, only when the size changes to previous calls.

The current used cache size.

Changes the mode in which the EUDK native plugin delivers the loaded RockMeshes to Unity. True if the EUDK native plugin should send raw protobuffers, false if the EUDK native plugin should decode the Protobuffer and send data in a ProtoRockStruct.

The EUDK native plugin LoD Bias level.

The material to use to render the Earth geometry.

The timestamp of the earth data we want to receive.

The datas timestamp relative to EPOCH TODO(b/38186625): Remove #if INTERNAL and handle it through a conditional custom inspector for correct variable naming.

KeyHole server URL to be used to load the RockTree from. If empty string, the native plugin will load from the default production server.

Epoch to be used on the specified KeyHole server to load the RockTree from. -1 means loading the newest available epoch on khserver.

The up direction used for the EUDK native plugin coordinate system.

The initial scale of the viewer. A value of 1.0f means human scale.

The camera that will be used for the traversal calculations.

The cached UnityEngine.Transform component of the _camera component.

The currently used altitude.

TODO(b/38186731): Group _currentAltitude, _currentLatitude, _currentLongitude.

The currently used latitude.

TODO(b/38186731): Group _currentAltitude, _currentLatitude, _currentLongitude.

The currently used longitude.

TODO(b/38186731): Group _currentAltitude, _currentLatitude, _currentLongitude.

The cached previous altitude.

TODO(b/38186731): Group _previousAltitude, _previousLatitude, _previousLongitude.

The cached previous EUDK native plugin LoD bias.

The cached previous latitude.

TODO(b/38186731): Group _previousAltitude, _previousLatitude, _previousLongitude.

The cached previous longitude.

TODO(b/38186731): Group _previousAltitude, _previousLatitude, _previousLongitude.

The cached previous timestamp.

The cached previous up direction.

The cached previous viewer scale.

Caching dictionary to map NodePaths to RockNode structures.

Custom logging function that's only executed in development builds.

The message to log.

RockNode removal callback function called by the EUDK native plugin to remove those RockNodes in Unity. This callback is called on a different thread.

The NodePath of the rock node.

RockNode mesh callback function called by the EUDK native plugin to provide Unity with the rock mesh data. This callback maybe called from different threads.

The RockMesh data packed into a ProtoRockStruct. The rock node url. The NodePath of the rock node.

Rock proto callback function called by the EUDK native plugin to provide Unity with the rock proto data. This callback is called on a different thread.

The rock proto data. The size of the rock proto data. The rock node url. The major of the NodePath of the rock node. The minor of the NodePath of the rock node. The number of digits of the NodePath of the rock node.

Helper function for RockNodeMeshCallback and RockNodeProtoCallback to finalize the addition.

Function to print a string from a 3x4 matrix in float[12] format.

The matrix of which to produce the string output. String representation of the 3x4 matrix.

Callback function used to write the EUDK native plugin debug output to the Unity log.

The string to write to the debug log.

Unity invoked quit event called before the application is being terminated.

Called by Unity at the creation of the object. Is only called once.

Refreshes the used camera to allow for play mode / runtime cameras as well as editor view cameras to drive the EUDK native plugin.

Unity start function. Called in the frame after Awake() but before Update() is being called for the first time. This function is used to setup relationship between game objects and parent - child.

Unity update function, called once every frame.

Destroys the GameObject of a RockNode and frees Texture, Material and Mesh of all its childrens.

Called by Unity at the end of the frame's main loop before culling and rendering.

Called by Unity upon destruction of this MonoBehaviour.

Stops the EUDK native plugin.

Sets a new Lla for [0,0,0] in Unity world coordinates used for the unityWorldFromGlobe transformation, updating the EUDK native plugin and the traversal accordingly.

The latitude in degrees. The longitude in degrees. The altitude in meters. The new unityWorldFromGlobe transformation matrix.

Asynchronous function to parse a ProtoEntry, create the game object add it to _rockObjects.

The proto entry to parse and integrate. An IEnumerator to execute asynchronously.

Updates the attributes from the public attributes.

Updates the EUDK native plugin.

This method is called once per eye per frame. We assume the left eye is rendered first, and is when we update the HMD for the plugin.

This event is called when the plugin finished initialization.

Public property to subscribe to the initialization event.

The transformation matrix that maps from Unity world to Globe space coordinates.

The instance of the currently active EUDKPlugin. This is valid only if PluginIsInitialized is true.

Indicate that the EUDK native plugin has been initialized. If it is not initialized, the EUDK native plugin API usage will crash the editor.

The transformation matrix that maps from Globe to Unity world space coordinates.

Internal static reference to expose the used RelocationService to Earth components for relocation offset calculations.

Reference to the camera currently used to calculate the visible part of the Earth.

Represents the path of a Rocktree node. This implementation stores the NodePath using two 64bit unsigned integers which supports 38 tree levels (not including root). The root node is represented by a NodePath with NumDigits = 0. The eight children of the root node have paths '0', '1', '2', '3' ... '7' with NumDigits = 1. Each level of descent into the tree appends one digit to the path. In the Rocktree, the child numbers correspond to the following locations within the parent node (derived by assuming that the ordering among the dimensions is longitude, latitude, altitude): 0: Lower South West 1: Lower South East 2: Lower North West 3: Lower North East 4: Upper South West 5: Upper South East 6: Upper North West 7: Upper North East For "tri-nodes", i.e. nodes below level 0 or 1 which touch either the north or south pole, the West and East children that touch the poles are combined into one double-wide child, and put in the lower-numbered (West) child index. E.g. a node that touches the south pole would have children: 0: Lower South (both West and East) 1: (shouldn't exist) 2: Lower North West 3: Lower North East 4: Upper South (both West and East) 5: (shouldn't exist) 6: Upper North West 7: Upper North East This structure is also used to pass the path between C# and C++, and thus only allows primitive data members.

Lookup array for 10^n.

Constructs a NodePath from two UInt64 and the path length. Since a NodePath can have leading zeroes, the length of the path is passed as argument as well.

Stores the major (closer to the root) part of the path for paths with more than 19 digits. Must contain only digits in [0,7]. Stores the minor (closer to the leaf) part of the path. Contains the full path for paths with fewer than 20 digits. Must contain only digits in [0,7]. The length of the path. Must be non-negative and smaller than 39.

Constructs a NodePath from its string representation.

The string to create the NodePath from. Must contain only digits in the range [0,7] and be shorter than 39 characters.

Each UInt64 can store 19 digits of the NodePath. If NumDigits is smaller than 20, only _minor is used.

Baking field of NumDigits. Required because auto implemented properties are not allowed with more modern .NET MSBuild versions as they do not provide a baking field to set in the constructor, leading to a CS0188 compile error.

Computes a hash code for this NodePath.

Compares two NodePaths for equality.

Compares two NodePaths for inequality.

Converts the NodePath to a string.

Truncates a NodePath. Does not change the NodePath if the new length is longer than the current length.

The number of digits after the truncation, if shorter.

Object invariants that should always evaluate to true.

Since a NodePath can start with leading zeroes, we store the number of digits explicitly.

Represents an octant index, which is an index with a value between 0 and 7 that is used to refer to the different octants of a cube.

The byte storing the octant. This is a value in [0,7].

Casts from Octant to byte.

Casts from byte to Octant.

Returns the OctantMask that masks exactly this Octant.

Returns true iff this is a valid octant.

Computes a hash code for this Octant.

Compares two Octants for equality.

Compares two Octants for inequality.

Converts the Octant to a string.

Gets the OctantName of this Octant.

Enumeration to distinguish the octants.

Represents a mask that has individual bits set for the 8 possible Octants.

OctantMask constant masking no octants.

OctantMask constant masking all octants.

The byte storing a bit mask with each bit corresponding to one octant.

Casts from OctantMask to byte.

Casts from byte to OctantMask.

Implements bitwise or operator.

Implements bitwise and operator.

Implements bitwise xor operator.

Implements bitwise not operator.

Returns true iff this OctantMask has the bit for octant set.

Returns true iff this OctantMask has the bits of octantMask (and potentially more) set.

Computes a hash code for this OctantMask.

Compares two OctantMasks for equality.

Compares two OctantMasks for inequality.

Converts the OctantMask to a string.

Wrapper class to provide logging functionality in EUDK.

Logging wrapper function.

The message to log. The type of message to log.

Logging wrapper function.

The exception to log.

Enumeration that identifies the type of a log message.

This class is implemented analogously to Unity's internal class MathfInternal. It implements an Epsilon that is the smallest positive double precision value that does not equate to Zero. Since System.Double.Epsilon is too small to be detected on ARM systems, this class exposes a different Epsilon value on such systems. See "Platform Notes" on https://msdn.microsoft.com/en-us/library/system.double.epsilon(v=vs.110).aspx

This magic number is taken from DBL_MIN defined in http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0491i/Babbfeda.html The analogous floating point value in MathfInternal is 1.17549435E-38f.

The smallest positive Double value that is significant in numeric operations on non-ARM systems. Corresponds to System.Double.Epsilon.

True if this is an ARM system. See Platform Notes in https://msdn.microsoft.com/en-us/library/system.double.epsilon(v=vs.110).aspx

The smallest positive double value that does not equate to zero.

This is a double precision 4x4 Matrix implementation. The interface of this class does intentionally not adhere to EUDK naming conventions and instead replicates the naming conventions of UnityEngine.Matrix4x4 in order to be in-place replaceable with it.

Computes and returns the inverse of this matrix. If the determinant of the matrix is 0 it will return the zero-matrix.

The inverse of this matrix.

Returns a transposed version of this matrix.

A transposed copy of the current .

Computes the determinant of a matrix.

The determinant of the matrix.

Sets this matrix to a translation, rotation and scaling matrix.

The translation. The rotation. The scale.

Creates a translation, rotation and scaling matrix.

The translation. The rotation. The scale.

Given a source point, a target point, and an up vector, computes a transformation matrix that corresponds to a camera viewing the target from the source, such that the right-hand vector is perpendicular to the up vector.

The source point. The target point. The vector describing the up direction (typically Vector3d.up).

Computes a hash code for this matrix.

Checks for equality with another object.

The object to compare this matrix to. True iff the other object is a Matrix4x4d and each element-wise equality check returns true.

Multiplies two matrices.

The matrix multiplied from the left. The matrix multiplied from the right. The returned result is lhs * rhs.

Transforms a Vector4 by a matrix.

The matrix multiplied from the left. The vector multiplied from the right. The returned result is lhs * v.

Checks whether two matrices are equal.

This is implemented column-wise using the == operator implemented on Vector4d, which does not check for bitwise equality of elements but rather checks whether the distance between the two arguments is smaller than a sigma error.

Checks whether two matrices are not equal.

See remarks of == operator.

Get a column of the matrix.

The zero based index of the column to return. The column as a Vector4d.

Get a row of the matrix.

The zero based index of the row to return. The row as a Vector4d.

Sets a column of the matrix.

The zero based index of the column to set. The Vector4d to set the specified column to.

Sets a row of the matrix.

The zero based index of the row to set. The Vector4d to set the specified row to.

Transforms a position by this matrix (generic).

Returns a position v transformed by the current fully arbitrary matrix. If the matrix is a regular 3D transformation matrix, it is much faster to use MultiplyPoint3x4 instead. MultiplyPoint is slower, but can handle projective transformations as well. The point to transform. The transformed point.

Transforms a position by this matrix (fast).

Returns a position v transformed by the current transformation matrix. This function is a faster version of MultiplyPoint; but it can only handle regular 3D transformations. MultiplyPoint is slower, but can handle projective transformations as well. The point to transform. The transformed point.

Transforms a direction by this matrix.

This function is similar to MultiplyPoint; but it transforms directions and not positions. When transforming a direction, only the rotation part of the matrix is taken into account. The direction to transform. The transformed direction.

Creates a scaling matrix.

Creates a translation matrix.

Returns a nicely formatted string for this matrix.

Returns a nicely formatted string for this matrix. Each element is formated using format.

Constructor that takes 16 doubles in row major order.

Non-boxing Equals comparison.

The other Matrix4x4d to compare against True iff an element wise quality test returns true for all elements.

Explicit cast from double precision Matrix to float precision matrix.

The double precision matrix.

Initializes a new instance of from a Matrix4x4.

The floating point Matrix4x4.

Returns a floating point Matrix4x4.

The representation of the current .

Creates a new from a double array.

16 4x4 matrix values in column major order.

Creates a new from a double array.

16 4x4 marix values in row major order.

Creates a row major double[16] array from this Matrix4x4d.

A double[16] containing the fields of the matrix in row major order.

Creates a column major double[16] array from this Matrix4x4d.

A double[16] containing the fields of the matrix in column major order.

Implements matrix scalar multiplication.

The matrix to multiply with the scalar. The scalar to multiply the matrix with.

Implements scalar matrix multiplication.

The scalar to multiply the matrix with. The matrix to multiply with the scalar.

Get the translation vector from a transformation matrix.

The translation vector.

Extracts rotation from transformation matrix.

The rotation quaternion.

Get the scale vector from a transformation matrix.

The scale vector.

Swaps two columns.

The index of the first column to swap with. The index of the second column to swap with.

Swaps two rows.

The index of the first row to swap with. The index of the second row to swap with.

Computes the classical adjoint of this matrix.

A copy of the current with the classical adjoint of this matrix.

Computes a minor of this matrix, with the submatrix specified by indices r0, r1, r2, c0, c1, c2.

The minor of the current .

The inverse of this matrix (Read Only). If the determinant of the matrix is 0 it will return the zero-matrix.

Returns the transpose of this matrix (Read Only).

Is this the identity matrix?

The determinant of the matrix.

Access element at [row, column].

The row of the element. The column of the element.

Gets/Sets the i-th element in column-major order.

The index of the element to look up in column-major order. The element.

Returns a matrix with all elements set to zero (Read Only).

Returns the identity matrix (Read Only).

Extension methods for Matrix4x4 class.

Get the translation vector from a transformation matrix.

The transformation matrix. Must be orthogonal. The translation vector.

Extracts rotation from orthogonal transformation matrix.

The transformation matrix. Must be orthogonal. The rotation quaternion.

Get the scale vector from a transformation matrix.

The transformation matrix. Must be orthogonal. The scale vector.

Creates a row major float[16] array from this Matrix4x4.

A float[16] containing the fields of the matrix in row major order.

Creates a column major float[16] array from this Matrix4x4d.

A float[16] containing the fields of the matrix in column major order.

This is a double precision Vector3d implementation. The interface of this class does intentionally not adhere to EUDK naming conventions and instead replicates the naming conventions of UnityEngine.Vector3 in order to be in-place replaceable with it.

X component of the vector.

Y component of the vector.

Z component of the vector.

Creates a new vector with given x, y, z components.

Creates a new vector with given x, y components and sets z to zero.

Spherically interpolates between two vectors.

Interpolates between a and b by amount t. The difference between this and linear interpolation (aka, "lerp") is that the vectors are treated as directions rather than points in space. The direction of the returned vector is interpolated by the angle and its magnitude is interpolated between the magnitudes of a and b. The parameter t is clamped to the range [0, 1].

Spherically interpolates between two vectors.

Makes vectors normalized and orthogonal to each other.

Normalizes normal. Normalizes tangent and makes sure it is orthogonal to normal (that is, angle between them is 90 degrees).

Makes vectors normalized and orthogonal to each other.

Normalizes normal. Normalizes tangent and makes sure it is orthogonal to normal. Normalizes binormal and makes sure it is orthogonal to both normal and tangent.

Rotates a vector current towards target.

This function is similar to MoveTowards except that the vector is treated as a direction rather than a position. The current vector will be rotated round toward the target direction by an angle of maxRadiansDelta, although it will land exactly on the target rather than overshoot. If the magnitudes of current and target are different then the magnitude of the result will be linearly interpolated during the rotation. If a negative value is used for maxRadiansDelta, the vector will rotate away from target until it is pointing in exactly the opposite direction, then stop.

Linearly interpolates between two vectors a and b by the interpolant t. Extrapolates if t is outside of the range [0,1].

The first vector. The second vector. The interpolant. a * (1-t) + b * t.

Moves a point current in a straight line towards a target point.

The point to move. The target to move the point towards. The maximum distance the point will be moved. The new position of the moved point.

Gradually changes a vector towards a desired goal over time.

The vector is smoothed by some spring-damper like function, which will never overshoot. The most common use is for smoothing a follow camera. The current position. The position we are trying to reach. The current velocity, this value is modified by the function every time you call it. Approximately the time it will take to reach the target. A smaller value will reach the target faster. Optionally allows you to clamp the maximum speed. The changed vector.

Gradually changes a vector towards a desired goal over time.

Sets the components of this vector.

The new X value. The new Y value. The new Z value.

Multiplies two vectors component-wise.

Every component in the result is a component of a multiplied by the same component of b. The first vector. The second vector. A new vector with all elements being the element-wise products of a and b.

Multiplies the components of this vector by the components of another vector.

The vector to multiply by component-wise.

Cross Product of two vectors.

The cross product of two vectors results in a third vector which is perpendicular to the two input vectors. The result's magnitude is equal to the magnitudes of the two inputs multiplied together and then multiplied by the sine of the angle between the inputs. The first vector. The second vector. The cross product lhs x rhs.

Returns the hash code for this Vector3d.

Returns true if the given vector is exactly equal to this vector.

The other object to compare this vector against.

Reflects a vector off the plane defined by a normal.

The inNormal vector defines a plane (a plane's normal is the vector that is perpendicular to its surface). the inDirection vector is treated as a directional arrow coming in to the plane. The returned value is a vector of equal magnitude to inDirection but with its direction reflected. The direction of the incoming vector. The normal of the plane to reflect on.

Returns a vector with the same direction and a magnitude of 1.

The vector to normalize. The normalized vector.

Makes this vector have a magnitude of 1.

When normalized, a vector keeps the same direction but its length is 1.0. Note that this function will change the current vector.If you want to keep the current vector unchanged, use normalized variable. If this vector is too small to be normalized it will be set to zero.

Dot Product of two vectors.

The dot product is a double value equal to the magnitudes of the two vectors multiplied together and then multiplied by the cosine of the angle between them. For normalized vectors Dot returns 1 if they point in exactly the same direction, -1 if they point in completely opposite directions and zero if the vectors are perpendicular. The first vector. The second vector. Returns the Dot product lhs . rhs.

Projects a vector onto another vector.

To understand vector projection, imagine that onNormal is resting on a line pointing in its direction. Somewhere along that line will be the nearest point to the tip of vector. The projection is just onNormal rescaled so that it reaches that point on the line. The function will return a zero vector if onNormal is almost zero. The vector to project. The normal to project the vector onto. The projected vector.

Projects a vector onto a plane defined by a normal orthogonal to the plane.

The vector to project. The normal of the plane to project the vector onto.

Returns the angle in degrees between from and to.

The angle returned is always the non reflex angle between the two vectors - ie the smaller of the two possible angles between them and never greater than 180 degrees. The angle extends round from this vector. The angle extends round to this vector.

Returns the distance between a and b.

Returns a copy of vector with its magnitude clamped to maxLength.

Computes the magnitude of a vector.

The vector to compute the magnitude of. The magnitude of vector a.

Computes the squared magnitude of a vector.

The vector to compute the squared magnitude of. The squared magnitude of vector a.

Returns a vector that is made from the smallest components of two vectors.

Returns a vector that is made from the largest components of two vectors.

Adds two vectors.

Subtracts one vector from another.

Negates a vector.

Multiplies a vector by a number.

Divides a vector by a number.

Returns true if two vectors are approximately equal.

To allow for double precision inaccuracies, the two vectors are considered equal if the magnitude of their difference is less than 1e-15.

Returns true if two vectors are not approximately equal.

See documentation of the == operator.

Returns a nicely formatted string for this vector.

Returns a nicely formatted string for this vector where each component is formated using format.

The format to use for the components.

Non-boxing Equals method.

The other Vector3d to compare against. True iff a component wise equality test returns true for all components.

Creates a double[3] array from this Vector3d.

A double[3] containing the x, y, z fields of the vector.

Explicit cast from float precision Vector3 to double precision Vector3d.

We could make this conversion implicit, as we're not losing precision. However it makes sense to clearly see in code when such a conversion is happening. The float precision vector.

Explicit cast from double precision Vector3 to float precision Vector3.

The double precision vector.

Clamps value to the range [min, max].

Access the x, y, z components using [0], [1], [2] respectively.

The index of the component to access.

Returns this vector with a magnitude of 1 (Read Only).

Returns the length of this vector (Read Only).

Returns the squared length of this vector (Read Only).

Shorthand for writing Vector3d(0, 0, 0).

Shorthand for writing Vector3d(1, 1, 1).

Shorthand for writing Vector3d(0, 0, 1).

Shorthand for writing Vector3d(0, 0, -1).

Shorthand for writing Vector3d(0, 1, 0).

Shorthand for writing Vector3d(0, -1, 0).

Shorthand for writing Vector3d(-1, 0, 0).

Shorthand for writing Vector3d(1, 0, 0).

Extension methods for UnityEngine.Vector3.

Creates a float[3] array from this Vector3.

The vector to convert to float[]. A float[3] containing the x, y, z fields of the vector.

This is a double precision Vector4d implementation. The interface of this class does intentionally not adhere to EUDK naming conventions and instead replicates the naming conventions of UnityEngine.Vector4 in order to be in-place replaceable with it.

X component of the vector.

Y component of the vector.

Z component of the vector.

W component of the vector.

Creates a new vector with given x, y, z, w components.

Creates a new vector with given x, y, z components and sets w to zero.

Creates a new vector with given x, y components and sets z and w to zero.

Sets the components of this vector.

The new X value. The new Y value. The new Z value. The new W value.

Linearly interpolates between two vectors a and b by the interpolant t. Extrapolates if t is outside of the range [0,1].

The first vector. The second vector. The interpolant. a * (1-t) + b * t.

Moves a point current towards target.

This is essentially the same as Vector4.Lerp but instead the function will ensure that the speed never exceeds maxDistanceDelta. Negative values of maxDistanceDelta pushes the vector away from target.

Multiplies two vectors component-wise.

Multiplies the components of this vector by the components of another vector.

The vector to multiply by component-wise.

Returns the hash code for this Vector4d.

Non-boxing Equals method.

The other Vector3d to compare against. True iff a component wise equality test returns true for all components.

Returns true if the given vector is exactly equal to this vector.

The other object to compare this vector against.

Returns a vector with the same direction and a magnitude of 1.

The vector to normalize. The normalized vector.

Makes this vector have a magnitude of 1. If this vector is too small to be normalized it will be set to zero.

Dot Product of two vectors.

The first vector. The second vector. Returns a . b.

Projects a vector onto another vector.

Returns a projected onto b.

Returns the distance between a and b.

Computes the length of a vector. The length of the vector is square root of (x*x+y*y+z*z+w*w).

The vector to compute the magnitude of. The magnitude of the vector.

Returns a vector that is made from the smallest components of two vectors.

Returns a vector that is made from the largest components of two vectors.

Adds two vectors.

Subtracts one vector from another.

Negates a vector.

Multiplies a vector by a number.

Divides a vector by a number.

Returns true if two vectors are approximately equal.

To allow for double precision inaccuracies, the two vectors are considered equal if the magnitude of their difference is less than 1e-15.

Returns true if two vectors are not approximately equal.

See documentation of the == operator.

Converts a Vector3d to a Vector4d.

Converts a Vector4d to a Vector3d.

Converts a Vector2 to a Vector4d.

Converts a Vector4d to a Vector2.

Returns a nicely formatted string for this vector.

Returns a nicely formatted string for this vector where each component is formated using format.

The format to use for the components.

Returns the squared length of a vector.

The vector to compute the squared magnitude of. The squared magnitude of the vector.

Returns the squared length of this a vector.

Clamps value to the range [min, max].

Access the x, y, z, w components using [0], [1], [2], [3] respectively.

The index of the component to access.

Returns this vector with a magnitude of 1 (Read Only).

Returns the length of this vector (Read Only).

Returns the squared length of this vector (Read Only).

Shorthand for writing Vector4d(0, 0, 0, 0).

Shorthand for writing Vector4d(1, 1, 1, 1).

Class to manage memory that got allocated on the native side.

The native plugin's library name used for DllImport.

Free memory that got allocated in different ways on the native side.

Pointer to memory adress to be freed.

Structure to hold the relevant datasructures of a RockNode together.

Current status of the RockNode.

The root GameObject of this RockNode. The meshes are stored in it's children.

The renderers of all meshes of this RockNode.

The materials of all meshes of this RockNode.

The Unity transform of the GameObject.

The RockPath of the RockNode.

Keeps track of extra additions of the RockPaths from the EUDK native plugin to Unity, compared to removals on the same Path. An addition of a RockNode that is already in Unity incremenets _ExtraAdditions by 1, a removal only removes the RockNode from Unity if _ExtraAdditions is 0 or else just decrements _ExtraAdditions by 1 (b/37890295).

Populates the fields of this RockNode based on the passed GameObject, which must be the parsing result of a rock proto.

Frees all Unity Resources this RockNode currently references and destroys the associated GameObjects.

Status of a RockNode on the Unity side regarding decoding/parsing or creation of GameObject.

Before the GameObject is created and added to the scene.

Loaded and rendered in scene.

Still loading but already removed again.

GameObject got destroyed.

Class to parse one RockNode from a RockProto stream.

Reference to the MaterialPropertyBlock used to supply all created Rocknode meshes with texture data without unnecessary GC allocations on each Rocknode parse.

Shader Id of the main texture.

Parses one RockNode from a custom datastructure passed from the EUDK native plugin and returns a GameObject that contains one child GameObject for each RockMesh in this RockNode. These children each contain one textured RockMesh.

The data container storing the decoded data. The material used for the newly created GameObjects. The meshes array storing the rockmeshes. The octant path as passed from the EUDK native plugin. The enumerator to execute this function asynchronously. TODO(b/38021565): Add support for per vertex octants like in ParseAsyncProto().

Parses one RockNode from a RockProto passed as Stream and returns a GameObject that contains one child GameObject for each RockMesh in this RockNode. These children each contain one textured RockMesh. TODO(mbuhlmann): Current implementation is synchronous, refactor to make asynchronous and then access Unity API from main thread.

Stream containing the RockProto to parse. The data container storing the decoded data. The material used for the generated meshes. The enumerator to execute this function asyncronously.

Creates a GameObject with the parsed meshes from the plugin. Is used by the parse methods to use the parsed data.

String representing the octant path of that RockNode. Array with parsed data from the EUDK native plugin. Structure to fill in the required return values. The default material to be used for the meshes.

Stream containing the RockProto to parse. Double precision matrix transforming from local mesh coordinates to global coordinates. Returns the parsed game object for the provided stream and transformation matrix.

Decodes the vertices as they are encoded in rockproto's NodeData.Mesh.vertices.

The decoded vertices. The encoded vertex bytedata.

Decodes TextureCoordinates as they are encoded in rockproto's NodeData.Mesh.texture_coordinates.

The decoded texture coordinates. The encoded texture coordinate data. Uv offset and scale, as they are stored in NodeData.Mesh.uv_offset_and_scale. Number of vertices to decode texture coordinates for.

Decodes the normal table as it is encoded in rockproto's NodeData.normal_table.

The normal table. The encoded normal table data.

Decodes one normal vector from it's octahedral representation in rockproto's NodeData.normal_table. The 3D normal is encoded in a 2D value. The mapping looks like this: -1,0,0 0,0,1 -1,0,0 1.0 S-------*-------S | /|\ | ^ | / | \ | | | / | \ | | |/ | \| t 0,-1,0 *-------N-------* 0,1,0 | |\ |1,0,0 /| | | \ | / | | | \ | / | | \|/ | 0.0 S-------*-------S -1,0,0 0,0,-1 -1,0,0 0.0 -----s----> 1.0 The point marked N maps to (1,0,0) and could be considered the "north pole" of a unit sphere. The four points marked S all map to (-1,0,0) and could be considered the "south pole" of a unit sphere. The diamond in the middle covers the sphere's northern hemisphere, and the four triangles at the corners together fold under to collectively cover the southern hemisphere.

S in. T in. The map to unit vector.

Decodes the actual per vertex normals as they are stored in NodeData.Mesh.normals.

The per vertex normals. The encoded normal data. The normal table used for the encoding. Number of vertices to decode normals for.

Decodes the layer and octant ranges of a mesh.

the encoded ranges. An ordered List of OctantRanges, with the first OctantRange starting at index 0 and each subsequent OctantRange starting at _RangeEnd+1 of the previous OctantRange.

Decodes the triangles as they are encoded in rockproto's NodeData.Mesh.indices.

The triangles as array of indices. Every three indices make up one triangle. The encoded index data. If set to true skirt triangles will be stripped out. A byte array containing one bit for each triangle, indicating whether the triangle is a skirt. Array holding the octantRanges. The first OctantRange starts at 0, subsequent octantRanges start at _RangeEnd+1 of the previous range. octantMasksOut is an array that will contain the octants of the vertices after this method returns. The array must have a size equal to the number of vertices. This is a Vector2[] rather than a byte[] (each octant is encoded as an OctantMask with the respective bit set. There are 8 octants.) so that it can be directly stored to the uv4 array of the mesh. The x component of this array holds the octants (as respective octantMask bytes directly cast to float).

Parses one index value from the encoded indices and advances the offset and highWaterMark accordingly.

The index value. The bytedata containing the indices. The offset to start reading from. After calling this function, offset will point to the start position of the next index. The current high water mark. Calling this function will update the highWaterMark accordingly.

Parses one encoded VarInt and returns the number of bytes traversed.

The number of bytes traversed. The bytedata containing the VarInt. The offset to start reading from. The VarInt returned. TODO(mbuhlmann): While not relevant for rockproto, VarInt's can actually contain 64bit integer data.

The decode container class holds references to relevant objects for the background thread - unity thread sync.

The node path of the rocknode to decode.

The globe from mesh transformation matrix.

Reference to the of this RockMesh node.

The decode container class holds relevant raw Rich3D protobuffer data for the background thread - unity thread sync.

Holds the indices of the RockMesh provided by the plugin.

Holds the hash of the RockMesh provided by the plugin.

Holds the normals of the RockMesh provided by the plugin.

Holds the texture coordinates of the RockMesh provided by the plugin.

Holds the texture data of the RockMesh provided by the plugin.

Holds the vertices of the RockMesh provided by the plugin.

The x component holds the per vertex octants of the RockMesh provided by the plugin. The y component is unused currently. The float value is directly cast from the byte representing the octant mask that has only this vertex's octant bit set. We use a Vector2[] here instead of a float[] to be able to assign it to uv4 of the Unity Mesh.

Holds the width of the texture.

Holds the height of the texture.

Holds the texture format of the texture stored in _TextureData.

Stores range of indices covering a single octant within a layer.

The end of this OctantRange.

The layer of this OctantRange.

The octant of this OctantRange (a value between 0 and 7).

Used for EUDK wide analytics.

The Google Analytics third party MonoBehavior.

Initializes the analytics service by adding a hidden GameObject to scene with a GoogleAnalyticsV4 MonoBehavior.

Logs an event to the analytics backend.

CoreService provides functionality to be informed about relevant Unity events without the overhead of implementing the corresponding invoke functions or being a UnityEngine.MonoBehaviour.

MonoBehaviour host object used by the core service to receive Unity lifecycle events and execute coroutines if necessary.

Called by EUDKPlugin to inform all subscribers of OnUpdate that Unity Update took place.

Called by EUDKPlugin to inform all subscribers of OnUpdate that Unity LateUpdate took place.

Called by EUDKPlugin to inform all subscribers of OnUpdate that Unity FixedUpdate took place.

Sets the core service up.

Cleans up the service and unregisters all event subscribers.

Event to which Earth Unity Development Kit plugin classes can subscribe to be informed about Unity's Update call without adding the overhead of the native - .NET invoke.

Event to which Earth Unity Development Kit plugin classes can subscribe to be informed about Unity's LateUpdate call without adding the overhead of the native - .NET invoke.

Event to which Earth Unity Development Kit plugin classes can subscribe to be informed about Unity's FixedUpdate call without adding the overhead of the native - .NET invoke.

Private MonoBehaviour used exclusively to forward the Unity events to the service.

Called by Unity every frame. Forwards the Update invocation to CoreService.Update.

Called by Unity every frame. Forwards the LateUpdate invocation to CoreService.LateUpdate.

Called by Unity every physics timestep. Forwards the FixedUpdate invocation to CoreService.FixedUpdate.

Provides the world relocation functionality to keep the user and camera within a predefined range around the origin of Unity's canonical cartesian space. This relocation ensures reasonable float accuracy and stability independent of the location of the traversed camera in Earth Globe coordinates.

The camera transform of the GameObject driving the EUDK native plugin's traversal.

Reference to the EUDK native plugin owning this service to interact with it.

The current unityWorldFromGlobe transformation matrix.

The maximum squared offset of _cameraTransform in Unity world units from [0,0,0] until the world is relocated. This value is stored as square to avoid the usage of sqrt for comparision. Default value is 1500 non-squared units.

TODO(mscharer): Find the maximum stable range of physics operations to define this.

Creates a new instance of the relocation service for a given camera.

The EUDKPlugin owning this relocation service. The transform representing the camera in the scene.

Destroys this instance of the RelocationService.

Adds a new Rocknode to the relocation service management.

The transform of the game object we want to manage. The globeFromMesh matrix of this rocknode.

Called at the end of Unity's main loop prior to rendering. Used to calculate if a world relocation is required.

Called to apply a world relocation basing on the _cameraTransform's current state.

Prepares the RelocationService once the the EUDKPlugin is ready.

Event that is fired before the world is relocated.

Internal property to subscribe to the preLocationUpdated event.

Event that is fired when the world is being relocated.

Event that is fired when the world is relocated. The event is called after all _rocknodeRoots have been repositioned but before _cameraTransform is updated.

Internal property to subscribe to the locationUpdated event.

The threshold against which the length of _cameraTransform.position is compared. If it exceeds the threshold, the world is relocated. Default value is 1500 units.

Private class to handle the relocation of rocknodes. Stores the original, untransformed GlobeFromUnityLocal transformation of a rocknode to provide a numerically stable relocation calculation.

The Rocknode's globeFromUnityLocal matrix from which the new relocated Transform is computed during relocation.

The UnityEngine.Transform of the GameObject that will be relocated to retain its world origin relative positioning after relocation.

Called by Unity when the rocknode is enabled.

Called by Unity when the rocknode is disabled.

Called by the RelocationService after the relocation took place. Only called if the rocknode is active.

Ninja jumps between threads.

Yield return it to switch to Unity main thread.

Yield return it to switch to background thread.

Represents an async task.

Runs next iteration.

true for continue, otherwise false.

Cancel the task till next iteration;

A co-routine that waits the task.

The current iterator yield return value.

Gets state of the task.

Gets exception during running.

Running state of a task.

Task has been created, but has not begun.

Task is running.

Task has finished properly.

Task has been cancelled.

Task terminated by errors.

Start a co-routine on a background thread.

Gets a task object with more control on the background thread.

Start a co-routine on a background thread.