LSL Compiler now only referring required assemblies (DotNetEngine and Common). Changed Vector and Rotation to custom types (stored in Common) that needs to be changed later. No longer using Axiom. Script support still broken.

1 files changed, 91 insertions, 90 deletions

diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/Server_API/LSL_BuiltIn_Commands.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/Server_API/LSL_BuiltIn_Commands.cs
index 6401163..15de03b 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/Server_API/LSL_BuiltIn_Commands.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/Server_API/LSL_BuiltIn_Commands.cs
@@ -60,16 +60,16 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public int llFloor(double f) { return (int)Math.Floor(f); }

         public int llCeil(double f) { return (int)Math.Ceiling(f); }

         public int llRound(double f) { return (int)Math.Round(f, 1); }

-        public double llVecMag(Axiom.Math.Vector3 v) { return 0; }

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

-        public double 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 double llVecMag(LSL_Types.Vector3 v) { return 0; }

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

+        public double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b) { return 0; }

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

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

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

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

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

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

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

 

         public void llWhisper(int channelID, string text)

         {

@@ -112,57 +112,57 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public string llDetectedKey(int number) { return ""; }

         public string llDetectedOwner(int number) { return ""; }

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

-        public Axiom.Math.Vector3 llDetectedPos(int number) { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Vector3 llDetectedVel(int number) { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Vector3 llDetectedGrab(int number) { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Quaternion llDetectedRot(int number) { return new Axiom.Math.Quaternion(); }

+        public LSL_Types.Vector3 llDetectedPos(int number) { return new LSL_Types.Vector3(); }

+        public LSL_Types.Vector3 llDetectedVel(int number) { return new LSL_Types.Vector3(); }

+        public LSL_Types.Vector3 llDetectedGrab(int number) { return new LSL_Types.Vector3(); }

+        public LSL_Types.Quaternion llDetectedRot(int number) { return new LSL_Types.Quaternion(); }

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

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

         public void llDie() { return; }

-        public double llGround(Axiom.Math.Vector3 offset) { return 0; }

-        public double llCloud(Axiom.Math.Vector3 offset) { return 0; }

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

+        public double llGround(LSL_Types.Vector3 offset) { return 0; }

+        public double llCloud(LSL_Types.Vector3 offset) { return 0; }

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

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

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

-        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, int face) { return; }

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

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

+        public void llSetColor(LSL_Types.Vector3 color, int face) { return; }

         public double llGetAlpha(int face) { return 0; }

         public void llSetAlpha(double alpha, int face) { return; }

-        public Axiom.Math.Vector3 llGetColor(int face) { return new Axiom.Math.Vector3(); }

+        public LSL_Types.Vector3 llGetColor(int face) { return new LSL_Types.Vector3(); }

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

         public void llScaleTexture(double u, double v, int face) { return; }

         public void llOffsetTexture(double u, double v, int face) { return; }

         public void llRotateTexture(double rotation, int face) { return; }

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

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

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

 

-        public Axiom.Math.Vector3 llGetPos()

+        public LSL_Types.Vector3 llGetPos()

         {

             throw new NotImplementedException("llGetPos");

             // return m_host.AbsolutePosition;

         }

 

-        public Axiom.Math.Vector3 llGetLocalPos() { return new Axiom.Math.Vector3(); }

-        public void llSetRot(Axiom.Math.Quaternion rot) { }

-        public Axiom.Math.Quaternion llGetRot() { return new Axiom.Math.Quaternion(); }

-        public Axiom.Math.Quaternion llGetLocalRot() { return new Axiom.Math.Quaternion(); }

-        public void llSetForce(Axiom.Math.Vector3 force, int local) { }

-        public Axiom.Math.Vector3 llGetForce() { return new Axiom.Math.Vector3(); }

-        public int llTarget(Axiom.Math.Vector3 position, double range) { return 0; }

+        public LSL_Types.Vector3 llGetLocalPos() { return new LSL_Types.Vector3(); }

+        public void llSetRot(LSL_Types.Quaternion rot) { }

+        public LSL_Types.Quaternion llGetRot() { return new LSL_Types.Quaternion(); }

+        public LSL_Types.Quaternion llGetLocalRot() { return new LSL_Types.Quaternion(); }

+        public void llSetForce(LSL_Types.Vector3 force, int local) { }

+        public LSL_Types.Vector3 llGetForce() { return new LSL_Types.Vector3(); }

+        public int llTarget(LSL_Types.Vector3 position, double range) { return 0; }

         public void llTargetRemove(int number) { }

-        public int llRotTarget(Axiom.Math.Quaternion rot, double error) { return 0; }

+        public int llRotTarget(LSL_Types.Quaternion rot, double error) { return 0; }

         public void llRotTargetRemove(int number) { }

-        public void llMoveToTarget(Axiom.Math.Vector3 target, double tau) { }

+        public void llMoveToTarget(LSL_Types.Vector3 target, double tau) { }

         public void llStopMoveToTarget() { }

-        public void llApplyImpulse(Axiom.Math.Vector3 force, int local) { }

-        public void llApplyRotationalImpulse(Axiom.Math.Vector3 force, int local) { }

-        public void llSetTorque(Axiom.Math.Vector3 torque, int local) { }

-        public Axiom.Math.Vector3 llGetTorque() { return new Axiom.Math.Vector3(); }

-        public void llSetForceAndTorque(Axiom.Math.Vector3 force, Axiom.Math.Vector3 torque, int local) { }

-        public Axiom.Math.Vector3 llGetVel() { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Vector3 llGetAccel() { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Vector3 llGetOmega() { return new Axiom.Math.Vector3(); }

+        public void llApplyImpulse(LSL_Types.Vector3 force, int local) { }

+        public void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local) { }

+        public void llSetTorque(LSL_Types.Vector3 torque, int local) { }

+        public LSL_Types.Vector3 llGetTorque() { return new LSL_Types.Vector3(); }

+        public void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local) { }

+        public LSL_Types.Vector3 llGetVel() { return new LSL_Types.Vector3(); }

+        public LSL_Types.Vector3 llGetAccel() { return new LSL_Types.Vector3(); }

+        public LSL_Types.Vector3 llGetOmega() { return new LSL_Types.Vector3(); }

         public double llGetTimeOfDay() { return 0; }

         public double llGetWallclock() { return 0; }

         public double llGetTime() { return 0; }

@@ -187,8 +187,8 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public void llMakeFountain() { }

         public void llMakeSmoke() { }

         public void llMakeFire() { }

-        public void llRezObject(string inventory, Axiom.Math.Vector3 pos, Axiom.Math.Quaternion rot, int param) { }

-        public void llLookAt(Axiom.Math.Vector3 target, double strength, double damping) { }

+        public void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Quaternion rot, int param) { }

+        public void llLookAt(LSL_Types.Vector3 target, double strength, double damping) { }

         public void llStopLookAt() { }

         public void llSetTimerEvent(double sec) { }

         public void llSleep(double sec) { System.Threading.Thread.Sleep((int)(sec * 1000)); }

@@ -210,7 +210,7 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public void llStopHover() { }

         public void llMinEventDelay(double delay) { }

         public void llSoundPreload() { }

-        public void llRotLookAt(Axiom.Math.Quaternion target, double strength, double damping) { }

+        public void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping) { }

 

         public int llStringLength(string str)

         {

@@ -228,14 +228,14 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public void llStopAnimation(string anim) { }

         public void llPointAt() { }

         public void llStopPointAt() { }

-        public void llTargetOmega(Axiom.Math.Vector3 axis, double spinrate, double gain) { }

+        public void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain) { }

         public int llGetStartParameter() { return 0; }

-        public void llGodLikeRezObject(string inventory, Axiom.Math.Vector3 pos) { }

+        public void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos) { }

         public void llRequestPermissions(string agent, int perm) { }

         public string llGetPermissionsKey() { return ""; }

         public int llGetPermissions() { return 0; }

         public int llGetLinkNumber() { return 0; }

