@reactvision/react-viro 2.41.3

package/ios/dist/ViroRenderer/x86_64/ViroKit.framework/Headers/VROPolyline.h

@@ -0,0 +1,126 @@
+//
+//  VROPolyline.h
+//  ViroRenderer
+//
+//  Created by Raj Advani on 10/12/16.
+//  Copyright © 2016 Viro Media. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+//  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#include <memory>
+#include <vector>
+#include "VROGeometry.h"
+#include "VROAnimatable.h"
+
+class VROVector3f;
+class VROByteBuffer;
+class VROLineSegment;
+class VROShaderModifier;
+
+/*
+ The style used to join segments. Round uses more triangles but generally looks better
+ for all shapes. Bevel means corners are clipped off, and is used for performance
+ reasons.
+ */
+enum class VROPolylineJoinStyle {
+    Round,
+    Bevel,
+};
+
+class VROPolyline : public VROGeometry {
+    
+public:
+    static std::shared_ptr<VROPolyline> createPolyline(std::vector<std::vector<VROVector3f>> &path, float thickness,
+                                                       VROPolylineJoinStyle joinStyle = VROPolylineJoinStyle::Round);
+    static std::shared_ptr<VROPolyline> createPolyline(std::vector<VROVector3f> &path, float thickness,
+                                                       VROPolylineJoinStyle joinStyle = VROPolylineJoinStyle::Round);
+    
+    VROPolyline();
+    virtual ~VROPolyline() {}
+    
+    /*
+     Set the thickness. Animatable.
+     */
+    void setThickness(float thickness);
+    float getThickness() const {
+        return _thickness;
+    }
+    
+    /*
+     Set the join style, which determines how segments in the polyline are connected
+     together.
+     */
+    void setJoinStyle(VROPolylineJoinStyle joinStyle);
+    VROPolylineJoinStyle getJoinStyle() const {
+        return _joinStyle;
+    }
+    
+    /*
+     Set the paths of this polyline. Each path is a contiguous line. This will reconstruct
+     all paths.
+     */
+    void setPaths(std::vector<std::vector<VROVector3f>> &paths);
+    
+    /*
+     Append the given point the last path in this polyline. This is more efficient
+     than invoking setPaths.
+     */
+    void appendPoint(VROVector3f point);
+
+    virtual void setMaterials(std::vector<std::shared_ptr<VROMaterial>> materials);
+
+private:
+    
+    float _thickness;
+    std::vector<std::vector<VROVector3f>> _paths;
+    VROPolylineJoinStyle _joinStyle;
+    
+    VROPolyline(std::vector<std::vector<VROVector3f>> paths, float thickness, VROPolylineJoinStyle joinStyle);
+    
+    /*
+     Update the underlying geometry using the latest instance variables.
+     */
+    void update();
+    
+    /*
+     Return true if there are no paths in this polyline.
+     */
+    bool isEmpty() const;
+    
+    /*
+     Get the last point in the polyline.
+     */
+    VROVector3f getLastPoint() const;
+    
+    static void buildGeometry(std::vector<std::vector<VROVector3f>> &paths,
+                              VROPolylineJoinStyle joinStyle,
+                              std::vector<std::shared_ptr<VROGeometrySource>> &sources,
+                              std::vector<std::shared_ptr<VROGeometryElement>> &elements);
+    static std::shared_ptr<VROGeometryElement> buildElement(size_t numCorners);
+    static size_t encodeLine(const std::vector<VROVector3f> &path, VROPolylineJoinStyle joinStyle, VROByteBuffer &outBuffer);
+    static size_t encodeQuad(VROLineSegment segment, bool beginDegenerate, bool endDegenerate, VROByteBuffer &buffer);
+    static size_t encodeCircularEndcap(VROVector3f center, VROVector3f direction,
+                                       bool beginDegenerate, bool endDegenerate, VROByteBuffer &buffer);
+
+    static void writeCorner(VROVector3f position, VROVector3f direction, VROByteBuffer &buffer);
+    static void writeEndcapCorner(VROVector3f position, VROVector3f direction, float rotation, VROByteBuffer &buffer);
+    static void createPolylineShaderModifiers();
+    
+};

