aceslowman

 matrix, and would like to convert it into a 

. I am attempting to fill a jitter matrix with 3D voronoi (similar to jit.bfg), but on the GPU.

I have gone down a few different paths in working on this:

First of all, I imagine that I could take a [jit.matrix 4 char 512 512] and remap RGB->XYZ, into a [jit.matrix 1 char 64 64 64]. Both should have an equivalent amount of data, but so far I have not found a way to remap the planes to match the new dimensions.

Next, and something I know far less about, I am finding information about 3D textures in OpenGL. I imagine something like this:

[jit.matrix 1 char 64 64 64] -> [jit.slab @file 3dVoronoi.jxs] -> [jit.matrix 1 char 64 64 64]

So far, I have not figured out how to utilize 3D texture coordinates, and even then, I can't seem to send a 3D matrix to a slab, and then read back into a 3D matrix.

Does anybody have some guidance on this, or some references that I could be pointed towards?

I'm working with an argb matrix, and would like to convert it into a single plane matrix, mapping rgb to xyz. I am attempting to fill a jitter matrix with 3D voronoi (similar to jit.bfg), but on the GPU.

I have gone down a few different paths in working on this:

First of all, I imagine that I could take a [jit.matrix 4 char 512 512] and remap RGB->XYZ, into a [jit.matrix 1 char 64 64 64]. Both should have an equivalent amount of data, but so far I have not found a way to remap the planes to match the new dimensions.

Next, and something I know far less about, I am finding information about 3D textures in OpenGL. I imagine something like this:

[jit.matrix 1 char 64 64 64] -> [jit.slab @file 3dVoronoi.jxs] -> [jit.matrix 1 char 64 64 64]

So far, I have not figured out how to utilize 3D texture coordinates, and even then, I can't seem to send a 3D matrix to a slab, and then read back into a 3D matrix.

Does anybody have some guidance on this, or some references that I could be pointed towards?

Thanks!

I'm working with an argb matrix, and would like to convert it into a single plane matrix, mapping rgb to xyz. I am attempting to fill a jitt

converting-rgb-planes-to-xyz-dimensions

Okay, I apparently missed this the first time I searched for it. While this seems relevant, it doesn't seem to actually map the rgb->xyz. 

https://cycling74.com/forums/make-a-3-plane-matrix-into-a-1-plane-matrix-with-3-dimensions

My patch is attached. It seems to map rg -> xy fine, but b->z doesn't seem to work.

<jittershader name="voronoi">
    <description>
    Voronoi
    </description>
    <param name="time" type="float" default="0.0" />
    <param name="scale" type="float" default="4." />
    <param name="speed" type="float" default="2000." />
    <param name="rand_seed1" type="float" default="1." />
    <param name="rand_seed2" type="float" default="2." />
    <param name="rand_seed3" type="float" default="3." />
    <param name="dim" type="vec2" default="500. 500." />
    <language name="glsl" version="2.1">
        <bind param="time" program="fp" />
        <bind param="scale" program="fp" />
        <bind param="speed" program="fp" />
        <bind param="dim" program="fp" />
        <bind param="rand_seed1" program="fp" />
        <bind param="rand_seed2" program="fp" />
        <bind param="rand_seed3" program="fp" />
        <program name="vp" type="vertex" source="sh.passthru.xform.vp.glsl" />
        <program name="fp" type="fragment">
