19 replies to this topic

[Gamer3D]

This forum is, as of the time of writing, focused entirely too much on fragment (pixel) shaders, and is ignoring the possibilities offered by vertex shaders. This is silly, so I put about an hour into making a nice, pretty vertex shader to demonstrate what you're missing.

With that in mind, I made a dual-quaternion skinning shader. In simple terms, it facilitates skeletal animation without some of the artifacts caused by linear skinning.

Supports:

• Customizable features. Skinning can be easily disabled, as can the tangent-space calculation, etc.
• Up to 3 bones/blend weights per vertex (48 total bones possible by default).
• Blended tangent-space (for effects such as tangent-space normal mapping)
• World-to-tangent space calculations, for effects such as relief mapping.

Screenshot:

Download GMZ (10.63 MiB)

Shaders:

Spoiler

Vertex (Complete):

//  Dual-quaternion skinning shader. Supports 3 weights and tangent-space.
/*    Minized-attribute version. Packing permits information for surfaces and 3
//  bone index/weight pairs to be passed per vertex, staying within GM's four
//  documented attribute names.
*/

//--------------------------Section: Customization---------------------------||
/*  Blend quality list:
//    Undefined: No blending.
//    0:  Quality only acceptable for rotations of 180 degrees or fewer.
//    1:  Good quality on the full range of rotations.
//    2:  Full quality
*/
#define SKINDQ_BLEND_QUALITY 2
//  Specifies the world transformation to be used.
#define SKINDQ_APPLY_D3D_TRANSFORM
//  Send a tangent-space eye vector (eye - position) to the fragment shader.
#define SKINDQ_EMIT_LOCAL_EYE
//  Send an orthonormalized basis for the tangent-space to the fragment shader.
#define SKINDQ_EMIT_TBN
//  Send world-space position to the fragment shader.
#define SKINDQ_EMIT_POSITION

//----------------------------Section: Uniforms------------------------------||
/*    Each bone's transformation (in the neutral pose) is specified by a dual
//  quaternion.
*/
const int k_MaxBlends = 48;  //  Must not exceed gl_MaxVertexUniformVectors / 2;
uniform vec4 u_BlendReal  [k_MaxBlends];
uniform vec4 u_BlendDual  [k_MaxBlends];

uniform vec3 u_Vertex_Eye;

//------------------------Section: Vertex Attributes-------------------------||
//  Vertex data is specified in neutral-pose space.
/*    Note: The names Tangent and Binormal are misleading. These are actually
//  the texture-space vectors <1, 0> and <0, 1> transformed into neutral-pose
//  space. The basis passed to the fragment shader is generated from these.
*/
attribute vec4 in_Position;     //  xyz = Position,     w   = 1st blend index
attribute vec4 in_Colour;       //  xyz = U (Tangent),  w   = 2nd blend index
attribute vec4 in_Normal;       //  xyz = V (Binormal), w   = 3rd blend index. Must be non-zero. Negate if tangent-space is left-handed.
attribute vec4 in_TextureCoord; //  xy  = Texture,      zw  = 1st and 2nd blend weights. Third is implicit: 1-(z+w).

//-----------------------------Section: Varying------------------------------||
//  Texture coordinate, for texturing purposes (duh).
varying vec2 v_TextureCoord;
//  World-space location of the given fragment, to simplify lighting calculations.
#ifdef SKINDQ_EMIT_POSITION
varying vec3 v_Position;
#endif
//  Tangent-space eye vector. To be more precise, this is a vector from the fragment to the camera.
#ifdef SKINDQ_EMIT_LOCAL_EYE
varying vec3 v_Local_Eye;
#endif
//  Tangent-Binormal-Normal matrix, forced to be unitary because typical normal maps rely on it.
#ifdef SKINDQ_EMIT_TBN
varying mat3 v_TBN;
#else
varying vec3 v_Normal;
#endif

