Adding ViroKit. Needs AWSCore :(

mobile/ios/ViroKit.framework/Headers/VROSortKey.h

@@ -0,0 +1,109 @@
+//
+//  VROSortKey.hpp
+//  ViroRenderer
+//
+//  Created by Raj Advani on 6/3/16.
+//  Copyright © 2016 Viro Media. All rights reserved.
+//
+
+#ifndef VROSortKey_hpp
+#define VROSortKey_hpp
+
+#include <stdio.h>
+#include <tuple>
+
+/*
+ Sort keys are used to quickly sort geometry elements into optimal batch rendering order,
+ to limit state changes on the GPU. They consist of a large byte[] that can be sorted
+ quickly via memcmp.
+ */
+class VROSortKey {
+    
+public:
+    VROSortKey() {
+        
+    }
+
+    bool operator< (const VROSortKey& r) const {
+        /*
+         The std::tie operation perform the sort for us, in order of increasing important.
+         We generally sort by rendering order and distance to camera, then by batch switching
+         concerns (shader, textures, light, material), and finally by tie-breakers (node, 
+         element index).
+         
+         For hierarchies, note that the distance from camera for all objects in a hierarchy
+         is set to the distance from camera of the parent. This way distance from camera becomes
+         irrelevant within a hierarchy, so that within each hierarchy we can sort by hierarchy
+         depth only. Note we do not sort by hierarchy ID because it is ok to interleave objects
+         of different hierarchies within the render order.
+         */
+        return std::tie(renderingOrder, distanceFromCamera, hierarchyDepth, incoming, shader, textures, lights, material, node, elementIndex) <
+               std::tie(r.renderingOrder, r.distanceFromCamera, r.hierarchyDepth, r.incoming, r.shader, r.textures, r.lights, r.material, r.node, r.elementIndex);
+    }
+            
+    /*
+     Manual rendering order setting is the highest sorting concern.
+     */
+    uint32_t renderingOrder;
+    
+    /*
+     The depth of the node in its hierarchy. This is normally set
+     to zero. If any of the node's parents is set to hierarchical 
+     rendering, then this is set to the node's depth in the hierarchy,
+     with 0 being the depth of the first hierarhical parent, 1 being
+     the depth after, etc.
+     
+     This ensures that when a hierarchial node is rendered, all 
+     of its children will be rendered immediately after by order of 
+     their depth.
+     */
+    uint32_t hierarchyDepth;
+    
+    /*
+     The ID of the hierarchy this node resides in. When comparing two
+     nodes, we only include graph depth in the sort if the two nodes
+     are in the same hierarchy. 0 indicates we are not in a hierarchy.
+     */
+    uint32_t hierarchyId;
+    
+    /*
+     Distance fom camera for objects is next (back to front).
+     This value is set to (zFar - distance from the camera).
+     
+     When sorted, this results in back to front rendering of
+     objects, ensuring correct rendering of translucent objects.
+     */
+    float distanceFromCamera;
+
+    /*
+     If a material is incoming (i.e. geometry transitioning in to
+     a new material as a result of an animation), we render it after
+     its outgoing counterpart. The incoming material renders
+     second (on top), as its alpha moves from 0 to 1.
+    */
+    bool incoming;
+    
+    /*
+     State-change minimization concerns.
+     */
+    uint32_t shader;
+    uint32_t textures;
+    uint32_t lights;
+    uint32_t material;
+    
+    //// 24 bytes to this point. Keep uintptr_t at an 8 byte boundary to avoid waste ////
+    
+    /*
+     Tie-breakers, double as pointers to the node and
+     index of the geometry element.
+     */
+    uintptr_t node;
+    uint32_t elementIndex;
+    
+};
+
+// Uncomment to see a compiler error indicating the size of each VROSortKey
+// template<int s> struct SortKeySize;
+// SortKeySize<sizeof(VROSortKey)> sortKeySize;
+
+#endif /* VROSortKey_hpp */