Accessing Prim Properties/de

Revision as of 01:30, 3 March 2024

Ein wenig Geschichte

Zuerst gab es llSetColor.

Dann gab es llSetLinkColor. Das war ein großer Fortschritt, da es Sie von der Last befreit hat, jedes einzelne Prim in Ihrem Haar zu skripten. Lache nicht. Möglicherweise finden Sie solche offensichtlich veralteten Skripte immer noch auf dem Hypergrid. Tun Sie uns einen Gefallen. Verbreiten Sie sie nicht. Mach sie kaputt. Schreiben Sie sie um.

Später erkannte man, dass die Möglichkeit, über ein Masterskript auf jede Eigenschaft eines Prims in einem Linkset zuzugreifen, eine gute Sache war. Dadurch wird Ihre Anwendung einfacher zu verstehen und zu warten und die Anzahl der Skripte wird reduziert. llSetLinkPrimitiveParams war geboren.

Schließlich hat OpenSimulator seine eigene Note hinzugefügt. Warum nicht Prims outside des Linkset von einem Masterskript aus manipulieren? Und wir hatten osSetPrimitiveParams.

llGet/SetLinkPrimitiveParams, osGet/SetPrimitiveParams sind das Arbeitstier der Prim-Manipulationen. Sie können von einem zentralen Ort aus auf alle vorhandenen Eigenschaften eines Prims zugreifen. Optimierter, schnellerer Code. Kein Chat oder LinkedMessages zwischen Prims mehr erforderlich.

Ein besonderer Hinweis zu llGetObjectLinkKey : Diese Funktion wurde im September 2022 eingeführt und ist der Kleber, den Sie benötigen, um auf Prims außerhalb des Linksets zuzugreifen. Sobald Sie die ID eines externen Objekts erhalten haben (vielleicht mit llSensor), können Sie llGetObjectPrimCount aufrufen (bedenken Sie auch osGetPrimCount, das sitzende Avatare nicht zählt) und dann mit llGetObjectLinkKey iterieren, um die ID jedes Prims im Remote-Objekt zu erhalten. Wenden Sie abschließend osGet/SetPrimitiveParams an.

In den folgenden Tabellen wird versucht, die zur Manipulation von Prims verfügbaren Funktionen für jede Adressierungsmethode zu sortieren.

Target is script's host (prim containing the script)	Target is link number (inside the linkset)	Target is prim id (any prim you own in the scene)
llGetOwner
llGetKey	llGetLinkKey(num)
llSetText
llGetRot / llSetRot
llGetScale / llSetScale
llGetAlpha / llSetAlpha	llSetLinkAlpha(num)
llGetColor / llSetColor	llSetLinkColor(num)
llGetPos / llSetPos
llGetObjectName / llSetObjectName	llGetLinkName(num)
llGetObjectDesc / llSetObjectDesc
llGetNumberOfSides	llGetLinkNumberOfSides(num)
llGetTexture / llSetTexture	llSetLinkTexture(num)
llSetTextureAnim	llSetLinkTextureAnim(num)
llParticleSystem	llLinkParticleSystem(num)
llSetPrimMediaParams	llSetLinkMedia(num)
		llGetObjectPrimCount(uuid)
		llGetObjectDetails(uuid)
		llGetObjectLinkKey(uuid,num)
"Universal" access (list of rules)
llGet/SetPrimitiveParams	llGet/SetLinkPrimitiveParams(num)	osGet/SetPrimitiveParams(uuid)

Beispiel: Ein Replikator

Fügen Sie dieses Skript zusammen mit einem Single-Prim-Objekt namens „seed“ in eine Box ein. Es iteriert auf jedem Prim eines benannten Objekts, das Sie in der Szene besitzen, und rezerrt dann ein identisches Prim mit einem bestimmten Offset, wodurch das Quellobjekt, sogar die Netze, perfekt repliziert wird. Sleeps sind zur Demo hier. Entfernen Sie sie für eine schnelle Replikation. Mit der CLEANUP-Option werden gelöschte Prims entfernt.

