@hxa-rn/react-native-gcanvas 6.0.24-beta.1

package/harmony/gcanvas/src/main/cpp/core/src/gcanvas/GShader.h

@@ -0,0 +1,360 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef GCANVAS_GSHADER_H
+#define GCANVAS_GSHADER_H
+
+#include "GGL.h"
+#include "GPoint.h"
+#include "GTransform.h"
+#include "../support/Log.h"
+
+#include <vector>
+
+class GShader
+{
+public:
+    GShader(const char *name, const char *vertexShaderSrc,
+            const char *fragmentShaderSrc);
+
+    virtual ~GShader();
+
+#ifdef ANDROID
+
+    bool initWithPreCompiledProgramByteArray(const char *shaderName,
+                                             const GLchar *vShaderByteArray,
+                                             const GLchar *fShaderByteArray);
+
+#endif
+
+    void Bind();
+
+    const std::string &GetName() { return mName; }
+
+    virtual void RestoreShaderState() {}
+
+    virtual void SetTextSampler(int value) {}
+
+    virtual void SetHasTexture(bool value) {}
+
+    virtual void SetOverideTextureColor(int value) {}
+    
+    GLint GetTexcoordSlot() { return mTexcoordSlot; }
+    
+    GLint GetPositionSlot() { return mPositionSlot; }
+    
+    GLint GetColorSlot() { return mColorSlot; }
+    
+    GLint GetTransformSlot() { return mTransfromSlot; }
+
+    virtual void SetRepeatMode(const std::string &pattern) {}
+
+    virtual void SetRange(const GPoint &start, const GPoint &end) {}
+
+    virtual void SetRange(const float *start, const float *end) {}
+
+    virtual void SetColorStopCount(int count) {}
+
+    virtual void SetColorStop(float *pack_color, float stop, int id) {}
+
+    virtual void SortColorStop() {}
+
+    virtual void SetTextureSize(float width, float height) {}
+
+    void SetTransform(const GTransform &trans);
+
+    virtual void SetDelta(float x, float y) {}
+
+    virtual void SetWeight(float w[], int count) {}
+
+    std::vector<GCanvasLog>& GetErrorVector(){ return mErrVec;}
+    
+    void ClearErrorVector() { mErrVec.clear(); }
+
+protected:
+    virtual void calculateAttributesLocations();
+
+    GLuint compileShader(const char *shader, GLenum shaderType);
+
+    GLuint mHandle;
+    std::string mName;
+    
+    GLint mTexcoordSlot;
+    GLint mPositionSlot;
+    GLint mColorSlot;
+    GLint mTransfromSlot;
+    
+    std::vector<GCanvasLog> mErrVec;
+};
+
+class DefaultShader : public GShader
+{
+public:
+    DefaultShader(const char *name, const char *vertexShaderSrc,
+                  const char *fragmentShaderSrc);
+
+    ~DefaultShader();
+
+    void SetTextSampler(int value)
+    {
+        glUniform1i(mTextureSamplerSlot, value);
+    }
+
+    void SetHasTexture(bool value)
+    {
+
+        if (mHasTextureFlag != value)
+        {
+            mHasTextureFlag = value;
+            glUniform1i(mHasTextureSlot, value);
+
+        }
+    }
+
+    void SetOverideTextureColor(int value)
+    {
+        mOverrideTextureColorFlag = value;
+        glUniform1i(mOverrideTextureColorSlot, value);
+    }
+
+    void RestoreShaderState()
+    {
+        SetHasTexture(mHasTextureFlag);
+        SetOverideTextureColor(mOverrideTextureColorFlag);
+    }
+
+protected:
+    void calculateAttributesLocations();
+
+private:
+    GLuint mTextureSamplerSlot;
+    GLuint mHasTextureSlot;
+    GLuint mOverrideTextureColorSlot;
+
+    bool mHasTextureFlag;
+    bool mOverrideTextureColorFlag;
+};
+
+class TextureShader : public GShader
+{
+public:
+    TextureShader(const char *name, const char *vertexShaderSrc,
+                  const char *fragmentShaderSrc);
+
+    ~TextureShader() = default;
+
+    void SetTextSampler(int value)
+    {
+        glUniform1i(mTextureSamplerSlot, value);
+    }
+    
+    void SetPremultipliedAlpha(bool value)
+    {
+        glUniform1i(mPremultipliedAlphaSlot, value);
+    }
+
+protected:
+    void calculateAttributesLocations();
+
+private:
+    GLuint mTextureSamplerSlot;
+    GLuint mPremultipliedAlphaSlot;
+};
+
+class ShadowShader : public GShader
+{
+public:
+    ShadowShader(const char *name, const char *vertexShaderSrc,
+                 const char *fragmentShaderSrc);
+
+    ~ShadowShader() = default;
+
+
+    void SetDelta(float x, float y)
+    {
+        glUniform1f(mXDeltaSlot, x);
+        glUniform1f(mYDeltaSlot, y);
+
+    }
+
+    void SetWeight(float w[], int count)
+    {
+        glUniform1fv(mWeightSlot, count, w);
+
+    }
+
+protected:
+    void calculateAttributesLocations();
+
+private:
+    GLuint mXDeltaSlot;
+    GLuint mYDeltaSlot;
+    GLuint mWeightSlot;
+    GLuint mSamplerSlot;
+
+};
+
+class PatternShader : public GShader
+{
+public:
+    PatternShader(const char *name, const char *vertexShaderSrc,
+                  const char *fragmentShaderSrc);
+
+    void SetTextSampler(int value)
+    {
+        glUniform1i(mTextureSamplerSlot, value);
+    }
+
+    void SetRepeatMode(const std::string &pattern)
+    {
+        glUniform1i(mRepeatXSlot,
+                    (pattern == "repeat" || pattern == "repeat-x"));
+        glUniform1i(mRepeatYslot,
+                    (pattern == "repeat" || pattern == "repeat-y"));
+    }
+
+    void SetTextureSize(float width, float height)
+    {
+        glUniform2f(mTextureSizeSlot, width, height);
+    }
+    
+    void SetPatternAlpha(float patternAlpha)
+    {
+        glUniform1f(mPatternAlphaSlot, patternAlpha);
+    }
+
+    GLint GetTextureSamplerSlot() { return mTextureSamplerSlot; }
+
+protected:
+    void calculateAttributesLocations();
+    
+    GLuint mTextureSamplerSlot;
+    GLuint mRepeatXSlot;
+    GLuint mRepeatYslot;
+    GLuint mTextureSizeSlot;
+    GLuint mPatternAlphaSlot;
+};
+
+
+class GradientShader : public GShader
+{
+public:
+    GradientShader(const char *name, const char *vertexShaderSrc, const char *fragmentShaderSrc);
+    
+    void SetHasTexture(bool value)
+    {
+        if (mHasTextureFlag != value)
+        {
+            mHasTextureFlag = value;
+            glUniform1i(mHasTextureSlot, value);
+            
+        }
+    }
+    
+    void RestoreShaderState() { SetHasTexture(mHasTextureFlag); }
+    
+    void SetColorStopCount(int count) { glUniform1i(mStopCountSlot, count); }
+    
+    void SetColorStop(float *color, float stop, int id)
+    {
+        GLuint stopLoc;
+        GLuint colorLoc;
+        if (id == 0)
+        {
+            stopLoc = mStop0Slot;
+            colorLoc = mStop0ColorSlot;
+        }
+        else if (id == 1)
+        {
+            stopLoc = mStop1Slot;
+            colorLoc = mStop1ColorSlot;
+        }
+        else if (id == 2)
+        {
+            stopLoc = mStop2Slot;
+            colorLoc = mStop2ColorSlot;
+        }
+        else if (id == 3)
+        {
+            stopLoc = mStop3Slot;
+            colorLoc = mStop3ColorSlot;
+        }
+        else if (id == 4)
+        {
+            stopLoc = mStop4Slot;
+            colorLoc = mStop4ColorSlot;
+        }
+        else
+        {
+            return;
+        }
+        
+        glUniform1f(stopLoc, stop);
+        glUniform4f(colorLoc, color[0], color[1], color[2], color[3]);
+    }
+    
+protected:
+    void calculateAttributesLocations();
+    
+    GLuint mTextureSamplerSlot;
+    
+    GLuint mStopCountSlot;
+    
+    GLuint mStop0ColorSlot;
+    GLuint mStop1ColorSlot;
+    GLuint mStop2ColorSlot;
+    GLuint mStop3ColorSlot;
+    GLuint mStop4ColorSlot;
+    
+    GLuint mStop0Slot;
+    GLuint mStop1Slot;
+    GLuint mStop2Slot;
+    GLuint mStop3Slot;
+    GLuint mStop4Slot;
+    
+    GLuint mHasTextureSlot;
+    bool mHasTextureFlag;
+};
+
+class LinearGradientShader : public GradientShader
+{
+public:
+    LinearGradientShader(const char *name, const char *vertexShaderSrc,
+                         const char *fragmentShaderSrc);
+
+    void SetRange(const GPoint &start, const GPoint &end)
+    {
+        glUniform2f(mRangeStartSlot, start.x, start.y);
+        glUniform2f(mRangeEndSlot, end.x, end.y);
+    }
+
+protected:
+    void calculateAttributesLocations();
+    GLuint mRangeStartSlot;
+    GLuint mRangeEndSlot;
+};
+
+class RadialGradientShader : public GradientShader
+{
+public:
+    RadialGradientShader(const char *name, const char *vertexShaderSrc,
+                         const char *fragmentShaderSrc);
+
+    void SetRange(const float *start, const float *end)
+    {
+        glUniform3f(mStartSlot, start[0], start[1], start[2]);
+        glUniform3f(mEndSlot, end[0], end[1], end[2]);
+    }
+protected:
+    void calculateAttributesLocations();
+    GLuint mStartSlot;
+    GLuint mEndSlot;
+
+};
+
+#endif /* GCANVAS_GSHADER_H */

