diff --git a/.vscode/third_year_project.code-workspace b/.vscode/third_year_project.code-workspace
new file mode 100644
index 0000000000000000000000000000000000000000..bab1b7f616b360395e747dbbcd59ebadc307ad61
--- /dev/null
+++ b/.vscode/third_year_project.code-workspace
@@ -0,0 +1,8 @@
+{
+ "folders": [
+ {
+ "path": ".."
+ }
+ ],
+ "settings": {}
+}
\ No newline at end of file
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a1bbbf1dcaae06d2ca8c4874a83c95e9a49f5fa5
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,32 @@
+use std::env;
+use std::fs;
+use std::fs::File;
+use std::io;
+use std::io::BufRead;
+use std::io::BufReader;
+use std::path::Path;
+
+fn main() -> io::Result<()> {
+ println!("cargo:rerun-if-changed=src/instructionset.glsl");
+ let out_dir = env::var_os("OUT_DIR").unwrap();
+ let dest_path = Path::new(&out_dir).join("instructionset.rs");
+ let f = File::open("src/instructionset.glsl")?;
+ let f = BufReader::new(f);
+ let mut out = "
+ #[repr(u16)]
+ pub enum InstructionSet{
+
+ "
+ .to_owned();
+
+ for l in f.lines() {
+ let line = l?;
+ out += &line[11..line.len() - 12];
+ out += ",\n";
+ }
+ out += "}";
+
+ fs::write(&dest_path, out).unwrap();
+ println!("cargo:rerun-if-changed=build.rs");
+ Ok(())
+}
diff --git a/src/frag.glsl b/src/frag.glsl
index fca2b23396e7d9cfdf7cc38a149c3e57529f91a7..c16e5da43fe17ca20d18a7bcdc5f6ef66065e2d9 100644
--- a/src/frag.glsl
+++ b/src/frag.glsl
@@ -47,17 +47,17 @@ vec3 shading(vec3 normal)
vec3 getNormal(vec3 p,float dens){
vec3 n;
- n.x=scene(vec3(p.x+EPSILON,p.y,p.z));
- n.y=scene(vec3(p.x,p.y+EPSILON,p.z));
- n.z=scene(vec3(p.x,p.y,p.z+EPSILON));
- return normalize(n-scene(p));
+ 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;
for(int i=0;i<MAX_STEPS&&td.y>EPSILON&&td.x<FARPLANE;i++){
- td.y=scene(p);
+ td.y=scene(p,false).x;
td.x+=(td.y)*.9;
p=ori+dir*td.x;
}
@@ -66,7 +66,7 @@ vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){
//Implicit Surface Entrypoint
void main(){
-
+ default_mask();
vec3 raypos=vertexInput.position.xyz;
vec2 iResolution=vec2(RES_X,RES_Y);
vec2 iuv=(gl_FragCoord.xy+gl_SamplePosition)/iResolution.xy*2.-1.;
@@ -74,10 +74,16 @@ void main(){
uv.x*=iResolution.x/iResolution.y;
vec3 p;
vec3 raydir=normalize(raypos-camera_uniforms.campos);
+ raypos-=vec3(5);
+ //scene(raypos,false);
+ //f_color=vec4(scene(raypos,false),1.);
+ ///return;
+
vec2 td=spheretracing(raypos,raydir,p);
vec3 n=getNormal(p,td.y);
if(td.y<EPSILON)
{
+ f_color=vec4(1.);
f_color=vec4(shading(n),1.);
vec4 tpoint=camera_uniforms.proj*camera_uniforms.view*vec4(p,1);
diff --git a/src/instructionset.glsl b/src/instructionset.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..5b6851cc19e1bde57fb27b18235b967a390b44eb
--- /dev/null
+++ b/src/instructionset.glsl
@@ -0,0 +1,341 @@
+const uint OPInvalid=__LINE__-1;
+const uint OPNop=__LINE__-1;
+const uint OPStop=__LINE__-1;
+const uint OPAddFloatFloat=__LINE__-1;
+const uint OPAddVec2Vec2=__LINE__-1;
+const uint OPAddVec2Float=__LINE__-1;
+const uint OPAddVec3Vec3=__LINE__-1;
+const uint OPAddVec3Float=__LINE__-1;
+const uint OPAddVec4Vec4=__LINE__-1;
+const uint OPAddVec4Float=__LINE__-1;
+const uint OPAddMat2Mat2=__LINE__-1;
+const uint OPAddMat2Float=__LINE__-1;
+const uint OPAddMat3Mat3=__LINE__-1;
+const uint OPAddMat3Float=__LINE__-1;
+const uint OPAddMat4Mat4=__LINE__-1;
+const uint OPAddMat4Float=__LINE__-1;
+const uint OPSubFloatFloat=__LINE__-1;
+const uint OPSubVec2Vec2=__LINE__-1;
+const uint OPSubVec2Float=__LINE__-1;
+const uint OPSubVec3Vec3=__LINE__-1;
+const uint OPSubVec3Float=__LINE__-1;
+const uint OPSubVec4Vec4=__LINE__-1;
+const uint OPSubVec4Float=__LINE__-1;
+const uint OPSubMat2Mat2=__LINE__-1;
+const uint OPSubMat2Float=__LINE__-1;
+const uint OPSubMat3Mat3=__LINE__-1;
+const uint OPSubMat3Float=__LINE__-1;
+const uint OPSubMat4Mat4=__LINE__-1;
+const uint OPSubMat4Float=__LINE__-1;
+const uint OPMulFloatFloat=__LINE__-1;
+const uint OPMulVec2Vec2=__LINE__-1;
+const uint OPMulVec2Float=__LINE__-1;
+const uint OPMulVec3Vec3=__LINE__-1;
+const uint OPMulVec3Float=__LINE__-1;
+const uint OPMulVec4Vec4=__LINE__-1;
+const uint OPMulVec4Float=__LINE__-1;
+const uint OPMulMat2Mat2=__LINE__-1;
+const uint OPMulMat2Float=__LINE__-1;
+const uint OPMulMat3Mat3=__LINE__-1;
+const uint OPMulMat3Float=__LINE__-1;
+const uint OPMulMat4Mat4=__LINE__-1;
+const uint OPMulMat4Float=__LINE__-1;
+const uint OPDivFloatFloat=__LINE__-1;
+const uint OPDivVec2Vec2=__LINE__-1;
+const uint OPDivVec2Float=__LINE__-1;
+const uint OPDivVec3Vec3=__LINE__-1;
+const uint OPDivVec3Float=__LINE__-1;
+const uint OPDivVec4Vec4=__LINE__-1;
+const uint OPDivVec4Float=__LINE__-1;
+const uint OPDivMat2Mat2=__LINE__-1;
+const uint OPDivMat2Float=__LINE__-1;
+const uint OPDivMat3Mat3=__LINE__-1;
+const uint OPDivMat3Float=__LINE__-1;
+const uint OPDivMat4Mat4=__LINE__-1;
+const uint OPDivMat4Float=__LINE__-1;
+const uint OPModFloatFloat=__LINE__-1;
+const uint OPModVec2Vec2=__LINE__-1;
+const uint OPModVec2Float=__LINE__-1;
+const uint OPModVec3Vec3=__LINE__-1;
+const uint OPModVec3Float=__LINE__-1;
+const uint OPModVec4Vec4=__LINE__-1;
+const uint OPModVec4Float=__LINE__-1;
+const uint OPPowFloatFloat=__LINE__-1;
+const uint OPPowVec2Vec2=__LINE__-1;
+const uint OPPowVec3Vec3=__LINE__-1;
+const uint OPPowVec4Vec4=__LINE__-1;
+const uint OPCrossVec3=__LINE__-1;
+const uint OPDotVec2=__LINE__-1;
+const uint OPDotVec3=__LINE__-1;
+const uint OPDotVec4=__LINE__-1;
+const uint OPLengthVec2=__LINE__-1;
+const uint OPLengthVec3=__LINE__-1;
+const uint OPLengthVec4=__LINE__-1;
+const uint OPDistanceVec2=__LINE__-1;
+const uint OPDistanceVec3=__LINE__-1;
+const uint OPDistanceVec4=__LINE__-1;
+const uint OPNormalizeVec2=__LINE__-1;
+const uint OPNormalizeVec3=__LINE__-1;
+const uint OPNormalizeVec4=__LINE__-1;
+const uint OPTransposeMat2=__LINE__-1;
+const uint OPTransposeMat3=__LINE__-1;
+const uint OPTransposeMat4=__LINE__-1;
+const uint OPDeterminantMat2=__LINE__-1;
+const uint OPDeterminantMat3=__LINE__-1;
+const uint OPDeterminantMat4=__LINE__-1;
+const uint OPInvertMat2=__LINE__-1;
+const uint OPInvertMat3=__LINE__-1;
+const uint OPInvertMat4=__LINE__-1;
+const uint OPAbsFloat=__LINE__-1;
+const uint OPSignFloat=__LINE__-1;
+const uint OPFloorFloat=__LINE__-1;
+const uint OPCeilFloat=__LINE__-1;
+const uint OPFractFloat=__LINE__-1;
+const uint OPSqrtFloat=__LINE__-1;
+const uint OPInverseSqrtFloat=__LINE__-1;
+const uint OPExpFloat=__LINE__-1;
+const uint OPExp2Float=__LINE__-1;
+const uint OPLogFloat=__LINE__-1;
+const uint OPLog2Float=__LINE__-1;
+const uint OPSinFloat=__LINE__-1;
+const uint OPCosFloat=__LINE__-1;
+const uint OPTanFloat=__LINE__-1;
+const uint OPAsinFloat=__LINE__-1;
+const uint OPAcosFloat=__LINE__-1;
+const uint OPAtanFloat=__LINE__-1;
+const uint OPMinFloat=__LINE__-1;
+const uint OPMaxFloat=__LINE__-1;
+const uint OPSmoothMinFloat=__LINE__-1;
+const uint OPSmoothMaxFloat=__LINE__-1;
+const uint OPMinMaterialFloat=__LINE__-1;
+const uint OPMaxMaterialFloat=__LINE__-1;
+const uint OPSmoothMinMaterialFloat=__LINE__-1;
+const uint OPSmoothMaxMaterialFloat=__LINE__-1;
+const uint OPSwap2Float=__LINE__-1;
+const uint OPSwap3Float=__LINE__-1;
+const uint OPSwap4Float=__LINE__-1;
+const uint OPDupFloat=__LINE__-1;
+const uint OPDup2Float=__LINE__-1;
+const uint OPDup3Float=__LINE__-1;
+const uint OPDup4Float=__LINE__-1;
+const uint OPDropFloat=__LINE__-1;
+const uint OPDrop2Float=__LINE__-1;
+const uint OPDrop3Float=__LINE__-1;
+const uint OPDrop4Float=__LINE__-1;
+const uint OPAbsVec2=__LINE__-1;
+const uint OPSignVec2=__LINE__-1;
+const uint OPFloorVec2=__LINE__-1;
+const uint OPCeilVec2=__LINE__-1;
+const uint OPFractVec2=__LINE__-1;
+const uint OPSqrtVec2=__LINE__-1;
+const uint OPInverseSqrtVec2=__LINE__-1;
+const uint OPExpVec2=__LINE__-1;
+const uint OPExp2Vec2=__LINE__-1;
+const uint OPLogVec2=__LINE__-1;
+const uint OPLog2Vec2=__LINE__-1;
+const uint OPSinVec2=__LINE__-1;
+const uint OPCosVec2=__LINE__-1;
+const uint OPTanVec2=__LINE__-1;
+const uint OPAsinVec2=__LINE__-1;
+const uint OPAcosVec2=__LINE__-1;
+const uint OPAtanVec2=__LINE__-1;
+const uint OPMinVec2=__LINE__-1;
+const uint OPMaxVec2=__LINE__-1;
+const uint OPSwap2Vec2=__LINE__-1;
+const uint OPSwap3Vec2=__LINE__-1;
+const uint OPSwap4Vec2=__LINE__-1;
+const uint OPDupVec2=__LINE__-1;
+const uint OPDup2Vec2=__LINE__-1;
+const uint OPDup3Vec2=__LINE__-1;
+const uint OPDup4Vec2=__LINE__-1;
+const uint OPDropVec2=__LINE__-1;
+const uint OPDrop2Vec2=__LINE__-1;
+const uint OPDrop3Vec2=__LINE__-1;
+const uint OPDrop4Vec2=__LINE__-1;
+const uint OPAbsVec3=__LINE__-1;
+const uint OPSignVec3=__LINE__-1;
+const uint OPFloorVec3=__LINE__-1;
+const uint OPCeilVec3=__LINE__-1;
+const uint OPFractVec3=__LINE__-1;
+const uint OPSqrtVec3=__LINE__-1;
+const uint OPInverseSqrtVec3=__LINE__-1;
+const uint OPExpVec3=__LINE__-1;
+const uint OPExp2Vec3=__LINE__-1;
+const uint OPLogVec3=__LINE__-1;
+const uint OPLog2Vec3=__LINE__-1;
+const uint OPSinVec3=__LINE__-1;
+const uint OPCosVec3=__LINE__-1;
+const uint OPTanVec3=__LINE__-1;
+const uint OPAsinVec3=__LINE__-1;
+const uint OPAcosVec3=__LINE__-1;
+const uint OPAtanVec3=__LINE__-1;
+const uint OPMinVec3=__LINE__-1;
+const uint OPMaxVec3=__LINE__-1;
+const uint OPSwap2Vec3=__LINE__-1;
+const uint OPSwap3Vec3=__LINE__-1;
+const uint OPSwap4Vec3=__LINE__-1;
+const uint OPDupVec3=__LINE__-1;
+const uint OPDup2Vec3=__LINE__-1;
+const uint OPDup3Vec3=__LINE__-1;
+const uint OPDup4Vec3=__LINE__-1;
+const uint OPDropVec3=__LINE__-1;
+const uint OPDrop2Vec3=__LINE__-1;
+const uint OPDrop3Vec3=__LINE__-1;
+const uint OPDrop4Vec3=__LINE__-1;
+const uint OPAbsVec4=__LINE__-1;
+const uint OPSignVec4=__LINE__-1;
+const uint OPFloorVec4=__LINE__-1;
+const uint OPCeilVec4=__LINE__-1;
+const uint OPFractVec4=__LINE__-1;
+const uint OPSqrtVec4=__LINE__-1;
+const uint OPInverseSqrtVec4=__LINE__-1;
+const uint OPExpVec4=__LINE__-1;
+const uint OPExp2Vec4=__LINE__-1;
+const uint OPLogVec4=__LINE__-1;
+const uint OPLog2Vec4=__LINE__-1;
+const uint OPSinVec4=__LINE__-1;
+const uint OPCosVec4=__LINE__-1;
+const uint OPTanVec4=__LINE__-1;
+const uint OPAsinVec4=__LINE__-1;
+const uint OPAcosVec4=__LINE__-1;
+const uint OPAtanVec4=__LINE__-1;
+const uint OPMinVec4=__LINE__-1;
+const uint OPMaxVec4=__LINE__-1;
+const uint OPSwap2Vec4=__LINE__-1;
+const uint OPSwap3Vec4=__LINE__-1;
+const uint OPSwap4Vec4=__LINE__-1;
+const uint OPDupVec4=__LINE__-1;
+const uint OPDup2Vec4=__LINE__-1;
+const uint OPDup3Vec4=__LINE__-1;
+const uint OPDup4Vec4=__LINE__-1;
+const uint OPDropVec4=__LINE__-1;
+const uint OPDrop2Vec4=__LINE__-1;
+const uint OPDrop3Vec4=__LINE__-1;
+const uint OPDrop4Vec4=__LINE__-1;
+const uint OPSwap2Mat2=__LINE__-1;
+const uint OPSwap3Mat2=__LINE__-1;
+const uint OPSwap4Mat2=__LINE__-1;
+const uint OPDupMat2=__LINE__-1;
+const uint OPDup2Mat2=__LINE__-1;
+const uint OPDup3Mat2=__LINE__-1;
+const uint OPDup4Mat2=__LINE__-1;
+const uint OPDropMat2=__LINE__-1;
+const uint OPDrop2Mat2=__LINE__-1;
+const uint OPDrop3Mat2=__LINE__-1;
+const uint OPDrop4Mat2=__LINE__-1;
+const uint OPSwap2Mat3=__LINE__-1;
+const uint OPSwap3Mat3=__LINE__-1;
+const uint OPSwap4Mat3=__LINE__-1;
+const uint OPDupMat3=__LINE__-1;
+const uint OPDup2Mat3=__LINE__-1;
+const uint OPDup3Mat3=__LINE__-1;
+const uint OPDup4Mat3=__LINE__-1;
+const uint OPDropMat3=__LINE__-1;
+const uint OPDrop2Mat3=__LINE__-1;
+const uint OPDrop3Mat3=__LINE__-1;
+const uint OPDrop4Mat3=__LINE__-1;
+const uint OPSwap2Mat4=__LINE__-1;
+const uint OPSwap3Mat4=__LINE__-1;
+const uint OPSwap4Mat4=__LINE__-1;
+const uint OPDupMat4=__LINE__-1;
+const uint OPDup2Mat4=__LINE__-1;
+const uint OPDup3Mat4=__LINE__-1;
+const uint OPDup4Mat4=__LINE__-1;
+const uint OPDropMat4=__LINE__-1;
+const uint OPDrop2Mat4=__LINE__-1;
+const uint OPDrop3Mat4=__LINE__-1;
+const uint OPDrop4Mat4=__LINE__-1;
+const uint OPPromoteFloatFloatVec2=__LINE__-1;
+const uint OPPromoteFloatFloatFloatVec3=__LINE__-1;
+const uint OPPromoteFloatFloatFloatFloatVec4=__LINE__-1;
+const uint OPPromoteVec2FloatVec3=__LINE__-1;
+const uint OPPromoteVec2FloatFloatVec4=__LINE__-1;
+const uint OPPromoteVec2Vec2Vec4=__LINE__-1;
+const uint OPPromoteVec3FloatVec4=__LINE__-1;
+const uint OPPromote4FloatMat2=__LINE__-1;
+const uint OPPromote2Vec2Mat2=__LINE__-1;
+const uint OPPromoteVec4Mat2=__LINE__-1;
+const uint OPPromote3Vec3Mat3=__LINE__-1;
+const uint OPPromote4Vec4Mat4=__LINE__-1;
+const uint OPPromoteMat2Mat3=__LINE__-1;
+const uint OPPromoteMat2Mat4=__LINE__-1;
+const uint OPPromoteMat3Mat4=__LINE__-1;
+const uint OPDemoteVec2FloatFloat=__LINE__-1;
+const uint OPDemoteVec3FloatFloatFloat=__LINE__-1;
+const uint OPDemoteVec4FloatFloatFloatFloat=__LINE__-1;
+const uint OPDemoteMat2Float=__LINE__-1;
+const uint OPDemoteMat2Vec2=__LINE__-1;
+const uint OPDemoteMat2Vec4=__LINE__-1;
+const uint OPDemoteMat3Vec3=__LINE__-1;
+const uint OPDemoteMat4Vec4=__LINE__-1;
+const uint OPAcoshFloat=__LINE__-1;
+const uint OPAcoshVec2=__LINE__-1;
+const uint OPAcoshVec3=__LINE__-1;
+const uint OPAcoshVec4=__LINE__-1;
+const uint OPAsinhFloat=__LINE__-1;
+const uint OPAsinhVec2=__LINE__-1;
+const uint OPAsinhVec3=__LINE__-1;
+const uint OPAsinhVec4=__LINE__-1;
+const uint OPAtanhFloat=__LINE__-1;
+const uint OPAtanhVec2=__LINE__-1;
+const uint OPAtanhVec3=__LINE__-1;
+const uint OPAtanhVec4=__LINE__-1;
+const uint OPCoshFloat=__LINE__-1;
+const uint OPCoshVec2=__LINE__-1;
+const uint OPCoshVec3=__LINE__-1;
+const uint OPCoshVec4=__LINE__-1;
+const uint OPSinhFloat=__LINE__-1;
+const uint OPSinhVec2=__LINE__-1;
+const uint OPSinhVec3=__LINE__-1;
+const uint OPSinhVec4=__LINE__-1;
+const uint OPTanhFloat=__LINE__-1;
+const uint OPTanhVec2=__LINE__-1;
+const uint OPTanhVec3=__LINE__-1;
+const uint OPTanhVec4=__LINE__-1;
+const uint OPFMAFloat=__LINE__-1;
+const uint OPFMAVec2=__LINE__-1;
+const uint OPFMAVec3=__LINE__-1;
+const uint OPFMAVec4=__LINE__-1;
+const uint OPRoundFloat=__LINE__-1;
+const uint OPRoundVec2=__LINE__-1;
+const uint OPRoundVec3=__LINE__-1;
+const uint OPRoundVec4=__LINE__-1;
+const uint OPTruncFloat=__LINE__-1;
+const uint OPTruncVec2=__LINE__-1;
+const uint OPTruncVec3=__LINE__-1;
+const uint OPTruncVec4=__LINE__-1;
+const uint OPOuterProductMat2=__LINE__-1;
+const uint OPOuterProductMat3=__LINE__-1;
+const uint OPOuterProductMat4=__LINE__-1;
+const uint OPCompMultMat2=__LINE__-1;
+const uint OPCompMultMat3=__LINE__-1;
+const uint OPCompMultMat4=__LINE__-1;
+const uint OPClampFloatFloat=__LINE__-1;
+const uint OPClampVec2Vec2=__LINE__-1;
+const uint OPClampVec2Float=__LINE__-1;
+const uint OPClampVec3Vec3=__LINE__-1;
+const uint OPClampVec3Float=__LINE__-1;
+const uint OPClampVec4Vec4=__LINE__-1;
+const uint OPClampVec4Float=__LINE__-1;
+const uint OPMixFloatFloat=__LINE__-1;
+const uint OPMixVec2Vec2=__LINE__-1;
+const uint OPMixVec2Float=__LINE__-1;
+const uint OPMixVec3Vec3=__LINE__-1;
+const uint OPMixVec3Float=__LINE__-1;
+const uint OPMixVec4Vec4=__LINE__-1;
+const uint OPMixVec4Float=__LINE__-1;
+const uint OPSquareFloat=__LINE__-1;
+const uint OPCubeFloat=__LINE__-1;
+const uint OPSquareVec2=__LINE__-1;
+const uint OPCubeVec2=__LINE__-1;
+const uint OPSquareVec3=__LINE__-1;
+const uint OPCubeVec3=__LINE__-1;
+const uint OPSquareVec4=__LINE__-1;
+const uint OPCubeVec4=__LINE__-1;
+const uint OPSquareMat2=__LINE__-1;
+const uint OPCubeMat2=__LINE__-1;
+const uint OPSquareMat3=__LINE__-1;
+const uint OPCubeMat3=__LINE__-1;
+const uint OPSquareMat4=__LINE__-1;
+const uint OPCubeMat4=__LINE__-1;
+const uint OPSDFSphere=__LINE__-1;
\ No newline at end of file
diff --git a/src/interpreter.glsl b/src/interpreter.glsl
index 90941bf9b8c28ed50efc57574b3a3d12d531c4cb..df402210749b7be06e6247984ad79a56961ae43d 100644
--- a/src/interpreter.glsl
+++ b/src/interpreter.glsl
@@ -1,7 +1,9 @@
//#extension GL_EXT_shader_16bit_storage:require
#extension GL_EXT_shader_explicit_arithmetic_types:require
-layout(set=1,binding=0)uniform SceneDescription{
+#include "instructionset.glsl"
+
+layout(set=0,binding=2)uniform SceneDescription{
u32vec4 d[13];//stored packed for space efficiency, 8 per index
}scene_description;
@@ -32,96 +34,1400 @@ minor_integer_unpack=unpackUint2x16(major_unpack.w);\
minor_integer_cache[6]=minor_integer_unpack.x;\
minor_integer_cache[7]=minor_integer_unpack.y;
-uint major_position=0;
-uint minor_position=0;
-
-float16_t float_stack[8];
+float float_stack[8];
uint float_stack_head=0;
-f16vec2 vec2_stack[8];
+vec2 vec2_stack[8];
uint vec2_stack_head=0;
-f16vec3 vec3_stack[8];
+vec3 vec3_stack[8];
uint vec3_stack_head=0;
-f16vec4 vec4_stack[8];
+vec4 vec4_stack[8];
uint vec4_stack_head=0;
-f16mat2 mat2_stack[8];
+mat2 mat2_stack[8];
uint mat2_stack_head=0;
-f16mat3 mat3_stack[8];
+mat3 mat3_stack[8];
uint mat3_stack_head=0;
-f16mat4 mat4_stack[8];
+mat4 mat4_stack[8];
uint mat4_stack_head=0;
+mat4 material_stack[8];
+uint material_stack_head=0;
-void push_float(float16_t f){
+void push_float(float f){
float_stack[float_stack_head++]=f;
}
-float16_t pull_float(){
+float pull_float(){
return float_stack[--float_stack_head];
}
-void push_vec2(f16vec2 f){
+void push_vec2(vec2 f){
vec2_stack[vec2_stack_head++]=f;
}
-f16vec2 pull_vec2(){
+vec2 pull_vec2(){
return vec2_stack[--vec2_stack_head];
}
-void push_vec3(f16vec3 f){
+void push_vec3(vec3 f){
vec3_stack[vec3_stack_head++]=f;
}
-f16vec3 pull_vec3(){
+vec3 pull_vec3(){
return vec3_stack[--vec3_stack_head];
}
-void push_vec4(f16vec4 f){
+void push_vec4(vec4 f){
vec4_stack[vec4_stack_head++]=f;
}
-f16vec4 pull_vec4(){
+vec4 pull_vec4(){
return vec4_stack[--vec4_stack_head];
}
-void push_mat2(f16mat2 f){
+void push_mat2(mat2 f){
mat2_stack[mat2_stack_head++]=f;
}
-f16mat2 pull_mat2(){
+mat2 pull_mat2(){
return mat2_stack[--mat2_stack_head];
}
-void push_mat3(f16mat3 f){
+void push_mat3(mat3 f){
mat3_stack[mat3_stack_head++]=f;
}
-f16mat3 pull_mat3(){
+mat3 pull_mat3(){
return mat3_stack[--mat3_stack_head];
}
-void push_mat4(f16mat4 f){
+void push_mat4(mat4 f){
mat4_stack[mat4_stack_head++]=f;
}
-f16mat4 pull_mat4(){
+mat4 pull_mat4(){
return mat4_stack[--mat4_stack_head];
}
-float scene(vec3 p)
+void push_material(mat4 f){
+ material_stack[material_stack_head++]=f;
+}
+
+mat4 pull_material(){
+ return material_stack[--material_stack_head];
+}
+
+void clear_stacks()
+{
+ float_stack_head=0;
+ vec2_stack_head=0;
+ vec3_stack_head=0;
+ vec4_stack_head=0;
+ mat2_stack_head=0;
+ mat3_stack_head=0;
+ mat4_stack_head=0;
+ material_stack_head=0;
+}
+
+uint8_t mask[13];
+
+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));
+}
+
+vec3 scene(vec3 p,bool material)
{
- major_position=0;
- minor_position=0;
+ uint major_position=0;
+ uint minor_position=0;
float16_t minor_float_cache[8];
uint16_t minor_integer_cache[8];
- if(minor_position==0){
- get_caches;
- }
+ clear_stacks();
+ push_vec3(p);
- if(isnan(minor_float_cache[minor_position]))
- {
+ bool cont=true;
+
+ while(cont){
+ 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)
+ {
+ 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());
+ break;
+ case OPMulMat2Mat2:
+ push_mat2(pull_mat2()*pull_mat2());
+ break;
+ case OPMulMat2Float:
+ push_mat2(pull_mat2()*pull_float());
+ break;
+ case OPMulMat3Mat3:
+ push_mat3(pull_mat3()*pull_mat3());
+ break;
+ case OPMulMat3Float:
+ push_mat3(pull_mat3()*pull_float());
+ break;
+ case OPMulMat4Mat4:
+ push_mat4(pull_mat4()*pull_mat4());
+ break;
+ case OPMulMat4Float:
+ push_mat4(pull_mat4()*pull_float());
+ 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());
+ break;
+ case OPSubMat2Mat2:
+ push_mat2(pull_mat2()-pull_mat2());
+ break;
+ case OPSubMat2Float:
+ push_mat2(pull_mat2()-pull_float());
+ break;
+ case OPSubMat3Mat3:
+ push_mat3(pull_mat3()-pull_mat3());
+ break;
+ case OPSubMat3Float:
+ push_mat3(pull_mat3()-pull_float());
+ break;
+ case OPSubMat4Mat4:
+ push_mat4(pull_mat4()-pull_mat4());
+ break;
+ case OPSubMat4Float:
+ push_mat4(pull_mat4()-pull_float());
+ 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());
+ break;
+ case OPDivMat2Mat2:
+ push_mat2(pull_mat2()/pull_mat2());
+ break;
+ case OPDivMat2Float:
+ push_mat2(pull_mat2()/pull_float());
+ break;
+ case OPDivMat3Mat3:
+ push_mat3(pull_mat3()/pull_mat3());
+ break;
+ case OPDivMat3Float:
+ push_mat3(pull_mat3()/pull_float());
+ break;
+ case OPDivMat4Mat4:
+ push_mat4(pull_mat4()/pull_mat4());
+ break;
+ case OPDivMat4Float:
+ push_mat4(pull_mat4()/pull_float());
+ 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()));
+ break;
+ case OPModVec3Float:
+ push_vec3(mod(pull_vec3(),pull_float()));
+ break;
+ case OPModVec4Float:
+ push_vec4(mod(pull_vec4(),pull_float()));
+ break;
+
+ case OPPowFloatFloat:
+ push_float(pow(pull_float(),pull_float()));
+ break;
+ case OPPowVec2Vec2:
+ push_vec2(pow(pull_vec2(),pull_vec2()));
+ break;
+ case OPPowVec3Vec3:
+ push_vec3(pow(pull_vec3(),pull_vec3()));
+ break;
+ case OPPowVec4Vec4:
+ push_vec4(pow(pull_vec4(),pull_vec4()));
+ 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()));
+ break;
+ case OPDeterminantMat2:
+ push_float(determinant(pull_mat2()));
+ break;
+ case OPDeterminantMat3:
+ push_float(determinant(pull_mat3()));
+ break;
+ case OPDeterminantMat4:
+ push_float(determinant(pull_mat4()));
+ break;
+
+ case OPAbsFloat:
+ push_float(abs(pull_float()));
+ break;
+ case OPSignFloat:
+ push_float(sign(pull_float()));
+ break;
+ case OPFloorFloat:
+ push_float(floor(pull_float()));
+ break;
+ case OPCeilFloat:
+ push_float(ceil(pull_float()));
+ break;
+ case OPFractFloat:
+ push_float(fract(pull_float()));
+ break;
+ case OPSqrtFloat:
+ push_float(sqrt(pull_float()));
+ break;
+ case OPInverseSqrtFloat:
+ push_float(inversesqrt(pull_float()));
+ break;
+ case OPExpFloat:
+ push_float(exp(pull_float()));
+ break;
+ case OPExp2Float:
+ push_float(exp2(pull_float()));
+ break;
+ case OPLogFloat:
+ push_float(log(pull_float()));
+ break;
+ case OPLog2Float:
+ push_float(log2(pull_float()));
+ break;
+ case OPSinFloat:
+ push_float(sin(pull_float()));
+ break;
+ case OPCosFloat:
+ push_float(cos(pull_float()));
+ break;
+ case OPTanFloat:
+ push_float(tan(pull_float()));
+ break;
+ case OPAsinFloat:
+ push_float(asin(pull_float()));
+ break;
+ case OPAcosFloat:
+ push_float(acos(pull_float()));
+ break;
+ case OPAtanFloat:
+ push_float(atan(pull_float()));
+ break;
+ case OPAsinhFloat:
+ push_float(asinh(pull_float()));
+ break;
+ case OPAcoshFloat:
+ push_float(acosh(pull_float()));
+ break;
+ case OPAtanhFloat:
+ push_float(atanh(pull_float()));
+ break;
+ case OPSinhFloat:
+ push_float(sinh(pull_float()));
+ break;
+ case OPCoshFloat:
+ push_float(cosh(pull_float()));
+ break;
+ case OPTanhFloat:
+ push_float(tanh(pull_float()));
+ break;
+ case OPRoundFloat:
+ push_float(round(pull_float()));
+ break;
+ case OPTruncFloat:
+ push_float(trunc(pull_float()));
+ 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;
+ 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;
+ 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;
+ break;
+ case OPDupFloat:
+ push_float(float_stack[float_stack_head-1]);
+ break;
+ case OPDup2Float:
+ push_float(float_stack[float_stack_head-2]);
+ break;
+ case OPDup3Float:
+ push_float(float_stack[float_stack_head-3]);
+ break;
+ case OPDup4Float:
+ push_float(float_stack[float_stack_head-4]);
+ break;
+ case OPDropFloat:
+ float_stack_head--;
+ break;
+ case OPDrop2Float:
+ float_stack[float_stack_head-2]=float_stack[float_stack_head-1];
+ float_stack_head--;
+ 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--;
+ 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--;
+ break;
+
+ case OPAbsVec2:
+ push_vec2(abs(pull_vec2()));
+ break;
+ case OPSignVec2:
+ push_vec2(sign(pull_vec2()));
+ break;
+ case OPFloorVec2:
+ push_vec2(floor(pull_vec2()));
+ break;
+ case OPCeilVec2:
+ push_vec2(ceil(pull_vec2()));
+ break;
+ case OPFractVec2:
+ push_vec2(fract(pull_vec2()));
+ break;
+ case OPSqrtVec2:
+ push_vec2(sqrt(pull_vec2()));
+ break;
+ case OPInverseSqrtVec2:
+ push_vec2(inversesqrt(pull_vec2()));
+ break;
+ case OPExpVec2:
+ push_vec2(exp(pull_vec2()));
+ break;
+ case OPExp2Vec2:
+ push_vec2(exp2(pull_vec2()));
+ break;
+ case OPLogVec2:
+ push_vec2(log(pull_vec2()));
+ break;
+ case OPLog2Vec2:
+ push_vec2(log2(pull_vec2()));
+ break;
+ case OPSinVec2:
+ push_vec2(sin(pull_vec2()));
+ break;
+ case OPCosVec2:
+ push_vec2(cos(pull_vec2()));
+ break;
+ case OPTanVec2:
+ push_vec2(tan(pull_vec2()));
+ break;
+ case OPAsinVec2:
+ push_vec2(asin(pull_vec2()));
+ break;
+ case OPAcosVec2:
+ push_vec2(acos(pull_vec2()));
+ break;
+ case OPAtanVec2:
+ push_vec2(atan(pull_vec2()));
+ break;
+ case OPAsinhVec2:
+ push_vec2(asinh(pull_vec2()));
+ break;
+ case OPAcoshVec2:
+ push_vec2(acosh(pull_vec2()));
+ break;
+ case OPAtanhVec2:
+ push_vec2(atanh(pull_vec2()));
+ break;
+ case OPSinhVec2:
+ push_vec2(sinh(pull_vec2()));
+ break;
+ case OPCoshVec2:
+ push_vec2(cosh(pull_vec2()));
+ break;
+ case OPTanhVec2:
+ push_vec2(tanh(pull_vec2()));
+ break;
+ case OPRoundVec2:
+ push_vec2(round(pull_vec2()));
+ break;
+ case OPTruncVec2:
+ push_vec2(trunc(pull_vec2()));
+ 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;
+ 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;
+ 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;
+ break;
+ case OPDupVec2:
+ push_vec2(vec2_stack[vec2_stack_head-1]);
+ break;
+ case OPDup2Vec2:
+ push_vec2(vec2_stack[vec2_stack_head-2]);
+ break;
+ case OPDup3Vec2:
+ push_vec2(vec2_stack[vec2_stack_head-3]);
+ break;
+ case OPDup4Vec2:
+ push_vec2(vec2_stack[vec2_stack_head-4]);
+ break;
+ case OPDropVec2:
+ vec2_stack_head--;
+ break;
+ case OPDrop2Vec2:
+ vec2_stack[vec2_stack_head-2]=vec2_stack[vec2_stack_head-1];
+ vec2_stack_head--;
+ 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--;
+ 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--;
+ break;
+
+ case OPAbsVec3:
+ push_vec3(abs(pull_vec3()));
+ break;
+ case OPSignVec3:
+ push_vec3(sign(pull_vec3()));
+ break;
+ case OPFloorVec3:
+ push_vec3(floor(pull_vec3()));
+ break;
+ case OPCeilVec3:
+ push_vec3(ceil(pull_vec3()));
+ break;
+ case OPFractVec3:
+ push_vec3(fract(pull_vec3()));
+ break;
+ case OPSqrtVec3:
+ push_vec3(sqrt(pull_vec3()));
+ break;
+ case OPInverseSqrtVec3:
+ push_vec3(inversesqrt(pull_vec3()));
+ break;
+ case OPExpVec3:
+ push_vec3(exp(pull_vec3()));
+ break;
+ case OPExp2Vec3:
+ push_vec3(exp2(pull_vec3()));
+ break;
+ case OPLogVec3:
+ push_vec3(log(pull_vec3()));
+ break;
+ case OPLog2Vec3:
+ push_vec3(log2(pull_vec3()));
+ break;
+ case OPSinVec3:
+ push_vec3(sin(pull_vec3()));
+ break;
+ case OPCosVec3:
+ push_vec3(cos(pull_vec3()));
+ break;
+ case OPTanVec3:
+ push_vec3(tan(pull_vec3()));
+ break;
+ case OPAsinVec3:
+ push_vec3(asin(pull_vec3()));
+ break;
+ case OPAcosVec3:
+ push_vec3(acos(pull_vec3()));
+ break;
+ case OPAtanVec3:
+ push_vec3(atan(pull_vec3()));
+ break;
+ case OPAsinhVec3:
+ push_vec3(asinh(pull_vec3()));
+ break;
+ case OPAcoshVec3:
+ push_vec3(acosh(pull_vec3()));
+ break;
+ case OPAtanhVec3:
+ push_vec3(atanh(pull_vec3()));
+ break;
+ case OPSinhVec3:
+ push_vec3(sinh(pull_vec3()));
+ break;
+ case OPCoshVec3:
+ push_vec3(cosh(pull_vec3()));
+ break;
+ case OPTanhVec3:
+ push_vec3(tanh(pull_vec3()));
+ break;
+ case OPRoundVec3:
+ push_vec3(round(pull_vec3()));
+ break;
+ case OPTruncVec3:
+ push_vec3(trunc(pull_vec3()));
+ 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;
+ 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;
+ 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;
+ break;
+ case OPDupVec3:
+ push_vec3(vec3_stack[vec3_stack_head-1]);
+ break;
+ case OPDup2Vec3:
+ push_vec3(vec3_stack[vec3_stack_head-2]);
+ break;
+ case OPDup3Vec3:
+ push_vec3(vec3_stack[vec3_stack_head-3]);
+ break;
+ case OPDup4Vec3:
+ push_vec3(vec3_stack[vec3_stack_head-4]);
+ break;
+ case OPDropVec3:
+ vec3_stack_head--;
+ break;
+ case OPDrop2Vec3:
+ vec3_stack[vec3_stack_head-2]=vec3_stack[vec3_stack_head-1];
+ vec3_stack_head--;
+ 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--;
+ 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--;
+ break;
+
+ case OPAbsVec4:
+ push_vec4(abs(pull_vec4()));
+ break;
+ case OPSignVec4:
+ push_vec4(sign(pull_vec4()));
+ break;
+ case OPFloorVec4:
+ push_vec4(floor(pull_vec4()));
+ break;
+ case OPCeilVec4:
+ push_vec4(ceil(pull_vec4()));
+ break;
+ case OPFractVec4:
+ push_vec4(fract(pull_vec4()));
+ break;
+ case OPSqrtVec4:
+ push_vec4(sqrt(pull_vec4()));
+ break;
+ case OPInverseSqrtVec4:
+ push_vec4(inversesqrt(pull_vec4()));
+ break;
+ case OPExpVec4:
+ push_vec4(exp(pull_vec4()));
+ break;
+ case OPExp2Vec4:
+ push_vec4(exp2(pull_vec4()));
+ break;
+ case OPLogVec4:
+ push_vec4(log(pull_vec4()));
+ break;
+ case OPLog2Vec4:
+ push_vec4(log2(pull_vec4()));
+ break;
+ case OPSinVec4:
+ push_vec4(sin(pull_vec4()));
+ break;
+ case OPCosVec4:
+ push_vec4(cos(pull_vec4()));
+ break;
+ case OPTanVec4:
+ push_vec4(tan(pull_vec4()));
+ break;
+ case OPAsinVec4:
+ push_vec4(asin(pull_vec4()));
+ break;
+ case OPAcosVec4:
+ push_vec4(acos(pull_vec4()));
+ break;
+ case OPAtanVec4:
+ push_vec4(atan(pull_vec4()));
+ break;
+ case OPAsinhVec4:
+ push_vec4(asinh(pull_vec4()));
+ break;
+ case OPAcoshVec4:
+ push_vec4(acosh(pull_vec4()));
+ break;
+ case OPAtanhVec4:
+ push_vec4(atanh(pull_vec4()));
+ break;
+ case OPSinhVec4:
+ push_vec4(sinh(pull_vec4()));
+ break;
+ case OPCoshVec4:
+ push_vec4(cosh(pull_vec4()));
+ break;
+ case OPTanhVec4:
+ push_vec4(tanh(pull_vec4()));
+ break;
+ case OPRoundVec4:
+ push_vec4(round(pull_vec4()));
+ break;
+ case OPTruncVec4:
+ push_vec4(trunc(pull_vec4()));
+ 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;
+ 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;
+ 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;
+ break;
+ case OPDupVec4:
+ push_vec4(vec4_stack[vec4_stack_head-1]);
+ break;
+ case OPDup2Vec4:
+ push_vec4(vec4_stack[vec4_stack_head-2]);
+ break;
+ case OPDup3Vec4:
+ push_vec4(vec4_stack[vec4_stack_head-3]);
+ break;
+ case OPDup4Vec4:
+ push_vec4(vec4_stack[vec4_stack_head-4]);
+ break;
+ case OPDropVec4:
+ vec4_stack_head--;
+ break;
+ case OPDrop2Vec4:
+ vec4_stack[vec4_stack_head-2]=vec4_stack[vec4_stack_head-1];
+ vec4_stack_head--;
+ 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--;
+ 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--;
+ 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--;
+ 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--;
+ 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;
+ 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;
+ 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;
+ break;
+ case OPDupMat3:
+ push_mat3(mat3_stack[mat3_stack_head-1]);
+ break;
+ case OPDup2Mat3:
+ push_mat3(mat3_stack[mat3_stack_head-2]);
+ break;
+ case OPDup3Mat3:
+ push_mat3(mat3_stack[mat3_stack_head-3]);
+ break;
+ case OPDup4Mat3:
+ push_mat3(mat3_stack[mat3_stack_head-4]);
+ break;
+ case OPDropMat3:
+ mat3_stack_head--;
+ break;
+ case OPDrop2Mat3:
+ mat3_stack[mat3_stack_head-2]=mat3_stack[mat3_stack_head-1];
+ mat3_stack_head--;
+ 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--;
+ 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--;
+ 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;
+ 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;
+ 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;
+ break;
+ case OPDupMat4:
+ push_mat4(mat4_stack[mat4_stack_head-1]);
+ break;
+ case OPDup2Mat4:
+ push_mat4(mat4_stack[mat4_stack_head-2]);
+ break;
+ case OPDup3Mat4:
+ push_mat4(mat4_stack[mat4_stack_head-3]);
+ break;
+ case OPDup4Mat4:
+ push_mat4(mat4_stack[mat4_stack_head-4]);
+ break;
+ case OPDropMat4:
+ mat4_stack_head--;
+ break;
+ case OPDrop2Mat4:
+ mat4_stack[mat4_stack_head-2]=mat4_stack[mat4_stack_head-1];
+ mat4_stack_head--;
+ 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--;
+ 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--;
+ break;
+
+ case OPMinFloat:
+ push_float(min(pull_float(),pull_float()));
+ break;
+ case OPMaxFloat:
+ push_float(max(pull_float(),pull_float()));
+ break;
+ 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)));
+ }
+ }
+ break;
+ 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)));
+ }
+ }
+ 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];
+ }
+ }
+ }
+ 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];
+ }
+ }
+ }
+ 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()));
+ break;
+
+ case OPFMAFloat:
+ push_float(fma(pull_float(),pull_float(),pull_float()));
+ break;
+ case OPFMAVec2:
+ push_vec2(fma(pull_vec2(),pull_vec2(),pull_vec2()));
+ break;
+ case OPFMAVec3:
+ push_vec3(fma(pull_vec3(),pull_vec3(),pull_vec3()));
+ break;
+ case OPFMAVec4:
+ push_vec4(fma(pull_vec4(),pull_vec4(),pull_vec4()));
+ break;
+
+ case OPOuterProductMat2:
+ push_mat2(outerProduct(pull_vec2(),pull_vec2()));
+ break;
+ case OPOuterProductMat3:
+ push_mat3(outerProduct(pull_vec3(),pull_vec3()));
+ break;
+ case OPOuterProductMat4:
+ push_mat4(outerProduct(pull_vec4(),pull_vec4()));
+ break;
+
+ case OPCompMultMat2:
+ push_mat2(matrixCompMult(pull_mat2(),pull_mat2()));
+ break;
+ case OPCompMultMat3:
+ push_mat3(matrixCompMult(pull_mat3(),pull_mat3()));
+ break;
+ case OPCompMultMat4:
+ push_mat4(matrixCompMult(pull_mat4(),pull_mat4()));
+ break;
+
+ case OPClampFloatFloat:
+ push_float(clamp(pull_float(),pull_float(),pull_float()));
+ break;
+ case OPClampVec2Vec2:
+ push_vec2(clamp(pull_vec2(),pull_vec2(),pull_vec2()));
+ break;
+ case OPClampVec3Vec3:
+ push_vec3(clamp(pull_vec3(),pull_vec3(),pull_vec3()));
+ break;
+ case OPClampVec4Vec4:
+ push_vec4(clamp(pull_vec4(),pull_vec4(),pull_vec4()));
+ break;
+ case OPClampVec2Float:
+ push_vec2(clamp(pull_vec2(),pull_float(),pull_float()));
+ break;
+ case OPClampVec3Float:
+ push_vec3(clamp(pull_vec3(),pull_float(),pull_float()));
+ break;
+ case OPClampVec4Float:
+ push_vec4(clamp(pull_vec4(),pull_float(),pull_float()));
+ break;
+
+ case OPMixFloatFloat:
+ push_float(mix(pull_float(),pull_float(),pull_float()));
+ break;
+ case OPMixVec2Vec2:
+ push_vec2(mix(pull_vec2(),pull_vec2(),pull_vec2()));
+ break;
+ case OPMixVec3Vec3:
+ push_vec3(mix(pull_vec3(),pull_vec3(),pull_vec3()));
+ break;
+ case OPMixVec4Vec4:
+ push_vec4(mix(pull_vec4(),pull_vec4(),pull_vec4()));
+ break;
+ case OPMixVec2Float:
+ push_vec2(mix(pull_vec2(),pull_vec2(),pull_float()));
+ break;
+ case OPMixVec3Float:
+ push_vec3(mix(pull_vec3(),pull_vec3(),pull_float()));
+ break;
+ case OPMixVec4Float:
+ push_vec4(mix(pull_vec4(),pull_vec4(),pull_float()));
+ break;
+
+ case OPSquareFloat:
+ floattemp=pull_float();
+ push_float(floattemp*floattemp);
+ break;
+ case OPCubeFloat:
+ floattemp=pull_float();
+ push_float(floattemp*floattemp*floattemp);
+ break;
+ case OPSquareVec2:
+ vec2temp=pull_vec2();
+ push_vec2(vec2temp*vec2temp);
+ break;
+ case OPCubeVec2:
+ vec2temp=pull_vec2();
+ push_vec2(vec2temp*vec2temp*vec2temp);
+ break;
+ case OPSquareVec3:
+ vec3temp=pull_vec3();
+ push_vec3(vec3temp*vec3temp);
+ break;
+ case OPCubeVec3:
+ vec3temp=pull_vec3();
+ push_vec3(vec3temp*vec3temp*vec3temp);
+ break;
+ case OPSquareVec4:
+ vec4temp=pull_vec4();
+ push_vec4(vec4temp*vec4temp);
+ break;
+ case OPCubeVec4:
+ vec4temp=pull_vec4();
+ push_vec4(vec4temp*vec4temp*vec4temp);
+ break;
+ case OPSquareMat2:
+ mat2temp=pull_mat2();
+ push_mat2(mat2temp*mat2temp);
+ break;
+ case OPCubeMat2:
+ mat2temp=pull_mat2();
+ push_mat2(mat2temp*mat2temp*mat2temp);
+ break;
+ case OPSquareMat3:
+ mat3temp=pull_mat3();
+ push_mat3(mat3temp*mat3temp);
+ break;
+ case OPCubeMat3:
+ mat3temp=pull_mat3();
+ push_mat3(mat3temp*mat3temp*mat3temp);
+ break;
+ case OPSquareMat4:
+ mat4temp=pull_mat4();
+ push_mat4(mat4temp*mat4temp);
+ break;
+ case OPCubeMat4:
+ mat4temp=pull_mat4();
+ push_mat4(mat4temp*mat4temp*mat4temp);
+ break;
+
+ case OPSDFSphere:
+ {
+ float r=pull_float();
+ vec3 p=pull_vec3();
+
+ push_float(length(p)-r);
+ if(material){
+ push_material(pull_mat4());
+ }
+ //return p;
+ //return vec3(0.,1.,1.);
+ }
+ break;
+
+ case OPNop:
+ break;
+ case OPStop:
+ return vec3(pull_float());
+ case OPInvalid:
+ default:
+ return vec3(float(minor_float_cache[minor_position]));
+ }
+ }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)
+ {
+ return vec3(pull_float());
+ }
+ }
}
-
- return length(p-vec3(5.))-5.;
}
\ No newline at end of file
diff --git a/src/main.rs b/src/main.rs
index 901d1e0109574429cac4f0fd10b7b53ea2988f18..de72adc0a1e1969002b01b71753ff9778390be5f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,6 +8,7 @@ use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
use vulkano::descriptor_set::{PersistentDescriptorSet, WriteDescriptorSet};
use vulkano::device::{DeviceOwned, Features, QueueFlags};
use vulkano::format::Format;
+use vulkano::half::f16;
use vulkano::image::view::ImageViewCreateInfo;
use vulkano::image::{AttachmentImage, SampleCount};
use vulkano::memory::allocator::StandardMemoryAllocator;
@@ -61,6 +62,12 @@ mod objects;
use crate::objects::*;
mod mcsg_deserialise;
+mod instruction_set {
+ include!(concat!(env!("OUT_DIR"), "/instructionset.rs"));
+}
+
+use crate::instruction_set::InstructionSet;
+
pub type MemoryAllocator = StandardMemoryAllocator;
fn main() {
@@ -140,6 +147,7 @@ fn main() {
sample_rate_shading: true,
shader_float16: true,
shader_int16: true,
+ shader_int8: true,
..Features::empty()
},
..Default::default()
@@ -601,6 +609,66 @@ fn main() {
sub
};
+ let csg_object = {
+ let mut data = [[0u32; 4]; 13];
+
+ let parts = vec![
+ CSGPart::literal(0i8.into()),
+ CSGPart::literal(2i8.into()),
+ CSGPart::literal(0i8.into()),
+ CSGPart::opcode(InstructionSet::OPDupVec3),
+ CSGPart::opcode(InstructionSet::OPPromoteFloatFloatFloatVec3),
+ CSGPart::opcode(InstructionSet::OPSubVec3Vec3),
+ CSGPart::literal(3i8.into()),
+ CSGPart::opcode(InstructionSet::OPSDFSphere),
+ CSGPart::literal(0i8.into()),
+ CSGPart::literal(2i8.into()),
+ CSGPart::literal(0i8.into()),
+ CSGPart::opcode(InstructionSet::OPPromoteFloatFloatFloatVec3),
+ CSGPart::opcode(InstructionSet::OPAddVec3Vec3),
+ CSGPart::literal(3i8.into()),
+ CSGPart::opcode(InstructionSet::OPSDFSphere),
+ CSGPart::literal(f16::from_f32(0.5)),
+ CSGPart::opcode(InstructionSet::OPSmoothMinFloat),
+ CSGPart::opcode(InstructionSet::OPStop),
+ ];
+
+ let mut lower = true;
+ let mut minor = 0;
+ let mut major = 0;
+
+ for part in parts {
+ data[major][minor] |= (part.code as u32) << (if lower { 0 } else { 16 });
+
+ lower = !lower;
+ if lower {
+ minor += 1;
+ if minor == 4 {
+ minor = 0;
+ major += 1;
+ if major == 13 {
+ panic!("CSGParts Too full!");
+ }
+ }
+ }
+ }
+
+ //01111101010101000000000000000000
+
+ /*data[0][0] = ((CSGPart::literal(5u8.into()).code as u32) << 0)
+ | ((CSGPart::opcode(InstructionSet::OPSDFSphere).code as u32) << 16);
+ data[0][1] = ((CSGPart::opcode(InstructionSet::OPStop).code as u32) << 16)
+ | (CSGPart::opcode(InstructionSet::OPStop).code as u32);*/
+
+ println!("data: {:?}, {:?}", data[0][0], data[0][1]);
+
+ let uniform_data = implicit_fs::ty::SceneDescription { d: data };
+
+ let sub = uniform_buffer.allocate_sized().unwrap();
+ *sub.write().unwrap() = uniform_data;
+ sub
+ };
+
let mesh_layout = mesh_pipeline.layout().set_layouts().get(0).unwrap();
let mesh_set = PersistentDescriptorSet::new(
&descriptor_set_allocator,
@@ -619,6 +687,7 @@ fn main() {
[
WriteDescriptorSet::buffer(0, uniform_buffer_subbuffer.clone()),
WriteDescriptorSet::buffer(1, cam_set.clone()),
+ WriteDescriptorSet::buffer(2, csg_object.clone()),
],
)
.unwrap();
diff --git a/src/objects.rs b/src/objects.rs
index 1a94354fbf4e50e0e68e75583da1598cb6ba22f6..dc56801fc78973c18b5b8219ef61e72d4a05e3d1 100644
--- a/src/objects.rs
+++ b/src/objects.rs
@@ -2,7 +2,6 @@ use std::{
collections::HashMap,
io::{Cursor, Read},
mem,
- num::ParseFloatError,
};
use bytemuck::{Pod, Zeroable};
@@ -15,10 +14,8 @@ use vulkano::{
pipeline::graphics::vertex_input::Vertex,
};
-use crate::{
- mcsg_deserialise::{from_reader, Deserializer},
- MemoryAllocator,
-};
+use crate::instruction_set::InstructionSet;
+use crate::{mcsg_deserialise::from_reader, MemoryAllocator};
pub const PLATONIC_SOLIDS: [(&str, &[u8]); 1] = [("Buny", include_bytes!("bunny.obj"))];
pub const CSG_SOLIDS: [(&str, &[u8]); 1] = [("Primitives", include_bytes!("primitive.mcsg"))];
@@ -58,20 +55,11 @@ pub struct CSG {
#[derive(Clone, Copy, Debug, Default, Zeroable, Pod, Vertex)]
pub struct CSGPart {
#[format(R16_SFLOAT)]
- code: u16,
-}
-
-#[repr(u8)]
-#[derive(Copy, Clone, Debug, Default)]
-pub enum CSGOpcode {
- Infinity = 0, // 0 is actually FP16 infinity, perfectly normal representation
- #[default]
- None,
- Const,
+ pub code: u16,
}
impl CSGPart {
- pub fn opcode(opcode: CSGOpcode) -> CSGPart {
+ pub fn opcode(opcode: InstructionSet) -> CSGPart {
CSGPart {
code: opcode as u16 | 0b0111110000000000,
}