string targetName = "Example"; // Name des Zielobjekts, das dupliziert werden soll
string seedName = "seed";      // Name des Ausgangs-Prims, der dupliziert werden soll
vector offset = <5,0,0>;       // Versatz für die Duplikate
 
 
integer primcnt;                // Anzahl der Prims im Wurzelobjekt
integer primnum;                // Aktuelle Nummer des zu kopierenden Prims
key rootKey;                    // Schlüssel des Wurzelobjekts
 
// Funktion zur Bestimmung der Länge eines Tupels basierend auf dem Parameter
integer TupleLength (integer param)
{
    if (param == PRIM_GLOW)       return 1;
    if (param == PRIM_COLOR)      return 2;
    if (param == PRIM_TEXGEN)     return 1;
    if (param == PRIM_TEXTURE)    return 4;
    if (param == PRIM_NORMAL)     return 4;
    if (param == PRIM_SPECULAR)   return 7;
    if (param == PRIM_BUMP_SHINY) return 2;
    if (param == PRIM_FULLBRIGHT) return 1;
 
    return 0; // Not a by-side parameter
}
 
// Funktion zum Iterieren durch die Seiten (Faces) eines Prims und Rückgabe der Parametertupel für jede Seite
list IterateFaces (list p, integer param)
{
    integer tuplelength = TupleLength (param);
    integer numsides =  llGetListLength(p) / tuplelength;
 
    // Une seule face, retourner [ param, ALL_SIDES, p ]
    if (numsides == 1) return [ param, ALL_SIDES ] + p;
 
    list result = [ ];
    for (integer s=0; s<numsides; s++) {
        list tuple = llList2List (p, s*tuplelength, (s+1)*tuplelength-1);
        result += [ param, s ] + tuple;
    }  
    return result;
}
 
// Funktion zum Kopieren der Parameter eines Prims von einer Quelle zu einem Ziel
CopyParams (key srcprim, key dstprim, integer param) {
    if (TupleLength(param) == 0)
    {
        list p = osGetPrimitiveParams (srcprim, [ param ]);
        if (param == PRIM_POSITION) p = [ llList2Vector (p,0) + offset ];
        osSetPrimitiveParams (dstprim, [ param ] + p);
    }
    else
    {
        list p = osGetPrimitiveParams (srcprim, [ param, ALL_SIDES ]);
        p = IterateFaces (p, param);
        osSetPrimitiveParams (dstprim, p);
    }
    llSleep (0.1);
}
 
// Funktion zum Erstellen eines neuen Prims
RezAPrim ()
{
    if (++primnum > primcnt) llResetScript();
    llRezObject (seedName, llGetPos()+<0,0,1>, ZERO_VECTOR, ZERO_ROTATION, 0);
}
 
// Funktion, die aufgerufen wird, wenn ein Prim rezisiert wurde
// Kopiert die Parameter des ursprünglichen Prims auf den rezisierten Prim
PrimRezed (key dstkey)
{
    llOwnerSay ("Processing link "+(string)primnum+" of "+(string)primcnt);
    key srckey = llGetObjectLinkKey (rootKey, primnum);
    llSleep (0.1);
 
    CopyParams (srckey, dstkey, PRIM_POSITION);
    CopyParams (srckey, dstkey, PRIM_ROTATION);
    CopyParams (srckey, dstkey, PRIM_TYPE);
    CopyParams (srckey, dstkey, PRIM_SIZE);
    CopyParams (srckey, dstkey, PRIM_COLOR);
    CopyParams (srckey, dstkey, PRIM_TEXTURE);
    CopyParams (srckey, dstkey, PRIM_NORMAL);
    CopyParams (srckey, dstkey, PRIM_SPECULAR);
    CopyParams (srckey, dstkey, PRIM_TEXGEN);
    CopyParams (srckey, dstkey, PRIM_BUMP_SHINY);
    CopyParams (srckey, dstkey, PRIM_FULLBRIGHT);
    CopyParams (srckey, dstkey, PRIM_PHYSICS_SHAPE_TYPE);
 
    RezAPrim ();
}
 
