all twist animations are now the right shape and direction, just colour to do

Author: lexbailey

controller/src/cli.rs

@@ -194,6 +194,11 @@ fn main() {
             return;
         }
         let gui_release = move||{let _ignored = sync_sender.send(());};
+        enum TwistMode{
+            Client(),
+            Server(),
+        }
+        let mut twist_mode = TwistMode::Client();
         for ev in receiver.iter() {
             let result: Result<bool, SendError<client::FromGUI>> = (||{
                 match ev {
@@ -236,6 +241,8 @@ fn main() {
                                 mprintln!(p, "\tsolved                   - move to the solved state");
                                 mprintln!(p, "\tstart                    - start the game (applies a scramble too)");
                                 mprintln!(p, "\ttwist <TWIST>            - execute a twist on the cube. eg: \"twist U'\"");
+                                mprintln!(p, "\ttwistmode client         - twists happen in the client, and the resulting raw state sent to the server");
+                                mprintln!(p, "\ttwistmode server         - twists happend on the server, and the resulting raw state is pulled from the server");
                             }
                             ,"show" => {
                                 let data = state.lock().unwrap();
@@ -299,12 +306,37 @@ fn main() {
                                             mprintln!(p, "twist requires one parameter");
                                         }
                                         let mut data = state.lock().unwrap();
-                                        match data.cube.twists(args_str){
-                                            Err(msg) => {mprintln!(p, "Error: {}", msg);}
-                                            ,Ok(_) => {
-                                                sender.send(SyncState())?;
-                                                draw(&gfx, &data, p);
-                                            }
+                                        match twist_mode{
+                                            TwistMode::Client() => {
+                                                match data.cube.twists(args_str){
+                                                    Err(msg) => {mprintln!(p, "Error: {}", msg);}
+                                                    ,Ok(_) => {
+                                                        sender.send(SyncState())?;
+                                                        draw(&gfx, &data, p);
+                                                    }
+                                                }
+                                            },
+                                            TwistMode::Server() => {
+                                                if let Ok(t) = cube_model::Twist::seq_from_string(args_str){
+                                                    for t in t{
+                                                        sender.send(DoTwist(t));
+                                                    }
+                                                    sender.send(GetState());
+                                                }
+                                                else{
+                                                    mprintln!(p, "Invalid twist sequence.");
+                                                }
+                                            },
+                                        }
+                                    }
+                                    "twistmode" => {
+                                        if args.len() != 1{
+                                            mprintln!(p, "twistmode requires one parameter");
+                                        }
+                                        match args[0]{
+                                            "client" => {twist_mode = TwistMode::Client();},
+                                            "server" => {twist_mode = TwistMode::Server();},
+                                            a => {mprintln!(p, "unknown twist mode '{}'", a)},
                                         }
                                     }
                                     ,"map" => {

controller/src/client.rs

@@ -259,6 +259,7 @@ pub enum FromGUI {
     EnableCalibrationView(),
     DisableCalibrationView(),
     RotateSubface(usize,usize),
+    DoTwist(Twist),
 }
 
 impl FromGUI{
@@ -684,6 +685,9 @@ pub fn start_client() -> (Arc<Mutex<ClientState>>, Sender<FromGUI>, Receiver<ToG
                             RotateSubface(f,sf) => {
                                 command_queue.push_back(("rotate_subface".to_string(), vec![f.to_string(),sf.to_string()]));
                             },
+                            DoTwist(t) => {
+                                command_queue.push_back(("do_twist".to_string(), vec![t.to_string()]));
+                            }
                         }
                     }
                 }

service/src/cube.frag.glsl

@@ -10,6 +10,7 @@ uniform uint u_map_facenum[45];
 uniform uint u_map_subfacenum[45];
 uniform uint u_inverse_facemap[45];
 uniform uint u_adjacent[45];
+uniform uint u_twist_dirs[6*9*9];
 uniform vec3 u_base_cols[6];
 uniform uint u_twist_face;
 uniform float u_twist_dir;
@@ -134,23 +135,23 @@ void main() {
 
         vec2 fl_coord = vec2(px_pos.x - (ix*u_facelet_px), px_pos.y - (iy*u_facelet_px)) / u_facelet_px;
         fl_coord -= vec2(0.5,0.5);
+
+        FragColor = vec4(0.0,0.0,0.0,1.0);
         if (this_face && u_anim_pos < 1.0){
             // Animations for subfaces on the twisted face
             float anim = u_anim_pos;
             //float anim = 0.5;
             float a = (PI/2) * anim * -u_twist_dir;
             float a2 = (PI/2) * (1.0-anim) * u_twist_dir;
-            FragColor = vec4(0.0,0.0,0.0,1.0);
             if (is_centre){
                 mat3 rot = rotate(a);
                 vec2 fl_coord1 = (vec3(fl_coord,1.0) * rot).xy;
                 FragColor += render_tile(fl_coord1, base, sf_rot, is_centre, is_edge, is_corner);
                 vec3 r = vec3(1.0,0.0,1.0) * rotate(sf_rot * PI/2);
-                // TODO calculate actual edge base colours
-                vec3 edge_base1 = u_base_cols[u_prev_colours[get_index(f, 1u)]]; // TODO determine centre colour to render here
-                vec3 edge_base2 = u_base_cols[u_prev_colours[get_index(f, 3u)]]; // TODO determine centre colour to render here
-                vec3 edge_base3 = u_base_cols[u_prev_colours[get_index(f, 7u)]]; // TODO determine centre colour to render here
-                vec3 edge_base4 = u_base_cols[u_prev_colours[get_index(f, 5u)]]; // TODO determine centre colour to render here
+                vec3 edge_base1 = u_base_cols[u_prev_colours[get_index(f, 1u)]];
+                vec3 edge_base2 = u_base_cols[u_prev_colours[get_index(f, 3u)]];
+                vec3 edge_base3 = u_base_cols[u_prev_colours[get_index(f, 7u)]];
+                vec3 edge_base4 = u_base_cols[u_prev_colours[get_index(f, 5u)]];
                 vec3 edge_coord1 = vec3(fl_coord,1.0) * rotate(a) * translate(-r.x,r.y);
                 vec3 edge_coord2 = vec3(fl_coord,1.0) * rotate(a + (1*PI/2)) * translate(-r.x,r.y);
                 vec3 edge_coord3 = vec3(fl_coord,1.0) * rotate(a + (2*PI/2)) * translate(-r.x,r.y);
@@ -225,7 +226,26 @@ void main() {
                 FragColor += render_tile(fl_coord, base, sf_rot, is_centre, is_edge, is_corner);
             }
             else {
-                // TODO animate these faces
+                float anim = u_anim_pos * 3;
+                uint angle = sf_rot+1u;
+                uint dir_index = (u_twist_face * 54u) + (f * 9u) + sf;
+                uint d = u_twist_dirs[dir_index];
+                angle += d;
+                if (u_twist_dir < 0){ angle += 2u; }
+                mat3 rot = rotate(angle * (PI/2));
+                vec2 fl_coord_a  = vec3(fl_coord + (vec3(      anim ,0.0,1.0)*rot).xy,1.0).xy;
+                vec2 fl_coord_a2 = vec3(fl_coord + (vec3(-(3.0-anim),0.0,1.0)*rot).xy,1.0).xy;
+                vec2 fl_coord_a3 = vec3(fl_coord + (vec3(-(1.0-anim),0.0,1.0)*rot).xy,1.0).xy;
+                vec2 fl_coord_a4 = vec3(fl_coord + (vec3(-(2.0-anim),0.0,1.0)*rot).xy,1.0).xy;
+                // previous colour, slides out
+                FragColor += render_tile(fl_coord_a, prev_base, sf_rot, is_centre, is_edge, is_corner);
+    
+                // two intermediate colours slide through
+                FragColor += render_tile(fl_coord_a3, u_base_cols[0], sf_rot, is_centre, is_edge, is_corner);
+                FragColor += render_tile(fl_coord_a4, u_base_cols[0], sf_rot, is_centre, is_edge, is_corner);
+
+                // next colour, slides in
+                FragColor += render_tile(fl_coord_a2, base, sf_rot, is_centre, is_edge, is_corner);
             }
         }
         if (is_centre && (u_debug_arrow > 0u)){

service/src/dir_map.txt

@@ -0,0 +1 @@
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 2, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 1, 0, 0, 0, 0, 0, 0, 2, 2, 1, 0, 0, 0, 0, 0, 0, 2, 2, 1, 0, 0, 0, 0, 0, 0, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 1, 0, 0, 0, 0, 0, 0, 3, 2, 1, 0, 0, 0, 0, 0, 0, 3, 2, 1, 0, 0, 0, 0, 0, 0, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

service/src/main.rs

@@ -90,7 +90,7 @@ enum ClientEvent{
     EnableCalibrationView(),
     DisableCalibrationView(),
     RotateSubface(usize,usize),
-    ApplyTwist(String),
+    DoTwist(cube_model::Twist),
 }
 
 enum Event{
@@ -232,6 +232,19 @@ fn handle_stream<R: 'static + Read + Send + Sync, W: 'static + Write + Send + Sy
                                                     }
                                                 }
                                             },
+                                            "do_twist" => {
+                                                if args.len() != 1{
+                                                    let msg = auth.construct_reply("wrong_arguments", &vec![&command]);
+                                                    write_stream.write(msg.as_bytes())?;
+                                                }
+                                                if let Ok(t) = Twist::from_string(&args[0]){
+                                                    sender.send(Event::Client(ClientEvent::DoTwist(t)))?;
+                                                }
+                                                else{
+                                                    let msg = auth.construct_reply("bad_argument", &vec![&command]);
+                                                    write_stream.write(msg.as_bytes())?;
+                                                }
+                                            }
                                             _=>{
                                                 let msg = auth.construct_reply("unknown_command", &vec![&command]);
                                                 write_stream.write(msg.as_bytes())?;
@@ -637,6 +650,7 @@ shader_struct!{
         u_map_subfacenum: Uniform1UIV,
         u_inverse_facemap: Uniform1UIV,
         u_adjacent: Uniform1UIV,
+        u_twist_dirs: Uniform1UIV,
         u_base_cols: Uniform3FV,
         u_twist_face: Uniform1UI,
         u_twist_dir: Uniform1F,
@@ -918,7 +932,8 @@ fn jumbotron_thread_main(
             shader.u_map_subfacenum.set(&lm.subfacemap);
             shader.u_inverse_facemap.set(&lm.inverse());
             shader.u_rotation_map.set(&lm.rotationmap);
-            shader.u_adjacent.set(&[12, 136, 24, 68, 192, 80, 6, 130, 18, 5, 129, 17, 260, 384, 272, 36, 160, 48, 9, 65, 3, 264, 320, 258, 40, 96, 34, 17, 129, 5, 272, 384, 260, 48, 160, 36, 3, 65, 9, 258, 320, 264, 34, 96, 40, 24, 136, 12, 80, 192, 68, 18, 130, 6])
+            shader.u_adjacent.set(&[12, 136, 24, 68, 192, 80, 6, 130, 18, 5, 129, 17, 260, 384, 272, 36, 160, 48, 9, 65, 3, 264, 320, 258, 40, 96, 34, 17, 129, 5, 272, 384, 260, 48, 160, 36, 3, 65, 9, 258, 320, 264, 34, 96, 40, 24, 136, 12, 80, 192, 68, 18, 130, 6]);
+            shader.u_twist_dirs.set(&include!("dir_map.txt"));
         }
         shader.u_prev_colours.set(prev_cols.as_slice());
         shader.u_cur_colours.set(cols.as_slice());
@@ -1001,8 +1016,8 @@ fn jumbotron_thread_main(
             let sf = 0.3;
             let base_trans = &Transform::scale(height as f32/width as f32,1.0,1.0) * &Transform::scale(sf,sf,sf);
             let base_trans = &base_trans * &Transform::rotate_xyz(-0.25,0.0,0.0);
-            //let base_trans = &base_trans * &Transform::rotate_xyz(0.00,(Instant::now()-start_time).as_millis() as f32 / 4000.0,0.0);
-            let base_trans = &base_trans * &Transform::rotate_xyz(0.00,1.0,0.0);
+            let base_trans = &base_trans * &Transform::rotate_xyz(0.00,(Instant::now()-start_time).as_millis() as f32 / 4000.0,0.0);
+            //let base_trans = &base_trans * &Transform::rotate_xyz(0.00,1.0,0.0);
             for (i, t1) in face_transforms.iter().enumerate(){
                 preview_cube.u_cur_face.set(i.try_into().unwrap());
                 for (j, t2) in facelet_translations.iter().enumerate(){
@@ -1266,8 +1281,12 @@ fn main() {
                             config.rotation_map = rotstr;
                             persist_config(&config, &args.config);
                         }
-                        ,ClientEvent::ApplyTwist(t) => {
-                            todo!();
+                        ,ClientEvent::DoTwist(twist) => {
+                            let mut c = cube.lock().unwrap();
+                            prev_cube.lock().unwrap().deserialise(&c.serialise()).unwrap();
+                            c.twist(twist);
+                            last_twist.lock().unwrap().twist = Some(twist);
+                            last_twist.lock().unwrap().time = Some(Instant::now());
                         }
                         ,ClientEvent::StartDetectLED() => {
                             println!("Detect LEDs");

service/twist_dirs

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+
+dirs = {
+#    V V
+0: [(1,0,1),(1,1,2),(1,2,2),(4,0,1),(4,1,2),(4,2,2),(3,0,1),(3,1,2),(3,2,2),(2,0,1),(2,1,2),(2,2,2),],##
+1: [(0,6,0),(0,7,0),(0,8,3),(2,2,3),(2,5,0),(2,8,0),(4,0,0),(4,3,0),(4,6,3),(5,6,0),(5,7,0),(5,8,0),],##
+2: [(0,0,2),(0,3,2),(0,6,1),(1,0,0),(1,3,0),(1,6,3),(3,2,3),(3,5,0),(3,8,0),(5,2,0),(5,5,0),(5,8,0),],##
+3: [(0,0,3),(0,1,0),(0,2,0),(2,0,0),(2,3,0),(2,6,3),(4,2,3),(4,5,0),(4,8,0),(5,0,0),(5,1,0),(5,2,0),],##
+4: [(0,2,1),(0,5,2),(0,8,2),(1,2,3),(1,5,0),(1,8,0),(3,0,0),(3,3,0),(3,6,3),(5,0,0),(5,3,0),(5,6,0),],##
+5: [(1,6,2),(1,7,2),(1,8,1),(2,6,2),(2,7,2),(2,8,1),(3,6,2),(3,7,2),(3,8,1),(4,6,2),(4,7,2),(4,8,1),],##
+6: [(0,3,1),(0,4,0),(0,5,3),(2,1,3),(2,4,1),(2,7,1),(4,1,1),(4,4,3),(4,7,3),(5,3,0),(5,4,0),(5,5,0),],##
+7: [(0,1,3),(0,4,1),(0,7,1),(1,1,1),(1,4,3),(1,7,3),(3,1,3),(3,4,1),(3,7,1),(5,1,0),(5,4,0),(5,7,0),],##
+
+8: [(1,3,3),(1,4,2),(1,5,1),(2,3,3),(2,4,2),(2,5,1),(3,3,3),(3,4,2),(3,5,1),(4,3,3),(4,4,2),(4,5,1),],
+}
+
+dir_map = [0]*6*9*9
+
+for twist_face, adjacent in dirs.items():
+    for a in adjacent:
+        f,sf,dir_ = a
+        index = (f * 9) + sf # 0 to 53
+        index2 = (twist_face * 54) + index
+        dir_map[index2] = dir_
+
+print(dir_map)