-        public void llSetLinkColor(int linknumber, Axiom.Math.Vector3 color, int face) { }

+        public void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face) { }

         public void llCreateLink(string target, int parent) { }

         public void llBreakLink(int linknum) { }

         public void llBreakAllLinks() { }

@@ -248,12 +248,13 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public void llGiveInventory(string destination, string inventory) { }

         public void llRemoveInventory(string item) { }

 

-        public void llSetText(string text, Axiom.Math.Vector3 color, double alpha)

+        public void llSetText(string text, LSL_Types.Vector3 color, double alpha)

         {

-            m_host.SetText(text, color, alpha);

+            // TEMP DISABLED UNTIL WE CAN AGREE UPON VECTOR/ROTATION FORMAT

+            //m_host.SetText(text, color, alpha);

         }

 

-        public double llWater(Axiom.Math.Vector3 offset) { return 0; }

+        public double llWater(LSL_Types.Vector3 offset) { return 0; }

         public void llPassTouches(int pass) { }

         public string llRequestAgentData(string id, int data) { return ""; }

         public string llRequestInventoryData(string name) { return ""; }

@@ -265,25 +266,25 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public string llGetAnimation(string id) { return ""; }

         public void llResetScript() { }

         public void llMessageLinked(int linknum, int num, string str, string id) { }