//---------------------------Section: Preparation----------------------------||
//  Set up transformations.
#ifdef SKINDQ_APPLY_D3D_TRANSFORM
#define SKINDQ_TRANSFORM_VIEW_PROJ gm_Matrices[MATRIX_WORLD_VIEW_PROJECTION]*(
#define SKINDQ_TRANSFORM gm_Matrices[MATRIX_WORLD]*
#else
#define SKINDQ_TRANSFORM_VIEW_PROJ gm_Matrices[MATRIX_PROJECTION]*(gm_Matrices[MATRIX_VIEW]*
#define SKINDQ_TRANSFORM
#endif

//  xyzw -> xi + yj + zk + w.
/*vec3 DQTransform(vec3 p, vec4 QReal, vec4 QDual) {
  return p + 2.0 * (cross(QReal.xyz, cross(QReal.xyz, p) + QReal.w * p) + QReal.w * QDual.xyz - QDual.w * QReal.xyz + cross(QReal.xyz, QDual.xyz));
}*/
vec3 QRotate(vec3 p, vec4 QReal) {
  return p + 2.0 * cross(QReal.xyz, cross(QReal.xyz, p) + QReal.w * p);
}

//-----------------------------Section: Shader-------------------------------||
void main() {
//  Unpack nuetral-pose (pre-transform) data, for convenient access.
  //  Vertex position
  vec3 neutral_position = in_Position.xyz;
  //  Texture coordinate.
  v_TextureCoord = in_TextureCoord.xy;
  //  Tangent space
  vec3 neutral_tangent  = in_Colour.xyz;
  vec3 neutral_binormal = in_Normal.xyz;
  float neutral_handedness = sign(in_Normal.w);

//---------------------------Subsection: Blending----------------------------||
//  Blends are transformations from pose-space to object-space.
#ifdef SKINDQ_BLEND_QUALITY
  //  Blend information
  vec3 blend_weight = vec3( in_TextureCoord.zw,
                            1.0 - (in_TextureCoord.z + in_TextureCoord.w));
  ivec3 blend_index = ivec3(in_Position.w, in_Colour.w, abs(in_Normal.w));
  
//  Calculate weighted blend.
  //  First, linearly interpolate blends by weight.
  vec4  blend_real =  u_BlendReal[blend_index.x] * blend_weight.x +
                      u_BlendReal[blend_index.y] * blend_weight.y +
                      u_BlendReal[blend_index.z] * blend_weight.z;
  vec4  blend_dual =  u_BlendDual[blend_index.x] * blend_weight.x +
                      u_BlendDual[blend_index.y] * blend_weight.y +
                      u_BlendDual[blend_index.z] * blend_weight.z;
//  Dual quaternions may have a dual norm, but it is more expensive to compute.
//  Additionally, the dual part of the quaternion has no effect on the real (rotation) part of the norm.
#if (SKINDQ_BLEND_QUALITY >= 1)
  float blend_norm_real = length(blend_real);
  blend_real /= blend_norm_real;  //  .yzwx
#if (SKINDQ_BLEND_QUALITY >= 2)
  blend_dual = (blend_dual - blend_real * dot(blend_real, blend_dual)) / blend_norm_real;
#else
  blend_dual /= blend_norm_real;
#endif
#endif

//  Blend is applied as rotate, then offset. Dual does not affect rotation.
  vec3 blend_offset = 2.0 * ( blend_real.w * blend_dual.xyz -
                              blend_dual.w * blend_real.xyz +
                              cross(blend_real.xyz, blend_dual.xyz));

//  Calculate vertex position, in object-space.
  vec4 object_position = vec4(QRotate(neutral_position, blend_real) + blend_offset, 1.0);
#else
  vec4 object_position = vec4(neutral_position, 1.0);
#endif

//-----------------------Subsection: Vertex Position-------------------------||
//  This moves position from object-space to world-space.
#ifdef SKINDQ_EMIT_POSITION
  v_Position  = (SKINDQ_TRANSFORM object_position).xyz;
#elif (defined(SKINDQ_EMIT_LOCAL_EYE))
  vec3 v_Position = (SKINDQ_TRANSFORM object_position).xyz;
#endif
//  This moves position from object-space to projection-space.
  gl_Position = SKINDQ_TRANSFORM_VIEW_PROJ object_position);