<![CDATA[

uniform float time;
uniform float scale;
uniform float speed;
uniform vec2 dim;

uniform float rand_seed1;
uniform float rand_seed2;
uniform float rand_seed3;

float rand(vec2 co){
    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

void main()
{
    vec2 st = vec2(gl_FragCoord.xy/dim.xy);
    st.x *= dim.x/dim.y;
    vec3 color = vec3(.0);

    st *= scale;    
    vec2 i_st = floor(st);
    vec2 f_st = fract(st);
    
    float r_dist = 1.;
    float g_dist = 1.;
    float b_dist = 1.;
 
     vec2 r_point;
    vec2 g_point;
    vec2 b_point;
    
    for(int y = -1; y <= 1; y++){
        for(int x = -1; x <= 1; x++){
            vec2 neighbor = vec2(float(x),float(y));
            vec2 r_point = vec2(rand((i_st + neighbor)*rand_seed1));
            vec2 g_point = vec2(rand((i_st + neighbor)*rand_seed2));
            vec2 b_point = vec2(rand((i_st + neighbor)*rand_seed3));
            
            r_point = 0.5 + 0.5*sin((time/speed) + 6.2831*r_point);
            g_point = 0.5 + 0.5*sin((time/speed) + 6.2831*g_point);
            b_point = 0.5 + 0.5*sin((time/speed) + 6.2831*b_point);
            
            vec2 _r_diff = neighbor + r_point - f_st;
            vec2 _g_diff = neighbor + g_point - f_st;
            vec2 _b_diff = neighbor + b_point - f_st;
            
            float _r_dist = length(_r_diff);
            float _g_dist = length(_g_diff);
            float _b_dist = length(_b_diff);
            
            if(_r_dist < r_dist){
                r_dist = _r_dist;
                r_point = r_point;
            }
            
            if(_g_dist < g_dist){
                g_dist = _g_dist;
                g_point = g_point;
            }
             
            if(_b_dist < b_dist){
                b_dist = _b_dist;
                b_point = g_point;
            }                                    
        }
    }

    color.rgb = vec3(r_dist, g_dist, b_dist);
    gl_FragColor = vec4(color,1.0);
}
]]>
        </program>
    </language>
</jittershader>

Okay, I apparently missed this the first time I searched for it. While this seems relevant, it doesn't seem to actually map the rgb->xyz. 

https://cycling74.com/forums/make-a-3-plane-matrix-into-a-1-plane-matrix-with-3-dimensions

My patch is attached. It seems to map rg -> xy fine, but b->z doesn't seem to work.

<jittershader name="voronoi">
	<description>
	Voronoi
	</description>
	<param name="time" type="float" default="0.0" />
	<param name="scale" type="float" default="4." />
	<param name="speed" type="float" default="2000." />
	<param name="rand_seed1" type="float" default="1." />
	<param name="rand_seed2" type="float" default="2." />
	<param name="rand_seed3" type="float" default="3." />
	<param name="dim" type="vec2" default="500. 500." />
	<language name="glsl" version="2.1">
		<bind param="time" program="fp" />
		<bind param="scale" program="fp" />
		<bind param="speed" program="fp" />
		<bind param="dim" program="fp" />
		<bind param="rand_seed1" program="fp" />
		<bind param="rand_seed2" program="fp" />
		<bind param="rand_seed3" program="fp" />
		<program name="vp" type="vertex" source="sh.passthru.xform.vp.glsl" />
		<program name="fp" type="fragment">
<![CDATA[

uniform float time;
uniform float scale;
uniform float speed;
uniform vec2 dim;

uniform float rand_seed1;
uniform float rand_seed2;
uniform float rand_seed3;

float rand(vec2 co){
    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

void main()
{
	vec2 st = vec2(gl_FragCoord.xy/dim.xy);
	st.x *= dim.x/dim.y;
	vec3 color = vec3(.0);

	st *= scale;	
	vec2 i_st = floor(st);
	vec2 f_st = fract(st);
	
	float r_dist = 1.;
	float g_dist = 1.;
	float b_dist = 1.;
 
 	vec2 r_point;
	vec2 g_point;
	vec2 b_point;
	
	for(int y = -1; y <= 1; y++){
		for(int x = -1; x <= 1; x++){
			vec2 neighbor = vec2(float(x),float(y));
			vec2 r_point = vec2(rand((i_st + neighbor)*rand_seed1));
			vec2 g_point = vec2(rand((i_st + neighbor)*rand_seed2));
			vec2 b_point = vec2(rand((i_st + neighbor)*rand_seed3));
			
			r_point = 0.5 + 0.5*sin((time/speed) + 6.2831*r_point);
			g_point = 0.5 + 0.5*sin((time/speed) + 6.2831*g_point);
			b_point = 0.5 + 0.5*sin((time/speed) + 6.2831*b_point);
			
			vec2 _r_diff = neighbor + r_point - f_st;
			vec2 _g_diff = neighbor + g_point - f_st;
			vec2 _b_diff = neighbor + b_point - f_st;
			
			float _r_dist = length(_r_diff);
			float _g_dist = length(_g_diff);
			float _b_dist = length(_b_diff);
			
			if(_r_dist < r_dist){
				r_dist = _r_dist;
				r_point = r_point;
			}
			
			if(_g_dist < g_dist){
				g_dist = _g_dist;
				g_point = g_point;
			}
			 
			if(_b_dist < b_dist){
				b_dist = _b_dist;
				b_point = g_point;
			}									
		}
	}

	color.rgb = vec3(r_dist, g_dist, b_dist);
	gl_FragColor = vec4(color,1.0);
}
]]>
		</program>
	</language>
</jittershader>

Seems like the dstdimend 3 3 $1 is the problem. Change the 3s to the required number or paste a patch.

Patch is attached. It seems to map rg -> xy fine, but b->z doesn't seem to work.

    <description> Default shader </description>

// 3D Voronoi code originally by Max Bittker, adapted for Max
// https://github.com/MaxBittker/glsl-voronoi-noise/blob/master/3d.glsl

const mat2 myt = mat2(.12121212, .13131313, -.13131313, .12121212);
const vec2 mys = vec2(1e4, 1e6);

vec2 rhash(vec2 uv) {
  uv *= myt;
  uv *= mys;
  return fract(fract(uv / mys) * uv);
}

vec3 hash(vec3 p) {
  return fract(
      sin(vec3(dot(p, vec3(1.0, 57.0, 113.0)), dot(p, vec3(57.0, 113.0, 1.0)),
               dot(p, vec3(113.0, 1.0, 57.0)))) *
      43758.5453);
}

vec3 voronoi3d(const in vec3 x) {
  vec3 p = floor(x);
  vec3 f = fract(x);

 float id = 0.0;
  vec2 res = vec2(100.0);
  for (int k = -1; k <= 1; k++) {
    for (int j = -1; j <= 1; j++) {
      for (int i = -1; i <= 1; i++) {
        vec3 b = vec3(float(i), float(j), float(k));
        vec3 r = vec3(b) - f + hash(p + b);
        float d = dot(r, r);

       float cond = max(sign(res.x - d), 0.0);
        float nCond = 1.0 - cond;

       float cond2 = nCond * max(sign(res.y - d), 0.0);
        float nCond2 = 1.0 - cond2;

       id = (dot(p + b, vec3(1.0, 57.0, 113.0)) * cond) + (id * nCond);
        res = vec2(d, res.x) * cond + res * nCond;

       res.y = cond2 * d + nCond2 * res.y;
      }
    }
  }

uniform float scale;
uniform float offset;

void main()
{    
    vec3 coord = gl_FragCoord.xyz;
 

    vec3 color = voronoi3d((coord * scale) + offset);
 

    gl_FragColor = vec4(color, 1.0);
} 
]]>
        </program>
    </language>
</jittershader>

Full patch below:

3DVoronoi.jxs

<jittershader name="default">
	<description> Default shader </description>
	<param name="offset" type="float" default="0.0" />
	<param name="scale" type="float" default="0.1" />	
	<language name="glsl" version="1.0">	
		<bind param="offset" program="fp" />
		<bind param="scale" program="fp" />	
		<program name="vp" type="vertex">
<![CDATA[
void main (void)
{
    gl_Position = ftransform();
	gl_FrontColor = gl_Color;
}
]]>		
		</program>
		<program name="fp" type="fragment">
<![CDATA[

void main()
{	
	vec3 coord = gl_FragCoord.xyz;
 

	vec3 color = voronoi3d((coord * scale) + offset);
 

	gl_FragColor = vec4(color, 1.0);
} 
]]>
		</program>
	</language>
</jittershader>

Converting RGB planes to XYZ dimensions