EZData - MVVM framework for EZ GUI

EZData in Unity Asset Store
Full info and documentation

EZData boosts productivity and quality of EZGUI based User Interface development with

• Advanced, resolution independent interface layout
• Automatic data binding, following the popular MVVM pattern.

With EZData you can build large scale, high quality user interfaces that are still stable, maintainable and robust.

Features

• Resolution independent interfaces creation.
• Crisp, pixel perfect graphics. You can literally control every pixel of your user interface.
• Advanced UI elements alignment capabilities.
• Two-way text bindings (including multi-bindings) with native .NET formatting capabilities.
• Flexible bindings that allow visible, enabled and checked states of UI controls to be bound to properties in your code (also in two-way mode for check-boxes bound to boolean values).
• Command bindings for buttons and text fields interaction that will trigger actions in your code.
• Items source binding for connecting list control with attached item template prefab to collection of items in your code.
• Code snippets for notifiable properties and collections for Visual Studio and Mono Develop.
• Editor script for bindings validation.

If you have any questions, do not hesitate to ask. We are looking forward to your feedback!

 

It sounds great!
The only problem it's a lot to read (documentation).
It would be wise to show video tutorial with simple implementation.
It would save some time for future buyers.
80 $ for extention to Ez GUI when new Unity 3.5 GUI system is coming soon !?
I know that it was a lot of hours of development but 50-60 $ like "Merlin's Prefab Lab" would be more accepted.

 

All indications are that this is NOT the case. See: http://forum.unity3d.com/threads/106581-Unity-3.5-no-new-GUI-system-(POLL)/page3

 

Thank you for your feedback

Our documentation section contains not only EZData specific information, but also different useful tips and Ez Gui usage explanation to make it understandable even for people, who haven't work with Ez Gui before.

If you are already familiar with it, you can just look at Demo and Data Binding overview and
example of usage to understand how EZData works. There are not so much to read and it is really easy to use in your project.

 

Yes, as I understand it is not clear if Unity 3.5. include new GUI system or not.
But if you use Ez Gui now or going to have complicated UI, our framework can be interesting for you anyway.

 

Hi all,
As it become clear that Unity 3.5. won't include new UI system, Ez Gui with EZData could be an option to help you with user interface creation. We have been developing new game with this interface creation approach and find it really convenient.

We have simplified documentation and reduced the price, to make EZData more accessible and understandable.

EZData in Asset Store
EZData website

Looking forward to your feedback and comments!

 

Thank you all who have bought EZData or considering this option. Your opinion is extremely important for us, so, if you have any questions about EZData integration and usage, problems or comments, please, contact us via website form, or post your questions in this topic, we'll answer asap.

We guarantee support of Unity 3.5 related changes if any, after EZGui is updated according to them. And we'll provide free update for all current EZData owners.
As I already told, we are developing game based on this framework, so we are highly interested in keeping EZData up to date.

 

Hello,
I'm planning to develop simple 2d scroller game. Game will be multilingual.
Question is how EZData will help me if I pick EzGUI as main GUI system?

Regards

 

Hi mente,

If you're planning to have any UI that reflects inner state of the game, EZData will definitely be helpful to significantly reduce amount of code for synchronizing UI with game state and decouple game logic from UI. That in our case made the whole project more stable, especially during UI changes.

In fact, correct usage of MVVM pattern allows you to completely change the UI without modifying game logic at all. So that you can safely experiment with your UI without worrying about breaking something. One of the EZData features is bindings validation in editor, you can always be sure if every UI control is bound to correct data, without even running a game and checking for run-time errors.

While using EZData might seem to be essential for large projects, small projects benefit from it too, by getting very clean, reliable and maintainable code-base, so you can keep everything under control much easier, thus increasing chances to successfully release a game in shorter terms with better quality.

You might also consider using EZData not only for UI but also for your game objects visualization and interaction, since in its core EZData is a lightweight framework for decoupling pure state from its external (usually complex) representation. Whether it be a check-box in your UI bound to Boolean property or editing filed bound to string property or say, some particle effect activated for your game character on low health that is bound to floating point health property. Ideally, you can arrange everything in a way when all your core game logic is operating on the most simple and straightforward data structures, completely independent of external representation, that allows you to develop and test your game code faster and more efficiently.

You can use source code for existing EZGUI bindings as a reference and a starting point. If you're interested in creating your own bindings, you can extend existing classes like EZBinding, EZMultiBinding, EZBooleanBinding, EZTextBinding, EZCommandBinding, etc. In this case you'll have to define only a way how data is transformed into things observable by users, and all the synchronization and data changes tracking is done completely automatically.

As for multi-language support, there is base localization interface that allows you to add custom language switching code. However, we're planning to publish our implementation of such mechanism soon, as it might be reused in other projects after some minor dependencies cleanup.

