notepad.txt

// My virtual exercise book for GPU programming 

float3 cross(float3 a, float3 b)
{
	return a.yzx * b.zxy - a.zxy * b.yzx;
}

float lerp (float x, float y, float t)
{
	return x+t*(y-x);
}

float remap (float x, float a, float b, float c, float d)  
//example parameters value,-1,1,0,1 -> remap value in range(-1,1) to range (0,1)
{
	return (x-a)/(b-a)*(d-c) + c; 
}

float sinh(float x)
{
	return 0.5 * (exp(x)-exp(-x));
}

////////////////////////////////////////////////////////////////////////////

"if" statement can be replace by following formula:
if( x>y ) a=5.0; else a=10.0;
is equivalent to:
a=lerp(5.0,10.0,step(x,y));

another example:
if (uv.x>1.0) fragColor=vec4(0,0,0,0); else fragColor=vec4(1,0,0,0);
fragColor = vec4( mix (vec3(0.0,0.0,0.0),vec3(1.0,0.0,0.0),step(uv.x,1.0)),1.0);

////////////////////////////////////////////////////////////////////////////

Conversion between HLSL and GLSL:

HLSL fmod:
float3 fmod(float3 x, float3 y)
{
	return x - y * trunc(x/y);
}

GLSL mod:
vec3 mod(vec3 x, vec3 y)
{
	return x - y * floor(x/y);
}

////////////////////////////////////////////////////////////////////////////

How to fix error "Constructors only defined for numeric base types" in HLSL:
Struct declaration (both GLSL and HLSL):

struct LightColor
{
    vec3 diffuse;
    vec3 specular;
};
   
struct Material
{
    LightColor color;
    float shininess;
};

GLSL:
Material black = Material(LightColor(vec3(0.0), vec3(0.5)), 35.0);

HLSL:
Material black;
black.color.diffuse = float3(0.0, 0.0, 0.0);
black.color.specular = float3(0.5, 0.5, 0.5);
black.shininess = 35.0;

////////////////////////////////////////////////////////////////////////////

GLSL lessThan
(https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/lessThan.xhtml)

HLSL:
float4 lessThan (float4 x, float4 y)
{
	return 1 - step(y, x);
}

////////////////////////////////////////////////////////////////////////////

GLSL texelFetch:
int px = int(fragCoord.x);
float x = texelFetch(iChannel0, ivec2(px, 0), 0).x;

HLSL:
Texture2D<float4> _BufferA;
float x = _BufferA.Load( int3(px, 0, 0) ).x;

////////////////////////////////////////////////////////////////////////////

Inverse smoothstep function:

float inverse_smoothstep( float x )
{
    return 0.5 - sin(asin(1.0-2.0*x)/3.0);
}

////////////////////////////////////////////////////////////////////////////