Category Archives: Ryzom Core

Creating new GUI with Ryzom Core Studio GUI Editor plugin

Good news everyone!

I’m proud to announce that the GUI Editor has taken a giant leap forward!
Until now it was only possible to modify an existing GUI with it, but from now on it will also be possible to create a brand new GUI from scratch!
While this doesn’t mean that it’s finished, and ready for production use, it’s like I said a giant leap into the right direction!

Here’s a video showing the workflow for creating a new GUI and using it with Ryzom:

 

Advertisements

Cross platform software development

Can be a real pain!
Ryzom Core Studio is a cross platform tool, the entire point of creating it was to move away and get free of the shackles of Windows as the old Ryzom tools were written with MFC.
Unfortunately two of it’s plugins kept triggering an assert when loaded together.

As it turns out the source of the problem was that GCC and Visual Studio link libraries differently:
Ryzom is built on Nel the Nevrax libraries. One of these libraries is the LIGO library, which is basically a data library. Also Nel uses a quite powerful (de)serialization system which is based on an abstract object factory, which is implemented using static methods and static member variables. What’s also important that these Nel libraries are linked statically right now.

Unfortunately as it turns out it behaves differently depending on which compiler built it: GCC or Visual Studio.
When building with Visual Studio each plugin gets it’s own instance of the static variables, while with GCC they share the same one.
So when the LIGO library is started up, it registers it’s classes. When the first plugin that uses it loads there’s no problem, but with the second an assert is triggered because those classes have already been registered.
In this case solving this problem was fairly simple: Since those plugins use their own LIGO configs ( a context object of sorts ), guarding against multiple registrations was enough.

Ryzom Core Studio improvements

So I’ve done the following:

Renamed and moved out toolset which used to be called OVQT.
Now it’s called Ryzom Core Studio, and resides in it’s own directory ( studio ) in the main source code directory.

Implemented a general settings dialog that shows up on the first start of studio, so one can set the paths and whatnot that are needed for the various plugins to work.

Made plugins hot-load and unloadable so that they can be load/unloaded while studio is running ( obviously ).


I also improved the splash screen: Now it shows the startup progress with a progressbar and prints text messages as well.
20140607_000001525

Improved the GUI Editor’s usability by allowing various properties to be set using either a combobox ( the enum ones ), or a texture chooser, or a color picker instead of setting them as strings.

Added an UXT Editor widget to the Translation Manager plugin.
UXT files basically contain the translations to various GUI texts and messages. So it’s quite important!

Implemented the Tile Editor plugin: This plugin allows the creation of tilesets, which are used to paint land components.
Again quite important!

Implemented the form, DFN, and type editors for the Georges Editor plugin.
In short Georges is an XML database system created for Ryzom in the early 2000s. It contains data for the game.
It allows one to create custom types, organize the types into structure definitions ( DFN ) and put those structures into a form which can be filled in.
So this is really essential for Ryzom!

Created a node-based expression editor for the GUI Editor plugin. So that GUI expressions that GUI widgets depend on can be graphically created instead of typing.
Here’s an example for such an expression:
and(eq(@UI:TEMP:SPECIECLICKRACE,0),eq(@UI:TEMP:SPECIECLICKINFO,1))

This was the initial GUI mockup of it:
expressioneditortkvjk

This is how it looks implemented:

 

OVQT Material Editor plugin as of July 8

Finally I have something small to show off about this.
After having worked on all this for a week ( more or less ), It can already load/save/manipulate materials and shaders, and also has a widget for previewing the changes.
NOTE: The material/shader manipulation part and the preview part are not yet linked, as the preview uses the old driver, since the new programmable pipeline one isn’t YET implemented.

As I develop it further I will post more about it. Until then this video should be a nice preview 🙂

Ryzom GUI Editor as of March 2013

Hi there!
So as promised here’s a post about the latest features of the Ryzom GUI Editor! There are actually 2 new major features implemented. Let’s start with the one that I implemented first:

Editing GUI widget templates

This one is a convenience feature, since whatever you can do with it, can be done by directly editing the XML files provided for the GUI Editor.
Basically all it does is allows you to add/remove GUI widget templates, and add/remove the properties they have from inside the GUI Editor.
These are the templates that tell the GUI Editor what widgets there are in the GUI, and what properties they have. These are what tell the GUI Editor what to query and show in the
widget properties windows docked in the right.
Here’s a short video showing how it works:

Selecting and deleting widgets in the scene

This one is a lot more important feature! It shows your selection properly in the scene, and allows you to remove the widgets selected.
There isn’t much more to tell about this, since it’s role is so obvious. Let a video speak and show you how it works.

 

Ryzom Core GUI Editor as of today

I’ve made two videos to show how the Ryzom GUI Editor works right at the moment.

The first video was basically meant as a features demo, to show all the currently available features of the editor.
It shows the following features, using the Ryzom Core login screen as an example:

  • Link editor
  • Process editor
  • Action editor
  • Project editor
  • GUI hierarchy traversal
  • Live preview of the GUI widget property changes

The second video shows some changes being made to the login screen, and then those changes saved into a new GUI XML file which is then loaded by the client.
Basically it is fairly simple. All one has to do is:

  • load a project into the editor,
  • make changes,
  • save them ( into a new XML file, if the project loads the old Ryzom XMLs, since those are made of sets of files, and the editor saves into a single file only ),
  • copy them into the client’s data/gamedev directory,
  • edit the client config so instead of the old XML set the new file is loaded
  • start up the client and see the results!

Enjoy! However please don’t forget that all this is only a little preview, a teaser even. There’s still a lot of work to be done, until the GUI Editor will be a fully functional tool!

 

 

Development progress July 22

It’s been said that a picture is worth a thousand words. What about a video then?

Development progress

So I think I’ve made some progress with the Ryzom GUI Editor tool.

I’ll let the video I’ve recorded speak for itself!

Obviously right now all widgets are but empty shells, however at least the GUI is mostly done. Now it’s time to finish the GUI library and then add functionality too 🙂

Progress as of July 5

So again I haven’t had the time to post lately, but now I’ve decided to take the time.

So far I think I’m mostly done with refactoring and moving the widgets to the GUI library, so I can show a semi-final class diagram auto-generated with Visual Studio 2008, the IDE I use for C++ development on Windows platform.

( Obviously you will have to click the image and zoom in )

The other thing is, this week I’ve finally started to work on the actual GUI editor. So far I’ve just started to work on the GUI widget definition loading.
The widget definitions look something like this:

These definition XML files will then tell the GUI Editor, which widgets are available to it, and what properties they have! So that the editor can offer them, and the user can change the properties in the property browser widget.

However since the GUI library is not 100% done yet, for now I will only load these, and use a little widget I’ve created to see what the application has loaded.
You can see how it works here: