OpenSimulator - User contributions [en]

Getting Started with Region Modules

2010-02-05T17:41:31Z

Robert d: /* Hacking OpenSim using MRM */

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensim-region-module.html updated project] from my blog.

--[[User:Robert d|Robert d]]

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/MRM.html my article] about accessing OpenSim classes from MRM script.

--[[User:Robert d|Robert d]]

Getting Started with Region Modules

2010-02-05T17:39:51Z

Robert d: /* Update for OpenSim 0.6.4.1 */

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensim-region-module.html updated project] from my blog.

--[[User:Robert d|Robert d]]

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/hacking-opensim-using-mrm.html my article] about accessing OpenSim classes from the MRM script.

--[[User:Robert d|Robert d]]

Getting Started with Region Modules

2010-02-05T17:39:11Z

Robert d: Undo revision 16792 by Robert d (Talk)

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensimregionmodule updated project] from my blog.

--[[User:Robert d|Robert d]]

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/hacking-opensim-using-mrm.html my article] about accessing OpenSim classes from the MRM script.

--[[User:Robert d|Robert d]]

Getting Started with Region Modules

2010-02-05T17:35:57Z

Robert d: /* Update for OpenSim 0.6.4.1 */

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library.

--[[User:Robert d|Robert d]]

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/hacking-opensim-using-mrm.html my article] about accessing OpenSim classes from the MRM script.

--[[User:Robert d|Robert d]]

Development Team

2009-06-02T17:21:06Z

Robert d: /* Additional Developers/Testers/Contributors */

__NOTOC__
{{Template:Quicklinks}}

[[Technical Reference | Technical Reference]] -> [[Technical Reference/terms | Terms]] -> [[Development_Team | Core Development Team]]

