Changeset 303 for trunk/thune/gl

Timestamp:

10/30/06 02:55:53 (2 years ago)

Author:

krobillard

Message:

Thune GL - Shader parameters can now be used.

Location:

trunk/thune/gl

Files:

• gx.c (modified) (1 diff)
• gx_atoms.h (modified) (1 diff)
• shader.c (modified) (5 diffs)
• test.t (modified) (2 diffs)

trunk/thune/gl/gx.c

@@ -1848 +1848 @@
     FIXED_ATOM( "specular", 8, UR_ATOM_SPECULAR );
     FIXED_ATOM( "pos",      3, UR_ATOM_POS );
+    FIXED_ATOM( "shader",   6, UR_ATOM_SHADER );
     FIXED_ATOM( "vertex",   6, UR_ATOM_VERTEX );
     FIXED_ATOM( "fragment", 8, UR_ATOM_FRAGMENT );

trunk/thune/gl/gx_atoms.h

@@ -18 +18 @@
 #define UR_ATOM_SPECULAR                316
 #define UR_ATOM_POS             317
-#define UR_ATOM_VERTEX          318
-#define UR_ATOM_FRAGMENT                319
+#define UR_ATOM_SHADER          318
+#define UR_ATOM_VERTEX          319
+#define UR_ATOM_FRAGMENT                320

trunk/thune/gl/shader.c

@@ -31 +31 @@
 #include "os.h"
 #include "gx.h"
+#include "gx_atoms.h"
 #include "shader.h"
 
@@ -145 +146 @@
                                    &count );
 
+        // Collect non-gl parameters.
+
         pi = param;
         for( i = 0; i < count; ++i )
@@ -161 +164 @@
         count = pi - param;
 
-        bufN = ur_makeBuffer( UT_SHADER, sizeof(Shader) + (count - 1), &buf );
+        if( count )
+        {
+            ShaderParam* pend;
+            UCell* cval;
+
+            // We have parameters - make context to hold shader & params.
+
+            ur_makeContext( cell, count + 1 );
+            ur_internWord( cell, UR_ATOM_SHADER );
+
+            cval = ur_blockPtr( cell->ctx.valBlk )->ptr.cells;
+
+            pi = param;
+            pend = param + count;
+            while( pi != pend )
+            {
+                ur_internWord( cell, pi->name );
+
+                ++cval;
+                switch( pi->type )
+                {
+                    case GL_FLOAT:
+                        ur_initType( cval, UT_DECIMAL );
+                        ur_decimal( cval ) = 0.0;
+                        break;
+
+                    case GL_FLOAT_VEC2_ARB:
+                    case GL_FLOAT_VEC3_ARB:
+                    //case GL_FLOAT_VEC4_ARB:
+                        ur_initType( cval, UT_VEC3 );
+                        cval->vec3.xyz[0] = 0.0f;
+                        cval->vec3.xyz[1] = 0.0f;
+                        cval->vec3.xyz[2] = 0.0f;
+                        break;
+
+                    case GL_INT:
+                        ur_initType( cval, UT_INT );
+                        ur_int( cval ) = 0;
+                        break;
+
+                    case GL_INT_VEC2_ARB:
+                    case GL_INT_VEC3_ARB:
+                    //case GL_INT_VEC4_ARB:
+                        ur_initType( cval, UT_COORD );
+                        break;
+
+                    case GL_BOOL_ARB:
+                        ur_initType( cval, UT_LOGIC );
+                        ur_int( cval ) = 0;
+                        break;
+
+                    default:
+                        ur_initType( cval, UT_NONE );
+                        break;
+                }
+
+                ++pi;
+            }
+        }
+
+        bufN = ur_makeBuffer( UT_SHADER,
+                          sizeof(Shader) + sizeof(ShaderParam) * (count - 1),
+                          &buf );
         sh = (Shader*) buf->ptr;
 
@@ -170 +235 @@
 
         if( count )
+        {
             memCpy( sh->param, param, sizeof(ShaderParam) * count );
+
+            // First context value will be set to shader!.
+            cell = ur_blockPtr( cell->ctx.valBlk )->ptr.cells;
+        }
 
         ur_initType( cell, UT_SHADER );
         ur_setSeries( cell, bufN, 0 );
