Source/System/State/Shader/Chunks/testSHLBumpMapDefAttr_shaderprog.cpp

   1 // OpenSG example: testSHL
   2 //
   3 // Demonstrates the use of the SHLChunk
   4 // Implements a simple bumpmapping via vertex and fragment shader.
   5
   6 // Headers
   7 #include "OSGGLUT.h"
   8 #include "OSGConfig.h"
   9
  10 #include "OSGSimpleGeometry.h"
  11 #include "OSGGLUT.h"
  12 #include "OSGGLUTWindow.h"
  13 #include "OSGSimpleSceneManager.h"
  14 #include "OSGAction.h"
  15 #include "OSGSceneFileHandler.h"
  16 #include "OSGBaseFunctions.h"
  17
  18 #include "OSGNode.h"
  19 #include "OSGGroup.h"
  20 #include "OSGTransform.h"
  21 #include "OSGPointLight.h"
  22
  23 #include "OSGImage.h"
  24 #include "OSGChunkMaterial.h"
  25 #include "OSGMaterialChunk.h"
  26 #include "OSGTextureObjChunk.h"
  27 #include "OSGTextureEnvChunk.h"
  28 #include "OSGShaderProgramChunk.h"
  29 #include "OSGShaderProgram.h"
  30
  31 // vertex shader program for bump mapping in surface local coordinates
  32 static std::string _vp_program =
  33 "varying vec3 lightDir;    // interpolated surface local coordinate light direction\n"
  34 "varying vec3 viewDir;     // interpolated surface local coordinate view direction\n"
  35 ""
  36 "attribute vec3 osg_Normal;\n"
  37 "attribute vec2 osg_MultiTexCoord0;\n"
  38 "attribute vec3 osg_Vertex;\n"
  39 ""
  40 "void main(void)\n"
  41 "{\n"
  42 "    // Do standard vertex stuff\n"
  43
  44 "    gl_Position  = gl_ModelViewProjectionMatrix * vec4(osg_Vertex, 1.0);\n"
  45 "    gl_TexCoord[0] = vec4(osg_MultiTexCoord0, 0.0, 0.0);\n"
  46
  47 "    // Compute the binormal\n"
  48
  49 "    vec3 n = normalize(gl_NormalMatrix * osg_Normal);\n"
  50 "    //vec3 t = normalize(gl_NormalMatrix * vec3 (gl_Color));\n"
  51 "    vec3 t = normalize(cross(vec3(1.141, 2.78, 3.14), n));\n"
  52 "    vec3 b = cross(n, t);\n"
  53
  54 "    // Transform light position into surface local coordinates\n"
  55
  56 "    vec3 LightPosition = gl_LightSource[0].position.xyz;\n"
  57
  58 "    vec3 v;\n"
  59 "    v.x = dot(LightPosition, t);\n"
  60 "    v.y = dot(LightPosition, b);\n"
  61 "    v.z = dot(LightPosition, n);\n"
  62
  63 "    lightDir = normalize(v);\n"
  64
  65 "    vec3 pos      = vec3 (gl_ModelViewMatrix * vec4(osg_Vertex, 1.0));\n"
  66
  67 "    v.x = dot(pos, t);\n"
  68 "    v.y = dot(pos, b);\n"
  69 "    v.z = dot(pos, n);\n"
  70
  71 "    viewDir = normalize(v);\n"
  72 "\n"
  73 "}\n";
  74
  75 // fragment shader program for bump mapping in surface local coordinates
  76 static std::string _fp_program =
  77 "uniform sampler2D sampler2d; // value of sampler2d = 3\n"
  78 "varying vec3 lightDir;       // interpolated surface local coordinate light direction\n"
  79 "varying vec3 viewDir;        // interpolated surface local coordinate view direction\n"
  80
  81 "const float diffuseFactor  = 0.7;\n"
  82 "const float specularFactor = 0.7;\n"
  83 "vec3 basecolor = vec3 (0.8, 0.7, 0.3);\n"
  84
  85 "void main (void)\n"
  86 "{\n"
  87 "    vec3 norm;\n"
  88 "    vec3 r;\n"
  89 "    vec3 color;\n"
  90 "    float intensity;\n"
  91 "    float spec;\n"
  92 "    float d;\n"
  93 "    // Fetch normal from normal map\n"
  94 "    norm = vec3(texture2D(sampler2d, vec2 (gl_TexCoord[0])));\n"
  95 "    norm = (norm - 0.5) * 2.0;\n"
  96 "    norm.y = -norm.y;\n"
  97 "    intensity = max(dot(lightDir, norm), 0.0) * diffuseFactor;\n"
  98 "    // Compute specular reflection component\n"
  99 "    d = 2.0 * dot(lightDir, norm);\n"
 100 "    r = d * norm;\n"
 101 "    r = lightDir - r;\n"
 102 "    spec = pow(max(dot(r, viewDir), 0.0) , 6.0) * specularFactor;\n"
 103 "    intensity += min (spec, 1.0);\n"
 104 "     // Compute final color value\n"
 105 "    color = clamp(basecolor * intensity, 0.0, 1.0);\n"
 106 "    // Write out final fragment color\n"
 107 "    gl_FragColor = vec4 (color, 1.0);\n"
 108 "\n"
 109 "}\n";
 110
 111
 112
 113 // ------------------- global vars ----------------------
 114 //
 115 // The SimpleSceneManager to manage simple applications
 116 static OSG::SimpleSceneManagerRefPtr _mgr;
 117 // The scene
 118 static OSG::NodeRecPtr _scene;
 119
 120 // forward declaration so we can have the interesting stuff upfront
 121 int setupGLUT( int *argc, char *argv[] );
 122
 123 // Initialize GLUT & OpenSG and set up the scene
 124 int doMain(int argc, char **argv)
 125 {
 126     printf("Usage: testCGShader [normal map filename]\n");
 127     const char *normal_map_img_name = "opensg_logoDOT3.png";
 128
 129     OSG::Color4f tmp;
 130
 131     if( argc > 1 )
 132         normal_map_img_name = argv[1];
 133
 134     // OSG init
 135     OSG::osgInit(argc,argv);
 136
 137     // GLUT init
 138     int winid = setupGLUT(&argc, argv);
 139
 140     // the connection between GLUT and OpenSG
 141     OSG::GLUTWindowUnrecPtr gwin= OSG::GLUTWindow::create();
 142     gwin->setGlutId(winid);
 143     gwin->setSize( 800, 800 );
 144     gwin->init();
 145
 146     // Create the shader material
 147
 148     // Read the image for the normal texture
 149     OSG::ImageUnrecPtr normal_map_img = OSG::Image::create();
 150     if(!normal_map_img->read(normal_map_img_name))
 151     {
 152         fprintf(stderr, "Couldn't read normalmap texture '%s'!\n", normal_map_img_name);
 153         return 1;
 154     }
 155
 156     OSG::ChunkMaterialUnrecPtr cmat = OSG::ChunkMaterial::create();
 157
 158     OSG::MaterialChunkUnrecPtr matc = OSG::MaterialChunk::create();
 159
 160     matc->setAmbient(OSG::Color4f(0.1, 0.1, 0.1, 1.0));
 161     matc->setDiffuse(OSG::Color4f(0.3, 0.3, 0.3, 1.0));
 162     matc->setSpecular(OSG::Color4f(0.8, 0.8, 0.8, 1.0));
 163     matc->setShininess(100);
 164     matc->setLit(true);
 165
 166     OSG::ShaderProgramChunkUnrecPtr shl = OSG::ShaderProgramChunk::create();
 167
 168     OSG::ShaderProgramUnrecPtr shl_vp =
 169         OSG::ShaderProgram::createVertexShader(true);
 170
 171     shl_vp->setProgram(_vp_program);
 172
 173     shl->addShader(shl_vp);
 174
 175     OSG::ShaderProgramUnrecPtr shl_fp =
 176         OSG::ShaderProgram::createFragmentShader();
 177
 178     shl_fp->setProgram(_fp_program);
 179
 180     shl->addShader(shl_fp);
 181
 182
 183     OSG::TextureObjChunkUnrecPtr tex_normal_map     =
 184         OSG::TextureObjChunk::create();
 185     OSG::TextureEnvChunkUnrecPtr tex_normal_map_env =
 186         OSG::TextureEnvChunk::create();
 187
 188     tex_normal_map->setImage(normal_map_img);
 189     tex_normal_map->setMinFilter(GL_LINEAR_MIPMAP_LINEAR);
 190     tex_normal_map->setMagFilter(GL_LINEAR);
 191     tex_normal_map->setWrapS(GL_REPEAT);
 192     tex_normal_map->setWrapT(GL_REPEAT);
 193     tex_normal_map_env->setEnvMode(GL_MODULATE);
 194
 195         //cmat->addChunk(matc);
 196     cmat->addChunk(shl);
 197     cmat->addChunk(tex_normal_map);
 198     cmat->addChunk(tex_normal_map_env);
 199
 200
 201     // create root node
 202     _scene = OSG::Node::create();
 203
 204     // create geometry
 205     //GeometryPtr geo = makeLatLongSphereGeo (100, 100, 1.0);
 206     OSG::GeometryUnrecPtr geo = OSG::makePlaneGeo(1.0, 1.0, 100, 100);
 207
 208     geo->setMaterial(cmat);
 209
 210     OSG::NodeUnrecPtr torus = OSG::Node::create();
 211     torus->setCore(geo);
 212
 213     // add torus to scene
 214     OSG::GroupUnrecPtr group = OSG::Group::create();
 215
 216     _scene->setCore(group);
 217     _scene->addChild(torus);
 218
 219     // create the SimpleSceneManager helper
 220     _mgr = OSG::SimpleSceneManager::create();
 221
 222     // tell the manager what to manage
 223     _mgr->setWindow(gwin );
 224     _mgr->setRoot(_scene);
 225
 226     // show the whole scene
 227     _mgr->showAll();
 228
 229     return 0;
 230 }
 231
 232 int main(int argc, char **argv)
 233 {
 234     doMain(argc, argv);
 235
 236     // GLUT main loop
 237     glutMainLoop();
 238
 239     return 0;
 240 }
 241
 242 //
 243 // GLUT callback functions
 244 //
 245
 246 // redraw the window
 247 void display(void)
 248 {
 249   // render scene
 250   _mgr->redraw();
 251 }
 252
 253 // react to size changes
 254 void reshape(int w, int h)
 255 {
 256     _mgr->resize(w, h);
 257     glutPostRedisplay();
 258 }
 259
 260 // react to mouse button presses
 261 void mouse(int button, int state, int x, int y)
 262 {
 263     if (state)
 264         _mgr->mouseButtonRelease(button, x, y);
 265     else
 266         _mgr->mouseButtonPress(button, x, y);
 267
 268     glutPostRedisplay();
 269 }
 270
 271 // react to mouse motions with pressed buttons
 272 void motion(int x, int y)
 273 {
 274     _mgr->mouseMove(x, y);
 275     glutPostRedisplay();
 276 }
 277
 278 // react to keys
 279 void keyboard(unsigned char k, int x, int y)
 280 {
 281     switch(k)
 282     {
 283         case 27:
 284         case 'q':
 285
 286             _mgr   = NULL;
 287             _scene = NULL;
 288
 289             OSG::osgExit();
 290             exit(1);
 291         break;
 292         case 'w':
 293             OSG::SceneFileHandler::the()->write(_scene, "scene.osb.gz", true);
 294             printf("wrote scene.osb.gz\n");
 295         break;
 296     }
 297
 298     glutPostRedisplay();
 299 }
 300
 301 // setup the GLUT library which handles the windows for us
 302 int setupGLUT(int *argc, char *argv[])
 303 {
 304     glutInit(argc, argv);
 305     glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
 306
 307     int winid = glutCreateWindow("OpenSG CG Shader");
 308
 309     glutReshapeFunc(reshape);
 310     glutDisplayFunc(display);
 311     glutMouseFunc(mouse);
 312     glutMotionFunc(motion);
 313     glutKeyboardFunc(keyboard);
 314
 315     return winid;
 316 }