The borders between pieces are not clear now but the real cube has clear borders.

• Classical cube has explicit thick black borders.
• Sticker-less cube (like picture below. It is GAN 356M) doesn't have black border but the border is clear.

How to implement this?

I think portable-simd will improve multiplication because it is gather operation.

   fn apply(self, to: Self) -> Self {
        let out = gather(&self.inv_perm, &to.inv_perm);
        Self { inv_perm: out }
    }

and portable_simd has one.

    pub fn gather_or_default(slice: &[T], idxs: Simd<usize, LANES>) -> Self
    where
        T: Default,
    {
        Self::gather_or(slice, idxs, Self::splat(T::default()))
    }

It looks quite an early stage but let's trust it.

I don't know how I can design it because I am not familiar with WebApp tech. Please help me.

But some requirements in my mind:

1. It should be embedded in rust-wasm application easily. (Implementing as a Yew component is my recommendation. See https://github.com/yewstack/yew/pull/908/files)
2. It should support camera moves by mouse move and reset when certain key (e.g. space or esc) is pressed. If it supports flicking in mobile browser It will be preferred.
3. It should accept sequence of command (like RU2R') and it performs rotations.
4. Rotations should be animated. The speed should be able to configure.
5. Camera move by key input should be considered. When key like UP is pressed it should rotate the cube by x or x'.

What you will do:

• You will create cube-component crate (or other name you like). You can use PermutationMatrix and operations to calculate cube state after rotation but this is not required.
• You will create cube-app that can launch webapp easily on localhost. This will help testing and debugging.

I got an advice in forum https://users.rust-lang.org/t/rubiks-cube-library-rubikmaster/65185/4?u=akiradeveloper

I guess it would look better if the cube wasn’t the same color as the blackground. Black cube sound fine if you want that, but then perhaps make the background dark grey or so. Right now your demo looks a bit like the cube’s stickers are free-floating in space.

In Rubik's cube, rotation is a sequence of characters.

The parser should parse a text like you see in here

Here are some examples:

• R2 D (R' U2 R) D' (R' U2 R')
• (R U') (R U)2 (R U') R' U' R2
• (R2' U)(RUR')(U'R'U')(R' U R')

But the space between the characters should not be assumed.

As an extension, it is convenient to allow to add prime to group (RLR')' and this will eventually be interpreted as RL'R' which is counter effective of the original one.

Implement this function using nom (>= 0.7) or anything you like as long as maintainable (combine is another choice I know)

pub enum Elem {
    One(Command),
    Group(Vec<Command>, i8),
}
pub fn parse(s: &str) -> Vec<Elem> {
    todo!()
}

What you will do:

1. Implement parser
2. Add some tests (basic tests are ok but you may use proptest)

F2L has 41 patterns. Each situation should be reproduced by

M = (F2L)' * (random OLL)' * (random PLL)' * Id

So we can make 41 * 57 * 21 (= 49k) problems.

The cube component is super sub-optimal. It recomputes everything in every frame.

To optimize, let's consider when data should be changed.

• The vertex and index list can be reused in all frames. This can use VAO.
• The color (each vertex) should be changed between moves. This can also use VAO.
• The rotation matrix should be updated in every frame because the rotation angle is changing.

Rotation is matrix multiply of O(54). It may be optimized to gather operation but may be not. It isn't a cheap computation anyway.

Multiplying N matrices can be parallel by Rayon. It would be nice to have a matrix::reduce function whose type is like this

fn reduce(Vec<PermutationMatrix>) -> PermutationMatrix

What you will do:

1. Implement reduce function
2. Add bench. What we want to know is what N should we choose to switch between serial and parallel. I will be great if it is small like 10 or so.

According to the rotation rule (x,y,z), cube is considered to have a x,y,z coordinate as the direction in this figure.

How I number the piece surfaces? The rule is

• When you see a surface, you can see two axis in two dimension
• Now place axis to direct 0 o'clock and 3 o'clock. That's the default position.
• The left-top is (0,0) and the right-top is (0,2)

For example, If you see the cube from R surface. Place z on 0 o'clock and y on 3 o'clock.

This rule is symmetric.

But this rule is too hard to calculate in brain unless you are a genius.

For ease of use, it would be better to have PieceCoordinate so the piece with 1,5,9 has (1,1,1) and 6,9,13 has (-1,1,1).

Then we can define a calculation (PieceCoordinate, Surface) -> Surface Index

What you will do:

1. Define coordinate module
2. Put this definitions there

This will help to draw Cube in 3d world.

https://github.com/rust-phf/rust-phf

We could use this library to speed up this table

fn create_plane_group() -> HashMap<RotationPlane, [Piece; 9]> {

Develop a crate that transforms events from smart cube to a command stream.

There are referential implementations so it will be easy because the spec is known.

https://github.com/playfultechnology/esp32-smartcube

If you can move the cube in an app by moving the cube in your hand, that will be a path to smart cube apps!

The component has blacklist which is a set of surfaces which will be painted in black.

Instead of this, I want to specify set of pieces to be transparent.

Transparent piece isn't possible with real cube so will be a great value.

To make a piece transparent, we can use so-called alpha brending. But since other pieces aren't transparent. We need to do some graphic technique to see solid piece behind a transparent piece because depth buffer enabled normally eliminated the solid piece when they are drawn front to back.

My idea is firstly draw all solid pieces and then transparent ones.

This cube app has two input fields. One for the initial scrambler and for a solve sequence.

This app helps cubers reproduce a cube state and try a new solve sequence. Especially good for learners.