package/harmony/gcanvas/src/main/cpp/core/src/gcanvas/GShaderManager.cpp

@@ -0,0 +1,140 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#include "GShaderManager.h"
+#include "GShader.h"
+#include "shaders/default.glsl"
+#include "shaders/grad.glsl"
+#include "shaders/pattern.glsl"
+#include "shaders/radiation.glsl"
+#include "shaders/texture.glsl"
+#include "shaders/shadow.glsl"
+
+#ifdef ANDROID
+#include "GPreCompiledShaders.h"
+bool g_use_pre_compile = false;
+#endif
+
+
+GShaderManager *GShaderManager::mShaderManager = nullptr;
+
+GShaderManager *GShaderManager::getSingleton()
+{
+    if (nullptr == mShaderManager)
+    {
+        mShaderManager = new GShaderManager();
+    }
+    return mShaderManager;
+}
+
+void GShaderManager::release()
+{
+    if (mShaderManager != nullptr)
+    {
+        delete mShaderManager;
+        mShaderManager = nullptr;
+    }
+}
+
+
+void GShaderManager::addProgram(const std::string &key, GShader *program)
+{
+    std::map< std::string, GShader * >::iterator iter =
+        mProgramCaches.find(key);
+    if (iter == mProgramCaches.end())
+    {
+        mProgramCaches.insert(
+            std::pair< std::string, GShader * >(key, program));
+    }
+    else if (iter->second != program)
+    {
+        delete (iter->second);
+        iter->second = program;
+    }
+}
+
+GShader *GShaderManager::programForKey(const std::string &key)
+{
+    std::map< std::string, GShader * >::iterator iter =
+        mProgramCaches.find(key);
+    if (iter == mProgramCaches.end())
+    {
+        return nullptr;
+    }
+
+    return iter->second;
+}
+
+GShaderManager::GShaderManager()
+{
+#ifdef ANDROID
+    if (g_use_pre_compile)
+    {
+        const char *extString = (const char *)glGetString(GL_EXTENSIONS);
+        bool isPreCompileSupported =
+            (strstr(extString, "GL_OES_get_program_binary") != 0);
+
+        if (isPreCompileSupported)
+        {
+            GPreCompiledShaders::getInstance()->SetSupportPreCompiledShaders(
+                    true);
+        }
+    }
+#endif
+
+    loadDefaultShaders();
+
+#ifdef ANDROID
+    if (g_use_pre_compile)
+    {
+        if (GPreCompiledShaders::getInstance()
+                ->GetSupportPreCompiledShaders())
+        {
+            GPreCompiledShaders::getInstance()->SavePreCompiledShaders();
+        }
+    }
+#endif
+}
+
+GShaderManager::~GShaderManager()
+{
+    std::map< std::string, GShader * >::iterator iter =
+        mProgramCaches.begin();
+    for (; iter != mProgramCaches.end(); ++iter)
+    {
+        delete iter->second;
+        iter->second = nullptr;
+    }
+}
+
+void GShaderManager::loadDefaultShaders()
+{
+    GShader *program =
+        new DefaultShader(DEFAULT_SHADER, DEFAULT_SHADER_VS, DEFAULT_SHADER_PS);
+    addProgram(DEFAULT_SHADER, program);
+
+    program =
+        new TextureShader(TEXTURE_SHADER, TEXTURE_SHADER_VS, TEXTURE_SHADER_PS);
+    addProgram(TEXTURE_SHADER, program);
+
+    program =
+            new ShadowShader(SHADOW_SHADER, SHADOW_SHADER_VS, SHADOW_SHADER_PS);
+    addProgram(SHADOW_SHADER, program);
+
+    program =
+            new PatternShader(PATTERN_SHADER, PATTERN_SHADER_VS, PATTERN_SHADER_PS);
+    addProgram(PATTERN_SHADER, program);
+
+    program = new LinearGradientShader(LINEAR_SHADER, LINEAR_SHADER_VS,
+                                       LINEAR_SHADER_PS);
+    addProgram(LINEAR_SHADER, program);
+
+    program = new RadialGradientShader(RADIAL_SHADER, RADIAL_SHADER_VS,
+                                       RADIAL_SHADER_PS);
+    addProgram(RADIAL_SHADER, program);
+}