-        public void llPushObject(string target, Axiom.Math.Vector3 impulse, Axiom.Math.Vector3 ang_impulse, int local) { }

+        public void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local) { }

         public void llPassCollisions(int pass) { }

         public string llGetScriptName() { return ""; }

         public int llGetNumberOfSides() { return 0; }

-        public Axiom.Math.Quaternion llAxisAngle2Rot(Axiom.Math.Vector3 axis, double angle) { return new Axiom.Math.Quaternion(); }

-        public Axiom.Math.Vector3 llRot2Axis(Axiom.Math.Quaternion rot) { return new Axiom.Math.Vector3(); }

+        public LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle) { return new LSL_Types.Quaternion(); }

+        public LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot) { return new LSL_Types.Vector3(); }

         public void llRot2Angle() { }

         public double llAcos(double val) { return (double)Math.Acos(val); }

         public double llAsin(double val) { return (double)Math.Asin(val); }

-        public double llAngleBetween(Axiom.Math.Quaternion a, Axiom.Math.Quaternion b) { return 0; }

+        public double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b) { return 0; }

         public string llGetInventoryKey(string name) { return ""; }

         public void llAllowInventoryDrop(int add) { }

-        public Axiom.Math.Vector3 llGetSunDirection() { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Vector3 llGetTextureOffset(int face) { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Vector3 llGetTextureScale(int side) { return new Axiom.Math.Vector3(); }

+        public LSL_Types.Vector3 llGetSunDirection() { return new LSL_Types.Vector3(); }

+        public LSL_Types.Vector3 llGetTextureOffset(int face) { return new LSL_Types.Vector3(); }

+        public LSL_Types.Vector3 llGetTextureScale(int side) { return new LSL_Types.Vector3(); }

         public double llGetTextureRot(int side) { return 0; }

         public int llSubStringIndex(string source, string pattern) { return 0; }

         public string llGetOwnerKey(string id) { return ""; }

-        public Axiom.Math.Vector3 llGetCenterOfMass() { return new Axiom.Math.Vector3(); }

+        public LSL_Types.Vector3 llGetCenterOfMass() { return new LSL_Types.Vector3(); }

         public List<string> llListSort(List<string> src, int stride, int ascending)

         { return new List<string>(); }

         public int llGetListLength(List<string> src) { return 0; }

@@ -291,10 +292,10 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public double llList2double(List<string> src, int index) { return 0; }

         public string llList2String(List<string> src, int index) { return ""; }

         public string llList2Key(List<string> src, int index) { return ""; }

-        public Axiom.Math.Vector3 llList2Vector(List<string> src, int index)

-        { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Quaternion llList2Rot(List<string> src, int index)

-        { return new Axiom.Math.Quaternion(); }

+        public LSL_Types.Vector3 llList2Vector(List<string> src, int index)

+        { return new LSL_Types.Vector3(); }

+        public LSL_Types.Quaternion llList2Rot(List<string> src, int index)

+        { return new LSL_Types.Quaternion(); }

         public List<string> llList2List(List<string> src, int start, int end)

         { return new List<string>(); }

         public List<string> llDeleteSubList(List<string> src, int start, int end)

@@ -307,33 +308,33 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         { return new List<string>(); }

         public List<string> llList2ListStrided(List<string> src, int start, int end, int stride)

         { return new List<string>(); }

-        public Axiom.Math.Vector3 llGetRegionCorner()

-        { return new Axiom.Math.Vector3(World.RegionInfo.RegionLocX * 256, World.RegionInfo.RegionLocY * 256, 0); }

+        public LSL_Types.Vector3 llGetRegionCorner()

+        { return new LSL_Types.Vector3(World.RegionInfo.RegionLocX * 256, World.RegionInfo.RegionLocY * 256, 0); }

         public List<string> llListInsertList(List<string> dest, List<string> src, int start)

         { return new List<string>(); }

         public int llListFindList(List<string> src, List<string> test) { return 0; }

         public string llGetObjectName() { return ""; }

         public void llSetObjectName(string name) { }

         public string llGetDate() { return ""; }

-        public int llEdgeOfWorld(Axiom.Math.Vector3 pos, Axiom.Math.Vector3 dir) { return 0; }

+        public int llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir) { return 0; }

         public int llGetAgentInfo(string id) { return 0; }

         public void llAdjustSoundVolume(double volume) { }

         public void llSetSoundQueueing(int queue) { }

         public void llSetSoundRadius(double radius) { }

         public string llKey2Name(string id) { return ""; }

         public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate) { }

-        public void llTriggerSoundLimited(string sound, double volume, Axiom.Math.Vector3 top_north_east, Axiom.Math.Vector3 bottom_south_west) { }

+        public void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east, LSL_Types.Vector3 bottom_south_west) { }

         public void llEjectFromLand(string pest) { }

         public void llParseString2List() { }

         public int llOverMyLand(string id) { return 0; }