package/ios/dist/ViroRenderer/x86_64/ViroKit.framework/Headers/VROPortal.h

@@ -0,0 +1,319 @@
+//
+//  VROPortal.h
+//  ViroKit
+//
+//  Created by Raj Advani on 7/31/17.
+//  Copyright © 2017 Viro Media. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+//  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef VROPortal_h
+#define VROPortal_h
+
+#include "VRONode.h"
+#include "VROTree.h"
+#include "VROLineSegment.h"
+#include "VROPortalDelegate.h"
+
+class VROPortalFrame;
+
+/*
+ Portals are nodes that partition subgraphs of the overall scene
+ graph. They are used to simulate "teleportation" between two
+ different scenes, and can also be used for more efficient visibility
+ determination.
+ */
+class VROPortal : public VRONode {
+public:
+    
+    VROPortal();
+    virtual ~VROPortal();
+    
+    /*
+     Delete any rendering resources. Invoked prior to destruction, on the
+     rendering thread.
+     
+     Recurses down the tree.
+     */
+    void deleteGL();
+    
+    /*
+     Render this portal's background.
+     */
+    void renderBackground(const VRORenderContext &context, std::shared_ptr<VRODriver> &driver);
+    
+    /*
+     Render this portal's geometry.
+     */
+    void renderPortal(const VRORenderContext &context, std::shared_ptr<VRODriver> &driver);
+    
+    /*
+     Render this portal's silhouette. The geometry is rendered using the provided material. This
+     method is typically used to render into the stencil or depth buffers only.
+     */
+    void renderPortalSilhouette(std::shared_ptr<VROMaterial> &material,
+                                VROSilhouetteMode mode, std::function<bool(const VRONode &)> filter,
+                                const VRORenderContext &context, std::shared_ptr<VRODriver> &driver);
+    
+    /*
+     Render the visible nodes in this portal's graph, in an order determined by the
+     latest computed sort keys.
+     */
+    void renderContents(const VRORenderContext &context, std::shared_ptr<VRODriver> &driver);
+    
+    /*
+     Iterate up and down the scene graph, starting at the active portal.
+     Fill in the recursion level of each portal (defined as steps to
+     reach from the active portal), and return a graph of all portals reached.
+     
+     This is the recursive helper for VROScene::sortPortalsByDistance().
+     
+     The frame number if used as a 'visited' flag, as this function searches
+     both up and down the graph and is expected to only be invoked once
+     per frame as part of the render-cycle.
+     
+     The activeFrame node is used to assign an entrance frame geometry to this
+     portal. See the discussion under _activePortalFrame for more detail.
+     */
+    void traversePortals(int frame, int recursionLevel,
+                         std::shared_ptr<VROPortalFrame> activeFrame,
+                         tree<std::shared_ptr<VROPortal>> *outPortals);
+    
+    /*
+     Sort the visible nodes in this portal's sub-graph by their sort-keys, and fill
+     the internal _keys vector with the results.
+     */
+    void sortNodesBySortKeys();
+    
+    /*
+     Represents how how many levels deep this portal is: for example, the active portal
+     is 0, a portal within the active portal is 1, a portal within a portal within a portal
+     is 2, and so on.
+     
+     Note this is *always* relative to the active portal.
+     */
+    int getRecursionLevel() const {
+        return _recursionLevel;
+    }
+    
+    /*
+     Set the node (with geometry) to render for the entrance to this portal. This
+     geometry will double as the 'exit' back to this portal from children.
+     */
+    void setPortalEntrance(std::shared_ptr<VROPortalFrame> entrance);
+    const std::shared_ptr<VROPortalFrame> getPortalEntrance() {
+        return _portalEntrance;
+    }
+    
+    /*
+     Return the portal frame being rendered for this portal; either an exit or an
+     entrance.
+     */
+    const std::shared_ptr<VROPortalFrame> getActivePortalFrame() const {
+        return _activePortalFrame;
+    }
+    
+    /*
+      Return portalDelegate if it exists.
+     */
+    std::shared_ptr<VROPortalDelegate> getPortalDelegate() {
+        if (_portalDelegate.expired()){
+            return nullptr;
+        }
+        return _portalDelegate.lock();
+    }
+    
+    void setPortalDelegate(std::shared_ptr<VROPortalDelegate> delegate) {
+        _portalDelegate = delegate;
+    }
+    
+    /*
+     Return true if the portal frame rendered by this portal is an exit into
+     a parent portal, as opposed to this portal's own 'entrance' portal.
+     */
+    bool isRenderingExitFrame() const {
+        return _activePortalFrame != _portalEntrance;
+    }
+    
+    /*
+     If a portal is passable then it reprsents an entry-point into another navigable world,
+     meaning it can be set as the active portal. Non-passable portals can be AR elements overlaid
+     on the real world like picture frames, that are meant to be viewed from outside only.
+     */
+    void setPassable(bool passable) {
+        _passable = passable;
+    }
+    bool isPassable() const {
+        return _passable;
+    }
+    
+    /*
+     Return true if the given line segment intersects the portal geometry.
+     */
+    bool intersectsLineSegment(VROLineSegment segment) const;
+    
+#pragma mark - Environment Lighting
+    
+    /*
+     Set the lighting environment map for this portal.
+     */
+    void setLightingEnvironment(std::shared_ptr<VROTexture> texture);
+    
+    /*
+     Get the lighting environment map for this portal.
+     */
+    std::shared_ptr<VROTexture> getLightingEnvironment() const;
+    
+#pragma mark - Backgrounds
+    
+    /*
+     Note: the scene renders all backgrounds in its tree before rendering
+     any content.
+     */
+    
+    /*
+     Set the background to a cube-map defined by the given cube texture or
+     color.
+     */
+    void setBackgroundCube(std::shared_ptr<VROTexture> textureCube);
+    void setBackgroundCube(VROVector4f color);
+    
+    /*
+     Set the background to a textured sphere.
+     */
+    void setBackgroundSphere(std::shared_ptr<VROTexture> textureSphere);
+    
+    /*
+     Set the background to an arbitrary geometry. All this guarantees is that
+     the given object will be rendered first. No properties will be set on
+     this geometry, but typically background geometries are screen-space, and
+     do not read or write to the depth buffer.
+     */
+    void setBackground(std::shared_ptr<VROGeometry> geometry);
+    
+    /*
+     Set an arbitrary transform to apply to the background. The transform
+     may also be set as a quaternion (rotation).
+     */
+    void setBackgroundTransform(VROMatrix4f transform);
+    void setBackgroundRotation(VROQuaternion rotation);
+    
+    std::shared_ptr<VROGeometry> getBackground() const {
+        return _background;
+    }
+    void removeBackground();
+    
+private:
+    
+    /*
+     The number of steps to reach this portal from the active portal.
+     */
+    int _recursionLevel;
+    
+    /*
+     The nodes in this portal's scene-graph, ordered for rendering by their
+     sort keys.
+     */
+    std::vector<VROSortKey> _keys;
+    
+    /*
+     True if this portal can be entered; e.g, if it can be made into an
+     active portal.
+     */
+    bool _passable;
+    
+    /*
+     Portals have an entrance node that strictly defines the *geometry*
+     (the frame, or window) that delineates the entrance into, or exit from,
+     the portal.
+     */
+    std::shared_ptr<VROPortalFrame> _portalEntrance;
+    
+    /*
+     The _activePortalFrame is the frame this portal should render as its
+     entrance.
+     
+     When moving down the portal tree, this is set to the portal's own
+     entrance: _portalEntrance. However, when moving up the tree, this is
+     set to the active child portal's entrance.
+     
+     For example, if we have the following portal tree:
+     
+         A
+       B   E
+     C   D
+     
+     If A is the active portal, then B would render its own entrance (as an
+     entrance from A into B), C would render its own entrance (as an entrance
+     from B into C) and so on for every portal in the tree.
+     
+     However, if D is the active portal, then B will render D's entrance (as
+     an exit from D into B), B will render A's entrance (as an exit from B into
+     A), and the remaining portals (C and E) would simply render their own
+     entrances.
+     
+     These portals frames are assigned during traversePortals.
+     */
+    std::shared_ptr<VROPortalFrame> _activePortalFrame;
+    
+    /*
+     The background visual to display. All backgrounds in the scene are rendered before
+     node content.
+     */
+    std::shared_ptr<VROGeometry> _background;
+    
+    /*
+     The lighting environment for this portal. Determines the effect of image-based
+     lighting (IBL) for objects using the physically based lighting model.
+     */
+    std::shared_ptr<VROTexture> _lightingEnvironment;
+    
+    /*
+      Portal delegate that is invoked when a portal is entered and exited.
+     */
+    std::weak_ptr<VROPortalDelegate> _portalDelegate;
+    
+    /*
+     Transform to apply to the background geometry.
+     */
+    VROMatrix4f _backgroundTransform;
+    
+    /*
+     Installs required shader modifiers on the background.
+     */
+    void installBackgroundShaderModifier();
+    
+    /*
+     Deactivates culling on every geometry in the given node, recursively down the
+     tree. Needed to ensure culling is off on portal frames.
+     */
+    void deactivateCulling(std::shared_ptr<VRONode> node);
+
+    /*
+     Write the hierarchy parent represented by the given sort key to the depth buffer
+     (only).
+     */
+    void writeHierarchyParentToDepthBuffer(VROSortKey &hierarchyParent,
+                                           const VRORenderContext &context,
+                                           std::shared_ptr<VRODriver> &driver);
+    
+};
+
+#endif /* VROPortal_h */

