Aligment of Objects

Imagine that I could select 3 objects, and have them snap align to any one axis.

Example : Building a wall, I create 3 objects, group select them and say Aling along X Axis, and BAM there they are , in a perfect line.

Doable ?

Tools > Show Grid
Tools > Grid Options

You'll have to do each individually, but you can do it.

But better still... use the drag-copy method of creating and they'll be lined up from the start. Or use the numbers in the edit box's object tab, for millimetre accuracy.

Well, I certainly understand the usefulness of the grid/snap functions, but I can see where something like a face-snap function would be highly useful. I was making some tube shapes just last night and rotating them in all sorts of directions and at funky angles, and it would be great if I could just tell the thing to snap face-face between the two tubes so that they aligned correctly. Most parametric CAD programs have functions similar to this, not sure how easy it would be to implement in SL though, but definitely would be useful! ... also along the same "lines" (pardon the pun) alignment to centerline axis of tubes/cylinders/cones (would be useful for wheels/axles n such), edge-edge alignment (without resorting to coordinate maths), perpendicular and tangent alignments on spherical shapes would be nice too

Peace,

Artillo

JUST SAY NO TO GAPS/FLASHING! LOL

That's exactly what I ended up doing, thanks to some guidance from my mentor.

Onward!

You know it!

Actually there are 2 axis of object alignment... one is evil, neutral, good and the other is chaos, neutral, law. A Lawfully good object....

*forestrock crawls back in his geek cave*

I am Chaotic Good. You?

I think I'm neutral good... though I'm easily charmed by bad people.

Neutral/Neutral.

However, I'm rather partial to the Warhammer setting, where Law/Chaos is the only axis one needs to care 'bout...

Ok, the joke has run long enough

A snap to object would be handy, but should be toggable as alot of times it would annoy me.

Often times I've wanted a "Line This Object up With This One" feature. Grid doesn't work because I don't start my builds by grid, and then using them later or moving them is just, ugh.

I endorse this idea/feature.

I'm good... IN BED!

I'm mature. Oh, so mature.

This has been done in scripting... I suggested "magnetic alignment" way back in beta or so, and philip coded up some magic blocks that snapped together. Dont know if they are still around, but i have a copy of them.

An alignment pallet like those found in many graphic layout programs would be nice. A ton of possibilities there that would be DAMN useful.

Tiger: Exactly. Not just alignment, but distribution - like when you are trying to space out posts along a railing, or stairs.

There's the code from what is most likely the magic blocks Eggy mentioned. Might be a start, I doubt it takes object shape, skew , etc. into account.

vector pos; 
vector found_pos;
vector start_touch_pos;
vector diff;
vector scale;
string name_detected;

vector PULSE_COLOR = <1,1,1>;

float GRAB_ALPHA = 0.5;
float INC = 2.0;                    // Grid spacing for snap, scale
float MAX_INC = 2.5;                // Biggest dimension

list colors = [<1,0,0>, <0,1,0>, <0,0,1>, 
                <0,1,1>, <1,0,1>, <1,1,0>];
                
//list tones = ["piano_1", "piano_3", "piano_5"];

vector color;
integer color_index = 0; 

integer CHANNEL = 3442;
integer pulse = FALSE;
integer inhibit = FALSE;
float INHIBIT_DELAY = 1.0;
float DECAY_FACTOR = 0.9;

send_pulse()
{
    // Change color briefly and transmit a neural 'pulse'
    inhibit = TRUE;
    llSetTimerEvent(INHIBIT_DELAY);    
    //integer tone = llRound(llFrand((float)(llGetListLength(tones) - 1)));
    //llTriggerSound(llList2String(tones, tone), 1.0);
    llSetColor(PULSE_COLOR, ALL_SIDES);
    llSay(CHANNEL, "pulse");
}

vector vec_round(vector vec, float inc)
{
    //  Rounds vector components to the nearest units of inc
    vec *= 1.0/inc;
    vec.x = ((float)llRound(vec.x));
    vec.y = ((float)llRound(vec.y));
    vec.z = ((float)llRound(vec.z)); 
    vec *= inc;
    return vec;
}