//------------------------Subsection: Tangent Space--------------------------||
//  Create the transformation from tangent-space to world-space.
#ifdef SKINDQ_BLEND_QUALITY
  vec3  world_tangent  = (SKINDQ_TRANSFORM vec4(QRotate(neutral_tangent,  blend_real), 0.0)).xyz;
  vec3  world_binormal = (SKINDQ_TRANSFORM vec4(QRotate(neutral_binormal, blend_real), 0.0)).xyz;
#else
  vec3  world_tangent  = (SKINDQ_TRANSFORM vec4(neutral_tangent,  0.0)).xyz;
  vec3  world_binormal = (SKINDQ_TRANSFORM vec4(neutral_binormal, 0.0)).xyz;
#endif
  //  Generating the normal from the tangent and binormal gives correct results under non-uniform scaling.
  vec3  world_normal   = cross(world_tangent, world_binormal);

#ifndef SKINDQ_EMIT_TBN
  v_Normal = normalize(neutral_handedness * world_normal);
#endif

#ifdef SKINDQ_EMIT_LOCAL_EYE
//  Transform the eye vector into tangent-space. Requires inverse of TBN.
  float world_TBN_determinant = dot(world_normal, world_normal);
  mat3  world_TBN_inverse = mat3( cross(world_binormal, world_normal) / world_TBN_determinant,
                                  cross(world_normal, world_tangent) / world_TBN_determinant,
                                  normalize(neutral_handedness * world_normal));
  v_Local_Eye = world_TBN_inverse * (u_Vertex_Eye - v_Position);

//  Create the unitary matrix for normals.
#ifdef SKINDQ_EMIT_TBN
  v_TBN = mat3(normalize(world_tangent), normalize(world_TBN_inverse[1]), world_TBN_inverse[2]);
#endif
#else
//  Create the unitary matrix for normals.
#ifdef SKINDQ_EMIT_TBN
  v_TBN = mat3(normalize(world_tangent), normalize(cross(world_normal, world_tangent)), normalize(neutral_handedness * world_normal));
#endif
#endif
}

Fragment (Incomplete):

Spoiler

//  Simple normal-mapping fragment shader.
varying vec3 v_Position;
varying mat3 v_TBN;
varying vec3 v_Local_Eye;
varying vec2 v_TextureCoord;

uniform vec3 u_Fragment_Eye;

//uniform int u_ConeSteps;
uniform sampler2D s_Normal;
uniform sampler2D s_Relief;
//  Scale
uniform float u_ReliefScale;
const ivec2 relief_quality = ivec2(9, 3);//ivec2(5, 2);

const vec3 light_pos = vec3(0.0, 16.0, 2.0);

vec3 raycast_conemap (sampler2D relief, float relief_scale, vec2 origin, vec3 ray) {
//  Pure, unaltered ray.
  vec2 ray_offset = relief_scale * ray.xy / ray.z;
//  Scaled, to avoid noise at grazing angles.
  //vec2 ray_offset = relief_scale * ray.z * ray.xy / dot(ray, ray);
  //ray_offset *= smoothstep(0.3, 0.7, normalize(ray).z);

//  No division by zero on my watch.
  float ray_slope = max(1.0/2048.0, length(ray_offset));
  float depth_sample = 0.0;
  float depth_delta = 0.0;
//  Use martini stepping instead of a linear search.
  for (int iteration = 0; iteration < relief_quality.x; ++iteration)
  {
    depth_sample += depth_delta;
    vec4 relief_sample = texture2D(relief, origin - depth_sample * ray_offset);
    if (relief_sample.r <= depth_sample) {
      depth_delta = -depth_delta;
      break;
    }
//  By storing the square-root, I get better precision for small cones and less damage from linear interpolation.
    float cone_slope = relief_sample.g * relief_sample.g;
//  The usual implementation of relaxed cone-stepping provides good convergence when the ray overshoots a peak, but has cases of slow convergence.
    //depth_delta = (relief_sample.r - depth_sample) * cone_slope / (ray_slope + cone_slope);
//  The essence of martini stepping is to use a union of cone and cylinder (hence the name). The cylinder will have radius <= cone radius at depth 0.
    depth_delta = cone_slope * max(relief_sample.b / ray_slope, (relief_sample.r - depth_sample) / (ray_slope + cone_slope));

//  Want to try a linear search instead? Uncomment this.
    //depth_delta = 1.0 / float(relief_quality.x);
  }
//  Cylinder mapping permits rays to punch through the floor. This corrects such situations.
  /*depth_delta = clamp(depth_delta + depth_sample, 0.0, 1.0);
  depth_sample = clamp(depth_sample, 0.0, 1.0);
  depth_delta -= depth_sample;*/
//  Next, refine the point using a binary search.
  for (int iteration = 0; iteration < relief_quality.y; ++iteration)
  {
    depth_delta /= 2.0;
    float depth_middle = depth_sample + depth_delta;
    vec4 heightmap_sample = texture2D(relief, origin - depth_middle * ray_offset);
    depth_sample += depth_delta * step(depth_middle * depth_delta, heightmap_sample.r * depth_delta);
  }
//  Once "close enough" to the final point, secant method can smooth results. Note: By saving old data, I could get this down to 1 texture fetch.
  /*{
    float sample_1 = texture2D(relief, origin - (depth_sample) * ray_offset).r;
    float sample_2 = texture2D(relief, origin - (depth_sample + depth_delta) * ray_offset).r;
    depth_sample = (sample_1 * depth_delta - (sample_2 - sample_1) * depth_sample) / (depth_delta - (sample_2 - sample_1));
  }*/
  return vec3(origin - depth_sample * ray_offset, depth_sample);
}

void main() {
  vec2 sample_point = raycast_conemap(s_Relief, u_ReliefScale, v_TextureCoord, v_Local_Eye).xy;
  //gl_FragColor = vec4(sample_point, 0.0, 1.0);
  //return;


  //vec2 sample_point = v_TextureCoord - (4.0 * v_TextureCoord.x * (1.0 - v_TextureCoord.x) * v_TextureCoord.y * (1.0 - v_TextureCoord.y)) * v_Local_Eye.xy / v_Local_Eye.z;
  
  //vec2 sample_point = v_TextureCoord - (1.0 - texture2D(s_NormalMap, v_TextureCoord).a) * 0.2 * v_Local_Eye.xy / v_Local_Eye.z;
  //vec3 eye_pos = (gm_Matrices[MATRIX_VIEW] * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
  vec4 NormalSpecular = texture2D(s_Normal, sample_point);
//  I could normalize it, but it should be pretty close anyway.  
  vec3 N = (NormalSpecular.rgb * 255.0/128.0 - vec3(1.0)) * v_TBN;
  vec3 L = normalize(light_pos - v_Position);
  
  vec3 l_diffuse = vec3(0.0, 0.0, 0.0);
  vec3 l_specular = vec3(0.0, 0.0, 0.0);
  
  float lambert = dot(N,L);
  if (lambert > 0.0) {
    /*float d = min(dist/lightRadius,1.0);
    float attenuation = 1.0 - d;*/
    
    l_diffuse = vec3(1.0) * lambert;// * attenuation * lightIntensity;
    
    vec3 R = reflect(L,N);
    vec3 V = normalize(v_Position - u_Fragment_Eye);
    float spec = pow(max(dot(R,V), 0.0), 40.0);
    l_specular = vec3(1.0) * spec;// * attenuation * lightIntensity; //* texture2D(texSpecular,texCoord.xy).rgb
  }

  gl_FragColor = vec4(l_diffuse + vec3(0.2), 1.0) * texture2D(gm_BaseTexture, sample_point) + vec4(l_specular, 0.0);//vec4(normalize(normal) * 0.5 + vec3(0.5), 1.0);// * texture2D(gm_BaseTexture, v_TextureCoord);
  //gl_FragColor = vec4(normalize(v_TBN[0]) * 0.5 + 0.5, 1.0);
  //gl_FragColor = vec4(normal * 0.5 + vec3(0.5), 1.0);
}