-        public string llGetLandOwnerAt(Axiom.Math.Vector3 pos) { return ""; }

+        public string llGetLandOwnerAt(LSL_Types.Vector3 pos) { return ""; }

         public string llGetNotecardLine(string name, int line) { return ""; }

-        public Axiom.Math.Vector3 llGetAgentSize(string id) { return new Axiom.Math.Vector3(); }

+        public LSL_Types.Vector3 llGetAgentSize(string id) { return new LSL_Types.Vector3(); }

         public int llSameGroup(string agent) { return 0; }

         public void llUnSit(string id) { }

-        public Axiom.Math.Vector3 llGroundSlope(Axiom.Math.Vector3 offset) { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Vector3 llGroundNormal(Axiom.Math.Vector3 offset) { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Vector3 llGroundContour(Axiom.Math.Vector3 offset) { return new Axiom.Math.Vector3(); }

+        public LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset) { return new LSL_Types.Vector3(); }

+        public LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset) { return new LSL_Types.Vector3(); }

+        public LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset) { return new LSL_Types.Vector3(); }

         public int llGetAttached() { return 0; }

         public int llGetFreeMemory() { return 0; }

         public string llGetRegionName() { return m_manager.RegionName; }

@@ -344,11 +345,11 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public void llGiveInventoryList() { }

         public void llSetVehicleType(int type) { }

         public void llSetVehicledoubleParam(int param, double value) { }

-        public void llSetVehicleVectorParam(int param, Axiom.Math.Vector3 vec) { }

-        public void llSetVehicleRotationParam(int param, Axiom.Math.Quaternion rot) { }

+        public void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec) { }

+        public void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot) { }

         public void llSetVehicleFlags(int flags) { }

         public void llRemoveVehicleFlags(int flags) { }

-        public void llSitTarget(Axiom.Math.Vector3 offset, Axiom.Math.Quaternion rot) { }

+        public void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot) { }

         public string llAvatarOnSitTarget() { return ""; }

         public void llAddToLandPassList(string avatar, double hours) { }

         public void llSetTouchText(string text)

@@ -358,10 +359,10 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public void llSetSitText(string text)

         {

         }

-        public void llSetCameraEyeOffset(Axiom.Math.Vector3 offset) { }

-        public void llSetCameraAtOffset(Axiom.Math.Vector3 offset) { }

+        public void llSetCameraEyeOffset(LSL_Types.Vector3 offset) { }

+        public void llSetCameraAtOffset(LSL_Types.Vector3 offset) { }

         public void llDumpList2String() { }

-        public void llScriptDanger(Axiom.Math.Vector3 pos) { }

+        public void llScriptDanger(LSL_Types.Vector3 pos) { }

         public void llDialog(string avatar, string message, List<string> buttons, int chat_channel) { }

         public void llVolumeDetect(int detect) { }

         public void llResetOtherScript(string name) { }

@@ -387,15 +388,15 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public List<string> llGetAnimationList(string id) { return new List<string>(); }

         public void llSetParcelMusicURL(string url) { }

 

-        public Axiom.Math.Vector3 llGetRootPosition()

+        public LSL_Types.Vector3 llGetRootPosition()

         {

             throw new NotImplementedException("llGetRootPosition");

             //return m_root.AbsolutePosition;

         }

 

