COMING SOON.
Bianca Bar Ad
Bianca Bar
Welcome to the world of Bianca Bar! This VFX commercial was born a few months ago, inspired by a Kinder Bueno ad I stumbled upon on YouTube. Unlike the large-scale Hollywood productions, the approach for commercials is quite different. While similar tools may be used, the camera-moves are delicate and smooth, the lighting is often based on traditional studio setups, the FX are small-scale - the list goes on.
Thus the Bianca Bar journey began! What started as a simple idea quickly transformed into weeks of creative iterations, thinking outside the box and ultimately creating a captivating visual journey that highlights the unique charm of this new-to-market candy Bianca Bar.
​
By the way, if you're looking for someone to produce VFX for your own commercial project - please don't hesitate to swing over to my Fiverr page!
​
Concept
The Bianca Bar is inspired by a Kinder Bueno advertisement that played repeatedly on YouTube. With a burst of creativity, I mapped out the shots I envisioned, launching an exhilarating production adventure.
Original concept
I really wanted to put together a commercial that felt polished and complete, a tall order as a one-man-band. From planning to execution, every detail was up to me: layout, modeling, texturing, animation, lighting, rendering, compositing and the final edit.
​
The initial sketch, shown to the left, was a crucial first step. It transformed the concept from something abstract into something tangible. Now it was more than just an idea - it was on paper. I knew the path ahead was going to be a challenge, but every project has to start somewhere.
Mood board
Color inspiration
Being part of the FX team at some of the largest VFX and animation studios around, I'm accustomed to joining high-profile projects well after initial planning is already well-established. Bianca Bar allowed me the opportunity to create something entirely from scratch and see it through to the end.
​
After the sketch I started a mood board, where I researched styles that might best suit my vision. This stage was transformative; as I sifted through inspiration, the vision kept evolving. I found that the biggest challenge wasn't adding more ideas but knowing when to limit them.
This discipline helped refine and focus the concept, bringing clarity to the vision I had in my head.
Modeling
The modeling phase began with a simple box, and with some SOPs procedural modeling it turned into a Bianca Bar. There were some tricky pieces to put together, but the process was fairly straight-forward.
Procedural modeling process
The next step after the base model was complete was figuring out how to fracture the bar so that it could break cleanly. This was done with a simple boolean fracture and a deformed grid. This gave a clean cut, but I wanted to have an interior "lip", because all the reference images I used had some sort of a lip to the break. I noticed the original tests rendered without the lip felt like they were lacking some photo-realistic quality. Once the lip was added, it helped ground the bar in reality more.
​
​
Fracture process
Let's talk a little bit about the spiral lines. I grabbed the bounding box of the bar geometry and from the end points I was able to make a line (that exactly fits the length of the candy bar). From that, I wrote some VEX code that allows for a spiral shape to take place. The cool thing about the code is it spirals along an arbitrary axis, making it fully procedural. I came up with this approach while working on Dr. Strange and the Multiverse of Madness.
Creating line along length
Spiral along length of line
The spiral requires a tangent vector and normal vector along the length of the curve, as well as a @curveu (again that useful 0-1 attribute along the length of a curve). Then with some custom parameters we can create a spiral to our liking. In this example it's quite simple.
VEX code for a spiral
It uses a two simple functions: sin and cos. Using that, we push the points in the direction tangent to the normal of the curve. It's super fast and can be run over thousands of curves in parallel. A decent base for 3D curly hair :)
​
After the curve is generated, it's converted to a VDB which is subtracted from the candy bar geometry to create those indentations. This small detail helps sell the realism, since these shots are all close-ups. We need every detail we can get. The texturing and rendering will be discussed later.
Spiral VDB subtraction
Specs (in red) were added for additional detail
Cocoa bean reference
For the cocoa beans, I first gathered some reference from Pinterest and Google. Then made a simple HDA that generates random cocoa beans based on artistic-driven parameters. This allowed for a consistent design across multiple variations while still generating a number of beans.
​
In this project I ended up using 5 separate designs of cocoa beans, and found that to be plenty of variety for what I needed.
Procedural cocoa beans
Animation
The animation was very simple, and I won't go into too much detail. I used two transform nodes to animate the rotation and translation of each of the two pieces to move them apart. A retime node was used to animate the speed of the animation. Then I simply framed it with a simple animated push in with the camera.
shot010 animation
FX
The FX in this project can only be broken down into five elements:
-
caramel (SOPs)
-
small breaking pieces (POPs)
-
chocolate drip (SOPs)
-
chocolate pour (FLIP)
-
caramel swirl (FLIP)
​
The first is the caramel drooping down as the bar is pulled apart. The second is the small "debris" pieces that break off and move around in slow-motion. The third is the chocolate droop in two separate shots. Let's take a look at each one independently.
​
Firstly let's break down the caramel.
Top is isolated
Matching points are connected
Lines are drooped
The top-inside piece is isolated using a simple boolean with a bounding box. This creates the simple geometry where we can further manipulate the isolated pieces. Points are then scattered on each side, making sure to scatter the same number of points on each side. These points are connected because they have a matching attribute, in this case id, but it can be any matching attribute. The trick is then making them droop, artificially simulating gravity. Let's take a look at that in more detail.
Animated line drooping
Line parabola on arbitrary axis
Any line in Houdini can be drooped, simulating gravity, quite easily. The VEX code is simple:
// control scale multiplier
float scale_mult = chf('scale_mult');
​
// @curveu is calculated from 0-1.0 along length of curve (arbitrary)
float u = @curveu;
// parabolic equation
u = 2.0*(u-0.5);
// droop points down in Y axis
v@P.y += -1*(1.0-u*u)* scale_mult;
The lines are then coalesced, which helps make the caramel feel more organic. This is done by running the lines through a for-each-number loop, in this case 6 iterations. The point positions are averaged together using a PC Open and PC Filter node inside a VOP, which averages the positions based on two main parameters: search radius and number of points. These were set as 0.3 and 800 respectively. The result is seen below, played back as iteration = $F so we can loop through each step to see the effect. The end result is only using the last step:
Coalescing points
The @pscale attribute is then created, using a remapped value of @curveu to determine the scale. Again the @curveu is a normalized (0-1) attribute along the length of each line. So we can taper in or out the scale based on this value. Below we can visualize the end result of the VDB operation, both before and after processing some smoothing to the final geometry.
​
Finally, velocity is transferred over to to the new mesh based on the animation.
VDB points
VDB smoothed
The next part of the FX we'll take a look at is the only simulation in the entire project. The small debris pieces, which is just a simple POP simulation.
POP sim
The sim is a very simple setup. The v@v is inherited from the animation + pushed toward the camera. However we're randomizing the velocity on the birth frame, which helps make the sim feel more organic and less CG. Since I want to instance geometry to the points post-sim (it's not a rigid body simulation), I want to add some sort of rotation or orient to the points so the geometry will look like it's rotating, which will make it look super dynamic given that we're slowing down the simulation mid-way through the shot.
​
I'll try to explain the VEX code for the spinning particles below:
vector up, rup, side;
​​
// normalize velocity
nv = normalize(v@v);
​
// define vectors
up = set(0,1,0);
side = cross(nv, up);
rup = cross(side, nv);
​
// axis is defined in the popspin node as rotation axis
axis = cross(rup, nv);
​​
// spinspeed is defined in popspin node as spin speed
spinspeed = fit01(rand(@id,23), 0.5, 1.0) * length(v@v);
We want to rotate the points along the perpendicular vector to their respective directions, or normalized velocity. To do this we just take the cross product of those vectors. But it's a global side vector, and we want a relative vector for each particle. So we cross again the Side vector with the normalized velocity. We get the up vector, then cross that with the directional vector again to get our spin axis, in this case called axis. It's easier to look at the code than understand my gibberish.
​
​The spin speed is then randomized per-particle to get variation within a degree of artistic control. Of course there's other nodes like drag and we're colliding with our bar geometry. But this is the gist of the simulation - keep it simple.
​
The third and final effect we'll talk about is the chocolate streak. This took me some time to figure out, because while it looks simple there's quite a few little gotchas that threw me for a loop.
shot070 chocolate streak
What made this particular effect so challenging? Well at first I wanted to make it a simulation, because after all that's the most logical thing, right?
Wrong!
​
The simplest way is not always the most intuitive, which was absolutely the case for this shot. Instead of a sim, I'm carving the spiral curve, and extracting the leading-edge point. A line is attached to this point, and drooped using the fake gravity code used for the caramel. The end result is super clean and easy to change.
Extracting the leading point
Breakdown of lines
Adding thickness to chocolate
The two curves are fused together, subdivided and then thickness is added by a simple Polywire node. I kept the colors to the left so you can visualize the transition.
​
Velocity was then transferred from the animated (blue) line and that's it. It's simple, but not so intuitive (at least for me).
The last two effects are the FLIP simulations. I won't go into detail with these as they're fairly straight-forward. The only challenge I had was the scale (both physical and time-scale). Something unique to the flip sims was the variable viscosity I was advecting through the sim. This allowed for both a more visually interesting simulation, as well as control in Nuke as a separate AOV. It's subtle, but you can feel it (is that too cliché?).
Viscosity AOV (I apologize for the compression)
Lighting
I'll go over lighting real quick, and maybe revisit compositing at a later date. But the lighting setup was very simple with one env light (hdri), a light coming from the top, and one from the bottom.
Viewport render
Lighting
The materials were super simple. Using the new COPs workflow, I was able to generate procedural textures with ease. The only two maps I used were Height and Specular, which provided enough variation for my taste for these shots.
Bump map
Specular map
Finally all the shots were cut together and edited in Davinci Resolve. I used AI voice as the VO, which was definitely fun to try out. Anyway, thanks for checking out the Bianca Bar project!