How to use it:

• Copy the vertex shader.
• Discard the features you don't plan to use. If you're not planning to use something that requires the surface's tangent-space, for example, then get rid of that part of the code.
• Code your fragment shader. It could be a simple passthrough shader; it could be normal-mapping, parallax mapping, etc.
• Set up the custom vertex format. If you haven't modified the way I use vertex attributes, this will be 4 4-float vectors, with component-use specified in the comments in the vertex shader.
• Set up your model. Each vertex will require the vertex's position (in the neutral pose), the indices of the bones it uses, the weights of the first 2 bones (the third is defined implicitly to force them to sum to 1), and (if you've left the shader as-is) the tangent and binormal.
• (Recommended) Freeze your buffer after setting up your model. If your animations are skeletal, you shouldn't need to modify your model very often.
• Set up the skeleton. Create 2 1-dimensional arrays, one for the real part of the dual quaternions, one for the dual part. Fill each with the appropriate quaternions. Note: Quaternions are in xyzw format, where xyz is the imaginary part.
• Pass the arrays to the uniforms u_BoneQReal and u_BoneQDual, then render.

Textures in the example are from Kay's Blog.


EDIT (2013-12-14): The vertex shader is now rather full-featured. The fragment shader is not complete, but has an implementation of relief mapping. When I get the fragment shader and a full example done, I'll update the demo.
EDIT (2013-12-17): Relief-mapping bug fix. Added relief-mapping demo. Fragment shader/example still incomplete.
EDIT (2014-02-06): I'm moving on to greener pastures (C++ and SDL). I've uploaded my latest version of this project, which includes a script for setting the dual quaternions; all you need to know is how to use regular quaternions, which is very basic knowledge.

Edited by Gamer3D, 06 February 2014 - 06:31 PM.

[jsorgeagames]

Really great stuff! Thanks for taking this forum in a direction it hasn't been yet.

[slayer 64]

i don't like dealing with quaternions component by component. the shader's nice though.

[Alvare]

@Gamer3D

I dunno anything about what you're talking about.. but you should continue working with shaders man. xD

I'll read trough the pdf you posted.

 

Also.. thank you for posting that site. Really good quality textures.

Edited by Alvare, 18 December 2013 - 01:02 PM.

[Gamer3D]

i don't like dealing with quaternions component by component. the shader's nice though.

You can manipulate the quaternions however you want, but you must eventually copy them to an array to pass them to the shader. Unless YoYo adds a shader_set_uniform_f_grid function, there's no other choice.

A word of warning: Avoid modifying the blend array in scripts, for performance reasons. GM doesn't pass arrays by reference (at least not if the function needs to change it), instead copying the entire array. For 64 dual quaternions, that copies 512 variables (doubled if GM copies the array twice) per manipulation, for about 32000 copies total.
If manipulated separately, this can be reduced to 512 extra copy operations, and fewer still if some bones are unused.

[blackhawkrobbo]

Would there be an easy way to implement this onto existing models?

[KayVriend]

Also.. thank you for posting that site. Really good quality textures.

 

Thanks! Much appreciated. I´m not a shader wiz, but cool idea!

 

Please let me know if you use/want to use some of my work so i can feature it on my blog, or if you have requests .

 

Cheers!

[Gamer3D]

Would there be an easy way to implement this onto existing models?

Yes and no. The tangent space computations are easy to automate, but unless your model format supports skinning (tracking which bones affect each vertex, and by how much), you will need to add the blend weights manually.