package/harmony/gcanvas/src/main/cpp/core/src/gcanvas/GShaderManager.h

@@ -0,0 +1,38 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef GCANVAS_GSHADERMANAGER_H
+#define GCANVAS_GSHADERMANAGER_H
+
+#include <iostream>
+#include <map>
+
+class GShader;
+
+class GShaderManager
+{
+public:
+
+    // Android depend constructor, set it public
+    GShaderManager();
+    ~GShaderManager();
+
+    static GShaderManager *getSingleton();
+    static void release();
+
+    void addProgram(const std::string &key, GShader *program);
+    GShader *programForKey(const std::string &key);
+
+private:
+    void loadDefaultShaders();
+
+    std::map< std::string, GShader * > mProgramCaches;
+    static GShaderManager *mShaderManager;
+};
+
+#endif /* GCANVAS_GSHADERMANAGER_H */

package/harmony/gcanvas/src/main/cpp/core/src/gcanvas/GStrSeparator.cpp

@@ -0,0 +1,84 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#include "GStrSeparator.h"
+
+#include <ctype.h>
+#include <string.h>
+
+namespace gcanvas
+{
+GStrSeparator::GStrSeparator() { memset(mPointers, 0, sizeof(mPointers)); }
+
+short GStrSeparator::SepStrByCharArray(char *str, const char *byteArray,
+                                        short byteCount, short maxCount)
+{
+    if (maxCount < 0)
+    {
+        maxCount = PARSESEPSTRMAXCOUNT;
+    }
+    short sepCount = 0, i = 0;
+    bool lastMark = true;
+    char *cur = str;
+
+    for (; *cur; cur++)
+    {
+        for (i = 0; i < byteCount; i++)
+        {
+            if (*cur == byteArray[i])
+            {
+                lastMark = true;
+                *cur = 0;
+                break;
+            }
+        }
+        if (*cur && lastMark)
+        {
+            if (sepCount < maxCount)
+            {
+                mPointers[sepCount++] = cur;
+            }
+            lastMark = false;
+        }
+    }
+    return sepCount;
+};
+
+short GStrSeparator::SepStrBySpace(char *str, short maxCount)
+{
+    if (maxCount < 0)
+    {
+        maxCount = PARSESEPSTRMAXCOUNT;
+    }
+
+    short sepCount = 0;
+    bool lastMark = true;
+    char *cur = str;
+
+    for (; *cur; cur++)
+    {
+        if (isspace((unsigned char)*cur))
+        {
+            lastMark = true;
+            *cur = 0;
+        }
+        else
+        {
+            if (lastMark)
+            {
+                if (sepCount < maxCount)
+                {
+                    mPointers[sepCount++] = cur;
+                }
+                lastMark = false;
+            }
+        }
+    }
+    return sepCount;
+};
+}

