Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash· GoogleHugging Face LMArena Human Preference 140K

write a maxscript plugin (scripted modifier) like a spherify

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with DeepSeekdeepseek-v3-0324’s answer.
  1. User

    write a maxscript plugin (scripted modifier) like a spherify

  2. Gemini Assistant

    Okay, here's a MaxScript scripted modifier that works like a "spherify" effect.

    How it works:

    1. Calculates a Center: It determines a central point (either the object's calculated average vertex center or a user-defined point).
    2. Iterates Vertices: For each vertex in the mesh:
      • It calculates the vector from the chosen center to the vertex.
      • It normalizes this vector (makes it a unit length direction).
      • It then moves the vertex along this normalized vector, out to a specified Radius from the center.
    3. Applies Strength: A Strength parameter allows you to blend between the original vertex position and the fully spherified position, creating a softer effect.

    MaxScript Code:

    To use this, open the MaxScript Editor (F11), paste the entire code, and then run it (Ctrl+E or Tools > Evaluate All).

    -- Define the Spherify Modifier Plugin
    plugin SimpleMod SpherifyMod category:"Modifiers"
    (
        -- PARAMETERS BLOCK
        -- This defines the parameters that will appear in the modify panel
        parameters main rollout:params_rollout
        (
            strength type:#float default:1.0 ui:strength_sld
            radius type:#worldUnits default:50.0 ui:radius_spn
            useObjectCenter type:#boolean default:true ui:useObjCenter_chk
            center type:#point3 default:[0,0,0] ui:center_spn
        )
    
        -- ROLLOUT BLOCK
        -- This defines the user interface for the modifier
        rollout params_rollout "Spherify Parameters"
        (
            slider strength_sld "Strength" range:[0,1,1.0] type:#float \
                tooltip:"How much to spherify (0 = no effect, 1 = full spherify)"
            spinner radius_spn "Radius" range:[0,1000000,50.0] type:#worldUnits \
                tooltip:"The target radius of the sphere"
    
            checkbox useObjCenter_chk "Use Object Center" checked:true \
                tooltip:"If checked, the spherify will center on the object's average vertex position. If unchecked, use the 'Spherify Center' below."
            spinner center_spn "Spherify Center" type:#point3 default:[0,0,0] \
                tooltip:"The object-space coordinate for the spherify center (only used if 'Use Object Center' is off)"
    
            -- Event handler for when the 'Use Object Center' checkbox changes
            on useObjCenter_chk changed state do
            (
                -- Enable/disable the 'center_spn' based on the checkbox state
                center_spn.enabled = not state
            )
        )
    
        -- ON CREATE EVENT
        -- This runs once when the modifier is first applied or loaded
        on create do
        (
            -- Initial update of the UI enable state for the center spinner
            -- (This ensures it's correctly disabled if useObjectCenter is true by default)
            params_rollout.center_spn.enabled = not useObjectCenter
        )
    
        -- ON MODIFY EVENT
        -- This is the core logic that runs whenever a parameter changes or the mesh updates
        on modify do
        (
            -- Get the node (object) the modifier is applied to
            local node = modContext.node
            -- Get the mesh data from the node
            local mesh = node.mesh
            
            -- --- SAFETY CHECKS ---
            -- If the mesh is undefined or has no vertices, there's nothing to do
            if mesh == undefined or mesh.numverts == 0 do return
    
            -- --- DETERMINE THE SPHERIFY CENTER ---
            local calculatedCenter = [0,0,0]
    
            if useObjectCenter then
            (
                -- Calculate the average position of all vertices as the center
                -- This works well for most objects
                for i = 1 to mesh.numverts do
                (
                    calculatedCenter += mesh.verts[i].pos
                )
                -- Avoid division by zero if for some reason numverts is 0 (though checked above)
                if mesh.numverts > 0 then
                (
                    calculatedCenter /= mesh.numverts
                )
            )
            else
            (
                -- Use the user-defined center parameter
                -- This 'center' is interpreted in the object's local space
                calculatedCenter = center
            )
    
            -- --- ITERATE THROUGH EACH VERTEX AND APPLY THE EFFECT ---
            for i = 1 to mesh.numverts do
            (
                local originalPos = mesh.verts[i].pos      -- Get the current vertex position
                local vec = originalPos - calculatedCenter  -- Vector from center to vertex
                local currentDist = length vec              -- Current distance from center
    
                local targetPos                             -- The desired spherified position
    
                -- If the vertex is not exactly at the center (to avoid division by zero)
                if currentDist > 0.00001f then -- Use a small epsilon to handle floating point inaccuracies
                (
                    local normalizedVec = normalize vec             -- Get the direction as a unit vector
                    targetPos = calculatedCenter + (normalizedVec * radius) -- New position at desired radius
                )
                else
                (
                    -- If the point is exactly at the center, we can't normalize.
                    -- Push it out along a default axis (e.g., Z) to the target radius from the center.
                    -- This ensures it still gets moved to the sphere surface.
                    targetPos = calculatedCenter + [0,0,radius] 
                )
    
                -- Interpolate between the original position and the target spherified position
                -- based on the 'strength' parameter.
                -- strength = 0: newPos = originalPos
                -- strength = 1: newPos = targetPos
                local newPos = originalPos + (targetPos - originalPos) * strength
                
                -- Update the vertex position in the mesh
                mesh.verts[i].pos = newPos
            )
    
            -- --- FINALIZE MESH UPDATES ---
            -- Tell 3ds Max that the mesh geometry has changed and needs to be redrawn
            update mesh
            -- Invalidate internal caches (like normals, bounding box, etc.) for correct display
            mesh.InvalidateGeomCache()
        )
    )
    

    How to Use After Running the Script:

    1. Create an Object: Create any primitive object in 3ds Max (e.g., a Box, Sphere, Teapot).
    2. Go to Modify Panel: Select the object, and go to the Modify tab in the Command Panel.
    3. Add Modifier: In the Modifier List dropdown, you should now see SpherifyMod under the "Modifiers" category (or "Simple Mod" if you change the category in the script). Select it.
    4. Adjust Parameters:
      • Strength: Drag the slider from 0 to 1 to see the spherify effect blend in.
      • Radius: Change the spinner value to control the size of the target sphere.
      • Use Object Center:
        • If checked (default), the spherify will happen around the geometric center of your object.
        • If unchecked, you can manually input an object-space Spherify Center (meaning relative to the object's pivot).

    Important Notes:

    • Object Space: This modifier operates in the object's local coordinate space. This means if you move or rotate the object after applying the modifier, the spherify effect will move/rotate with it correctly. The center parameter, when useObjectCenter is off, refers to coordinates within this local space.
    • Performance: For very dense meshes, MaxScript-based modifiers can be slower than native C++ modifiers. For most typical uses, it should be perfectly fine.
    • Undo/Redo: MaxScript modifiers fully support undo/redo functionality.
    • Saving: Once you run the script, the modifier becomes available for the current 3ds Max session. To make it permanently available across sessions, save the script as a .ms file in your 3ds Max startup folder (usually C:\Program Files\Autodesk\3ds Max 20xx\scripts\startup).

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.