@reactvision/react-viro 2.41.3

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/VROFrustumBoxIntersectionMetadata.h

@@ -0,0 +1,64 @@
+//
+//  VROFrustumBoxIntersectionMetadata.hpp
+//  ViroRenderer
+//
+//  Created by Raj Advani on 4/17/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 VROFrustumBoxIntersectionMetadata_h
+#define VROFrustumBoxIntersectionMetadata_h
+
+#include <math.h>
+#include <stdint.h>
+
+class VROFrustum;
+
+/*
+ Stores metadata about the intersection between a given VROFrustum
+ and VROBoundingBox, which can be utilized to accelerate intersection
+ computations between the same frustum and box in subsequent 
+ frames.
+ */
+class VROFrustumBoxIntersectionMetadata {
+    
+public:
+    
+    VROFrustumBoxIntersectionMetadata();
+    ~VROFrustumBoxIntersectionMetadata();
+    
+    uint8_t getPlaneLastOutside() const {
+        return _planeLastOutside;
+    }
+    void setPlaneLastOutside(uint8_t plane) {
+        _planeLastOutside = plane;
+    }
+    
+private:
+    
+    /*
+     The plane of the frustum the bounding-box was last outside.
+     */
+    uint8_t _planeLastOutside;
+    
+};
+
+#endif /* VROFrustumBoxIntersectionMetadata_h */

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/VROFrustumPlane.h

@@ -0,0 +1,54 @@
+//
+//  VROFrustumPlane.h
+//  ViroRenderer
+//
+//  Created by Raj Advani on 10/15/15.
+//  Copyright © 2015 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 VROFRUSTUMPLANE_H_
+#define VROFRUSTUMPLANE_H_
+
+#include "VROPlane.h"
+#include "VROBoundingBox.h"
+
+typedef enum {
+    VROFarPointPosX = 0,
+    VROFarPointPosY = 1,
+    VROFarPointPosZ = 2,
+    VROFarPointNegX = 3,
+    VROFarPointNegY = 4,
+    VROFarPointNegZ = 5
+} VROFarPoint;
+
+class VROFrustumPlane : public VROPlane {
+public:
+    
+    VROBoxPlane farPoints[6];
+
+    VROFrustumPlane();
+    virtual ~VROFrustumPlane();
+
+    void refreshFarPoints();
+
+};
+
+#endif /* VROFRUSTUMPLANE_H_ */

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/VROGLTFLoader.h

