When preparing the Rendered Image frames, you can use any desired program, so long as it’s capable of rendering animations as separate frames.
Preparation
General rules when preparing the image renders:
- Set-up an animation where the camera rotates for 360 degrees around an object in focus.
- The animation movement should be linear / rotate at a constant rate (no interpolation or rather no easing movements).
- Camera should start at the lowest and end at the highest point
- Camera should be evenly spaced, relative to the frame count (if you want to have X-frames = 72, then the rotation should increment by 360 / 72 every frame)
- Rendered frames should have NO MOTION BLUR
- Each full 360 rotation (not including the last frame) should yield 72 or 124 frames.
- Export animation frames as .webp images at 1024×1024 or 2048×2048 pixel resolution (1k resolution is sufficient in most cases)
- Example here
In-depth explanations below.
Example
For this example, I will be using a metal locker as the main product. The scope of this example is as follows:
- 36 horizontal frames
- 2 vertical frames
- 1 product
- 2 colors
- No configurable parts
As stated above, I would like to have 36 horizontal frames, and 2 vertical frames. This means that I would need to render a total of 72 images to achieve this.
First, I place the camera at a specific distance away from the product while facing it head on.
Starting at index 0, the camera will rotate around the object by 10° each frame
(360°36 frames), moving at 1 frame per second to avoid motion blur and to keep an even incremental distance between each frame.
The reason why the spacing of each frame has to be consistent is that an uneven spacing will result in a jittery experience when interacting with the visualization.
After rotating the object 36 times, the camera should stop right before making a full rotation.
The scope of this example requires 2 vertical frames, it means that frame 37 (or in my case index 36) will be set 1 vertical increment up. This increment can be anything you would like. And then it goes around once more.
Then the final frame would once again end right before it finishes it’s full rotation
My final result is 72 Rendered Images, which create an animation which rotates around the object.
The next step is to decide on a naming convention for our renders, it can be anything we want, so long as it includes an index for X and or Y. For our example, lets go with m_locker_{{y}}_{{x}}.webp
The index is derived from your frame count – 1, which means if we have 36 frames, our X index will go from 0 to 35 and our Y index will go from 0 to 1.
The first X frame in the first Y axis will be called: m_locker_0_0.webp
The last X frame in the first Y axis will be called: m_locker_0_35.webp
The first X frame in the last Y axis will be called: m_locker_1_0.webp
The last X frame in the last Y axis will be called: m_locker_1_35.webp
The rest of the images are named incrementally by 1 more than the previous one.
- m_locker_0_0.webp
- m_locker_0_1.webp
- m_locker_0_2.webp
- m_locker_0_3.webp
- …
Now we have to compress all of the images into a .zip file with the name of the .zip file being anything you would like.
Now go to the platform and open the Image 360 View settings:
- Fill out the correct number of frames on the left side,
- Upload the .zip file
- Type in our Image name pattern m_locker_{{y}}_{{x}}.webp
If you’ve done everything correctly, you should see your product pop up in the right side panel.
Press Validate and if all of the images are present, then you will see a green notice
In order to add configurability to this visualization and to finish the scope of this example, I will need to render 144 frames, 72 per different possible colors.
The parts of the product that aren’t colored, are masked out.
We set the visibility of each configurable layer to false and then use Rules to enable them once a certain condition has been met.
