Skip to content
Snippets Groups Projects
Unverified Commit 56dc49f9 authored by John Hunter's avatar John Hunter :minidisc:
Browse files

Interpreter works :)

parent 79b46cf0
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
.vscode/third_year_project.code-workspace 0 → 100644
+ 8
− 0
View file @ 56dc49f9
{
"folders": [
{
"path": ".."
}
],
"settings": {}
}
\ No newline at end of file
build.rs 0 → 100644
+ 32
− 0
View file @ 56dc49f9
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(())
}
src/frag.glsl
+ 12
− 6
View file @ 56dc49f9
...@@ -47,17 +47,17 @@ vec3 shading(vec3 normal) ...@@ -47,17 +47,17 @@ vec3 shading(vec3 normal)
vec3 getNormal(vec3 p,float dens){ vec3 getNormal(vec3 p,float dens){
vec3 n; vec3 n;
n.x=scene(vec3(p.x+EPSILON,p.y,p.z)); n.x=scene(vec3(p.x+EPSILON,p.y,p.z),false).x;
n.y=scene(vec3(p.x,p.y+EPSILON,p.z)); n.y=scene(vec3(p.x,p.y+EPSILON,p.z),false).x;
n.z=scene(vec3(p.x,p.y,p.z+EPSILON)); n.z=scene(vec3(p.x,p.y,p.z+EPSILON),false).x;
return normalize(n-scene(p)); return normalize(n-(scene(p,false).x));
} }
vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){ vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){
vec2 td=vec2(NEARPLANE,1.); vec2 td=vec2(NEARPLANE,1.);
p=ori; p=ori;
for(int i=0;i<MAX_STEPS&&td.y>EPSILON&&td.x<FARPLANE;i++){ 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; td.x+=(td.y)*.9;
p=ori+dir*td.x; p=ori+dir*td.x;
} }
...@@ -66,7 +66,7 @@ vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){ ...@@ -66,7 +66,7 @@ vec2 spheretracing(vec3 ori,vec3 dir,out vec3 p){
//Implicit Surface Entrypoint //Implicit Surface Entrypoint
void main(){ void main(){
default_mask();
vec3 raypos=vertexInput.position.xyz; vec3 raypos=vertexInput.position.xyz;
vec2 iResolution=vec2(RES_X,RES_Y); vec2 iResolution=vec2(RES_X,RES_Y);
vec2 iuv=(gl_FragCoord.xy+gl_SamplePosition)/iResolution.xy*2.-1.; vec2 iuv=(gl_FragCoord.xy+gl_SamplePosition)/iResolution.xy*2.-1.;
...@@ -74,10 +74,16 @@ void main(){ ...@@ -74,10 +74,16 @@ void main(){
uv.x*=iResolution.x/iResolution.y; uv.x*=iResolution.x/iResolution.y;
vec3 p; vec3 p;
vec3 raydir=normalize(raypos-camera_uniforms.campos); 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); vec2 td=spheretracing(raypos,raydir,p);
vec3 n=getNormal(p,td.y); vec3 n=getNormal(p,td.y);
if(td.y<EPSILON) if(td.y<EPSILON)
{ {
f_color=vec4(1.);
f_color=vec4(shading(n),1.); f_color=vec4(shading(n),1.);
vec4 tpoint=camera_uniforms.proj*camera_uniforms.view*vec4(p,1); vec4 tpoint=camera_uniforms.proj*camera_uniforms.view*vec4(p,1);
......
src/instructionset.glsl 0 → 100644
+ 341
− 0
View file @ 56dc49f9
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
src/interpreter.glsl
+ 1341
− 35
View file @ 56dc49f9
//#extension GL_EXT_shader_16bit_storage:require //#extension GL_EXT_shader_16bit_storage:require
#extension GL_EXT_shader_explicit_arithmetic_types: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 u32vec4 d[13];//stored packed for space efficiency, 8 per index
}scene_description; }scene_description;
...@@ -32,96 +34,1400 @@ minor_integer_unpack=unpackUint2x16(major_unpack.w);\ ...@@ -32,96 +34,1400 @@ minor_integer_unpack=unpackUint2x16(major_unpack.w);\
minor_integer_cache[6]=minor_integer_unpack.x;\ minor_integer_cache[6]=minor_integer_unpack.x;\
minor_integer_cache[7]=minor_integer_unpack.y; minor_integer_cache[7]=minor_integer_unpack.y;
uint major_position=0; float float_stack[8];
uint minor_position=0;
float16_t float_stack[8];
uint float_stack_head=0; uint float_stack_head=0;
f16vec2 vec2_stack[8]; vec2 vec2_stack[8];
uint vec2_stack_head=0; uint vec2_stack_head=0;
f16vec3 vec3_stack[8]; vec3 vec3_stack[8];
uint vec3_stack_head=0; uint vec3_stack_head=0;
f16vec4 vec4_stack[8]; vec4 vec4_stack[8];
uint vec4_stack_head=0; uint vec4_stack_head=0;
f16mat2 mat2_stack[8]; mat2 mat2_stack[8];
uint mat2_stack_head=0; uint mat2_stack_head=0;
f16mat3 mat3_stack[8]; mat3 mat3_stack[8];
uint mat3_stack_head=0; uint mat3_stack_head=0;
f16mat4 mat4_stack[8]; mat4 mat4_stack[8];
uint mat4_stack_head=0; 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; float_stack[float_stack_head++]=f;
} }
float16_t pull_float(){ float pull_float(){
return float_stack[--float_stack_head]; return float_stack[--float_stack_head];
} }
void push_vec2(f16vec2 f){ void push_vec2(vec2 f){
vec2_stack[vec2_stack_head++]=f; vec2_stack[vec2_stack_head++]=f;
} }
f16vec2 pull_vec2(){ vec2 pull_vec2(){
return vec2_stack[--vec2_stack_head]; return vec2_stack[--vec2_stack_head];
} }
void push_vec3(f16vec3 f){ void push_vec3(vec3 f){
vec3_stack[vec3_stack_head++]=f; vec3_stack[vec3_stack_head++]=f;
} }
f16vec3 pull_vec3(){ vec3 pull_vec3(){
return vec3_stack[--vec3_stack_head]; return vec3_stack[--vec3_stack_head];
} }
void push_vec4(f16vec4 f){ void push_vec4(vec4 f){
vec4_stack[vec4_stack_head++]=f; vec4_stack[vec4_stack_head++]=f;
} }
f16vec4 pull_vec4(){ vec4 pull_vec4(){
return vec4_stack[--vec4_stack_head]; return vec4_stack[--vec4_stack_head];
} }
void push_mat2(f16mat2 f){ void push_mat2(mat2 f){
mat2_stack[mat2_stack_head++]=f; mat2_stack[mat2_stack_head++]=f;
} }
f16mat2 pull_mat2(){ mat2 pull_mat2(){
return mat2_stack[--mat2_stack_head]; return mat2_stack[--mat2_stack_head];
} }
void push_mat3(f16mat3 f){ void push_mat3(mat3 f){
mat3_stack[mat3_stack_head++]=f; mat3_stack[mat3_stack_head++]=f;
} }
f16mat3 pull_mat3(){ mat3 pull_mat3(){
return mat3_stack[--mat3_stack_head]; return mat3_stack[--mat3_stack_head];
} }
void push_mat4(f16mat4 f){ void push_mat4(mat4 f){
mat4_stack[mat4_stack_head++]=f; mat4_stack[mat4_stack_head++]=f;
} }
f16mat4 pull_mat4(){ mat4 pull_mat4(){
return mat4_stack[--mat4_stack_head]; 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()
{ {
major_position=0; float_stack_head=0;
minor_position=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)
{
uint major_position=0;
uint minor_position=0;
float16_t minor_float_cache[8]; float16_t minor_float_cache[8];
uint16_t minor_integer_cache[8]; uint16_t minor_integer_cache[8];
clear_stacks();
push_vec3(p);
bool cont=true;
while(cont){
if(minor_position==0){ if(minor_position==0){
get_caches; 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])) 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;
return length(p-vec3(5.))-5.; 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());
}
}
}
} }
\ No newline at end of file
src/main.rs
+ 69
− 0
View file @ 56dc49f9
...@@ -8,6 +8,7 @@ use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator; ...@@ -8,6 +8,7 @@ use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
use vulkano::descriptor_set::{PersistentDescriptorSet, WriteDescriptorSet}; use vulkano::descriptor_set::{PersistentDescriptorSet, WriteDescriptorSet};
use vulkano::device::{DeviceOwned, Features, QueueFlags}; use vulkano::device::{DeviceOwned, Features, QueueFlags};
use vulkano::format::Format; use vulkano::format::Format;
use vulkano::half::f16;
use vulkano::image::view::ImageViewCreateInfo; use vulkano::image::view::ImageViewCreateInfo;
use vulkano::image::{AttachmentImage, SampleCount}; use vulkano::image::{AttachmentImage, SampleCount};
use vulkano::memory::allocator::StandardMemoryAllocator; use vulkano::memory::allocator::StandardMemoryAllocator;
...@@ -61,6 +62,12 @@ mod objects; ...@@ -61,6 +62,12 @@ mod objects;
use crate::objects::*; use crate::objects::*;
mod mcsg_deserialise; mod mcsg_deserialise;
mod instruction_set {
include!(concat!(env!("OUT_DIR"), "/instructionset.rs"));
}
use crate::instruction_set::InstructionSet;
pub type MemoryAllocator = StandardMemoryAllocator; pub type MemoryAllocator = StandardMemoryAllocator;
fn main() { fn main() {
...@@ -140,6 +147,7 @@ fn main() { ...@@ -140,6 +147,7 @@ fn main() {
sample_rate_shading: true, sample_rate_shading: true,
shader_float16: true, shader_float16: true,
shader_int16: true, shader_int16: true,
shader_int8: true,
..Features::empty() ..Features::empty()
}, },
..Default::default() ..Default::default()
...@@ -601,6 +609,66 @@ fn main() { ...@@ -601,6 +609,66 @@ fn main() {
sub 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_layout = mesh_pipeline.layout().set_layouts().get(0).unwrap();
let mesh_set = PersistentDescriptorSet::new( let mesh_set = PersistentDescriptorSet::new(
&descriptor_set_allocator, &descriptor_set_allocator,
...@@ -619,6 +687,7 @@ fn main() { ...@@ -619,6 +687,7 @@ fn main() {
[ [
WriteDescriptorSet::buffer(0, uniform_buffer_subbuffer.clone()), WriteDescriptorSet::buffer(0, uniform_buffer_subbuffer.clone()),
WriteDescriptorSet::buffer(1, cam_set.clone()), WriteDescriptorSet::buffer(1, cam_set.clone()),
WriteDescriptorSet::buffer(2, csg_object.clone()),
], ],
) )
.unwrap(); .unwrap();
......
src/objects.rs
+ 4
− 16
View file @ 56dc49f9
...@@ -2,7 +2,6 @@ use std::{ ...@@ -2,7 +2,6 @@ use std::{
collections::HashMap, collections::HashMap,
io::{Cursor, Read}, io::{Cursor, Read},
mem, mem,
num::ParseFloatError,
}; };
use bytemuck::{Pod, Zeroable}; use bytemuck::{Pod, Zeroable};
...@@ -15,10 +14,8 @@ use vulkano::{ ...@@ -15,10 +14,8 @@ use vulkano::{
pipeline::graphics::vertex_input::Vertex, pipeline::graphics::vertex_input::Vertex,
}; };
use crate::{ use crate::instruction_set::InstructionSet;
mcsg_deserialise::{from_reader, Deserializer}, use crate::{mcsg_deserialise::from_reader, MemoryAllocator};
MemoryAllocator,
};
pub const PLATONIC_SOLIDS: [(&str, &[u8]); 1] = [("Buny", include_bytes!("bunny.obj"))]; pub const PLATONIC_SOLIDS: [(&str, &[u8]); 1] = [("Buny", include_bytes!("bunny.obj"))];
pub const CSG_SOLIDS: [(&str, &[u8]); 1] = [("Primitives", include_bytes!("primitive.mcsg"))]; pub const CSG_SOLIDS: [(&str, &[u8]); 1] = [("Primitives", include_bytes!("primitive.mcsg"))];
...@@ -58,20 +55,11 @@ pub struct CSG { ...@@ -58,20 +55,11 @@ pub struct CSG {
#[derive(Clone, Copy, Debug, Default, Zeroable, Pod, Vertex)] #[derive(Clone, Copy, Debug, Default, Zeroable, Pod, Vertex)]
pub struct CSGPart { pub struct CSGPart {
#[format(R16_SFLOAT)] #[format(R16_SFLOAT)]
code: u16, pub 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,
} }
impl CSGPart { impl CSGPart {
pub fn opcode(opcode: CSGOpcode) -> CSGPart { pub fn opcode(opcode: InstructionSet) -> CSGPart {
CSGPart { CSGPart {
code: opcode as u16 | 0b0111110000000000, code: opcode as u16 | 0b0111110000000000,
} }
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment