diff --git a/src/frag.glsl b/src/frag.glsl
index 65dd9c29a501b4a5d63e7d24ea038021940ccab7..a5985b2abd473b59cf22b79cd8cb6a822260e12a 100644
--- a/src/frag.glsl
+++ b/src/frag.glsl
@@ -12,23 +12,23 @@ layout (constant_id = 0) const bool DISABLE_TRACE = false;
layout(location=0)in VertexInput
{
vec4 position;
- vec3 globaloffset;
}vertexInput;
#else
layout(location=0)in vec3 tri_normal;
+layout(location=1)in vec4 tri_pos;
#endif
layout(location=0)out vec4 f_color;
/// SHARED CODE ///
-vec3 shading(vec3 normal)
+vec3 shading(vec3 normal, vec3 position)
{
vec3 accum=vec3(0.,0.,0.);
mat3 rotation=mat3(pc.world[0].xyz,pc.world[1].xyz,pc.world[2].xyz);
- vec3 position=pc.world[3].xyz;
+ //vec3 position=pc.world[3].xyz;
for(int i=0;i<light_uniforms.light_count;i++)
{
@@ -57,7 +57,7 @@ const uint MAX_STEPS=50;
#define gl_GlobalInvocationID uvec3(1)
#endif
#define interval_frags
-#include "intervals.glsl"
+#include "interpreter.glsl"
layout(set=0,binding=20, std430)restrict readonly buffer fragmentMasks{
uint8_t masks[][masklen];
@@ -66,20 +66,20 @@ layout(set=0,binding=20, std430)restrict readonly buffer fragmentMasks{
#ifdef debug
vec3 getNormal(vec3 p,float dens){
vec3 n;
- n.x=sceneoverride(vec3(p.x+EPSILON,p.y,p.z),false).x;
- n.y=sceneoverride(vec3(p.x,p.y+EPSILON,p.z),false).x;
- n.z=sceneoverride(vec3(p.x,p.y,p.z+EPSILON),false).x;
- return normalize(n-(sceneoverride(p,false).x));
+ n.x=scene(vec3(p.x+EPSILON,p.y,p.z),false).x;
+ n.y=scene(vec3(p.x,p.y+EPSILON,p.z),false).x;
+ n.z=scene(vec3(p.x,p.y,p.z+EPSILON),false).x;
+ return normalize(n-(scene(p,false).x));
}
vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){
vec2 td=vec2(NEARPLANE,1.);
p=ori;
- td.y=sceneoverride(p,false).x;
+ td.y=scene(p,false).x;
td.x+=(td.y)*.9;
p=ori+dir*td.x;
for(int i=0;i<MAX_STEPS&&td.y>EPSILON&&td.x<FARPLANE;i++){
- td.y=sceneoverride(p,false).x;
+ td.y=scene(p,false).x;
td.x+=(td.y)*.9;
p=ori+dir*td.x;
}
@@ -88,17 +88,17 @@ vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){
#else
vec3 getNormal(vec3 p,float dens){
vec3 n;
- n.x=sceneoverride(vec3(p.x+EPSILON,p.y,p.z),false);
- n.y=sceneoverride(vec3(p.x,p.y+EPSILON,p.z),false);
- n.z=sceneoverride(vec3(p.x,p.y,p.z+EPSILON),false);
- return normalize(n-(sceneoverride(p,false)));
+ n.x=scene(vec3(p.x+EPSILON,p.y,p.z),false);
+ n.y=scene(vec3(p.x,p.y+EPSILON,p.z),false);
+ n.z=scene(vec3(p.x,p.y,p.z+EPSILON),false);
+ return normalize(n-(scene(p,false)));
}
vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){
vec2 td=vec2(NEARPLANE,1.);
p=ori;
for(int i=0;i<MAX_STEPS&&td.y>EPSILON&&td.x<FARPLANE;i++){
- td.y=sceneoverride(p,false);
+ td.y=scene(p,false);
td.x+=(td.y)*.9;
p=ori+dir*td.x;
}
@@ -113,7 +113,6 @@ void main(){
vec3 raypos=vertexInput.position.xyz;
vec3 p;
vec3 raydir=normalize(raypos-(inverse(pc.world)*vec4(camera_uniforms.campos,1)).xyz);
- raypos+=vertexInput.globaloffset;
//f_color=vec4(raydir,1.);
@@ -123,7 +122,7 @@ void main(){
}
#ifdef debug
- f_color=vec4(sceneoverride(raypos,false),1);
+ f_color=vec4(scene(raypos,false),1);
return;
#endif
@@ -136,7 +135,7 @@ void main(){
{
vec3 n=getNormal(p,td.y);
//f_color=vec4(1.);
- f_color=vec4(shading(n),1.);
+ f_color=vec4(shading(n, p),1.);
vec4 tpoint=camera_uniforms.proj*camera_uniforms.view*pc.world*vec4(p,1);
gl_FragDepth=(tpoint.z/tpoint.w);
@@ -152,7 +151,7 @@ void main(){
//Mesh Surface Entrypoint
void main(){
- f_color=vec4(shading(tri_normal),1.);
+ f_color=vec4(shading(tri_normal, tri_pos.xyz),1.);
}
#endif
\ No newline at end of file
diff --git a/src/implicit.mesh.glsl b/src/implicit.mesh.glsl
index b7623a7b9c72c99d67467353320555727412ffab..adcb1f7cb2370f65566a84385c3ec57f40128a25 100644
--- a/src/implicit.mesh.glsl
+++ b/src/implicit.mesh.glsl
@@ -18,7 +18,6 @@ layout(triangles,max_vertices=256,max_primitives=192)out;
layout(location=0)out VertexOutput
{
vec4 position;
- vec3 globaloffset;
}vertexOutput[];
struct MeshMasks
@@ -28,8 +27,7 @@ struct MeshMasks
vec3 bottomleft; //12
vec3 topright; //12
uint globalindex; //4
- vec3 globaloffset; //12
-}; //total = 1000 bytes
+}; //total = 988 bytes
taskPayloadSharedEXT MeshMasks meshmasks;
layout(set=0,binding=20, std430)restrict writeonly buffer fragmentMasks{
@@ -127,22 +125,6 @@ void main()
vertexOutput[vindex+5].position=(positions[5]);
vertexOutput[vindex+6].position=(positions[6]);
vertexOutput[vindex+7].position=(positions[7]);
- vertexOutput[vindex+0].globaloffset=(meshmasks.globaloffset);
- vertexOutput[vindex+1].globaloffset=(meshmasks.globaloffset);
- vertexOutput[vindex+2].globaloffset=(meshmasks.globaloffset);
- vertexOutput[vindex+3].globaloffset=(meshmasks.globaloffset);
- vertexOutput[vindex+4].globaloffset=(meshmasks.globaloffset);
- vertexOutput[vindex+5].globaloffset=(meshmasks.globaloffset);
- vertexOutput[vindex+6].globaloffset=(meshmasks.globaloffset);
- vertexOutput[vindex+7].globaloffset=(meshmasks.globaloffset);
- /*vertexOutput[vindex+0].position=vec4(bottomleft,1.);
- vertexOutput[vindex+1].position=vec4(bottomleft.x,bottomleft.y,topright.z,1.);
- vertexOutput[vindex+2].position=vec4(bottomleft.x,topright.y,bottomleft.z,1.);
- vertexOutput[vindex+3].position=vec4(bottomleft.x,topright.y,topright.z,1.);
- vertexOutput[vindex+4].position=vec4(topright.x,bottomleft.y,bottomleft.z,1.);
- vertexOutput[vindex+5].position=vec4(topright.x,bottomleft.y,topright.z,1.);
- vertexOutput[vindex+6].position=vec4(topright.x,topright.y,bottomleft.z,1.);
- vertexOutput[vindex+7].position=vec4(topright,1.);*/
if(signingvec.x){
gl_PrimitiveTriangleIndicesEXT[pindex+0]=uvec3(4,5,6)+uvec3(vindex);
diff --git a/src/implicit.task.glsl b/src/implicit.task.glsl
index 34a5fcdc035b7bb79a7b88356d1ab2bd8ca40bcf..488b20b48bdd124484271676f46bb13b01c6a83f 100644
--- a/src/implicit.task.glsl
+++ b/src/implicit.task.glsl
@@ -19,8 +19,7 @@ struct MeshMasks
vec3 bottomleft; //12
vec3 topright; //12
uint globalindex; //4
- vec3 globaloffset; //12
-}; //total = 1000 bytes
+}; //total = 988 bytes
taskPayloadSharedEXT MeshMasks meshmasks;
shared uint index;
@@ -36,33 +35,10 @@ void main()
index=0;
}
- //#define CLIPCHECK 65536
-
- /*float[6]bounds={
- CLIPCHECK-sceneoverride(vec3(CLIPCHECK,0,0),false),
- CLIPCHECK-sceneoverride(vec3(0,CLIPCHECK,0),false),
- CLIPCHECK-sceneoverride(vec3(0,0,CLIPCHECK),false),
- -CLIPCHECK+sceneoverride(vec3(-CLIPCHECK,0,0),false),
- -CLIPCHECK+sceneoverride(vec3(0,-CLIPCHECK,0),false),
- -CLIPCHECK+sceneoverride(vec3(0,0,-CLIPCHECK),false),
- };*/
- /*const float[6]bounds={
- 1,1,1,-1,-1,-1,
- };*/
-
float[6]bounds=scene_description.desc[gl_WorkGroupID.x+1].bounds;
-
-
- /*bounds[0] += abs(bounds[0] * 0.01);
- bounds[1] += abs(bounds[1] * 0.01);
- bounds[2] += abs(bounds[2] * 0.01);
- bounds[3] -= abs(bounds[3] * 0.01);
- bounds[4] -= abs(bounds[4] * 0.01);
- bounds[5] -= abs(bounds[5] * 0.01);*/
vec3 bottomleft = vec3(bounds[3],bounds[4],bounds[5]);
vec3 topright = vec3(bounds[0],bounds[1],bounds[2]);
- vec3 globaloffset = vec3(0);//(topright+bottomleft)/2.;
#define adjust(var) \
var *= vec3(0.25,0.25,0.25);\
@@ -77,35 +53,24 @@ void main()
bool triangle_fine;
if (!DISABLE_TRACE) {
- float[2] check = scene(vec3[2](bottomleft+globaloffset,topright+globaloffset), true);
+ float[2] check = scene(vec3[2](bottomleft,topright), true);
triangle_fine = (check[0] <= 0) && (check[1] >= 0);
} else {
triangle_fine = true;
}
- //default_mask();
- //float[2] check = scene(vec3[2](bottomleft,topright), false);
- //float[2] check = scene(vec3[2](bottomleft-globaloffset,topright-globaloffset), false);
- //float[2] check = scene(vec3[2](vec3(bounds[3],bounds[4],bounds[5]),vec3(bounds[0],bounds[1],bounds[2])), false);
-
- //if (((check[0] <= 0) && (check[1] >= 0)) )//|| ((check[1] <= 0) && ()))
- //if ((bottomleft.x >= -1) && (bottomleft.y >= -1) && (bottomleft.z >= -1) && (topright.x <= 1) && (topright.y <= 1) && (topright.z <= 1))
- //if ((gl_LocalInvocationID.x == 0) && (bottomleft.x >= 0))
if (triangle_fine)
{
uint localindex = atomicAdd(index, 1);
- //if (localindex < 32) {
meshmasks.masks[localindex]=mask;
meshmasks.enabled[localindex]=uint8_t(gl_LocalInvocationID.x);
- //}
}
if (gl_LocalInvocationID.x==0)
{
- meshmasks.bottomleft = vec3(bounds[3],bounds[4],(bounds[5]*0.5) + ((bounds[2]-bounds[5])*0.5 * (-0.5+gl_WorkGroupID.z)));
- meshmasks.topright = vec3(bounds[0],bounds[1],(bounds[2]*0.5) + ((bounds[2]-bounds[5])*0.5 * (-0.5+gl_WorkGroupID.z)));
+ meshmasks.bottomleft = vec3(bounds[3],bounds[4],(bounds[5]*0.5) + ((bounds[2]-bounds[5])*0.5 * (-0.5+gl_WorkGroupID.z)) + ((bounds[2]+bounds[5])*0.25));
+ meshmasks.topright = vec3(bounds[0],bounds[1],(bounds[2]*0.5) + ((bounds[2]-bounds[5])*0.5 * (-0.5+gl_WorkGroupID.z)) + ((bounds[2]+bounds[5])*0.25));
meshmasks.globalindex = gl_WorkGroupID.x*2+gl_WorkGroupID.z;
- meshmasks.globaloffset = globaloffset/0.25;
}
barrier();
diff --git a/src/interpreter.glsl b/src/interpreter.glsl
index 1cf01fa6ad32bc3135268f918db8cb175c86626d..7061b0284b52b3695dab8cc0e14bf0fd7d22ca34 100644
--- a/src/interpreter.glsl
+++ b/src/interpreter.glsl
@@ -1,4 +1,3 @@
-//#extension GL_EXT_shader_16bit_storage:require
#extension GL_EXT_shader_explicit_arithmetic_types:require
#ifndef interpreter
@@ -6,36 +5,62 @@
#include "instructionset.glsl"
-layout(set=0,binding=2, std430)uniform SceneDescription{
- u32vec4 d[13];//stored packed for space efficiency, 8 per index
+struct Description{
+ uint scene;
+ uint floats;
+ uint vec2s;
+ uint vec4s;
+ uint mat2s;
+ uint mat3s;
+ uint mat4s;
+ uint mats;
+ uint dependencies;
+ float[6] bounds;
+};
+Description desc;
+
+layout(set=0,binding=2, std430)restrict readonly buffer SceneDescription{
+ Description desc[];
}scene_description;
-// unpack as both integers and floats
-#define get_caches u32vec4 major_unpack=scene_description.d[major_position];\
-f16vec2 minor_float_unpack=unpackFloat2x16(major_unpack.x);\
-minor_float_cache[0]=minor_float_unpack.x;\
-minor_float_cache[1]=minor_float_unpack.y;\
-minor_float_unpack=unpackFloat2x16(major_unpack.y);\
-minor_float_cache[2]=minor_float_unpack.x;\
-minor_float_cache[3]=minor_float_unpack.y;\
-minor_float_unpack=unpackFloat2x16(major_unpack.z);\
-minor_float_cache[4]=minor_float_unpack.x;\
-minor_float_cache[5]=minor_float_unpack.y;\
-minor_float_unpack=unpackFloat2x16(major_unpack.w);\
-minor_float_cache[6]=minor_float_unpack.x;\
-minor_float_cache[7]=minor_float_unpack.y;\
-u16vec2 minor_integer_unpack=unpackUint2x16(major_unpack.x);\
-minor_integer_cache[0]=minor_integer_unpack.x;\
-minor_integer_cache[1]=minor_integer_unpack.y;\
-minor_integer_unpack=unpackUint2x16(major_unpack.y);\
-minor_integer_cache[2]=minor_integer_unpack.x;\
-minor_integer_cache[3]=minor_integer_unpack.y;\
-minor_integer_unpack=unpackUint2x16(major_unpack.z);\
-minor_integer_cache[4]=minor_integer_unpack.x;\
-minor_integer_cache[5]=minor_integer_unpack.y;\
-minor_integer_unpack=unpackUint2x16(major_unpack.w);\
-minor_integer_cache[6]=minor_integer_unpack.x;\
-minor_integer_cache[7]=minor_integer_unpack.y;
+layout(set=0,binding=3, std430)restrict readonly buffer SceneBuf{
+ u32vec4 opcodes[];
+}scenes;
+layout(set=0,binding=4, std430)restrict readonly buffer FloatConst{
+ float floats[];
+}fconst;
+layout(set=0,binding=5, std430)restrict readonly buffer Vec2Const{
+ vec2 vec2s[];
+}v2const;
+layout(set=0,binding=7, std430)restrict readonly buffer Vec4Const{
+ vec4 vec4s[];
+}v4const;
+layout(set=0,binding=8, std430)restrict readonly buffer Mat2Const{
+ mat2 mat2s[];
+}m2const;
+layout(set=0,binding=9, std430)restrict readonly buffer Mat3Const{
+ mat3 mat3s[];
+}m3const;
+layout(set=0,binding=10, std430)restrict readonly buffer Mat4Const{
+ mat4 mat4s[];
+}m4const;
+layout(set=0,binding=11, std430)restrict readonly buffer MatConst{
+ mat4 mats[];
+}matconst;
+layout(set=0,binding=12, std430)restrict readonly buffer DepInfo{
+ uint8_t dependencies[][2] ;
+}depinfo;
+
+// unpack integers
+#define get_caches u32vec4 major_unpack=scenes.opcodes[desc.scene+major_position];\
+minor_integer_cache[0]=major_unpack.x&65535;\
+minor_integer_cache[1]=major_unpack.x>>16;\
+minor_integer_cache[2]=major_unpack.y&65535;\
+minor_integer_cache[3]=major_unpack.y>>16;\
+minor_integer_cache[4]=major_unpack.z&65535;\
+minor_integer_cache[5]=major_unpack.z>>16;\
+minor_integer_cache[6]=major_unpack.w&65535;\
+minor_integer_cache[7]=major_unpack.w>>16;
float float_stack[8];
uint float_stack_head=0;
@@ -45,77 +70,142 @@ vec3 vec3_stack[8];
uint vec3_stack_head=0;
vec4 vec4_stack[8];
uint vec4_stack_head=0;
-mat2 mat2_stack[8];
+mat2 mat2_stack[1];
uint mat2_stack_head=0;
-mat3 mat3_stack[8];
+mat3 mat3_stack[1];
uint mat3_stack_head=0;
-mat4 mat4_stack[8];
+mat4 mat4_stack[1];
uint mat4_stack_head=0;
-mat4 material_stack[8];
-uint material_stack_head=0;
+
+uint float_const_head=0;
+uint vec2_const_head=0;
+uint vec4_const_head=0;
+uint mat2_const_head=0;
+uint mat3_const_head=0;
+uint mat4_const_head=0;
+uint mat_const_head=0;
+
+#define vec3_const_head vec4_const_head
+#define v3const v4const
+#define vec3s vec4s
void push_float(float f){
float_stack[float_stack_head++]=f;
}
-float pull_float(){
- return float_stack[--float_stack_head];
+float pull_float(bool c){
+ if (c) {
+ return fconst.floats[desc.floats+float_const_head++];
+ }
+ else {
+ return float_stack[--float_stack_head];
+ }
+}
+
+float cpull_float(){
+ return fconst.floats[desc.floats+float_const_head++];
}
void push_vec2(vec2 f){
vec2_stack[vec2_stack_head++]=f;
}
-vec2 pull_vec2(){
- return vec2_stack[--vec2_stack_head];
+vec2 pull_vec2(bool c){
+ if (c) {
+ return v2const.vec2s[desc.vec2s+vec2_const_head++];
+ }
+ else {
+ return vec2_stack[--vec2_stack_head];
+ }
+}
+
+vec2 cpull_vec2(){
+ return v2const.vec2s[desc.vec2s+vec2_const_head++];
}
void push_vec3(vec3 f){
vec3_stack[vec3_stack_head++]=f;
}
-vec3 pull_vec3(){
- return vec3_stack[--vec3_stack_head];
+vec3 pull_vec3(bool c){
+ if (c) {
+ return v3const.vec3s[desc.vec3s+vec3_const_head++].xyz;
+ }
+ else {
+ return vec3_stack[--vec3_stack_head];
+ }
+}
+
+vec3 cpull_vec3(){
+ return v3const.vec3s[desc.vec3s+vec3_const_head++].xyz;
}
void push_vec4(vec4 f){
vec4_stack[vec4_stack_head++]=f;
}
-vec4 pull_vec4(){
- return vec4_stack[--vec4_stack_head];
+vec4 pull_vec4(bool c){
+ if (c) {
+ return v4const.vec4s[desc.vec4s+vec4_const_head++];
+ }
+ else {
+ return vec4_stack[--vec4_stack_head];
+ }
+}
+
+vec4 cpull_vec4(){
+ return v4const.vec4s[desc.vec4s+vec4_const_head++];
}
void push_mat2(mat2 f){
mat2_stack[mat2_stack_head++]=f;
}
-mat2 pull_mat2(){
- return mat2_stack[--mat2_stack_head];
+mat2 pull_mat2(bool c){
+ if (c) {
+ return m2const.mat2s[desc.mat2s+mat2_const_head++];
+ }
+ else {
+ return mat2_stack[--mat2_stack_head];
+ }
+}
+
+mat2 cpull_mat2(){
+ return m2const.mat2s[desc.mat2s+mat2_const_head++];
}
void push_mat3(mat3 f){
mat3_stack[mat3_stack_head++]=f;
}
-mat3 pull_mat3(){
- return mat3_stack[--mat3_stack_head];
+mat3 pull_mat3(bool c){
+ if (c) {
+ return m3const.mat3s[desc.mat3s+mat3_const_head++];;
+ }
+ else {
+ return mat3_stack[--mat3_stack_head];
+ }
}
-void push_mat4(mat4 f){
- mat4_stack[mat4_stack_head++]=f;
+mat3 cpull_mat3(){
+ return m3const.mat3s[desc.mat3s+mat3_const_head++];
}
-mat4 pull_mat4(){
- return mat4_stack[--mat4_stack_head];
+void push_mat4(mat4 f){
+ mat4_stack[mat4_stack_head++]=f;
}
-void push_material(mat4 f){
- material_stack[material_stack_head++]=f;
+mat4 pull_mat4(bool c){
+ if (c) {
+ return m4const.mat4s[desc.mat4s+mat4_const_head++];
+ }
+ else {
+ return mat4_stack[--mat4_stack_head];
+ }
}
-mat4 pull_material(){
- return material_stack[--material_stack_head];
+mat4 cpull_mat4(){
+ return m4const.mat4s[desc.mat4s+mat4_const_head++];
}
void clear_stacks()
@@ -127,1319 +217,2195 @@ void clear_stacks()
mat2_stack_head=0;
mat3_stack_head=0;
mat4_stack_head=0;
- material_stack_head=0;
+ float_const_head=0;
+ vec2_const_head=0;
+ vec3_const_head=0;
+ vec4_const_head=0;
+ mat2_const_head=0;
+ mat3_const_head=0;
+ mat4_const_head=0;
+ mat_const_head=0;
}
-uint8_t mask[13];
+const int masklen = 29;
+uint8_t mask[masklen];
void default_mask()
{
- mask=uint8_t[13](uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255),uint8_t(255));
+ mask=uint8_t[29](
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255),
+ uint8_t(255)
+ );
+}
+
+//monotonic
+#define multiply {\
+ in1 *= in2;\
+}
+//monotonic
+#define divide {\
+ in1 /= in2;\
+}
+//monotonic
+#define add {\
+ in1 += in2;\
+}
+//monotonic
+#define subtract {\
+ in1 -= in2;\
+}
+#define modulo {\
+ in1 = mod(in1,in2);\
+}
+//always monotonic for x>0
+#define power {\
+ in1 = pow(in1,in2);\
+}
+//handled
+#define dist {\
+ out1 = distance(in1,in2);\
+}
+//variable
+#define dotprod {\
+ out1 = dot(in1,in2);\
+}
+//monotonic
+#define clampof {\
+ in1=clamp(in1,in2,in3);\
+}
+//monotonic
+#define mixof {\
+ in1=mix(in1,in2,in3);\
+}
+//monotonic
+#define fmaof {\
+ multiply;\
+ in2=in3;\
+ add;\
+}
+//variable
+#define square {\
+ in1=in1*in1;\
+}
+//monotonic
+#define cube {\
+ in1=in1*in1*in1;\
+}
+//mess
+#define len {\
+ out1 = length(in1);\
+}
+//monotonic
+#define mattranspose {\
+ in1=transpose(in1);\
+}
+//unused
+#define matdeterminant {\
+ in1=determinant(in1);\
+}
+//unused
+#define matinvert {\
+ in1=inverse(in1);\
+}
+//handled
+#define absolute {\
+ in1=abs(in1);\
+}
+//monotonic
+#define signof {\
+ in1=sign(in1);\
+}
+//monotonic
+#define floorof {\
+ in1=floor(in1);\
+}
+//monotonic
+#define ceilingof {\
+ in1=ceil(in1);\
+}
+//handled
+//If the integer component changes across the interval, then we've managed to hit
+//a discontinuity, and the max and min are constant.
+//Otherwise, it's monotonic.
+#define fractionalof {\
+ in1=fract(in1);\
+}
+//monotonic
+#define squarerootof {\
+ in1=sqrt(in1);\
+}
+//monotonic
+#define inversesquarerootof {\
+ in1=inversesqrt(in1);\
+}
+//monotonic
+#define exponentof {\
+ in1=exp(in1);\
+}
+//monotonic
+#define exponent2of {\
+ in1=exp2(in1);\
+}
+//monotonic
+#define logarithmof {\
+ in1=log(in1);\
+}
+//monotonic
+#define logarithm2of {\
+ in1=log2(in1);\
+}
+#define PI 3.1415926536
+//handled
+#define sineof {\
+ in1=sin(in1);\
+}
+//handled
+#define cosineof {\
+ in1=cos(in1);\
+}
+//handled
+#define tangentof {\
+ in1=tan(in1);\
+}
+//monotonic
+#define arcsineof {\
+ in1=asin(in1);\
+}
+//negatively monotonic
+#define arccosineof {\
+ in1=acos(in1);\
+}
+//monotonic
+#define arctangentof {\
+ in1=atan(in1);\
+}
+//monotonic
+#define hyperbolicsineof {\
+ in1=sinh(in1);\
+}
+//handled
+#define hyperboliccosineof {\
+ in1=cosh(in1);\
+}
+//monotonic
+#define hyperbolictangentof {\
+ in1=tanh(in1);\
+}
+//monotonic
+#define hyperbolicarcsineof {\
+ in1=asinh(in1);\
+}
+//monotonic
+#define hyperbolicarccosineof {\
+ in1=acosh(in1);\
+}
+//monotonic
+#define hyperbolicarctangentof {\
+ in1=atanh(in1);\
+}
+//obvious
+#define minimum {\
+ in1=min(in1,in2);\
+}
+//obvious
+#define maximum {\
+ in1=max(in1,in2);\
+}
+//monotonic
+#define roundof {\
+ in1=round(in1);\
+}
+//truncate
+#define truncof {\
+ in1=trunc(in1);\
}
-float scene(vec3 p,bool material)
+#define maskdefine (mask[major_position]&(1<<minor_position))==0
+#define inputmask1(m_in_1) if(maskdefine){\
+ if(ifconst(0)) {m_in_1++;}\
+ break;\
+}
+#define inputmask2(m_in_1,m_in_2) if(maskdefine){\
+ if(ifconst(0)) {m_in_1++;}\
+ if(ifconst(1)) {m_in_2++;}\
+ break;\
+}
+#define inputmask3(m_in_1,m_in_2,m_in_3) if(maskdefine){\
+ if(ifconst(0)) {m_in_1++;}\
+ if(ifconst(1)) {m_in_2++;}\
+ if(ifconst(2)) {m_in_3++;}\
+ break;\
+}
+#define inputmask4(m_in_1,m_in_2,m_in_3,m_in_4) if(maskdefine){\
+ if(ifconst(0)) {m_in_1++;}\
+ if(ifconst(1)) {m_in_2++;}\
+ if(ifconst(2)) {m_in_3++;}\
+ if(ifconst(3)) {m_in_4++;}\
+ break;\
+}
+#define inputmask5(m_in_1,m_in_2,m_in_3,m_in_4,m_in_5) if(maskdefine){\
+ if(ifconst(0)) {m_in_1++;}\
+ if(ifconst(1)) {m_in_2++;}\
+ if(ifconst(2)) {m_in_3++;}\
+ if(ifconst(3)) {m_in_4++;}\
+ if(ifconst(4)) {m_in_5++;}\
+ break;\
+}
+#define inputmask6(m_in_1,m_in_2,m_in_3,m_in_4,m_in_5,m_in_6) if(maskdefine){\
+ if(ifconst(0)) {m_in_1++;}\
+ if(ifconst(1)) {m_in_2++;}\
+ if(ifconst(2)) {m_in_3++;}\
+ if(ifconst(3)) {m_in_4++;}\
+ if(ifconst(4)) {m_in_5++;}\
+ if(ifconst(5)) {m_in_6++;}\
+ break;\
+}
+
+#ifdef debug
+vec3 scene(vec3 p, bool materials)
+#else
+float scene(vec3 p, bool materials)
+#endif
{
uint major_position=0;
uint minor_position=0;
- float16_t minor_float_cache[8];
- uint16_t minor_integer_cache[8];
+ uint minor_integer_cache[8];
+
+ desc = scene_description.desc[(DescriptionIndex)+1];
clear_stacks();
push_vec3(p);
- bool cont=true;
-
- while(cont){
+ while(true){
if(minor_position==0){
get_caches;
}
- /*if(float(minor_float_cache[minor_position])==5)
- return vec3(0.,0.,1.);
- if(isnan(minor_float_cache[minor_position+1]))
- return vec3(0.,1.,0.);
- if(isnan(minor_float_cache[minor_position+2]))
- return vec3(1.,0.,0.);
- if(isnan(minor_float_cache[minor_position+3]))
- return vec3(1.,0.,1.);
- if(isnan(minor_float_cache[minor_position+4]))
- return vec3(0.,1.,1.);
- if(isnan(minor_float_cache[minor_position+5]))
- return vec3(1.,1.,0.);
- //if (float(minor_float_cache[minor_position+5]) == 5)
- return vec3(1.,1.,1.);
-
- return vec3(float(minor_float_cache[minor_position]),float(minor_float_cache[minor_position+1]),float(minor_float_cache[minor_position+2]));
- */
- if((mask[major_position]&(1<<minor_position))>0)
- {
- //return vec3(1.,1.,0.);
- if(isnan(minor_float_cache[minor_position]))
- {
- float floattemp;
- vec2 vec2temp;
- vec3 vec3temp;
- vec4 vec4temp;
- mat2 mat2temp;
- mat3 mat3temp;
- mat4 mat4temp;
-
- switch(uint(minor_integer_cache[minor_position])&511)
+ /*#ifdef implicit
+ if (mask[major_position] != 255) discard;
+ if (mask[major_position+1] != 255) discard;
+ if (mask[major_position+2] != 255) discard;
+ if (mask[major_position+3] != 255) discard;
+ #endif*/
+ #ifdef debug
+ /*if((minor_integer_cache[minor_position]&1023)==OPStop) {
+ return vec3(0.,0.,1.);
+ }
+ if((minor_integer_cache[minor_position]&1023)==OPSDFSphere) {
+ return vec3(1.,0.,0.);
+ }*/
+ /*if((minor_integer_cache[minor_position] & (1 << (15 - 1))) > 0) {
+ return vec3(1.,0.,0.);
+ }
+ if((minor_integer_cache[minor_position] & (1 << (15 - 0))) > 0) {
+ return vec3(0.,0.,1.);
+ }*/
+ //return vec3(0.,1.,0.);
+ return vec3(desc.floats,desc.scene,DescriptionIndex);
+ #endif
+
+ switch(minor_integer_cache[minor_position]&1023)
{
- case OPAddFloatFloat:
- push_float(pull_float()+pull_float());
- break;
- case OPAddVec2Vec2:
- push_vec2(pull_vec2()+pull_vec2());
- break;
- case OPAddVec2Float:
- push_vec2(pull_vec2()+pull_float());
- break;
- case OPAddVec3Vec3:
- push_vec3(pull_vec3()+pull_vec3());
- break;
- case OPAddVec3Float:
- push_vec3(pull_vec3()+pull_float());
- break;
- case OPAddVec4Vec4:
- push_vec4(pull_vec4()+pull_vec4());
- break;
- case OPAddVec4Float:
- push_vec4(pull_vec4()+pull_float());
- break;
- case OPAddMat2Mat2:
- push_mat2(pull_mat2()+pull_mat2());
- break;
- case OPAddMat2Float:
- push_mat2(pull_mat2()+pull_float());
- break;
- case OPAddMat3Mat3:
- push_mat3(pull_mat3()+pull_mat3());
- break;
- case OPAddMat3Float:
- push_mat3(pull_mat3()+pull_float());
- break;
- case OPAddMat4Mat4:
- push_mat4(pull_mat4()+pull_mat4());
- break;
- case OPAddMat4Float:
- push_mat4(pull_mat4()+pull_float());
- break;
-
- case OPMulFloatFloat:
- push_float(pull_float()*pull_float());
- break;
- case OPMulVec2Vec2:
- push_vec2(pull_vec2()*pull_vec2());
- break;
- case OPMulVec2Float:
- push_vec2(pull_vec2()*pull_float());
- break;
- case OPMulVec3Vec3:
- push_vec3(pull_vec3()*pull_vec3());
- break;
- case OPMulVec3Float:
- push_vec3(pull_vec3()*pull_float());
- break;
- case OPMulVec4Vec4:
- push_vec4(pull_vec4()*pull_vec4());
- break;
- case OPMulVec4Float:
- push_vec4(pull_vec4()*pull_float());
+ #define ifconst(pos) (minor_integer_cache[minor_position] & (1 << (15 - pos))) > 0
+ #define OPPos int((major_position<<3)|minor_position)
+ case OPAddFloatFloat:{
+ inputmask2(float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ add;
+ push_float(in1);
+ }
break;
- case OPMulMat2Mat2:
- push_mat2(pull_mat2()*pull_mat2());
+ case OPAddVec2Vec2:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ add;
+ push_vec2(in1);
+ }
break;
- case OPMulMat2Float:
- push_mat2(pull_mat2()*pull_float());
+ case OPAddVec2Float:{
+ inputmask2(vec2_const_head,float_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ add;
+ push_vec2(in1);
+ }
break;
- case OPMulMat3Mat3:
- push_mat3(pull_mat3()*pull_mat3());
+ case OPAddVec3Vec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ add;
+ push_vec3(in1);
+ }
break;
- case OPMulMat3Float:
- push_mat3(pull_mat3()*pull_float());
+ case OPAddVec3Float:{
+ inputmask2(vec3_const_head,float_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ add;
+ push_vec3(in1);
+ }
break;
- case OPMulMat4Mat4:
- push_mat4(pull_mat4()*pull_mat4());
+ case OPAddVec4Vec4:{
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ add;
+ push_vec4(in1);
+ }
break;
- case OPMulMat4Float:
- push_mat4(pull_mat4()*pull_float());
+ case OPAddVec4Float:{
+ inputmask2(vec4_const_head,float_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ add;
+ push_vec4(in1);
+ }
break;
- case OPSubFloatFloat:
- push_float(pull_float()-pull_float());
- break;
- case OPSubVec2Vec2:
- push_vec2(pull_vec2()-pull_vec2());
- break;
- case OPSubVec2Float:
- push_vec2(pull_vec2()-pull_float());
- break;
- case OPSubVec3Vec3:
- push_vec3(pull_vec3()-pull_vec3());
- break;
- case OPSubVec3Float:
- push_vec3(pull_vec3()-pull_float());
- break;
- case OPSubVec4Vec4:
- push_vec4(pull_vec4()-pull_vec4());
- break;
- case OPSubVec4Float:
- push_vec4(pull_vec4()-pull_float());
+ case OPSubFloatFloat:{
+ inputmask2(float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ subtract;
+ push_float(in1);
+ }
break;
- case OPSubMat2Mat2:
- push_mat2(pull_mat2()-pull_mat2());
+ case OPSubVec2Vec2:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ subtract;
+ push_vec2(in1);
+ }
break;
- case OPSubMat2Float:
- push_mat2(pull_mat2()-pull_float());
+ case OPSubVec2Float:{
+ inputmask2(vec2_const_head,float_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ subtract;
+ push_vec2(in1);
+ }
break;
- case OPSubMat3Mat3:
- push_mat3(pull_mat3()-pull_mat3());
+ case OPSubVec3Vec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ subtract;
+ push_vec3(in1);
+ }
break;
- case OPSubMat3Float:
- push_mat3(pull_mat3()-pull_float());
+ case OPSubVec3Float:{
+ inputmask2(vec3_const_head,float_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ subtract;
+ push_vec3(in1);
+ }
break;
- case OPSubMat4Mat4:
- push_mat4(pull_mat4()-pull_mat4());
+ case OPSubVec4Vec4:{
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ subtract;
+ push_vec4(in1);
+ }
break;
- case OPSubMat4Float:
- push_mat4(pull_mat4()-pull_float());
+ case OPSubVec4Float:{
+ inputmask2(vec4_const_head,float_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ subtract;
+ push_vec4(in1);
+ }
break;
- case OPDivFloatFloat:
- push_float(pull_float()/pull_float());
- break;
- case OPDivVec2Vec2:
- push_vec2(pull_vec2()/pull_vec2());
- break;
- case OPDivVec2Float:
- push_vec2(pull_vec2()/pull_float());
- break;
- case OPDivVec3Vec3:
- push_vec3(pull_vec3()/pull_vec3());
- break;
- case OPDivVec3Float:
- push_vec3(pull_vec3()/pull_float());
- break;
- case OPDivVec4Vec4:
- push_vec4(pull_vec4()/pull_vec4());
- break;
- case OPDivVec4Float:
- push_vec4(pull_vec4()/pull_float());
+ case OPMulFloatFloat:{
+ inputmask2(float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ multiply;
+ push_float(in1);
+ }
break;
- case OPDivMat2Mat2:
- push_mat2(pull_mat2()/pull_mat2());
+ case OPMulVec2Vec2:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ multiply;
+ push_vec2(in1);
+ }
break;
- case OPDivMat2Float:
- push_mat2(pull_mat2()/pull_float());
+ case OPMulVec2Float:{
+ inputmask2(vec2_const_head,float_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ multiply;
+ push_vec2(in1);
+ }
break;
- case OPDivMat3Mat3:
- push_mat3(pull_mat3()/pull_mat3());
+ case OPMulVec3Vec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ multiply;
+ push_vec3(in1);
+ }
break;
- case OPDivMat3Float:
- push_mat3(pull_mat3()/pull_float());
+ case OPMulVec3Float:{
+ inputmask2(vec3_const_head,float_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ multiply;
+ push_vec3(in1);
+ }
break;
- case OPDivMat4Mat4:
- push_mat4(pull_mat4()/pull_mat4());
+ case OPMulVec4Vec4:{
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ multiply;
+ push_vec4(in1);
+ }
break;
- case OPDivMat4Float:
- push_mat4(pull_mat4()/pull_float());
+ case OPMulVec4Float:{
+ inputmask2(vec4_const_head,float_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ multiply;
+ push_vec4(in1);
+ }
break;
- case OPModFloatFloat:
- push_float(mod(pull_float(),pull_float()));
- break;
- case OPModVec2Vec2:
- push_vec2(mod(pull_vec2(),pull_vec2()));
- break;
- case OPModVec3Vec3:
- push_vec3(mod(pull_vec3(),pull_vec3()));
- break;
- case OPModVec4Vec4:
- push_vec4(mod(pull_vec4(),pull_vec4()));
- break;
- case OPModVec2Float:
- push_vec2(mod(pull_vec2(),pull_float()));
+ case OPDivFloatFloat:{
+ inputmask2(float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ divide;
+ push_float(in1);
+ }
break;
- case OPModVec3Float:
- push_vec3(mod(pull_vec3(),pull_float()));
+ case OPDivVec2Vec2:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ divide;
+ push_vec2(in1);
+ }
break;
- case OPModVec4Float:
- push_vec4(mod(pull_vec4(),pull_float()));
+ case OPDivVec2Float:{
+ inputmask2(vec2_const_head,float_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ divide;
+ push_vec2(in1);
+ }
break;
-
- case OPPowFloatFloat:
- push_float(pow(pull_float(),pull_float()));
+ case OPDivVec3Vec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ divide;
+ push_vec3(in1);
+ }
break;
- case OPPowVec2Vec2:
- push_vec2(pow(pull_vec2(),pull_vec2()));
+ case OPDivVec3Float:{
+ inputmask2(vec3_const_head,float_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ divide;
+ push_vec3(in1);
+ }
break;
- case OPPowVec3Vec3:
- push_vec3(pow(pull_vec3(),pull_vec3()));
+ case OPDivVec4Vec4:{
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ divide;
+ push_vec4(in1);
+ }
break;
- case OPPowVec4Vec4:
- push_vec4(pow(pull_vec4(),pull_vec4()));
+ case OPDivVec4Float:{
+ inputmask2(vec4_const_head,float_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ divide;
+ push_vec4(in1);
+ }
break;
- case OPCrossVec3:
- push_vec3(cross(pull_vec3(),pull_vec3()));
- break;
- case OPDotVec2:
- push_float(dot(pull_vec2(),pull_vec2()));
- break;
- case OPDotVec3:
- push_float(dot(pull_vec3(),pull_vec3()));
- break;
- case OPDotVec4:
- push_float(dot(pull_vec4(),pull_vec4()));
- break;
- case OPDistanceVec2:
- push_float(distance(pull_vec2(),pull_vec2()));
- break;
- case OPDistanceVec3:
- push_float(distance(pull_vec3(),pull_vec3()));
- break;
- case OPDistanceVec4:
- push_float(distance(pull_vec4(),pull_vec4()));
- break;
- case OPLengthVec2:
- push_float(length(pull_vec2()));
- break;
- case OPLengthVec3:
- push_float(length(pull_vec3()));
- break;
- case OPLengthVec4:
- push_float(length(pull_vec4()));
- break;
- case OPNormalizeVec2:
- push_vec2(normalize(pull_vec2()));
- break;
- case OPNormalizeVec3:
- push_vec3(normalize(pull_vec3()));
- break;
- case OPNormalizeVec4:
- push_vec4(normalize(pull_vec4()));
- break;
- case OPTransposeMat2:
- push_mat2(transpose(pull_mat2()));
- break;
- case OPTransposeMat3:
- push_mat3(transpose(pull_mat3()));
- break;
- case OPTransposeMat4:
- push_mat4(transpose(pull_mat4()));
- break;
- case OPInvertMat2:
- push_mat2(inverse(pull_mat2()));
- break;
- case OPInvertMat3:
- push_mat3(inverse(pull_mat3()));
- break;
- case OPInvertMat4:
- push_mat4(inverse(pull_mat4()));
+ case OPPowFloatFloat:{
+ inputmask2(float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ power;
+ push_float(in1);
+ }
break;
- case OPDeterminantMat2:
- push_float(determinant(pull_mat2()));
+ case OPPowVec2Vec2:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ power;
+ push_vec2(in1);
+ }
break;
- case OPDeterminantMat3:
- push_float(determinant(pull_mat3()));
+ case OPPowVec3Vec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ power;
+ push_vec3(in1);
+ }
break;
- case OPDeterminantMat4:
- push_float(determinant(pull_mat4()));
+ case OPPowVec4Vec4:{
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ power;
+ push_vec4(in1);
+ }
break;
- case OPAbsFloat:
- push_float(abs(pull_float()));
- break;
- case OPSignFloat:
- push_float(sign(pull_float()));
+ case OPModFloatFloat:{
+ inputmask2(float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ modulo;
+ push_float(in1);
+ }
break;
- case OPFloorFloat:
- push_float(floor(pull_float()));
+ case OPModVec2Vec2:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ modulo;
+ push_vec2(in1);
+ }
break;
- case OPCeilFloat:
- push_float(ceil(pull_float()));
+ case OPModVec2Float:{
+ inputmask2(vec2_const_head,float_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ modulo;
+ push_vec2(in1);
+ }
break;
- case OPFractFloat:
- push_float(fract(pull_float()));
+ case OPModVec3Vec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ modulo;
+ push_vec3(in1);
+ }
break;
- case OPSqrtFloat:
- push_float(sqrt(pull_float()));
+ case OPModVec3Float:{
+ inputmask2(vec3_const_head,float_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ modulo;
+ push_vec3(in1);
+ }
break;
- case OPInverseSqrtFloat:
- push_float(inversesqrt(pull_float()));
+ case OPModVec4Vec4:{
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ modulo;
+ push_vec4(in1);
+ }
break;
- case OPExpFloat:
- push_float(exp(pull_float()));
+ case OPModVec4Float:{
+ inputmask2(vec4_const_head,float_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ modulo;
+ push_vec4(in1);
+ }
break;
- case OPExp2Float:
- push_float(exp2(pull_float()));
+
+
+ case OPCrossVec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ push_vec3(cross(in1,in2));
+ }
break;
- case OPLogFloat:
- push_float(log(pull_float()));
+
+ case OPDotVec2:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ float out1;
+ dotprod;
+ push_float(out1);
+ }
break;
- case OPLog2Float:
- push_float(log2(pull_float()));
+ case OPDotVec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ float out1;
+ dotprod;
+ push_float(out1);
+ }
break;
- case OPSinFloat:
- push_float(sin(pull_float()));
+ case OPDotVec4:{
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ float out1;
+ dotprod;
+ push_float(out1);
+ }
break;
- case OPCosFloat:
- push_float(cos(pull_float()));
+
+ case OPLengthVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ float out1;
+ len;
+ push_float(out1);
+ }
break;
- case OPTanFloat:
- push_float(tan(pull_float()));
+ case OPLengthVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ float out1;
+ len;
+ push_float(out1);
+ }
break;
- case OPAsinFloat:
- push_float(asin(pull_float()));
+ case OPLengthVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ float out1;
+ len;
+ push_float(out1);
+ }
break;
- case OPAcosFloat:
- push_float(acos(pull_float()));
+
+ case OPDistanceVec2:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ float out1;
+ dist;
+ push_float(out1);
+ }
break;
- case OPAtanFloat:
- push_float(atan(pull_float()));
+ case OPDistanceVec3:{
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ float out1;
+ len;
+ push_float(out1);
+ }
break;
- case OPAsinhFloat:
- push_float(asinh(pull_float()));
+ case OPDistanceVec4:{
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ float out1;
+ dist;
+ push_float(out1);
+ }
break;
- case OPAcoshFloat:
- push_float(acosh(pull_float()));
+
+ case OPAbsFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ absolute;
+ push_float(in1);
+ }
break;
- case OPAtanhFloat:
- push_float(atanh(pull_float()));
+ case OPSignFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ signof;
+ push_float(in1);
+ }
break;
- case OPSinhFloat:
- push_float(sinh(pull_float()));
+ case OPFloorFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ floorof;
+ push_float(in1);
+ }
break;
- case OPCoshFloat:
- push_float(cosh(pull_float()));
+ case OPCeilFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ ceilingof;
+ push_float(in1);
+ }
break;
- case OPTanhFloat:
- push_float(tanh(pull_float()));
+ case OPFractFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ fractionalof;\
+ push_float(in1);
+ }
break;
- case OPRoundFloat:
- push_float(round(pull_float()));
+ case OPSqrtFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ squarerootof;
+ push_float(in1);
+ }
break;
- case OPTruncFloat:
- push_float(trunc(pull_float()));
+ case OPInverseSqrtFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ inversesquarerootof;
+ push_float(in1);
+ }
break;
- case OPSwap2Float:
- floattemp=float_stack[float_stack_head-1];
- float_stack[float_stack_head-1]=float_stack[float_stack_head-2];
- float_stack[float_stack_head-2]=floattemp;
+ case OPExpFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ exponentof;
+ push_float(in1);
+ }
break;
- case OPSwap3Float:
- floattemp=float_stack[float_stack_head-1];
- float_stack[float_stack_head-1]=float_stack[float_stack_head-3];
- float_stack[float_stack_head-3]=floattemp;
+ case OPExp2Float: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ exponent2of;
+ push_float(in1);
+ }
break;
- case OPSwap4Float:
- floattemp=float_stack[float_stack_head-1];
- float_stack[float_stack_head-1]=float_stack[float_stack_head-4];
- float_stack[float_stack_head-4]=floattemp;
+ case OPLogFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ logarithmof;
+ push_float(in1);
+ }
break;
- case OPDupFloat:
- push_float(float_stack[float_stack_head-1]);
+ case OPLog2Float: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ logarithm2of;
+ push_float(in1);
+ }
break;
- case OPDup2Float:
- push_float(float_stack[float_stack_head-2]);
+ case OPSinFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ sineof;
+ push_float(in1);
+ }
break;
- case OPDup3Float:
- push_float(float_stack[float_stack_head-3]);
+ case OPCosFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ cosineof;
+ push_float(in1);
+ }
break;
- case OPDup4Float:
- push_float(float_stack[float_stack_head-4]);
+ case OPTanFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ tangentof;
+ push_float(in1);
+ }
break;
- case OPDropFloat:
- float_stack_head--;
+ case OPAsinFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ arcsineof;
+ push_float(in1);
+ }
break;
- case OPDrop2Float:
- float_stack[float_stack_head-2]=float_stack[float_stack_head-1];
- float_stack_head--;
+ case OPAcosFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ arccosineof;
+ push_float(in1);
+ }
break;
- case OPDrop3Float:
- float_stack[float_stack_head-3]=float_stack[float_stack_head-2];
- float_stack[float_stack_head-2]=float_stack[float_stack_head-1];
- float_stack_head--;
+ case OPAtanFloat: {
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ arctangentof;
+ push_float(in1);
+ }
break;
- case OPDrop4Float:
- float_stack[float_stack_head-4]=float_stack[float_stack_head-3];
- float_stack[float_stack_head-3]=float_stack[float_stack_head-2];
- float_stack[float_stack_head-2]=float_stack[float_stack_head-1];
- float_stack_head--;
+ case OPAcoshFloat:{
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ hyperbolicarccosineof;
+ push_float(in1);
+ }
break;
-
- case OPAbsVec2:
- push_vec2(abs(pull_vec2()));
+ case OPAsinhFloat:{
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ hyperbolicarcsineof;
+ push_float(in1);
+ }
break;
- case OPSignVec2:
- push_vec2(sign(pull_vec2()));
+ case OPAtanhFloat:{
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ hyperbolicarctangentof;
+ push_float(in1);
+ }
break;
- case OPFloorVec2:
- push_vec2(floor(pull_vec2()));
+ case OPCoshFloat:{
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ hyperboliccosineof;
+ push_float(in1);
+ }
break;
- case OPCeilVec2:
- push_vec2(ceil(pull_vec2()));
+ case OPSinhFloat:{
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ hyperbolicsineof;
+ push_float(in1);
+ }
break;
- case OPFractVec2:
- push_vec2(fract(pull_vec2()));
+ case OPTanhFloat:{
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ hyperbolictangentof;
+ push_float(in1);
+ }
break;
- case OPSqrtVec2:
- push_vec2(sqrt(pull_vec2()));
+ case OPRoundFloat:{
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ roundof;
+ push_float(in1);
+ }
break;
- case OPInverseSqrtVec2:
- push_vec2(inversesqrt(pull_vec2()));
+ case OPTruncFloat:{
+ inputmask1(float_const_head);
+ float in1=pull_float(ifconst(0));
+ truncof;
+ push_float(in1);
+ }
break;
- case OPExpVec2:
- push_vec2(exp(pull_vec2()));
+ case OPMinMaterialFloat:
+ case OPMinFloat: {
+ inputmask2(float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ minimum;
+ push_float(in1);
+ }
break;
- case OPExp2Vec2:
- push_vec2(exp2(pull_vec2()));
+ case OPMaxMaterialFloat:
+ case OPMaxFloat: {
+ inputmask2(float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ maximum;
+ push_float(in1);
+ }
break;
- case OPLogVec2:
- push_vec2(log(pull_vec2()));
+ case OPFMAFloat: {
+ inputmask3(float_const_head,float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ fmaof;
+ push_float(in1);
+ }
break;
- case OPLog2Vec2:
- push_vec2(log2(pull_vec2()));
+
+ case OPAbsVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ absolute;
+ push_vec2(in1);
+ }
break;
- case OPSinVec2:
- push_vec2(sin(pull_vec2()));
+ case OPSignVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ signof;
+ push_vec2(in1);
+ }
break;
- case OPCosVec2:
- push_vec2(cos(pull_vec2()));
+ case OPFloorVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ floorof;
+ push_vec2(in1);
+ }
break;
- case OPTanVec2:
- push_vec2(tan(pull_vec2()));
+ case OPCeilVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ ceilingof;
+ push_vec2(in1);
+ }
break;
- case OPAsinVec2:
- push_vec2(asin(pull_vec2()));
+ case OPFractVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ fractionalof;
+ push_vec2(in1);
+ }
break;
- case OPAcosVec2:
- push_vec2(acos(pull_vec2()));
+ case OPSqrtVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ squarerootof;
+ push_vec2(in1);
+ }
break;
- case OPAtanVec2:
- push_vec2(atan(pull_vec2()));
+ case OPInverseSqrtVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ inversesquarerootof;
+ push_vec2(in1);
+ }
break;
- case OPAsinhVec2:
- push_vec2(asinh(pull_vec2()));
+ case OPExpVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ exponentof;
+ push_vec2(in1);
+ }
break;
- case OPAcoshVec2:
- push_vec2(acosh(pull_vec2()));
+ case OPExp2Vec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ exponent2of;
+ push_vec2(in1);
+ }
break;
- case OPAtanhVec2:
- push_vec2(atanh(pull_vec2()));
+ case OPLogVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ logarithmof;
+ push_vec2(in1);
+ }
break;
- case OPSinhVec2:
- push_vec2(sinh(pull_vec2()));
+ case OPLog2Vec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ logarithm2of;
+ push_vec2(in1);
+ }
break;
- case OPCoshVec2:
- push_vec2(cosh(pull_vec2()));
+ case OPSinVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ sineof;
+ push_vec2(in1);
+ }
break;
- case OPTanhVec2:
- push_vec2(tanh(pull_vec2()));
+ case OPCosVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ cosineof;
+ push_vec2(in1);
+ }
break;
- case OPRoundVec2:
- push_vec2(round(pull_vec2()));
+ case OPTanVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ tangentof;
+ push_vec2(in1);
+ }
break;
- case OPTruncVec2:
- push_vec2(trunc(pull_vec2()));
+ case OPAsinVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ arcsineof;
+ push_vec2(in1);
+ }
break;
- case OPSwap2Vec2:
- vec2temp=vec2_stack[vec2_stack_head-1];
- vec2_stack[vec2_stack_head-1]=vec2_stack[vec2_stack_head-2];
- vec2_stack[vec2_stack_head-2]=vec2temp;
+ case OPAcosVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ arccosineof;
+ push_vec2(in1);
+ }
break;
- case OPSwap3Vec2:
- vec2temp=vec2_stack[vec2_stack_head-1];
- vec2_stack[vec2_stack_head-1]=vec2_stack[vec2_stack_head-3];
- vec2_stack[vec2_stack_head-3]=vec2temp;
+ case OPAtanVec2: {
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ arctangentof;
+ push_vec2(in1);
+ }
break;
- case OPSwap4Vec2:
- vec2temp=vec2_stack[vec2_stack_head-1];
- vec2_stack[vec2_stack_head-1]=vec2_stack[vec2_stack_head-4];
- vec2_stack[vec2_stack_head-4]=vec2temp;
+ case OPAcoshVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ hyperbolicarccosineof;
+ push_vec2(in1);
+ }
break;
- case OPDupVec2:
- push_vec2(vec2_stack[vec2_stack_head-1]);
+ case OPAsinhVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ hyperbolicarcsineof;
+ push_vec2(in1);
+ }
break;
- case OPDup2Vec2:
- push_vec2(vec2_stack[vec2_stack_head-2]);
+ case OPAtanhVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ hyperbolicarctangentof;
+ push_vec2(in1);
+ }
break;
- case OPDup3Vec2:
- push_vec2(vec2_stack[vec2_stack_head-3]);
+ case OPCoshVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ hyperboliccosineof;
+ push_vec2(in1);
+ }
break;
- case OPDup4Vec2:
- push_vec2(vec2_stack[vec2_stack_head-4]);
+ case OPSinhVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ hyperbolicsineof;
+ push_vec2(in1);
+ }
break;
- case OPDropVec2:
- vec2_stack_head--;
+ case OPTanhVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ hyperbolictangentof;
+ push_vec2(in1);
+ }
break;
- case OPDrop2Vec2:
- vec2_stack[vec2_stack_head-2]=vec2_stack[vec2_stack_head-1];
- vec2_stack_head--;
+ case OPRoundVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ roundof;
+ push_vec2(in1);
+ }
break;
- case OPDrop3Vec2:
- vec2_stack[vec2_stack_head-3]=vec2_stack[vec2_stack_head-2];
- vec2_stack[vec2_stack_head-2]=vec2_stack[vec2_stack_head-1];
- vec2_stack_head--;
+ case OPTruncVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ truncof;
+ push_vec2(in1);
+ }
break;
- case OPDrop4Vec2:
- vec2_stack[vec2_stack_head-4]=vec2_stack[vec2_stack_head-3];
- vec2_stack[vec2_stack_head-3]=vec2_stack[vec2_stack_head-2];
- vec2_stack[vec2_stack_head-2]=vec2_stack[vec2_stack_head-1];
- vec2_stack_head--;
+ case OPMinVec2: {
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ minimum;
+ push_vec2(in1);
+ }
break;
-
- case OPAbsVec3:
- push_vec3(abs(pull_vec3()));
+ case OPMaxVec2: {
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ maximum;
+ push_vec2(in1);
+ }
break;
- case OPSignVec3:
- push_vec3(sign(pull_vec3()));
+ case OPFMAVec2: {
+ inputmask3(vec2_const_head,vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ vec2 in3=pull_vec2(ifconst(2));
+ fmaof;
+ push_vec2(in1);
+ }
break;
- case OPFloorVec3:
- push_vec3(floor(pull_vec3()));
+
+ case OPAbsVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ absolute;
+ push_vec3(in1);
+ }
break;
- case OPCeilVec3:
- push_vec3(ceil(pull_vec3()));
+ case OPSignVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ signof;
+ push_vec3(in1);
+ }
break;
- case OPFractVec3:
- push_vec3(fract(pull_vec3()));
+ case OPFloorVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ floorof;
+ push_vec3(in1);
+ }
break;
- case OPSqrtVec3:
- push_vec3(sqrt(pull_vec3()));
+ case OPCeilVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ ceilingof;
+ push_vec3(in1);
+ }
break;
- case OPInverseSqrtVec3:
- push_vec3(inversesqrt(pull_vec3()));
+ case OPFractVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ fractionalof;
+ push_vec3(in1);
+ }
break;
- case OPExpVec3:
- push_vec3(exp(pull_vec3()));
+ case OPSqrtVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ squarerootof;
+ push_vec3(in1);
+ }
break;
- case OPExp2Vec3:
- push_vec3(exp2(pull_vec3()));
+ case OPInverseSqrtVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ inversesquarerootof;
+ push_vec3(in1);
+ }
break;
- case OPLogVec3:
- push_vec3(log(pull_vec3()));
+ case OPExpVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ exponentof;
+ push_vec3(in1);
+ }
break;
- case OPLog2Vec3:
- push_vec3(log2(pull_vec3()));
+ case OPExp2Vec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ exponent2of;
+ push_vec3(in1);
+ }
break;
- case OPSinVec3:
- push_vec3(sin(pull_vec3()));
+ case OPLogVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ logarithmof;
+ push_vec3(in1);
+ }
break;
- case OPCosVec3:
- push_vec3(cos(pull_vec3()));
+ case OPLog2Vec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ logarithm2of;
+ push_vec3(in1);
+ }
break;
- case OPTanVec3:
- push_vec3(tan(pull_vec3()));
+ case OPSinVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ sineof;
+ push_vec3(in1);
+ }
break;
- case OPAsinVec3:
- push_vec3(asin(pull_vec3()));
+ case OPCosVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ cosineof;
+ push_vec3(in1);
+ }
break;
- case OPAcosVec3:
- push_vec3(acos(pull_vec3()));
+ case OPTanVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ tangentof;
+ push_vec3(in1);
+ }
break;
- case OPAtanVec3:
- push_vec3(atan(pull_vec3()));
+ case OPAsinVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ arcsineof;
+ push_vec3(in1);
+ }
break;
- case OPAsinhVec3:
- push_vec3(asinh(pull_vec3()));
+ case OPAcosVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ arccosineof;
+ push_vec3(in1);
+ }
break;
- case OPAcoshVec3:
- push_vec3(acosh(pull_vec3()));
+ case OPAtanVec3: {
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ arctangentof;
+ push_vec3(in1);
+ }
break;
- case OPAtanhVec3:
- push_vec3(atanh(pull_vec3()));
+ case OPAcoshVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ hyperbolicarccosineof;
+ push_vec3(in1);
+ }
break;
- case OPSinhVec3:
- push_vec3(sinh(pull_vec3()));
+ case OPAsinhVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ hyperbolicarcsineof;
+ push_vec3(in1);
+ }
break;
- case OPCoshVec3:
- push_vec3(cosh(pull_vec3()));
+ case OPAtanhVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ hyperbolicarctangentof;
+ push_vec3(in1);
+ }
break;
- case OPTanhVec3:
- push_vec3(tanh(pull_vec3()));
+ case OPCoshVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ hyperboliccosineof;
+ push_vec3(in1);
+ }
break;
- case OPRoundVec3:
- push_vec3(round(pull_vec3()));
+ case OPSinhVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ hyperbolicsineof;
+ push_vec3(in1);
+ }
break;
- case OPTruncVec3:
- push_vec3(trunc(pull_vec3()));
+ case OPTanhVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ hyperbolictangentof;
+ push_vec3(in1);
+ }
break;
- case OPSwap2Vec3:
- vec3temp=vec3_stack[vec3_stack_head-1];
- vec3_stack[vec3_stack_head-1]=vec3_stack[vec3_stack_head-2];
- vec3_stack[vec3_stack_head-2]=vec3temp;
+ case OPRoundVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ roundof;
+ push_vec3(in1);
+ }
break;
- case OPSwap3Vec3:
- vec3temp=vec3_stack[vec3_stack_head-1];
- vec3_stack[vec3_stack_head-1]=vec3_stack[vec3_stack_head-3];
- vec3_stack[vec3_stack_head-3]=vec3temp;
+ case OPTruncVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ truncof;
+ push_vec3(in1);
+ }
break;
- case OPSwap4Vec3:
- vec3temp=vec3_stack[vec3_stack_head-1];
- vec3_stack[vec3_stack_head-1]=vec3_stack[vec3_stack_head-4];
- vec3_stack[vec3_stack_head-4]=vec3temp;
+ case OPMinVec3: {
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ minimum;
+ push_vec3(in1);
+ }
break;
- case OPDupVec3:
- push_vec3(vec3_stack[vec3_stack_head-1]);
+ case OPMaxVec3: {
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ maximum;
+ push_vec3(in1);
+ }
break;
- case OPDup2Vec3:
- push_vec3(vec3_stack[vec3_stack_head-2]);
+ case OPFMAVec3: {
+ inputmask3(vec3_const_head,vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ vec3 in3=pull_vec3(ifconst(2));
+ fmaof;
+ push_vec3(in1);
+ }
break;
- case OPDup3Vec3:
- push_vec3(vec3_stack[vec3_stack_head-3]);
+
+ case OPAbsVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ absolute;
+ push_vec4(in1);
+ }
break;
- case OPDup4Vec3:
- push_vec3(vec3_stack[vec3_stack_head-4]);
+ case OPSignVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ signof;
+ push_vec4(in1);
+ }
break;
- case OPDropVec3:
- vec3_stack_head--;
+ case OPFloorVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ floorof;
+ push_vec4(in1);
+ }
break;
- case OPDrop2Vec3:
- vec3_stack[vec3_stack_head-2]=vec3_stack[vec3_stack_head-1];
- vec3_stack_head--;
+ case OPCeilVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ ceilingof;
+ push_vec4(in1);
+ }
break;
- case OPDrop3Vec3:
- vec3_stack[vec3_stack_head-3]=vec3_stack[vec3_stack_head-2];
- vec3_stack[vec3_stack_head-2]=vec3_stack[vec3_stack_head-1];
- vec3_stack_head--;
+ case OPFractVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ fractionalof;
+ push_vec4(in1);
+ }
break;
- case OPDrop4Vec3:
- vec3_stack[vec3_stack_head-4]=vec3_stack[vec3_stack_head-3];
- vec3_stack[vec3_stack_head-3]=vec3_stack[vec3_stack_head-2];
- vec3_stack[vec3_stack_head-2]=vec3_stack[vec3_stack_head-1];
- vec3_stack_head--;
+ case OPSqrtVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ squarerootof;
+ push_vec4(in1);
+ }
break;
-
- case OPAbsVec4:
- push_vec4(abs(pull_vec4()));
+ case OPInverseSqrtVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ inversesquarerootof;
+ push_vec4(in1);
+ }
break;
- case OPSignVec4:
- push_vec4(sign(pull_vec4()));
+ case OPExpVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ exponentof;
+ push_vec4(in1);
+ }
break;
- case OPFloorVec4:
- push_vec4(floor(pull_vec4()));
+ case OPExp2Vec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ exponent2of;
+ push_vec4(in1);
+ }
break;
- case OPCeilVec4:
- push_vec4(ceil(pull_vec4()));
+ case OPLogVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ logarithmof;
+ push_vec4(in1);
+ }
break;
- case OPFractVec4:
- push_vec4(fract(pull_vec4()));
+ case OPLog2Vec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ logarithm2of;
+ push_vec4(in1);
+ }
break;
- case OPSqrtVec4:
- push_vec4(sqrt(pull_vec4()));
+ case OPSinVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ sineof;
+ push_vec4(in1);
+ }
break;
- case OPInverseSqrtVec4:
- push_vec4(inversesqrt(pull_vec4()));
+ case OPCosVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ cosineof;
+ push_vec4(in1);
+ }
break;
- case OPExpVec4:
- push_vec4(exp(pull_vec4()));
+ case OPTanVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ tangentof;
+ push_vec4(in1);
+ }
break;
- case OPExp2Vec4:
- push_vec4(exp2(pull_vec4()));
+ case OPAsinVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ arcsineof;
+ push_vec4(in1);
+ }
break;
- case OPLogVec4:
- push_vec4(log(pull_vec4()));
+ case OPAcosVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ arccosineof;
+ push_vec4(in1);
+ }
break;
- case OPLog2Vec4:
- push_vec4(log2(pull_vec4()));
+ case OPAtanVec4: {
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ arctangentof;
+ push_vec4(in1);
+ }
break;
- case OPSinVec4:
- push_vec4(sin(pull_vec4()));
+ case OPAcoshVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ hyperbolicarccosineof;
+ push_vec4(in1);
+ }
break;
- case OPCosVec4:
- push_vec4(cos(pull_vec4()));
+ case OPAsinhVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ hyperbolicarcsineof;
+ push_vec4(in1);
+ }
break;
- case OPTanVec4:
- push_vec4(tan(pull_vec4()));
+ case OPAtanhVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ hyperbolicarctangentof;
+ push_vec4(in1);
+ }
break;
- case OPAsinVec4:
- push_vec4(asin(pull_vec4()));
+ case OPCoshVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ hyperboliccosineof;
+ push_vec4(in1);
+ }
break;
- case OPAcosVec4:
- push_vec4(acos(pull_vec4()));
+ case OPSinhVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ hyperbolicsineof;
+ push_vec4(in1);
+ }
break;
- case OPAtanVec4:
- push_vec4(atan(pull_vec4()));
+ case OPTanhVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ hyperbolictangentof;
+ push_vec4(in1);
+ }
break;
- case OPAsinhVec4:
- push_vec4(asinh(pull_vec4()));
+ case OPRoundVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ roundof;
+ push_vec4(in1);
+ }
break;
- case OPAcoshVec4:
- push_vec4(acosh(pull_vec4()));
+ case OPTruncVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ truncof;
+ push_vec4(in1);
+ }
break;
- case OPAtanhVec4:
- push_vec4(atanh(pull_vec4()));
+ case OPMinVec4: {
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ minimum;
+ push_vec4(in1);
+ }
break;
- case OPSinhVec4:
- push_vec4(sinh(pull_vec4()));
+ case OPMaxVec4: {
+ inputmask2(vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ maximum;
+ push_vec4(in1);
+ }
break;
- case OPCoshVec4:
- push_vec4(cosh(pull_vec4()));
+ case OPFMAVec4: {
+ inputmask3(vec4_const_head,vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ vec4 in3=pull_vec4(ifconst(2));
+ fmaof;
+ push_vec4(in1);
+ }
break;
- case OPTanhVec4:
- push_vec4(tanh(pull_vec4()));
+
+ case OPClampFloatFloat:{
+ inputmask3(float_const_head,float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ clampof;
+ push_float(in1);
+ }
break;
- case OPRoundVec4:
- push_vec4(round(pull_vec4()));
+ case OPMixFloatFloat:{
+ inputmask3(float_const_head,float_const_head,float_const_head);
+ float in1=pull_float(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ mixof;
+ push_float(in1);
+ }
break;
- case OPTruncVec4:
- push_vec4(trunc(pull_vec4()));
+ case OPClampVec2Vec2:{
+ inputmask3(vec2_const_head,vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ vec2 in3=pull_vec2(ifconst(2));
+ clampof;
+ push_vec2(in1);
+ }
break;
- case OPSwap2Vec4:
- vec4temp=vec4_stack[vec4_stack_head-1];
- vec4_stack[vec4_stack_head-1]=vec4_stack[vec4_stack_head-2];
- vec4_stack[vec4_stack_head-2]=vec4temp;
+ case OPMixVec2Vec2:{
+ inputmask3(vec2_const_head,vec2_const_head,vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ vec2 in3=pull_vec2(ifconst(2));
+ mixof;
+ push_vec2(in1);
+ }
break;
- case OPSwap3Vec4:
- vec4temp=vec4_stack[vec4_stack_head-1];
- vec4_stack[vec4_stack_head-1]=vec4_stack[vec4_stack_head-3];
- vec4_stack[vec4_stack_head-3]=vec4temp;
+ case OPClampVec2Float:{
+ inputmask3(vec2_const_head,float_const_head,float_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ clampof;
+ push_vec2(in1);
+ }
break;
- case OPSwap4Vec4:
- vec4temp=vec4_stack[vec4_stack_head-1];
- vec4_stack[vec4_stack_head-1]=vec4_stack[vec4_stack_head-4];
- vec4_stack[vec4_stack_head-4]=vec4temp;
+ case OPMixVec2Float:{
+ inputmask3(vec2_const_head,vec2_const_head,float_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ vec2 in2=pull_vec2(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ mixof;
+ push_vec2(in1);
+ }
break;
- case OPDupVec4:
- push_vec4(vec4_stack[vec4_stack_head-1]);
+ case OPClampVec3Vec3:{
+ inputmask3(vec3_const_head,vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ vec3 in3=pull_vec3(ifconst(2));
+ clampof;
+ push_vec3(in1);
+ }
break;
- case OPDup2Vec4:
- push_vec4(vec4_stack[vec4_stack_head-2]);
+ case OPMixVec3Vec3:{
+ inputmask3(vec3_const_head,vec3_const_head,vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ vec3 in3=pull_vec3(ifconst(2));
+ mixof;
+ push_vec3(in1);
+ }
break;
- case OPDup3Vec4:
- push_vec4(vec4_stack[vec4_stack_head-3]);
+ case OPClampVec3Float:{
+ inputmask3(vec3_const_head,float_const_head,float_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ clampof;
+ push_vec3(in1);
+ }
break;
- case OPDup4Vec4:
- push_vec4(vec4_stack[vec4_stack_head-4]);
+ case OPMixVec3Float:{
+ inputmask3(vec3_const_head,vec3_const_head,float_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ vec3 in2=pull_vec3(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ mixof;
+ push_vec3(in1);
+ }
break;
- case OPDropVec4:
- vec4_stack_head--;
+ case OPClampVec4Vec4:{
+ inputmask3(vec4_const_head,vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ vec4 in3=pull_vec4(ifconst(2));
+ clampof;
+ push_vec4(in1);
+ }
break;
- case OPDrop2Vec4:
- vec4_stack[vec4_stack_head-2]=vec4_stack[vec4_stack_head-1];
- vec4_stack_head--;
+ case OPMixVec4Vec4:{
+ inputmask3(vec4_const_head,vec4_const_head,vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ vec4 in3=pull_vec4(ifconst(2));
+ mixof;
+ push_vec4(in1);
+ }
break;
- case OPDrop3Vec4:
- vec4_stack[vec4_stack_head-3]=vec4_stack[vec4_stack_head-2];
- vec4_stack[vec4_stack_head-2]=vec4_stack[vec4_stack_head-1];
- vec4_stack_head--;
+ case OPClampVec4Float:{
+ inputmask3(vec4_const_head,float_const_head,float_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ float in2=pull_float(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ clampof;
+ push_vec4(in1);
+ }
break;
- case OPDrop4Vec4:
- vec4_stack[vec4_stack_head-4]=vec4_stack[vec4_stack_head-3];
- vec4_stack[vec4_stack_head-3]=vec4_stack[vec4_stack_head-2];
- vec4_stack[vec4_stack_head-2]=vec4_stack[vec4_stack_head-1];
- vec4_stack_head--;
+ case OPMixVec4Float:{
+ inputmask3(vec4_const_head,vec4_const_head,float_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ vec4 in2=pull_vec4(ifconst(1));
+ float in3=pull_float(ifconst(2));
+ mixof;
+ push_vec4(in1);
+ }
break;
- case OPSwap2Mat2:
- mat2temp=mat2_stack[mat2_stack_head-1];
- mat2_stack[mat2_stack_head-1]=mat2_stack[mat2_stack_head-2];
- mat2_stack[mat2_stack_head-2]=mat2temp;
- break;
- case OPSwap3Mat2:
- mat2temp=mat2_stack[mat2_stack_head-1];
- mat2_stack[mat2_stack_head-1]=mat2_stack[mat2_stack_head-3];
- mat2_stack[mat2_stack_head-3]=mat2temp;
- break;
- case OPSwap4Mat2:
- mat2temp=mat2_stack[mat2_stack_head-1];
- mat2_stack[mat2_stack_head-1]=mat2_stack[mat2_stack_head-4];
- mat2_stack[mat2_stack_head-4]=mat2temp;
- break;
- case OPDupMat2:
- push_mat2(mat2_stack[mat2_stack_head-1]);
- break;
- case OPDup2Mat2:
- push_mat2(mat2_stack[mat2_stack_head-2]);
- break;
- case OPDup3Mat2:
- push_mat2(mat2_stack[mat2_stack_head-3]);
- break;
- case OPDup4Mat2:
- push_mat2(mat2_stack[mat2_stack_head-4]);
- break;
- case OPDropMat2:
- mat2_stack_head--;
- break;
- case OPDrop2Mat2:
- mat2_stack[mat2_stack_head-2]=mat2_stack[mat2_stack_head-1];
- mat2_stack_head--;
- break;
- case OPDrop3Mat2:
- mat2_stack[mat2_stack_head-3]=mat2_stack[mat2_stack_head-2];
- mat2_stack[mat2_stack_head-2]=mat2_stack[mat2_stack_head-1];
- mat2_stack_head--;
+ case OPNormalizeVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1=pull_vec2(ifconst(0));
+ push_vec2(normalize(in1));
+ }
break;
- case OPDrop4Mat2:
- mat2_stack[mat2_stack_head-4]=mat2_stack[mat2_stack_head-3];
- mat2_stack[mat2_stack_head-3]=mat2_stack[mat2_stack_head-2];
- mat2_stack[mat2_stack_head-2]=mat2_stack[mat2_stack_head-1];
- mat2_stack_head--;
+ case OPNormalizeVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1=pull_vec3(ifconst(0));
+ push_vec3(normalize(in1));
+ }
break;
-
- case OPSwap2Mat3:
- mat3temp=mat3_stack[mat3_stack_head-1];
- mat3_stack[mat3_stack_head-1]=mat3_stack[mat3_stack_head-2];
- mat3_stack[mat3_stack_head-2]=mat3temp;
+ case OPNormalizeVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1=pull_vec4(ifconst(0));
+ push_vec4(normalize(in1));
+ }
break;
- case OPSwap3Mat3:
- mat3temp=mat3_stack[mat3_stack_head-1];
- mat3_stack[mat3_stack_head-1]=mat3_stack[mat3_stack_head-3];
- mat3_stack[mat3_stack_head-3]=mat3temp;
+
+ case OPPromoteFloatFloatVec2:{
+ inputmask2(float_const_head,float_const_head);
+ float a = pull_float(ifconst(0));
+ float b = pull_float(ifconst(1));
+ push_vec2(vec2 (a,b));
+ }
break;
- case OPSwap4Mat3:
- mat3temp=mat3_stack[mat3_stack_head-1];
- mat3_stack[mat3_stack_head-1]=mat3_stack[mat3_stack_head-4];
- mat3_stack[mat3_stack_head-4]=mat3temp;
+ case OPPromoteFloatFloatFloatVec3:{
+ inputmask3(float_const_head,float_const_head,float_const_head);
+ float a = pull_float(ifconst(0));
+ float b = pull_float(ifconst(1));
+ float c = pull_float(ifconst(2));
+ push_vec3(vec3 (a,b,c));
+ }
break;
- case OPDupMat3:
- push_mat3(mat3_stack[mat3_stack_head-1]);
+ case OPPromoteVec2FloatVec3:{
+ inputmask2(vec2_const_head,float_const_head);
+ vec2 a = pull_vec2(ifconst(0));
+ float b = pull_float(ifconst(1));
+ push_vec3(vec3 (a,b));
+ }
break;
- case OPDup2Mat3:
- push_mat3(mat3_stack[mat3_stack_head-2]);
+ case OPPromoteFloatFloatFloatFloatVec4:{
+ inputmask4(float_const_head,float_const_head,float_const_head,float_const_head);
+ float a = pull_float(ifconst(0));
+ float b = pull_float(ifconst(1));
+ float c = pull_float(ifconst(2));
+ float d = pull_float(ifconst(3));
+ push_vec4(vec4 (a,b,c,d));
+ }
break;
- case OPDup3Mat3:
- push_mat3(mat3_stack[mat3_stack_head-3]);
+ case OPPromoteVec2FloatFloatVec4:{
+ inputmask3(vec2_const_head,float_const_head,float_const_head);
+ vec2 a = pull_vec2(ifconst(0));
+ float b = pull_float(ifconst(1));
+ float c = pull_float(ifconst(2));
+ push_vec4(vec4 (a,b,c));
+ }
break;
- case OPDup4Mat3:
- push_mat3(mat3_stack[mat3_stack_head-4]);
+ case OPPromoteVec3FloatVec4:{
+ inputmask2(vec3_const_head,float_const_head);
+ vec3 a = pull_vec3(ifconst(0));
+ float b = pull_float(ifconst(1));
+ push_vec4(vec4 (a,b));
+ }
break;
- case OPDropMat3:
- mat3_stack_head--;
+ case OPPromoteVec2Vec2Vec4:{
+ inputmask2(vec2_const_head,vec2_const_head);
+ vec2 a = pull_vec2(ifconst(0));
+ vec2 b = pull_vec2(ifconst(1));
+ push_vec4(vec4 (a,b));
+ }
break;
- case OPDrop2Mat3:
- mat3_stack[mat3_stack_head-2]=mat3_stack[mat3_stack_head-1];
- mat3_stack_head--;
+
+ /*
+ case OPDemoteMat2Float:{
+ mat2 mat2temp=pull_mat2(ifconst(0));
+ push_float(float (mat2temp[0][1].y,mat2temp[1][1].y));
+ push_float(float (mat2temp[0][1].x,mat2temp[1][1].x));
+ push_float(float (mat2temp[0][0].y,mat2temp[1][0].y));
+ push_float(float (mat2temp[0][0].x,mat2temp[1][0].x));
+ }
break;
- case OPDrop3Mat3:
- mat3_stack[mat3_stack_head-3]=mat3_stack[mat3_stack_head-2];
- mat3_stack[mat3_stack_head-2]=mat3_stack[mat3_stack_head-1];
- mat3_stack_head--;
+ case OPDemoteMat2Vec2:{
+ mat2 mat2temp=pull_mat2(ifconst(0));
+ push_vec2(vec2 (mat2temp[0][1],mat2temp[1][1]));
+ push_vec2(vec2 (mat2temp[0][0],mat2temp[1][0]));
+ }
break;
- case OPDrop4Mat3:
- mat3_stack[mat3_stack_head-4]=mat3_stack[mat3_stack_head-3];
- mat3_stack[mat3_stack_head-3]=mat3_stack[mat3_stack_head-2];
- mat3_stack[mat3_stack_head-2]=mat3_stack[mat3_stack_head-1];
- mat3_stack_head--;
+ case OPDemoteMat3Vec3:{
+ mat3 mat3temp=pull_mat3(ifconst(0));
+ push_vec3(vec3 (mat3temp[0] ,mat3temp[1] ));
+ push_vec3(vec3 (mat3temp[0][1],mat3temp[1][1]));
+ push_vec3(vec3 (mat3temp[0][0],mat3temp[1][0]));
+ }
break;
-
- case OPSwap2Mat4:
- mat4temp=mat4_stack[mat4_stack_head-1];
- mat4_stack[mat4_stack_head-1]=mat4_stack[mat4_stack_head-2];
- mat4_stack[mat4_stack_head-2]=mat4temp;
+ case OPDemoteMat4Vec4:{
+ mat4 mat4temp=pull_mat4(ifconst(0));
+ push_vec4(vec4 (mat4temp[0][3],mat4temp[1][3]));
+ push_vec4(vec4 (mat4temp[0] ,mat4temp[1] ));
+ push_vec4(vec4 (mat4temp[0][1],mat4temp[1][1]));
+ push_vec4(vec4 (mat4temp[0][0],mat4temp[1][0]));
+ }
break;
- case OPSwap3Mat4:
- mat4temp=mat4_stack[mat4_stack_head-1];
- mat4_stack[mat4_stack_head-1]=mat4_stack[mat4_stack_head-3];
- mat4_stack[mat4_stack_head-3]=mat4temp;
+ case OPDemoteMat2Vec4:{
+ mat2 mat2temp=pull_mat2(ifconst(0));
+ push_vec4(vec4 (vec4(mat2temp[0][0],mat2temp[0][1]),vec4(mat2temp[1][0],mat2temp[1][1])));
+ }
break;
- case OPSwap4Mat4:
- mat4temp=mat4_stack[mat4_stack_head-1];
- mat4_stack[mat4_stack_head-1]=mat4_stack[mat4_stack_head-4];
- mat4_stack[mat4_stack_head-4]=mat4temp;
+ case OPDemoteVec2FloatFloat:{
+ vec2 vec2temp=pull_vec2(ifconst(0));
+ push_float(float (vec2temp[0].y,vec2temp[1].y));
+ push_float(float (vec2temp[0].x,vec2temp[1].x));
+ }
break;
- case OPDupMat4:
- push_mat4(mat4_stack[mat4_stack_head-1]);
+ case OPDemoteVec3FloatFloatFloat:{
+ vec3 vec3temp=pull_vec3(ifconst(0));
+ push_float(float (vec3temp[0].z,vec3temp[1].z));
+ push_float(float (vec3temp[0].y,vec3temp[1].y));
+ push_float(float (vec3temp[0].x,vec3temp[1].x));
+ }
break;
- case OPDup2Mat4:
- push_mat4(mat4_stack[mat4_stack_head-2]);
+ case OPDemoteVec4FloatFloatFloatFloat:{
+ vec4 vec4temp=pull_vec4(ifconst(0));
+ push_float(float (vec4temp[0].w,vec4temp[1].w));
+ push_float(float (vec4temp[0].z,vec4temp[1].z));
+ push_float(float (vec4temp[0].y,vec4temp[1].y));
+ push_float(float (vec4temp[0].x,vec4temp[1].x));
+ }
break;
- case OPDup3Mat4:
- push_mat4(mat4_stack[mat4_stack_head-3]);
+ */
+
+ case OPSquareFloat:{
+ inputmask1(float_const_head);
+ float in1 = pull_float(ifconst(0));
+ square;
+ push_float(in1);
+ }
break;
- case OPDup4Mat4:
- push_mat4(mat4_stack[mat4_stack_head-4]);
+ case OPCubeFloat:{
+ inputmask1(float_const_head);
+ float in1 = pull_float(ifconst(0));
+ cube;
+ push_float(in1);
+ }
break;
- case OPDropMat4:
- mat4_stack_head--;
+ case OPSquareVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1 = pull_vec2(ifconst(0));
+ square;
+ push_vec2(in1);
+ }
break;
- case OPDrop2Mat4:
- mat4_stack[mat4_stack_head-2]=mat4_stack[mat4_stack_head-1];
- mat4_stack_head--;
+ case OPCubeVec2:{
+ inputmask1(vec2_const_head);
+ vec2 in1 = pull_vec2(ifconst(0));
+ cube;
+ push_vec2(in1);
+ }
break;
- case OPDrop3Mat4:
- mat4_stack[mat4_stack_head-3]=mat4_stack[mat4_stack_head-2];
- mat4_stack[mat4_stack_head-2]=mat4_stack[mat4_stack_head-1];
- mat4_stack_head--;
+ case OPSquareVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1 = pull_vec3(ifconst(0));
+ square;
+ push_vec3(in1);
+ }
break;
- case OPDrop4Mat4:
- mat4_stack[mat4_stack_head-4]=mat4_stack[mat4_stack_head-3];
- mat4_stack[mat4_stack_head-3]=mat4_stack[mat4_stack_head-2];
- mat4_stack[mat4_stack_head-2]=mat4_stack[mat4_stack_head-1];
- mat4_stack_head--;
+ case OPCubeVec3:{
+ inputmask1(vec3_const_head);
+ vec3 in1 = pull_vec3(ifconst(0));
+ cube;
+ push_vec3(in1);
+ }
break;
-
- case OPMinFloat:
- push_float(min(pull_float(),pull_float()));
+ case OPSquareVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1 = pull_vec4(ifconst(0));
+ square;
+ push_vec4(in1);
+ }
break;
- case OPMaxFloat:
- push_float(max(pull_float(),pull_float()));
+ case OPCubeVec4:{
+ inputmask1(vec4_const_head);
+ vec4 in1 = pull_vec4(ifconst(0));
+ cube;
+ push_vec4(in1);
+ }
break;
+
+ case OPSmoothMinMaterialFloat:
case OPSmoothMinFloat:{
- float k=pull_float();
- float a=pull_float();
- float b=pull_float();
- float h=max(k-abs(a-b),0.)/k;
- push_float(min(a,b)-h*h*k*(1./4.));
- }
- break;
- case OPSmoothMinMaterialFloat:{
- float k=pull_float();
- float a=pull_float();
- float b=pull_float();
- float h=max(k-abs(a-b),0.)/k;
- float m=h*h*.5;
- float s=m*k*(1./2.);
- push_float(min(a,b)-s);
- if(material){
- m=(a<b)?m:1.-m;
- push_material((pull_material()*m)+(pull_material()*(1-m)));
- }
+ inputmask3(float_const_head,float_const_head,float_const_head);
+ float k=pull_float(ifconst(0));
+ float a=pull_float(ifconst(1));
+ float b=pull_float(ifconst(2));
+ float h=max(k-abs(a-b),0.);
+ float s=min(a,b)-h*h*.25/k;
+ push_float(s);
}
break;
+ case OPSmoothMaxMaterialFloat:
case OPSmoothMaxFloat:{
- float k=pull_float();
- float a=pull_float();
- float b=pull_float();
- float h=max(k-abs(a-b),0.)/k;
- push_float(max(a,b)+h*h*k*(1./4.));
- }
- break;
- case OPSmoothMaxMaterialFloat:{
- float k=pull_float();
- float a=pull_float();
- float b=pull_float();
- float h=max(k-abs(a-b),0.)/k;
- float m=h*h*.5;
- float s=m*k*(1./2.);
- push_float(max(a,b)+s);
- if(material){
- m=(a>b)?m:1.-m;
- push_material((pull_material()*m)+(pull_material()*(1-m)));
- }
+ inputmask3(float_const_head,float_const_head,float_const_head);
+ float k=pull_float(ifconst(0));
+ float a=pull_float(ifconst(1));
+ float b=pull_float(ifconst(2));
+ float h=max(k-abs(a-b),0.);
+ float s=max(a,b)+h*h*.25/k;
+ push_float(s);
}
break;
-
- case OPMinMaterialFloat:
- {
- float a=pull_float();
- float b=pull_float();
- push_float(min(a,b));
- if(material){
- material_stack_head--;
- if(a<b){
- material_stack[material_stack_head-1]=material_stack[material_stack_head];
- }
- }
+
+ /*
+ case OPSwap2Float:{
+ float floattemp=float_stack[float_stack_head-1];
+ float_stack[float_stack_head-1]=float_stack[float_stack_head-2];
}
break;
- case OPMaxMaterialFloat:
- {
- float a=pull_float();
- float b=pull_float();
- push_float(max(a,b));
- if(material){
- material_stack_head--;
- if(a>b){
- material_stack[material_stack_head-1]=material_stack[material_stack_head];
- }
- }
+ case OPSwap3Float:{
+ float floattemp=float_stack[float_stack_head-1];
+ float_stack[float_stack_head-1]=float_stack[float_stack_head-3];
}
break;
-
- case OPPromoteFloatFloatVec2:
- push_vec2(vec2(pull_float(),pull_float()));
- break;
- case OPPromoteFloatFloatFloatVec3:
- push_vec3(vec3(pull_float(),pull_float(),pull_float()));
- break;
- case OPPromoteVec2FloatVec3:
- push_vec3(vec3(pull_vec2(),pull_float()));
- break;
- case OPPromoteFloatFloatFloatFloatVec4:
- push_vec4(vec4(pull_float(),pull_float(),pull_float(),pull_float()));
- break;
- case OPPromoteVec2FloatFloatVec4:
- push_vec4(vec4(pull_vec2(),pull_float(),pull_float()));
- break;
- case OPPromoteVec3FloatVec4:
- push_vec4(vec4(pull_vec3(),pull_float()));
- break;
- case OPPromoteVec2Vec2Vec4:
- push_vec4(vec4(pull_vec2(),pull_vec2()));
- break;
- case OPPromote2Vec2Mat2:
- push_mat2(mat2(pull_vec2(),pull_vec2()));
- break;
- case OPPromote4FloatMat2:
- push_mat2(mat2(pull_float(),pull_float(),pull_float(),pull_float()));
- break;
- case OPPromoteVec4Mat2:
- push_mat2(mat2(pull_vec4()));
- break;
- case OPPromote3Vec3Mat3:
- push_mat3(mat3(pull_vec3(),pull_vec3(),pull_vec3()));
- break;
- case OPPromote4Vec4Mat4:
- push_mat4(mat4(pull_vec4(),pull_vec4(),pull_vec4(),pull_vec4()));
- break;
- case OPPromoteMat2Mat3:
- push_mat3(mat3(pull_mat2()));
- break;
- case OPPromoteMat2Mat4:
- push_mat4(mat4(pull_mat2()));
- break;
- case OPPromoteMat3Mat4:
- push_mat4(mat4(pull_mat3()));
- break;
-
- case OPDemoteMat2Float:
- mat2temp=pull_mat2();
- push_float(mat2temp[1].y);
- push_float(mat2temp[1].x);
- push_float(mat2temp[0].y);
- push_float(mat2temp[0].x);
- break;
- case OPDemoteMat2Vec2:
- mat2temp=pull_mat2();
- push_vec2(mat2temp[1]);
- push_vec2(mat2temp[0]);
- break;
- case OPDemoteMat3Vec3:
- mat3temp=pull_mat3();
- push_vec3(mat3temp[2]);
- push_vec3(mat3temp[1]);
- push_vec3(mat3temp[0]);
- break;
- case OPDemoteMat4Vec4:
- mat4temp=pull_mat4();
- push_vec4(mat4temp[3]);
- push_vec4(mat4temp[2]);
- push_vec4(mat4temp[1]);
- push_vec4(mat4temp[0]);
- break;
- case OPDemoteMat2Vec4:
- mat2temp=pull_mat2();
- push_vec4(vec4(mat2temp[0],mat2temp[1]));
- break;
- case OPDemoteVec2FloatFloat:
- vec2temp=pull_vec2();
- push_float(vec2temp.y);
- push_float(vec2temp.x);
- break;
- case OPDemoteVec3FloatFloatFloat:
- vec3temp=pull_vec3();
- push_float(vec3temp.z);
- push_float(vec3temp.y);
- push_float(vec3temp.x);
- break;
- case OPDemoteVec4FloatFloatFloatFloat:
- vec4temp=pull_vec4();
- push_float(vec4temp.w);
- push_float(vec4temp.z);
- push_float(vec4temp.y);
- push_float(vec4temp.x);
- break;
-
- case OPMinVec2:
- push_vec2(min(pull_vec2(),pull_vec2()));
- break;
- case OPMaxVec2:
- push_vec2(max(pull_vec2(),pull_vec2()));
- break;
- case OPMinVec3:
- push_vec3(min(pull_vec3(),pull_vec3()));
- break;
- case OPMaxVec3:
- push_vec3(max(pull_vec3(),pull_vec3()));
- break;
- case OPMinVec4:
- push_vec4(min(pull_vec4(),pull_vec4()));
- break;
- case OPMaxVec4:
- push_vec4(max(pull_vec4(),pull_vec4()));
+ case OPSwap4Float:{
+ float floattemp=float_stack[float_stack_head-1];
+ float_stack[float_stack_head-1]=float_stack[float_stack_head-4];
+ }
+ */
break;
-
- case OPFMAFloat:
- push_float(fma(pull_float(),pull_float(),pull_float()));
+ case OPDupFloat:{
+ inputmask1(float_const_head);
+ push_float(float_stack[float_stack_head-1]);
+ }
break;
- case OPFMAVec2:
- push_vec2(fma(pull_vec2(),pull_vec2(),pull_vec2()));
+ case OPDup2Float:{
+ inputmask1(float_const_head);
+ push_float(float_stack[float_stack_head-2]);
+ }
break;
- case OPFMAVec3:
- push_vec3(fma(pull_vec3(),pull_vec3(),pull_vec3()));
+ case OPDup3Float:{
+ inputmask1(float_const_head);
+ push_float(float_stack[float_stack_head-3]);
+ }
break;
- case OPFMAVec4:
- push_vec4(fma(pull_vec4(),pull_vec4(),pull_vec4()));
+ case OPDup4Float:{
+ inputmask1(float_const_head);
+ push_float(float_stack[float_stack_head-4]);
+ }
break;
-
- case OPOuterProductMat2:
- push_mat2(outerProduct(pull_vec2(),pull_vec2()));
+ /*
+ case OPDropFloat:{
+ float_stack_head--;
+ }
break;
- case OPOuterProductMat3:
- push_mat3(outerProduct(pull_vec3(),pull_vec3()));
+ case OPDrop2Float:{
+ float_stack[float_stack_head-2]=float_stack[float_stack_head-1];
+ float_stack_head--;
+ }
break;
- case OPOuterProductMat4:
- push_mat4(outerProduct(pull_vec4(),pull_vec4()));
+ case OPDrop3Float:{
+ float_stack[float_stack_head-3]=float_stack[float_stack_head-2];
+ float_stack[float_stack_head-2]=float_stack[float_stack_head-1];
+ float_stack_head--;
+ }
break;
-
- case OPCompMultMat2:
- push_mat2(matrixCompMult(pull_mat2(),pull_mat2()));
+ case OPDrop4Float:{
+ float_stack[float_stack_head-4]=float_stack[float_stack_head-3];
+ float_stack[float_stack_head-3]=float_stack[float_stack_head-2];
+ float_stack[float_stack_head-2]=float_stack[float_stack_head-1];
+ float_stack_head--;
+ }
break;
- case OPCompMultMat3:
- push_mat3(matrixCompMult(pull_mat3(),pull_mat3()));
+ */
+ /*
+ case OPSwap2Vec2:{
+ vec2 vec2temp=vec2_stack[vec2_stack_head-1];
+ vec2_stack[vec2_stack_head-1]=vec2_stack[vec2_stack_head-2];
+ }
break;
- case OPCompMultMat4:
- push_mat4(matrixCompMult(pull_mat4(),pull_mat4()));
+ case OPSwap3Vec2:{
+ vec2 vec2temp=vec2_stack[vec2_stack_head-1];
+ vec2_stack[vec2_stack_head-1]=vec2_stack[vec2_stack_head-3];
+ }
break;
-
- case OPClampFloatFloat:
- push_float(clamp(pull_float(),pull_float(),pull_float()));
+ case OPSwap4Vec2:{
+ vec2 vec2temp=vec2_stack[vec2_stack_head-1];
+ vec2_stack[vec2_stack_head-1]=vec2_stack[vec2_stack_head-4];
+ }
break;
- case OPClampVec2Vec2:
- push_vec2(clamp(pull_vec2(),pull_vec2(),pull_vec2()));
+ */
+ case OPDupVec2:{
+ inputmask1(vec2_const_head);
+ push_vec2(vec2_stack[vec2_stack_head-1]);
+ }
break;
- case OPClampVec3Vec3:
- push_vec3(clamp(pull_vec3(),pull_vec3(),pull_vec3()));
+ case OPDup2Vec2:{
+ inputmask1(vec2_const_head);
+ push_vec2(vec2_stack[vec2_stack_head-2]);
+ }
break;
- case OPClampVec4Vec4:
- push_vec4(clamp(pull_vec4(),pull_vec4(),pull_vec4()));
+ case OPDup3Vec2:{
+ inputmask1(vec2_const_head);
+ push_vec2(vec2_stack[vec2_stack_head-3]);
+ }
break;
- case OPClampVec2Float:
- push_vec2(clamp(pull_vec2(),pull_float(),pull_float()));
+ case OPDup4Vec2:{
+ inputmask1(vec2_const_head);
+ push_vec2(vec2_stack[vec2_stack_head-4]);
+ }
break;
- case OPClampVec3Float:
- push_vec3(clamp(pull_vec3(),pull_float(),pull_float()));
+ /*
+ case OPDropVec2:{
+ vec2_stack_head--;
+ }
break;
- case OPClampVec4Float:
- push_vec4(clamp(pull_vec4(),pull_float(),pull_float()));
+ case OPDrop2Vec2:{
+ vec2_stack[vec2_stack_head-2]=vec2_stack[vec2_stack_head-1];
+ vec2_stack_head--;
+ }
break;
-
- case OPMixFloatFloat:
- push_float(mix(pull_float(),pull_float(),pull_float()));
+ case OPDrop3Vec2:{
+ vec2_stack[vec2_stack_head-3]=vec2_stack[vec2_stack_head-2];
+ vec2_stack[vec2_stack_head-2]=vec2_stack[vec2_stack_head-1];
+ vec2_stack_head--;
+ }
break;
- case OPMixVec2Vec2:
- push_vec2(mix(pull_vec2(),pull_vec2(),pull_vec2()));
+ case OPDrop4Vec2:{
+ vec2_stack[vec2_stack_head-4]=vec2_stack[vec2_stack_head-3];
+ vec2_stack[vec2_stack_head-3]=vec2_stack[vec2_stack_head-2];
+ vec2_stack[vec2_stack_head-2]=vec2_stack[vec2_stack_head-1];
+ vec2_stack_head--;
+ }
break;
- case OPMixVec3Vec3:
- push_vec3(mix(pull_vec3(),pull_vec3(),pull_vec3()));
+ */
+ /*
+ case OPSwap2Vec3:{
+ vec3 vec3temp=vec3_stack[vec3_stack_head-1];
+ vec3_stack[vec3_stack_head-1]=vec3_stack[vec3_stack_head-2];
+ }
break;
- case OPMixVec4Vec4:
- push_vec4(mix(pull_vec4(),pull_vec4(),pull_vec4()));
+ case OPSwap3Vec3:{
+ vec3 vec3temp=vec3_stack[vec3_stack_head-1];
+ vec3_stack[vec3_stack_head-1]=vec3_stack[vec3_stack_head-3];
+ }
break;
- case OPMixVec2Float:
- push_vec2(mix(pull_vec2(),pull_vec2(),pull_float()));
+ case OPSwap4Vec3:{
+ vec3 vec3temp=vec3_stack[vec3_stack_head-1];
+ vec3_stack[vec3_stack_head-1]=vec3_stack[vec3_stack_head-4];
+ }
break;
- case OPMixVec3Float:
- push_vec3(mix(pull_vec3(),pull_vec3(),pull_float()));
+ */
+ case OPDupVec3:{
+ inputmask1(vec3_const_head);
+ push_vec3(vec3_stack[vec3_stack_head-1]);
+ }
break;
- case OPMixVec4Float:
- push_vec4(mix(pull_vec4(),pull_vec4(),pull_float()));
+ case OPDup2Vec3:{
+ inputmask1(vec3_const_head);
+ push_vec3(vec3_stack[vec3_stack_head-2]);
+ }
break;
-
- case OPSquareFloat:
- floattemp=pull_float();
- push_float(floattemp*floattemp);
+ case OPDup3Vec3:{
+ inputmask1(vec3_const_head);
+ push_vec3(vec3_stack[vec3_stack_head-3]);
+ }
break;
- case OPCubeFloat:
- floattemp=pull_float();
- push_float(floattemp*floattemp*floattemp);
+ case OPDup4Vec3:{
+ inputmask1(vec3_const_head);
+ push_vec3(vec3_stack[vec3_stack_head-4]);
+ }
break;
- case OPSquareVec2:
- vec2temp=pull_vec2();
- push_vec2(vec2temp*vec2temp);
+ /*
+ case OPDropVec3:{
+ vec3_stack_head--;
+ }
break;
- case OPCubeVec2:
- vec2temp=pull_vec2();
- push_vec2(vec2temp*vec2temp*vec2temp);
+ case OPDrop2Vec3:{
+ vec3_stack[vec3_stack_head-2]=vec3_stack[vec3_stack_head-1];
+ vec3_stack_head--;
+ }
break;
- case OPSquareVec3:
- vec3temp=pull_vec3();
- push_vec3(vec3temp*vec3temp);
+ case OPDrop3Vec3:{
+ vec3_stack[vec3_stack_head-3]=vec3_stack[vec3_stack_head-2];
+ vec3_stack[vec3_stack_head-2]=vec3_stack[vec3_stack_head-1];
+ vec3_stack_head--;
+ }
break;
- case OPCubeVec3:
- vec3temp=pull_vec3();
- push_vec3(vec3temp*vec3temp*vec3temp);
+ case OPDrop4Vec3:{
+ vec3_stack[vec3_stack_head-4]=vec3_stack[vec3_stack_head-3];
+ vec3_stack[vec3_stack_head-3]=vec3_stack[vec3_stack_head-2];
+ vec3_stack[vec3_stack_head-2]=vec3_stack[vec3_stack_head-1];
+ vec3_stack_head--;
+ }
break;
- case OPSquareVec4:
- vec4temp=pull_vec4();
- push_vec4(vec4temp*vec4temp);
+ */
+ /*
+ case OPSwap2Vec4:{
+ vec4 vec4temp=vec4_stack[vec4_stack_head-1];
+ vec4_stack[vec4_stack_head-1]=vec4_stack[vec4_stack_head-2];
+ }
break;
- case OPCubeVec4:
- vec4temp=pull_vec4();
- push_vec4(vec4temp*vec4temp*vec4temp);
+ case OPSwap3Vec4:{
+ vec4 vec4temp=vec4_stack[vec4_stack_head-1];
+ vec4_stack[vec4_stack_head-1]=vec4_stack[vec4_stack_head-3];
+ }
break;
- case OPSquareMat2:
- mat2temp=pull_mat2();
- push_mat2(mat2temp*mat2temp);
+ case OPSwap4Vec4:{
+ vec4 vec4temp=vec4_stack[vec4_stack_head-1];
+ vec4_stack[vec4_stack_head-1]=vec4_stack[vec4_stack_head-4];
+ }
break;
- case OPCubeMat2:
- mat2temp=pull_mat2();
- push_mat2(mat2temp*mat2temp*mat2temp);
+ */
+ case OPDupVec4:{
+ inputmask1(vec4_const_head);
+ push_vec4(vec4_stack[vec4_stack_head-1]);
+ }
break;
- case OPSquareMat3:
- mat3temp=pull_mat3();
- push_mat3(mat3temp*mat3temp);
+ case OPDup2Vec4:{
+ inputmask1(vec4_const_head);
+ push_vec4(vec4_stack[vec4_stack_head-2]);
+ }
break;
- case OPCubeMat3:
- mat3temp=pull_mat3();
- push_mat3(mat3temp*mat3temp*mat3temp);
+ case OPDup3Vec4:{
+ inputmask1(vec4_const_head);
+ push_vec4(vec4_stack[vec4_stack_head-3]);
+ }
break;
- case OPSquareMat4:
- mat4temp=pull_mat4();
- push_mat4(mat4temp*mat4temp);
+ case OPDup4Vec4:{
+ inputmask1(vec4_const_head);
+ push_vec4(vec4_stack[vec4_stack_head-4]);
+ }
break;
- case OPCubeMat4:
- mat4temp=pull_mat4();
- push_mat4(mat4temp*mat4temp*mat4temp);
+ /*
+ case OPDropVec4:{
+ vec4_stack_head--;
+ }
break;
-
- case OPMulMat2Vec2:
- push_vec2(pull_mat2()*pull_vec2());
+ case OPDrop2Vec4:{
+ vec4_stack[vec4_stack_head-2]=vec4_stack[vec4_stack_head-1];
+ vec4_stack_head--;
+ }
break;
- case OPMulMat3Vec3:
- push_vec3(pull_mat3()*pull_vec3());
+ case OPDrop3Vec4:{
+ vec4_stack[vec4_stack_head-3]=vec4_stack[vec4_stack_head-2];
+ vec4_stack[vec4_stack_head-2]=vec4_stack[vec4_stack_head-1];
+ vec4_stack_head--;
+ }
break;
- case OPMulMat4Vec4:
- push_vec4(pull_mat4()*pull_vec4());
+ case OPDrop4Vec4:{
+ vec4_stack[vec4_stack_head-4]=vec4_stack[vec4_stack_head-3];
+ vec4_stack[vec4_stack_head-3]=vec4_stack[vec4_stack_head-2];
+ vec4_stack[vec4_stack_head-2]=vec4_stack[vec4_stack_head-1];
+ vec4_stack_head--;
+ }
break;
+ */
+
case OPSDFSphere:
{
- float r=pull_float();
- vec3 p=pull_vec3();
-
- push_float(length(p)-r);
- if(material){
- push_material(pull_mat4());
+ inputmask2(float_const_head,vec3_const_head);
+ float in2=pull_float(ifconst(0));
+ /*#ifdef debug
+ if (in2[0] == in2[1] && in2[0] == 0.2)
+ {return vec3(in2[0],in2[1],0.);
+ }else{
+ return vec3(in2[0],in2[1],1.);
}
- //return p;
- //return vec3(0.,1.,1.);
+ #endif*/
+ vec3 in1=pull_vec3(ifconst(1));
+ /*#ifdef debug
+ return in1[0];
+ #endif*/
+
+ push_float(length(in1)-in2);
+ }
+ break;
+
+ case OPSDFTorus:
+ {
+ inputmask2(vec2_const_head,vec3_const_head);
+ vec2 t=pull_vec2(ifconst(0)); //t
+ vec3 p=pull_vec3(ifconst(1)); //p
+
+ vec2 q = vec2(length(p.xz)-t.x,p.y);
+ push_float(length(q)-t.y);
+ }
+ break;
+
+ //this doesn't work internally but it's probably fiiiine
+ case OPSDFBox:
+ {
+ inputmask2(vec3_const_head,vec3_const_head);
+ vec3 b=pull_vec3(ifconst(0)); //r
+ vec3 p=pull_vec3(ifconst(1)); //p
+
+ vec3 q = abs(p) - b;
+
+ push_float(length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0));
}
break;
case OPNop:
break;
case OPStop:
- return pull_float();
+ #ifdef debug
+ return vec3(pull_float(ifconst(0)));
+ #else
+ return pull_float(ifconst(0));
+ #endif
case OPInvalid:
default:
- return float(minor_float_cache[minor_position]);
+ #ifdef debug
+ return vec3(float(minor_integer_cache[minor_position]));
+ #else
+ return float (-1);
+ #endif
}
- }else{
- //return vec3(float(minor_float_cache[minor_position]));
- push_float(float(minor_float_cache[minor_position]));
- }
- }
+
minor_position++;
if(minor_position==8)
{
minor_position=0;
major_position++;
- if(major_position==13)
+ if(major_position==masklen)
{
- return pull_float();
+ #ifdef debug
+ return vec3(pull_float(false));
+ #else
+ return pull_float(false);
+ #endif
}
}
}
diff --git a/src/intervals.glsl b/src/intervals.glsl
index 8b7ef5a452ad3759e473c52f886416c74f09f08b..07abdcbb5091921802b1297971edf98b31930b7a 100644
--- a/src/intervals.glsl
+++ b/src/intervals.glsl
@@ -3197,17 +3197,4 @@ float[2]scene(vec3 p[2], bool prune)
}
}
}
-
-#ifdef debug
-vec3 sceneoverride(vec3 p, bool m)
-{
- return scene(vec3[2](p,p), false);
-}
-#else
-float sceneoverride(vec3 p, bool m)
-{
- return scene(vec3[2](p,p), false)[0];
-}
-#endif
-
#endif//ifndef intervals
\ No newline at end of file
diff --git a/src/main.rs b/src/main.rs
index 3b8bdc9166953040a49466bbc1aa3f40c8ef500b..1d54f80aaaac01e0a8e54cf2e616413584fb3766 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1295,6 +1295,7 @@ fn object_size_dependent_setup(
//CSGPart::opcode(InstructionSet::OPAddVec3Vec3, vec![Inputs::Variable, Inputs::Vec3([-0.0, -0.0, -0.0].into())]),
//CSGPart::opcode(InstructionSet::OPSDFSphere,vec![Inputs::Float(1.2), Inputs::Variable]),
CSGPart::opcode(InstructionSet::OPSDFTorus, vec![Inputs::Vec2([0.7, 0.4].into()), Inputs::Variable]),
+ //CSGPart::opcode(InstructionSet::OPSDFBox, vec![Inputs::Vec3([0.7, 0.4, 0.7].into()), Inputs::Variable]),
CSGPart::opcode(InstructionSet::OPMinFloat, vec![Inputs::Variable,Inputs::Variable]),
CSGPart::opcode(InstructionSet::OPDivFloatFloat, vec![Inputs::Variable, Inputs::Float(0.9)]),
CSGPart::opcode(InstructionSet::OPStop, vec![Inputs::Variable]),
diff --git a/src/triangle.vert.glsl b/src/triangle.vert.glsl
index 7141fb41310e8228270fdb1635a8e1fb40a8acfc..d50bd83de2456f4a3514db6a2622dd8941551d6e 100644
--- a/src/triangle.vert.glsl
+++ b/src/triangle.vert.glsl
@@ -5,9 +5,11 @@ layout(location=0)in vec3 position;
layout(location=1)in vec3 normal;
layout(location=0)out vec3 v_normal;
+layout(location=1)out vec4 pos;
void main(){
mat4 worldview=camera_uniforms.view*pc.world;
v_normal=normal;//normalize(transpose(inverse(mat3(worldview))) * normal);
- gl_Position=camera_uniforms.proj*worldview*vec4(position,1.);
+ pos = worldview*vec4(position,1.);
+ gl_Position=camera_uniforms.proj*pos;
}
\ No newline at end of file