Glsl mod vs Hlsl fmod

Question

Implementé el sombreado GLSL en espiral descrito en el subproceso stackflow How to implement this rotating spiral in WebGL? en HLSL pero los resultados no son los mismos y creo que es debido a la función mod en GLSL que he traducido a fmod en HLSL. He intentado reemplazar la llamada a mod por una llamada personalizada a una función que he creado que hace lo que se describe en la documentación de GSLS (http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml) y funciona:

mod devuelve el valor de x modulo y . Esto se calcula como x - y * piso (x/y).

La función fmod según la documentación de MSDN http://msdn.microsoft.com/en-us/library/windows/desktop/bb509601(v=vs.85).aspx, dice lo siguiente:

El punto flotante resto se calcula de tal manera que x = i * y + f, donde i es un número entero, f tiene el mismo signo que x, y el valor absoluto de f es menor que el valor absoluto de y.

He utilizado el convertidor de HLSL a GLSL alojado en http://sourceforge.net/projects/hlsl2glsl y la función fmod se traduce como mod, sin embargo, no sé si puedo suponer que mod se traduce a fmod.

Mi pregunta es, ¿cuáles son las diferencias entre las dos funciones y cómo puedo traducir la descripción criptográfica msdn de fmod a una implementación de pseudo-código?

sospecho que este problema sólo ocurre cuando tenemos números negativos en la entrada de la función HOQF

GLSL Shader:

uniform float time; 
uniform vec2 resolution; 
uniform vec2 aspect; 

void main(void) { 
    vec2 position = -aspect.xy + 2.0 * gl_FragCoord.xy/resolution.xy * aspect.xy; 
    float angle = 0.0 ; 
    float radius = length(position) ; 
    if (position.x != 0.0 && position.y != 0.0){ 
    angle = degrees(atan(position.y,position.x)) ; 
    } 
    float amod = mod(angle+30.0*time-120.0*log(radius), 30.0) ; 
    if (amod<15.0){ 
    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0); 
    } else{ 
    gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);      
    } 
} 

HLSL Shader:

struct Psl_VertexShaderInput 
{ 
    float3 pos : POSITION; 
}; 

struct Psl_VertexShaderOutput 
{ 
    float4 pos : POSITION; 

}; 

struct Psl_PixelShaderOutput 
{ 
    float4 Output0 : COLOR0; 
}; 

float3 psl_positionOffset; 
float2 psl_dimension; 

Psl_VertexShaderOutput Psl_VertexShaderFunction(Psl_VertexShaderInput psl_input) 
{ 
    Psl_VertexShaderOutput psl_output = (Psl_VertexShaderOutput)0; 

    psl_output.pos = float4(psl_input.pos + psl_positionOffset, 1); 


    return psl_output; 
} 

float time : TIME; 
float2 resolution : DIMENSION; 


Psl_PixelShaderOutput Psl_PixelShaderFunction(float2 pos : VPOS) 
{ 
    Psl_PixelShaderOutput psl_output = (Psl_PixelShaderOutput)0; 

    float2 aspect = float2(resolution.x/resolution.y, 1.0); 
    float2 position = -aspect.xy + 2.0 * pos.xy/resolution.xy * aspect.xy; 
    float angle = 0.0; 
    float radius = length(position); 
    if (position.x != 0.0 && position.y != 0.0) 
    { 
     angle = degrees(atan2(position.y, position.x)); 
    } 
    float amod = fmod((angle + 30.0 * time - 120.0 * log(radius)), 30.0); 
    if (amod < 15.0) 
    { 
     psl_output.Output0 = float4(0.0, 0.0, 0.0, 1.0); 
     return psl_output; 
    } 

    else 
    { 
     psl_output.Output0 = float4(1.0, 1.0, 1.0, 1.0); 
     return psl_output; 
    } 

} 

technique Default 
{ 
    pass P0 
    { 
     VertexShader = compile vs_3_0 Psl_VertexShaderFunction(); 
     PixelShader = compile ps_3_0 Psl_PixelShaderFunction(); 
    } 
} 

tengo no hay problema si en lugar de fmod llamo a la siguiente función (por definición del mod GLSL)

float mod(float x, float y) 
{ 
    return x - y * floor(x/y) 
} 

Answer 1

Como habrás notado, son diferentes. La modificación GLSL siempre tendrá el mismo signo que y en lugar de x. De lo contrario, es lo mismo: un valor f tal que x = i * y + f donde i es un número entero y | f | < | y |. Si está intentando hacer un patrón repetitivo de algún tipo, el mod de GLSL es generalmente lo que quiere.

Como comparación, HLSL fmod es equivalente a x - y * trunc (x/y). Son iguales cuando x/y es positivo, diferente cuando x/y es negativo.