package/harmony/gcanvas/src/main/cpp/core/src/gcanvas/GStrSeparator.h

@@ -0,0 +1,31 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef GCANVAS_GSTRSEPARATOR_H
+#define GCANVAS_GSTRSEPARATOR_H
+
+namespace gcanvas
+{
+class GStrSeparator
+{
+public:
+    static const short PARSESEPSTRMAXCOUNT = 50;
+    static const short PARSELOCALBUFFERSIZE = 480;
+
+    GStrSeparator();
+    short SepStrBySpace(char *str, short maxCount = -1);
+    short SepStrByCharArray(char *str, const char *byteArray, short byteCount,
+                            short maxCount = -1);
+    char **GetSepArray() { return (char **)mPointers; }
+
+private:
+    char *mPointers[PARSELOCALBUFFERSIZE];
+};
+}
+
+#endif /* GCANVAS_GSTRSEPARATOR_H */

package/harmony/gcanvas/src/main/cpp/core/src/gcanvas/GTextDefine.h

@@ -0,0 +1,34 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef GCANVAS_GTEXTDEFINE_H
+#define GCANVAS_GTEXTDEFINE_H
+
+typedef enum {
+    GTEXT_BASELINE_ALPHABETIC = 0, // for Western fonts: Default. The text
+                                   // baseline is the normal alphabetic baseline
+    GTEXT_BASELINE_MIDDLE,  // The text baseline is the middle of the em square
+    GTEXT_BASELINE_TOP,     // The text baseline is the top of the em square
+    GTEXT_BASELINE_HANGING, // for Indian fonts : The text baseline is the
+                            // hanging baseline
+    GGTEXT_BASELINE_BOTTOM,  // The text baseline is the bottom of the bounding
+                            // box
+    GTEXT_BASELINE_IDEOGRAPHIC // for CJK fonts: The text baseline is the
+                               // ideographic baseline
+} GTextBaseline;
+
+typedef enum {
+    GTEXT_ALIGN_START = 0, // Default. The text baseline is the normal alphabetic baseline
+    GTEXT_ALIGN_END,    // The text ends at the specified position
+    GTEXT_ALIGN_LEFT,   // The text starts at the specified position
+    GTEXT_ALIGN_CENTER, // The center of the text is placed at the specified
+                        // position
+    GTEXT_ALIGN_RIGHT   // The text ends at the specified position
+} GTextAlign;
+
+#endif /* GCANVAS_GTEXTDEFINE_H  */