diff options
Diffstat (limited to 'shaders')
| -rw-r--r-- | shaders/pts/paraview-1.0.3/many-spheres/15.shader_test | 260 | ||||
| -rw-r--r-- | shaders/pts/paraview-1.0.3/many-spheres/6.shader_test | 297 | ||||
| -rw-r--r-- | shaders/pts/paraview-1.0.3/many-spheres/9.shader_test | 862 | ||||
| -rw-r--r-- | shaders/pts/paraview-1.0.3/wavelet-volume/6.shader_test | 627 | ||||
| -rw-r--r-- | shaders/pts/paraview-1.0.3/wavelet-volume/9.shader_test | 240 |
5 files changed, 2286 insertions, 0 deletions
diff --git a/shaders/pts/paraview-1.0.3/many-spheres/15.shader_test b/shaders/pts/paraview-1.0.3/many-spheres/15.shader_test new file mode 100644 index 0000000..69b741d --- /dev/null +++ b/shaders/pts/paraview-1.0.3/many-spheres/15.shader_test @@ -0,0 +1,260 @@ +[require] +GLSL >= 1.50 + +[vertex shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define attribute in +#define varying out +#endif // 300 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define attribute in +#define varying out +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: vtkPolyDataVS.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ + +attribute vec4 vertexMC; + +// frag position in VC +varying vec4 vertexVCVSOutput; + +// optional normal declaration +//VTK::Normal::Dec + +// extra lighting parameters +//VTK::Light::Dec + +// Texture coordinates +//VTK::TCoord::Dec + +// material property values +//VTK::Color::Dec + +// clipping plane vars +//VTK::Clip::Dec + +// camera and actor matrix values +uniform mat4 MCDCMatrix; +uniform mat4 MCVCMatrix; + +// Apple Bug +//VTK::PrimID::Dec + +// Value raster +//VTK::ValuePass::Dec + +void main() +{ + //VTK::Color::Impl + + //VTK::Normal::Impl + + //VTK::TCoord::Impl + + //VTK::Clip::Impl + + //VTK::PrimID::Impl + + vertexVCVSOutput = MCVCMatrix * vertexMC; + gl_Position = MCDCMatrix * vertexMC; + + + //VTK::ValuePass::Impl + + //VTK::Light::Impl +} + + +[fragment shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define varying in +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +precision highp sampler2D; +precision highp sampler3D; +#else +precision mediump float; +precision mediump sampler2D; +precision mediump sampler3D; +#endif +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif // 300 +#if __VERSION__ == 100 +#extension GL_OES_standard_derivatives : enable +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else +precision mediump float; +#endif +#endif // 100 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define varying in +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif +#if __VERSION__ == 120 +#extension GL_EXT_gpu_shader4 : require +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: vtkPolyDataFS.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ +// Template for the polydata mappers fragment shader + +uniform int PrimitiveIDOffset; + +// VC position of this fragment +varying vec4 vertexVCVSOutput; + +// optional color passed in from the vertex shader, vertexColor +uniform float opacityUniform; // the fragment opacity +uniform vec3 ambientColorUniform; // intensity weighted color +uniform vec3 diffuseColorUniform; // intensity weighted color +uniform vec3 specularColorUniform; // intensity weighted color +uniform float specularPowerUniform; + + +// optional surface normal declaration +uniform int cameraParallel; + +// extra lighting parameters +//VTK::Light::Dec + +// Texture coordinates +//VTK::TCoord::Dec + +// picking support +//VTK::Picking::Dec + +// Depth Peeling Support +//VTK::DepthPeeling::Dec + +// clipping plane vars +//VTK::Clip::Dec + +// the output of this shader +out vec4 fragOutput0; + + +// Apple Bug +//VTK::PrimID::Dec + +// handle coincident offsets +uniform float coffset; + +// Value raster +//VTK::ValuePass::Dec + +void main() +{ + // VC position of this fragment. This should not branch/return/discard. + vec4 vertexVC = vertexVCVSOutput; + + // Place any calls that require uniform flow (e.g. dFdx) here. + vec3 fdx = vec3(dFdx(vertexVC.x),dFdx(vertexVC.y),dFdx(vertexVC.z)); + vec3 fdy = vec3(dFdy(vertexVC.x),dFdy(vertexVC.y),dFdy(vertexVC.z)); + //VTK::UniformFlow::Impl + + + // Set gl_FragDepth here (gl_FragCoord.z by default) + gl_FragDepth = gl_FragCoord.z + 0.000016*coffset; + + + // Early depth peeling abort: + //VTK::DepthPeeling::PreColor + + // Apple Bug + //VTK::PrimID::Impl + + //VTK::Clip::Impl + + //VTK::ValuePass::Impl + + vec3 ambientColor; + vec3 diffuseColor; + float opacity; + vec3 specularColor; + float specularPower; + ambientColor = ambientColorUniform; + diffuseColor = diffuseColorUniform; + opacity = opacityUniform; + specularColor = specularColorUniform; + specularPower = specularPowerUniform; + + + // Generate the normal if we are not passed in one + fdx = normalize(fdx); + fdy = normalize(fdy); + vec3 normalVCVSOutput = normalize(cross(fdx,fdy)); + if (cameraParallel == 1 && normalVCVSOutput.z < 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; } + if (cameraParallel == 0 && dot(normalVCVSOutput,vertexVC.xyz) > 0.0) { normalVCVSOutput = -1.0*normalVCVSOutput; } + + float df = max(0.0,normalVCVSOutput.z); + float sf = pow(df, specularPower); + vec3 diffuse = df * diffuseColor; + vec3 specular = sf * specularColor; + fragOutput0 = vec4(ambientColor + diffuse + specular, opacity); + //VTK::Light::Impl + + + //VTK::TCoord::Impl + + if (fragOutput0.a <= 0.0) + { + discard; + } + + //VTK::DepthPeeling::Impl + + //VTK::Picking::Impl + + // handle coincident offsets + //VTK::Coincident::Impl +} + + diff --git a/shaders/pts/paraview-1.0.3/many-spheres/6.shader_test b/shaders/pts/paraview-1.0.3/many-spheres/6.shader_test new file mode 100644 index 0000000..ab8c7ae --- /dev/null +++ b/shaders/pts/paraview-1.0.3/many-spheres/6.shader_test @@ -0,0 +1,297 @@ +[require] +GLSL >= 1.50 + +[vertex shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define attribute in +#define varying out +#endif // 300 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define attribute in +#define varying out +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: vtkPolyDataVS.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ + +attribute vec4 vertexMC; + +// frag position in VC +varying vec4 vertexVCVSOutput; + +// optional normal declaration +attribute vec3 normalMC; +uniform mat3 normalMatrix; +varying vec3 normalVCVSOutput; + +// extra lighting parameters +//VTK::Light::Dec + +// Texture coordinates +attribute vec2 tcoordMC; +varying vec2 tcoordVCVSOutput; + +// material property values +//VTK::Color::Dec + +// clipping plane vars +//VTK::Clip::Dec + +// camera and actor matrix values +uniform mat4 MCDCMatrix; +uniform mat4 MCVCMatrix; + +// Apple Bug +//VTK::PrimID::Dec + +// Value raster +//VTK::ValuePass::Dec + +void main() +{ + //VTK::Color::Impl + + normalVCVSOutput = normalMatrix * normalMC; + + tcoordVCVSOutput = tcoordMC; + + //VTK::Clip::Impl + + //VTK::PrimID::Impl + + vertexVCVSOutput = MCVCMatrix * vertexMC; + gl_Position = MCDCMatrix * vertexMC; + + + //VTK::ValuePass::Impl + + //VTK::Light::Impl +} + + +[fragment shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define varying in +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +precision highp sampler2D; +precision highp sampler3D; +#else +precision mediump float; +precision mediump sampler2D; +precision mediump sampler3D; +#endif +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif // 300 +#if __VERSION__ == 100 +#extension GL_OES_standard_derivatives : enable +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else +precision mediump float; +#endif +#endif // 100 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define varying in +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif +#if __VERSION__ == 120 +#extension GL_EXT_gpu_shader4 : require +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: vtkPolyDataFS.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ +// Template for the polydata mappers fragment shader + +uniform int PrimitiveIDOffset; + +// VC position of this fragment +varying vec4 vertexVCVSOutput; + +// optional color passed in from the vertex shader, vertexColor +uniform bool OverridesColor; +uniform float opacityUniform; // the fragment opacity +uniform vec3 ambientColorUniform; // intensity weighted color +uniform vec3 diffuseColorUniform; // intensity weighted color +uniform vec3 specularColorUniform; // intensity weighted color +uniform float specularPowerUniform; + + +// optional surface normal declaration +varying vec3 normalVCVSOutput; + +// extra lighting parameters +uniform vec3 lightColor0; + uniform vec3 lightDirectionVC0; // normalized +uniform vec3 lightColor1; + uniform vec3 lightDirectionVC1; // normalized +uniform vec3 lightColor2; + uniform vec3 lightDirectionVC2; // normalized +uniform vec3 lightColor3; + uniform vec3 lightDirectionVC3; // normalized +uniform vec3 lightColor4; + uniform vec3 lightDirectionVC4; // normalized + + +// Texture coordinates +varying vec2 tcoordVCVSOutput; +uniform sampler2D texture_0; + + +// picking support +//VTK::Picking::Dec + +// Depth Peeling Support +//VTK::DepthPeeling::Dec + +// clipping plane vars +//VTK::Clip::Dec + +// the output of this shader +out vec4 fragOutput0; + + +// Apple Bug +//VTK::PrimID::Dec + +// handle coincident offsets +uniform float coffset; + +// Value raster +//VTK::ValuePass::Dec + +void main() +{ + // VC position of this fragment. This should not branch/return/discard. + vec4 vertexVC = vertexVCVSOutput; + + // Place any calls that require uniform flow (e.g. dFdx) here. + //VTK::UniformFlow::Impl + + // Set gl_FragDepth here (gl_FragCoord.z by default) + gl_FragDepth = gl_FragCoord.z + 0.000016*coffset; + + + // Early depth peeling abort: + //VTK::DepthPeeling::PreColor + + // Apple Bug + //VTK::PrimID::Impl + + //VTK::Clip::Impl + + //VTK::ValuePass::Impl + + vec3 ambientColor; + vec3 diffuseColor; + float opacity; + vec3 specularColor; + float specularPower; + ambientColor = ambientColorUniform; + diffuseColor = diffuseColorUniform; + opacity = opacityUniform; + specularColor = specularColorUniform; + specularPower = specularPowerUniform; + vec4 texColor = texture2D(texture_0, tcoordVCVSOutput.st); + diffuseColor = texColor.rgb; + opacity = opacity*texColor.a; + if (OverridesColor) { + ambientColor = ambientColorUniform; + diffuseColor = diffuseColorUniform; } + + + // Generate the normal if we are not passed in one + vec3 normalVCVSOutput = normalize(normalVCVSOutput); + if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; } + + + vec3 diffuse = vec3(0,0,0); + vec3 specular = vec3(0,0,0); + float df; + float sf; + df = max(0.0, dot(normalVCVSOutput, -lightDirectionVC0)); + diffuse += (df * lightColor0); + sf = sign(df)*pow(max(0.0, dot( reflect(lightDirectionVC0, normalVCVSOutput), normalize(-vertexVC.xyz))), specularPower); + specular += (sf * lightColor0); + df = max(0.0, dot(normalVCVSOutput, -lightDirectionVC1)); + diffuse += (df * lightColor1); + sf = sign(df)*pow(max(0.0, dot( reflect(lightDirectionVC1, normalVCVSOutput), normalize(-vertexVC.xyz))), specularPower); + specular += (sf * lightColor1); + df = max(0.0, dot(normalVCVSOutput, -lightDirectionVC2)); + diffuse += (df * lightColor2); + sf = sign(df)*pow(max(0.0, dot( reflect(lightDirectionVC2, normalVCVSOutput), normalize(-vertexVC.xyz))), specularPower); + specular += (sf * lightColor2); + df = max(0.0, dot(normalVCVSOutput, -lightDirectionVC3)); + diffuse += (df * lightColor3); + sf = sign(df)*pow(max(0.0, dot( reflect(lightDirectionVC3, normalVCVSOutput), normalize(-vertexVC.xyz))), specularPower); + specular += (sf * lightColor3); + df = max(0.0, dot(normalVCVSOutput, -lightDirectionVC4)); + diffuse += (df * lightColor4); + sf = sign(df)*pow(max(0.0, dot( reflect(lightDirectionVC4, normalVCVSOutput), normalize(-vertexVC.xyz))), specularPower); + specular += (sf * lightColor4); + diffuse = diffuse * diffuseColor; + specular = specular * specularColor; + fragOutput0 = vec4(ambientColor + diffuse + specular, opacity); //VTK::Light::Impl + + //VTK::TCoord::Impl + + if (fragOutput0.a <= 0.0) + { + discard; + } + + //VTK::DepthPeeling::Impl + + //VTK::Picking::Impl + + // handle coincident offsets + //VTK::Coincident::Impl +} + + diff --git a/shaders/pts/paraview-1.0.3/many-spheres/9.shader_test b/shaders/pts/paraview-1.0.3/many-spheres/9.shader_test new file mode 100644 index 0000000..98cd947 --- /dev/null +++ b/shaders/pts/paraview-1.0.3/many-spheres/9.shader_test @@ -0,0 +1,862 @@ +[require] +GLSL >= 1.50 + +[vertex shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define attribute in +#define varying out +#endif // 300 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define attribute in +#define varying out +#endif +#endif // GL_ES + +attribute vec4 ndCoordIn; +attribute vec2 texCoordIn; +varying vec2 texCoord; +void main() +{ + gl_Position = ndCoordIn; + texCoord = texCoordIn; +} + +[fragment shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define varying in +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +precision highp sampler2D; +precision highp sampler3D; +#else +precision mediump float; +precision mediump sampler2D; +precision mediump sampler3D; +#endif +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif // 300 +#if __VERSION__ == 100 +#extension GL_OES_standard_derivatives : enable +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else +precision mediump float; +#endif +#endif // 100 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define varying in +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif +#if __VERSION__ == 120 +#extension GL_EXT_gpu_shader4 : require +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: vtkFXAAFilterFS.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ +// Fragment shader for vtkOpenGLFXAAFilter. +// +// Based on the following implementation and description: +// +// Whitepaper: +// http://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf +// +// Sample implementation: +// https://github.com/NVIDIAGameWorks/GraphicsSamples/blob/master/samples/es3-kepler/FXAA/FXAA3_11.h + +out vec4 fragOutput0; + + +//======================== Debugging Options: ================================== + +// Output a greyscale image showing the detected amount of subpixel aliasing. +//#define FXAA_DEBUG_SUBPIXEL_ALIASING + +// Output vertical edges in red, and horizontal edges in blue. +//#define FXAA_DEBUG_EDGE_DIRECTION + +// Output (number of steps taken) / (EndpointSearchIterations). Negative steps +// in the red channel, positive steps in the blue. +//#define FXAA_DEBUG_EDGE_NUM_STEPS + +// Output degrees of red if the edge is near the negative edge endpoint, or +// shades of blue if near the positive edge endpoint. Pixels near an edge but +// not eligible for edgeAA (e.g. they are on the unaliased side of an edge) +// are shown in yellow. +//#define FXAA_DEBUG_EDGE_DISTANCE + +// Output the length of the edge anti-aliasing offset vector in the red channel. +//#define FXAA_DEBUG_EDGE_SAMPLE_OFFSET + +// Only apply a single form of anti-aliasing: +// 1 - Only apply sub-pixel anti-aliasing. +// 2 - Only apply edge anti-aliasing. +// Other / undefined - Apply both sub-pixel and edge anti-aliasing. +//#define FXAA_DEBUG_ONLY_SUBPIX_AA +//#define FXAA_DEBUG_ONLY_EDGE_AA + +// Replacement stub for vtkShaderProgram::Substitute: +//VTK::DebugOptions::Def + +//========================== Tuning Define: ==================================== + +// Which edge search implementation to use. If defined, use VTK's endpoint +// algorithm, otherwise use NVIDIA's. +// +// NVIDIA is faster, but gives poor results on single pixel lines (e.g. +// vtkPolyDataMapper's wireframe/edges). VTK is slower, but gives nicer results +// on single pixel lines. +//#define FXAA_USE_HIGH_QUALITY_ENDPOINTS; + +// Replacement stub for vtkShaderProgram::Substitute: +#define FXAA_USE_HIGH_QUALITY_ENDPOINTS + +//========================= Input Parameters: ================================== + +// Current fragment texture coordinate: +in vec2 texCoord; + +// Aliased color buffer (should be sRGB, ideally) +uniform sampler2D Input; + +// 1.f/Input.width, 1.f/Input.height: +uniform vec2 InvTexSize; + +//======================== Tuning Parameters: ================================== + +// See the vtkOpenGLFXAAFilter class documentation for details on these. + +// Minimum change in luminosity (relative to maxLum) to use FXAA: +uniform float RelativeContrastThreshold; + +// Absolute minimum lum change required for FXAA (overrides +// RelativeContrastThreshold value, not scaled): +uniform float HardContrastThreshold; + +// Maximum amount of lowpass blending for subpixel anti-aliasing: +uniform float SubpixelBlendLimit; + +// Ignore subpixel anti-aliasing that contributes less than this amount to the +// total contrast: +uniform float SubpixelContrastThreshold; + +// Maximum number of steps to take when searching for line edges: +uniform int EndpointSearchIterations; + +//============================ Helper Methods ================================== +// Converts rgb to luminosity: +const vec3 LUMINOSITY_VEC = vec3(0.299, 0.587, 0.114); +float luminosity(vec3 rgb) +{ + return dot(rgb, LUMINOSITY_VEC); +} + +//======================= Endpoint Search Routines ============================= +// Identify the endpoints of a detected edge and compute a sampling offset to +// correct for aliasing. The computed offset accounts for distance from edge +// to create a gradient of antialiased values. +// +// Input parameters: +// - posC: The texture coordinate position of the current pixel. +// - lumC: The luminosity of the current pixel. +// - lumHC: The luminosity of the highest contrast pixel to HC that is +// perpendicular to the detected edge. +// - lengthSign: Single component magnitude and direction (in texture +// coordinates) from the center of C pointing to HC. +// - tcPixel: (Width, Height) of a single pixel in texture coordinate units. +// - horzSpan: True if the detected edge is horizontal. +// - posEdgeAA: Output parameter with the position to resample the input texture +// to get an edge anti-aliased rgb value for the current pixel. +// +// Implementations: +// - nvidiaEndpointSearch: The algorithm proposed by nVidia in their whitepaper +// and sample implementations. Faster, but poorly handles single-pixel lines. +// - vtkEndpointSearch: Modified endpoint search that does more texture lookups, +// but does better detection of single pixel line endpoints. +// +// Return values for endpoint searches: +const int FXAA_NO_EDGE_AA = 0; // Edge AA not required. +const int FXAA_NEED_EDGE_AA = 1; // Edge AA required. +const int FXAA_ABORT_EDGE_AA = 2; // Instruct to return. Used for debugging. + +//================ nVidia's Endpoint Search Implementation ===================== + +int nvidiaEndpointSearch(vec2 posC, float lumC, float lumHC, float lengthSign, + vec2 tcPixel, bool horzSpan, out vec2 posEdgeAA) +{ + /***************************************************************************** + * End of Edge Search * + *===========================================================================* + * Search along the direction of the detected edge to find both endpoints. * + * * + * We define HC as the Highest Contrast neighbor perpendicular to the edge * + * direction (i.e. the pixel on the other side of the edge). * + * * + * The luminosity of HC is lumHC, the contrast between C and HC is * + * contrastCHC, and the average luminosity of HC and C is lumAveCHC. * + * * + * We'll walk along the edge boundary in both direction, sampling the average* + * luminosity of the pixels on both sides of the edge: lumAveN for the * + * negative direction, lumAveP for the positive direction. We determine the * + * end of the edge to be where: * + * * + * abs(lumAve[NP] - lumCHC) >= contrastHC / 4. * + * * + * which indicates that the average luminosities have diverged enough to no * + * longer be considered part of the edge. * + ****************************************************************************/ + + float contrastCHC = abs(lumC - lumHC); + + // Point on the boundary of C and HC: + vec2 boundaryCHC = posC; // Will be shifted later. + + // Direction of the edge + vec2 edgeDir = vec2(0.f); // Component is set below: + + if (horzSpan) + { + boundaryCHC.y += lengthSign * 0.5f; + edgeDir.x = tcPixel.x; + } + else + { + boundaryCHC.x += lengthSign * 0.5f; + edgeDir.y = tcPixel.y; + } + + // Prepare for the search loop: + float contrastThreshold = contrastCHC / 4.f; + float lumAveCHC = 0.5f * (lumC + lumHC); + float lumAveN; + float lumAveP; + bool doneN = false; + bool doneP = false; + vec2 posN = boundaryCHC - edgeDir; + vec2 posP = boundaryCHC + edgeDir; + +#ifdef FXAA_DEBUG_EDGE_NUM_STEPS + int stepsN = 0; + int stepsP = 0; +#endif // FXAA_DEBUG_EDGE_NUM_STEPS + + for (int i = 0; i < EndpointSearchIterations; ++i) + { +#ifdef FXAA_DEBUG_EDGE_NUM_STEPS + if (!doneN) stepsN += 1; + if (!doneP) stepsP += 1; +#endif // FXAA_DEBUG_EDGE_NUM_STEPS + + // Sample on the edge boundary in both directions: + if (!doneN) lumAveN = luminosity(texture2D(Input, posN).rgb); + if (!doneP) lumAveP = luminosity(texture2D(Input, posP).rgb); + + // Edge endpoint is where the contrast changes significantly: + doneN = doneN || (abs(lumAveN - lumAveCHC) >= contrastThreshold); + doneP = doneP || (abs(lumAveP - lumAveCHC) >= contrastThreshold); + if (doneN && doneP) break; + + // Step to next pixel: + if (!doneN) posN -= edgeDir; + if (!doneP) posP += edgeDir; + } + +#ifdef FXAA_DEBUG_EDGE_NUM_STEPS + fragOutput0 = vec4(float(stepsN) / float(EndpointSearchIterations), 0.f, + float(stepsP) / float(EndpointSearchIterations), 1.f); + return FXAA_ABORT_EDGE_AA; +#endif // FXAA_DEBUG_EDGE_NUM_STEPS + + /***************************************************************************** + * Edge Search Analysis * + *===========================================================================* + * We've located the ends of the edge at this point. Next we figure out how * + * to interpolate the edge. * + * * + * First we need to find out which end of the edge (N or P) is changing * + * contrast relative to boundaryCHC. This is best explained visually: * + * * + * +------------+ * + * |XX E | * + * |NXXXHXXP | * + * |N C PXXXX| * + * | X| * + * +------------+ * + * * + * In the above, an X represents a dark pixel, and a blank space is a light * + * pixel. C is the current pixel, and H is pixel HC. The negative endpoint N* + * of the edge is the midpoint between the first set of blank pixels to the * + * left of C and H, while the positive endpoint P is the first set of dark * + * pixels to the right. The pixels under the "N" are light, while the pixels* + * under "P" are dark. The "P" side of the edge is changing contrast * + * relative to C. We compute this condition as: * + * * + * bool lumCLessThanAve = lumC < lumAveCHC; * + * bool lumNLessThanAve = lumAveN < lumAveCHC; * + * bool lumPLessThanAve = lumAveP < lumAveCHC; * + * bool shadeIfNearN = lumCLessThanAve != lumNLessThanAve; * + * bool shadeIfNearP = lumCLessThanAve != lumPLessThanAve; * + * * + * If shadeIfNearN is true, N is changing contrast relative to C. The same * + * is true for P. Thus, the change in the average contrast of the the * + * endpoint relative to lumAveHC must be opposite to the change in contrast * + * from C to lumAveHC. * + * * + * In addition to checking the change in contrast, we also identify which * + * endpoint is nearest to C. As the variable names suggest, we will only * + * apply edge anti-aliasing if we're nearest an endpoint that has the * + * desired contrast change. This prevents shading edge neighbors that do not* + * follow the direction of the line, such as point E in the diagram. * + * * + * bool CisNearN = (norm(posN - boundaryCHC) < norm(posP - boundaryCHC)); * + * * + * If both of the above conditions are met (the nearest endpoint has the * + * proper contrast change), then we compute the ratio of C's distance from * + * the desired endpoint to the total length of the edge. This ratio is the * + * fraction of a pixel that we shift C towards HC to resample C for * + * anti-aliasing. * + ****************************************************************************/ + + // Check both endpoints for the contrast change condition: + bool lumCLessThanAve = lumC < lumAveCHC; + bool lumNLessThanAve = lumAveN < lumAveCHC; + bool lumPLessThanAve = lumAveP < lumAveCHC; + bool shadeIfNearN = lumCLessThanAve != lumNLessThanAve; + bool shadeIfNearP = lumCLessThanAve != lumPLessThanAve; + + // Identify the closest point: + float dstN; + float dstP; + if (horzSpan) + { + dstN = boundaryCHC.x - posN.x; + dstP = posP.x - boundaryCHC.x; + } + else + { + dstN = boundaryCHC.y - posN.y; + dstP = posP.y - boundaryCHC.y; + } + bool nearestEndpointIsN = dstN < dstP; + float dst = min(dstN, dstP); + + // Finally determine if we need shading: + bool needEdgeAA = nearestEndpointIsN ? shadeIfNearN : shadeIfNearP; + +#ifdef FXAA_DEBUG_EDGE_DISTANCE + if (needEdgeAA) + { + float maxDistance = EndpointSearchIterations; + if (nearestEndpointIsN) + { + fragOutput0 = vec4(1.f - dstN / maxDistance, 0.f, 0.f, 1.f); + } + else + { + fragOutput0 = vec4(0.f, 0.f, 1.f - dstP / maxDistance, 1.f); + } + } + else + { + fragOutput0 = vec4(1.f, 1.f, 0.f, 1.f); + } + return FXAA_ABORT_EDGE_AA; +#endif // FXAA_DEBUG_EDGE_DISTANCE + + // Compute the pixel offset: + float invNegSpanLength = -1.f / (dstN + dstP); + float pixelOffset = dst * invNegSpanLength + 0.5; + +#ifdef FXAA_DEBUG_EDGE_SAMPLE_OFFSET + if (needEdgeAA) + { // x2, since the max value is 0.5: + fragOutput0 = vec4(-2.f * dst * invNegSpanLength, 0.f, 0.f, 1.f); + return FXAA_ABORT_EDGE_AA; + } +#endif // FXAA_DEBUG_EDGE_SAMPLE_OFFSET + + // Resample the edge anti-aliased value: + posEdgeAA = posC; + if (horzSpan) + { + posEdgeAA.y += pixelOffset * lengthSign; + } + else + { + posEdgeAA.x += pixelOffset * lengthSign; + } + + return needEdgeAA ? 1 : 0; +} + +//================== VTK's Endpoint Search Implementation ====================== + +int vtkEndpointSearch(vec2 posC, float lumC, float lumHC, float lengthSign, + vec2 tcPixel, bool horzSpan, out vec2 posEdgeAA) +{ + /***************************************************************************** + * End of Edge Search * + *===========================================================================* + * Search along the direction of the detected edge to find both endpoints. * + * +------------+ * + * |X | nVidia's endpoint detector handles this case poorly. If C * + * | XXXXXX C | is the current pixel, it will detect N as the leftmost * + * | XXHXX| column of pixels, since it samples the average luminosity * + * | X| at the border of the rows containing C and HC. The actual * + * +------------+ endpoint is 3 pixels to the left from C, but the average * + * luminosity does not change at this point. * + * * + * We adapt the algorithm to sample both rows/columns containing C and HC on * + * the texel centers, rather than the interpolated border. We then detect * + * the edge endpoints when: * + * * + * abs(lumHCN - lumHC) > abs(lumHCN - lumC) || * + * abs(lumCN - lumC) > abs(lumCN - lumHC) * + * * + * where lumHCN is the luminosity of the sample in HC's row in the negative * + * direction, lumCN is the luminosity of the sample in C's row in the * + * negative direction, lumHC is the luminosity of HC, and lumC is the * + * luminosity of C. Thus, the endpoint is where a sampled luminosity in C's * + * row is closer to HC, or vice-versa. The positive endpoint is determined * + * similarly. * + * * + * After the endpoints has been determined, we decide whether or not the * + * current pixel needs resampling. This is similar to nVidia's algorithm. * + * We determine if the luminosity of the nearest endpoint's C sample is * + * closer to C or HC. If it's closer to HC, it gets shaded. The resampling * + * offset is computed identically to nVidia's algorithm. * + ****************************************************************************/ + + // Point on the boundary of C and HC: + vec2 posHC = posC; // Will be shifted later. + + // Direction of the edge + vec2 edgeDir = vec2(0.f); // Component is set below: + + if (horzSpan) + { + posHC.y += lengthSign; + edgeDir.x = tcPixel.x; + } + else + { + posHC.x += lengthSign; + edgeDir.y = tcPixel.y; + } + + // Prepare for the search loop: + float lumHCN; + float lumHCP; + float lumCN; + float lumCP; + bool doneN = false; + bool doneP = false; + vec2 posHCN = posHC - edgeDir; + vec2 posHCP = posHC + edgeDir; + vec2 posCN = posC - edgeDir; + vec2 posCP = posC + edgeDir; + +#ifdef FXAA_DEBUG_EDGE_NUM_STEPS + int stepsN = 0; + int stepsP = 0; +#endif // FXAA_DEBUG_EDGE_NUM_STEPS + + for (int i = 0; i < EndpointSearchIterations; ++i) + { +#ifdef FXAA_DEBUG_EDGE_NUM_STEPS + if (!doneN) stepsN += 1; + if (!doneP) stepsP += 1; +#endif // FXAA_DEBUG_EDGE_NUM_STEPS + + // Sample the luminosities along the edge: + if (!doneN) + { + lumHCN = luminosity(texture2D(Input, posHCN).rgb); + lumCN = luminosity(texture2D(Input, posCN).rgb); + } + if (!doneP) + { + lumHCP = luminosity(texture2D(Input, posHCP).rgb); + lumCP = luminosity(texture2D(Input, posCP).rgb); + } + + // Check contrast to detect endpoint: + doneN = doneN || abs(lumHCN - lumHC) > abs(lumHCN - lumC) + || abs(lumCN - lumC) > abs(lumCN - lumHC); + doneP = doneP || abs(lumHCP - lumHC) > abs(lumHCP - lumC) + || abs(lumCP - lumC) > abs(lumCP - lumHC); + + if (doneN && doneP) + { + break; + } + + // Take next step. + if (!doneN) + { + posHCN -= edgeDir; + posCN -= edgeDir; + } + if (!doneP) + { + posHCP += edgeDir; + posCP += edgeDir; + } + } + +#ifdef FXAA_DEBUG_EDGE_NUM_STEPS + fragOutput0 = vec4(float(stepsN) / float(EndpointSearchIterations), 0.f, + float(stepsP) / float(EndpointSearchIterations), 1.f); + return FXAA_ABORT_EDGE_AA; +#endif // FXAA_DEBUG_EDGE_NUM_STEPS + + // Identify the closest point: + float dstN; + float dstP; + + if (horzSpan) + { + dstN = posC.x - posCN.x; + dstP = posCP.x - posC.x; + } + else + { + dstN = posC.y - posCN.y; + dstP = posCP.y - posC.y; + } + + bool nearestEndpointIsN = dstN < dstP; + float dst = min(dstN, dstP); + float lumCNear = nearestEndpointIsN ? lumCN : lumCP; + + // Resample if the nearest endpoint sample in C's row is closer in luminosity + // to HC than C. + bool needEdgeAA = abs(lumCNear - lumHC) < abs(lumCNear - lumC); + +#ifdef FXAA_DEBUG_EDGE_DISTANCE + if (needEdgeAA) + { + float maxDistance = EndpointSearchIterations; + if (nearestEndpointIsN) + { + fragOutput0 = vec4(1.f - dstN / maxDistance, 0.f, 0.f, 1.f); + } + else + { + fragOutput0 = vec4(0.f, 0.f, 1.f - dstP / maxDistance, 1.f); + } + } + else + { + fragOutput0 = vec4(1.f, 1.f, 0.f, 1.f); + } + return FXAA_ABORT_EDGE_AA; +#endif // FXAA_DEBUG_EDGE_DISTANCE + + // Compute the pixel offset: + float invNegSpanLength = -1.f / (dstN + dstP); + float pixelOffset = dst * invNegSpanLength + 0.5f; + +#ifdef FXAA_DEBUG_EDGE_SAMPLE_OFFSET + if (needEdgeAA) + { // x2, since the max value is 0.5: + fragOutput0 = vec4(-2.f * dst * invNegSpanLength, 0.f, 0.f, 1.f); + return FXAA_ABORT_EDGE_AA; + } +#endif // FXAA_DEBUG_EDGE_SAMPLE_OFFSET + + // Resample the edge anti-aliased value: + posEdgeAA = posC; + if (horzSpan) + { + posEdgeAA.y += pixelOffset * lengthSign; + } + else + { + posEdgeAA.x += pixelOffset * lengthSign; + } + + return needEdgeAA ? 1 : 0; +} + +//=============================== FXAA Body ==================================== + +void main() +{ + // Pixel step size in texture coordinate units: + vec2 tcPixel = InvTexSize; + + /**************************************************************************** + * Compute Local Contrast Range And Early Abort * + *==========================================================================* + * Determine the contrast range for the current pixel and its neightbors * + * to the North, South, West, and East. If the range is less than both of: * + * * + * a) RelativeContrastThreshold * lumMax * + * * + * and * + * * + * b) HardContrastThreshold * + * * + * then skip anti-aliasing for this pixel. * + ****************************************************************************/ + + // First compute the texture coordinates: + vec2 tcC = texCoord; + vec2 tcN = texCoord + vec2( 0.f, -tcPixel.y); + vec2 tcS = texCoord + vec2( 0.f, tcPixel.y); + vec2 tcW = texCoord + vec2(-tcPixel.x, 0.f); + vec2 tcE = texCoord + vec2( tcPixel.x, 0.f); + + // Extract the rgb values of these pixels: + vec3 rgbC = texture2D(Input, tcC).rgb; + vec3 rgbN = texture2D(Input, tcN).rgb; + vec3 rgbS = texture2D(Input, tcS).rgb; + vec3 rgbW = texture2D(Input, tcW).rgb; + vec3 rgbE = texture2D(Input, tcE).rgb; + + // Convert to luminosity: + float lumC = luminosity(rgbC); + float lumN = luminosity(rgbN); + float lumS = luminosity(rgbS); + float lumW = luminosity(rgbW); + float lumE = luminosity(rgbE); + + // The min, max, and range of luminosity for CNSWE: + float lumMin = min(lumC, min(min(lumN, lumS), min(lumW, lumE))); + float lumMax = max(lumC, max(max(lumN, lumS), max(lumW, lumE))); + float lumRange = lumMax - lumMin; + float lumThresh = max(HardContrastThreshold, + RelativeContrastThreshold * lumMax); + + // Don't apply FXAA unless there's a significant change in luminosity around + // the current pixel: + if (lumRange < lumThresh) + { + fragOutput0 = vec4(rgbC, 1.f); // original color + return; + } + + /**************************************************************************** + * Fetch texels for complete 3x3 neighborhood. * + ****************************************************************************/ + + // Fetch additional texels for edge detection / subpixel antialiasing: + vec2 tcNE = texCoord + vec2( tcPixel.x, -tcPixel.y); + vec2 tcSE = texCoord + vec2( tcPixel.x, tcPixel.y); + vec2 tcNW = texCoord + vec2(-tcPixel.x, -tcPixel.y); + vec2 tcSW = texCoord + vec2(-tcPixel.x, tcPixel.y); + vec3 rgbNE = texture2D(Input, tcNE).rgb; + vec3 rgbSE = texture2D(Input, tcSE).rgb; + vec3 rgbNW = texture2D(Input, tcNW).rgb; + vec3 rgbSW = texture2D(Input, tcSW).rgb; + float lumNE = luminosity(rgbNE); + float lumSE = luminosity(rgbSE); + float lumNW = luminosity(rgbNW); + float lumSW = luminosity(rgbSW); + + // Precompute some combined luminosities. These are reused later. + float lumNS = lumN + lumS; + float lumWE = lumW + lumE; + float lumNSWE = lumNS + lumWE; + float lumNWNE = lumNW + lumNE; + float lumSWSE = lumSW + lumSE; + float lumNWSW = lumNW + lumSW; + float lumNESE = lumNE + lumSE; + + /**************************************************************************** + * Subpixel Anti-aliasing * + *==========================================================================* + * Check if the current pixel is very high contrast to it's neighbors (e.g. * + * specular aliasing, noisy shadow textures, etc). If it is, compute the * + * average color over the 3x3 neighborhood and a blending factor. * + * * + * The blending factor is computed as the minimum of: * + * * + * 1) max(0.f, abs([average NSWE lum] - lumC) - SubpixelContrastThreshold) * + * FXAA_SUBPIX_TRIM_SCALE * + * * + * or * + * * + * 2) SubpixelBlendLimit * + ****************************************************************************/ + + // Check for sub-pixel aliasing (e.g. current pixel has high contrast from + // neighbors): + float lumAveNSWE = 0.25f * (lumNSWE); + float lumSubRange = abs(lumAveNSWE - lumC); + + // Compute the subpixel blend amount: + float blendSub = max(0.f, (lumSubRange / lumRange) - + SubpixelContrastThreshold); + blendSub = min(SubpixelBlendLimit, + blendSub * (1.f / (1.f - SubpixelContrastThreshold))); + +#ifdef FXAA_DEBUG_SUBPIXEL_ALIASING + if (blendSub > 0.f) + { + fragOutput0 = vec4(vec3(blendSub / SubpixelBlendLimit), 1.f); + } + else + { + fragOutput0 = vec4(rgbC, 1.f); + } + return; +#endif // FXAA_DEBUG_SUBPIXEL_ALIASING + + // Compute the subpixel blend color. Average the 3x3 neighborhood: + vec3 rgbSub = (1.f/9.f) * + (rgbNW + rgbN + rgbNE + + rgbW + rgbC + rgbE + + rgbSW + rgbS + rgbSE); + + /**************************************************************************** + * Edge Testing * + *==========================================================================* + * Apply vertical and horizontal edge detection techniques to determine the * + * direction of any edges in the 3x3 neighborhood. * + ****************************************************************************/ + + // Check for vertical edge. Pixel coeffecients are: + // 1 -2 1 + // 2 -4 2 + // 1 -2 1 + // The absolute value of each row is taken, summed, and divided by 12. + // Operations are decomposed here to take advantage of FMA ops. + float edgeVertRow1 = abs(-2.f * lumN + lumNWNE); + float edgeVertRow2 = abs(-2.f * lumC + lumWE); + float edgeVertRow3 = abs(-2.f * lumS + lumSWSE); + float edgeVert = ((2.f * edgeVertRow2 + edgeVertRow1) + edgeVertRow3) / 12.f; + + // Check for horizontal edge. Pixel coeffecients are: + // 1 2 1 + // -2 -4 -2 + // 1 2 1 + // The absolute value of each column is taken, summed, and divided by 12. + // Operations are decomposed here to take advantage of FMA ops. + float edgeHorzCol1 = abs(-2.f * lumW + lumNWSW); + float edgeHorzCol2 = abs(-2.f * lumC + lumNS); + float edgeHorzCol3 = abs(-2.f * lumE + lumNESE); + float edgeHorz = ((2.f * edgeHorzCol2 + edgeHorzCol1) + edgeHorzCol3) / 12.f; + + // Indicates that the edge span is horizontal: + bool horzSpan = edgeHorz >= edgeVert; + +#ifdef FXAA_DEBUG_EDGE_DIRECTION + fragOutput0 = horzSpan ? vec4(0.f, 0.f, 1.f, 1.f) + : vec4(1.f, 0.f, 0.f, 1.f); + return; +#endif // FXAA_DEBUG_EDGE_DIRECTION + + /**************************************************************************** + * Endpoint Search Preparation * + *==========================================================================* + * Compute inputs for an endpoint detection algorithm. Mainly concerned * + * locating HC -- the Highest Contrast pixel (relative to C) that's on the * + * opposite side of the detected edge from C. * + ****************************************************************************/ + + // The two neighbor pixels perpendicular to the edge: + float lumHC1; + float lumHC2; + + // Single-pixel texture coordinate offset that points from C to HC. + float lengthSign; + + if (horzSpan) + { + lumHC1 = lumN; + lumHC2 = lumS; + lengthSign = -tcPixel.y; // Assume N for now. + } + else + { + lumHC1 = lumW; + lumHC2 = lumE; + lengthSign = -tcPixel.x; // Assume W for now. + } + + // Luminosity of the NSWE pixel perpendicular to the edge with the highest + // contrast to C: + float lumHC; + if (abs(lumC - lumHC1) >= abs(lumC - lumHC2)) + { + lumHC = lumHC1; + } + else + { + lumHC = lumHC2; + // Also reverse the offset direction in this case: + lengthSign = -lengthSign; + } + + vec2 posEdgeAA; // Position to resample C at to get edge-antialiasing. + +#ifdef FXAA_USE_HIGH_QUALITY_ENDPOINTS + int endpointResult = vtkEndpointSearch(tcC, lumC, lumHC, lengthSign, + tcPixel, horzSpan, posEdgeAA); +#else // FXAA_USE_HIGH_QUALITY_ENDPOINTS + int endpointResult = nvidiaEndpointSearch(tcC, lumC, lumHC, lengthSign, + tcPixel, horzSpan, posEdgeAA); +#endif // FXAA_USE_HIGH_QUALITY_ENDPOINTS + + // Only sample texture if needed. Reuse rgbC otherwise. + vec3 rgbEdgeAA = rgbC; + + switch (endpointResult) + { + case FXAA_ABORT_EDGE_AA: // Used for debugging (endpoint search set colors) + return; + + case FXAA_NEED_EDGE_AA: // Resample the texture at the requested position. + rgbEdgeAA = texture2D(Input, posEdgeAA).rgb; + break; + + case FXAA_NO_EDGE_AA: // Current pixel does not need edge anti-aliasing. + default: + break; + } + +#ifdef FXAA_DEBUG_ONLY_SUBPIX_AA + rgbEdgeAA = rgbC; +#endif // FXAA_DEBUG_ONLY_SUBPIX_AA +#ifdef FXAA_DEBUG_ONLY_EDGE_AA + blendSub = 0.f; +#endif // FXAA_DEBUG_ONLY_EDGE_AA + + // Blend the edgeAA and subpixelAA results together: + fragOutput0 = vec4(mix(rgbEdgeAA, rgbSub, blendSub), 1.f); +} + + diff --git a/shaders/pts/paraview-1.0.3/wavelet-volume/6.shader_test b/shaders/pts/paraview-1.0.3/wavelet-volume/6.shader_test new file mode 100644 index 0000000..55c232f --- /dev/null +++ b/shaders/pts/paraview-1.0.3/wavelet-volume/6.shader_test @@ -0,0 +1,627 @@ +[require] +GLSL >= 1.50 + +[vertex shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define attribute in +#define varying out +#endif // 300 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define attribute in +#define varying out +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: raycastervs.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ + +/// Needed to enable inverse function +#extension GL_ARB_gpu_shader5 : enable + +////////////////////////////////////////////////////////////////////////////// +/// +/// Uniforms, attributes, and globals +/// +////////////////////////////////////////////////////////////////////////////// + + uniform bool in_cellFlag; + uniform vec3 in_cellSpacing; + uniform mat4 in_modelViewMatrix; + uniform mat4 in_projectionMatrix; + uniform mat4 in_volumeMatrix; + + uniform vec3 in_volumeExtentsMin; + uniform vec3 in_volumeExtentsMax; + + uniform mat4 in_inverseTextureDatasetMatrix; + uniform mat4 in_cellToPoint; + uniform vec3 in_textureExtentsMax; + uniform vec3 in_textureExtentsMin; + + //This variable could be 'invariant varying' but it is declared + //as 'varying' to avoid compiler compatibility issues. + varying mat4 ip_inverseTextureDataAdjusted; + +//VTK::Termination::Dec + +//VTK::Cropping::Dec + +//VTK::Shading::Dec + +////////////////////////////////////////////////////////////////////////////// +/// +/// Inputs +/// +////////////////////////////////////////////////////////////////////////////// +attribute vec3 in_vertexPos; + +////////////////////////////////////////////////////////////////////////////// +/// +/// Outputs +/// +////////////////////////////////////////////////////////////////////////////// +/// 3D texture coordinates for texture lookup in the fragment shader +varying vec3 ip_textureCoords; +varying vec3 ip_vertexPos; + +void main() +{ + /// Get clipspace position + + vec4 pos = in_projectionMatrix * in_modelViewMatrix * + in_volumeMatrix * vec4(in_vertexPos.xyz, 1.0); + gl_Position = pos; + + /// Compute texture coordinates + + // For point dataset, we offset the texture coordinate + // to account for OpenGL treating voxel at the center of the cell. + vec3 uvx = sign(in_cellSpacing) * (in_vertexPos - in_volumeExtentsMin) / + (in_volumeExtentsMax - in_volumeExtentsMin); + + if (in_cellFlag) + { + ip_textureCoords = uvx; + ip_inverseTextureDataAdjusted = in_inverseTextureDatasetMatrix; + } + else + { + // Transform cell tex-coordinates to point tex-coordinates + ip_textureCoords = (in_cellToPoint * vec4(uvx, 1.0)).xyz; + ip_inverseTextureDataAdjusted = in_cellToPoint * in_inverseTextureDatasetMatrix; + } + + /// Copy incoming vertex position for the fragment shader + ip_vertexPos = in_vertexPos; +} + + +[fragment shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define varying in +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +precision highp sampler2D; +precision highp sampler3D; +#else +precision mediump float; +precision mediump sampler2D; +precision mediump sampler3D; +#endif +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif // 300 +#if __VERSION__ == 100 +#extension GL_OES_standard_derivatives : enable +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else +precision mediump float; +#endif +#endif // 100 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define varying in +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif +#if __VERSION__ == 120 +#extension GL_EXT_gpu_shader4 : require +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: raycasterfs.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ + +////////////////////////////////////////////////////////////////////////////// +/// +/// Inputs +/// +////////////////////////////////////////////////////////////////////////////// + +/// 3D texture coordinates form vertex shader +varying vec3 ip_textureCoords; +varying vec3 ip_vertexPos; + +////////////////////////////////////////////////////////////////////////////// +/// +/// Outputs +/// +////////////////////////////////////////////////////////////////////////////// + +vec4 g_fragColor = vec4(0.0); + +////////////////////////////////////////////////////////////////////////////// +/// +/// Uniforms, attributes, and globals +/// +////////////////////////////////////////////////////////////////////////////// +vec3 g_dataPos; +vec3 g_dirStep; +vec4 g_srcColor; +vec4 g_eyePosObj; +bool g_exit; +bool g_skip; +float g_currentT; +float g_terminatePointMax; + +uniform vec4 in_volume_scale; +uniform vec4 in_volume_bias; + +out vec4 fragOutput0; + + + +// Volume dataset +uniform sampler3D in_volume; +uniform int in_noOfComponents; +uniform int in_independentComponents; + +uniform sampler2D in_noiseSampler; +#ifndef GL_ES +uniform sampler2D in_depthSampler; +#endif + +// Camera position +uniform vec3 in_cameraPos; + +// view and model matrices +uniform mat4 in_volumeMatrix; +uniform mat4 in_inverseVolumeMatrix; +uniform mat4 in_projectionMatrix; +uniform mat4 in_inverseProjectionMatrix; +uniform mat4 in_modelViewMatrix; +uniform mat4 in_inverseModelViewMatrix; +uniform mat4 in_textureDatasetMatrix; +uniform mat4 in_inverseTextureDatasetMatrix; +varying mat4 ip_inverseTextureDataAdjusted; +uniform vec3 in_texMin; +uniform vec3 in_texMax; +uniform mat4 in_textureToEye; + +// Ray step size +uniform vec3 in_cellStep; +uniform vec2 in_scalarsRange[4]; +uniform vec3 in_cellSpacing; + +// Sample distance +uniform float in_sampleDistance; + +// Scales +uniform vec3 in_cellScale; +uniform vec2 in_windowLowerLeftCorner; +uniform vec2 in_inverseOriginalWindowSize; +uniform vec2 in_inverseWindowSize; +uniform vec3 in_textureExtentsMax; +uniform vec3 in_textureExtentsMin; + +// Material and lighting +uniform vec3 in_diffuse[4]; +uniform vec3 in_ambient[4]; +uniform vec3 in_specular[4]; +uniform float in_shininess[4]; + +// Others +uniform bool in_cellFlag; +uniform bool in_useJittering; +vec3 g_rayJitter = vec3(0.0); +uniform bool in_clampDepthToBackface; + +uniform vec2 in_averageIPRange; +uniform vec3 in_lightAmbientColor[1]; +uniform vec3 in_lightDiffuseColor[1]; +uniform vec3 in_lightSpecularColor[1]; +vec4 g_lightPosObj; +vec3 g_ldir; +vec3 g_vdir; +vec3 g_h; + + + const float g_opacityThreshold = 1.0 - 1.0 / 255.0; + +//VTK::Cropping::Dec + + + int clippingPlanesSize; + vec3 objRayDir; + mat4 textureToObjMat; + +//VTK::Shading::Dec + +//VTK::BinaryMask::Dec + +//VTK::CompositeMask::Dec + + +uniform sampler2D in_opacityTransferFunc; +float computeOpacity(vec4 scalar) + { + return texture2D(in_opacityTransferFunc, vec2(scalar.w, 0)).r; + } + + +vec4 computeGradient(int component) + { + return vec4(0.0); + } + + +vec4 computeLighting(vec4 color, int component) + { + vec4 finalColor = vec4(0.0); + finalColor = vec4(color.rgb, 0.0); + finalColor.a = color.a; + return finalColor; + } + + +uniform sampler2D in_colorTransferFunc; +vec4 computeColor(vec4 scalar, float opacity) + { + return computeLighting(vec4(texture2D(in_colorTransferFunc, + vec2(scalar.w, 0.0)).xyz, opacity), 0); + } + + +vec3 computeRayDirection() + { + return normalize(ip_vertexPos.xyz - g_eyePosObj.xyz); + } + +//VTK::Picking::Dec + +//VTK::RenderToImage::Dec + +//VTK::DepthPeeling::Dec + +/// We support only 8 clipping planes for now +/// The first value is the size of the data array for clipping +/// planes (origin, normal) +uniform float in_clippingPlanes[49]; +uniform float in_scale; +uniform float in_bias; + +////////////////////////////////////////////////////////////////////////////// +/// +/// Helper functions +/// +////////////////////////////////////////////////////////////////////////////// + +/** + * Transform window coordinate to NDC. + */ +vec4 WindowToNDC(const float xCoord, const float yCoord, const float zCoord) +{ + vec4 NDCCoord = vec4(0.0, 0.0, 0.0, 1.0); + + NDCCoord.x = (xCoord - in_windowLowerLeftCorner.x) * 2.0 * + in_inverseWindowSize.x - 1.0; + NDCCoord.y = (yCoord - in_windowLowerLeftCorner.y) * 2.0 * + in_inverseWindowSize.y - 1.0; + NDCCoord.z = (2.0 * zCoord - (gl_DepthRange.near + gl_DepthRange.far)) / + gl_DepthRange.diff; + + return NDCCoord; +} + +/** + * Transform NDC coordinate to window coordinates. + */ +vec4 NDCToWindow(const float xNDC, const float yNDC, const float zNDC) +{ + vec4 WinCoord = vec4(0.0, 0.0, 0.0, 1.0); + + WinCoord.x = (xNDC + 1.f) / (2.f * in_inverseWindowSize.x) + + in_windowLowerLeftCorner.x; + WinCoord.y = (yNDC + 1.f) / (2.f * in_inverseWindowSize.y) + + in_windowLowerLeftCorner.y; + WinCoord.z = (zNDC * gl_DepthRange.diff + + (gl_DepthRange.near + gl_DepthRange.far)) / 2.f; + + return WinCoord; +} + +////////////////////////////////////////////////////////////////////////////// +/// +/// Ray-casting +/// +////////////////////////////////////////////////////////////////////////////// + +/** + * Global initialization. This method should only be called once per shader + * invocation regardless of whether castRay() is called several times (e.g. + * vtkDualDepthPeelingPass). Any castRay() specific initialization should be + * placed within that function. + */ +void initializeRayCast() +{ + /// Initialize g_fragColor (output) to 0 + g_fragColor = vec4(0.0); + g_dirStep = vec3(0.0); + g_srcColor = vec4(0.0); + g_exit = false; + + + bool l_adjustTextureExtents = !in_cellFlag; + // Get the 3D texture coordinates for lookup into the in_volume dataset + g_dataPos = ip_textureCoords.xyz; + + // Eye position in dataset space + g_eyePosObj = (in_inverseVolumeMatrix * vec4(in_cameraPos, 1.0)); + if (g_eyePosObj.w != 0.0) + { + g_eyePosObj.x /= g_eyePosObj.w; + g_eyePosObj.y /= g_eyePosObj.w; + g_eyePosObj.z /= g_eyePosObj.w; + g_eyePosObj.w = 1.0; + } + + // Getting the ray marching direction (in dataset space); + vec3 rayDir = computeRayDirection(); + + // Multiply the raymarching direction with the step size to get the + // sub-step size we need to take at each raymarching step + g_dirStep = (ip_inverseTextureDataAdjusted * + vec4(rayDir, 0.0)).xyz * in_sampleDistance; + + // 2D Texture fragment coordinates [0,1] from fragment coordinates. + // The frame buffer texture has the size of the plain buffer but + // we use a fraction of it. The texture coordinate is less than 1 if + // the reduction factor is less than 1. + // Device coordinates are between -1 and 1. We need texture + // coordinates between 0 and 1. The in_noiseSampler and in_depthSampler + // buffers have the original size buffer. + vec2 fragTexCoord = (gl_FragCoord.xy - in_windowLowerLeftCorner) * + in_inverseWindowSize; + + if (in_useJittering) + { + float jitterValue = texture2D(in_noiseSampler, fragTexCoord).x; + g_rayJitter = g_dirStep * jitterValue; + g_dataPos += g_rayJitter; + } + else + { + g_dataPos += g_dirStep; + } + + // Flag to deternmine if voxel should be considered for the rendering + g_skip = false; + + + // Flag to indicate if the raymarch loop should terminate + bool stop = false; + + g_terminatePointMax = 0.0; + +#ifdef GL_ES + vec4 l_depthValue = vec4(1.0,1.0,1.0,1.0); +#else + vec4 l_depthValue = texture2D(in_depthSampler, fragTexCoord); +#endif + // Depth test + if(gl_FragCoord.z >= l_depthValue.x) + { + discard; + } + + // color buffer or max scalar buffer have a reduced size. + fragTexCoord = (gl_FragCoord.xy - in_windowLowerLeftCorner) * + in_inverseOriginalWindowSize; + + // Compute max number of iterations it will take before we hit + // the termination point + + // Abscissa of the point on the depth buffer along the ray. + // point in texture coordinates + vec4 terminatePoint = WindowToNDC(gl_FragCoord.x, gl_FragCoord.y, l_depthValue.x); + + // From normalized device coordinates to eye coordinates. + // in_projectionMatrix is inversed because of way VT + // From eye coordinates to texture coordinates + terminatePoint = ip_inverseTextureDataAdjusted * + in_inverseVolumeMatrix * + in_inverseModelViewMatrix * + in_inverseProjectionMatrix * + terminatePoint; + terminatePoint /= terminatePoint.w; + + g_terminatePointMax = length(terminatePoint.xyz - g_dataPos.xyz) / + length(g_dirStep); + g_currentT = 0.0; + + //VTK::Cropping::Init + + //VTK::Clipping::Init + + //VTK::RenderToImage::Init + + //VTK::DepthPass::Init +} + +/** + * March along the ray direction sampling the volume texture. This function + * takes a start and end point as arguments but it is up to the specific render + * pass implementation to use these values (e.g. vtkDualDepthPeelingPass). The + * mapper does not use these values by default, instead it uses the number of + * steps defined by g_terminatePointMax. + */ +vec4 castRay(const float zStart, const float zEnd) +{ + //VTK::DepthPeeling::Ray::Init + + //VTK::DepthPeeling::Ray::PathCheck + + //VTK::Shading::Init + + /// For all samples along the ray + while (!g_exit) + { + + g_skip = false; + + //VTK::Cropping::Impl + + //VTK::Clipping::Impl + + //VTK::BinaryMask::Impl + + //VTK::CompositeMask::Impl + + + if (!g_skip) + { + vec4 scalar = texture3D(in_volume, g_dataPos); + scalar.r = scalar.r*in_volume_scale.r + in_volume_bias.r; + scalar = vec4(scalar.r,scalar.r,scalar.r,scalar.r); + g_srcColor = vec4(0.0); + g_srcColor.a = computeOpacity(scalar); + if (g_srcColor.a > 0.0) + { + g_srcColor = computeColor(scalar, g_srcColor.a); + // Opacity calculation using compositing: + // Here we use front to back compositing scheme whereby + // the current sample value is multiplied to the + // currently accumulated alpha and then this product + // is subtracted from the sample value to get the + // alpha from the previous steps. Next, this alpha is + // multiplied with the current sample colour + // and accumulated to the composited colour. The alpha + // value from the previous steps is then accumulated + // to the composited colour alpha. + g_srcColor.rgb *= g_srcColor.a; + g_fragColor = (1.0f - g_fragColor.a) * g_srcColor + g_fragColor; + } + } + + //VTK::RenderToImage::Impl + + //VTK::DepthPass::Impl + + /// Advance ray + g_dataPos += g_dirStep; + + + if(any(greaterThan(g_dataPos, in_texMax)) || + any(lessThan(g_dataPos, in_texMin))) + { + break; + } + + // Early ray termination + // if the currently composited colour alpha is already fully saturated + // we terminated the loop or if we have hit an obstacle in the + // direction of they ray (using depth buffer) we terminate as well. + if((g_fragColor.a > g_opacityThreshold) || + g_currentT >= g_terminatePointMax) + { + break; + } + ++g_currentT; + } + + //VTK::Shading::Exit + + return g_fragColor; +} + +/** + * Finalize specific modes and set output data. + */ +void finalizeRayCast() +{ + //VTK::Base::Exit + + //VTK::Terminate::Exit + + //VTK::Cropping::Exit + + //VTK::Clipping::Exit + + //VTK::Picking::Exit + + g_fragColor.r = g_fragColor.r * in_scale + in_bias * g_fragColor.a; + g_fragColor.g = g_fragColor.g * in_scale + in_bias * g_fragColor.a; + g_fragColor.b = g_fragColor.b * in_scale + in_bias * g_fragColor.a; + fragOutput0 = g_fragColor; + + //VTK::RenderToImage::Exit + + //VTK::DepthPass::Exit +} + +////////////////////////////////////////////////////////////////////////////// +/// +/// Main +/// +////////////////////////////////////////////////////////////////////////////// +void main() +{ + + initializeRayCast(); + castRay(-1.0, -1.0); + finalizeRayCast(); +} + + diff --git a/shaders/pts/paraview-1.0.3/wavelet-volume/9.shader_test b/shaders/pts/paraview-1.0.3/wavelet-volume/9.shader_test new file mode 100644 index 0000000..d328dc9 --- /dev/null +++ b/shaders/pts/paraview-1.0.3/wavelet-volume/9.shader_test @@ -0,0 +1,240 @@ +[require] +GLSL >= 1.50 + +[vertex shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define attribute in +#define varying out +#endif // 300 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define attribute in +#define varying out +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: vtkPolyDataVS.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ + +attribute vec4 vertexMC; + +// frag position in VC +//VTK::PositionVC::Dec + +// optional normal declaration +//VTK::Normal::Dec + +// extra lighting parameters +//VTK::Light::Dec + +// Texture coordinates +//VTK::TCoord::Dec + +// material property values +//VTK::Color::Dec + +// clipping plane vars +//VTK::Clip::Dec + +// camera and actor matrix values +uniform mat4 MCDCMatrix; + +// Apple Bug +//VTK::PrimID::Dec + +// Value raster +//VTK::ValuePass::Dec + +void main() +{ + //VTK::Color::Impl + + //VTK::Normal::Impl + + //VTK::TCoord::Impl + + //VTK::Clip::Impl + + //VTK::PrimID::Impl + + gl_Position = MCDCMatrix * vertexMC; + + + //VTK::ValuePass::Impl + + //VTK::Light::Impl +} + + +[fragment shader] +#version 150 +#ifdef GL_ES +#if __VERSION__ == 300 +#define varying in +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +precision highp sampler2D; +precision highp sampler3D; +#else +precision mediump float; +precision mediump sampler2D; +precision mediump sampler3D; +#endif +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif // 300 +#if __VERSION__ == 100 +#extension GL_OES_standard_derivatives : enable +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else +precision mediump float; +#endif +#endif // 100 +#else // GL_ES +#define highp +#define mediump +#define lowp +#if __VERSION__ == 150 +#define varying in +#define texelFetchBuffer texelFetch +#define texture1D texture +#define texture2D texture +#define texture3D texture +#endif +#if __VERSION__ == 120 +#extension GL_EXT_gpu_shader4 : require +#endif +#endif // GL_ES + + +/*========================================================================= + + Program: Visualization Toolkit + Module: vtkPolyDataFS.glsl + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ +// Template for the polydata mappers fragment shader + +uniform int PrimitiveIDOffset; + +// VC position of this fragment +//VTK::PositionVC::Dec + +// optional color passed in from the vertex shader, vertexColor +uniform float opacityUniform; // the fragment opacity +uniform vec3 ambientColorUniform; // intensity weighted color +uniform vec3 diffuseColorUniform; // intensity weighted color + + +// optional surface normal declaration +//VTK::Normal::Dec + +// extra lighting parameters +//VTK::Light::Dec + +// Texture coordinates +//VTK::TCoord::Dec + +// picking support +//VTK::Picking::Dec + +// Depth Peeling Support +//VTK::DepthPeeling::Dec + +// clipping plane vars +//VTK::Clip::Dec + +// the output of this shader +out vec4 fragOutput0; + + +// Apple Bug +//VTK::PrimID::Dec + +// handle coincident offsets +//VTK::Coincident::Dec + +// Value raster +//VTK::ValuePass::Dec + +void main() +{ + // VC position of this fragment. This should not branch/return/discard. + //VTK::PositionVC::Impl + + // Place any calls that require uniform flow (e.g. dFdx) here. + //VTK::UniformFlow::Impl + + // Set gl_FragDepth here (gl_FragCoord.z by default) + //VTK::Depth::Impl + + // Early depth peeling abort: + //VTK::DepthPeeling::PreColor + + // Apple Bug + //VTK::PrimID::Impl + + //VTK::Clip::Impl + + //VTK::ValuePass::Impl + + vec3 ambientColor; + vec3 diffuseColor; + float opacity; + ambientColor = ambientColorUniform; + diffuseColor = diffuseColorUniform; + opacity = opacityUniform; + + + // Generate the normal if we are not passed in one + //VTK::Normal::Impl + + fragOutput0 = vec4(ambientColor + diffuseColor, opacity); + //VTK::Light::Impl + + + //VTK::TCoord::Impl + + if (fragOutput0.a <= 0.0) + { + discard; + } + + //VTK::DepthPeeling::Impl + + //VTK::Picking::Impl + + // handle coincident offsets + //VTK::Coincident::Impl +} + + |