Difference between revisions of "Linkset resizer with menu"

From Second Life Wiki
Jump to: navigation, search
(modernize the script)
(the trick explained no longer works, provide link)
 
Line 186: Line 186:
 
----
 
----
  
==== Crunching and Inflating ====
+
For information about using a resizer to handle nanoprims, check this older version: [http://wiki.secondlife.com/w/index.php?title=Linkset_resizer_with_menu&oldid=1194741#Crunching_and_Inflating]
 
+
* This is an addition by [[User:Kira Komarov|Kira Komarov]] to the former script by [[User:Brilliant Scientist|Brilliant Scientist]].
+
 
+
I have been faced with the following problem: [[User:Stephen Xootfly|Stephen Xootfly]] handed me a representation of a caffeine molecule. I wanted to scale that molecule down so that I may create a necklace out of it. This is what the molecule looks like in comparison to my avatar:
+
 
+
[[File:Resize_-_Comparison.png|800px]]
+
 
+
On the lower right, you can see the result after using the script above and using the minimal size option AND replacing the molecules and bindings with a set of nanoprims that I carry around. Here is a blow-up so you can see what it looks like after those operations:
+
 
+
[[File:Resize_-_BadCrunch.png|800px]]
+
 
+
As you can see, the distances between the bindings and the atoms are relatively larger than in the original picture. This is NOT because the script above does not function correctly. The script above functions correctly however, by replacing the atoms and bindings with their equivalent nanoprim-sized sculpt shapes, I have thereby increased the "visible distance" artificially. In other words, the primitives are still the same size but by using nanoprims only a subpart of that is visible.
+
 
+
One way to solve this problem, would have been to roll-up my sleeves and start manually putting each molecule and binding in place. I went as far as doing one peripheral cluster and then I gave up. This would have wasted probably the rest of my day...
+
 
+
So, I took again at the script above and wondered how the script repositions the primitives after it has scaled them. The key is to be found in the script above, at this line:
+
 
+
<source lang="lsl2">
+
link_positions += [(link_pos-llGetRootPosition())/llGetRootRotation()];
+
</source>
+
 
+
which repositions the primitive relative to the root position.
+
 
+
Since I used n_20-size nanoprims for bindings between atoms, n_10-size nanoprims for small atoms and n_5-size nanoprims for large atoms, I figured that in fact, I am just inducing an error by a factor of 5.  
+
 
+
To fix the problem, I used the script as it is to scale the molecule to its maximum size, after I had scaled it down and replaced the atoms and bindings with nanoprims. I then edited the script and alter it in order to take the factor out:
+
 
+
<source lang="lsl2">
+
link_positions += [(link_pos/5-llGetRootPosition())/llGetRootRotation()];
+
</source>
+
 
+
And then I clicked the gigantic molecule and selected "minimum size" to crunch it back into place, hoping to eliminate that factor of 5. This is the result:
+
 
+
[[File:Resize_-_GoodCrunch.png|800px]]
+
 
+
As you see, the factor has been taken out and the molecule is now a perfect nano-replica of the original, scaled down to a n_20-size nano and respecting the relative distances between atoms and bindings.
+
 
+
This spared me a lot of time. Perhaps one could take this concept to the next level and write a script that would eliminate such a factor. It would be mightily useful for builders using nanoprims.
+
  
 
[[Category:LSL Examples]]
 
[[Category:LSL Examples]]

Latest revision as of 12:16, 9 July 2015

A single script that rescales every prim in a linkset

by Brilliant Scientist, 25th April 2010

Updated and heavily modified by Sei Lisa, 8th July 2015

This script uses the llGetLinkPrimitiveParams() and llSetLinkPrimitiveParamsFast() functions introduced in server 1.38 to rescale every prim in an arbitrary linkset. Based on Linkset resizer script by Maestro Linden.

The main differences between the two scripts are:

  • this script is menu-controlled
  • the script's listen channel is generated dynamically
  • more comments in the code for beginner scripters
  • it's just less chatty

The main differences with the previous version are:

  • modernized to use more recent features (it considers linkability rules now)
  • works with single-prim objects too now
  • closes the listener after a timeout
  • keeps the menu open until explicitly cancelled
  • MIN SIZE and MAX SIZE are commented out (but they can be enabled by removing the comment marks)
  • cancelling the DELETE option no longer resizes the linkset to the same size (it was a waste of resources)
  • no longer limited to 10m size per prim


Special thanks to:
Ann Otoole for contributing with a script removal function. The source code on this wiki page has been modified to reflect this contribution.

Source Code

// Linkset Resizer with Menu
// version 1.50 (2015-07-08)
// by: Brilliant Scientist and Sei Lisa
// © Copyright 2015 Sei Lisa
// --
// This script resizes all prims in a linkset, or a single prim.
// The process is controlled via a menu.
// The script works on arbitrary objects and requires no configuration.
// The script is based on "Linkset Resizer" script by Maestro Linden.
// http://wiki.secondlife.com/wiki/Linkset_resizer
// Special thanks to:
// Ann Otoole
 
float DialogTimeout = 180; // how many seconds before removing the listener
 
float max_scale;
float min_scale;
 
float   cur_scale = 1.0;
integer handle = 0;
integer menuChan;
 
list link_scales = [];
list link_positions = [];
 
makeMenu()
{
    if (!handle)
    {
        menuChan = 500000 + (integer)llFrand(500000);
        handle = llListen(menuChan, "", llGetOwner(), "");
    }
    llSetTimerEvent(DialogTimeout);
 
    //the button values can be changed i.e. you can set a value like "-1.00" or "+2.00"
    //and it will work without changing anything else in the script
    llDialog(llGetOwner(), "Max scale: " + (string)max_scale + "\nMin scale: " + (string)min_scale
        + "\n\nCurrent scale: "+ (string)cur_scale,
        ["-0.05", "-0.10", "-0.25", "+0.05", "+0.10", "+0.25", /*"MIN SIZE",*/ "RESTORE", /*"MAX SIZE",*/ "CLOSE", "DELETE..."],
        menuChan);
}
 
scanLinkset()
{
    integer link_qty = llGetNumberOfPrims();
    integer link_idx;
    integer link_ofs = (link_qty != 1); // add 1 if more than one prim (as linksets start numbering with 1)
    list params;
 
    for (link_idx = 0; link_idx < link_qty; ++link_idx)
    {
        params = llGetLinkPrimitiveParams(link_idx + link_ofs, [PRIM_POS_LOCAL, PRIM_SIZE]);
 
        link_positions += llList2Vector(params, 0);
        link_scales    += llList2Vector(params, 1);
    }
 
    max_scale = llGetMaxScaleFactor() * 0.999999;
    min_scale = llGetMinScaleFactor() * 1.000001;
}
 
resizeObject(float scale)
{
    integer link_qty = llGetNumberOfPrims();
    integer link_idx;
    integer link_ofs = (link_qty != 1);
 
    // scale the root
    llSetLinkPrimitiveParamsFast(link_ofs, [PRIM_SIZE, scale * llList2Vector(link_scales, 0)]);
    // scale all but the root
    for (link_idx = 1; link_idx < link_qty; link_idx++)
    {
        llSetLinkPrimitiveParamsFast(link_idx + link_ofs,
            [PRIM_SIZE,      scale * llList2Vector(link_scales, link_idx),
             PRIM_POS_LOCAL, scale * llList2Vector(link_positions, link_idx)]);
    }
}
 
default
{
    state_entry()
    {
        scanLinkset();
    }
 
    touch_start(integer total)
    {
        if (llDetectedKey(0) == llGetOwner())
            makeMenu();
    }
 
    timer()
    {
        llListenRemove(handle);
        handle = 0;
        llSetTimerEvent(0);
    }
 
    listen(integer channel, string name, key id, string msg)
    {
        if (msg == "RESTORE")
        {
            cur_scale = 1.0;
        }
        else if (msg == "MIN SIZE")
        {
            cur_scale = min_scale;
        }
        else if (msg == "MAX SIZE")
        {
            cur_scale = max_scale;
        }
        else if (msg == "DELETE...")
        {
            llDialog(llGetOwner(),"Are you sure you want to delete the resizer script?",
                ["DELETE","CANCEL"],menuChan);
            llSetTimerEvent(DialogTimeout);
            return;
        }
        else if (msg == "DELETE")
        {
            llOwnerSay("Deleting resizer script...");
            llRemoveInventory(llGetScriptName());
            return; // prevents the menu from showing - llRemoveInventory is not instant
        }
        else if (msg == "CANCEL")
        {
            // ignore but it will re-show the menu as it falls through
        }
        else if (msg == "CLOSE")
        {
            llListenRemove(handle);
            handle = 0;
            llSetTimerEvent(0);
            return; // prevents the menu from showing
        }
        else
        {
            cur_scale += (float)msg;
        }
 
        //check that the scale doesn't go beyond the bounds
        if (cur_scale > max_scale) { cur_scale = max_scale; }
        if (cur_scale < min_scale) { cur_scale = min_scale; }
 
        resizeObject(cur_scale);
        makeMenu();
    }
}



For information about using a resizer to handle nanoprims, check this older version: [1]