compile error

This topic contains 39 replies, has 2 voices, and was last updated by  chototsu 5 years, 10 months ago.

Viewing 15 posts - 1 through 15 (of 40 total)
  • Author
  • #30746



    I got a compile error on Galaxy S.

    This shader works fine on Tegra2, Adreno200,205,220,Mali-400M.

    Why doesn’t it work on PowerVR SGX540?

    However, I removed this line:

           #define USE_HWSKINNING 1

    It works fine on Galaxy S.

    Sample APK(This apk doesn’t work on Galaxy S)

    Release version(This apk works on Galaxy S, but it’s slow because GLSL skinning is disabled).


    #define COLORRAMP 1

    #define DIFFUSEMAP 1

    #define MATERIAL_COLORS 1

    #define NUM_BONES 20

    #define USE_HWSKINNING 1

    #define VERTEX_LIGHTING 1

    // #import “MatDefs/pmd/Skinning.glsllib”


    uniform mat4 m_BoneMatrices[NUM_BONES];


    #define ATTENUATION

    // #define HQ_ATTENUATION

    uniform mat4 g_WorldViewProjectionMatrix;

    uniform mat4 g_WorldViewMatrix;

    uniform mat3 g_NormalMatrix;

    uniform mat4 g_ViewMatrix;

    uniform vec4 m_Ambient;

    uniform vec4 m_Diffuse;

    uniform vec4 m_Specular;

    uniform float m_Shininess;

    uniform vec4 g_LightColor;

    uniform vec4 g_LightPosition;

    uniform vec4 g_AmbientLightColor;

    varying vec2 texCoord;

    varying vec4 AmbientSum;

    varying vec4 DiffuseSum;

    varying vec4 SpecularSum;

    attribute vec3 inPosition;

    attribute vec2 inTexCoord;

    attribute vec3 inNormal;

    // uniform Sampler2D m_BoneParameter;

    // uniform sampler2D m_BoneParameter;


    varying vec3 lightVec;


    #ifdef VERTEX_COLOR

    attribute vec4 inColor;



    attribute vec4 inTangent;

    #ifndef NORMALMAP

        varying vec3 vNormal;


    varying vec3 vPosition;

    varying vec3 vViewDir;

    varying vec4 vLightDir;


    // #ifdef USE_REFLECTION

        uniform vec3 g_CameraPosition;

        uniform mat4 g_WorldMatrix;

        uniform vec3 m_FresnelParams;

        varying vec4 refVec;


         * Input:

         * attribute inPosition

         * attribute inNormal

         * uniform g_WorldMatrix

         * uniform g_CameraPosition


         * Output:

         * varying refVec


        void computeRef(in vec4 position, in vec4 normal){

            vec3 worldPos = (g_WorldMatrix * vec4(normalize(,1.0)).xyz;

            vec3 I = normalize( g_CameraPosition – worldPos ).xyz;

            vec3 N = normalize( (g_WorldMatrix * vec4(normalize(, 0.0)).xyz );

   = reflect(I, N);

            refVec.w   = 1.0;//m_FresnelParams.x + m_FresnelParams.y * pow(1.0 + dot(I, N), m_FresnelParams.z);


    // #endif

    // JME3 lights in world space

    void lightComputeDir(in vec3 worldPos, in vec4 color, in vec4 position, out vec4 lightDir){

        float posLight = step(0.5, color.w);

        vec3 tempVec = * sign(posLight – 0.5) – (worldPos * posLight);

        #ifdef ATTENUATION

         float dist = length(tempVec);

         lightDir.w = clamp(1.0 – position.w * dist * posLight, 0.0, 1.0);
 = tempVec / vec3(dist);

         #ifdef HQ_ATTENUATION

           lightVec = tempVec;



         lightDir = vec4(normalize(tempVec), 1.0);




    float lightComputeDiffuse(in vec3 norm, in vec3 lightdir){

          return max(0.0, dot(norm, lightdir));


    float lightComputeSpecular(in vec3 norm, in vec3 viewdir, in vec3 lightdir, in float shiny){

          #ifndef LOW_QUALITY

            vec3 H = (viewdir + lightdir) * vec3(0.5);

            return pow(max(dot(H, norm), 0.0), shiny);


            return 0.0;



    vec2 computeLighting(in vec3 wvPos, in vec3 wvNorm, in vec3 wvViewDir, in vec4 wvLightPos){

         vec4 lightDir;

         lightComputeDir(wvPos, g_LightColor, wvLightPos, lightDir);

         float diffuseFactor = lightComputeDiffuse(wvNorm,;

         float specularFactor = lightComputeSpecular(wvNorm, wvViewDir,, m_Shininess);

         //specularFactor *= step(0.01, diffuseFactor);

         return vec2(diffuseFactor, specularFactor) * vec2(lightDir.w);



    attribute vec4 inBoneWeight;

    attribute vec4 inBoneIndices;

    attribute vec4 inBoneIndex;


    void Skinning_Compute(inout vec4 position, inout vec4 normal){

    //    vec4 index = inBoneIndices;

        vec4 index = inBoneIndex;

        vec4 weight = inBoneWeight;

        vec4 newPos    = vec4(0.0,0.0,0.0,0.0);

        vec4 newNormal = vec4(0.0,0.0,0.0,0.0);

        //for (float i = 1.0; i < 2.0; i += 1.0){

            mat4 skinMat = m_BoneMatrices[int(index.x)];

            newPos    = weight.x * (skinMat * position);

            newNormal = weight.x * (skinMat * normal);

            //index = index.yzwx;

            //weight = weight.yzwx;

            skinMat = m_BoneMatrices[int(index.y)];

            newPos    = newPos + weight.y * (skinMat * position);

            newNormal = newNormal + weight.y * (skinMat * normal);


        position = newPos;

        normal = newNormal;



    void main(){

       vec4 pos = vec4(inPosition, 1.0);

       vec4 normal = vec4(inNormal,0.0);


       Skinning_Compute(pos, normal);


    //    pos = m_BoneMatrices[0] * pos;

       gl_Position = g_WorldViewProjectionMatrix * pos;

       texCoord = inTexCoord;

       vec3 wvPosition = (g_WorldViewMatrix * pos).xyz;

       vec3 wvNormal = normalize(g_NormalMatrix *;

    //   vec3 wvPosition = (g_WorldViewMatrix * pos).xyz;

    //   vec3 wvNormal = normalize(g_NormalMatrix * inNormal);

       vec3 viewDir = normalize(-wvPosition);

           //vec4 lightColor = g_LightColor[gl_InstanceID];

           //vec4 lightPos   = g_LightPosition[gl_InstanceID];

           //vec4 wvLightPos = (g_ViewMatrix * vec4(, lightColor.w));

           //wvLightPos.w = lightPos.w;

       vec4 wvLightPos = (g_ViewMatrix * vec4(, g_LightColor.w));

       wvLightPos.w = g_LightPosition.w;

       vec4 lightColor = g_LightColor;

       #if defined(NORMALMAP) && !defined(VERTEX_LIGHTING)

         vec3 wvTangent = normalize(g_NormalMatrix *;

         vec3 wvBinormal = cross(wvNormal, wvTangent);

         mat3 tbnMat = mat3(wvTangent, wvBinormal * -inTangent.w,wvNormal);


         vPosition = wvPosition * tbnMat;

         vViewDir = viewDir * tbnMat;

         lightComputeDir(wvPosition, lightColor, wvLightPos, vLightDir);
 = ( * tbnMat).xyz;

       #elif !defined(VERTEX_LIGHTING)

         vNormal = wvNormal;

         vPosition = wvPosition;

         vViewDir = viewDir;

         lightComputeDir(wvPosition, lightColor, wvLightPos, vLightDir);

         #ifdef V_TANGENT

            vNormal = normalize(g_NormalMatrix *;

            vNormal = -cross(cross(, vNormal), vNormal);



       lightColor.w = 1.0;

       #ifdef MATERIAL_COLORS

          AmbientSum = m_Ambient * g_AmbientLightColor;

          DiffuseSum = m_Diffuse * lightColor;

          SpecularSum = m_Specular * lightColor;


          AmbientSum = vec4(0.2, 0.2, 0.2, 1.0) * g_AmbientLightColor; // Default: ambient color is dark gray

          DiffuseSum = lightColor;

          SpecularSum = lightColor;


        #ifdef VERTEX_COLOR

          AmbientSum *= inColor;

          DiffuseSum *= inColor;


        #ifdef VERTEX_LIGHTING

           vec2 light = computeLighting(wvPosition, wvNormal, viewDir, wvLightPos);

           AmbientSum.a = light.x;

           SpecularSum.a = light.y * 0.3;


        #if defined(USE_REFLECTION) || defined(SPHERE_MAP_A) || defined(SPHERE_MAP_H)







    This shader works on Galaxy NEXUS.

    However it doesn’t work on Galaxy S, EPSON MOVERIO, FUJITSU ARROWS X.

    Why does the compile error happen?

    How should I fix it?





    Just to let you know that we are currently investigating this issue and we’ll keep you updated if we find anything out.



    Hi, Arron.

    Thank you for your quick reply.

    I send all source code to you if you need.

    This is an open source product.




    Hi chototsu.

    If you could send the source that would be great. Please send a zipped package to



    Hi chototsu.

    We may have found the problem. It seems that the statement “precision mediump float;” is being prepended to your vertex shader. This seems to have some issues on the Galaxy S & Nexus S.

    Although your vertex shader doesn’t actually contain this declaration, it seems as though your shader loading code is adding the line and causing the issue.

    If you can track this down and perhaps retest the application with this line removed it may work.




    Hi, Arron.

    > your shader loading code is adding the line

    Sorry, I forgot it.

    I changed my renderer code and build my app.

    (However, I don’t yet test it because I don’t have Galaxy S.)

    Thank you very much.

            if (source.getType().equals(ShaderType.Vertex)

                   && GLES20.glGetString(GLES20.GL_RENDERER).indexOf(“PowerVR”)>=0) {




                        + source.getSource());

            } else {



                        “precision mediump float;n”

                        + source.getDefines()

                        + source.getSource());




    Hi chototsu,

    This no longer fails to compile so that problem is solved :).

    However, on our Galaxy S the application runs very, very slow – around 4-5fps. This appears to be due to very high CPU load.Arron2012-02-03 16:26:15



    Thank you for test my app.

    > However, on our Galaxy S the application runs very, very slow

    Which of release version or 112beta3 is faster?

    On my test machine(ASUS TF101 Tegra2), it’s same frame rate as release version.

    (Don’t select Megurine Luka models because it’s too heavy for Galaxy S.

    Please select Miku model.)




    Old version of my app runs around 25fps on Galaxy S.

    It uses GLSL skinning.

    It works fine.

    However, I updated to new version, it didn’t work on Galaxy S.

    I didn’t change my shader.

    I am confused very much.

    It runs around 25fps on Galaxy S if GLSL skinning works.




    Hi chototsu,

    I have downloaded your release app and can confirm that 112beta3 runs faster than the released version. I assume this is because you have now enabled HW skinning?

    I believe I was using the Miku model, but I cannot find a way to switch models.

    Regards.Arron2012-02-03 17:07:47



    Thank you for test.

    > I assume this is because you have now enabled HW skinning?

    Yes, 112beta3 uses GLSL skinning.

    However, I head that old version(uses GLSL skinning) runs around 25 fps on Galaxy S from users.

    My app runs around 40fps on TF101(Tegra2).

    4-5fps is too slow…

    I don’t understand the cause.

    > I believe I was using the Miku model, but I cannot find a way to switch models.

    Please push menu button.

    (Default model is Miku, you don’t need to change model.)




    Hi chototsu.

    I’m not really sure. I’ve profiled your app with our internal tools and can see that the GPU does very little work, while the CPU is fully loaded. There’s approximately a 200ms gap between a GPU calls.

    The app runs well (40-50fps+) on a Galaxy Nexus which is also an SGX540 although clocked higher, so I do not think that the issue is with the graphics hardware.

    Your other models vary with speed – some run around 17-20fps while as you say Megurine Luka runs very very slow.

    I’ll continue profiling your application next week and I’ll update this post if I find any more information which may be of use.

    Best regards.Arron2012-02-03 18:00:56



    > I do not think that the issue is with the graphics hardware.


    I investigate My app code.

    Thank you for your kindness.



    You’re welcome.

    One thing I have noticed is that you seem to call glGetError a lot (317 times per frame). This should be disabled in release code as that number of calls may affect performance.

Viewing 15 posts - 1 through 15 (of 40 total)
You must be logged in to reply to this topic.