---

vmdsphere.frag

Go to the documentation of this file.

/***************************************************************************
 *cr
 *cr            (C) Copyright 1995-2011 The Board of Trustees of the
 *cr                        University of Illinois
 *cr                         All Rights Reserved
 *cr
 ***************************************************************************/
/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: vmdsphere.frag,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.36 $       $Date: 2020/02/24 21:25:51 $
 *
 ***************************************************************************/

#version 110

#define FASTONESIDEDSPHERES     1

//
// Fragment shader varying and uniform variable definitions for data 
// supplied by VMD and/or the vertex shader
//
varying vec3 oglcolor;        
varying vec3 V;               
varying vec3 spherepos;       
varying vec3 rayorigin;       
varying float sphereradsq;    

uniform vec3 vmdlight0;       
uniform vec3 vmdlight1;       
uniform vec3 vmdlight2;       
uniform vec3 vmdlight3;       

uniform vec3 vmdlight0H;      
uniform vec3 vmdlight1H;      
uniform vec3 vmdlight2H;      
uniform vec3 vmdlight3H;      

uniform vec4 vmdlightscale;   






uniform vec4 vmdmaterial;     





uniform int vmdprojectionmode;
uniform vec4 vmdprojparms;    





uniform float vmdopacity;     

uniform float vmdoutline;     
uniform float vmdoutlinewidth;
uniform int vmdtransmode;     
uniform int vmdfogmode;       
uniform int vmdtexturemode;   
uniform sampler3D vmdtex0;    


void main(void) {
  vec3 raydir = normalize(V);
  vec3 spheredir = spherepos - rayorigin;
   
  //
  // Perform ray-sphere intersection tests based on the code in Tachyon
  //
  float b = dot(raydir, spheredir);
  float disc = b*b + sphereradsq - dot(spheredir, spheredir);

#if defined(FASTONESIDEDSPHERES)
  // only calculate the nearest intersection, for speed
  if (disc <= 0.0)
    discard; // ray missed sphere entirely, discard fragment

  // calculate closest intersection
  float tnear = b - sqrt(disc);

  if (tnear < 0.0)
    discard;
#else
  // calculate and sort both intersections
  if (disc <= 0.0)
    discard; // ray missed sphere entirely, discard fragment

  disc = sqrt(disc);

  // calculate farthest intersection
  float t2 = b + disc;
  if (t2 <= 0.0)
    discard; // farthest intersection is behind the eye, discard fragment

  // calculate closest intersection
  float t1 = b - disc;

  // select closest intersection in front of the eye
  float tnear;
  if (t1 > 0.0)
    tnear = t1;
  else
    tnear = t2;
#endif

  // calculate hit point and resulting surface normal
  vec3 pnt = rayorigin + tnear * raydir;
  vec3 N = normalize(pnt - spherepos);

  // Output the ray-sphere intersection point as the fragment depth 
  // rather than the depth of the bounding box polygons.
  // The eye coordinate Z value must be transformed to normalized device 
  // coordinates before being assigned as the final fragment depth.
  if (vmdprojectionmode == 1) {
    // perspective projection = 0.5 + (hfpn + (f * n / pnt.z)) / diff
    gl_FragDepth = 0.5 + (vmdprojparms[2] + (vmdprojparms[1] * vmdprojparms[0] / pnt.z)) * vmdprojparms[3];
  } else {
    // orthographic projection = 0.5 + (-hfpn - pnt.z) / diff
    gl_FragDepth = 0.5 + (-vmdprojparms[2] - pnt.z) * vmdprojparms[3];
  }

  // Done with ray-sphere intersection test and normal calculation
  // beginning of shading calculations
  float ambient = vmdmaterial[0];   // ambient
  float diffuse = 0.0;
  float specular = 0.0;
  float shininess = vmdmaterial[3]; // shininess 
  vec3 objcolor = oglcolor;         // default if texturing is disabled

  // perform texturing operations for volumetric data
  // The only texturing mode that applies to the sphere shader
  // is the GL_MODULATE texturing mode with texture coordinate generation.
  // The other texturing mode is never encountered in the sphere shader.
  // Note: texsture fetches cannot occur earlier than this point since we
  // don't know the fragment depth until this poing.
  if (vmdtexturemode == 1) {
    // emulate GL_MODULATE
    // The 3-D texture coordinates must be updated based
    // on the eye coordinate of the ray-sphere intersection in this case
    vec3 spheretexcoord;
    vec4 specpos = vec4(pnt, 1.0);
    spheretexcoord.s = dot(specpos, gl_EyePlaneS[0]);
    spheretexcoord.t = dot(specpos, gl_EyePlaneT[0]);
    spheretexcoord.p = dot(specpos, gl_EyePlaneR[0]);
    objcolor = oglcolor * vec3(texture3D(vmdtex0, spheretexcoord));
  }

  // calculate diffuse lighting contribution
  diffuse += max(0.0, dot(N, vmdlight0)) * vmdlightscale[0];
  diffuse += max(0.0, dot(N, vmdlight1)) * vmdlightscale[1];
  diffuse += max(0.0, dot(N, vmdlight2)) * vmdlightscale[2];
  diffuse += max(0.0, dot(N, vmdlight3)) * vmdlightscale[3];
  diffuse *= vmdmaterial[1]; // diffuse scaling factor

  // compute edge outline if enabled
  if (vmdoutline > 0.0) {
    float edgefactor = dot(N,V);
    edgefactor = 1.0 - (edgefactor*edgefactor);
    edgefactor = 1.0 - pow(edgefactor, (1.0-vmdoutlinewidth)*32.0);
    diffuse = mix(diffuse, diffuse * edgefactor, vmdoutline);
  }

  // Calculate specular lighting contribution with Phong highlights, based
  // on Blinn's halfway vector variation of Phong highlights
  specular += pow(max(0.0, dot(N, vmdlight0H)), shininess) * vmdlightscale[0];
  specular += pow(max(0.0, dot(N, vmdlight1H)), shininess) * vmdlightscale[1];
  specular += pow(max(0.0, dot(N, vmdlight2H)), shininess) * vmdlightscale[2];
  specular += pow(max(0.0, dot(N, vmdlight3H)), shininess) * vmdlightscale[3];
  specular *= vmdmaterial[2]; // specular scaling factor

  // Fog computations
  const float Log2E = 1.442695; // = log2(2.718281828)
  float fog = 1.0;
  if (vmdfogmode == 1) {
    // linear fog
    fog = (gl_Fog.end - gl_FogFragCoord) * gl_Fog.scale;
  } else if (vmdfogmode == 2) {
    // exponential fog
    fog = exp2(-gl_Fog.density * gl_FogFragCoord * Log2E);
  } else if (vmdfogmode == 3) {
    // exponential-squared fog
    fog = exp2(-gl_Fog.density * gl_Fog.density * gl_FogFragCoord * gl_FogFragCoord * Log2E);
  }
  fog = clamp(fog, 0.0, 1.0);       // clamp the final fog parameter [0->1)

  vec3 color = objcolor * vec3(diffuse) + vec3(ambient + specular);

  float alpha = vmdopacity;
  
  // Emulate Raster3D's angle-dependent surface opacity if enabled
  if (vmdtransmode==1) {
    alpha = 1.0 + cos(3.1415926 * (1.0-alpha) * dot(N,V));
    alpha = alpha*alpha * 0.25;
  }

  gl_FragColor = vec4(mix(vec3(gl_Fog.color), color, fog), alpha);
}

---