Code comments and cleanup, correct datatypes for key, vector, rotation, (hopefully) reference to Axiom during compile, passing of BuiltIns during script load, BuiltIn interface added, etc etc

2 files changed, 57 insertions, 57 deletions

diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSO/Server_API/LSL_BuiltIn_Commands_Interface.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/Server_API/LSL_BuiltIn_Commands_Interface.cs
index 8a5d4b6..d484a05 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSO/Server_API/LSL_BuiltIn_Commands_Interface.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/Server_API/LSL_BuiltIn_Commands_Interface.cs
@@ -30,7 +30,7 @@ using System;
 using System.Collections.Generic;

 using System.Text;

 

-namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSO

+namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler

 {

     public interface LSL_BuiltIn_Commands_Interface

     {

@@ -46,54 +46,54 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSO
         UInt32 llFloor(float f);

         UInt32 llCeil(float f);

         UInt32 llRound(float f);

-        float llVecMag(LSO_Enums.Vector v);

-        LSO_Enums.Vector llVecNorm(LSO_Enums.Vector v);

-        float llVecDist(LSO_Enums.Vector a, LSO_Enums.Vector b);

-        LSO_Enums.Vector llRot2Euler(LSO_Enums.Rotation r);

-        LSO_Enums.Rotation llEuler2Rot(LSO_Enums.Vector v);

-        LSO_Enums.Rotation llAxes2Rot(LSO_Enums.Vector fwd, LSO_Enums.Vector left, LSO_Enums.Vector up);

-        LSO_Enums.Vector llRot2Fwd(LSO_Enums.Rotation r);

-        LSO_Enums.Vector llRot2Left(LSO_Enums.Rotation r);

-        LSO_Enums.Vector llRot2Up(LSO_Enums.Rotation r);

-        LSO_Enums.Rotation llRotBetween(LSO_Enums.Vector start, LSO_Enums.Vector end);

+        float llVecMag(Axiom.Math.Vector3 v);

+        Axiom.Math.Vector3 llVecNorm(Axiom.Math.Vector3 v);

+        float llVecDist(Axiom.Math.Vector3 a, Axiom.Math.Vector3 b);

+        Axiom.Math.Vector3 llRot2Euler(Axiom.Math.Quaternion r);

+        Axiom.Math.Quaternion llEuler2Rot(Axiom.Math.Vector3 v);

+        Axiom.Math.Quaternion llAxes2Rot(Axiom.Math.Vector3 fwd, Axiom.Math.Vector3 left, Axiom.Math.Vector3 up);

+        Axiom.Math.Vector3 llRot2Fwd(Axiom.Math.Quaternion r);

+        Axiom.Math.Vector3 llRot2Left(Axiom.Math.Quaternion r);

+        Axiom.Math.Vector3 llRot2Up(Axiom.Math.Quaternion r);

+        Axiom.Math.Quaternion llRotBetween(Axiom.Math.Vector3 start, Axiom.Math.Vector3 end);

         void llWhisper(UInt16 channelID, string text);

         //void llSay(UInt32 channelID, string text);

         void llSay(object channelID, object text);

         void llShout(UInt16 channelID, string text);

-        UInt32 llListen(UInt16 channelID, string name, LSO_Enums.Key ID, string msg);

+        UInt32 llListen(UInt16 channelID, string name, string ID, string msg);

         void llListenControl(UInt32 number, UInt32 active);

         void llListenRemove(UInt32 number);

-        void llSensor(string name, LSO_Enums.Key id, UInt32 type, float range, float arc);

-        void llSensorRepeat(string name, LSO_Enums.Key id, UInt32 type, float range, float arc, float rate);

+        void llSensor(string name, string id, UInt32 type, float range, float arc);

+        void llSensorRepeat(string name, string id, UInt32 type, float range, float arc, float rate);

         void llSensorRemove();

         string llDetectedName(UInt32 number);

-        LSO_Enums.Key llDetectedKey(UInt32 number);

-        LSO_Enums.Key llDetectedOwner(UInt32 number);

+        string llDetectedKey(UInt32 number);

+        string llDetectedOwner(UInt32 number);

         UInt32 llDetectedType(UInt32 number);

-        LSO_Enums.Vector llDetectedPos(UInt32 number);

-        LSO_Enums.Vector llDetectedVel(UInt32 number);

-        LSO_Enums.Vector llDetectedGrab(UInt32 number);

-        LSO_Enums.Rotation llDetectedRot(UInt32 number);

+        Axiom.Math.Vector3 llDetectedPos(UInt32 number);

+        Axiom.Math.Vector3 llDetectedVel(UInt32 number);

+        Axiom.Math.Vector3 llDetectedGrab(UInt32 number);

+        Axiom.Math.Quaternion llDetectedRot(UInt32 number);

         UInt32 llDetectedGroup(UInt32 number);

         UInt32 llDetectedLinkNumber(UInt32 number);

         void llDie();

-        float llGround(LSO_Enums.Vector offset);

-        float llCloud(LSO_Enums.Vector offset);

-        LSO_Enums.Vector llWind(LSO_Enums.Vector offset);

+        float llGround(Axiom.Math.Vector3 offset);

+        float llCloud(Axiom.Math.Vector3 offset);

+        Axiom.Math.Vector3 llWind(Axiom.Math.Vector3 offset);

         void llSetStatus(UInt32 status, UInt32 value);

         UInt32 llGetStatus(UInt32 status);

-        void llSetScale(LSO_Enums.Vector scale);

-        LSO_Enums.Vector llGetScale();

-        void llSetColor(LSO_Enums.Vector color, UInt32 face);

+        void llSetScale(Axiom.Math.Vector3 scale);

+        Axiom.Math.Vector3 llGetScale();

+        void llSetColor(Axiom.Math.Vector3 color, UInt32 face);

         float llGetAlpha(UInt32 face);

         void llSetAlpha(float alpha, UInt32 face);

-        LSO_Enums.Vector llGetColor(UInt32 face);

+        Axiom.Math.Vector3 llGetColor(UInt32 face);

         void llSetTexture(string texture, UInt32 face);

         void llScaleTexture(float u, float v, UInt32 face);

         void llOffsetTexture(float u, float v, UInt32 face);

         void llRotateTexture(float rotation, UInt32 face);

         string llGetTexture(UInt32 face);

-        void llSetPos(LSO_Enums.Vector pos);

+        void llSetPos(Axiom.Math.Vector3 pos);

 

         void llGetPos();

         void llGetLocalPos();

diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSO/Server_API/LSL_BuiltIn_Commands_TestImplementation.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/Server_API/LSL_BuiltIn_Commands_TestImplementation.cs
index 38adf9f..f107993 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSO/Server_API/LSL_BuiltIn_Commands_TestImplementation.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/Server_API/LSL_BuiltIn_Commands_TestImplementation.cs
@@ -1,4 +1,4 @@
-/*

+    /*

 * Copyright (c) Contributors, http://www.openmetaverse.org/

 * See CONTRIBUTORS.TXT for a full list of copyright holders.

 *

@@ -30,7 +30,7 @@ using System;
 using System.Collections.Generic;

 using System.Text;

 

-namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSO

+namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler

 {

     public class LSL_BuiltIn_Commands_TestImplementation : LSL_BuiltIn_Commands_Interface

     {

@@ -52,16 +52,16 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSO
         public UInt32 llFloor(float f) { return 0; }

         public UInt32 llCeil(float f) { return 0; }

         public UInt32 llRound(float f) { return 0; }

-        public float llVecMag(LSO_Enums.Vector v) { return 0; }

-        public LSO_Enums.Vector llVecNorm(LSO_Enums.Vector v) { return new LSO_Enums.Vector(); }

-        public float llVecDist(LSO_Enums.Vector a, LSO_Enums.Vector b) { return 0; }

-        public LSO_Enums.Vector llRot2Euler(LSO_Enums.Rotation r) { return new LSO_Enums.Vector(); }

-        public LSO_Enums.Rotation llEuler2Rot(LSO_Enums.Vector v) { return new LSO_Enums.Rotation(); }

-        public LSO_Enums.Rotation llAxes2Rot(LSO_Enums.Vector fwd, LSO_Enums.Vector left, LSO_Enums.Vector up) { return new LSO_Enums.Rotation(); }

-        public LSO_Enums.Vector llRot2Fwd(LSO_Enums.Rotation r) { return new LSO_Enums.Vector(); }

-        public LSO_Enums.Vector llRot2Left(LSO_Enums.Rotation r) { return new LSO_Enums.Vector(); }

-        public LSO_Enums.Vector llRot2Up(LSO_Enums.Rotation r) { return new LSO_Enums.Vector(); }

-        public LSO_Enums.Rotation llRotBetween(LSO_Enums.Vector start, LSO_Enums.Vector end) { return new LSO_Enums.Rotation(); }

+        public float llVecMag(Axiom.Math.Vector3 v) { return 0; }

+        public Axiom.Math.Vector3 llVecNorm(Axiom.Math.Vector3 v) { return new Axiom.Math.Vector3(); }

+        public float llVecDist(Axiom.Math.Vector3 a, Axiom.Math.Vector3 b) { return 0; }

+        public Axiom.Math.Vector3 llRot2Euler(Axiom.Math.Quaternion r) { return new Axiom.Math.Vector3(); }

+        public Axiom.Math.Quaternion llEuler2Rot(Axiom.Math.Vector3 v) { return new Axiom.Math.Quaternion(); }

+        public Axiom.Math.Quaternion llAxes2Rot(Axiom.Math.Vector3 fwd, Axiom.Math.Vector3 left, Axiom.Math.Vector3 up) { return new Axiom.Math.Quaternion(); }

+        public Axiom.Math.Vector3 llRot2Fwd(Axiom.Math.Quaternion r) { return new Axiom.Math.Vector3(); }

+        public Axiom.Math.Vector3 llRot2Left(Axiom.Math.Quaternion r) { return new Axiom.Math.Vector3(); }

+        public Axiom.Math.Vector3 llRot2Up(Axiom.Math.Quaternion r) { return new Axiom.Math.Vector3(); }

+        public Axiom.Math.Quaternion llRotBetween(Axiom.Math.Vector3 start, Axiom.Math.Vector3 end) { return new Axiom.Math.Quaternion(); }

         public void llWhisper(UInt16 channelID, string text)

         {

             Common.SendToDebug("INTERNAL FUNCTION llWhisper(" + channelID + ", \"" + text + "\");");

@@ -75,40 +75,40 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSO
             Common.SendToLog("llSay Channel " + (UInt32)channelID + ", Text: \"" + (string)text + "\"");

         }

         public void llShout(UInt16 channelID, string text) { return; }

-        public UInt32 llListen(UInt16 channelID, string name, LSO_Enums.Key ID, string msg) { return 0; }

+        public UInt32 llListen(UInt16 channelID, string name, string ID, string msg) { return 0; }

         public void llListenControl(UInt32 number, UInt32 active) { return; }

         public void llListenRemove(UInt32 number) { return; }

-        public void llSensor(string name, LSO_Enums.Key id, UInt32 type, float range, float arc) { return; }

-        public void llSensorRepeat(string name, LSO_Enums.Key id, UInt32 type, float range, float arc, float rate) { return; }

+        public void llSensor(string name, string id, UInt32 type, float range, float arc) { return; }

+        public void llSensorRepeat(string name, string id, UInt32 type, float range, float arc, float rate) { return; }

         public void llSensorRemove() { return; }

         public string llDetectedName(UInt32 number) { return ""; }

-        public LSO_Enums.Key llDetectedKey(UInt32 number) { return new LSO_Enums.Key(); }

-        public LSO_Enums.Key llDetectedOwner(UInt32 number) { return new LSO_Enums.Key(); }

+        public string llDetectedKey(UInt32 number) { return ""; }

+        public string llDetectedOwner(UInt32 number) { return ""; }

         public UInt32 llDetectedType(UInt32 number) { return 0; }

-        public LSO_Enums.Vector llDetectedPos(UInt32 number) { return new LSO_Enums.Vector(); }

-        public LSO_Enums.Vector llDetectedVel(UInt32 number) { return new LSO_Enums.Vector(); }

-        public LSO_Enums.Vector llDetectedGrab(UInt32 number) { return new LSO_Enums.Vector(); }

-        public LSO_Enums.Rotation llDetectedRot(UInt32 number) { return new LSO_Enums.Rotation(); }

+        public Axiom.Math.Vector3 llDetectedPos(UInt32 number) { return new Axiom.Math.Vector3(); }

+        public Axiom.Math.Vector3 llDetectedVel(UInt32 number) { return new Axiom.Math.Vector3(); }

+        public Axiom.Math.Vector3 llDetectedGrab(UInt32 number) { return new Axiom.Math.Vector3(); }

+        public Axiom.Math.Quaternion llDetectedRot(UInt32 number) { return new Axiom.Math.Quaternion(); }

         public UInt32 llDetectedGroup(UInt32 number) { return 0; }

         public UInt32 llDetectedLinkNumber(UInt32 number) { return 0; }

         public void llDie() { return; }

-        public float llGround(LSO_Enums.Vector offset) { return 0; }

-        public float llCloud(LSO_Enums.Vector offset) { return 0; }

-        public LSO_Enums.Vector llWind(LSO_Enums.Vector offset) { return new LSO_Enums.Vector(); }

+        public float llGround(Axiom.Math.Vector3 offset) { return 0; }

+        public float llCloud(Axiom.Math.Vector3 offset) { return 0; }

+        public Axiom.Math.Vector3 llWind(Axiom.Math.Vector3 offset) { return new Axiom.Math.Vector3(); }

         public void llSetStatus(UInt32 status, UInt32 value) { return; }

         public UInt32 llGetStatus(UInt32 status) { return 0; }

-        public void llSetScale(LSO_Enums.Vector scale) { return; }

-        public LSO_Enums.Vector llGetScale() { return new LSO_Enums.Vector(); }

-        public void llSetColor(LSO_Enums.Vector color, UInt32 face) { return; }

+        public void llSetScale(Axiom.Math.Vector3 scale) { return; }

+        public Axiom.Math.Vector3 llGetScale() { return new Axiom.Math.Vector3(); }

+        public void llSetColor(Axiom.Math.Vector3 color, UInt32 face) { return; }

         public float llGetAlpha(UInt32 face) { return 0; }

         public void llSetAlpha(float alpha, UInt32 face) { return; }

-        public LSO_Enums.Vector llGetColor(UInt32 face) { return new LSO_Enums.Vector(); }

+        public Axiom.Math.Vector3 llGetColor(UInt32 face) { return new Axiom.Math.Vector3(); }

         public void llSetTexture(string texture, UInt32 face) { return; }

         public void llScaleTexture(float u, float v, UInt32 face) { return; }

         public void llOffsetTexture(float u, float v, UInt32 face) { return; }

         public void llRotateTexture(float rotation, UInt32 face) { return; }

         public string llGetTexture(UInt32 face) { return ""; }

-        public void llSetPos(LSO_Enums.Vector pos) { return; }

+        public void llSetPos(Axiom.Math.Vector3 pos) { return; }

 

 

         public void llGetPos() { }