Aurora.ScriptEngine.AuroraDotNetEngine.APIs.LSL_Api.SetPrimParams C# (CSharp) Method

SetPrimParams() protected method

protected SetPrimParams ( IEntity part, Aurora.ScriptEngine.AuroraDotNetEngine.LSL_Types.list rules ) : void
part IEntity
rules Aurora.ScriptEngine.AuroraDotNetEngine.LSL_Types.list
return void
        protected void SetPrimParams(IEntity part, LSL_List rules)
        {
            int idx = 0;

            while (idx < rules.Length)
            {
                int code = rules.GetLSLIntegerItem(idx++);

                int remain = rules.Length - idx;

                int face;
                LSL_Vector v;

                if (code == (int)ScriptBaseClass.PRIM_NAME)
                {
                    if (remain < 1)
                        return;

                    string name = rules.Data[idx++].ToString();
                    if (part is ISceneChildEntity)
                        (part as ISceneChildEntity).Name = name;
                }

                else if (code == (int)ScriptBaseClass.PRIM_DESC)
                {
                    if (remain < 1)
                        return;

                    string desc = rules.Data[idx++].ToString();
                    if (part is ISceneChildEntity)
                        (part as ISceneChildEntity).Description = desc;
                }

                else if (code == (int)ScriptBaseClass.PRIM_ROT_LOCAL)
                {
                    if (remain < 1)
                        return;
                    LSL_Rotation lr = rules.GetQuaternionItem(idx++);
                    if (part is ISceneChildEntity)
                        SetRot((part as ISceneChildEntity), Rot2Quaternion(lr));
                }

                else if (code == (int)ScriptBaseClass.PRIM_POSITION)
                {
                    if (remain < 1)
                        return;

                    v = rules.GetVector3Item(idx++);
                    if (part is ISceneChildEntity)
                        SetPos(part as ISceneChildEntity, v, true);
                    else if (part is IScenePresence)
                    {
                        (part as IScenePresence).OffsetPosition = new Vector3((float)v.x, (float)v.y, (float)v.z);
                        (part as IScenePresence).SendTerseUpdateToAllClients();
                    }
                }
                else if (code == (int)ScriptBaseClass.PRIM_POS_LOCAL)
                {
                    if (remain < 1)
                        return;

                    v = rules.GetVector3Item(idx++);
                    if (part is ISceneChildEntity)
                    {
                        if (((ISceneChildEntity)part).ParentID != 0)
                            ((ISceneChildEntity)part).OffsetPosition = new Vector3((float)v.x, (float)v.y, (float)v.z);
                        else
                            part.AbsolutePosition = new Vector3((float)v.x, (float)v.y, (float)v.z);
                    }
                    else if (part is IScenePresence)
                    {
                        (part as IScenePresence).OffsetPosition = new Vector3((float)v.x, (float)v.y, (float)v.z);
                        (part as IScenePresence).SendTerseUpdateToAllClients();
                    }
                }
                else if (code == (int)ScriptBaseClass.PRIM_SIZE)
                {
                    if (remain < 1)
                        return;


                    v = rules.GetVector3Item(idx++);
                    if (part is ISceneChildEntity)
                        SetScale(part as ISceneChildEntity, v);

                }
                else if (code == (int)ScriptBaseClass.PRIM_ROTATION)
                {
                    if (remain < 1)
                        return;

                    LSL_Rotation q = rules.GetQuaternionItem(idx++);
                    if (part is ISceneChildEntity)
                    {
                        // try to let this work as in SL...
                        if ((part as ISceneChildEntity).ParentID == 0)
                        {
                            // special case: If we are root, rotate complete SOG to new rotation
                            SetRot(part as ISceneChildEntity, Rot2Quaternion(q));
                        }
                        else
                        {
                            // we are a child. The rotation values will be set to the one of root modified by rot, as in SL. Don't ask.
                            ISceneEntity group = (part as ISceneChildEntity).ParentEntity;
                            if (group != null) // a bit paranoid, maybe
                            {
                                ISceneChildEntity rootPart = group.RootChild;
                                if (rootPart != null) // again, better safe than sorry
                                {
                                    SetRot((part as ISceneChildEntity), rootPart.RotationOffset * Rot2Quaternion(q));
                                }
                            }
                        }
                    }
                    else if (part is IScenePresence)
                    {
                        IScenePresence sp = (IScenePresence)part;
                        ISceneChildEntity childObj = sp.Scene.GetSceneObjectPart(sp.SittingOnUUID);
                        if (childObj != null)
                        {
                            sp.Rotation = childObj.ParentEntity.GroupRotation * Rot2Quaternion(q);
                            sp.SendTerseUpdateToAllClients();
                        }
                    }
                }

                else if (code == (int)ScriptBaseClass.PRIM_TYPE)
                {
                    if (remain < 3)
                        return;

                    if (part is ISceneChildEntity) { }
                    else
                        return;

                    code = rules.GetLSLIntegerItem(idx++);

                    remain = rules.Length - idx;
                    float hollow;
                    LSL_Vector twist;
                    LSL_Vector taper_b;
                    LSL_Vector topshear;
                    float revolutions;
                    float radiusoffset;
                    float skew;
                    LSL_Vector holesize;
                    LSL_Vector profilecut;

                    if (code == (int)ScriptBaseClass.PRIM_TYPE_BOX)
                    {
                        if (remain < 6)
                            return;

                        face = rules.GetLSLIntegerItem(idx++);
                        v = rules.GetVector3Item(idx++); // cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);

                        (part as ISceneChildEntity).Shape.PathCurve = (byte)Extrusion.Straight;
                        SetPrimitiveShapeParams((part as ISceneChildEntity), face, v, hollow, twist, taper_b, topshear, 1);

                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_CYLINDER)
                    {
                        if (remain < 6)
                            return;

                        face = rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); // cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        (part as ISceneChildEntity).Shape.ProfileShape = ProfileShape.Circle;
                        (part as ISceneChildEntity).Shape.PathCurve = (byte)Extrusion.Straight;
                        SetPrimitiveShapeParams((part as ISceneChildEntity), face, v, hollow, twist, taper_b, topshear, 0);
                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_PRISM)
                    {
                        if (remain < 6)
                            return;

                        face = rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); //cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        (part as ISceneChildEntity).Shape.PathCurve = (byte)Extrusion.Straight;
                        SetPrimitiveShapeParams((part as ISceneChildEntity), face, v, hollow, twist, taper_b, topshear, 3);

                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_SPHERE)
                    {
                        if (remain < 5)
                            return;

                        face = rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); // cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++); // dimple
                        (part as ISceneChildEntity).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as ISceneChildEntity), face, v, hollow, twist, taper_b, 5);

                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_TORUS)
                    {
                        if (remain < 11)
                            return;

                        face = rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); //cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        holesize = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        profilecut = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++); // taper_a
                        revolutions = (float)rules.GetLSLFloatItem(idx++);
                        radiusoffset = (float)rules.GetLSLFloatItem(idx++);
                        skew = (float)rules.GetLSLFloatItem(idx++);
                        (part as ISceneChildEntity).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as ISceneChildEntity), face, v, hollow, twist, holesize, topshear, profilecut, taper_b,
                                                revolutions, radiusoffset, skew, 0);
                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_TUBE)
                    {
                        if (remain < 11)
                            return;

                        face = rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); //cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        holesize = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        profilecut = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++); // taper_a
                        revolutions = (float)rules.GetLSLFloatItem(idx++);
                        radiusoffset = (float)rules.GetLSLFloatItem(idx++);
                        skew = (float)rules.GetLSLFloatItem(idx++);
                        (part as ISceneChildEntity).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as ISceneChildEntity), face, v, hollow, twist, holesize, topshear, profilecut, taper_b,
                                                revolutions, radiusoffset, skew, 1);
                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_RING)
                    {
                        if (remain < 11)
                            return;

                        face = rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); //cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        holesize = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        profilecut = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++); // taper_a
                        revolutions = (float)rules.GetLSLFloatItem(idx++);
                        radiusoffset = (float)rules.GetLSLFloatItem(idx++);
                        skew = (float)rules.GetLSLFloatItem(idx++);
                        (part as ISceneChildEntity).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as ISceneChildEntity), face, v, hollow, twist, holesize, topshear, profilecut, taper_b,
                                                revolutions, radiusoffset, skew, 3);
                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_SCULPT)
                    {
                        if (remain < 2)
                            return;

                        string map = rules.Data[idx++].ToString();
                        face = rules.GetLSLIntegerItem(idx++); // type
                        (part as ISceneChildEntity).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as ISceneChildEntity), map, face);
                    }
                }

                else if (code == (int)ScriptBaseClass.PRIM_TEXTURE)
                {
                    if (remain < 5)
                        return;
                    if (part is ISceneChildEntity) { }
                    else
                        return;
                    face = rules.GetLSLIntegerItem(idx++);
                    string tex = rules.Data[idx++].ToString();
                    LSL_Vector repeats = rules.GetVector3Item(idx++);
                    LSL_Vector offsets = rules.GetVector3Item(idx++);
                    double rotation = rules.GetLSLFloatItem(idx++);

                    SetTexture((part as ISceneChildEntity), tex, face);
                    ScaleTexture((part as ISceneChildEntity), repeats.x, repeats.y, face);
                    OffsetTexture((part as ISceneChildEntity), offsets.x, offsets.y, face);
                    RotateTexture((part as ISceneChildEntity), rotation, face);

                }

                else if (code == (int)ScriptBaseClass.PRIM_COLOR)
                {
                    if (remain < 3)
                        return;
                    if (part is ISceneChildEntity) { }
                    else
                        return;
                    face = rules.GetLSLIntegerItem(idx++);
                    LSL_Vector color = rules.GetVector3Item(idx++);
                    double alpha = rules.GetLSLFloatItem(idx++);

                    (part as ISceneChildEntity).SetFaceColor(new Vector3((float)color.x, (float)color.y, (float)color.z), face);
                    SetAlpha((part as ISceneChildEntity), alpha, face);

                }

                else if (code == (int)ScriptBaseClass.PRIM_FLEXIBLE)
                {
                    if (remain < 7)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    bool flexi = rules.GetLSLIntegerItem(idx++);
                    int softness = rules.GetLSLIntegerItem(idx++);
                    float gravity = (float)rules.GetLSLFloatItem(idx++);
                    float friction = (float)rules.GetLSLFloatItem(idx++);
                    float wind = (float)rules.GetLSLFloatItem(idx++);
                    float tension = (float)rules.GetLSLFloatItem(idx++);
                    LSL_Vector force = rules.GetVector3Item(idx++);

                    SetFlexi((part as ISceneChildEntity), flexi, softness, gravity, friction, wind, tension, force);
                }
                else if (code == (int)ScriptBaseClass.PRIM_POINT_LIGHT)
                {
                    if (remain < 5)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    bool light = rules.GetLSLIntegerItem(idx++);
                    LSL_Vector lightcolor = rules.GetVector3Item(idx++);
                    float intensity = (float)rules.GetLSLFloatItem(idx++);
                    float radius = (float)rules.GetLSLFloatItem(idx++);
                    float falloff = (float)rules.GetLSLFloatItem(idx++);

                    SetPointLight((part as ISceneChildEntity), light, lightcolor, intensity, radius, falloff);

                }

                else if (code == (int)ScriptBaseClass.PRIM_GLOW)
                {
                    if (remain < 2)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    face = rules.GetLSLIntegerItem(idx++);
                    float glow = (float)rules.GetLSLFloatItem(idx++);

                    SetGlow((part as ISceneChildEntity), face, glow);

                }
                else if (code == (int)ScriptBaseClass.PRIM_BUMP_SHINY)
                {
                    if (remain < 3)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    face = rules.GetLSLIntegerItem(idx++);
                    int shiny = rules.GetLSLIntegerItem(idx++);
                    Bumpiness bump = (Bumpiness)Convert.ToByte((int)rules.GetLSLIntegerItem(idx++));

                    SetShiny(part as ISceneChildEntity, face, shiny, bump);

                }
                else if (code == (int)ScriptBaseClass.PRIM_FULLBRIGHT)
                {
                    if (remain < 2)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    face = rules.GetLSLIntegerItem(idx++);
                    bool st = rules.GetLSLIntegerItem(idx++);
                    SetFullBright(part as ISceneChildEntity, face, st);
                }

                else if (code == (int)ScriptBaseClass.PRIM_MATERIAL)
                {
                    if (remain < 1)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    int mat = rules.GetLSLIntegerItem(idx++);
                    if (mat < 0 || mat > 7)
                        return;

                    (part as ISceneChildEntity).Material = Convert.ToByte(mat);
                }
                else if (code == (int)ScriptBaseClass.PRIM_PHANTOM)
                {
                    if (remain < 1)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    string ph = rules.Data[idx++].ToString();

                    bool phantom = ph.Equals("1");

                    (part as ISceneChildEntity).ScriptSetPhantomStatus(phantom);
                }
                else if (code == (int)ScriptBaseClass.PRIM_PHYSICS)
                {
                    if (remain < 1)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    string phy = rules.Data[idx++].ToString();

                    ((SceneObjectGroup)m_host.ParentEntity).ScriptSetPhysicsStatus(phy.Equals("1"));
                }
                else if (code == (int)ScriptBaseClass.PRIM_TEMP_ON_REZ)
                {
                    if (remain < 1)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    string temp = rules.Data[idx++].ToString();

                    bool tempOnRez = temp.Equals("1");

                    (part as ISceneChildEntity).ScriptSetTemporaryStatus(tempOnRez);
                }
                else if (code == (int)ScriptBaseClass.PRIM_TEXGEN)
                {
                    if (remain < 2)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    //face,type
                    face = rules.GetLSLIntegerItem(idx++);
                    int style = rules.GetLSLIntegerItem(idx++);
                    SetTexGen((part as ISceneChildEntity), face, style);
                }
                else if (code == (int)ScriptBaseClass.PRIM_TEXT)
                {
                    if (remain < 3)
                        return;
                    if (!(part is ISceneChildEntity))
                        return;
                    string primText = rules.GetLSLStringItem(idx++);
                    LSL_Vector primTextColor = rules.GetVector3Item(idx++);
                    LSL_Float primTextAlpha = rules.GetLSLFloatItem(idx++);
                    Vector3 av3 = new Vector3(Util.Clip((float)primTextColor.x, 0.0f, 1.0f),
                                  Util.Clip((float)primTextColor.y, 0.0f, 1.0f),
                                  Util.Clip((float)primTextColor.z, 0.0f, 1.0f));
                    (part as ISceneChildEntity).SetText(primText, av3, Util.Clip((float)primTextAlpha, 0.0f, 1.0f));

                }
                else if (code == (int)ScriptBaseClass.PRIM_OMEGA)
                {
                    if (remain < 3)
                        return;
                    LSL_Vector direction = rules.GetVector3Item(idx++);
                    LSL_Float spinrate = rules.GetLSLFloatItem(idx++);
                    LSL_Float gain = rules.GetLSLFloatItem(idx++);
                    if (part is ISceneChildEntity)
                        llTargetOmega(direction, spinrate, gain);
                }
                else if (code == (int)ScriptBaseClass.PRIM_PHYSICS_SHAPE_TYPE)
                {
                    bool UsePhysics = ((m_host.Flags & PrimFlags.Physics) != 0);
                    bool IsTemporary = ((m_host.Flags & PrimFlags.TemporaryOnRez) != 0);
                    bool IsPhantom = ((m_host.Flags & PrimFlags.Phantom) != 0);
                    bool IsVolumeDetect = m_host.VolumeDetectActive;
                    ObjectFlagUpdatePacket.ExtraPhysicsBlock[] blocks = new ObjectFlagUpdatePacket.ExtraPhysicsBlock[1];
                    blocks[0] = new ObjectFlagUpdatePacket.ExtraPhysicsBlock
                                    {
                                        Density = m_host.Density,
                                        Friction = m_host.Friction,
                                        GravityMultiplier = m_host.GravityMultiplier
                                    };
                    LSL_Integer shapeType = rules.GetLSLIntegerItem(idx++);
                    if (shapeType == ScriptBaseClass.PRIM_PHYSICS_SHAPE_PRIM)
                        blocks[0].PhysicsShapeType = (byte)shapeType.value;
                    else if (shapeType == ScriptBaseClass.PRIM_PHYSICS_SHAPE_NONE)
                        blocks[0].PhysicsShapeType = (byte)shapeType.value;
                    else //if(shapeType == ScriptBaseClass.PRIM_PHYSICS_SHAPE_CONVEX)
                        blocks[0].PhysicsShapeType = (byte)shapeType.value;
                    blocks[0].Restitution = m_host.Restitution;
                    if (part is ISceneChildEntity)
                        if ((part as ISceneChildEntity).UpdatePrimFlags(UsePhysics,
                            IsTemporary, IsPhantom, IsVolumeDetect, blocks))
                            (part as ISceneChildEntity).ParentEntity.RebuildPhysicalRepresentation(true);
                }
                else if (code == (int)ScriptBaseClass.PRIM_LINK_TARGET)
                {
                    if (remain < 1)
                        return;
                    LSL_Integer nextLink = rules.GetLSLIntegerItem(idx++);
                    List<IEntity> entities = GetLinkPartsAndEntities(nextLink);
                    if (entities.Count > 0)
                        part = entities[0];
                }
            }
        }
LSL_Api