-        public Axiom.Math.Quaternion llGetRootRotation()

+        public LSL_Types.Quaternion llGetRootRotation()

         {

-            return new Axiom.Math.Quaternion();

+            return new LSL_Types.Quaternion();

         }

 

         public string llGetObjectDesc() { return ""; }

@@ -406,16 +407,16 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         public int llGetNumberOfPrims() { return 0; }

         public string llGetNumberOfNotecardLines(string name) { return ""; }

         public List<string> llGetBoundingBox(string obj) { return new List<string>(); }

-        public Axiom.Math.Vector3 llGetGeometricCenter() { return new Axiom.Math.Vector3(); }

+        public LSL_Types.Vector3 llGetGeometricCenter() { return new LSL_Types.Vector3(); }

         public void llGetPrimitiveParams() { }

         public string llIntegerToBase64(int number) { return ""; }

         public int llBase64ToInteger(string str) { return 0; }

         public double llGetGMTclock() { return 0; }

         public string llGetSimulatorHostname() { return ""; }

-        public void llSetLocalRot(Axiom.Math.Quaternion rot) { }

+        public void llSetLocalRot(LSL_Types.Quaternion rot) { }

         public List<string> llParseStringKeepNulls(string src, List<string> seperators, List<string> spacers)

         { return new List<string>(); }

-        public void llRezAtRoot(string inventory, Axiom.Math.Vector3 position, Axiom.Math.Vector3 velocity, Axiom.Math.Quaternion rot, int param) { }

+        public void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity, LSL_Types.Quaternion rot, int param) { }

         public int llGetObjectPermMask(int mask) { return 0; }

         public void llSetObjectPermMask(int mask, int value) { }

         public void llGetInventoryPermMask(string item, int mask) { }

@@ -440,13 +441,13 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
 

         public int llGetInventoryType(string name) { return 0; }

         public void llSetPayPrice(int price, List<string> quick_pay_buttons) { }

-        public Axiom.Math.Vector3 llGetCameraPos() { return new Axiom.Math.Vector3(); }

-        public Axiom.Math.Quaternion llGetCameraRot() { return new Axiom.Math.Quaternion(); }

+        public LSL_Types.Vector3 llGetCameraPos() { return new LSL_Types.Vector3(); }

+        public LSL_Types.Quaternion llGetCameraRot() { return new LSL_Types.Quaternion(); }

         public void llSetPrimURL() { }

         public void llRefreshPrimURL() { }

         public string llEscapeURL(string url) { return ""; }

         public string llUnescapeURL(string url) { return ""; }

-        public void llMapDestination(string simname, Axiom.Math.Vector3 pos, Axiom.Math.Vector3 look_at) { }

+        public void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at) { }

         public void llAddToLandBanList(string avatar, double hours) { }

         public void llRemoveFromLandPassList(string avatar) { }

         public void llRemoveFromLandBanList(string avatar) { }

@@ -457,17 +458,17 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler
         {

             return OpenSim.Framework.Utilities.Util.UnixTimeSinceEpoch();

         }

-        public int llGetParcelFlags(Axiom.Math.Vector3 pos) { return 0; }

+        public int llGetParcelFlags(LSL_Types.Vector3 pos) { return 0; }

         public int llGetRegionFlags() { return 0; }

         public string llXorBase64StringsCorrect(string str1, string str2) { return ""; }

         public void llHTTPRequest() { }

         public void llResetLandBanList() { }

         public void llResetLandPassList() { }

-        public int llGetParcelPrimCount(Axiom.Math.Vector3 pos, int category, int sim_wide) { return 0; }

-        public List<string> llGetParcelPrimOwners(Axiom.Math.Vector3 pos) { return new List<string>(); }

+        public int llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide) { return 0; }

+        public List<string> llGetParcelPrimOwners(LSL_Types.Vector3 pos) { return new List<string>(); }

         public int llGetObjectPrimCount(string object_id) { return 0; }

-        public int llGetParcelMaxPrims(Axiom.Math.Vector3 pos, int sim_wide) { return 0; }

-        public List<string> llGetParcelDetails(Axiom.Math.Vector3 pos, List<string> param) { return new List<string>(); }

+        public int llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide) { return 0; }

+        public List<string> llGetParcelDetails(LSL_Types.Vector3 pos, List<string> param) { return new List<string>(); }

 

 

     }