set_pos()
{
   // 
   //  On finding a neighbor, snap relative to neighbor
   // 
   pos = llGetPos();
    llSetColor(color*0.5, ALL_SIDES);
    diff = pos - found_pos;
    diff = vec_round(diff, INC/2.0);   
    diff += found_pos;
    llSetPos(diff);
    llTriggerSound("on", 1.0);
    llSetColor(color, ALL_SIDES);
}

vector new_color()
{
    integer num_colors = llGetListLength(colors);
    color_index++; 
    if (color_index >= num_colors) color_index = 0;
    return llList2Vector(colors, color_index);
}

snap()
{
    //  Issues the sensor to look for nearby blocks to snap to
    float range = 10.0;
    llSensor("Magic Block", "", PASSIVE | SCRIPTED, range, 2.0*PI);
}

default
{
    state_entry()
    {
        scale = llGetScale();
        color = new_color();
        llSetColor(color, ALL_SIDES);
        llSetStatus(STATUS_BLOCK_GRAB, FALSE);
        llSetBuoyancy(1.0);
        llListen(CHANNEL, "", "", "pulse");
    }
    
    on_rez(integer param)
    {
        found_pos = llGetPos();
        set_pos();
        snap();
    }
    
    timer()
    {
        llSetTimerEvent(0.0);
        inhibit = FALSE;
        llSetColor(color, ALL_SIDES);
    }
    
    changed(integer change)
    {
        if (change == CHANGED_SCALE)
        {
            scale = llGetScale();
            scale = vec_round(scale, INC);
            if (scale.x == 0.0) scale.x = INC;
            if (scale.y == 0.0) scale.y = INC;
            if (scale.z == 0.0) scale.z = INC;
            if (scale.x > MAX_INC) scale.x = MAX_INC;
            if (scale.y > MAX_INC) scale.y = MAX_INC;
            if (scale.z > MAX_INC) scale.z = MAX_INC;
            llSay(0, "new scale = " + (string)scale);
            llSetScale(scale);
            // Choose a new color for the block
            snap();
        }
    }

    touch_start(integer total_number)
    {
        start_touch_pos = llGetPos();
        llSetAlpha(GRAB_ALPHA, ALL_SIDES);
        llTriggerSound("on", 1.0);
        llResetTime();
        llSetStatus(STATUS_PHYSICS, FALSE);
    }
    touch_end(integer total_number) 
    {
        llSetStatus(STATUS_PHYSICS, FALSE);
        llSetAlpha(1.0, ALL_SIDES);
        vector moved = llGetPos() - start_touch_pos;
        
        if (llGetTime() < 0.3)
        {
            //  Cycle colors on short click
            llSetPos(start_touch_pos);
            llTriggerSound("color", 1.0); 
            color = new_color();
            llSetColor(color, ALL_SIDES); 
        }
        else if (llVecMag(moved) < (INC/10.0))
        {
            llSetPos(start_touch_pos);
            send_pulse();
        }
        else
        {
            // Try to find a block to stick to!
            llSetColor(color, ALL_SIDES);
            snap();  
        }
        llSetRot(<0,0,0,1>);
    }
    
    listen(integer channel, string name, key id, string message)
    {
        // Received neural pulse, so sense sender's distance
        if (!inhibit)
        {
            pulse = TRUE;
            llSensor("", id, PASSIVE | SCRIPTED, 10.0, 2.0*PI);
        }
    }
    
    no_sensor()
    {
        pulse = FALSE;
    }
    sensor(integer num_detected)
    {
        if (!pulse)
        {
            // 
            //  Rotate/snap to nearest box
            //
            //  Issue scale request to this box
            //
            found_pos = llDetectedPos(0);
            set_pos();
        }
        else
        {
            //
            //  Gauge distance to nearest box, decide whether to 'fire'
            // 
            pulse = FALSE;
            pos = llGetPos();
            found_pos = llDetectedPos(0);
            diff = pos - found_pos;
            // probability of neural firing is related to distance 
            float distance = llVecMag(diff);
            if (distance > 0.0)
            {
                if (llFrand(1.0) < ((INC/(distance*distance))*DECAY_FACTOR))
                {
                    send_pulse();
                }
            }     
        }
    }
}