Did many thngs in sl lately

An was very busy. Anyway currently studying how to use smile for distributing presentations without the need of uploading images on SL.

The theory should be the following:

1\ build a server on my php server domain being able to serve smil output.
2\ functions handled might be the following:
3\ http://url/smil/text.php sending via post a text composed to up of 600 chars and define a font and dimension, will receive back a smil with a textual slide
4\ http://usr/smil/graphics.php sending via post url of an image, a title and a description and have it returned as a service with proper formatting.

This should avoid uploading images to SL.

My own alignment software

Project Joker.

The idea is to have a very easy peer to peer script in the objects that can interactively be used to do some interesting functions.







Experimenting the following in the toy:

1\ copy position
2\ copy rotation
3\ copy size

Using just a simple menu.

check this for the source: source

Very busy inworld

I made a lot of interesting things inworld, and started to sell on slexchange.
You can see them at http://slexchange.com/modules.php?name=Marketplace&MerchantID=85242

I also managed to buy a LOT of tools and had some upgrades for something.

Just here a listing of things I bought:

- *****Skidz Primz (waiting for new version, enlisted in beta test), (1500 L$)
- *****Prim.Docker (new version 4.0 released) (600 L$)
- *Texture Aligner (1100L$)
- ***Virtual Builder Studio (2500ç$)
- ****Prim Replicator (1500 L$)
- (didn't check yet) Jextone Easy texture (1600 L$)
- *** Free Temp Rezzer
- * Builder's Tab (free)
- **** Landscaper Friend (cheap)
- ** Builder's Eye
- ** LH Texture Display HUD

I also investigated on the following interesting free tools:

- ** SLBrowser
- * SecondView
- * second pages
- * ShopOnRez

Texture alignment...

If you build a lot you will found almost impossible to align those damn textures when you resize or move your pieces.
Surely you can try offset and repeats per face parameters, but how to do that in a "safe" and exact way?

So I rezzed up a 10x10x.5 box and tried to get the magical numbers you must use when aligning textures.

I call SizeX the size on X and ShrinkX the coefficient of shrinking on X, so that .1 means you shrinked th box on the X axis to be 1 m only.

So almost obviously the RepeatPerFace x must be multiplied by ShrinkX.

OffsetX depends on where you moved you piece, but if you want to put at the higher X you should apply the following formula:

OffsetX=( 1 - ShrinkX) / 2

For example:

if you shrinkX by .1, you have to
- offsetX add .45
- changeX by .45*LX=4.5

If you have a strange size box, say 3.5 x 3.5 and you want to put it to 3 x 3.5, than shrinkX is
3 / 3.5 = .857,

offset will be (1-.857)/2=.0715

and changeX will be .715*3.5=.250

:)

NB: if instead of aligning the box exactly to other boxes you are further offsetting of a small amount, you just have to offset the textures of the further/originalsize so that it will fully aligned.

Builder helping tools Skids Primz Vs Prims.Docker

Some weeks ago I read on some blogs about an interesting event in sl: RoseLinUK London was organizing classes on how to build and cited a "copy create tool" which should make easy aligning prims when building.
I contacted her and had information on the copy create tool, and she gave me a quick, yet incredibly informative learning session on using the grid and this tool to have good prim alignments, then told me that I could experiment "Skidz Primz" as a useful tool for aligning prims.
I experimented with the "free" tricks she gave me and also bought Skidz Primz, but also found that there is another tool, called Prims.Docker which apparently did the same things as Skidz Primz, but was much more cheap: around 500L$ instead of 1500L$. So I bought both of them and experimented with both.
Here I want to give you a feedback on the three ways of building:
- free "expert" hands (using grid, copy create tool, reference and other tricks),
- skidz primz
- prims.docker

What I tried to build is very very simple: just a 10x10 box (6 sides) and on one side simulate a lateral door. Here are the results:

Free Hand: zero L$

Description & Setup:
- Use grid options
- Use world ruler
- Use copy selection tool
- NO SETUP needed except for grid options with proper values, and possibly coloring your prims

PROS:
- ZERO linden cost
- prims built in this way are surely yours :) no need to do strange voodoos for marking them with you as creator
- no need to wear huds or have strange tools with you
- no need to insert and clean up scripts on your objects
- building the door is paradoxically easier than the other methods

CONS:
- you have to know very well how to set and use grid, numerical positions, word/local/reference coordinates
- you also need to be very aware of the prims properties
- you loose sometimes a lot of time in moving around assessing you are doing correctly

Skidz Primz (from Skidz Tweak) around 1500 L$
USE and SETUP:
- wear the belt and the hud
- setup for being creator just needs to substitute the Primz in the belt with your own starting prim
- needs a bit of auto-learning before using it productively