== Active OpenSim Core Developers ==
These people have commit access to our central SVN server and are [http://www.ohloh.net/projects/4753/contributors regular contributors] to the codebase.
** '''Only voted in developers should be listed here, please do not list yourself'''
(please add in as much info as you like for your name)

<table border="1" cellpadding="2" cellspacing="0" class="sortable">
<tr>
<th>Photo </th>
<th>IRC Nick </th>
<th>Name</th>
<th>SL Avatar</th>
<th>Other Grid</th>
<th>Time Zone (UTC)</th>
<th>Org</th>
<th>Areas of Interest</th>
</tr>

<tr>
<td />
<td>[[User:MW |MW ]]</td>
<td>Darren</td>
<td>OSG:Wright Juran TN:Darren Guard</td>
<td></td>
<td>0</td>
<td>[http://tribalmedia.se/ Tribal Media AB]</td>
<td>Everything</td>
</tr>
<tr>
<td> </td>
<td>[[User:lbsa71|lbsa71]]</td>
<td>Stefan Andersson</td>
<td>Tribal Skytower</td>
<td>OSG:Stefan Andersson TN:Stefan Andersson</td>
<td>+1</td>
<td>[http://tribalmedia.se/ Tribal Media AB]</td>
<td>Web Integration</td>
</tr>
<tr>
<tr>
<td />
<td>[[User:Adam Frisby|Adam Frisby]]</td>
<td>Adam Frisby</td>
<td>Adam Zaius</td>
<td></td>
<td>+8</td>
<td>DeepThink Pty Ltd</td>
<td>Terrain, Performance</td>
</tr>
<tr>
<td />
<td>[[User:MingChen|MingChen]]</td>
<td>Mike/Michael Ortman</td>
<td>Ming Chen</td>
<td></td>
<td>-6 (-5 in Summer)</td>
<td>DeepThink Pty Ltd</td>
<td>Estate/Parcel Support/Modules/Keeping things all neat and tidy.</td>
</tr>
<tr>
<td />
<td>[[User:SeanDague|sdague]]</td>
<td>Sean Dague</td>
<td>Neas Bade</td>
<td></td>
<td>-5</td>
<td>IBM</td>
<td>Database, Linux, Testing, Misc</td>
</tr>
<tr>
<td />
<td>[[User:Tedd|Tedd]]</td>
<td>Tedd Hansen</td>
<td>Tedd Maa</td>
<td></td>
<td>+1</td>
<td>Tedd Hansen</td>
<td>Programming/Scripting/Architecture</td>
</tr>
<tr>
<td />
<td>ckrinke</td>
<td>Charles Krinke</td>
<td>Charlesk Bing</td>
<td></td>
<td>-8</td>
<td> </td>
<td>Reliability/Grid servers/ll-functions</td>
</tr>
<tr>
<td />
<td>[[User:chi11ken|chi11ken]]</td>
<td>Jeff Ames</td>
<td>Chillken Proto</td>
<td> </td>
<td>+9</td>
<td>[http://www.genkii.com Genkii]</td>
<td> </td>
</tr>
<tr>
<td />
<td>[[User:adjohn|adjohn]]</td>
<td>Adam Johnson</td>
<td>Zeuz Zenovka</td>
<td> </td>
<td>+9</td>
<td>[http://www.genkii.com Genkii]</td>
<td> </td>
</tr>
<tr>
<td />
<td>[[User:joha1|joha1]]</td>
<td>Johan Berntsson</td>
<td>Joppi Brandenburg</td>
<td> </td>
<td>+9</td>
<td>[http://www.3di.jp/en/ 3Di Inc, Japan] http://www.3di.jp/en/</td>
<td>Performance, packet handling/libSL</td>
</tr>
<tr>
<td />
<td>[[User:Teravus|Teravus]]</td>
<td>Teravus</td>
<td>Teravus Ousley</td>
<td></td>
<td>-5</td>
<td>W3z</td>
<td>Physics & Admin tools, A working sim.</td>
</tr>
<tr>
<td />
<td>[[User:justincc|justincc]]</td>
<td>Justin Clark-Casey</td>
<td>Lulworth Beaumont</td>
<td>Justin Clark-Casey (osgrid)</td>
<td>0</td>
<td>Black Dress Technology [http://justincc.wordpress.com justincc's OpenSim blog]</td>
<td>Grid, performance & reliability, inventory (avatar and object), assets, scenes, etc.</td>
</tr>
<tr>
<td />
<td>[[User:DrScofield|drscofld]]</td>
<td>Dirk Husemann</td>
<td>Dr Scofield</td>
<td></td>
<td>+1</td>
<td>IBM</td>
<td>Reliability, networking protocols, voice, inventory, assets, remote control, and pretty much everything else :-)</td>
</tr>
<tr>
<td />
<td>[[User:dahlia|dahlia]]</td>
<td>T. Hoff</td>
<td>Dahlia Trimble</td>
<td></td>
<td>-8 / -7</td>
<td>Independent</td>
<td>Collision geometry, various math and physics issues, occasional bug fixes and random enhancements</td>
</tr>
<tr>
<td></td>
<td>[[User:Mikem|mikem]]</td>
<td>Mike</td>
<td> </td>
<td> </td>
<td>+9</td>
<td>[http://www.3di.jp/en/ 3Di Inc, Japan] http://www.3di.jp/en/</td>
<td>Patches, scripting improvements, LSL compiler</td>
</tr>
<tr>
<td></td>
<td>[[User:Melanie_T|Melanie_T]]</td>
<td>Melanie</td>
<td>Melanie Milland</td>
<td> </td>
<td>+1</td>
<td>Independent</td>
<td>Scripting, Prims/Scene, Life, The Universe, and Everything</td>
</tr>
<tr>
<td></td>
<td>[[User:HomerHorwitz|homerh]]</td>
<td>Homer Horwitz</td>
<td>Homer Horwitz</td>
<td> </td>
<td>+2</td>
<td>Independent</td>
<td>Rev. engineering, "now, that's funny" problems, but still interested in all parts of it</td>
</tr>
<tr>
<td></td>
<td>[[User:Diva|Diva]]</td>
<td>Crista Lopes</td>
<td>Diva Canto</td>
<td>Crista Lopes / Diva Canto</td>
<td>-8</td>
<td>University of California, Irvine</td>
<td>Everything, except databases</td>
</tr>
<tr>
<td />
<td>[[User:nlin|nlin]]</td>
<td>N Lin</td>
<td>Standard Drucker</td>
<td> </td>
<td>+9</td>
<td>[http://www.3di.jp/en/ 3Di Inc, Japan] http://www.3di.jp/en/</td>
<td>Physics, scripting, more to come</td>
</tr>
<tr>
<td />
<td>[[User:arthursv|arthursv]]</td>
<td>Arthur Valadares</td>
<td>Arthur Valadares</td>
<td>NONE</td>
<td>-3</td>
<td>IBM</td>
<td>Unit testing, database plugins, bug fixes, general </td>
</tr>

</table>

== Retired OpenSim core developers ==

These people are core developers who have transcended our mortal plane (i.e. they are no longer active).

<table border="1" cellpadding="2" cellspacing="0" class="sortable">
<tr>
<th>Photo </th>
<th>IRC Nick </th>
<th>Name</th>
<th>SL Avatar</th>
<th>Other Grid</th>
<th>Time Zone (UTC)</th>
<th>Org</th>
<th>Areas of Interest</th>
</tr>
<tr>
<td />
<td>[[User:babblefrog|babblefrog]]</td>
<td>Brian McBee</td>
<td>Dogen Coldstream</td>
<td>Babblefrog Ballistic (osgrid)</td>
<td>-8</td>
<td>Disorganized</td>
<td> </td>
</tr>
<tr>
<td />
<td>[[User:danx0r|danx0r]]</td>
<td>Dan Miller</td>
<td>Albert Pascal</td>
<td></td>
<td>-8</td>
<td>squiggle.com</td>
<td>PHEEZIKS; everything</td>
</tr>
<tr>
<td />
<td>Tleiades</td>
<td> </td>
<td>Tleiades Hax</td>
<td></td>
<td>+1</td>
<td> </td>
<td>Grid servers/Database</td>
</tr>
<tr>
<td />
<td>[[User:Darok|Darok]]</td>
<td> </td>
<td>Darok Kaminski</td>
<td></td>
<td>+1</td>
<td> </td>
<td>Physics engines (especially BulletX)</td>
</tr>
<tr>
<td />
<td>Gareth / Gwen</td>
<td>Gareth Nelson</td>
<td>Gareth Ellison</td>
<td>Gareth Nelson (on everywhere but SL)</td>
<td>BST (UTC+1)</td>
<td>Litesim Ltd</td>
<td>Grid servers, sim border crossing, avatar animations</td>
</tr>
<tr>
<td />
<td>[[User:dalien|dalien]]</td>
<td>Dalien Talbot</td>
<td>Dalien Talbot</td>
<td></td>
<td>+1</td>
<td>Mostly TCP-based</td>
<td>Small fixes; rev.eng./prototyping; nightlies; git-keeper </td>
</tr>
<tr>
<td />
<td>[[Alondria]]</td>
<td></td>
<td>Alondria LeFay</td>
<td>Alondria LeFay (OSGrid)</td>
<td>-8</td>
<td>Independent</td>
<td>Implementation of LSL functions and other scripting tidbits.</td>
</tr>
</table>

== Additional Developers/Testers/Contributors ==
These people have contributed bug reports, patches or other contributions to OpenSim. 
'''New comers please add yourself to bottom of the list!'''

<table border="1" cellpadding="2" cellspacing="0" class="wikitable sortable">
<tr>
<th>IRC Nick </th>
<th>Name</th>
<th>SL Avatar</th>
<th>Other Grid</th>
<th>Time Zone (UTC)</th>
<th>Org</th>
<th>Areas of Interest</th>
</tr>

<tr>
<td>[[User:Nebadon|Nebadon]]</td>
<td>Michael Cerquoni</td>
<td>Nebadon Izumi</td>
<td>Nebadon Izumi</td>
<td>-7 Arizona</td>
<td>Oni Kenkon Creations</td>
<td>Building, Scripting, Testing</td>
</tr>

<tr>
<td>[[User:jtclark48|jclark4]]</td>
<td>Jay Clark</td>
<td>Jay Clarke</td>
<td></td>
<td>-5</td>
<td>IBM</td>
<td>Physics, Grid Host, AI, Scripting, Testing</td>
</tr>

<tr>
<td>[[User:AdamStevenson|BigFootAg]]</td>
<td>Adam Stevenson</td>
<td>Adamus Petrov</td>
<td></td>
<td>-6</td>
<td>Texas A&M University</td>
<td>AI, Skynet, Evolving Systems, Biology</td>
</tr>

<tr>
<td>[[User:jeff1564|Jeff1564]]</td>
<td>Jeff</td>
<td>Potter Taurog</td>
<td></td>
<td>-8</td>
<td></td>
<td>Building, Scripting, Testing</td>
</tr>

<tr>
<td>Rock_Vacirca</td>
<td>Colin Withers</td>
<td>Rock Vacirca</td>
<td> </td>
<td>+1</td>
<td>http://rock-vacirca.blogspot.com</td>
<td>Testing, building, scripting, maintaining an opensim blog.</td>
</tr>
<tr>
<td>simsim</td>
<td>caocao</td>
<td> </td>
<td> </td>
<td>+9</td>
<td> </td>
<td>Testing whole functions of OpenSim system,working with OpenSim-Engine,reporting on OpenSim</td>
</tr>

<tr>
<td>[[User:Vicero Lambert|Vicero Lambert]]</td>
<td> </td>
<td> </td>
<td></td>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td>[[User:Magi|Magi]]</td>
<td>Andy Agnew</td>
<td>Magi Merlin</td>
<td></td>
<td>+10</td>
<td>Spun Pty Ltd</td>
<td>3D Web Integration, Database stuff and playing with the odds and ends box.</td>
</tr>

<tr>
<td>john_</td>
<td>John Moyer</td>
<td>VAJohn GeekSquad or Matthew Kendal</td>
<td></td>
<td>-5</td>
<td>Best Buy/Geek Squad</td>
<td>Tester</td>
</tr>

<tr>
<td>[[User:ClarkZone|ClarkZone]]</td>
<td>Troy Admin(@ClarkZone)</td>
<td>Troy Childs</td>
<td>Troy Admin (ClarkZone)</td>
<td>-5</td>
<td>Http://clarkzone.dyndns.org</td>
<td>Tester and Grid Host</td>
</tr>

<tr>
<td>[[User:aiaustin|aiaustin]]</td>
<td>Ai Austin</td>
<td>Ai Austin</td>
<td>Ai AIAI (AIAI Grid)</td>
<td>+0</td>
<td>AIAI, University of Edinburgh http://www.aiai.ed.ac.uk/~ai/ http://vue.ed.ac.uk/openvue/</td>
<td>Windows Vista tests Content testing Use of multiple VWs</td>
</tr>

<tr>
<td>Marc Manders</td>
<td>Marc Manders</td>
<td> </td>
<td> </td>
<td>+6</td>
<td>marcmanders@gmail.com</td>
<td>Creative features</td>
</tr>

<tr>
<td>[[User:balthazar|balthazar]]</td>
<td>Trevor Brooks</td>
<td>Balthazar Sin</td>
<td></td>
<td>-5</td>
<td>None</td>
<td>Terrains, testing and some small coding tasks</td>
</tr>

<tr>
<td>[[User:jimbo2120|jimbo2120]]</td>
<td>Michael Osias</td>
<td>Illuminous Beltran</td>
<td></td>
<td>-5</td>
<td>IBM</td>
<td>Grid, AI, Skynet, coding and testing</td>
</tr>

<tr>
<td>ZeroPoint</td>
<td> </td>
<td>Guilderoy Dench</td>
<td></td>
<td>-5</td>
<td> </td>
<td>Programming/Database</td>
</tr>

<tr>
<td>[[User:DerekTang|DerekTang]]</td>
<td>Derek Tang</td>
<td>Derek Timeless</td>
<td>Derek Tang (ChineseGrid)</td>
<td>+8</td>
<td>http://ChineseGrid.net</td>
<td>Running a public WINDOWS sim for testing, Docs, Helping Chinese users to enjoy OpenSim; building Chinese OpenSim communities. In construction...</td>
</tr>

<tr>
<td>[[User:TayB|TayB]]</td>
<td>Earl B</td>
<td>Taylor Boyau</td>
<td></td>
<td>-10</td>
<td>ViziGrid</td>
<td>Grid Host,Networking,Contributions & Testing.</td>
</tr>

<tr>
<td>[[User:JamieDav|JamieDav]]</td>
<td>Jamie David</td>
<td>Jamie David</td>
<td></td>
<td>+7</td>
<td>Forum</td>
<td>Grid, Sim, Avitar, Functionality</td>
</tr>

<tr>
<td>[[User:Krtaylor|Krtaylor]]</td>
<td>Kurt Taylor</td>
<td>Kurt Stringer </td>
<td></td>
<td>-6</td>
<td>IBM</td>
<td>Grid, Networking, Monitoring, Scripting, Inventory, Testing</td>
</tr>

<tr>
<td>[[User:Nink|Nink]]</td>
<td>Peter Finn</td>
<td>Nink Noonan</td>
<td></td>
<td>-5</td>
<td>IBM</td>
<td>Disruptive Influence.</td>
</tr>

<tr>
<td>[[User:Bruce|Bruce]]</td>
<td>Bruce Meerson</td>
<td>Bruce Meerson</td>
<td></td>
<td>+8</td>
<td>HiPiHi</td>
<td>Watching.</td>
</tr>

<tr>
<td>[[User:Darb|DarbD]]</td>
<td>Brian B. Quinn</td>
<td>Darb Dabney</td>
<td>regions near Marin</td>
<td>PST/SLT (-7 or -8)</td>
<td>County of Marin, California http://blog.simgis.com</td>
<td>LiDAR-based sculpties, real-world terrain, pursuit of civic paraverses </td>
</tr>

<tr>
<td>[[CharlieO]]</td>
<td>Dan</td>
<td>Charlie Omega</td>
<td></td>
<td> </td>
<td> </td>
<td>Mild coding/tweaking/simple feature adds, Stress testing/break stuff, Testing limits of existing code. Making sure [[LSL Status]] is up to date</td>
</tr>

<tr>
<td>oobscure</td>
<td> </td>
<td>Opensource Obscure</td>
<td></td>
<td>+1</td>
<td>http://www.opensim.it</td>
<td>Running a public Linux sim for testing, Docs, Helping italian users, Building opensim communities, Watching</td>
</tr>

<tr>
<td>pitman</td>
<td>Mike Pitman</td>
<td>Rez Tone</td>
<td></td>
<td> </td>
<td>IBM</td>
<td>Scientific visualization schemes, virt world product design, persistant workspaces, virt world based big biz</td>
</tr>

<tr>
<td>cmu</td>
<td>Christopher Mumme</td>
<td>Snook Destiny</td>
<td></td>
<td>+1</td>
<td>http://www.cmu-develop.de/ and research group "Collaboration Systems and CSCW" at Clausthal University of Technology</td>
<td>Testing OpenSim, working with OpenSim-Engine, reporting on OpenSim</td>
</tr>

<tr>
<td>[[Silpol]]</td>
<td>Andriy Tymchenko</td>
<td>Andy Tir</td>
<td></td>
<td>EET (+2/3)</td>
<td> http://silpol.blogspot.com/ (also visible at Nokia)</td>
<td>Highly uncoordinated mess with elements of palace games, under-table diplomacy, rebellion, coup d'état and mutiny. optionally pirate</td>
</tr>

<tr>
<td>[[User:Grumly|Grumly]]</td>
<td></td>
<td>Forest Klaar</td>
<td>Grumly TheBear</td>
<td>GMT+1</td>
<td>.NET MCAD Dev/Arch/Trainer http://www.devoteam.com</td>
<td>Trying to get into OpenSim code for now. Particularly interrested in data persistence. blog (Hello, Avatar!): http://lslblog.free.fr</td>
</tr>

<tr>
<td>[[daTwitch]]</td>
<td>James G. Stallings II</td>
<td> Lazarus Longstaff</td>
<td>Hiro Protagonist (OSGrid)</td>
<td>-5</td>
<td>House Husband</td>
<td>OSGrid Region owner, OSGrid Operator, Forum Admin, sometime wiki editor</td>
</tr>

<tr>
<td>gryc</td>
<td>Gryc Ueusp</td>
<td>Gryc Uriza</td>
<td>Gryc Uriza(OSGrid)</td>
<td>-6</td>
<td></td>
<td>PHP scripting, web interfaces, interconnectivity, cross-platformedness</td>
</tr>

<tr>
<td>[[User:Phrearch|Phrearch]]</td>
<td>Jeroen van Veen</td>
<td>Phrearch Miles</td>
<td>Phrearch Miles(OSGrid)</td>
<td>Amsterdam/Paris</td>
<td></td>
<td>WiXTD, Wikidoc and Moo</td>
</tr>

<tr>
<td>[[User:Burnman|Burnman]]</td>
<td>Allen Wilkins</td>
<td>Burnman Bedlam</td>
<td>Sid Green (United Grid)</td>
<td>Boston, USA</td>
<td>United Grid</td>
<td>Testing, testing, and more testing! Getting familiar with the source, interested in all aspects of the project.</td>
</tr>

<tr>
<td>[[User:krisbfunk|krisbfunk]]</td>
<td>Kris Bulman</td>
<td>Krisbfunk Vought</td>
<td>Krisbfunk Nocturnal(OSGrid)</td>
<td>PE, Canada (-4)</td>
<td>Edactive Technologies NocturnalEye Productions UPEI</td>
<td>Currently: Testing, bug reports, wiki updating, building on OSGrid</td>
</tr>

<tr>
<td>[[User:HashBox|HashBox]]</td>
<td> </td>
<td>Sibariel Darkstone</td>
<td>Sibariel Darkstone (OSGrid)</td>
<td>New Zealand (+12)</td>
<td></td>
<td>Testing, bug reports, and updating the wiki.</td>
</tr>

<tr>
<td>[[User:Kinoc|Kinoc]]</td>
<td>Kino Coursey</td>
<td>Daxxon Jaxxon</td>
<td>Daxxon Kinoc (OSgrid)</td>
<td>-6</td>
<td>Daxtron Laboratories http://www.daxtron.com University of North Texas</td>
<td>AI, Semantic web, Ontologies, Natural Laanguage Processing, Cyc, Bots, NPC </td>
</tr>

<tr>
<td>[[User:trapuh|trapuh]]</td>
<td>Pedro Ribeiro</td>
<td>Vaiten Forder</td>
<td></td>
<td>GMT</td>
<td>University Student, Escola Superior de Educação de Viseu, Portugal </td>
<td>Testing, eventual bug reports and wiki. Music, web/digital arts and php+sql.</td>
</tr>

<tr>
<td>[[User:SonicViz|SonicViz]]</td>
<td>Paul Cohen</td>
<td>Komuso Tokugawa</td>
<td></td>
<td>+9</td>
<td>Http://sonicviz.com</td>
<td>Audio/Music, Interactive Music, Control Protocols, Interfaces, VisualFX, Procedural animation/Generative systems + testing and general dev</td>
</tr>

<tr>
<td>[[User:Mokele|mokele]]</td>
<td>Scott Norman</td>
<td>Mokelembembe Mokeev</td>
<td></td>
<td>-8 (Southern California)</td>
<td>Web Developer (PHP and MySQL)</td>
<td>Interested in seeing running on PowerPC Macs which it is. So, when I can, I'll compile and test on PowerPC Mac (PowerBook G4) and submit reports and then update the wiki if need on installing on Mac. Also have a Ubuntu 7.10 server that I can do testing on too.</td>
</tr>

<tr>
<td>[[User:devalnor|devalnor]]</td>
<td>Devalnor</td>
<td>M. Watkin</td>
<td></td>
<td>+1 (Belgium)</td>
<td></td>
<td>Small Patch code, bug reports, and updating the wiki.</td>
</tr>

<tr>
<td>[[User:Ezekiel|Ezekiel]]</td>
<td>Ezekiel</td>
<td>Ezekiel Zabelin</td>
<td></td>
<td>+1 </td>
<td>http://www.yosims.com </td>
<td>Concepts, business aspects of virtual worlds - web developer (PHP, MySQL, Javascript, LSL) </td>
</tr>

<tr>
<td>[[User:Buggmaster|Buggmaster]]</td>
<td>Mike D</td>
<td>Bug Master</td>
<td>None</td>
<td>-8 </td>
<td>http://www.adultmetaverse.com</td>
<td>Grid, Data/Web PHP/PERL/MySQL</td>
</tr>

<tr>
<td>[[User:Nixnerd|nixnerd]]</td>
<td></td>
<td>Dangerously Moody</td>
<td>None</td>
<td>GMT </td>
<td>http://www.integratedtechnologies.eu</td>
<td>Cross Platform Testing, Feedback, Bug Reporting</td>
</tr>

<tr>
<td>[[User:MoHax|mohax]]</td>
<td>Mo Hax</td>
<td>Mo Hax</td>
<td></td>
<td>-5 Eastern</td>
<td>IBM</td>
<td>Testing, Feedback, Content Contributions, Bug Reporting, Documenting, Development</td>
</tr>

<tr>
<td>[[User:Webmage|webmage]]</td>
<td>webmage</td>
<td>Leyla Masala</td>
<td>Web Mage</td>
<td>+1</td>
<td>IBM</td>
<td>Testing, terrain</td>
</tr>

<tr>
<td>[[User:NLStitch|NLStitch]]</td>
<td>Marijn Oosterveld</td>
<td>Stitch Seale</td>
<td>NYA</td>
<td>GMT +1 Amsterdam</td>
<td>Twingate Systems (http://www.twingate.nl) HanzeHogeschool Groningen, Netherlands
</td>
<td>Programming, Photography, AI</td>
</tr>

<tr>
<td>[[User:Ideia Boa|Ideia Boa]]</td>
<td>Joao Lopes</td>
<td>Ideia Boa</td>
<td>Ideia Boa or Boa Ideia in some grids</td>
<td>GTM+1 Stockholm/Sweden</td>
<td>WorldSimTERRA - Virtual World that speaks Portuguese too http://www.worldsimterra.com</td>
<td>Testing and more testing! Updating the original wiki and translating the OpenSim Wiki into Portuguese and reporting on OpenSim</td>
</tr>

<tr>
<td>[[User:Lulurun|lulurun]]</td>
<td>liu</td>
<td> </td>
<td> </td>
<td>+9</td>
<td>3Di Inc, Japan http://www.3di.jp</td>
<td>Patches, openid, server performance, UGAI</td>
</tr>

<tr>
<td>[[User:Carlosroundel|Carlosrounde]]</td>
<td>Carlosroundel</td>
<td>Carlos Roundel</td>
<td> </td>
<td>+1</td>
<td>Cyberlandia Italy http://www.cyberlandia.net</td>
<td>Grid, programmer, database, tester</td>
</tr>

<tr>
<td>[[User:Mikebert|Mikebert]]</td>
<td>Michael Strunck</td>
<td>Mikebert Miles</td>
<td>Mikebert M34</td>
<td>+1</td>
<td>OpenSIM Wiki, Germany http://www.opensim.de</td>
<td>German Wiki, Translater, Server Performance (Linux/Windows), Tester, Feedback, Bug Reporting, Server-Hosting</td>
</tr>

<tr>
<td>[[User:Fly-man-|Fly-Man-]]</td>
<td>Laurence</td>
<td></td>
<td>Fly Man</td>
<td>+1</td>
<td></td>
<td>Testing, OpenSimSearch, OpenSimProfile, OpenWiredux</td>
</tr>

<tr>
<td>Taoki</td>
<td>Mircea Kitsune / Taoki Vixen</td>
<td>Mircea Kitsune (OSGrid) / Mircea Lobo (LL grid)</td>
<td> </td>
<td>GMT +2</td>
<td> </td>
<td>Usually testing and bug reporting but I also make smaller patches where I know what to do.</td>
</tr>

<tr>
<td>[[User:Patnad|Patnad]]</td>
<td>Patrick</td>
<td>Patnad Babii</td>
<td>Patnad Babii (OSGrid)</td>
<td>GMT -5</td>
<td>RezzMe Technologies http://www.rezzme.com</td>
<td>Bug testing and reporting, I code C# and have submitted a few patches</td>
</tr>

<tr>
<td>[[User:Hallow Palmer|Hallow Palmer]]</td>
<td>Markus</td>
<td>Hallow Palmer</td>
<td> </td>
<td>+1</td>
<td>Grid4Us http://www.grid4us.net</td>
<td>Server Performance (Windows), Tester, Feedback, Business concepts,Bug Reporting, Server-Hosting</td>
</tr>

<tr>
<td>[[User:^DarkMan|^DarkMan]]</td>
<td>Brian Adair</td>
<td>Patrick Ouachita</td>
<td>Brian Adair | Patrick Meta</td>
<td>-6 CST</td>
<td>RealMetaLife | B&H Networking</td>
<td>Building, Scripting, Testing, etc.</td>
</tr>

<tr>
<td>[[User:tlaukkan|Tommi Laukkanen]]</td>
<td>Tommi Laukkanen</td>
<td> </td>
<td>Tommi Laukkanen</td>
<td>+2 GMT</td>
<td>http://www.bubblecloud.org</td>
<td>Protocols ([http://www.bubblecloud.org MXP]), NHibernate, Scrip API, Map Generation, Bug Fixes, Grid Hosting</td>
</tr>
<tr>
<td>[[User:Mystical|Mystical]]</td>
<td>Kevin Tweedy</td>
<td>Mystical Demina</td>
<td>Mystical Demina</td>
<td>-5</td>
<td>Extreme Reality Grid http://www.XRGrid.com</td>
<td>Windows Communication Framework, Windows Workflow,Entity Framework, MSSQL Enhancements,Commerce, Content,DotNetNuke based portal, development services</td>
</tr>

<tr>
<td>[[User:Godfrey|Godfrey]]</td>
<td>Jeff Lee</td>
<td>Warin Cascabel</td>
<td> </td>
<td>-5 (EST5EDT)</td>
<td></td>
<td>Testing, minor bugfixes. Scripting, building, animating</td>
</tr>
<tr>
<td>Jamenai</td>
<td>Christopher Händler</td>
<td>Jamenai Luik</td>
<td>Jamenai Luik</td>
<td>+1</td>
<td>Playneko Grid | XIMDEX Jamenai http://www.playneko.de http://www.ximdex.de</td>
<td>Performance,Bug Reporting, Hosting, Grid-Owner,(PHP, MySQL, Perl, JavaScript, LSL)</td>
</tr>

<tr>
<td>[[User:bikcmp|bikcmp]]</td>
<td>Jason</td>
<td>Jake1500 Allen</td>
<td>Jason Helios (The Helios Grid)</td>
<td>EST</td>
<td>Blue Software</td>
<td>Search, groups, land, and currency</td>
</tr>

<tr>
<td>[[User:mark.malewski|Slipaway]]</td>
<td>Mark Malewski</td>
<td>Chris Rock</td>
<td></td>
<td>-6 (-5 during summer - CDT)</td>
<td>NexTECH / Joopla</td>
<td>Web development & systems integration, terrain, WIKI documentation, tutorials, testing, bug reporting and feedback. </td>
</tr>

<tr>
<td>barakademi </td>
<td>Steve Topp</td>
<td>barakademi Barzane</td>
<td>same avi on baragrid OSgrid Grid4us sciencesim</td>
<td>utc+1 (CET) paris</td>
<td>http://xbot-sl.barakademi.org http://vps.barakademi.org/oswi http://vps.barakademi.org/oswi/loginscreen.php </td>
<td>Music LiveMusic MetaverseMusic Opensim Libomv Mono-2.4 Linux (suse,debian,ubuntu) Admin Scripting Automating Development Intergration php mysql bash nant +++</td>
</tr>
<tr>
<td>[[User:RemedyTomm|RemedyTomm]]</td>
<td>Tom Grimshaw</td>
<td>Tomm Remedy</td>
<td>KGrid: Casper Warden
OSGrid: Tomm Remedy</td>
<td>UTC+0 (BST)</td>
<td>Remedy Communications</td>
<td>Texture pipeline, Groups, ObjectUpdates</td>
</tr>
<tr>
<td>[[User:robert_d|robert_d]]</td>
<td>Robert Dzikowski</td>
<td> </td>
<td>OSGrid: robert_d 13</td>
<td>UTC+1</td>
<td>[http://blog.rd-it.net http://blog.rd-it.net]</td>
<td>Region Modules, Tutorials</td>
</tr>

</table>
[[Category:Main]]
[[Category:Development]]
[[Category:Tech Reference]]
[[Category:Help]]

User:Robert d

2009-06-02T17:20:20Z

Robert d:

Robert Dzikowski, [http://blog.rd-it.net http://blog.rd-it.net]

Development Team

2009-06-02T17:11:56Z

Robert d: /* Additional Developers/Testers/Contributors */

__NOTOC__
{{Template:Quicklinks}}

[[Technical Reference | Technical Reference]] -> [[Technical Reference/terms | Terms]] -> [[Development_Team | Core Development Team]]

== Active OpenSim Core Developers ==
These people have commit access to our central SVN server and are [http://www.ohloh.net/projects/4753/contributors regular contributors] to the codebase.
** '''Only voted in developers should be listed here, please do not list yourself'''
(please add in as much info as you like for your name)

<table border="1" cellpadding="2" cellspacing="0" class="sortable">
<tr>
<th>Photo </th>
<th>IRC Nick </th>
<th>Name</th>
<th>SL Avatar</th>
<th>Other Grid</th>
<th>Time Zone (UTC)</th>
<th>Org</th>
<th>Areas of Interest</th>
</tr>

<tr>
<td />
<td>[[User:MW |MW ]]</td>
<td>Darren</td>
<td>OSG:Wright Juran TN:Darren Guard</td>
<td></td>
<td>0</td>
<td>[http://tribalmedia.se/ Tribal Media AB]</td>
<td>Everything</td>
</tr>
<tr>
<td> </td>
<td>[[User:lbsa71|lbsa71]]</td>
<td>Stefan Andersson</td>
<td>Tribal Skytower</td>
<td>OSG:Stefan Andersson TN:Stefan Andersson</td>
<td>+1</td>
<td>[http://tribalmedia.se/ Tribal Media AB]</td>
<td>Web Integration</td>
</tr>
<tr>
<tr>
<td />
<td>[[User:Adam Frisby|Adam Frisby]]</td>
<td>Adam Frisby</td>
<td>Adam Zaius</td>
<td></td>
<td>+8</td>
<td>DeepThink Pty Ltd</td>
<td>Terrain, Performance</td>
</tr>
<tr>
<td />
<td>[[User:MingChen|MingChen]]</td>
<td>Mike/Michael Ortman</td>
<td>Ming Chen</td>
<td></td>
<td>-6 (-5 in Summer)</td>
<td>DeepThink Pty Ltd</td>
<td>Estate/Parcel Support/Modules/Keeping things all neat and tidy.</td>
</tr>
<tr>
<td />
<td>[[User:SeanDague|sdague]]</td>
<td>Sean Dague</td>
<td>Neas Bade</td>
<td></td>
<td>-5</td>
<td>IBM</td>
<td>Database, Linux, Testing, Misc</td>
</tr>
<tr>
<td />
<td>[[User:Tedd|Tedd]]</td>
<td>Tedd Hansen</td>
<td>Tedd Maa</td>
<td></td>
<td>+1</td>
<td>Tedd Hansen</td>
<td>Programming/Scripting/Architecture</td>
</tr>
<tr>
<td />
<td>ckrinke</td>
<td>Charles Krinke</td>
<td>Charlesk Bing</td>
<td></td>
<td>-8</td>
<td> </td>
<td>Reliability/Grid servers/ll-functions</td>
</tr>
<tr>
<td />
<td>[[User:chi11ken|chi11ken]]</td>
<td>Jeff Ames</td>
<td>Chillken Proto</td>
<td> </td>
<td>+9</td>
<td>[http://www.genkii.com Genkii]</td>
<td> </td>
</tr>
<tr>
<td />
<td>[[User:adjohn|adjohn]]</td>
<td>Adam Johnson</td>
<td>Zeuz Zenovka</td>
<td> </td>
<td>+9</td>
<td>[http://www.genkii.com Genkii]</td>
<td> </td>
</tr>
<tr>
<td />
<td>[[User:joha1|joha1]]</td>
<td>Johan Berntsson</td>
<td>Joppi Brandenburg</td>
<td> </td>
<td>+9</td>
<td>[http://www.3di.jp/en/ 3Di Inc, Japan] http://www.3di.jp/en/</td>
<td>Performance, packet handling/libSL</td>
</tr>
<tr>
<td />
<td>[[User:Teravus|Teravus]]</td>
<td>Teravus</td>
<td>Teravus Ousley</td>
<td></td>
<td>-5</td>
<td>W3z</td>
<td>Physics & Admin tools, A working sim.</td>
</tr>
<tr>
<td />
<td>[[User:justincc|justincc]]</td>
<td>Justin Clark-Casey</td>
<td>Lulworth Beaumont</td>
<td>Justin Clark-Casey (osgrid)</td>
<td>0</td>
<td>Black Dress Technology [http://justincc.wordpress.com justincc's OpenSim blog]</td>
<td>Grid, performance & reliability, inventory (avatar and object), assets, scenes, etc.</td>
</tr>
<tr>
<td />
<td>[[User:DrScofield|drscofld]]</td>
<td>Dirk Husemann</td>
<td>Dr Scofield</td>
<td></td>
<td>+1</td>
<td>IBM</td>
<td>Reliability, networking protocols, voice, inventory, assets, remote control, and pretty much everything else :-)</td>
</tr>
<tr>
<td />
<td>[[User:dahlia|dahlia]]</td>
<td>T. Hoff</td>
<td>Dahlia Trimble</td>
<td></td>
<td>-8 / -7</td>
<td>Independent</td>
<td>Collision geometry, various math and physics issues, occasional bug fixes and random enhancements</td>
</tr>
<tr>
<td></td>
<td>[[User:Mikem|mikem]]</td>
<td>Mike</td>
<td> </td>
<td> </td>
<td>+9</td>
<td>[http://www.3di.jp/en/ 3Di Inc, Japan] http://www.3di.jp/en/</td>
<td>Patches, scripting improvements, LSL compiler</td>
</tr>
<tr>
<td></td>
<td>[[User:Melanie_T|Melanie_T]]</td>
<td>Melanie</td>
<td>Melanie Milland</td>
<td> </td>
<td>+1</td>
<td>Independent</td>
<td>Scripting, Prims/Scene, Life, The Universe, and Everything</td>
</tr>
<tr>
<td></td>
<td>[[User:HomerHorwitz|homerh]]</td>
<td>Homer Horwitz</td>
<td>Homer Horwitz</td>
<td> </td>
<td>+2</td>
<td>Independent</td>
<td>Rev. engineering, "now, that's funny" problems, but still interested in all parts of it</td>
</tr>
<tr>
<td></td>
<td>[[User:Diva|Diva]]</td>
<td>Crista Lopes</td>
<td>Diva Canto</td>
<td>Crista Lopes / Diva Canto</td>
<td>-8</td>
<td>University of California, Irvine</td>
<td>Everything, except databases</td>
</tr>
<tr>
<td />
<td>[[User:nlin|nlin]]</td>
<td>N Lin</td>
<td>Standard Drucker</td>
<td> </td>
<td>+9</td>
<td>[http://www.3di.jp/en/ 3Di Inc, Japan] http://www.3di.jp/en/</td>
<td>Physics, scripting, more to come</td>
</tr>
<tr>
<td />
<td>[[User:arthursv|arthursv]]</td>
<td>Arthur Valadares</td>
<td>Arthur Valadares</td>
<td>NONE</td>
<td>-3</td>
<td>IBM</td>
<td>Unit testing, database plugins, bug fixes, general </td>
</tr>

</table>

== Retired OpenSim core developers ==

These people are core developers who have transcended our mortal plane (i.e. they are no longer active).

<table border="1" cellpadding="2" cellspacing="0" class="sortable">
<tr>
<th>Photo </th>
<th>IRC Nick </th>
<th>Name</th>
<th>SL Avatar</th>
<th>Other Grid</th>
<th>Time Zone (UTC)</th>
<th>Org</th>
<th>Areas of Interest</th>
</tr>
<tr>
<td />
<td>[[User:babblefrog|babblefrog]]</td>
<td>Brian McBee</td>
<td>Dogen Coldstream</td>
<td>Babblefrog Ballistic (osgrid)</td>
<td>-8</td>
<td>Disorganized</td>
<td> </td>
</tr>
<tr>
<td />
<td>[[User:danx0r|danx0r]]</td>
<td>Dan Miller</td>
<td>Albert Pascal</td>
<td></td>
<td>-8</td>
<td>squiggle.com</td>
<td>PHEEZIKS; everything</td>
</tr>
<tr>
<td />
<td>Tleiades</td>
<td> </td>
<td>Tleiades Hax</td>
<td></td>
<td>+1</td>
<td> </td>
<td>Grid servers/Database</td>
</tr>
<tr>
<td />
<td>[[User:Darok|Darok]]</td>
<td> </td>
<td>Darok Kaminski</td>
<td></td>
<td>+1</td>
<td> </td>
<td>Physics engines (especially BulletX)</td>
</tr>
<tr>
<td />
<td>Gareth / Gwen</td>
<td>Gareth Nelson</td>
<td>Gareth Ellison</td>
<td>Gareth Nelson (on everywhere but SL)</td>
<td>BST (UTC+1)</td>
<td>Litesim Ltd</td>
<td>Grid servers, sim border crossing, avatar animations</td>
</tr>
<tr>
<td />
<td>[[User:dalien|dalien]]</td>
<td>Dalien Talbot</td>
<td>Dalien Talbot</td>
<td></td>
<td>+1</td>
<td>Mostly TCP-based</td>
<td>Small fixes; rev.eng./prototyping; nightlies; git-keeper </td>
</tr>
<tr>
<td />
<td>[[Alondria]]</td>
<td></td>
<td>Alondria LeFay</td>
<td>Alondria LeFay (OSGrid)</td>
<td>-8</td>
<td>Independent</td>
<td>Implementation of LSL functions and other scripting tidbits.</td>
</tr>
</table>

== Additional Developers/Testers/Contributors ==
These people have contributed bug reports, patches or other contributions to OpenSim. 
'''New comers please add yourself to bottom of the list!'''

<table border="1" cellpadding="2" cellspacing="0" class="wikitable sortable">
<tr>
<th>IRC Nick </th>
<th>Name</th>
<th>SL Avatar</th>
<th>Other Grid</th>
<th>Time Zone (UTC)</th>
<th>Org</th>
<th>Areas of Interest</th>
</tr>

<tr>
<td>[[User:Nebadon|Nebadon]]</td>
<td>Michael Cerquoni</td>
<td>Nebadon Izumi</td>
<td>Nebadon Izumi</td>
<td>-7 Arizona</td>
<td>Oni Kenkon Creations</td>
<td>Building, Scripting, Testing</td>
</tr>

<tr>
<td>[[User:jtclark48|jclark4]]</td>
<td>Jay Clark</td>
<td>Jay Clarke</td>
<td></td>
<td>-5</td>
<td>IBM</td>
<td>Physics, Grid Host, AI, Scripting, Testing</td>
</tr>

<tr>
<td>[[User:AdamStevenson|BigFootAg]]</td>
<td>Adam Stevenson</td>
<td>Adamus Petrov</td>
<td></td>
<td>-6</td>
<td>Texas A&M University</td>
<td>AI, Skynet, Evolving Systems, Biology</td>
</tr>

<tr>
<td>[[User:jeff1564|Jeff1564]]</td>
<td>Jeff</td>
<td>Potter Taurog</td>
<td></td>
<td>-8</td>
<td></td>
<td>Building, Scripting, Testing</td>
</tr>

<tr>
<td>Rock_Vacirca</td>
<td>Colin Withers</td>
<td>Rock Vacirca</td>
<td> </td>
<td>+1</td>
<td>http://rock-vacirca.blogspot.com</td>
<td>Testing, building, scripting, maintaining an opensim blog.</td>
</tr>
<tr>
<td>simsim</td>
<td>caocao</td>
<td> </td>
<td> </td>
<td>+9</td>
<td> </td>
<td>Testing whole functions of OpenSim system,working with OpenSim-Engine,reporting on OpenSim</td>
</tr>

<tr>
<td>[[User:Vicero Lambert|Vicero Lambert]]</td>
<td> </td>
<td> </td>
<td></td>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td>[[User:Magi|Magi]]</td>
<td>Andy Agnew</td>
<td>Magi Merlin</td>
<td></td>
<td>+10</td>
<td>Spun Pty Ltd</td>
<td>3D Web Integration, Database stuff and playing with the odds and ends box.</td>
</tr>

<tr>
<td>john_</td>
<td>John Moyer</td>
<td>VAJohn GeekSquad or Matthew Kendal</td>
<td></td>
<td>-5</td>
<td>Best Buy/Geek Squad</td>
<td>Tester</td>
</tr>

<tr>
<td>[[User:ClarkZone|ClarkZone]]</td>
<td>Troy Admin(@ClarkZone)</td>
<td>Troy Childs</td>
<td>Troy Admin (ClarkZone)</td>
<td>-5</td>
<td>Http://clarkzone.dyndns.org</td>
<td>Tester and Grid Host</td>
</tr>

<tr>
<td>[[User:aiaustin|aiaustin]]</td>
<td>Ai Austin</td>
<td>Ai Austin</td>
<td>Ai AIAI (AIAI Grid)</td>
<td>+0</td>
<td>AIAI, University of Edinburgh http://www.aiai.ed.ac.uk/~ai/ http://vue.ed.ac.uk/openvue/</td>
<td>Windows Vista tests Content testing Use of multiple VWs</td>
</tr>

<tr>
<td>Marc Manders</td>
<td>Marc Manders</td>
<td> </td>
<td> </td>
<td>+6</td>
<td>marcmanders@gmail.com</td>
<td>Creative features</td>
</tr>

<tr>
<td>[[User:balthazar|balthazar]]</td>
<td>Trevor Brooks</td>
<td>Balthazar Sin</td>
<td></td>
<td>-5</td>
<td>None</td>
<td>Terrains, testing and some small coding tasks</td>
</tr>

<tr>
<td>[[User:jimbo2120|jimbo2120]]</td>
<td>Michael Osias</td>
<td>Illuminous Beltran</td>
<td></td>
<td>-5</td>
<td>IBM</td>
<td>Grid, AI, Skynet, coding and testing</td>
</tr>

<tr>
<td>ZeroPoint</td>
<td> </td>
<td>Guilderoy Dench</td>
<td></td>
<td>-5</td>
<td> </td>
<td>Programming/Database</td>
</tr>

<tr>
<td>[[User:DerekTang|DerekTang]]</td>
<td>Derek Tang</td>
<td>Derek Timeless</td>
<td>Derek Tang (ChineseGrid)</td>
<td>+8</td>
<td>http://ChineseGrid.net</td>
<td>Running a public WINDOWS sim for testing, Docs, Helping Chinese users to enjoy OpenSim; building Chinese OpenSim communities. In construction...</td>
</tr>

<tr>
<td>[[User:TayB|TayB]]</td>
<td>Earl B</td>
<td>Taylor Boyau</td>
<td></td>
<td>-10</td>
<td>ViziGrid</td>
<td>Grid Host,Networking,Contributions & Testing.</td>
</tr>

<tr>
<td>[[User:JamieDav|JamieDav]]</td>
<td>Jamie David</td>
<td>Jamie David</td>
<td></td>
<td>+7</td>
<td>Forum</td>
<td>Grid, Sim, Avitar, Functionality</td>
</tr>

<tr>
<td>[[User:Krtaylor|Krtaylor]]</td>
<td>Kurt Taylor</td>
<td>Kurt Stringer </td>
<td></td>
<td>-6</td>
<td>IBM</td>
<td>Grid, Networking, Monitoring, Scripting, Inventory, Testing</td>
</tr>

<tr>
<td>[[User:Nink|Nink]]</td>
<td>Peter Finn</td>
<td>Nink Noonan</td>
<td></td>
<td>-5</td>
<td>IBM</td>
<td>Disruptive Influence.</td>
</tr>

<tr>
<td>[[User:Bruce|Bruce]]</td>
<td>Bruce Meerson</td>
<td>Bruce Meerson</td>
<td></td>
<td>+8</td>
<td>HiPiHi</td>
<td>Watching.</td>
</tr>

<tr>
<td>[[User:Darb|DarbD]]</td>
<td>Brian B. Quinn</td>
<td>Darb Dabney</td>
<td>regions near Marin</td>
<td>PST/SLT (-7 or -8)</td>
<td>County of Marin, California http://blog.simgis.com</td>
<td>LiDAR-based sculpties, real-world terrain, pursuit of civic paraverses </td>
</tr>

<tr>
<td>[[CharlieO]]</td>
<td>Dan</td>
<td>Charlie Omega</td>
<td></td>
<td> </td>
<td> </td>
<td>Mild coding/tweaking/simple feature adds, Stress testing/break stuff, Testing limits of existing code. Making sure [[LSL Status]] is up to date</td>
</tr>

<tr>
<td>oobscure</td>
<td> </td>
<td>Opensource Obscure</td>
<td></td>
<td>+1</td>
<td>http://www.opensim.it</td>
<td>Running a public Linux sim for testing, Docs, Helping italian users, Building opensim communities, Watching</td>
</tr>

<tr>
<td>pitman</td>
<td>Mike Pitman</td>
<td>Rez Tone</td>
<td></td>
<td> </td>
<td>IBM</td>
<td>Scientific visualization schemes, virt world product design, persistant workspaces, virt world based big biz</td>
</tr>

<tr>
<td>cmu</td>
<td>Christopher Mumme</td>
<td>Snook Destiny</td>
<td></td>
<td>+1</td>
<td>http://www.cmu-develop.de/ and research group "Collaboration Systems and CSCW" at Clausthal University of Technology</td>
<td>Testing OpenSim, working with OpenSim-Engine, reporting on OpenSim</td>
</tr>

<tr>
<td>[[Silpol]]</td>
<td>Andriy Tymchenko</td>
<td>Andy Tir</td>
<td></td>
<td>EET (+2/3)</td>
<td> http://silpol.blogspot.com/ (also visible at Nokia)</td>
<td>Highly uncoordinated mess with elements of palace games, under-table diplomacy, rebellion, coup d'état and mutiny. optionally pirate</td>
</tr>

<tr>
<td>[[User:Grumly|Grumly]]</td>
<td></td>
<td>Forest Klaar</td>
<td>Grumly TheBear</td>
<td>GMT+1</td>
<td>.NET MCAD Dev/Arch/Trainer http://www.devoteam.com</td>
<td>Trying to get into OpenSim code for now. Particularly interrested in data persistence. blog (Hello, Avatar!): http://lslblog.free.fr</td>
</tr>

<tr>
<td>[[daTwitch]]</td>
<td>James G. Stallings II</td>
<td> Lazarus Longstaff</td>
<td>Hiro Protagonist (OSGrid)</td>
<td>-5</td>
<td>House Husband</td>
<td>OSGrid Region owner, OSGrid Operator, Forum Admin, sometime wiki editor</td>
</tr>

<tr>
<td>gryc</td>
<td>Gryc Ueusp</td>
<td>Gryc Uriza</td>
<td>Gryc Uriza(OSGrid)</td>
<td>-6</td>
<td></td>
<td>PHP scripting, web interfaces, interconnectivity, cross-platformedness</td>
</tr>

<tr>
<td>[[User:Phrearch|Phrearch]]</td>
<td>Jeroen van Veen</td>
<td>Phrearch Miles</td>
<td>Phrearch Miles(OSGrid)</td>
<td>Amsterdam/Paris</td>
<td></td>
<td>WiXTD, Wikidoc and Moo</td>
</tr>

<tr>
<td>[[User:Burnman|Burnman]]</td>
<td>Allen Wilkins</td>
<td>Burnman Bedlam</td>
<td>Sid Green (United Grid)</td>
<td>Boston, USA</td>
<td>United Grid</td>
<td>Testing, testing, and more testing! Getting familiar with the source, interested in all aspects of the project.</td>
</tr>

<tr>
<td>[[User:krisbfunk|krisbfunk]]</td>
<td>Kris Bulman</td>
<td>Krisbfunk Vought</td>
<td>Krisbfunk Nocturnal(OSGrid)</td>
<td>PE, Canada (-4)</td>
<td>Edactive Technologies NocturnalEye Productions UPEI</td>
<td>Currently: Testing, bug reports, wiki updating, building on OSGrid</td>
</tr>

<tr>
<td>[[User:HashBox|HashBox]]</td>
<td> </td>
<td>Sibariel Darkstone</td>
<td>Sibariel Darkstone (OSGrid)</td>
<td>New Zealand (+12)</td>
<td></td>
<td>Testing, bug reports, and updating the wiki.</td>
</tr>

<tr>
<td>[[User:Kinoc|Kinoc]]</td>
<td>Kino Coursey</td>
<td>Daxxon Jaxxon</td>
<td>Daxxon Kinoc (OSgrid)</td>
<td>-6</td>
<td>Daxtron Laboratories http://www.daxtron.com University of North Texas</td>
<td>AI, Semantic web, Ontologies, Natural Laanguage Processing, Cyc, Bots, NPC </td>
</tr>

<tr>
<td>[[User:trapuh|trapuh]]</td>
<td>Pedro Ribeiro</td>
<td>Vaiten Forder</td>
<td></td>
<td>GMT</td>
<td>University Student, Escola Superior de Educação de Viseu, Portugal </td>
<td>Testing, eventual bug reports and wiki. Music, web/digital arts and php+sql.</td>
</tr>

<tr>
<td>[[User:SonicViz|SonicViz]]</td>
<td>Paul Cohen</td>
<td>Komuso Tokugawa</td>
<td></td>
<td>+9</td>
<td>Http://sonicviz.com</td>
<td>Audio/Music, Interactive Music, Control Protocols, Interfaces, VisualFX, Procedural animation/Generative systems + testing and general dev</td>
</tr>

<tr>
<td>[[User:Mokele|mokele]]</td>
<td>Scott Norman</td>
<td>Mokelembembe Mokeev</td>
<td></td>
<td>-8 (Southern California)</td>
<td>Web Developer (PHP and MySQL)</td>
<td>Interested in seeing running on PowerPC Macs which it is. So, when I can, I'll compile and test on PowerPC Mac (PowerBook G4) and submit reports and then update the wiki if need on installing on Mac. Also have a Ubuntu 7.10 server that I can do testing on too.</td>
</tr>

<tr>
<td>[[User:devalnor|devalnor]]</td>
<td>Devalnor</td>
<td>M. Watkin</td>
<td></td>
<td>+1 (Belgium)</td>
<td></td>
<td>Small Patch code, bug reports, and updating the wiki.</td>
</tr>

<tr>
<td>[[User:Ezekiel|Ezekiel]]</td>
<td>Ezekiel</td>
<td>Ezekiel Zabelin</td>
<td></td>
<td>+1 </td>
<td>http://www.yosims.com </td>
<td>Concepts, business aspects of virtual worlds - web developer (PHP, MySQL, Javascript, LSL) </td>
</tr>

<tr>
<td>[[User:Buggmaster|Buggmaster]]</td>
<td>Mike D</td>
<td>Bug Master</td>
<td>None</td>
<td>-8 </td>
<td>http://www.adultmetaverse.com</td>
<td>Grid, Data/Web PHP/PERL/MySQL</td>
</tr>

<tr>
<td>[[User:Nixnerd|nixnerd]]</td>
<td></td>
<td>Dangerously Moody</td>
<td>None</td>
<td>GMT </td>
<td>http://www.integratedtechnologies.eu</td>
<td>Cross Platform Testing, Feedback, Bug Reporting</td>
</tr>

<tr>
<td>[[User:MoHax|mohax]]</td>
<td>Mo Hax</td>
<td>Mo Hax</td>
<td></td>
<td>-5 Eastern</td>
<td>IBM</td>
<td>Testing, Feedback, Content Contributions, Bug Reporting, Documenting, Development</td>
</tr>

<tr>
<td>[[User:Webmage|webmage]]</td>
<td>webmage</td>
<td>Leyla Masala</td>
<td>Web Mage</td>
<td>+1</td>
<td>IBM</td>
<td>Testing, terrain</td>
</tr>

<tr>
<td>[[User:NLStitch|NLStitch]]</td>
<td>Marijn Oosterveld</td>
<td>Stitch Seale</td>
<td>NYA</td>
<td>GMT +1 Amsterdam</td>
<td>Twingate Systems (http://www.twingate.nl) HanzeHogeschool Groningen, Netherlands
</td>
<td>Programming, Photography, AI</td>
</tr>

<tr>
<td>[[User:Ideia Boa|Ideia Boa]]</td>
<td>Joao Lopes</td>
<td>Ideia Boa</td>
<td>Ideia Boa or Boa Ideia in some grids</td>
<td>GTM+1 Stockholm/Sweden</td>
<td>WorldSimTERRA - Virtual World that speaks Portuguese too http://www.worldsimterra.com</td>
<td>Testing and more testing! Updating the original wiki and translating the OpenSim Wiki into Portuguese and reporting on OpenSim</td>
</tr>

<tr>
<td>[[User:Lulurun|lulurun]]</td>
<td>liu</td>
<td> </td>
<td> </td>
<td>+9</td>
<td>3Di Inc, Japan http://www.3di.jp</td>
<td>Patches, openid, server performance, UGAI</td>
</tr>

<tr>
<td>[[User:Carlosroundel|Carlosrounde]]</td>
<td>Carlosroundel</td>
<td>Carlos Roundel</td>
<td> </td>
<td>+1</td>
<td>Cyberlandia Italy http://www.cyberlandia.net</td>
<td>Grid, programmer, database, tester</td>
</tr>

<tr>
<td>[[User:Mikebert|Mikebert]]</td>
<td>Michael Strunck</td>
<td>Mikebert Miles</td>
<td>Mikebert M34</td>
<td>+1</td>
<td>OpenSIM Wiki, Germany http://www.opensim.de</td>
<td>German Wiki, Translater, Server Performance (Linux/Windows), Tester, Feedback, Bug Reporting, Server-Hosting</td>
</tr>

<tr>
<td>[[User:Fly-man-|Fly-Man-]]</td>
<td>Laurence</td>
<td></td>
<td>Fly Man</td>
<td>+1</td>
<td></td>
<td>Testing, OpenSimSearch, OpenSimProfile, OpenWiredux</td>
</tr>

<tr>
<td>Taoki</td>
<td>Mircea Kitsune / Taoki Vixen</td>
<td>Mircea Kitsune (OSGrid) / Mircea Lobo (LL grid)</td>
<td> </td>
<td>GMT +2</td>
<td> </td>
<td>Usually testing and bug reporting but I also make smaller patches where I know what to do.</td>
</tr>

<tr>
<td>[[User:Patnad|Patnad]]</td>
<td>Patrick</td>
<td>Patnad Babii</td>
<td>Patnad Babii (OSGrid)</td>
<td>GMT -5</td>
<td>RezzMe Technologies http://www.rezzme.com</td>
<td>Bug testing and reporting, I code C# and have submitted a few patches</td>
</tr>

<tr>
<td>[[User:Hallow Palmer|Hallow Palmer]]</td>
<td>Markus</td>
<td>Hallow Palmer</td>
<td> </td>
<td>+1</td>
<td>Grid4Us http://www.grid4us.net</td>
<td>Server Performance (Windows), Tester, Feedback, Business concepts,Bug Reporting, Server-Hosting</td>
</tr>

<tr>
<td>[[User:^DarkMan|^DarkMan]]</td>
<td>Brian Adair</td>
<td>Patrick Ouachita</td>
<td>Brian Adair | Patrick Meta</td>
<td>-6 CST</td>
<td>RealMetaLife | B&H Networking</td>
<td>Building, Scripting, Testing, etc.</td>
</tr>

<tr>
<td>[[User:tlaukkan|Tommi Laukkanen]]</td>
<td>Tommi Laukkanen</td>
<td> </td>
<td>Tommi Laukkanen</td>
<td>+2 GMT</td>
<td>http://www.bubblecloud.org</td>
<td>Protocols ([http://www.bubblecloud.org MXP]), NHibernate, Scrip API, Map Generation, Bug Fixes, Grid Hosting</td>
</tr>
<tr>
<td>[[User:Mystical|Mystical]]</td>
<td>Kevin Tweedy</td>
<td>Mystical Demina</td>
<td>Mystical Demina</td>
<td>-5</td>
<td>Extreme Reality Grid http://www.XRGrid.com</td>
<td>Windows Communication Framework, Windows Workflow,Entity Framework, MSSQL Enhancements,Commerce, Content,DotNetNuke based portal, development services</td>
</tr>

<tr>
<td>[[User:Godfrey|Godfrey]]</td>
<td>Jeff Lee</td>
<td>Warin Cascabel</td>
<td> </td>
<td>-5 (EST5EDT)</td>
<td></td>
<td>Testing, minor bugfixes. Scripting, building, animating</td>
</tr>
<tr>
<td>Jamenai</td>
<td>Christopher Händler</td>
<td>Jamenai Luik</td>
<td>Jamenai Luik</td>
<td>+1</td>
<td>Playneko Grid | XIMDEX Jamenai http://www.playneko.de http://www.ximdex.de</td>
<td>Performance,Bug Reporting, Hosting, Grid-Owner,(PHP, MySQL, Perl, JavaScript, LSL)</td>
</tr>

<tr>
<td>[[User:bikcmp|bikcmp]]</td>
<td>Jason</td>
<td>Jake1500 Allen</td>
<td>Jason Helios (The Helios Grid)</td>
<td>EST</td>
<td>Blue Software</td>
<td>Search, groups, land, and currency</td>
</tr>

<tr>
<td>[[User:mark.malewski|Slipaway]]</td>
<td>Mark Malewski</td>
<td>Chris Rock</td>
<td></td>
<td>-6 (-5 during summer - CDT)</td>
<td>NexTECH / Joopla</td>
<td>Web development & systems integration, terrain, WIKI documentation, tutorials, testing, bug reporting and feedback. </td>
</tr>

<tr>
<td>barakademi </td>
<td>Steve Topp</td>
<td>barakademi Barzane</td>
<td>same avi on baragrid OSgrid Grid4us sciencesim</td>
<td>utc+1 (CET) paris</td>
<td>http://xbot-sl.barakademi.org http://vps.barakademi.org/oswi http://vps.barakademi.org/oswi/loginscreen.php </td>
<td>Music LiveMusic MetaverseMusic Opensim Libomv Mono-2.4 Linux (suse,debian,ubuntu) Admin Scripting Automating Development Intergration php mysql bash nant +++</td>
</tr>
<tr>
<td>[[User:RemedyTomm|RemedyTomm]]</td>
<td>Tom Grimshaw</td>
<td>Tomm Remedy</td>
<td>KGrid: Casper Warden
OSGrid: Tomm Remedy</td>
<td>UTC+0 (BST)</td>
<td>Remedy Communications</td>
<td>Texture pipeline, Groups, ObjectUpdates</td>
</tr>
<tr>
<td>[[User:robert_d|robert_d]]</td>
<td>Robert Dzikowski</td>
<td> </td>
<td>OSGrid: robert_d 13</td>
<td>UTC+1</td>
<td>[http://blog.rd-it.net blog.rd-it.net]</td>
<td>Region Modules, Tutorials</td>
</tr>

</table>
[[Category:Main]]
[[Category:Development]]
[[Category:Tech Reference]]
[[Category:Help]]

Getting Started with Region Modules

2009-05-26T23:10:56Z

Robert d: /* Hacking OpenSim using MRM */

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensimregionmodule updated project] from my blog.

--[[User:Robert d|Robert d]]

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/hacking-opensim-using-mrm.html my article] about accessing OpenSim classes from the MRM script.

--[[User:Robert d|Robert d]]

Talk:Getting Started with Region Modules

2009-05-26T22:42:15Z

Robert d: Removing all content from page

Getting Started with Region Modules

2009-05-26T06:52:05Z

Robert d: /* Update for OpenSim 0.6.4.1 */

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensimregionmodule updated project] from my blog.

--[[User:Robert d|Robert d]]

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/hackingopensimusingmrm my article] about accessing OpenSim classes from the MRM script.

--[[User:Robert d|Robert d]] 06:45, 26 May 2009 (UTC)

Getting Started with Region Modules

2009-05-26T06:47:21Z

Robert d: /* Update for OpenSim 0.6.4.1 */

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensimregionmodule updated project] from my blog.

--[[User:Robert d|Robert d]] 06:45, 26 May 2009 (UTC)

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/hackingopensimusingmrm my article] about accessing OpenSim classes from the MRM script.

--[[User:Robert d|Robert d]] 06:45, 26 May 2009 (UTC)

Getting Started with Region Modules

2009-05-26T06:46:36Z

Robert d: /* Hacking OpenSim using MRM */

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensimregionmodule updated project] from my blog.
--[[User:Robert d|Robert d]] 06:45, 26 May 2009 (UTC)

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/hackingopensimusingmrm my article] about accessing OpenSim classes from the MRM script.

--[[User:Robert d|Robert d]] 06:45, 26 May 2009 (UTC)

Getting Started with Region Modules

2009-05-26T06:45:53Z

Robert d: /* Update for OpenSim 0.6.4.1 */

__NOTOC__
{{Template:Quicklinks}}
 

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensimregionmodule updated project] from my blog.
--[[User:Robert d|Robert d]] 06:45, 26 May 2009 (UTC)

=== Hacking OpenSim using MRM ===
Check out [http://blog.rd-it.net/hackingopensimusingmrm my article] about accessing OpenSim classes from the MRM script.
--[[User:Robert d|Robert d]] 06:45, 26 May 2009 (UTC)

IRegionModule

2009-05-11T00:12:09Z

Robert d: /* Accessible Objects */

== Introduction ==

Region modules are .net/mono dlls. During initialization of the simulator, the current directory (/bin) and the scriptengines (/ScriptEngines) directory are scanned for dlls, in an attempt to load region modules stored there.

Region modules execute within the heart of the simulator. Typically region modules register for a number of events, e.g. chat messages, user logins, texture transfers, and take what ever steps are appropriate for the purposes of the module.

Region Modules require a few basic things:
* The Base Interface
* Some callbacks for OpenSim events

== The Base Interface ==
All region modules must implement this interface:

<source lang="csharp">
public interface IRegionModule
{
void Initialise(Scene scene, IConfig config);
void PostInitialise();
void Close();
string Name { get; }
bool IsSharedModule { get; }
}
</source>

<table>
<tr>
<th>Name</th>
<th>Description</th>
</tr>
<tr>
<td>Initialise</td>
<td>This method is called immediately after the region module has been loaded by the sim. At this time the module is passed a reference to the scene contained within the sim. The region module should store this reference for later use. Care should be taken, not to depend on the scene and/or sim being fully loaded and running at this time.
</td>
</tr>
<tr>
<td>PostInitialise</td>
<td>Once the sim is fully initialized and all region modules have been loaded, the sim will invoke PostInitialize on all loaded region modules. At this point the sim will be fully operational, and it should be safe to invoke any method on the scene. Note: PostInitialize will not be invoked on shared modules for regions created via XmlRpcCreateRegion or via the console command "create-region"!</td>
</tr>
<tr>
<td>Close</td>
<td>This method will be invoked when the sim is closing down.</td>
</tr>
<tr>
<td>Name</td>
<td>This name is shown when the console command "show modules" is ran. It's should be a nice name like "Sim Chat Module" or "The Best Region Module Ever".</td>
</tr>
<tr>
<td>IsSharedModule</td>
<td>The simulator process (OpenSim.exe) supports running multiple regions (internally, a Scene object) on a single simulator process. If this returns True, the module will only be loaded once and Initialize will be called for each Scene being simulated. If false, a separate copy of your RegionModule will be created for each Scene.</td>
</tr>
</table>

The base interface doesn't give you much beyond a piece of loaded code. In order to do anything useful you'll need to use a combination of events and object crawling through scene.

== Accessible Objects ==

'''Note:''' these are internal interfaces, and will change in the future, probably for the better. We expect these to stabilize over time, but for now this point in time snapshot is probably helpful.

In the '''Initialise''' routine you get access to the scene object for the region, from here you can spider down into the scene and get access to many other objects of interest.

* scene.GetEntities() - returns a list of all the Entities in the environment. This will be a combined list of SceneObjectGroups (prim sets) and ScenePresences (avatars).
* scene.GetAvatars() - get only the avatars in the scene (very handy for sending messages to clients)
* scene.EventManager - this is the object from which you can register callbacks for scene events. Some examples provided in a little bit
* scene.RegionInfo - properties about the region

== Registering for Events ==

Taking the [http://opensimulator.org/cgi-bin/viewcvs.cgi/trunk/OpenSim/Region/Environment/Modules/World/Sun/SunModule.cs?view=markup SunModule] as an example we can see the following code:

In Initialise():
<source lang="csharp">
...
m_scene.EventManager.OnFrame += SunUpdate;
...
</source>
Pretty simple, we just got the EventManager and registered the SunUpdate method as a callback for the OnFrame event. OnFrame is triggered every time there is a render frame in opensim, which is about 20 times per second. If you are firing on the OnFrame event you need to do something small, or punt most of the time, as you'll negatively impact the performance of the system otherwise.

Now, for that function...

<source lang="csharp">
public void SunUpdate()
{
// this code just means only do this on every 1000th frame, and don't do it if the sun is in a fixed possition
if (((m_frame++%m_frame_mod) != 0) || !ready || sunFixed)
{
return;
}

GenSunPos(); // Generate shared values once

List<ScenePresence> avatars = m_scene.GetAvatars();
foreach (ScenePresence avatar in avatars)
{
if (!avatar.IsChildAgent)
avatar.ControllingClient.SendSunPos(Position, Velocity, CurrentTime, SecondsPerSunCycle, SecondsPerYear, OrbitalPosition);
}

// set estate settings for region access to sun position
m_scene.RegionInfo.RegionSettings.SunVector = Position;
}
</source>

SunUpdate() takes no parameter (some events may require them). It only fires every 1000th frame by default (m_frame_mod = 1000 in this module), so it doesn't take too many cycles.

In order for the sun position to change for the clients, they need to be told that it changes. This is done by getting a list of all the Avatars from the scene, then sending the Sun Position to each of them in turn. It is important to check to see if the avatar is a ChildAgent, otherwise you will generate zombies in opensim world.

== Where to go from here ==

* [[Getting Started with Region Modules]] -- the Hello World of OpenSim application development
* Read the source for existing opensim core modules. You can do it here via [http://opensimulator.org/cgi-bin/viewcvs.cgi/trunk/OpenSim/Region/Environment/Modules view svn].
* Read the source for [http://opensimulator.org/cgi-bin/viewcvs.cgi/trunk/OpenSim/Region/Environment/Scenes/EventManager.cs?view=markup EventManager]. It will tell you what events exist.
* Help write more examples here. OpenSim grows with your contributions.

[[Category:Development]]

User:Robert d

2009-05-10T19:42:49Z

Robert d:

Robert Dzikowski, email: blog@rd-it.net

User:Robert d

2009-05-10T19:42:28Z

Robert d: New page: Robert Dzikowski email: blog@rd-it.net

Robert Dzikowski
email: blog@rd-it.net

Talk:Screenshots

2009-05-10T19:40:45Z

Robert d: New page: Where can I find more info about drawing on prims using a Browser Silverlight applet? --~~~~

Where can I find more info about drawing on prims using a Browser Silverlight applet?

--[[User:Robert d|Robert d]] 19:40, 10 May 2009 (UTC)

Talk:Getting Started with Region Modules

2009-05-09T22:18:53Z

Robert d:

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensimregionmodule updated project] from my blog.

--[[User:Robert d|Robert d]] 22:03, 9 May 2009 (UTC)

Getting Started with Region Modules

2009-05-09T22:16:53Z

Robert d: /* Update for OpenSim 0.6.4.1 */

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://blog.rd-it.net/opensimregionmodule updated project] from my blog.

Getting Started with Region Modules

2009-05-09T22:10:14Z

Robert d: /* Update for OpenSim 0.6.4.1 */

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://rdzikowski.googlepages.com/opensimregionmodule updated project] from my blog.

Getting Started with Region Modules

2009-05-09T22:08:59Z

Robert d: /* Tips */ updated for OpenSim 0.6.4.1

== Hello World ==

This brief tutorial is intended to get people started with developing applications with/for opensim using [[IRegionModule|region modules]] and the [http://docs.opensimulator.org/namespaceOpenSim.html opensim API]. This approach to developing virtual world applications, unique to OpenSim, is a powerful alternative to the well-known inworld scripting approach.
The very simple module available here writes "HELLO" with prims on every region of your opensim instance, and makes them move every 2 seconds or so. Please note:

* The opensim API is rapidly changing. The code available in this example has been written and tested for opensim release 0.6.0, which corresponds to SVN 7176. The example has also been tested for a more recent stable version, SVN 7320. You are encouraged to use 7176, if possible.
* You are also encouraged to try this code on the default standalone region first before running on a grid.
* The resulting dll will run both in Windows and Linux, but the building environment is assumed to be VC# on Windows. Users of other operating systems will be able to follow, though.

To get started:

# Download and install opensim (preferably 7176), and build it as normal. Run it once, so you create a default region and a default user. Then shut it down.
# Get this zip file: http://www.ics.uci.edu/~lopes/opensim/HelloWorld-current.zip. Unzip it somewhere.
# Before you go changing the code of the application, see its effect inworld by doing this:
#* Grab HelloWorld/bin/Release/HelloWorld.dll and dump it in opensim/bin
#* Start opensim as normal, and login to it.

You should see the word HELLO spelled out in prims, and moving every so often.

[[image:Hello 001.jpg|220px|left|thumb|Hello]]

Are you ready to explore the code now?

Hold on. Before we do that, let me give you the 30-second introduction to Visual C#. Visual C# is similar to Eclipse, if you ever used that. When it builds, it places the resulting dll or exe in whatever folder you tell it to (right-click on the project->properties). By default it places them in bin/Release. When you compile it with debugging, that goes into bin/Debug. In spirit, the dll is equivalent to a jar file. That's what you want to produce and pass around. The PDB file can be ignored, unless you want to debug. The HelloWorld example uses the defaults of VC#, so every time you build it without debugging, the dll is placed under HelloWorld/bin/Release. To build without debugging information, simply right-click on the solution in the Solution Explorer window and choose Build.

Another note: the solution file included in the zip is for VC# 2005. If you have VC# 2008 that's fine too. Just double-click on the solution file, and VC# 2008 will convert the whole thing.

And now for the linux/mac/unix folk:
We now have a nant default.build file included in the tutorial zip - just drop it in the same directory with the source. Note that for everything to go well, you will need to park your module source directory inside opensim/bin/. When you are ready to build, open a shell, change to the module source directory, and then run 'nant' without any args.

OK, now we're ready. Go ahead and double-click HelloWorld.sln.

The only class in this example is called HelloWorldModule. I know you're eager to get to the part where objects are created and moved around, but I'm afraid that's the easy part. In order to be able to write those functions effectively, you will need to understand a lot more of the engineering of these modules, and that's the part that's not so trivial, especially if you aren't familiar with VC#. So let me go through the code very slowly.
<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Reflection;

using log4net;
using Nini.Config;
using OpenMetaverse;

using OpenSim.Framework;
using OpenSim.Region.Environment;
using OpenSim.Region.Environment.Interfaces;
using OpenSim.Region.Environment.Scenes;
</source>

This first part consists of a collection of "using" declarations. If you come from Java, those declarations are equivalent to "import" declarations. And you know what that means in Java: the jar files must be reachable for compilation to succeed. Same here: the dlls for those elements must be reachable for this project to build. Luckily for you, I have included those dlls in the zip file, so you don't need to add them. They are all happily bundled in HelloWorld/bin/Release. Go ahead and look there. However, as you start getting cozy with this code and you start wanting more, more, more, you will need more from the OpenSim API and even from other libraries. When that comes, you will need to add more dlls to your project. That is done through VC#, not on the file system directly! To add libraries ("References"), right-click on "References" in the Solution Explorer, and choose "Add Reference". A small window will pop up with a few tabs. If the library you need is under the System namespace, you want to interact with the .NET tab. If the library you need is from OpenSim you need to interact with the "Browse" tab; then, navigate to your installation of opensim bin, and pick the dlls you need.

<source lang="csharp">
namespace HelloWorld
{
public class HelloWorldModule : IRegionModule
{
</source>

This second part is the namespace and class declaration. The only noteworthy thing here is the ": IRegionModule" part. What that means is that our class HelloWorldModule implements the [[Region Modules|IRegionModule]] interface, which means that we have to implement the 5 methods of that interface, namely: Initialise (yes, it's the British spelling...), PostInitialise, Close, Name, and IsSharedModule. But that's not all. OpenSim treats IRegionModule classes in a very special way. When OpenSim starts, it looks into all the dlls it can reach (under its bin) in search for classes that implement the IRegionModule interface. All of those classes are then acquired and run by OpenSim as if they were part of OpenSim.

And this is the key to OpenSim application development: you can add your own code, or somebody else's code, as a plug-in that runs natively on the server. Yeepie!

<source lang="csharp">
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
</source>

This third block above is the declaration of the m_log variable. This variable helps us output messages into a log. I'm just using a common idiom that is used all over OpenSim and that uses log4net. If you come from Java, I'm sure this rings a bell... if you've never seen this, you don't need to understand it, just use it to output messages both onto the console and onto the OpenSim.log file.

<source lang="csharp">
List<Scene> m_scenes = new List<Scene>();
Dictionary<Scene, List<SceneObjectGroup>> scene_prims = new Dictionary<Scene, List<SceneObjectGroup>>();

int counter = 0;
bool positive = true;
</source>

The fourth block of code is the declaration of a few instance variables for our HelloWorld example, and this is where we start getting acquainted with the OpenSim API.
* m_scenes will hold references to all the scenes. "What's a scene?", I hear you asking. A scene is OpenSim's representation of the contents of a region. If your opensim has only one region, there will be only one scene object; if it has more, there will be as many.
* scene_prims is a dictionary that associates scenes with a list of objects of type SceneObjectGroup. In the Java world this would probably be a Hashtable; in the .NET world it's a Dictionary. scene_prims will hold references to the prims that we will instantiate for constructing the world HELLO in each scene. An important note: if you look inside OpenSim's Scene class, you will see that it has a list of entities corresponding to all objects and avatars present in the scene. As we place prims in scenes, including these HELLO prims, they will be placed on that list. However, what we are doing here is constructing a set of prims that are special for our application and that we want to track throughout our application; they are our managed prims. As such, we want to hold references to those, and only those. That's what scene_prims is for.
* The other two variables, counter and positive, are explained later.

<source lang="csharp">
#region IRegionModule interface

public void Initialise(Scene scene, IConfigSource config)
{
m_log.Info("[HELLOWORLD] Initializing...");
m_scenes.Add(scene);
}

public void PostInitialise()
{
m_scenes[0].EventManager.OnFrame += new EventManager.OnFrameDelegate(OnTick);
foreach (Scene s in m_scenes)
DoHelloWorld(s);
}

public void Close()
{
}

public string Name
{
get { return "Hello World Module"; }
}

public bool IsSharedModule
{
get { return true; }
}

#endregion
</source>

The fifth block is the implementation of the IRegionModule methods. There's nothing much here, and this is how it should be: encapsulate all of your code in your own functions. Let's go through the most important of these methods:
* Initialise (I still can't get over this British spelling): this method is called by OpenSim when it is discovering all the IRegionModule classes in dlls. OpenSim sends us two parameters: a scene object and a configuration object. The configuration object allows us to browse through the OpenSim configuration, if we need that info. The scene object is the very important scene information that we want to hold on to; the scene object is our code's main link to OpenSim, it's how we get to access and modify things in the world and beyond. So the main thing our Initialise method does is to hold on to the scene object that OpenSim sends us.
* PostInitialise (argh, British spelling again): this method is called by OpenSim once everything is ready to go, that is, after OpenSim has properly set all the internal things it needs to set. You should look at PostInitialise as the Main method of our application modules. In this case, we are doing two things:
** We are subscribing to an OpenSim event called OnFrame. This event is the Heartbeat of the simulator, so if our module is to do things periodically, we may want to tag along this heartbeat. We are going to move the word HELLO periodically, that's why we're subscribing to this event. Note that this is not always the best approach, though. The simulator is a busy bee, and has to do lots of things already without our module being there. Tagging along the simulator's heartbeat means that we're making it do more stuff. If you're planning to develop modules with your own simulations, you're much better off defining your own timer object, because that will make the tick function run on a different thread than the simulator's heartbeat. But in this case, this is just HelloWorld, so we can abuse gently.
** For each scene, we are constructing the HELLO word.
* Close and Name are trivial -- see the [[IRegionModule|documentation]].
* IsSharedModule is very important, and may be a source of much grief. Here's the deal: OpenSim can either (a) instantiate our HelloWorldModule class exactly once, a singleton, independent of the number of regions; or (b) instantiate our HelloWorldModule class as many times as the number of regions, creating a different HelloWorldModule instance for every scene. These two modes are captured by the IsSharedModule method. If you want OpenSim to create a singleton, make this method return true ("yes, OpenSim, my module is shared"); if you want to create different instances for different regions, make this method return false ("no, OpenSim, my module is not shared among the regions"). Depending on your application, you may want one thing or the other. In this case, I want to centralize the management of my specially constructed prims, so I made it be shared. (In reality for this simple example, it wouldn't matter). But here's the important idiom: when you have a shared module, you want to have a list of scenes, just like the m_scenes variable in this example; when you have a non-shared module, you want to have only one scene variable declared in your module, so that would be "Scene m_scene;" instead of "List<Scene> m_scenes;"

Alright! If you read up to here, and followed the story, you're now ready to move on to the fun part.

<source lang="csharp">
void DoHelloWorld(Scene scene)
{
// We're going to write HELLO with prims

List<SceneObjectGroup> prims = new List<SceneObjectGroup>();
// First prim: |
Vector3 pos = new Vector3(120, 128, 30);
SceneObjectGroup sog = new SceneObjectGroup(UUID.Zero, pos, PrimitiveBaseShape.CreateBox());
sog.RootPart.Scale = new Vector3(0.3f, 0.3f, 2f);
prims.Add(sog);

...

// Add these to the managed objects
scene_prims.Add(scene, prims);

// Now place them visibly on the scene
foreach (SceneObjectGroup sogr in prims)
{
scene.AddNewSceneObject(sogr, false);
}
}
</source>

This method creates 12 SceneObjectGroup (SOG) instances corresponding to the 12 segments that constitute the word HELLO. '''BIG WARNING:''' SOG is currently under heavy redesign, and may be replaced with another class altogether in future versions of opensim. But for 0.6.0 SOG is tha man. SOG represents a linked group of objects, the linksets in SL, with root part and all. If you have your VC# open with HelloWorld, go to this method, and type, somewhere: sog. -- just like that, stopping at the dot. VC# will show you everything that is inside SOG instances. And that is A LOT! It's one of those monster classes! (and that's the reason why it's being redesigned) You should spend some time exploring what's inside SOG. In this example, I'm only using a couple of things: one of the constructors and the RootPart. For the RootPart, I'm only setting its Scale, i.e. the size of the prim.

At the end of this method, when all prims are instantiated, they're added to the list of managed prims (scene_prims) and they're finally made visible on the scene, by calling scene.AddNewSceneObject. The second argument to this method, false, means that we're telling OpenSim not to back these objects up on the DB; we want them to be non-persistent.

And finally we come to the end of the application:

<source lang="csharp">
void OnTick()
{
if (counter++ % 50 == 0)
{
foreach (KeyValuePair<Scene, List<SceneObjectGroup>> kvp in scene_prims)
{
foreach (SceneObjectGroup sog in kvp.Value)
{
if (positive)
sog.AbsolutePosition += new Vector3(5, 5, 0);
else
sog.AbsolutePosition += new Vector3(-5, -5, 0);
sog.ScheduleGroupForTerseUpdate();
}
}
positive = !positive;
}
}
</source>

This is the worker method in our application for every heartbeat of the simulator. Notice that I have a counter there so that things only move every 50 heartbeats. I also have a direction (positive) that can be true or false, so that the prims move back and forth. As you can see, the way to move prims is to set their AbsolutePosition property directly. After that, we tell opensim to schedule the object for an update, so that we can see it move. Note this last bit, the scheduling for updates, is still a fragile piece of the opensim API; we may need it here or not, depending on the version of opensim you're using.

Voila!

Running on custom configurations (grids, alternate terrain) should work fine if you take into account the following:

# Make sure that the Z value in the C# code is above the terrain. Instead of 30,you may wish to raise or lower this value. Make sure to also modify 29 and 31, similarly.
# Change UUID.Zero to your a UUID for an avatar that has build rights on your region. You can replace "UUID.Zero" with "new UUID("your UUID string here")"
# This C# module will place "HELLO" on each region in your grid. If you want to make it so that "HELLO" appears in only one region, try this quick replacement:

<source lang="csharp">
foreach (Scene s in m_scenes)
if (s.RegionInfo.RegionName == "YourRegionName")
DoHelloWorld(s);
</source>

=== What Next ===

This is an [http://www.youtube.com/watch?v=Xxsk9WDYMtg example]
of 100 continuously moving blocks.

Here are some other suggestions for what you can do next, on your own:

* Change the Color of the prims
* Complete the example by creating prims for the word WORLD. For the W you probably need our beloved quaternions...
* Add more regions to your opensim and see what happens
* Change this module from shared to non-shared and see what happens (nothing much different, one hopes, in this simple case)
* Be more creative with the movement and make the prims move in circles
* ...

Remember, every time you make changes to the application code, and you build it, its dll is placed under bin/Release, so you have to copy it to opensim/bin. If you want, you can change the build settings of your application, so that it places the dll directly in opensim/bin.

Have Fun!

=== Tips ===

There is very little documentation about the OpenSim API. One of the reasons for that is that it is still evolving and therefore unstable. A reasonable place to look at the API is http://docs.opensimulator.org/namespaceOpenSim.html; in there, the most interesting place to start is the Region.Environment.Scenes namespace http://docs.opensimulator.org/namespaceOpenSim_1_1Region_1_1Environment_1_1Scenes.html.

The code itself is full of information, if you can cope with looking at too much information. Here's what I do and recommend: when you're developing these modules, have 2 VC# open, one with your application and the other with opensim. My experience with opensim is that the names of things are quite reasonable. So whenever you want something that you don't know exactly how to get, go to the opensim code and make heavy use of the Search functions, especially Edit->Find and Replace->Find in Files. VC#, just like Eclipse, also has those wonderful navigation facilities that take you to definitions from calls, etc. Just right-click on things in the code.

=== Update for OpenSim 0.6.4.1 ===

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://rdzikowski.googlepages.com/opensimregionmodule updated project] from my blog.

--[[User:Robert d|Robert d]] 22:03, 9 May 2009 (UTC)

Talk:Getting Started with Region Modules

2009-05-09T22:03:17Z

Robert d: Updated for OpenSim 0.6.4.1

To compile and run this example in OpenSim 0.6.4.1 you have to change using statements
to this
<pre>
using System.Collections.Generic;
using System.Reflection;
using log4net;
using Nini.Config;
using OpenMetaverse;
using OpenSim.Framework;
using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes;
</pre>

You will also have to add references to all those libraries and OpenMetaverseTypes library,
or you can download [http://rdzikowski.googlepages.com/opensimregionmodule updated project] from my blog.

--[[User:Robert d|Robert d]] 22:03, 9 May 2009 (UTC)