Blog-posts are sorted by the tags you see below. You can filter the listing by checking/unchecking individual tags. Doubleclick or Shift-click a tag to see only its entries. For more informations see: About the Blog.
Not many will remember the times when vvvv's 3d rendering was based on Direct3D 8. Not important really, because at the same time we released vvvv 33beta1 in December 2002, Microsoft released Direct3D 9 with a lot of new features, so we knew what we had to do..
Luckily vvvv's DX9 implementation proved powerful enough to be quite useful for many years. Then it took Microsoft 5 years to release its successor DX10 which was only available on Windows Vista, which nobody wanted. Also graphic-card adoption took quite a while so we didn't really feel an urge to start working on it right away.
A year later in 2008 Microsoft released Windows 7 and with it DX11, which altogether looked more promising. But still a lack of adoption of supported hardware and Windows 7 didn't put too much pressure on us to implement it. Instead we thought it would be smarter to improve the plugin-interface for vvvv to make it easier for users to contribute to the library of nodes.
In parallel we had already secretly started work on our next big thing that would become VL, which we first announced at the keynode during NODE13. Since with VL we've mentioned from the beginning that we wanted it to eventually run across platforms, for us, implementing a new renderer based on the windows-only Direct3D api became less and less appealing.
What happened next couldn't have been more fortunate: besides many other major contributions, using the possibilities of vvvv's plugin-interface, power-user vux took it in his own hands to create a set of nodes for rendering with the features of DX11, which he released on vvvv's 10th birthday in December 2012. And the vvvvorld was a better place.
DX11 for vvvv is amazing, but innovation in the world of computer graphics started moving faster and faster. Despite the magic that DX11 brought, users demanded more and more bling, but all we were talking about was how VL would revolutionize visual-programming, which brought us all together in the first place.
With the cross-platform goal in mind, for years it seemed the only option was going for OpenGL instead of Direct3D as rendering API for VL. But all those years, following OpenGLs development and stories about bad support by Microsoft and Apple never got us excited enough to just go for it. Meanwhile a new player has appeared as a modern cross-platform graphics API, called Vulkan, but since it is still in its early stages and support for MacOS seems not official yet, again we were reluctant to jump on it.
All the years we knew there would be another option: Instead of using Direct3D, OpenGL or Vulkan directly, we could base a rendering library for VL on a game-engine API that would deal with different graphics APIs under the hood and would possibly have all 3 as back-ends that can be used on different platforms without us needing to worry about it.
While this sounds brilliant, it obviously has other potential drawbacks (out of scope for this post). But also the range of options for game-engines we could have used wasn't too overwhelming. Until recently. Enter Xenko.
We've had an eye on this engine for a while already but it being targeted at commercial game-studios would mean that every user of vl would also need to buy a license for it, so again we were hesitating and looked for alternatives.
But what just happened could again not have been more fortunate: The company behind Xenko, Silicon Studio, removed its commercial licensing and released it to the community under the MIT license, which is a very permissive open source license. This would allow us to base a renderer for VL on it without any licensing restrictions.
Initial tests look very promising. Within just a few days we were able to patch a little interactive scene and export the project as an executable so it could be distributed via the Steam store and run on a VR device.
Hence our plan is to investigate further in this direction and at the moment we see two interesting workflows between VL and Xenko:
For both scenarios what will be important, is a proper library design wrapping the original Xenko functionality into a comfortable set of nodes, similar to what we just did for Skia.
We'd usually not water your mouths before we are more sure about things. But with Xenko just having gone full open-source and looking to build a community of developers and users, we thought it would be a good idea to talk about this now and try to involve you from the beginning.
So if you're curious about Xenko's universe, just head over to its website and see what it has to offer. You can even download and play around with the editor and if you're familiar with C# create a little game with fancy graphics and assets in no time.
Next we'll demo what we've got so far to participants at LINK and start a discussion there. If you're not at LINK please still join the discussion with your thoughts using this thread. If all goes well we should also be able to share our proof of concept sometime after LINK.
So we hope you understand that at this stage it is too early to promise anything but at the moment we are confident to having found the right library for implementing a 3d rendering system for VL. Just as we were happy when we finally found Skia as the perfect library for VLs 2d rendering system.
We'll update you about developments as we progress...
previously on vvvv: vvvvhat happened in June 2018
...and the patching goes easy. And we have a release candidate for beta37 out! Please take a moment to test it against your latest projects and report any problems in the forum using the alpha tag.
We added two more features to the alphas within the last month:
For the brave we also pre-released the long announced 2d Rendering Engine for VL based on Skia. Note that this is still an alpha-grade release and we are very much hoping for your feedback on it! But this also means that for projects that don't necessarily need 3d-rendering you can now most likely start thinking full VL! Who will show us the first such project?
The 2nd Berlin Meetup has happened and now LINK Summer Camp is coming up shortly. Even if you're not attending, we'd be happy if you participate in the discussions we'll be having there. And maybe you can make it to our next meetup at the lake on August 12th!
|Two new:||Two updated:|
Who david, aaa, joreg, sebl
When Sun, Aug 12th 2018 - 11:00 until Sun, Aug 12th 2018 - 22:00
Where Grüne Hütte, Brandenburg, Germany, Germany
Invitation! Come and spend a day at LINK - the vvvv summercamp.
LINK opens the space and shares the experience on our last day Sunday August 12th.
So we thought, lets have the next Berlin VVVV Meetup right there including family, kids and friends.
Please register for the open sunday on the LINK Website HERE
UPDATE: We reduced the expenses to 10 Euro for the food and drinks.
Spend the night withs us and stay overnight. No Problem, bring a tent, we count you for the breakfast on Monday morning then.
Also please share your ride with others. Organize yourself in this spreadsheet
Thanks go to Laura and Julia and her family who own the space and share it with us.
Skia is a modern and fast 2d rendering library. As usual, we stand upon the shoulders of giants when making this functionality available to you: the core Skia technology and the .Net binding "SkiaSharp". The VL.Skia package aims to make all of this functionality available within VL in an easy-to-use high-level node set.
You now can have the first glimpse on it. From the start, it comes with a nice stack of tutorials and example patches. This package is done for vvvvbeta37.
Here is a rough overview of what the key concepts are:
Just like known from vvvv the main idea is that layers can be grouped and can be connected to a renderer to draw them. Most Layers come with a Bounds input OR Position and Size and Anchor.
We offer different renderers:
Every layer comes with a Paint input. It describes how to draw the layer. This is very comparable to the render states in DX9/DX11.
You can stack the Paint-modifying nodes. Nodes like SetColor would take everything from the incoming paint and only adjust the color.
Shaders, Filters, and PathEffects are all properties of Paint. 1000 words wouldn't be enough to describe what you can do with them. You probably just need to play with them a bit.
Text nodes are also just Layers. You can think of them as text boxes.
Within that rectangular region you now can adjust horizontal and vertical alignment. This is done via properties of Paint. The FontAndParagraph node allows to conveniently adjust several text related paint properties in one go.
You can visualize the text box with the Show Helpers pin of FontAndParagraph.
(See the examples\3_Text for how to do word wrapping etc.)
Layers can be transformed. This allows you to patch a Camera. You would then connect your scene to the Camera and the camera to the renderer.
Transforms are not that important as in 3D rendering frameworks as all Layers already can be placed.
Scaling a Layer influences the stroke width. If this is unwanted specify the Size on the layer itself and not via transform node.
We designed the library in a way that it works for different scenarios. Sometimes you would like to think in a normalized space, like known from DX9/DX11. In other scenarios, you want to think pixel- or device-independent-pixel-based.
Layers in Skia can be interactive. The main idea here is: "What you see is what you want to interact with". So if the layer is interactive, connecting it to the renderer in one way or the other means that it will be drawn AND that you can interact with it. (See examples\5_Interaction)
This part is under construction still.
In order to use this library with VL, you have to install the NuGet that is available via nuget.org. For information on how to use NuGets with VL, see Managing NuGets in the VL documentation. In short, navigate via document menu to Dependencies -> Manage NuGets -> Commandline and then type:
As long as we don't have an example browser here is how to get them via windows explorer:
Drag & drop an example patch onto vvvv or VL. For closing the example use the X on the renderer or hit Ctrl-F4 on the VL patch.
Serialization in VL has drastically been simplified by introducing two new nodes called Serialize and Deserialize in the category System.Serialization.
Let's first have a look at two basic examples:
As you can see from the screenshot the resulting string is very short and contains only the mimimum amount of data. It achieves that tidyness by only serializing user defined properties, skipping properties which have the default value, making use of XML attributes, putting collections of primitive values into comma separated strings and adding type information only when necessary.
When deserializing the system will try to apply the serialized content on the instance to be created. This makes it very resilient to future patch changes as adding or removing properties and to some extend even changing the type of a property will just work.
Serializers are provided for all primtive types (Boolean, Integer32, Float32, etc.), collection types (Array, Spread, Dictionary, etc.), commonly used imported types (Vector2/3/4, Matrix, Color, etc.) and most importantly all patched types. If a serializer should be missing for a certain type either report it to us or keep on reading to the next section where you learn how to patch (or write) your own serializer.
Paired with the new files nodes serialization to disk is straight forward:
That's basically all there is to know from an end-user perspective. You can try these new nodes in the latest alpha versions.
Even though VL ships with serializers for the most common types the situation could still arise where a custom serializer has to be written - either because it's simply missing for the type in question or one is not satisfied with the output of the already existing serializer.
Creating a custom serializer consists of two steps
Here are two screenshots of the above from an example implementation which can be found in the VL.CoreLib/help/Serialization.vl file:
We're looking forward to your feedback.
We and the 25 participants can't wait for LINK, here are some information for everybody on what we're gonna do there.
We went through all applications and clustered the topics the participants want to work on and tried to sort all wishes and tagged them into 6 main topics/areas.
What we've mostly understood by now is that different use-cases have different timeline or cueing needs. Can we identify recurring scenarios and work towards a modular set of nodes to build custom timelines quickly?
2) 3D Engine
Direct3d, OpenGL or Vulkan, all possible with VL but what does a library of nodes look like for the things we want to do. What's the basics, what's needed, what's a bonus?
3) Integrating Libraries
VL makes it particularly simple to integrate basically any .Net library. There are tons of libraries available. What are common patterns, best practices when importing and wrapping third-party libraries for use in a visual-programming language.
4) Machine Learning
Being the buzz of 2018, ML can be beautifully integrated with visual programming concepts. Libraries exist that can be used, ideas are needed regarding what to use them for.
5) Authoring Environment
vvvv is a multipurpose toolkit, VL is even much more general. Too general for some. What future target groups can be identified, what are their specific needs, how to best work towards those.
6) Realizing Projects
This is a group where everyone works on their personal projects but is interested in sharing ideas and best patching practices, brainstorming concepts and helping each other out.
Please add your thoughts/ideas/interests regarding each of these topics in the forum.
When Mon, Sep 10th 2018 until Sun, Sep 16th 2018
Where Kontor80, Torgauer Straße 80, Leipzig, Germany
Open Call | Wisp Laboratory ‘18
We’re pleased to announce the international Open Call for the second edition of Wisp Laboratory at Kontor80 in Leipzig, which will happen from 10th to 16th of September.
After last year’s successful week of building a 3D speaker setup and realising a 360° visualisation setup together with the participants, Wisp Laboratory is back for its second year.
We welcome audio and video artists from across the globe to apply for this unique lab. The Laboratory is limited up to 20 participants. The aim is to encourage and increase meeting points and the interaction between people. Together we will reconstruct architecturally the audiovisual phenomenon through concerts & performances with collaborative real-time systems.
From 10th to 14th of September the participants will set-up a 3D Audio and 360° projection environment together with the lab hosts and have time to prepare their shows for the final presentation. In the nights of the 15th and 16th of September the results will be presented to an audience in a public event.
The lab will be facilitated by Felix Deufel (Audio Host) and Paul Schengber (Video Host) and David Simmons (Video & Audio Host) of Wisp Collective.
The location of the lab days and performance nights will be Kontor80, Torgauer Straße 80, Leipzig.
Deadline for Applications is the 31st of July!
Please download and fill out the Application Form:https://drive.google.com/open?id=1eRVMQ1Ku9IwMwMe9M52RsHUNYSb5L42Y
Once you have completed your application, please ensure it is accompanied by the following:
Portfolio (maximum of ten works) – JPEG, PDF or Word Docs, links to videos, sound files
Please send your application electronically along with the above information to the following email address: email@example.com
If you have any questions please do not hesitate to contact us!
as an avid vl user by now you've understood that in vl there are different kinds of patches. While colloquially we just call them all patches for simplicity and because they all allow you to patch in them, we can easily distinguish two main types of patches:
While datatype patches more resemble what we had in vvvv, structural patches are new in vl. We just reworked this part a litte and ended up with 3 structural patches which make things much more clear:
But before we go on let's make sure we are on par regarding the term "Category":
Obviously. (Yeah, just wanted to make sure)
What we had so far was a not so clear mix of all three. Let's see what we have in latest alpha:
Group patches simply allow you to create more space in a patch by opening a new canvas. The groups name is merely used for human readability, vl doesn't care about it at all. Create a group by typing "group" in the nodebrowser. Groups is what you will be mostly using in your daily project-patching work.
Inside a group patch
Group patch from the outside
A Category patch looks quite similar to the group, only its name has a meaning: The name appends itself to the category of its parent patch. That way you can build up any category hierarchy, that you then see in the NodeBrowser. Multiple category levels are allowed with dot notation. e.g. MyCat1.MyCat2.
Inside a category patch
Category patch from the outside
A Full Category patch is similar to the Category patch, only that it doesn't add its category to the parent. By that you can place nodes in any category, regardless of the parent patch. It's considered bad practice to do that, but is useful to add nodes to an existing category like Collections.Spread, for example. Multiple category levels are allowed with dot notation. e.g. MyParentCat.MySubCat.
Inside a full category patch
Full category patch from the outside
Each vl document can directly start a category, which you can define in the angular brackets in the top left corner of the document patch.
You can easily convert a group patch into a category patch and vice versa by the patch type enum. Note how the label changes and represents the actual category structure:
As if the above didn't offer enough options already there is one more way to specify a category for an operation or a datatype definition:
Happy node sorting!
Who Alexandra Pirici, Andrei Dinu, Ion Cotenescu, Jared Marks, Maria Mora
When Thu, Jul 5th 2018 - 19:30 until Fri, Jul 6th 2018 - 19:30
Where Roskilde Festival Art Tent, Roskilde, Denmark
Adda Kaleh is a musical project of first league performance artist Alexandra Pirici.
Come have a brake from the beers at the Art Tent on thursday and/or friday at 19:30 for a show made both by woman and robot. Or something inbetween.
If you are from hhhhere, don’t hesitate to say hi, ggml will be scriptkid for the night.
previously on vvvv: vvvvhat happened in May 2018
que patcha? we did it. as announced here last time, we've finally finished our cleanup of the VL.Corelib. further we've released improved File IO nodes and a little new feature to frame your patches. we've also reworked how groups and categories work which we'll introduce in a blogpost soon. these then were the biggest chunks that we had planned for the coming release. so we're now soon reaching everyones favorite: release-candidate time!
|again some amazing new stuff:||and some fine updates to existing contributions:|
anonymous user login