+
         return 1;
     }
@@ -182 +253 @@
 void loadShader( UCell* cell )
 {
-    if( ur_is(cell, UT_SHADER) )
+    if( ur_is(cell, UT_CONTEXT) )
+    {
+        UCell* cval;
+        ShaderParam* pi;
+        ShaderParam* pend;
+
+        cval = ur_blockPtr( cell->ctx.valBlk )->ptr.cells;
+        if( cval && ur_is(cval, UT_SHADER) )
+        {
+            Shader* sh = (Shader*) ur_bufPtr( cval->series.n )->ptr;
+            glUseProgramObjectARB( sh->program );
+
+            pi   = sh->param;
+            pend = sh->param + sh->paramCount;
+            while( pi != pend )
+            {
+                // There is no cell type checking or conversion here for speed.
+                // If the user loads bad types then we'll just get garbage.
+
+                ++cval;
+                switch( pi->type )
+                {
+                    case GL_FLOAT:
+                        glUniform1fARB( pi->location, ur_decimal(cval) );
+                        break;
+
+                    case GL_FLOAT_VEC2_ARB:
+                        glUniform2fvARB( pi->location, 1, cval->vec3.xyz );
+                        break;
+
+                    case GL_FLOAT_VEC3_ARB:
+                        glUniform3fvARB( pi->location, 1, cval->vec3.xyz );
+                        break;
+
+                    //case GL_FLOAT_VEC4_ARB:
+
+                    case GL_INT:
+                    case GL_BOOL_ARB:
+                        glUniform1iARB( pi->location, ur_int(cval) );
+                        break;
+
+                    case GL_INT_VEC2_ARB:
+                        glUniform2iARB( pi->location,
+                                        cval->coord.elem[0],
+                                        cval->coord.elem[1] );
+                        break;
+
+                    case GL_INT_VEC3_ARB:
+                        glUniform3iARB( pi->location,
+                                        cval->coord.elem[0],
+                                        cval->coord.elem[1],
+                                        cval->coord.elem[2] );
+                        break;
+
+                    //case GL_INT_VEC4_ARB:
+                }
+                ++pi;
+            }
+            /*
+            glUniform1fARB( loc_specularCoeff, specular_coefficient );
+            */
+
+            return;
+        }
+    }
+    else if( ur_is(cell, UT_SHADER) )
     {
         Shader* sh = (Shader*) ur_bufPtr( cell->series.n )->ptr;
         glUseProgramObjectARB( sh->program );
-    }
-    else
-    {
-        glUseProgramObjectARB( 0 );
-    }
-    /*
-    glUniform3fvARB( loc_lightDirOS, 1, &lightDir.x );
-    glUniform1fARB( loc_specularCoeff, specular_coefficient );
-    */
+        return;
+    }
+
+    glUseProgramObjectARB( 0 );
 }
 

trunk/thune/gl/test.t

@@ -43 +43 @@
 
 
-"data/d7.gx" load draw-list.compile :d7-list
-"data/test-shader.gx" load do
-
+[load shader! swap make] proc :load.shader   ; (file -- shader)
+
+"data/model/d7.gx" load draw-list.compile :d7-list
+
+"data/shader/brick.gx"
+;"data/shader/testA.gx"
+    load.shader :test-shader
+
+test-shader context! is-type? ift (
+    1.0, 0.3, 0.2 :test-shader/brickcolor
+    0.9, 0.85     :test-shader/brickpct
+    1.0, 0.5      :test-shader/bricksize
+    0.8, 0.8, 0.8 :test-shader/mortarcolor
+)
+;test-shader .
 
 0,0,0 :strobe
@@ -292 +304 @@
 
 
-font! ["data/20thfont.ttf" 22] make :fontA
-font! ["data/FederationBold_KR.ttf" 12 256,128] make :fontF
+font! ["data/font/20thfont.ttf" 22] make :fontA
+font! ["data/font/FederationBold_KR.ttf" 12 256,128] make :fontF
 
 0,0,155 display.swap