Vol. 1 · No. 338Blender 3.6 / 4.2 / 4.5 / 5.0 / 5.2 / 5.3Cycles · EEVEE
JANCTION
Render · Blender on RTX PRO 6000 · Tokyo
0.1 JPYper GPU-secondFirst 100 JPYfree, no card

Case No. 1  Product shot

A glass bottle on a studio backdrop

One bpy script, one call, a square product still with glass and liquid that reads as real.

● Product shot · CyclesRTX PRO 6000 · Tokyo
Product shot: a glass bottle
Cycles1440 × 1440Samples 128PNG still
Fig. — Product shot: a glass bottle. A real render from the production GPU.
The short answer

This product still of a glass bottle was rendered with Cycles on a JANCTION GPU from a single bpy script. The script builds only the bottle, the backdrop and the camera; the service sets resolution, samples, denoising and the GPU, and the studio preset supplies the light. It took 166.5 GPU seconds on the production GPU, 16.7 JPY at 0.1 JPY per GPU-second.

What is in the frame

A bottle with a label and amber liquid stands on a seamless white sweep. The glass picks up the soft studio reflections and the liquid shows through it. It is the kind of image a store page needs before the physical sample exists.

How the scene is built

The script only builds the scene, the camera and the frame range. Everything that decides quality (resolution, sample count, denoising, which GPU) is set by the service when the job runs, so the same script can produce a quick preview or a 1440 px final.

Adapt it

Change the bottle profile or the label colour in the script, keep the studio preset, and ask for a 4-frame preview first. The preview comes back with a verdict, so a dark or clipped image is caught before you pay for the final.

16.7 JPY for this render. The free welcome credit of a new key covers about 6 of them, with no card.

Render this example with your AI

ChatGPT · Claude · Grok · Perplexity

