[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [11141] branches/soc-2007-maike/source/ blender/src: Added spot light and area light

Miguel Torres Lima torreslima at gmail.com
Mon Jul 2 13:29:01 CEST 2007


Revision: 11141
          http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=11141
Author:   maike
Date:     2007-07-02 13:29:01 +0200 (Mon, 02 Jul 2007)

Log Message:
-----------
Added spot light and area light

Modified Paths:
--------------
    branches/soc-2007-maike/source/blender/src/glsl_drawobject.c
    branches/soc-2007-maike/source/blender/src/glsl_light.c
    branches/soc-2007-maike/source/blender/src/glsl_material.c
    branches/soc-2007-maike/source/blender/src/glsl_material_node.c
    branches/soc-2007-maike/source/blender/src/glsl_node_util.c
    branches/soc-2007-maike/source/blender/src/glsl_program.c

Modified: branches/soc-2007-maike/source/blender/src/glsl_drawobject.c
===================================================================
--- branches/soc-2007-maike/source/blender/src/glsl_drawobject.c	2007-07-02 07:42:18 UTC (rev 11140)
+++ branches/soc-2007-maike/source/blender/src/glsl_drawobject.c	2007-07-02 11:29:01 UTC (rev 11141)
@@ -48,62 +48,268 @@
 static float selected_color[4] = { -1, -1, -1 };
 
 
-void light_uniforms(GLuint program, Object *obj)
+void glsl_runtime_lamp_uniforms(Lamp *lamp, Object *obj, Object *lamp_obj, int num, GLuint program)
 {
-  GLSL_List list = glsl_get_lights();
-  int i;
+  char *loc = glsl_string(3, 0, "lights[", GINT, num, 0, "].loc");
+  char *layer = glsl_string(3, 0, "lights[", GINT, num, 0, "].layer");
+  char *eye = glsl_string(1, 0, "eye");
+  
+  float vect[3] = { lamp_obj->obmat[3][0], 
+		    lamp_obj->obmat[3][1], 
+		    lamp_obj->obmat[3][2] };
+  
+  glUniform3f(glsl_uniform_location(program, eye), G.vd->dist * G.vd->viewinv[2][0],  G.vd->dist * G.vd->viewinv[2][1],  G.vd->dist * G.vd->viewinv[2][2]);
+  
+  Mat4MulVecfl(G.vd->viewmat, vect);
+  glUniform3fv(glsl_uniform_location(program, loc), 1, vect);
+  
+  if(obj->lay & lamp_obj->lay || !(lamp->mode & LA_LAYER))
+    glUniform1i(glsl_uniform_location(program, layer), 1);
+  else
+    glUniform1i(glsl_uniform_location(program, layer), 0);
+ 
+  MEM_freeN(loc);
+  MEM_freeN(layer);
+  MEM_freeN(eye);
+}
 
-  for(i = 0; list; list = list->next, i++){
-    GLSL_Light light = (struct GLSL_Light_ *) list->data;
-    char *loc = glsl_string(3, 0, "lights[", GINT, i, 0, "].loc");
-    char *vec = glsl_string(3, 0, "lights[", GINT, i, 0, "].vec");
-    char *layer = glsl_string(3, 0, "lights[", GINT, i, 0, "].layer");
-    char *eye = glsl_string(1, 0, "eye");
-    Lamp *lamp = light->blen_light;
-    Object *lamp_obj = light->obj;
 
-    float vect[3] = { lamp_obj->obmat[3][0], 
-		      lamp_obj->obmat[3][1], 
-		      lamp_obj->obmat[3][2] };
-    float mat[4][4];
-    float vecc[3];
-    float eyevec[3] = { 0,0,0 };
+void glsl_runtime_spot_uniforms(Lamp *lamp, Object *obj, Object *lamp_obj, int num, GLuint program)
+{
+  char *loc = glsl_string(3, 0, "lights[", GINT, num, 0, "].loc");
+  char *vec = glsl_string(3, 0, "lights[", GINT, num, 0, "].vec");
+  char *layer = glsl_string(3, 0, "lights[", GINT, num, 0, "].layer");
+  char *eye = glsl_string(1, 0, "eye");
+  char *matr = glsl_string(3, 0, "lights[", GINT, num, 0, "].mat");
 
-    glUniform3f(glsl_uniform_location(program, eye), eyevec[0], eyevec[1], eyevec[2] );
-		
+  float vect[3] = { lamp_obj->obmat[3][0], 
+		    lamp_obj->obmat[3][1], 
+		    lamp_obj->obmat[3][2] };
+  float mat[4][4];
+  float vecc[3];
 
-		/*G.vd->dist * G.vd->viewinv[2][0], 
-		G.vd->dist * G.vd->viewinv[2][1], 
-		G.vd->dist * G.vd->viewinv[2][2]);*/
+  glUniform3f(glsl_uniform_location(program, eye), G.vd->dist * G.vd->viewinv[2][0], G.vd->dist * G.vd->viewinv[2][1], G.vd->dist * G.vd->viewinv[2][2]);
 
 
-    Mat4MulVecfl(G.vd->viewmat, vect);
+  Mat4MulVecfl(G.vd->viewmat, vect);
+  glUniform3fv(glsl_uniform_location(program, loc), 1, vect);
   
-    glUniform3fv(glsl_uniform_location(program, loc), 1, vect);
+  Mat4MulMat4(mat, lamp_obj->obmat, G.vd->viewmat);
+  vecc[0] = -mat[2][0];
+  vecc[1] = -mat[2][1];
+  vecc[2] = -mat[2][2];      
+  Normalize(vecc);
+    
+  glUniform3fv(glsl_uniform_location(program, vec), 1, vecc);
 
-    Mat4MulMat4(mat, lamp_obj->obmat, G.vd->viewmat);
-    vecc[0] = mat[2][0];
-    vecc[1] = mat[2][1];
-    vecc[2] = mat[2][2];      
+  glUniformMatrix4fv(glsl_uniform_location(program, matr), 1, 0, (GLfloat *) lamp_obj->imat);
+  if(obj->lay & lamp_obj->lay || !(lamp->mode & LA_LAYER))
+    glUniform1i(glsl_uniform_location(program, layer), 1);
+  else
+    glUniform1i(glsl_uniform_location(program, layer), 0);
+  
+  MEM_freeN(loc);
+  MEM_freeN(vec);
+  MEM_freeN(layer);
+  MEM_freeN(eye);  
+  MEM_freeN(matr);
+}
 
-    glUniform3fv(glsl_uniform_location(program, vec), 1, vecc);
 
- 
-    if(obj->lay & lamp_obj->lay || !(lamp->mode & LA_LAYER)){
-      glUniform1i(glsl_uniform_location(program, layer), 1);
-    } 
-    else{
-      glUniform1i(glsl_uniform_location(program, layer), 0);
+void glsl_runtime_area_uniforms(Lamp *lamp, Object *obj, Object *lamp_obj, int num, GLuint program)
+{
+  char *loc = glsl_string(3, 0, "lights[", GINT, num, 0, "].loc");
+  char *vec = glsl_string(3, 0, "lights[", GINT, num, 0, "].vec");
+  char *layer = glsl_string(3, 0, "lights[", GINT, num, 0, "].layer");
+  char *eye = glsl_string(1, 0, "eye");
+  
+  float vect[3] = { lamp_obj->obmat[3][0], 
+		    lamp_obj->obmat[3][1], 
+		    lamp_obj->obmat[3][2] };
+  float mat[4][4];
+  float vecc[3];
+
+
+  glUniform3f(glsl_uniform_location(program, eye), G.vd->dist * G.vd->viewinv[2][0], G.vd->dist * G.vd->viewinv[2][1], G.vd->dist * G.vd->viewinv[2][2]);
+
+  Mat4MulVecfl(G.vd->viewmat, vect);
+  glUniform3fv(glsl_uniform_location(program, loc), 1, vect);
+
+  Mat4MulMat4(mat, lamp_obj->obmat, G.vd->viewmat);
+  vecc[0] = -mat[2][0];
+  vecc[1] = -mat[2][1];
+  vecc[2] = -mat[2][2];
+  Normalize(vecc);
+
+  glUniform3fv(glsl_uniform_location(program, vec), 1, vecc);
+
+  glsl_area_lamp_vectors(lamp, obj, lamp_obj, num, program);
+  
+  if(obj->lay & lamp_obj->lay || !(lamp->mode & LA_LAYER))
+    glUniform1i(glsl_uniform_location(program, layer), 1);
+  else
+    glUniform1i(glsl_uniform_location(program, layer), 0);
+  
+  MEM_freeN(loc);
+  MEM_freeN(vec);
+  MEM_freeN(layer);
+  MEM_freeN(eye);
+}
+
+
+void glsl_area_lamp_vectors(Lamp *lamp, Object *obj, Object *lamp_obj, int num, GLuint program)
+{
+  char *areac     = glsl_string(3, 0, "lights[", GINT, num, 0, "].mat");
+  char *areasizec = glsl_string(3, 0, "lights[", GINT, num, 0, "].areasize");
+  char *kc        = glsl_string(3, 0, "lights[", GINT, num, 0, "].k");
+
+  float mat[4][4];
+  float area[4][4];
+  float xsize;
+  float ysize;
+  float areasize;
+  int i;
+
+  MTC_Mat4MulMat4(mat, lamp_obj->obmat, G.vd->viewmat);
+
+  switch(lamp->area_shape)
+    {
+    case LA_AREA_SQUARE:
+      xsize = 0.5 * MAX2(lamp->area_size, 0.5);
+      ysize = xsize;
+      break;
+    case LA_AREA_RECT:
+      xsize = 0.5 * MAX2(lamp->area_size, 0.5);
+      ysize = 0.5 * MAX2(lamp->area_sizey, 0.5);
+      break;
     }
 
-    MEM_freeN(loc);
-    MEM_freeN(vec);
-    MEM_freeN(layer);
-    MEM_freeN(eye);
+
+  for(i = 0; i < 3; i++){
+    area[0][i] = mat[3][i] - xsize * mat[0][i] - ysize * mat[1][i];
+    area[1][i] = mat[3][i] - xsize * mat[0][i] + ysize * mat[1][i];
+    area[2][i] = mat[3][i] + xsize * mat[0][i] + ysize * mat[1][i];
+    area[3][i] = mat[3][i] + xsize * mat[0][i] - ysize * mat[1][i];
   }
+  
+  areasize = lamp->dist * lamp->dist / (4.0 * xsize * ysize);
+ 
+  glUniformMatrix4fv(glsl_uniform_location(program, areac), 1, 0, (GLfloat *) area);
+  glUniform1f(glsl_uniform_location(program, areasizec), areasize);
+  glUniform1f(glsl_uniform_location(program, kc), lamp->k);
+  
+  MEM_freeN(areac);
+  MEM_freeN(areasizec);
+  MEM_freeN(kc);
 }
 
 
+void glsl_runtime_sun_uniforms(Lamp *lamp, Object *obj, Object *lamp_obj, int num, GLuint program)
+{
+  char *loc = glsl_string(3, 0, "lights[", GINT, num, 0, "].loc");
+  char *vec = glsl_string(3, 0, "lights[", GINT, num, 0, "].vec");
+  char *layer = glsl_string(3, 0, "lights[", GINT, num, 0, "].layer");
+  char *eye = glsl_string(1, 0, "eye");
+
+  float vect[3] = { lamp_obj->obmat[3][0], 
+		    lamp_obj->obmat[3][1], 
+		    lamp_obj->obmat[3][2] };
+  float mat[4][4];
+  float vecc[3];
+ 
+  glUniform3f(glsl_uniform_location(program, eye), G.vd->dist * G.vd->viewinv[2][0], G.vd->dist * G.vd->viewinv[2][1], G.vd->dist * G.vd->viewinv[2][2]);
+
+  Mat4MulVecfl(G.vd->viewmat, vect);
+  glUniform3fv(glsl_uniform_location(program, loc), 1, vect);
+
+  Mat4MulMat4(mat, lamp_obj->obmat, G.vd->viewmat);
+  vecc[0] = mat[2][0];
+  vecc[1] = mat[2][1];
+  vecc[2] = mat[2][2];      
+
+  glUniform3fv(glsl_uniform_location(program, vec), 1, vecc);
+ 
+  if(obj->lay & lamp_obj->lay || !(lamp->mode & LA_LAYER))
+    glUniform1i(glsl_uniform_location(program, layer), 1);
+  else
+    glUniform1i(glsl_uniform_location(program, layer), 0);
+  
+  MEM_freeN(loc);
+  MEM_freeN(vec);
+  MEM_freeN(layer);
+  MEM_freeN(eye);
+}
+
+
+void glsl_runtime_hemi_uniforms(Lamp *lamp, Object *obj, Object *lamp_obj, int num, GLuint program)
+{
+  char *loc = glsl_string(3, 0, "lights[", GINT, num, 0, "].loc");
+  char *vec = glsl_string(3, 0, "lights[", GINT, num, 0, "].vec");
+  char *layer = glsl_string(3, 0, "lights[", GINT, num, 0, "].layer");
+  char *eye = glsl_string(1, 0, "eye");
+  
+  float vect[3] = { lamp_obj->obmat[3][0], 
+		    lamp_obj->obmat[3][1], 
+		    lamp_obj->obmat[3][2] };
+  float mat[4][4];
+  float vecc[3];
+  
+  glUniform3f(glsl_uniform_location(program, eye), G.vd->dist * G.vd->viewinv[2][0], G.vd->dist * G.vd->viewinv[2][1], G.vd->dist * G.vd->viewinv[2][2]);
+
+  Mat4MulVecfl(G.vd->viewmat, vect);
+  glUniform3fv(glsl_uniform_location(program, loc), 1, vect);
+
+  Mat4MulMat4(mat, lamp_obj->obmat, G.vd->viewmat);
+  vecc[0] = mat[2][0];
+  vecc[1] = mat[2][1];
+  vecc[2] = mat[2][2];      
+
+  glUniform3fv(glsl_uniform_location(program, vec), 1, vecc);
+
+  if(obj->lay & lamp_obj->lay || !(lamp->mode & LA_LAYER))
+    glUniform1i(glsl_uniform_location(program, layer), 1);
+  else
+    glUniform1i(glsl_uniform_location(program, layer), 0);
+
+  MEM_freeN(loc);
+  MEM_freeN(vec);
+  MEM_freeN(layer);
+  MEM_freeN(eye);
+}
+
+
+void glsl_light_uniforms(GLuint program, Object *obj)
+{
+  GLSL_List list = glsl_get_lights();
+  int i;
+
+  for(i = 0; list; list = list->next, i++){
+    GLSL_Light light = (struct GLSL_Light_ *) list->data;
+    Lamp *lamp = light->blen_light;
+    Object *lamp_obj = light->obj;
+
+    switch(lamp->type)
+      {
+      case LA_LOCAL:
+	glsl_runtime_lamp_uniforms(lamp, obj, lamp_obj, i, program);
+	break;
+      case LA_SPOT:
+	glsl_runtime_spot_uniforms(lamp, obj, lamp_obj, i, program);
+	break;
+      case LA_AREA:
+	glsl_runtime_area_uniforms(lamp, obj, lamp_obj, i, program);
+	break;
+      case LA_SUN:
+	glsl_runtime_sun_uniforms(lamp, obj, lamp_obj, i, program);
+	break;
+      case LA_HEMI:
+	glsl_runtime_hemi_uniforms(lamp, obj, lamp_obj, i, program);
+	break;
+      }
+  }
+}
+
+
 void create_vertex(Object *obj, MVert *vert, int index, int flag)
 {
   if(flag & ME_SMOOTH){
@@ -161,19 +367,18 @@
       if(G.vd->drawtype == OB_SHADED){

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list