Göbekli Tepe Greenstone Amulet / Signet

Added noise displacement to ring after subdividing (5) : just the ring...not the pictograph

Archaeological Context & Identification

• Site: Göbekli Tepe (Southeastern Anatolia, Şanlıurfa Province, Turkey).

• Period: Pre-Pottery Neolithic A / B (PPNA / PPNB), circa 9600–8200 BCE.

• Material: Greenstone / serpentinite pebble, smoothed and incised.

• Find Context: Excavated by the German Archaeological Institute (DAI) team led by Klaus Schmidt. It is housed in the collection of the Şanlıurfa Archaeology Museum.

• Iconography:

  • The vertical dividing line mirrors the vertical seams seen on some T-shaped pillars.

  • The left incised figure is a serpent/snake motif, identical in posture to the relief snakes carved into Pillar 1 and Pillar 20 at Göbekli Tepe.

  • The upper right element is interpreted either as a schematic branch/tree or a stylized humanoid / aviary figure.

  • The lower right three-pronged motif is interpreted as a schematic claw, comb, trident, or standing figure.

In academic literature, rather than carrying a mythic proper name, it is cataloged and discussed as the "Göbekli Tepe Greenstone Amulet" or "PPN Incised Stone Plaquette from Göbekli Tepe".

Code Block Below (SIGNET RING)

import bpy
import bmesh
import math
from mathutils import Vector
bl_info = {
    "name": "Blank Signet Ring Generator",
    "author": "Assistant",
    "version": (2, 2),
    "blender": (3, 0, 0),
    "location": "View3D > Sidebar > Signet Ring",
    "description": "Generates a signet ring with a rounded, comfortable bottom shank and flat stamp bezel",
    "category": "Add Mesh",
}
def get_plate_xy(angle, half_w, half_l, shape, softness):
    """Calculates boundary coordinates on the top plate according to the chosen shape."""
    cos_a = math.cos(angle)
    sin_a = math.sin(angle)
if shape == 'ROUND':
    r = min(half_w, half_l)
    return cos_a * r, sin_a * r
elif shape == 'OVAL':
    return cos_a * half_w, sin_a * half_l
else:
    # Superellipse for Cushion and Rectangle
    n = 10.0 if shape == 'RECTANGLE' else (2.0 + (1.0 - softness) * 5.0)
    sign_x = 1.0 if cos_a >= 0 else -1.0
    sign_y = 1.0 if sin_a >= 0 else -1.0
    x = sign_x * half_w * (abs(cos_a) ** (2.0 / n))
    y = sign_y * half_l * (abs(sin_a) ** (2.0 / n))
    return x, y

def create_signet_ring_geometry(context):
    props = context.scene.signet_ring_props
# Scale factor to keep ring sized comfortably with the default cube
scale = 0.1

r_in = (props.inner_diameter / 2.0) * scale
shank_th = props.bottom_thickness * scale
shank_w = props.bottom_width * scale

top_head_th = props.top_thickness * scale
plate_half_l = (props.plate_length / 2.0) * scale  # Y axis (along finger direction)
plate_half_w = (props.plate_width / 2.0) * scale   # X axis (across finger)

flare_p = props.flare_power
shape = props.plate_shape
softness = props.corner_radius