package/ios/dist/ViroRenderer/x86_64/ViroKit.framework/Headers/VROPortalDelegate.h

@@ -0,0 +1,45 @@
+//
+//  VROPortalDelegate.hpp
+//  ViroRenderer
+//
+//  Created by Vik Advani on 9/14/17.
+//  Copyright © 2017 Viro Media. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+//  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef VROPortalDelegate_h
+#define VROPortalDelegate_h
+
+#include <memory>
+#include <vector>
+#include "VROVector3f.h"
+#include "VROTime.h"
+
+/*
+ Delegate that is attached to a node for notifying the bridge regarding transformation updates.
+ */
+class VROPortalDelegate {
+public:
+    VROPortalDelegate() {}
+    virtual ~VROPortalDelegate() {}
+    virtual void onPortalEnter()=0;
+    virtual void onPortalExit()=0;
+};
+#endif

package/ios/dist/ViroRenderer/x86_64/ViroKit.framework/Headers/VROPortalDelegateiOS.h

@@ -0,0 +1,69 @@
+//
+//  VROPortalDelegateiOS.h
+//  ViroKit
+//
+//  Created by Vik Advani on 9/14/17.
+//  Copyright © 2017 Viro Media. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+//  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef VROPortalDelegateiOS_h
+#define VROPortalDelegateiOS_h
+#import "VROPortalDelegate.h"
+#import <Foundation/Foundation.h>
+
+/*
+ Protocol to be implemented by objective C controls to be
+ set on VROEventDelegateiOS for the notification of
+ input events.
+ */
+@protocol VROPortalDelegateProtocol<NSObject>
+@required
+- (void)onPortalEnter;
+- (void)onPortalExit;
+@end
+
+
+/*
+ iOS implementation of VROEventDelegate for the notification
+ of delegate events across the bridge.
+ */
+class VROPortalDelegateiOS : public VROPortalDelegate  {
+public:
+    VROPortalDelegateiOS(id<VROPortalDelegateProtocol> delegate) :
+    _delegate(delegate) {}
+    virtual ~VROPortalDelegateiOS() {}
+    
+    /*
+     Delegate events triggered by the EventManager.
+     */
+    virtual void onPortalEnter() {
+        [_delegate onPortalEnter];
+    }
+    virtual void onPortalExit() {
+        [_delegate onPortalExit];
+    }
+    
+private:
+    __weak id<VROPortalDelegateProtocol> _delegate;
+    
+};
+
+#endif /* VROPortalDelegateiOS_h */