// Funktion zum Abrufen des Besitzers eines Objekts anhand der Objekt-ID
key OwnerOf (key id)
{
    list l = llGetObjectDetails (id, [ OBJECT_OWNER ]);
    return llList2Key (l, 0);
}
 
 
default
{
    state_entry()
    {
        // Initialisierung des Skripts
        llSetText ("READY", <0,1,0>, 1.0);
    }
 
    touch_start (integer n)
    {
        // Wenn das Objekt berührt wird, wechselt der Zustand in den Dialog-Modus
        state dialog;
    }
}
 
 
integer dlgchan = 99;
integer dlglistener;
state dialog
{
    state_entry()
    {
        // Initialisierung des Dialog-Modus
        llSetText ("LISTENING", <0,1,0>, 1.0);
        llDialog (llGetOwner(), "Action?", ["CLEANUP", "REPLICATE"], dlgchan);
        dlglistener = llListen (dlgchan, "", llGetOwner(), "");
        llSetTimerEvent (10);
    }
 
    // Abhören von Dialognachrichten und Auslösen entsprechender Aktionen
    listen (integer chan, string name, key id, string msg)
    {
        if (msg == "CLEANUP")   state cleanup;
        if (msg == "REPLICATE") state replicate;
    }
 
    timer ()
    {
        // Timer-Ereignis zum Zurückkehren in den Standardzustand nach einer bestimmten Zeit
        state default;
    }
 
    state_exit ()
    {
        // Aufräumen beim Verlassen des Dialog-Modus
        llSetTimerEvent (0.0);
        llListenRemove (dlglistener);
    }
}
 
 
state cleanup
{
    state_entry()
    {
        // Zustand für die Bereinigung von Prims
        llSetText ("CLEANUP", <0,1,0>, 1.0);
        llSensor (seedName, NULL_KEY, PASSIVE|SCRIPTED, 100, PI);
    }
 
    sensor (integer num) {
        // Ereignis, das ausgelöst wird, wenn Sensoren aktiv sind
        llOwnerSay ("Garbage collecting "+(string)num);
        for (integer i=0; i<num; i++) osDie (llDetectedKey(i));
        state default;
    }
 
    no_sensor() {
        // Ereignis, das ausgelöst wird, wenn keine Sensoren aktiv sind
        llOwnerSay ("All clean.");
        state default;
    }
}
 
 
state replicate
{
    state_entry()
    {
        // Zustand für die Replikation von Prims
        llSetText ("REPLICATE", <0,1,0>, 1.0);
        llSensor (targetName, NULL_KEY, PASSIVE|SCRIPTED, 100, PI);
    }
 
    sensor (integer num) {
        // Ereignis, das ausgelöst wird, wenn Sensoren aktiv sind
        rootKey = llDetectedKey (0);
 
        if (OwnerOf(rootKey) != llGetOwner())
        {
            llOwnerSay ("I don't own "+targetName+". Aborting.");
            state default;
        }
 
        primcnt = llGetObjectPrimCount (rootKey);
        primnum = 0; RezAPrim ();
    }
 
    no_sensor() {
        // Ereignis, das ausgelöst wird, wenn keine Sensoren aktiv sind
        llOwnerSay ("Object "+targetName+" was not found.");
    }
 
    object_rez (key uuid) {
        // Ereignis, das ausgelöst wird, wenn ein Objekt rezisiert wird
        PrimRezed (uuid);
    }
}

Schreibzugriffsmethoden

Die Funktionsfamilie Get/SetPrimitiveParams ist unglaublich leistungsstark. Es ist auch ziemlich geheimnisvoll zu schreiben und zu entschlüsseln. Eine Möglichkeit, diese langen Parameterlisten loszuwerden, die Ihren Code überladen, besteht darin, Get/SetPrimitiveParams in einzelne get/set-Accessoren zu kapseln und so tatsächlich die Lücken in der obigen Tabelle zu füllen. Obwohl dies sehr angenehm zu lesen ist, beachten Sie, dass dies die Leistung beeinträchtigen kann, wenn Sie viele Eigenschaften auf einmal ändern möchten, was SetPrimitiveParams in einem Aufruf tun kann. Als Beispiel wird die folgende Bibliothek angeboten.