PROS:
- no need to use numbers for aligning objects: just use special markers (red points rezzed by your interface)
- very smart textures put on Skidz Primz showing you x,y,z axes, cutting direction and so. Very useful for teaching and understanding where the object axes are :)
- very excellent way for filling gaps. Also the others, when you have understood the trick are very intuitive.

CONS:
- price
- a lot of object rezzed just to act as coloured markers. Be sure to use them temp or hybrid so not to waste prims in your land!
- even if gaps are ok, building of doors is not exactly so easy. Better doing free hand with the grid options!!!


Prim.Docker from Riefa Rennebohm
SETUP:
- just one hud to wear
- need to set client->rendering->Axes to understand axis directions.

PROS:
- cheap
- very useful for multiple safe same level alignments
- copy also textures!!!

CONS:
- need to put client script in each prim
- spanning (filling the gaps) works in an almost unusable way :( Too dependent on the local axis, and in some circumstances cannot understand what it is doing


So my final conclusions are:
1\ you can live even without these expensive tools (you can build without much problems if you really have big experience in building
2\ even if you are experienced builder Prim.Docker can really help you since it can manage multiple objects at the same time (being sure they have the same z or be correctly centered),
3\ for beginners, Skidz Primz is better because it is much more visual and also have a very smarty texture helping you in understanding cutting, axes and so.
4\ For making windows or dealing with gaps, sometimes grid hand methods are preferable. Skidz and Docker might make you lose a lot of time trying to use them for simple tasks
5\ if you have a lot of L$ like me it is very funny buying them and using them alternatively for easying the building task

I'm currently thinking to build myself some tools for building, completing the gaps each of these systems have.

BTW: Latest building I tried I didn't use these tools, or just used them very sparingly.

So a good classroom with RoseLinUK is 100 times worth the usage of these tools... :)

Building a wall with a door

You can use the door described at previous point and one of the wall described in the simple room, then using various cut and pasting you can "make a hole" where the door is.

making a hole means that you have to restrict and duplicate the red wall (for instance) to be at least a 3 part structure:

The section over the door (.7x10x.2) 0,270,0
The section on the left of the door (3.5x1.5x.2) 0,270,0
The section on the right of the door (3.5x6.4x.2) 0,270,0 (You can hollow this 60 to have extra window).

You can link together the pieces of the wall but NOT the door. (UNLUCKILY)

A very simple door

Build a door as following:

cube, .2x4.25x3.33, (cut: .375-.875) apply a texture of your choice (maybe a real door?)
put following script inside:

// improved door script by Ezhar Fairlight
// features: automatic closing, workaround for rotating out of position,
// doesn't mess up when moved, adjustable direction (inwards/outwards)
// updated for SL 1.1 damped rotations, small bugfix

// ********** USER SETTINGS HERE **********
float       TIMER_CLOSE = 5.0;      // automatically close the door after this many seconds,
                                 // set to 0 to disable

integer     DIRECTION   = -1;       // direction door opens in. Either 1 (outwards) or -1 (inwards);
// ********** END OF USER SETTINGS **********



integer     DOOR_OPEN   = 1;
integer     DOOR_CLOSE  = 2;

vector      mypos;      // door position (objects move a tiny amount
                     // away from their position each time they are rotated,
                     // thus we need to workaround this by resetting
                     // the position after rotating)
                 
door(integer what) {
 rotation    rot;
 rotation    delta;

 llSetTimerEvent(0); // kill any running timers

 if ( what == DOOR_OPEN ) {
     //llTriggerSound("Door open", 0.8);

     rot = llGetRot();
     delta = llEuler2Rot(<0,>);
     rot = delta * rot;                  // rotate by -45 degree
     llSetRot(rot);
 
 } else if ( what == DOOR_CLOSE) {
     rot = llGetRot();
     delta = llEuler2Rot(<0,>);    // rotate by 45 degree
     rot = delta * rot;
     llSetRot(rot);

     //llTriggerSound("Door close", 0.8);
 }
}
 

default {   // is closed
 on_rez(integer start_param) { // reset, so we store the new position
     llResetScript();
 }

 state_entry() {
     mypos = llGetPos();     // remember where we're supposed to be
 }

 touch_start(integer total_number) {
     door(DOOR_OPEN);
 
     state is_open;
 }

 moving_end() {  // done moving me around, store new position
     mypos = llGetPos();
 }
}

state is_open {
 state_entry() {
     llSetTimerEvent(TIMER_CLOSE);
 }

 touch_start(integer num) {
     door(DOOR_CLOSE);
 
     llSetPos(mypos);        // workaround for tiny movements during rotation
 
     state default;
 }

 timer() { // it's time to close the door
     door(DOOR_CLOSE);
 
     llSetPos(mypos);        // workaround for tiny movements during rotation
 
     state default;
 }

 moving_start() { // close door when door is being moved
     door(DOOR_CLOSE);
 
     state default;
 }
}

The door should be working