@@ -0,0 +1,237 @@
+//
+//  VROGLTFLoader.h
+//  ViroRenderer
+//
+//  Copyright © 2018 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 VROGLTFLoader_h
+#define VROGLTFLoader_h
+
+#include <vector>
+#include <string>
+#include <memory>
+#include <map>
+#include <functional>
+#include <set>
+#include "VROGeometrySource.h"
+#include "VROGeometryElement.h"
+#include "VROMaterial.h"
+#include "VROModelIOUtil.h"
+#include "VROByteBuffer.h"
+
+class VROMorpher;
+class VRONode;
+class VROVertexBuffer;
+class VROTexture;
+class VROGeometry;
+class VROSkinner;
+class VROSkeleton;
+class VROTaskQueue;
+class VROSkeletalAnimation;
+class VROKeyframeAnimation;
+class VROKeyframeAnimationFrame;
+
+namespace tinygltf {
+    class Model;
+    class Scene;
+    class Accessor;
+    class Mesh;
+    class Material;
+    class Texture;
+    class Parameter;
+    class Primitive;
+    class Skin;
+    class Animation;
+    class AnimationSampler;
+    class Buffer;
+    class BufferView;
+}
+
+/*
+ Enum representing the format of the data stored within the buffers of a GLTF model.
+ Each GLTFType is associated with a value that represents the number of
+ GLTFTypeComponent contained within this GTLFType. For example, GLTFType::VEC3 has 3
+ GLTFTypeComponent components.
+ */
+enum class GLTFType {
+    Scalar,
+    Vec2,
+    Vec3,
+    Vec4,
+    Mat2,
+    Mat3,
+    Mat4
+};
+
+/*
+ Enum representing the byte size of a single GLTFTypeComponent contained within a GLTFType.
+ */
+enum class GLTFTypeComponent {
+    Byte,
+    UnsignedByte,
+    Short,
+    UnsignedShort,
+    UnsignedInt,
+    Float
+};
+
+/*
+ Handles the loading of a GLTF model that is represented by a given .gltf or .glb file.
+ TinyGltf is used to parse raw GTLF data into a tinygltf::Model format, after which we then
+ use to construct a tree of VRONodes and VROGeometries representing the 3D model.
+ */
+class VROGLTFLoader {
+public:
+    static void loadGLTFFromResource(std::string gltfManifestFilePath,
+                                     const std::map<std::string, std::string> overwriteResourceMap,
+                                     VROResourceType resourceType,
+                                     std::shared_ptr<VRONode> rootNode,
+                                     bool isGLTFBinary,
+                                     std::shared_ptr<VRODriver> driver,
+                                     std::function<void(std::shared_ptr<VRONode> node, bool success)> onFinish = nullptr);
+
+private:
+    // Functions for processing basic components required for constructing a 3D Model in Viro.
+    static bool processScene(const tinygltf::Model &gModel, std::shared_ptr<VRONode> rootNode, const tinygltf::Scene &gScene,
+                             std::shared_ptr<VRODriver> driver);
+    static bool processNode(const tinygltf::Model &gModel, std::shared_ptr<VRONode> &sceneNode, int gNodeIndex,
+                            std::shared_ptr<VRODriver> driver);
+    static bool processMesh(const tinygltf::Model &gModel, std::shared_ptr<VRONode> &node, const tinygltf::Mesh &gMesh,
+                            std::shared_ptr<VRODriver> driver);
+    static bool processSkin(const tinygltf::Model &gModel, std::shared_ptr<VRONode> &node, int skinIndex);
+    static bool processVertexElement(const tinygltf::Model &gModel, const tinygltf::Primitive &gPrimitive,
+                                     std::vector<std::shared_ptr<VROGeometryElement>> &element);
+    static bool processVertexAttributes(const tinygltf::Model &gModel, std::map<std::string, int> &gAttributes,
+                                        std::vector<std::shared_ptr<VROGeometrySource>> &sources,
+                                        size_t geoElementIndex,
+                                        std::shared_ptr<VRODriver> driver);
+    static void processTangent(std::vector<std::shared_ptr<VROGeometryElement>> &elements,
+                               std::vector<std::shared_ptr<VROGeometrySource>> &sources, size_t geoElementIndex);
+    static void regenerateTangent(std::vector<VROVector3f> &posArray,
+                                  std::vector<VROVector3f> &normArray,
+                                  std::vector<VROVector3f> &texCoordArray,
+                                  std::vector<int> &elementIndicesArray,
+                                  std::vector<VROVector4f> &generatedTangents);
+    static bool processMorphTargets(const tinygltf::Model &gModel,
+                                    const tinygltf::Mesh &gMesh,
+                                    const tinygltf::Primitive &gPrimitive,
+                                    std::shared_ptr<VROMaterial> &material,
+                                    std::vector<std::shared_ptr<VROGeometrySource>> &sources,
+                                    std::vector<std::shared_ptr<VROGeometryElement>> &elements,
+                                    std::map<int, std::shared_ptr<VROMorpher>> &morphers,
+                                    std::shared_ptr<VRODriver> driver);
+    static std::string getMorphTargetName(const tinygltf::Model &gModel,
+                                          const tinygltf::Primitive &gPrimtive, int targetIndex);
+
+    static void injectGLTF(std::shared_ptr<VRONode> gltfNode, std::shared_ptr<VRONode> rootNode,
+                           std::shared_ptr<VRODriver> driver, std::function<void(std::shared_ptr<VRONode> node, bool success)> onFinish);
+    
+    static std::shared_ptr<VROGeometrySource> buildGeometrySource(VROGeometrySourceSemantic attributeType,
+                                                                  GLTFType gType,
+                                                                  GLTFTypeComponent gTypeComponent,
+                                                                  const tinygltf::Accessor &gAttributeAccesor,
+                                                                  const tinygltf::BufferView &gIndiceBufferView,
+                                                                  std::shared_ptr<VROVertexBuffer> vbo);
+    static std::shared_ptr<VROGeometrySource> buildBoneWeightSource(GLTFType gType,
+                                                                    GLTFTypeComponent gTypeComponent,
+                                                                    const tinygltf::Accessor &gAttributeAccesor,
+                                                                    const tinygltf::BufferView &gIndiceBufferView,
+                                                                    const tinygltf::Buffer &gbuffer);
+
+    // Processing of GTLF Materials and Textures into VROMaterials and VROTextures
+    static std::shared_ptr<VROMaterial> getMaterial(const tinygltf::Model &gModel, const tinygltf::Material &gMat);
+    static std::shared_ptr<VROTexture> getTexture(const  tinygltf::Model &gModel, std::map<std::string, tinygltf::Parameter> gPropMap,
+                                                  std::string targetedTextureName, bool srgb);
+    static std::shared_ptr<VROTexture> getTexture(const tinygltf::Model &gModel, const tinygltf::Texture &texture, bool srgb);
+    static void processPBR(const tinygltf::Model &gModel, std::shared_ptr<VROMaterial> &texture, const tinygltf::Material &gMat);
+
+    // Conversion of GLTF Semantics to VRO Semantics
+    static bool getPrimitiveType(int mode, VROGeometryPrimitiveType &type);
+    static bool getComponentType(const tinygltf::Accessor &accessor, GLTFTypeComponent &typeComponent);
+    static bool getComponent(const tinygltf::Accessor &accessor, GLTFType &type);
+    static VROGeometrySourceSemantic getGeometryAttribute(std::string attributeName);
+    static VROFilterMode getFilterMode(int mode);
+    static VROWrapMode getWrappingMode(int mode);
+
+    // Processing of Animation Data
+    static bool processAnimations(const tinygltf::Model &gModel);
+    static bool processKeyFrameAnimations(const tinygltf::Model &gModel,
+                                         std::map<int, std::map<int, std::vector<int>>> &gltfAnimatedNodes);
+    static void flattenSkeletalKeyframeAnimations(
+            std::map<int, std::pair<int, std::vector<int>>> &skeletalAnimToNodeSkinPair);
+    static std::shared_ptr<VROKeyframeAnimation> convertChannelToKeyFrameAnimation(
+                                                  const tinygltf::Model &gModel,
+                                                  const tinygltf::Animation &anim,
+                                                  int targetedChannel);
+    static bool processRawChannelData(const tinygltf::Model &gModel,
+                                      std::string channelProperty,
+                                      int channelTarget,
+                                      const tinygltf::AnimationSampler &gChannelSampler,
+                                      std::vector<std::unique_ptr<VROKeyframeAnimationFrame>> &framesOut);
+    static bool processSkeletalAnimation(const tinygltf::Model &gModel,
+                                         std::map<int, std::pair<int, std::vector<int>>> &skeletalAnimToSkinToNodeMap);
+    static bool processSkeletalTransformsForFrame(const tinygltf::Model &gModel,
+                                                  int skin,
+                                                  int animation,
+                                                  int subAnimPropertyIndex,
+                                                  int keyFrameIndex,
+                                                  int currentJointIndex,
+                                                  std::map<int, VROMatrix4f> &transforms);
+    static bool processSkinner(const tinygltf::Model &gModel);
+    static bool processSkinnerInverseBindData(const tinygltf::Model &gModel,
+                                              const tinygltf::Skin &skin,
+                                              std::vector<VROMatrix4f> &invBindTransformsOut);
+    static void clearCachedData();
+
+    /*
+     As multiple mesh attributes may point to the same texture or data arrays when loading a
+     GTLF model, we cache them here during loadGLTFFromResource(), and clear them out after.
+     */
+    static std::map<std::string, std::shared_ptr<VROVertexBuffer>> _dataCache;
+    static std::map<std::string, std::shared_ptr<VROTexture>> _textureCache;
+
+    /*
+     Cached maps of skinner indexes to skeletal data, including both joints and affected node
+     indexes. Note that in gLTF, a node can only have one skeletal root joint. These caches
+     are cleared out after the parsing of a single gLTF model.
+     */
+    static std::map<int, std::shared_ptr<VROSkeleton>> _skinIndexToSkeleton;
+    static std::map<int, std::map<int,int>> _skinIndexToJointNodeIndex;
+    static std::map<int, std::map<int,std::vector<int>>> _skinIndexToJointChildJoints;
+    static std::map<int, std::shared_ptr<VROSkinner>> _skinMap;
+    static std::map<int, int> _skinIndexToSkeletonRootJoint;
+
+    /*
+     Cached maps of nodeIndexes to it's corresponding animations. These caches are cleared
+     out after the parsing of a single gLTF model. Note that _nodeKeyFrameAnims is of the form:
+     <nodeIndex , <animationIndex, VROKeyframeAnimation>>> _nodeKeyframeAnims.
+     */
+    static std::map<int, std::map<int, std::vector<std::shared_ptr<VROKeyframeAnimation>>>> _nodeKeyFrameAnims;
+    static std::map<int, std::vector<std::shared_ptr<VROSkeletalAnimation>>> _skinSkeletalAnims;
+
+    /*
+     Returns the local transform of the node index retried from the gltf model.
+     */
+    static VROMatrix4f getTransformOfNode(const tinygltf::Model &gModel, int nodeIndex);
+};
+
+#endif /* VROGLTFLoader_h */

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/VROGaussianBlurRenderPass.h

@@ -0,0 +1,209 @@
+//
+//  VROGaussianBlurRenderPass.h
+//  ViroKit
+//
+//  Created by Raj Advani on 8/24/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 VROGaussianBlurRenderPass_h
+#define VROGaussianBlurRenderPass_h
+
+#include "VRORenderPass.h"
+#include "VROVector4f.h"
+
+class VRODriver;
+class VROImagePostProcess;
+class VROViewport;
+
+/*
+ Keys for the gaussian render pass.
+ */
+const std::string kGaussianInput = "G_Input";
+const std::string kGaussianPingPong = "G_PP";
+
+/*
+ Implements Gaussian blur for Bloom. Ping-pongs the blur between
+ two render targets.
+ */
+class VROGaussianBlurRenderPass : public VRORenderPass, public std::enable_shared_from_this<VROGaussianBlurRenderPass> {
+public:
+    
+    VROGaussianBlurRenderPass();
+    virtual ~VROGaussianBlurRenderPass();
+
+    void render(std::shared_ptr<VROScene> scene,
+                std::shared_ptr<VROScene> outgoingScene,
+                VRORenderPassInputOutput &inputs,
+                VRORenderContext *context, std::shared_ptr<VRODriver> &driver);
+
+    /*
+     Functions for handling the render targets associated with this Gaussian Blur.
+     */
+    void createRenderTargets(std::shared_ptr<VRODriver> &driver);
+    void resetRenderTargets();
+    void setViewPort(VROViewport viewport, std::shared_ptr<VRODriver> &driver);
+    void setClearColor(VROVector4f color, std::shared_ptr<VRODriver> driver);
+
+    /*
+     The more iterations, the more blur. Must be an even number.
+     */
+    void setNumBlurIterations(int numIterations);
+
+    /*
+     Sets properties for controlling the blur visually.
+     - kernelSize controls the spread of the blur.
+     - sigma controls the blur intensity.
+     - normalized controls the 'consistent look' of the blur.
+     */
+    void setBlurKernel(int kernelSize, float sigma, bool normalized = false);
+    
+    int getKernelSize() const {
+        return _kernelSize;
+    }
+    float getSigma() const {
+        return _sigma;
+    }
+
+    /*
+     Set to True to optimize the blur by reducing the number of texture lookups,
+     done by performing bilinear texture lookups in our kernel offsets. This is
+     enabled by default.
+     */
+    void setBilinearTextureLookup(bool enabled);
+
+    /*
+     Notifies this blurRenderPass of the current background color configuration of the
+     renderer (and more importantly, if there are any semi-transparent pixels).
+     */
+    void setClearColor(VROVector4f color);
+
+    /*
+     A scale factor to reinforce and intensify the rgb values of the input texture before
+     applying the blur.
+     */
+    void setReinforcedIntensity(float intensity) {
+        _reinforcedIntensity = intensity;
+        resetShaders();
+    }
+
+    float getReinforcedIntensity() {
+        return _reinforcedIntensity;
+    }
+    
+private:
+
+    /*
+     Render targets for ping-ponging the blur operation.
+     */
+    std::shared_ptr<VRORenderTarget> _blurTargetA;
+    std::shared_ptr<VRORenderTarget> _blurTargetB;
+
+    /*
+     Sigma controls gaussian "drop-off", and thus the blur intensity. The higher
+     the sigma, the faster the drop-off, decreasing the intensity of the blur.
+     */
+    float _sigma;
+
+    /*
+     KernelSize controls how large the convolution window should be. With larger
+     sizes, more pixels are included in the blur, thus 'spreading' the blur over
+     a wider area.
+     */
+    int _kernelSize;
+
+    /*
+     Set to false if we wish to have a more "feathery" blur. And true if we would
+     like the blur distribution to always be the same, no matter the kernel size.
+     */
+    bool _normalizedKernel;
+
+    /*
+     Set to true to optimize the blur by reducing the number of texture lookups,
+     done by performing bilinear texture lookups in our kernel offsets.
+     */
+    bool _bilinearTextureLookup;
+
+    /*
+     Flag for tracking the current blur state.
+     */
+    bool _horizontal;
+
+    /*
+     The number of times to perform the blur (both horizontal and vertical).
+     */
+    int _numBlurIterations;
+
+    /*
+     True if we are compositing onto a renderer that has transparent pixels.
+     */
+    bool _considerTransparentPixels = true;
+
+    /*
+     A premultiplied intensity ratio applied to the input texture and it's rgb values
+     before bluring.
+     */
+    float _reinforcedIntensity;
+
+    /*
+     The main gaussian blur shader post process program used for blurring the image.
+     */
+    std::shared_ptr<VROImagePostProcess> _gaussianBlur;
+
+    /*
+     Program for pre-processing the image before it is blurred.
+     */
+    std::shared_ptr<VROImagePostProcess> _preBlurPass;
+
+    /*
+     The size of the blur targets relative to the display. Smaller scale leads to
+     less accurate but faster blur.
+     */
+    float _blurScaling;
+
+    /*
+     Initializes and replaces _gaussianBlur and _preBlurPass shaders.
+     */
+    void initPostProcess(std::shared_ptr<VRODriver> driver);
+    void initBlurPass(std::shared_ptr<VRODriver> driver);
+    void initPreBlurPass(std::shared_ptr<VRODriver> driver);
+
+    /*
+     Mathematical helper functions for calculating a kernel that represents a
+     weighted gaussian distribution used for bluring the image.
+     */
+    std::vector<float> calculateKernel(float sigma,
+                                       float kernelSize,
+                                       float sampleCount);
+    float gaussianDistribution(float x,
+                               float mu,
+                               float sigma);
+    float integrateSimphson(std::vector<std::vector<float>> tapSamples);
+    std::vector<std::vector<float>> calculateSamplesForRange(float minInclusive,
+                                                             float maxInclusive,
+                                                             int sampleCount,
+                                                             float sigma);
+    void convertToLinearKernelSample(std::vector<float> &kernelWeights,
+                                     std::vector<float> &kernelOffsets);
+    void resetShaders();
+};
+
+#endif /* VROGaussianBlurRenderPass_h */