// Indizes der Eigenschaften für PRIM_TYPE_BOX, PRIM_TYPE_CYLINDER, PRIM_TYPE_PRISM
 
integer INDEX_TYPE      = 0; // Typ
integer INDEX_HOLE      = 1; // Lochgröße
integer INDEX_CUT       = 2; // Schnittgröße
integer INDEX_HOLLOW    = 3; // Leeregröße
integer INDEX_TWIST     = 4; // Verdrehung
integer INDEX_TAPER     = 5; // Zulauf
integer INDEX_SHEAR     = 6; // Scherung
 
// Indizes der Eigenschaften für PRIM_TEXTURE
 
integer INDEX_TEXTURE   = 0; // Textur
integer INDEX_REPEATS   = 1; // Wiederholungen
integer INDEX_OFFSETS   = 2; // Versatz
integer INDEX_ROTATION  = 3; // Rotation
 
// Indizes der Eigenschaften für PRIM_COLOR 
//                client        script
//          +---------------+------------+
//  Taper   | -1.0 0  +1.0  |  2.0   0.0 | 
//  Shear   | -0.5 0  +0.5  | -0.5  +0.5 |
//  Twist   | -180 0  +180  | -1.0  +1.0 | 
//          +---------------+------------+
 
 
// Set-Methoden
 
mySetLinkName (integer link, string text) {
    // Setzt den Namen eines Links
    llSetLinkPrimitiveParamsFast (link, [PRIM_NAME, text]);
}
 
mySetLinkDesc (integer link, string text) {
    // Setzt die Beschreibung eines Links
    llSetLinkPrimitiveParamsFast (link, [PRIM_DESC, text]);
}
 
mySetLinkText (integer link, string text, vector color) {
    // Setzt den Text eines Links mit Farbe
    llSetLinkPrimitiveParamsFast (link, [PRIM_TEXT, text, color, 1.0]);
}
 
mySetLinkColor (integer link, vector color, integer face) {
    // Setzt die Farbe eines Links für eine bestimmte Seite
    llSetLinkPrimitiveParamsFast (link, [PRIM_COLOR, face, color, 1.0]);
}
 
mySetLinkBright (integer link, integer bright, integer face) {
    // Setzt die Helligkeit eines Links für eine bestimmte Seite
    llSetLinkPrimitiveParamsFast (link, [PRIM_FULLBRIGHT, face, bright]);
}
 
mySetLinkGlow (integer link, float glow, integer face) {
    // Setzt das Leuchten eines Links für eine bestimmte Seite
    llSetLinkPrimitiveParamsFast (link, [PRIM_GLOW, face, glow]);
}
 
// Die folgenden drei funktionieren nicht für ALL_SIDES
 
mySetLinkTexture (integer link, key texture, integer face) {
    // Setzt die Textur eines Links für eine bestimmte Seite
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    l = llListReplaceList(l, [texture], INDEX_TEXTURE, INDEX_TEXTURE);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TEXTURE, face] + l);
}
 
mySetLinkRepeat (integer link, vector repeat, integer face) {
    // Setzt die Texturwiederholungen eines Links für eine bestimmte Seite
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    l = llListReplaceList(l, [repeat], INDEX_REPEATS, INDEX_REPEATS);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TEXTURE, face] + l);
}
 
mySetLinkOffset (integer link, vector offset, integer face) {
    // Setzt den Texturversatz eines Links für eine bestimmte Seite
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    l = llListReplaceList(l, [offset], INDEX_OFFSETS, INDEX_OFFSETS);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TEXTURE, face] + l);
}
 
mySetLinkPos (integer link, vector pos) {
    // Setzt die Position eines Links relativ zum Elternobjekt
    llSetLinkPrimitiveParamsFast (link, [PRIM_POS_LOCAL, pos]);
}
 
