Adding ViroKit. Needs AWSCore :(

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

@@ -0,0 +1,421 @@
+//
+//  VROMaterial.h
+//  ViroRenderer
+//
+//  Created by Raj Advani on 11/17/15.
+//  Copyright © 2015 Viro Media. All rights reserved.
+//
+
+#ifndef VROMaterial_h
+#define VROMaterial_h
+
+#include <memory>
+#include "VROMaterialVisual.h"
+#include "VROAnimatable.h"
+#include "VROStringUtil.h"
+
+enum class VROFace {
+    Front,
+    Back,
+    FrontAndBack
+};
+
+enum class VROCullMode {
+    Back,
+    Front,
+    None
+};
+
+enum class VROBlendMode {
+    None,
+    Alpha,
+    Add,
+    Multiply,   // Note: Unimplemented mode
+    Subtract,   // Note: Unimplemented mode
+    Screen,     // Note: Unimplemented mode
+};
+
+enum class VROTransparencyMode {
+    AOne,
+    RGBZero
+};
+
+enum class VROLightingModel {
+    Phong,
+    Blinn,
+    Lambert,
+    Constant,
+    PhysicallyBased
+};
+
+class VROLight;
+class VRODriver;
+class VROSortKey;
+class VROMaterialSubstrate;
+class VROShaderModifier;
+
+/*
+ Manages the lighting and shading attributes associated with the surface of a geometry that
+ define its appearance when rendered. When you create a material, you define a collection of
+ visual attributes and their options, which you can then reuse for multiple geometries 
+ in a scene.
+ */
+class VROMaterial : public VROAnimatable {
+    
+public:
+    
+    VROMaterial();
+    virtual ~VROMaterial();
+    
+    /*
+     Delete any rendering resources. Invoked prior to destruction, on the
+     rendering thread.
+     */
+    void deleteGL();
+    
+    /*
+     Copy constructor for this material. Texture contents use shared references.
+     */
+    VROMaterial(std::shared_ptr<VROMaterial> material);
+    
+    /*
+     Copy function, to write over all properties of this material with the
+     properties of the given material.
+     */
+    void copyFrom(std::shared_ptr<VROMaterial> material);
+    
+    /*
+     Set a name for this material. No functionality, only used for 
+     debugging.
+     */
+    void setName(std::string name) {
+        _name = name;
+    }
+    std::string getName() const {
+        return _name;
+    }
+    
+    uint32_t getMaterialId() const {
+        return _materialId;
+    }
+    
+    /*
+     Bind shader and properties. These must be called in order: material properties
+     cannot be bound until the shader is bound.
+     
+     Lights are passed into bindShader because the shader used by a material
+     is a function both of that material's properties and of the desired lighting
+     configuration.
+     */
+    void bindShader(int lightsHash,
+                    const std::vector<std::shared_ptr<VROLight>> &lights,
+                    const VRORenderContext &context,
+                    std::shared_ptr<VRODriver> &driver);
+    void bindProperties(std::shared_ptr<VRODriver> &driver);
+
+    VROMaterialVisual &getDiffuse() const {
+        return *_diffuse;
+    }
+    VROMaterialVisual &getRoughness() const {
+        return *_roughness;
+    }
+    VROMaterialVisual &getMetalness() const {
+        return *_metalness;
+    }
+    VROMaterialVisual &getSpecular() const {
+        return *_specular;
+    }
+    VROMaterialVisual &getNormal() const {
+        return *_normal;
+    }
+    VROMaterialVisual &getReflective() const {
+        return *_reflective;
+    }
+    VROMaterialVisual &getEmission() const {
+        return *_emission;
+    }
+    VROMaterialVisual &getMultiply() const {
+        return *_multiply;
+    }
+    VROMaterialVisual &getAmbientOcclusion() const {
+        return *_ambientOcclusion;
+    }
+    VROMaterialVisual &getSelfIllumination() const {
+        return *_selfIllumination;
+    }
+    
+    void setShininess(float shininess);
+    float getShininess() const {
+        return _shininess;
+    }
+    
+    void setFresnelExponent(float fresnelExponent);
+    float getFresnelExponent() const {
+        return _fresnelExponent;
+    }
+    
+    void setTransparency(float transparency);
+    float getTransparency() const {
+        return _transparency;
+    }
+    
+    void setTransparencyMode(VROTransparencyMode mode) {
+        _transparencyMode = mode;
+    }
+    VROTransparencyMode getTransparencyMode() const {
+        return _transparencyMode;
+    }
+    
+    void setLightingModel(VROLightingModel model) {
+        _lightingModel = model;
+    }
+    VROLightingModel getLightingModel() const {
+        return _lightingModel;
+    }
+    
+    void setCullMode(VROCullMode cullMode) {
+        _cullMode = cullMode;
+    }
+    VROCullMode getCullMode() const {
+        return _cullMode;
+    }
+    
+    bool isLitPerPixel() const {
+        return _litPerPixel;
+    }
+    
+    VROBlendMode getBlendMode() const {
+        return _blendMode;
+    }
+    void setBlendMode(VROBlendMode mode){
+        _blendMode = mode;
+    }
+
+    bool getWritesToDepthBuffer() const {
+        return _writesToDepthBuffer;
+    }
+    bool getReadsFromDepthBuffer() const {
+        return _readsFromDepthBuffer;
+    }
+    
+    void setWritesToDepthBuffer(bool writesToDepthBuffer) {
+        _writesToDepthBuffer = writesToDepthBuffer;
+        updateSubstrate();
+    }
+    void setReadsFromDepthBuffer(bool readsFromDepthBuffer) {
+        _readsFromDepthBuffer = readsFromDepthBuffer;
+        updateSubstrate();
+    }
+    
+    void setBloomThreshold(float threshold) {
+        bool needsSubstrateUpdate = (_bloomThreshold >= 0 && threshold < 0) || (_bloomThreshold < 0 && threshold >= 0);
+        _bloomThreshold = threshold;
+        
+        if (needsSubstrateUpdate) {
+            updateSubstrate();
+        }
+    }
+    float getBloomThreshold() const {
+        return _bloomThreshold;
+    }
+    bool isBloomSupported() const {
+        return _bloomThreshold >= 0;
+    }
+
+    void setReceivesShadows(bool receivesShadows) {
+        _receivesShadows = receivesShadows;
+        updateSubstrate();
+    }
+    bool getReceivesShadows() const {
+        return _receivesShadows;
+    }
+
+    void addShaderModifier(std::shared_ptr<VROShaderModifier> modifier);
+    void removeShaderModifier(std::shared_ptr<VROShaderModifier> modifier);
+    bool hasShaderModifier(std::shared_ptr<VROShaderModifier> modifier);
+    const std::vector<std::shared_ptr<VROShaderModifier>> &getShaderModifiers() const {
+        return _shaderModifiers;
+    }
+    void removeAllShaderModifiers() {
+        _shaderModifiers.clear();
+    }
+    
+    /*
+     Make a snapshot of this material and cross-fade that snapshot out,
+     bringing in the current material. Used to animate material changes.
+     No effect if there is no active animation transaction.
+     */
+    void fadeSnapshot();
+    std::shared_ptr<VROMaterial> getOutgoing() const {
+        return _outgoing;
+    }
+    
+    /*
+     Check if the material has been updated since the last substrate was
+     created.
+     */
+    bool isUpdated() {
+        return _substrate == nullptr;
+    }
+    
+    /*
+     Force the substrate of this material to update on the next render cycle.
+     */
+    void updateSubstrate();
+    
+    /*
+     Faster than updateSubstrate(), used only when the textures of this material are
+     updated.
+     */
+    void updateSubstrateTextures();
+    
+    /*
+     Get the representation of this material in the underlying graphics 
+     technology.
+     */
+    VROMaterialSubstrate *const getSubstrate(std::shared_ptr<VRODriver> &driver);
+    
+    /*
+     Update the given sort key with fields from this material, if the given
+     lights are used in the render.
+     */
+    void updateSortKey(VROSortKey &key, const std::vector<std::shared_ptr<VROLight>> &lights,
+                       const VRORenderContext &context,
+                       std::shared_ptr<VRODriver> &driver);
+
+    /*
+     Returns a VROBlendMode for the given string. If no matching blend modes were found,
+     VROBlendMode::None is returned.
+     */
+    static VROBlendMode getBlendModeFromString(std::string strType) {
+        if (VROStringUtil::strcmpinsensitive(strType, "Alpha")) {
+            return VROBlendMode::Alpha;
+        } else if (VROStringUtil::strcmpinsensitive(strType, "Add")) {
+            return VROBlendMode::Add;
+        } else if (VROStringUtil::strcmpinsensitive(strType, "Multiply")) {
+            return VROBlendMode::Multiply;
+        } else if (VROStringUtil::strcmpinsensitive(strType, "Subtract")) {
+            return VROBlendMode::Subtract;
+        } else if (VROStringUtil::strcmpinsensitive(strType, "Screen")) {
+            return VROBlendMode::Screen;
+        } else if (VROStringUtil::strcmpinsensitive(strType, "None")) {
+            return VROBlendMode::None;
+        }
+        return VROBlendMode::None;
+    }
+
+private:
+    
+    uint32_t _materialId;
+    
+    /*
+     Properties used for PBR.
+     */
+    VROMaterialVisual *_diffuse;
+    VROMaterialVisual *_roughness;
+    VROMaterialVisual *_metalness;
+    VROMaterialVisual *_ambientOcclusion;
+    
+    /*
+     Properties used for standard lighting.
+     */
+    VROMaterialVisual *_specular;
+    VROMaterialVisual *_reflective;
+    
+    /*
+     Properties used for special effects.
+     */
+    VROMaterialVisual *_normal;
+    VROMaterialVisual *_emission;         // Unsupported (TODO VIRO-1188)
+    VROMaterialVisual *_multiply;         // Unsupported (TODO VIRO-1190)
+    
+    /*
+     Currently unsupported. This will be used to override the Scene's overall environment 
+     map with a material-specific environment map.
+     */
+    VROMaterialVisual *_selfIllumination;
+    
+    /*
+     User-provided name of the material.
+     */
+    std::string _name;
+    
+    /*
+     The sharpness of specular highlights.
+     */
+    float _shininess;
+    
+    /*
+     Factor affecting material reflectivity.
+     */
+    float _fresnelExponent;
+    
+    /*
+     Uniform transparency of the material.
+     */
+    float _transparency;
+    
+    /*
+     The mode used to calculate transparency.
+     */
+    VROTransparencyMode _transparencyMode;
+    
+    /*
+     The lighting model to use to compute the interaction between
+     the lights in the scene and this material's visual properties.
+     */
+    VROLightingModel _lightingModel;
+    
+    /*
+     True means use per-pixel lighting, false means use per-vertex lighting.
+     */
+    bool _litPerPixel;
+    
+    /*
+     Set to cull back faces, front faces, or none.
+     */
+    VROCullMode _cullMode;
+    
+    /*
+     Determines how pixel colors rendered using this material blend with 
+     pixel colors already in the render target.
+     */
+    VROBlendMode _blendMode;
+    
+    /*
+     Depth write and read settings.
+     */
+    bool _writesToDepthBuffer, _readsFromDepthBuffer;
+    
+    /*
+     Version of this material that's being animated away. Populated with the current
+     values of this material whenever this material is changed.
+     */
+    std::shared_ptr<VROMaterial> _outgoing;
+    
+    /*
+     Modifiers to alter the shader code.
+     */
+    std::vector<std::shared_ptr<VROShaderModifier>> _shaderModifiers;
+    
+    /*
+     If fragments of this material exceed this value, then those fragments will
+     glow. If less than 0, bloom will be disabled. Defaults to -1.
+     */
+    float _bloomThreshold;
+
+    /*
+     True if this material receives shadows. Defaults to true.
+     */
+    bool _receivesShadows;
+    
+    /*
+     Representation of this material in the underlying graphics hardware.
+     */
+    VROMaterialSubstrate *_substrate;
+    
+    void removeOutgoingMaterial();
+    
+};
+
+#endif /* VROMaterial_h */