Something to be aware of is that the shader currently assumes that the tangent space is right-handed. If your UV mapping involves mirrored triangles (or triangles with mirrored UV coordinates), the normal will be computed incorrectly.
The shader can be modified to permit left-handed tangent spaces by adding additional vertex information indicating whether to negate the normal. Because the shader is currently using the entirety of GM's documented bandwidth, this information would necessarily need to be packed into pre-existing information, using a scheme similar to one of the following:

• Negative blend weight (for first blend) indicates that normal should be negated. Ordering the blend weights in decreasing order guarantees uniqueness.
• Negative blend index (for third blend) indicates that normal should be negated. Ordering the blend indices in increasing order guarantees uniqueness.

[blackhawkrobbo]

Okay, so that would be for an animated model, right? What about simple D3D models (e.g. imported from an .obj) that are rotated once, such as trees, benches, barrels etc. ?

My guess is that this should be easy. The other thing i'd like to add would be FPS weapons, say, a gun with normal mapping that changes as you rotate the character. Now i'm kind of a noob when talking about tangent spaces, blend weights and what not. Would you be able to create a simple example of some kind?

Thanks a ton in advance!

[Gamer3D]

blackhawkrobbo, on 30 Sept 2013 - 08:21, said:
Okay, so that would be for an animated model, right? What about simple D3D models (e.g. imported from an .obj) that are rotated once, such as trees, benches, barrels etc. ?

Blend weights are only important for animated models. For a static model, this particular shader is overkill; you could (probably) remove half of its instructions, or more, and still have the important parts for static models (for a static model, all you really need to do is transform the position to view-space and rotate the tangent space).
 

blackhawkrobbo, on 30 Sept 2013 - 08:21, said:
My guess is that this should be easy. The other thing i'd like to add would be FPS weapons, say, a gun with normal mapping that changes as you rotate the character. Now i'm kind of a noob when talking about tangent spaces, blend weights and what not. Would you be able to create a simple example of some kind?

The example will need to wait until I complete a different project. When I have time, I intend to create such an example, as well as update the shader with a few things such as:

• Support for both left and right-handed tangent spaces.
• A better implementation of normal mapping. The current fragment shader is severely limited (it's just a placeholder, after all), and may not give proper results if the model has been scaled non-uniformly.
• Possibly switching from the TBN matrix to its inverse.
• Examples of shaders optimized for specific situations. For example, a separate vertex shader dedicated to static models and a vertex/fragment shader-pair for transformations consisting only of rotation, translation, and uniform scaling.
• Examples of how to use tangent-space for various effects (Like normal mapping, parallax mapping, etc.), with discussions of exactly why it is used in that fashion.

EDIT (2013-12-17): I have crossed out all the features I have completed at this date.

Edited by Gamer3D, 18 December 2013 - 04:45 AM.

[Alvare]

Parallax mapping! =D

Although.. it will make distant textures appear even more crispy when not using mipmapping.

 

There's also alot of work in getting all these shaders combined, right?

[FrozenFireZFGC]

Shoot, I need to animate 3D hair and to bend models to move/animate arms, legs, etc., and this looks like what I need to understand. *sigh* I really need to learn about shaders.

Even though I don't understand it enough to implement it as I need to, thanks for this. I'm sure I can learn something from it if I can get enough free time to learn about shaders.

[Gamer3D]

I've gotten relief mapping to the point where I will show it off. It's still not a full example/tutorial, but the following ease-of-use improvements have been made:

• The script shdr_skindq_set_blend has been provided to permit easy use of bones (it simplifies user effort to supplying a position and quaternion).
• The work-in-progress script shdr_skindq_set automatically sets many variables, a process which includes extracting the camera location from its matrix.
• The vertex shader now uses the preprocessor to allow easy removal of unused features. For example, if you're not using relief mapping, you can--by commenting out a single line--turn off the additional calculations required for the effect.

The remaining to-do list:

• Demo, with examples of various effects and more comments on why each choice was made.
• Choose additional effects to demonstrate. I've got normal mapping and relief mapping, but I might want to improve the whole thing by choosing a different lighting model, adding reflections, etc.
• Fully comment the fragment shader.
• Finalize some vertex-shader choices.
• Release GFX-card accelerated relief map baking software. "Baking" additional visibility information permits martini-stepping, an improvement I made to relaxed cone-stepping, which is again an improvement over searching linearly.
• Create command-line relief map baking software with support for batches.

Edited by Gamer3D, 18 December 2013 - 06:41 AM.

[MishMash]

Wow that looks incredible! Have you tried this on other textures / shapes? Was just curious as to what performance is like ! Great job!

[Gamer3D]

Wow that looks incredible! Have you tried this on other textures / shapes? Was just curious as to what performance is like ! Great job!

I have tested the algorithm on other textures, including the classic lion sculpture. In each case, image quality was approximately as good as for the chesterfield texture.

The following benchmarks are created on an Ivy Bridge integrated graphics chip.

Performance on full detail:

• Vertexes per second: 65075324 (102860996 without skinning)
• Pixels per second: 292552704 (585105408 without relief mapping)

For reference, the default pass-through shader has the following performance:

• Vertexes per second: 102860996
• Pixels per second: 698351616

[MishMash]

Ahh nice! I really can't wait for this to be fully featured, Just curious, do you know of any good software for generating relief maps? I tried a few i found online but they didn't seem to work.
Also, in the future, would you be willing to create a stand-alone demo showing off the relief mapping alone, without the DQ skinning, and just on a regular model. This is going to look incredible on things like walls and floors! 

[Gamer3D]

Ahh nice! I really can't wait for this to be fully featured, Just curious, do you know of any good software for generating relief maps? I tried a few i found online but they didn't seem to work.

Crazybump seems to be the gold standard. Not sure if free.

Also, simply importing a relief map is insufficient for use with the relief-mapping part of the shader. The ray-casting code I wrote uses additional information about the texture, so to use a relief map, you must first process it (I've made a tool for that, but its interface needs a bit of work before release) or switch to a linear search (there's a line in the fragment shader for you to uncomment).
 

Also, in the future, would you be willing to create a stand-alone demo showing off the relief mapping alone, without the DQ skinning, and just on a regular model. This is going to look incredible on things like walls and floors!

I'll add it to the to-do list. If you want to do this yourself, comment out the following line:

#define SKINDQ_BLEND_QUALITY 2

Once that line is removed, the shader will no longer perform any skinning operations. Currently, the defined uniforms and vertex attributes remain the same, but this isn't particularly difficult to alter. The reason I don't automatically disable them is that it would require changing a lot of non-shader code after each revision (need to remove requests for uniforms and alter the method used for building the vertexes).

[MishMash]

 

 

Crazybump seems to be the gold standard. Not sure if free.

Also, simply importing a relief map is insufficient for use with the relief-mapping part of the shader. The ray-casting code I wrote uses additional information about the texture, so to use a relief map, you must first process it (I've made a tool for that, but its interface needs a bit of work before release) or switch to a linear search (there's a line in the fragment shader for you to uncomment).

Ahh k, yeah i use Crazy bump atm for normal maps, wasnt sure if the relief ones needed a different technique, Looking forward to being able to use your program.

Great job so far anyway!

[Gamer3D]

Here's the relief-map baking tool: Executable or Source Code

This tool takes a heightmap (white for details at the surface, black for details at maximum depth) and generates the data necessary for martini-stepping. To be more specific, it stores the following data:

• Red channel: Depth map (full red for maximum depth, black for details at the surface).
• Green channel: Square-root of slope of relaxed cone.
• Blue channel: Cylinder radius, as a fraction of cone radius at one unit above cone vertex.
• Alpha channel: Unused.

[blackhawkrobbo]

That is really cool, gamer, gonna check that out in a second