mySetLinkRot (integer link, rotation rot) {
    // Setzt die Rotation eines Links relativ zum Elternobjekt
    llSetLinkPrimitiveParamsFast (link, [PRIM_ROT_LOCAL, rot]);
}
 
mySetLinkSize (integer link, vector size) {
    // Setzt die Größe eines Links
    llSetLinkPrimitiveParamsFast (link, [PRIM_SIZE, size]);
}
 
mySetLinkCut (integer link, vector cut) {
    // Setzt den Schnitt eines Links (nur für Boxen, Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [cut], INDEX_CUT, INDEX_CUT);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
mySetLinkTwist (integer link, vector twist) {
    // Setzt die Verdrehung eines Links (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [twist], INDEX_TWIST, INDEX_TWIST);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
mySetLinkTaper (integer link, vector taper) {
    // Setzt den Zulauf eines Links (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [taper], INDEX_TAPER, INDEX_TAPER);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
mySetLinkShear (integer link, vector shear) {
    // Setzt die Scherung eines Links (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [shear], INDEX_SHEAR, INDEX_SHEAR);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
mySetLinkHollow (integer link, float hollow) {
    // Setzt die Hohlheit eines Links (nur für Boxen, Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [hollow], INDEX_HOLLOW, INDEX_HOLLOW);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
// Get-Methoden
 
string myGetLinkName (integer link) {
    // Gibt den Namen eines Links zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_NAME]);
    return llList2String (l,0);
}
 
string myGetLinkDesc (integer link) {
    // Gibt die Beschreibung eines Links zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_DESC]);
    return llList2String (l,0);
}
 
string myGetLinkText (integer link) {
    // Gibt den Text eines Links zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXT]);
    return llList2String (l,0);
}
 
vector myGetLinkColor (integer link, integer face) {
     // Gibt die Farbe eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_COLOR, face]);
    return llList2Vector (l,0);
}
 
integer myGetLinkBright (integer link, integer face) {
    // Gibt die Helligkeit eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_FULLBRIGHT, face]);
    return llList2Integer (l,0);
}
 
float myGetLinkGlow (integer link, integer face) {
    // Gibt das Leuchten eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_GLOW, face]);
    return llList2Float (l,0);
}
 
key myGetLinkTexture (integer link, integer face) {
    // Gibt die Textur eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    return llList2Key(l,0);
}
 
vector myGetLinkRepeat (integer link, integer face) {
    // Gibt die Texturwiederholungen eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    return llList2Vector(l,1);
}
 
vector myGetLinkOffset (integer link, integer face) {
    // Gibt den Texturversatz eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    return llList2Vector(l,2);
}
 
vector myGetLinkPos (integer link) {
    // Gibt die Position eines Links relativ zum Elternobjekt zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_POS_LOCAL]);
    return llList2Vector (l,0);
}
 
vector myGetLinkSize (integer link) {
    // Gibt die Größe eines Links zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_SIZE]);
    return llList2Vector (l,0);
}
 
vector myGetLinkCut (integer link) {
    // Gibt den Schnitt eines Links zurück (nur für Boxen, Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Vector (l, INDEX_CUT);
}
 
vector myGetLinkTwist (integer link) {
    // Gibt die Verdrehung eines Links zurück (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Vector (l, INDEX_TWIST);
}
 
vector myGetLinkTaper (integer link) {
    // Gibt den Zulauf eines Links zurück (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Vector (l, INDEX_TAPER);
}
 
vector myGetLinkShear (integer link) {
    // Gibt die Scherung eines Links zurück (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Vector (l, INDEX_SHEAR);
}
 
float myGetLinkHollow (integer link) {
    // Gibt die Hohlheit eines Links zurück (nur für Boxen, Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Float (l, INDEX_HOLLOW);
}

Views

Accessing Prim Properties/de

From OpenSimulator

Revision as of 01:30, 3 March 2024

Ein wenig Geschichte

Beispiel: Ein Replikator

Schreibzugriffsmethoden

Personal tools

General

For Administrators

For Developers

For Creators

For Grid Users

Related Links

About This Wiki

Search

Tools