# Grid resolution
num_rad = (props.segments // 4) * 4   # Around ring circle
num_cross = 12                        # Across the band width

obj_name = "Signet_Ring_Blank"
existing_obj = bpy.data.objects.get(obj_name)
if existing_obj:
    bpy.data.objects.remove(existing_obj, do_unlink=True)

mesh = bpy.data.meshes.new(obj_name + "_Mesh")
obj = bpy.data.objects.new(obj_name, mesh)
context.collection.objects.link(obj)

bm = bmesh.new()

# The finger hole is centered along the X axis (Y=0, Z=0)
# Angle theta sweeps around the finger:
# theta = -pi/2 (bottom: -Z), 0 (front: +Y), pi/2 (top: +Z), pi (back: -Y)

z_top_flat = r_in + top_head_th
grid = []

for i in range(num_rad):
    theta = -math.pi / 2.0 + (2.0 * math.pi * i) / num_rad
    
    # normalized vertical blend t: 0.0 at bottom (-Z), 1.0 at top (+Z)
    t_height = (math.sin(theta) + 1.0) / 2.0
    flare = math.pow(t_height, flare_p)

    # Inner ring surface (circular finger hole)
    y_in = math.cos(theta) * r_in
    z_in = math.sin(theta) * r_in

    # Band outer width (along X)
    half_w = (shank_w / 2.0) * (1.0 - flare) + plate_half_w * flare

    # Outer radial profile (rounded bottom shank transitioning to flat top)
    r_out_base = r_in + shank_th
    y_out_natural = math.cos(theta) * (r_out_base * (1.0 - flare) + (r_in + top_head_th) * flare)
    z_out_natural = math.sin(theta) * (r_out_base * (1.0 - flare) + (r_in + top_head_th) * flare)

    # Near the top, clamp and shape onto the flat stamping plane
    if t_height > 0.65:
        top_blend = (t_height - 0.65) / 0.35
        top_blend = top_blend * top_blend  # smooth ease-in
        
        # Map theta to plate parameter angle phi
        phi = math.atan2(y_out_natural, 1e-4 if abs(z_out_natural) < 1e-4 else z_out_natural)
        px, py = get_plate_xy(phi, half_w, plate_half_l, shape, softness)
        
        z_outer = z_out_natural * (1.0 - top_blend) + z_top_flat * top_blend
        y_outer = y_out_natural * (1.0 - top_blend) + py * top_blend
        half_w = half_w * (1.0 - top_blend) + abs(px) * top_blend
    else:
        z_outer = z_out_natural
        y_outer = y_out_natural

    # Generate cross-section loop with comfort-fit curved edges across width
    ring_loop = []
    for c in range(num_cross):
        # u goes from -1 to 1 across the width of the band
        u = -1.0 + (2.0 * c) / (num_cross - 1)
        
        # Inner comfort rounding factor
        comfort_arch = math.sqrt(max(0.0, 1.0 - 0.5 * (u ** 2)))
        x_pos = u * half_w

        # Lower half / shank: rounded D-profile on the outside
        # Top half: straightens out to make the flat bezel
        if t_height < 0.65:
            # Crown curvature for outside of shank
            dome = (1.0 - u * u) * 0.15 * shank_th
            z_cur = z_in + (z_outer - z_in) * comfort_arch + dome * math.sin(theta)
            y_cur = y_in + (y_outer - y_in) * comfort_arch + dome * math.cos(theta)
        else:
            z_cur = z_in + (z_outer - z_in)
            y_cur = y_in + (y_outer - y_in)

        v = bm.verts.new((x_pos, y_cur, z_cur))
        ring_loop.append(v)
        
    grid.append(ring_loop)

# Bridge the outer surface grid
for i in range(num_rad):
    next_i = (i + 1) % num_rad
    for c in range(num_cross - 1):
        v0 = grid[i][c]
        v1 = grid[next_i][c]
        v2 = grid[next_i][c + 1]
        v3 = grid[i][c + 1]
        bm.faces.new((v0, v1, v2, v3))

# Inner finger surface
inner_grid = []
for i in range(num_rad):
    theta = -math.pi / 2.0 + (2.0 * math.pi * i) / num_rad
    t_height = (math.sin(theta) + 1.0) / 2.0
    flare = math.pow(t_height, flare_p)
    half_w = (shank_w / 2.0) * (1.0 - flare) + plate_half_w * flare
    
    y_in = math.cos(theta) * r_in
    z_in = math.sin(theta) * r_in

    inner_loop = []
    for c in range(num_cross):
        u = -1.0 + (2.0 * c) / (num_cross - 1)
        v = bm.verts.new((u * half_w, y_in, z_in))
        inner_loop.append(v)
    inner_grid.append(inner_loop)

# Bridge inner surface
for i in range(num_rad):
    next_i = (i + 1) % num_rad
    for c in range(num_cross - 1):
        v0 = inner_grid[i][c]
        v1 = inner_grid[i][c + 1]
        v2 = inner_grid[next_i][c + 1]
        v3 = inner_grid[next_i][c]
        bm.faces.new((v0, v1, v2, v3))

# Close left and right sides
for i in range(num_rad):
    next_i = (i + 1) % num_rad
    # Left side (c = 0)
    bm.faces.new((grid[i][0], inner_grid[i][0], inner_grid[next_i][0], grid[next_i][0]))
    # Right side (c = num_cross - 1)
    bm.faces.new((grid[i][-1], grid[next_i][-1], inner_grid[next_i][-1], inner_grid[i][-1]))

# Flatten and weld top table vertices to guarantee a level stamp face
top_verts = []
for loop in grid:
    for v in loop:
        if v.co.z >= z_top_flat - 0.02:
            v.co.z = z_top_flat
            top_verts.append(v)

bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
bm.to_mesh(mesh)
bm.free()

# Modifiers: Bevel + Subsurf for smooth jewelry finish
bevel_mod = obj.modifiers.new(name="CornerBevel", type='BEVEL')
bevel_mod.width = 0.03
bevel_mod.segments = 2
bevel_mod.limit_method = 'ANGLE'
bevel_mod.angle_limit = math.radians(40.0)

subsurf = obj.modifiers.new(name="Subdivision", type='SUBSURF')
subsurf.levels = 1
subsurf.render_levels = 2

for poly in mesh.polygons:
    poly.use_smooth = True

context.view_layer.objects.active = obj
obj.select_set(True)

----------------- PROPERTY GROUP -----------------
class SignetRingProperties(bpy.types.PropertyGroup):
    inner_diameter: bpy.props.FloatProperty(
        name="Inner Ring Diameter",
        description="Inner hole size (e.g. 18-20 fits around the 2m default cube scale)",
        default=19.0,
        min=10.0,
        max=32.0,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    flare_power: bpy.props.FloatProperty(
        name="Shoulder Flare",
        description="Controls taper from band to face. 1.5 = gradual/beefy, 3.0+ = sharp taper",
        default=2.0,
        min=1.0,
        max=5.0,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    plate_shape: bpy.props.EnumProperty(
        name="Top Shape",
        description="Shape of the stamp table",
        items=[
            ('CUSHION', "Cushion", "Traditional rounded rectangle"),
            ('OVAL', "Oval", "Classic oval seal"),
            ('ROUND', "Round", "Circular stamp surface"),
            ('RECTANGLE', "Rectangle", "Flat rectangular plate"),
        ],
        default='ROUND',
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    plate_length: bpy.props.FloatProperty(
        name="Top Length",
        description="Length of seal table (along finger)",
        default=14.0,
        min=5.0,
        max=30.0,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    plate_width: bpy.props.FloatProperty(
        name="Top Width",
        description="Width of seal table (across finger)",
        default=16.0,
        min=5.0,
        max=30.0,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    top_thickness: bpy.props.FloatProperty(
        name="Head Thickness",
        description="Height of the top face above the inner finger band",
        default=3.5,
        min=1.2,
        max=10.0,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    bottom_width: bpy.props.FloatProperty(
        name="Shank Width",
        description="Width of band at the bottom",
        default=4.5,
        min=2.0,
        max=12.0,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    bottom_thickness: bpy.props.FloatProperty(
        name="Shank Thickness",
        description="Radial thickness of the band under the finger",
        default=1.8,
        min=0.8,
        max=5.0,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    corner_radius: bpy.props.FloatProperty(
        name="Corner Softness",
        description="Corner rounding for cushion/rectangle shapes",
        default=0.4,
        min=0.05,
        max=0.95,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
    segments: bpy.props.IntProperty(
        name="Mesh Segments",
        description="Band polygon resolution (multiples of 4)",
        default=64,
        min=32,
        max=128,
        update=lambda s, c: create_signet_ring_geometry(c)
    )
----------------- UI PANEL -----------------
class OBJECT_PT_SignetRingPanel(bpy.types.Panel):
    bl_label = "Signet Ring Generator"
    bl_idname = "OBJECT_PT_signet_ring"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'Signet Ring'
def draw(self, context):
    layout = self.layout
    props = context.scene.signet_ring_props

    col = layout.column(align=True)
    col.label(text="Finger Band (Shank)", icon='SNAP_FACE')
    col.prop(props, "inner_diameter")
    col.prop(props, "bottom_thickness")
    col.prop(props, "bottom_width")

    layout.separator()
    col = layout.column(align=True)
    col.label(text="Blank Stamp Bezel", icon='MESH_PLANE')
    col.prop(props, "plate_shape")
    col.prop(props, "plate_width")
    col.prop(props, "plate_length")
    col.prop(props, "top_thickness")
    if props.plate_shape in {'CUSHION', 'RECTANGLE'}:
        col.prop(props, "corner_radius")

    layout.separator()
    col = layout.column(align=True)
    col.label(text="Flare & Geometry", icon='MOD_CURVE')
    col.prop(props, "flare_power")
    col.prop(props, "segments")

    layout.separator()
    layout.operator("mesh.generate_signet_ring", text="Rebuild Ring", icon='FILE_REFRESH')

class MESH_OT_GenerateSignetRing(bpy.types.Operator):
    bl_idname = "mesh.generate_signet_ring"
    bl_label = "Generate Signet Ring"
    bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
    create_signet_ring_geometry(context)
    return {'FINISHED'}

classes = (
    SignetRingProperties,
    OBJECT_PT_SignetRingPanel,
    MESH_OT_GenerateSignetRing,
)
def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.Scene.signet_ring_props = bpy.props.PointerProperty(type=SignetRingProperties)
def unregister():
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)
    del bpy.types.Scene.signet_ring_props
if name == "main":
    register()
    create_signet_ring_geometry(bpy.context)