[Cat.of.Library]

Oui on me voit rarement là je suis trop nulle et j'évite les scripts

Voilà en essayant de prendre l'air pro j'aimerai un script pour gonfler un prim , un sculpt ou un mesh en continu , donc réglable sur les trois axes vitesse et taille . Même avec un timer pourquoi pas .

Qu'en pensez vous ? Quelqu'un aurait ce genre de script sous la main ? Je suis nulle je sais ! A le dire ou l'imaginer ça a l'air tout con mais je sais qu'avec les scripts rien n'est si simple .

A vot' bon coeur siouplaît

[Worstbobo]

Il faudrait partir d'un script resizer (qu'on trouve sur le net, un peu récent quand même) et l'adapter selon tes besoins concrets.
Enfin, même partir de quelque chose de plus simple. En gros tu veux que l'objet gonfle et rétrécisse en looping?

[MenthalOH]

Comme je sens que le truc va se compliquer, je donne un premier jet qui double le volume d' un objet par deux et le divise ensuite par deux toutes les deux secondes en continu....


integer gonfle;
float coeff_mult = 2.0;//changer le coeff d' aggrandissement ici

default
{
state_entry()
{
llSetTimerEvent(2.0);
}

timer()
{
if (gonfle) llScaleByFactor(coeff_mult);
else llScaleByFactor(1/coeff_mult);

gonfle= !gonfle;
}
}
on peut evidemment mettre des gardes fous concernant la taille le rytme etc....

[bestmomo]

Effectivement llScaleByFactor est la réponse de base idéale et l'arrivée de cette fonction très attendue à grandement simplifié le redimensionnement des objets.

Après il faut voir la mise en oeuvre spécifique, "gonfler en continue" ce n'est pas vraiment prudent parce qu'on va droit à l'explosion .

[Cat.of.Library]

Citation :

Publié par MenthalOH

Comme je sens que le truc va se compliquer, je donne un premier jet qui double le volume d' un objet par deux et le divise ensuite par deux toutes les deux secondes en continu....

Merci t'es génial et super rapide

Moi qui pensais que ce serait super compliqué et pas besoin de toucher ça fonctionne tout seul

Pourquoi compliquer un truc simple qui fonctionne

@ Worstbobo oui tu avais compris le but c'est ça et Menthal a trouvé trop vite (j'aurai bien aimé l'embêter un peu tant qu'à faire )

@ Bestmomo .......... euh oui j'ai pas l'intention de rejouer la fable de La Fontaine , La grenouille et le boeuf .......... on sait comment ça finit

Merci à vous

[Worstbobo]

(Désolé pour la pub)

[bonob0h]

et sur un seul axe ?
et pour des prims liées ?
histoire de compléter les besoins des uns et des autres ...

[Cat.of.Library]

Je teste là pour prims liées ensemble avant ajout du script (toutes les prims changent), puis liées après ajout du script , puis plus vite moins vite , plus grand moins grand ........ ça fonctionneeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee sur tout

Zut je cherche la ptite bête mais je la trouve pas

Ok Menthal t'es le meilleur sur ce coup là

.......... mais je cherche encore

[bestmomo]

Citation :

Publié par bonob0h

et sur un seul axe ?
et pour des prims liées ?
histoire de compléter les besoins des uns et des autres ...

La fonction en question est destinée à un objet de primitives liées.

Pour un groupe de primitives non liées c'est plus délicat parce qu'il faut que les primitives communiquent et surtout arriver à définir le centre du groupe pour le garder constant.

Pour un changement de dimension sur un seul axe on en revient à l'ancienne parce que la fonction ne sert plus à rien.

[Cat.of.Library]

Bon suite à mon appel au secours ici on m'a donné un script intéressant justement à propos des axes . Y'aurait il possibilité d'y insérer un timer ? J'ai essayé j'y arrive pas

Il est pas mal mais il faut cliquer dessus pour qu'il agisse et 1 seul axe s'agrandit

J'ai pensé à ce que Bonob0h disait à propos des axes

Voici le script :
// Note: This script can rescale a prim on any or all axes

// Define the large and small sizes of the prim here:-
// (if the prim is sliced or path cut, it will appear to be half size on the affected dimension)
vector gScaleLarge = <0.1, 1.0,1.0>;
vector gScaleSmall = <0.1, 3.0, 1.0>;

integer gSteps = 20; // Number of steps in the shrink/expand process
float gSwitch = 1.0; // Action on first touch. +1.0 = shrink, -1.0 = expand