package/ios/dist/ViroRenderer/x86_64/ViroKit.framework/Headers/VROPortalFrame.h

@@ -0,0 +1,121 @@
+//
+//  VROPortalFrame.h
+//  ViroKit
+//
+//  Created by Raj Advani on 8/5/17.
+//  Copyright © 2017 Viro Media. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included
+//  in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+//  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+//  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef VROPortalFrame_h
+#define VROPortalFrame_h
+
+#include "VRONode.h"
+
+class VROShaderModifier;
+class VROLineSegment;
+enum class VROFace;
+
+/*
+ Portal frames are nodes that contain the geometry representing the
+ entrance (or exit) from the portal. We need these for two reasons:
+ 
+ 1. They enable us to manipulate the scale and other transformations
+    of the portal's entrance without changing the transform of the entire
+    VROPortal.
+ 
+ 2. VROPortals need their frames dynamically assigned each frame if the
+    active portal changes, in order to render entrances where necessary
+    and exits where necessary.
+ */
+class VROPortalFrame : public VRONode {
+public:
+    
+    /*
+     Return the shader modifier that is used to render a portal frame to the
+     stencil buffer. This modifier discards the non-transparent sections of the
+     portal frame, so that only the 'window' gets rendered to the stencil
+     buffer.
+     */
+    static std::shared_ptr<VROShaderModifier> getAlphaDiscardModifier();
+    
+    VROPortalFrame();
+    virtual ~VROPortalFrame();
+    
+    /*
+     If this portal frame is two-sided then this returns the stencil face
+     that we should render to the stencil buffer. The other face (the inactive)
+     face, will not render to the stencil buffer.
+     
+     Example:
+     
+     A --- P --- B
+     
+     Suppose A and B are two portals separated by portal frame P. Suppose P is
+     the 'entrance' to B. Our goal is to have the front face of P display B, and
+     the back face display A.
+     
+     Therefore, if we're "in" portal B, we should render the stencil to the back
+     faces of B, and if we're "in" portal A, we should render the stencil to the
+     front faces of B. This works because when we don't write to the stencil, we
+     simply render the world we're in; so in the former case the front of P will
+     render B, and the latter case the back of P will render A.
+     */
+    VROFace getActiveFace(bool isExit) const;
+    VROFace getInactiveFace(bool isExit) const;
+    
+    /*
+     Return true if this portal frame is two-sided. See _twoSided below for
+     discussion.
+     */
+    bool isTwoSided() const {
+        return _twoSided;
+    }
+    void setTwoSided(bool twoSided) {
+        _twoSided = twoSided;
+    }
+    
+    /*
+     Returns true if this frame intersects the given line segment.
+     */
+    bool intersectsLineSegment(VROLineSegment segment) const;
+    
+private:
+    
+    /*
+     Normally, both sides of a portal frame are windows into the same scene. So if
+     you are in an AR world and you're looking through a portal into a VR world,
+     you can walk around the portal and see the VR world from both sides of the
+     portal.
+     
+     However, it's also useful to sometimes have 2-sided portals: that is,
+     a portal which on one side shows the VR world and on the other side the AR
+     world. This is particularly useful when we're about to pass through a portal.
+     In such cases, we want the portal to show different worlds on each side in
+     order to prevent flickering.
+     
+     Two-sided portals are enabled under the hood by using the front/back stencil
+     buffer operations.
+     */
+    bool _twoSided;
+    
+};
+
+#endif /* VROPortalFrame_h */