Use JANCTION Render (MCP server https://render.janction.jp/mcp) to render this example: render_preview(scene_url="https://render.janction.jp/samples/ex01_product_bottle.py"). Then suggest how to change the colors, shapes and camera for my own subject. Ask me before the final render.

Each link opens the app with the text below filled in (if it is not, copy and paste it). If JANCTION Render is not connected in that app yet, add https://render.janction.jp/mcp as a connector first.

Blender warnings

  • environment preset 'studio' replaced the scene's world (HDRI lighting)

The script (bpy, runs as is)

ex01_product_bottle.py. It builds the scene, the camera and the frame range; resolution, samples, denoising and the GPU are set by the service.

"""JANCTION Render example 01: product shot of a glass bottle on a studio backdrop (one still).

Reproduce: render_final(scene_url="https://render.janction.jp/samples/ex01_product_bottle.py",
                        width=1440, height=1440, samples=128, environment="studio")
The service sets resolution, samples, denoising and the GPU; this script only builds the scene,
the camera and the frame range.
"""
import math

import bpy
from mathutils import Vector

for ob in list(bpy.data.objects):
    bpy.data.objects.remove(ob, do_unlink=True)
scene = bpy.context.scene
scene.frame_start = 1
scene.frame_end = 1


def material(name, color, roughness=0.5, metallic=0.0, **inputs):
    mat = bpy.data.materials.new(name)
    mat.use_nodes = True
    bsdf = mat.node_tree.nodes["Principled BSDF"]
    bsdf.inputs["Base Color"].default_value = (*color, 1.0)
    bsdf.inputs["Roughness"].default_value = roughness
    bsdf.inputs["Metallic"].default_value = metallic
    for key, value in inputs.items():
        bsdf.inputs[key].default_value = value
    return mat


def smooth(ob):
    for p in ob.data.polygons:
        p.use_smooth = True
    return ob


def add(op, name, mat=None, **kw):
    getattr(bpy.ops.mesh, op)(**kw)
    ob = bpy.context.object
    ob.name = name
    if mat is not None:
        ob.data.materials.append(mat)
    return ob


def look_at(ob, target):
    ob.rotation_euler = (Vector(target) - ob.location).to_track_quat("-Z", "Y").to_euler()


def camera(location, target, lens=50.0, sensor_fit="AUTO"):
    data = bpy.data.cameras.new("Camera")
    data.lens = lens
    # VERTICAL keeps the same vertical framing at any aspect: the square final (1440x1440) and the 16:9 preview (1280x720)
    # both show the whole bottle (AUTO fitted the width, so the wide preview cut off the cap)
    data.sensor_fit = sensor_fit
    if sensor_fit == "VERTICAL":
        data.sensor_height = 24.0
    cam = bpy.data.objects.new("Camera", data)
    scene.collection.objects.link(cam)
    cam.location = location
    look_at(cam, target)
    scene.camera = cam
    return cam


def light(name, kind, location, energy, target=None, size=1.0, color=(1.0, 1.0, 1.0)):
    data = bpy.data.lights.new(name, kind)
    data.energy = energy
    data.color = color
    if kind == "AREA":
        data.size = size
    ob = bpy.data.objects.new(name, data)
    scene.collection.objects.link(ob)
    ob.location = location
    if target is not None:
        look_at(ob, target)
    return ob


glass = material("Glass", (0.85, 0.95, 0.92), roughness=0.04, **{"Transmission Weight": 1.0, "IOR": 1.45})
liquid = material("Liquid", (0.95, 0.55, 0.12), roughness=0.08, **{"Transmission Weight": 1.0, "IOR": 1.36})
cap = material("Cap", (0.03, 0.03, 0.03), roughness=0.45)
paper = material("Label", (0.96, 0.94, 0.88), roughness=0.7)
floor = material("Floor", (0.82, 0.82, 0.8), roughness=0.3)
wall = material("Wall", (0.9, 0.9, 0.88), roughness=0.8)

# The backdrop colour for camera rays only (11/12): a turntable of this sample (orbit=True) hides the backdrop wall on the
# frames where the camera passes behind it, and the camera then sees the world. Light from the world is unchanged, so the
# still render looks the same as before.
world = scene.world or bpy.data.worlds.new("World")
scene.world = world
world.use_nodes = True
wn, wl = world.node_tree.nodes, world.node_tree.links
for n in list(wn):
    wn.remove(n)
w_out = wn.new("ShaderNodeOutputWorld")
w_light = wn.new("ShaderNodeBackground")
w_light.inputs["Color"].default_value = (0.05, 0.05, 0.05, 1.0)
w_seen = wn.new("ShaderNodeBackground")
w_seen.inputs["Color"].default_value = (0.62, 0.62, 0.6, 1.0)
w_path = wn.new("ShaderNodeLightPath")
w_mix = wn.new("ShaderNodeMixShader")
wl.new(w_path.outputs["Is Camera Ray"], w_mix.inputs["Fac"])
wl.new(w_light.outputs["Background"], w_mix.inputs[1])
wl.new(w_seen.outputs["Background"], w_mix.inputs[2])
wl.new(w_mix.outputs["Shader"], w_out.inputs["Surface"])

add("primitive_plane_add", "Floor", floor, size=24)
back = add("primitive_plane_add", "Backdrop", wall, size=24, location=(0, 4, 6))
back.rotation_euler = (math.pi / 2, 0, 0)

body = add("primitive_cylinder_add", "Bottle", glass, radius=0.5, depth=2.0, location=(0, 0, 1.0), vertices=96)
bev = body.modifiers.new("Bevel", "BEVEL")
bev.width = 0.12
bev.segments = 10
smooth(body)
neck = add("primitive_cylinder_add", "Neck", glass, radius=0.17, depth=0.7, location=(0, 0, 2.3), vertices=64)
smooth(neck)
inner = add("primitive_cylinder_add", "Liquid", liquid, radius=0.45, depth=1.55, location=(0, 0, 0.85), vertices=96)
smooth(inner)
top = add("primitive_cylinder_add", "Cap", cap, radius=0.21, depth=0.28, location=(0, 0, 2.78), vertices=64)
smooth(top)
label = add("primitive_cylinder_add", "Label", paper, radius=0.505, depth=0.62, location=(0, 0, 0.95), vertices=96,
            end_fill_type="NOTHING")
smooth(label)

light("Key", "AREA", (3.0, -3.0, 4.0), 450, target=(0, 0, 1.2), size=2.5)
light("Rim", "AREA", (-3.0, 3.0, 3.0), 250, target=(0, 0, 1.4), size=1.5, color=(0.9, 0.95, 1.0))
camera((0.0, -7.8, 1.5), (0.0, 0.0, 1.45), lens=50, sensor_fit="VERTICAL")

Questions about this case

Can I render a product shot without owning a GPU?

Yes. Send a bpy script, a .blend or a 3D file to JANCTION Render; it renders on NVIDIA GPUs in the cloud and returns a PNG. Previews are free up to 2 GPU-minutes a day after the welcome credit.

Which lighting does the product shot use?

The bundled studio preset, a CC0 HDRI from Poly Haven that replaces the scene's world. Pass environment="studio".

More from the Journal