default
{
state_entry()
{
llSetScale(gScaleLarge);
}

on_rez(integer x)
{
llResetScript();
}

touch_start(integer total_number)
{
vector ScaleStep = (gScaleLarge - gScaleSmall) / gSteps; // Compute the scale augment per step
vector wscale = llGetScale();
gSwitch *= -1; // Switch between stretch and contract
integer i;
for ( ; i < gSteps; ++i )
{
// It is more lag-friendly to incorporate a sleep per step
// Rather than greatly increasing the number of steps
llSleep(0.1);
llSetScale(wscale + ScaleStep * (float) i * gSwitch);
}
}
}

Ai je trouvé une tite bête impossible à réaliser , oh ce que je suis vilaine ...... mais super intriguée

Désolée de vous embêter et c'est la faute à la question de Bonob0h (voilà comment on fait toujours retomber la faute sur les autres ) .

Sinon le script de Menthal est nickel , merci encore

[Grace Capalini]

Pauvre bonoboh 😂

[MenthalOH]

ajouter un timer est très simple...


vector gScaleLarge = <0.1, 1.0,1.0>;//modif des axes à ces deux lignes....
vector gScaleSmall = <0.1, 3.0, 1.0>;
integer gSteps = 20; // Number of steps in the shrink/expand process
float gSwitch = 1.0; // Action on first touch. +1.0 = shrink, -1.0 = expand
default
{
state_entry()
{
llSetScale(gScaleLarge);
llSetTimerEvent(3.0);
}
on_rez(integer x)
{
llResetScript();
}
timer()
{
vector ScaleStep = (gScaleLarge - gScaleSmall) / gSteps; // Compute the scale augment per step
vector wscale = llGetScale();
gSwitch *= -1; // Switch between stretch and contract
integer i;
for ( ; i < gSteps; ++i )
{

llSleep(0.1);
llSetScale(wscale + ScaleStep * (float) i * gSwitch);
}
}
}


petites remarques....
*la taille "small" est plus grande que la "Large"
*c' est un aggrandissement du prim en 20 etapes d' au moins 0.1 sec.....ce qui en soit est déjà un timer....
*je vois pas trop le rapport entre le timer et les axes :s (début de ta demande)...
*ce script ne fonctionne que dans un seul prim, pas un objet multiprim...because le llSetScale, qu'il faudrait remplacer par llSetLinkPrimitiveParamsFast...
*il y a des limite de taille aussi à ce genre de script, pour les builds "extrêmes"

[Cat.of.Library]

Tu veux la vérité , on m'a donné ce script suite à ce post et je l'ai testé mais ça m'énerve qu'il ne continue pas à "gonfler" et "dégonfler" un seul côté d'une prim et qu'il faut cliquer dessus sans cesse

Au départ je voulais faire un coeur qui bat et pour ça ton script est NICKEL !

En testant celui que j'ai posté j'ai pensé à la réflexion de Bonob0h et même si je ne comprends rien aux scripts je sais ce qu'est un axe alors j'ai pensé que si ça pouvait aider quelqu'un , pourquoi pas le mettre ici et je lui trouverai bien une utilité , j'ai déjà quelques idées en tête

Donc le but est ne pas avoir à cliquer dessus et que ce soit en continu ...... maintenant j'ai un doute et je repense au mot "looping" , c'est pas un peu la même chose ?

Je vais zyeuter ton script (enfin juste le glisser dans des prims hein ! Je comprends rien )

Mille fois mercis

[MenthalOH]

Petite variante sans veritable timer, reglable sur les 3 axes avec des vitesses de "pulsations" différentes ...


vector gTailleDepart = <1.0,1.0,1.0>;

vector gAxe = <0.0,0.1,0.0>;// ici aggrandissement de 0.1 sur l 'axe y....possibilité de changer 1, 2, ou 3 axes avec des variations de tailles differentes....
integer nb_etape = 10; // Nombre d' etapes de la transformation

float v1 = 0.3; //vitesse entre deux aggrandissements....

float v2 = 0.05; //vitesse entre deux retrecissements.....si besoin

default
{
on_rez(integer x)
{
llResetScript();
}

state_entry()
{
llSetScale(gTailleDepart);
integer i;
for(i=0;i<nb_etape*2;++i)
{
if(i<nb_etape)
{
llSetScale(llGetScale()+gAxe);
llSleep(v1);
}
else if(i<=nb_etape*2)
{
llSetScale(llGetScale()-gAxe);
llSleep(v2);
}
}
llResetScript();
}
}

[Cat.of.Library]

Merci Menthal

Tu sais faire plaisir aux femmes qui aiment bidouiller des conneries

Oops désolée y'a pt'être des gars à qui ça va plaire

Bonne soirée