And don't forget about advanced layouting tools that come with EZData, that will enable you to create absolutely pixel perfect interfaces that are resolution independent. And that means that you can easily create a builds for different devices without changing even a bit of your project.

If you have any other questions or improvements requests, please, let us know

Cheers

 

Nice, long, answer.
By saying layouting tool do you mean EZAlignment?
What tools are included in package?

 

Does EZData for EZGUI provide a automatic, smart capability to handle caching of list items for Scrolllist so it does not flood the list with dozens of list objects when only a handfull are needed. Lets say for example if you requested all friends on myspace and wanted to provide them in a list, would EZData offer a way to only have list objects generated for the next / previous friends with the rest reusing these? (pool or smart reuse a la iOS UI itself)

 

EZGUI seems to handle large numbers of items more or less well, at least from what we know, list items that are off-screen are in disabled state and make a very small overhead on performance, also adding item that will be off-screen happens quite fast. The only problem is that it works only when many items are added not in a single frame, but distributed between several frames. EZData itself doesn't provide any smart optimizations on that, it's just about synchronizing content of UI list with collection of items.

Items pooling looks like a good idea, because objects instantiation could kills performance in many cases. Ideally, it should be a part of ScrollList behavior.
Another possibility is to create some proxy outside ScrollList that will handle items pool and somehow distribute items addition to the list to avoid spikes in performance.

What do you think, is that a common task to operate with large numbers of items in lists and such proxy is needed in multiple projects?

 

For normal EZGUI users potentially not.

But for anyone even considering to invest in a databinding solution like EZData like me, I would assume its a common task.
If we didn't have to handle a flexible or larger amount of data or larger datasets, why would we want to invest in a solution for databinding if it isn't capable of handle the data in a performant way it binds?
Its the data binding layer that instantiates the prefabs I specify, not EZGUI, so I couldn't think of anyone but EZData doing that in a smart way as it has absolute knowledge about the prefabs it instantiates for pooling, the element order and the elements information, the informations required to make this list element reusage even possible


And yes I agree that it would be nice if EZGUIs UIScrollList would do that / that it would normally be its job but that would require it to force users to extend a scroll list base class to handle the caching (like Silverlight and Cocoa do it too) and then it wouldn't be really unity userbase oriented anymore.
So I expect addons to EZGUI that claim to be more for the professional user and which actually are responsible for the prefabs that get thrown at the ScrollList to do their job right and handle that filling of the scroll list in a performant way

 

Generally, we do have information about all the items, and since we instantiate list items from a custom templates outside of the list, we could handle large collections of data with only number of items equal to visible UI page size.

But it means that scroll bar should be handled in some custom way, because actual UI list always contains only a small part of visible items. Adding some knowledge about external items provider and supporting some kind of placeholders (to sort of fill the space and keep scroll bar working) in the UIScrollList class is an option, but we're trying to be non-intrusive with our components, so they don't restrict you from upgrading UI library separately.

Creating alternative list control for large data sets seems to be a good solution. So, we are adding it to our priority list, and eventually it'll be available as a part of EZData. That would help to use Unity not only for games creation but for applications with big amount of data as well.

By the way, EZData can be useful not only for handling DB-like data and sync with UI lists, but for managing complex structure UIs as well.
F.e., if you have multiple windows/panels/controls that rely on the common state and you try to handle it with manual manipulations with controls when something happens, it become too complicated quite fast. And it doesn't take a million of items in the list to create a problem, in many cases it's a number of controls and states behind them that are blend into a monolith, unsupportable construction.

And we are trying to help UI developers to reduce UI complexity, however, you are right (and thank you for feedback ) that some special tools for grinding large data sets will be useful for many people too, so hopefully we'll add some soon.

 

Thanks for the informations.
I fully understand and support the non-intrusive target and I like and favor that as I've had past experiences in the past where this didn't hold


As for the multiple windows - states etc: Thats a thing I would instantly sign on .NET / Silverlight / MVC / MVVM platforms.
But with Unity and its component pattern, I am not that sure as it solves some of the larger problems that all those monolithic architectures have if properly applied but it might none the less have some core benefits in complex multi view situations and I definitely consider to test it in some more or less complex situations to draw some proper and qualified conclusions not general 'pattern vs pattern' chitterchatter

Looking forward in general to whats gonna happen with (EZ)Data as I like anything that can make my work day more productive, it solves the problem that I would need 2 clones to perform my work

 

EZData update can be found in AssetStore - http://u3d.as/content/art-of-bytes/ezdata-for-ezgui/2ru
There are:

• IEnumerable support for collections to allow foreach for items
• Binding to collection items by index (allowing binding paths like: HighScores.Table.0.Name)
• Slight context access level modification for possible iOS issues
• Better handling of unresolved bindings
• Indexed bindings validation