How To Get The Star Jelly On The Blender

Star Jelly is a feature often encountered in the context of animation and visual effects within Blender, a free and open-source 3D creation suite. Achieving a Star Jelly effect, typically characterized by a translucent, wobbly, and often colorful appearance, necessitates combining several Blender functionalities. This article delineates the steps required to create such an effect.

Setting Up the Base Object

The initial phase involves creating the underlying object that will embody the Star Jelly. A sphere is a commonly used starting point; however, more complex shapes are viable.

Creating a Sphere

To create a sphere, proceed as follows:

1. Open Blender. The default scene typically contains a cube. Delete this by pressing 'X' and confirming the deletion.
2. Press 'Shift+A' to open the 'Add' menu.
3. Navigate to 'Mesh' and select 'UVSphere'. This adds a UV sphere to the scene.

Adjusting the sphere's subdivisions is crucial. More subdivisions result in a smoother surface, enhancing the final jelly-like appearance. This adjustment is done in the operator panel, which appears in the lower-left corner after adding the sphere. Modify the 'Segments' and 'Rings' values, typically increasing them to a range between 32 and 64 for a high-quality result.

Shaping the Object

The sphere can be deformed to create a more organic and less uniform appearance. Enter 'Edit Mode' by pressing 'Tab'. Utilize proportional editing to subtly distort the sphere. Proportional editing influences vertices near the selected vertex. To activate proportional editing, press 'O' and choose a falloff type like 'Smooth'. Select a vertex and move it; the surrounding vertices will move along, creating a smooth deformation.

Creating the Material

The material is responsible for the visual characteristics of the Star Jelly, including translucency, color, and surface properties. The 'Principled BSDF' shader is a versatile choice for this purpose.

Setting Up the Principled BSDF Shader

To configure the material, adhere to these steps:

1. Select the object.
2. Navigate to the 'Material Properties' tab in the Properties editor. It is the icon resembling a checkered sphere.
3. Click 'New' to create a new material.
4. Rename the material to something descriptive, such as "StarJellyMaterial".
5. Ensure the 'Surface' parameter is set to 'Principled BSDF'.

Adjusting Material Properties

Several properties of the 'Principled BSDF' shader must be adjusted to emulate the Star Jelly's appearance.

• Base Color: Set the base color to the desired hue for the jelly. A vibrant color contributes to the overall effect.
• Subsurface: Increase the 'Subsurface' value. This allows light to scatter within the object, creating a translucent effect. A value between 0.5 and 0.8 is a good starting point.
• Subsurface Radius: Adjust the 'Subsurface Radius' to control the color of the scattered light. Different values for the red, green, and blue channels can create interesting color variations. For instance, setting the radius to (1.0, 0.5, 0.2) will result in a red-tinted subsurface scattering.
• IOR (Index of Refraction): Lower the IOR slightly to create a softer, less defined surface. A value around 1.3 is suitable.
• Roughness: Increase the 'Roughness' to scatter the light more diffusely, enhancing the soft appearance. A value between 0.2 and 0.4 is appropriate.
• Transmission: A small amount of 'Transmission' can further enhance translucency, though it should be used sparingly to avoid making the object appear glassy.

Adding Detail with Noise Texture

To add surface imperfections and visual interest, a noise texture can be incorporated into the material.

Using Noise Texture for Bump Mapping

To apply a noise texture for bump mapping, perform the following:

1. In the Shader Editor (accessed by changing the editor type to 'Shader Editor'), add a 'Noise Texture' node (Shift+A -> Texture -> Noise Texture).
2. Add a 'Bump' node (Shift+A -> Vector -> Bump).
3. Connect the 'Fac' output of the 'Noise Texture' node to the 'Height' input of the 'Bump' node.
4. Connect the 'Normal' output of the 'Bump' node to the 'Normal' input of the 'Principled BSDF' node.

Adjust the 'Scale' and 'Detail' parameters of the 'Noise Texture' node to control the size and complexity of the surface imperfections. Lower scales create larger bumps, while higher scales create finer details. Adjust the 'Strength' parameter of the 'Bump' node to control the intensity of the bump effect.

Adding Color Variation with Noise Texture

A noise texture can also be used to introduce subtle color variations across the surface.

1. Add a 'ColorRamp' node (Shift+A -> Converter -> ColorRamp).
2. Connect the 'Fac' output of the 'Noise Texture' node to the 'Fac' input of the 'ColorRamp' node.
3. Add a 'Mix Color' node (Shift+A -> Color -> Mix Color).
4. Connect the 'Color' output of the 'ColorRamp' node to one of the color inputs of the 'Mix Color' node. Connect the 'Base Color' to the other color input of the 'Mix Color' node.
5. Connect the 'Color' output of the 'Mix Color' node to the 'Base Color' input of the 'Principled BSDF' node.

Within the 'ColorRamp' node, add multiple color stops to create a gradient. The noise texture will then interpolate between these colors, producing a varied surface color. Adjust the 'Factor' of the 'Mix Color' node to control the strength of the color variation.

Adding Animation with Simulation Nodes (Geometry Nodes)

To create the wobbly, jelly-like movement, simulation nodes within geometry nodes are used to simulate a soft body effect. Geometry nodes provide procedural control over the object's geometry.

Setting up a Simulation Zone

First, establish a geometry node network and a simulation zone:

1. Select the object.
2. Go to the 'Geometry Nodes' tab.
3. Click 'New' to create a new geometry node network.
4. Add a 'Simulation Input' and 'Simulation Output' node (Shift+A -> Utilities -> Simulation Input/Output).
5. Connect the 'Geometry' output of the 'Simulation Input' to the 'Geometry' input of the 'Simulation Output'. Connect the 'Geometry' output of the 'Group Input' to the 'Simulation Input' node. Finally, connect the 'Geometry' output of the 'Simulation Output' to the 'Group Output' node.

Applying a Position Modifier

Inside the simulation zone, apply a random offset to each point to simulate movement.

1. Add a 'Set Position' node (Shift+A -> Set -> Set Position). Place it between the simulation input and output.
2. Add a 'Noise Texture' node (Shift+A -> Texture -> Noise Texture).
3. Add a 'Vector Math' node set to 'Subtract' (Shift+A -> Utilities -> Vector Math).
4. Add a 'Vector Math' node set to 'Multiply' (Shift+A -> Utilities -> Vector Math).
5. Connect the 'Geometry' input of the 'Set Position' node. Connect the 'Position' input of the 'Set Position' node to the simulation input. Connect the 'Vector' output of the 'Set Position' node to the 'Geometry' input of the 'Simulation Output'.
6. Set the scale of the 'Noise Texture' node to a small value, such as 2.
7. Connect the 'Color' output of the 'Noise Texture' to the 'Vector' input of the 'Subtract' node. Set the second input to (0.5, 0.5, 0.5). This centers the values around zero.
8. Connect the 'Vector' output of the 'Subtract' node to the 'Vector' input of the 'Multiply' node. Add a 'Value' node to the second input to control the intensity.
9. Connect the 'Vector' output of the 'Multiply' node to the 'Offset' input of the 'Set Position' node.

Adding Time Dependency for Animation

To make the noise evolve over time, incorporate the frame number into the 'Noise Texture'.

1. Add a 'Scene Time' node (Shift+A -> Input -> Scene Time).
2. Add a 'Vector Math' node set to 'Add' (Shift+A -> Utilities -> Vector Math).
3. Add a 'Position' node.
4. Connect the 'Frame' output of the 'Scene Time' node to one of the 'Vector' inputs of the 'Add' node, creating a new 'Value' node. Adjust to a small value.
5. Connect the 'Position' output of the 'Position' node to the other 'Vector' inputs of the 'Add' node.
6. Connect the 'Vector' output of the 'Add' node to the 'Vector' input of the 'Noise Texture' node.

Adjust the settings on the noise texture to get a smooth animation. Change the 'W' value to add more complexity.

Lighting and Rendering

The lighting setup significantly influences the final appearance of the Star Jelly. Using subsurface scattering requires a well-lit scene to accentuate the translucent effect. Using Eevee requires enabling Screen Space Reflections and Refraction. Enabling Bloom adds a soft glow effect.

Rendering Settings

To render the Star Jelly, configure the following settings:

• Render Engine: Choose either Cycles or Eevee. Cycles produces more realistic results, especially with subsurface scattering, but requires more processing power. Eevee is faster but may require adjustments to achieve the desired effect.
• Samples (Cycles): Increase the number of samples to reduce noise. A value between 256 and 512 is generally sufficient.
• Screen Space Reflections and Refraction (Eevee): Enable these options in the Render Properties tab to simulate reflections and refractions, enhancing the translucent appearance.

Practical Advice

• Experimentation: The key to achieving the desired Star Jelly effect lies in experimentation. Adjust the material properties, noise texture settings, and lighting to achieve the desired look.
• Performance: Complex materials and geometry node setups can impact rendering performance. Optimize the scene by reducing the number of subdivisions, simplifying the material, or using lower-resolution textures.
• Compositing: Use the Compositor to further enhance the rendered image. Adding effects such as glare, bloom, or color correction can significantly improve the final result.