Adding ViroKit. Needs AWSCore :(

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

@@ -0,0 +1,192 @@
+//
+//  VRODriver.h
+//  ViroRenderer
+//
+//  Created by Raj Advani on 4/21/16.
+//  Copyright © 2016 Viro Media. All rights reserved.
+//
+
+#ifndef VRODriver_h
+#define VRODriver_h
+
+#include <vector>
+#include "VRODefines.h"
+#include "VROSoundData.h"
+
+class VROGeometry;
+class VROMaterial;
+class VROGeometrySubstrate;
+class VROMaterialSubstrate;
+class VROTextureSubstrate;
+class VROData;
+class VROImage;
+class VROVideoTextureCache;
+class VROSound;
+class VROAudioPlayer;
+class VROTypeface;
+class VROFrameTimer;
+class VRORenderTarget;
+class VRORenderContext;
+class VROShaderProgram;
+class VROImagePostProcess;
+
+enum class VROSoundType;
+enum class VROTextureType;
+enum class VROTextureFormat;
+enum class VROTextureInternalFormat;
+enum class VROWrapMode;
+enum class VROFilterMode;
+enum class VROMipmapMode;
+enum class VRORenderTargetType;
+enum class VROFace;
+enum class VROCullMode;
+enum class VROBlendMode;
+enum class VROResourceType;
+
+/*
+ The type of the GPU can be used to modify rendering for compatibility with older
+ GPUs, or it can be used to gate access to advanced rendering features that only
+ work with some subset of GPUs.
+ */
+enum class VROGPUType {
+    /*
+     Covers properly functioning GPUs.
+     */
+    Normal,
+
+    /*
+     This type is used for GPUs that supposedly support OpenGL 3.0 but can't handle
+     simple 3D graphics without serious errors. This is primarily used for the Adreno 330
+     and earlier, which have issues with structs in GLSL programs. The inclusion of structs can
+     cause textures to corrupt (EGL textures gain a purple tint), and shaders to sporadically fail
+     compilation.
+
+     Since these GPUs are generally legacy and can't support AR and VR, instead of writing
+     an entirely new set of shaders to support them, we instead force these GPUs to always
+     use a simple constant shader, and modify the expand the Surface struct into separate
+     variables.
+     */
+    Adreno330OrOlder,
+};
+
+/*
+ The color mode used when rendering.
+
+ NonLinear: textures are sampled in RGB (gamma-corrected) space, shader operations
+            are performed in this non-linear space, and rendered straight to the frame
+            buffer without conversion. In other words, inputs are gamma corrected and
+            output is gamma corrected. Less color accuracy.
+
+ Linear:    textures are sampled as sRGB, meaning they are converted to a linear
+            colorspace by the underlying hardware. Colors remain in linear color space
+            until the *final* framebuffer render, at which point they are gamma
+            corrected by the hardware (by rendering into an sRGB-configured framebuffer)
+
+ LinearSoftware: textures are sampled as sRGB, as with Linear, but the final framebuffer
+                 is gamma-corrected via shader code. This is typically used in situations
+                 where we are unable to allocate an sRGB framebuffer for the final render.
+ */
+enum class VROColorRenderingMode {
+    NonLinear,
+    Linear,
+    LinearSoftware,
+};
+
+/*
+ The driver is used to interface with the rendering subsystem (OpenGL,
+ Metal, etc.).
+ */
+class VRODriver {
+    
+public:
+    
+    virtual ~VRODriver() {}
+    
+    /*
+     Provides the driver an opportunity to update any sub-components
+     with per-frame state. The willRenderFrame method is invoked just
+     prior to rendering, and didRenderFrame is invoked afterward. The
+     VROFrameTimer can be used by the driver to timebox its tasks so
+     as not to overrun frame time.
+     */
+    virtual void willRenderFrame(const VRORenderContext &context) = 0;
+    virtual void didRenderFrame(const VROFrameTimer &timer, const VRORenderContext &context) = 0;
+    
+    /*
+     Invoked when the renderer is paused and resumed.
+     */
+    virtual void pause() = 0;
+    virtual void resume() = 0;
+
+    /*
+     Read the GPU type, which may be necessary to support old GPUs that are not to
+     specification, or to control whether or not to use advanced features only supported
+     by a subset of GPUs.
+     */
+    virtual void readGPUType() = 0;
+
+    /*
+     Get the GPU type, after it has been read by the system.
+     */
+    virtual VROGPUType getGPUType() = 0;
+    
+    /*
+     Read the ID of the display's framebuffer. May not be required on all
+     platforms. This way we're able to re-bind to the display during a multi-pass
+     alogrithm.
+     */
+    virtual void readDisplayFramebuffer() = 0;
+    
+    /*
+     The driver controls context-wide state change. The implementation
+     should store a CPU copy of current state to avoid sending unnecessary
+     instructions to the GPU.
+     */
+    virtual void setDepthWritingEnabled(bool enabled) = 0;
+    virtual void setDepthReadingEnabled(bool enabled) = 0;
+    virtual void setStencilTestEnabled(bool enabled) = 0;
+    virtual void setCullMode(VROCullMode cullMode) = 0;
+    virtual void setColorWritingEnabled(bool enabled) = 0;
+    virtual void bindShader(std::shared_ptr<VROShaderProgram> program) = 0;
+    virtual void unbindShader() = 0;
+    virtual void bindRenderTarget(std::shared_ptr<VRORenderTarget> target) = 0;
+    virtual void unbindRenderTarget() = 0;
+    
+    /*
+     Indicates how we handle linear rendering and gamma-correction for this device
+     and platform. Features like HDR are only enabled in linear space.
+     */
+    virtual VROColorRenderingMode getColorRenderingMode() = 0;
+    
+    /*
+     Return true if bloom rendering is enabled. If so, materials that exceed their
+     bloom threshold will glow.
+     */
+    virtual bool isBloomSupported() = 0;
+    
+    virtual VROGeometrySubstrate *newGeometrySubstrate(const VROGeometry &geometry) = 0;
+    virtual VROMaterialSubstrate *newMaterialSubstrate(VROMaterial &material) = 0;
+    virtual VROTextureSubstrate *newTextureSubstrate(VROTextureType type,
+                                                     VROTextureFormat format,
+                                                     VROTextureInternalFormat internalFormat, bool sRGB,
+                                                     VROMipmapMode mipmapMode,
+                                                     std::vector<std::shared_ptr<VROData>> &data,
+                                                     int width, int height, std::vector<uint32_t> mipSizes,
+                                                     VROWrapMode wrapS, VROWrapMode wrapT,
+                                                     VROFilterMode minFilter, VROFilterMode magFilter, VROFilterMode mipFilter) = 0;
+    virtual std::shared_ptr<VRORenderTarget> newRenderTarget(VRORenderTargetType type, int numAttachments, int numImages,
+                                                             bool enableMipmaps) = 0;
+    virtual std::shared_ptr<VRORenderTarget> getDisplay() = 0;
+    virtual std::shared_ptr<VROImagePostProcess> newImagePostProcess(std::shared_ptr<VROShaderProgram> shader) = 0;
+    virtual std::shared_ptr<VROVideoTextureCache> newVideoTextureCache() = 0;
+    virtual std::shared_ptr<VROSound> newSound(std::shared_ptr<VROSoundData> data, VROSoundType type) = 0;
+    virtual std::shared_ptr<VROSound> newSound(std::string resource, VROResourceType resourceType, VROSoundType type) = 0;
+    virtual std::shared_ptr<VROAudioPlayer> newAudioPlayer(std::shared_ptr<VROSoundData> data) = 0;
+    virtual std::shared_ptr<VROAudioPlayer> newAudioPlayer(std::string path, bool isLocal) = 0;
+    virtual std::shared_ptr<VROTypeface> newTypeface(std::string typeface, int size) = 0;
+    virtual void setSoundRoom(float sizeX, float sizeY, float sizeZ, std::string wallMaterial,
+                              std::string ceilingMaterial, std::string floorMaterial) = 0;
+    virtual void setBlendingMode(VROBlendMode mode) = 0;
+};
+
+#endif /* VRODriver_hpp */