» Blog
This site relies heavily on Javascript. You should enable it if you want the full experience. Learn more.

Blog

new post

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.

  reset tags

addon-release core-release date devvvv gallery news screenshot stuff
delicious flickr vimeo
Order by post date popularity

Who maarja, tobyk
When Tue, May 1st 2018 - 10:00 until Fri, May 4th 2018 - 20:00
Where Pistoriho palác, Štefánikova 834/25, Bratislava, Slovakia

CCL is an internationally traveling format offering digital media ‘code savvy’ artists the opportunity to translate aspects of choreography and dance into digital form and apply choreographic thinking to their own practice. In a one week interdisciplinary peer-to-peer setting, the participants work on their own projects, share knowledge, find new collaboration partners, discuss ideas and challenges. Previous CCLs have been joined by digital artists, musicians, architects, physicists and dancers, all bringing along a variety of emerging new media tools and setups that can be experimented with and explored for new artistic ideas. Results from the week might range from prototypes for artworks to new plug-ins for working with dance related datasets (www.choreographiccoding.org). CCLs finally seek to initiate a sustainable collaborative practice among its participants encouraging ongoing exchange in an artistic research community of individuals.

Limited number of participants. Submissions deadline is 23th of March.

Workshop is free of charge thanks to the support of the Goethe-Institut Bratislava.

maarja, Wednesday, Mar 14th 2018 Digg | Tweet | Delicious 0 comments  

Who fibo
When Fri, Mar 16th 2018 - 14:00 until Sun, Mar 18th 2018 - 02:30
Where Ri-make, Via Artesani 47, Milan, Italy

rimake flyer

We are happy to be hosted by Ri-Make, that is a sort of squat in a dismissed bank, for few installations and a free vvvv workshop!

The workshop will be on saturday 17th March 2018, in the afternoon. In the last Patcher Kucha I organized I knew many people from Brera Accademy in Milan and noticed and increased interest in vvvv.

Thanks also to fusomario who is spreading the vvvvord really hard, there will be few vvvv installations hosted.

My installation is related to mathematics, of course, and let user interact with music generated by prime numbers and tells the user their history while a bitcoin data graph in real time is showed... in some way they are related.

On the other hand fusomario will present two installations (of course using vvvv, otherwise italian mafia gang is disappointed): one is hard to believe at first, there is some vegetable connected with an arduino to get its feelings into an IObox. I saw with my eyes and it is true: the vegetable responds to stimuli (light, sounds and caresses) , connects with people, and manifests its feelings.

I have heard other people from Brera will show other installations using vvvv.

Come to vvvvisit us!

fibo, Tuesday, Mar 13th 2018 Digg | Tweet | Delicious 0 comments  

previously on vvvv: vvvvhat happened in Jannuary 2018


okok,

have we mentioned beta36 yet? it is still a release candidate and about to be released soon. quasi. so please take this last chance and make sure your latest projects will work with it when it will be released, by getting the latest candidate and testing them against it. in the unlikely event that you have something bugging you, prettyplease let us know. in the comments, in the forum or in the chat. thanks.

in case you've missed the february news from the devvvv room, please catch up here. both of these can be tested in the candidate already:

and meanwhile we're already working on a branch towards b36.1 scheduled for in about 2 months after b36 release. it will mostly focus on a cleanup of all vl libraries and finally opensourcing them so we can start accepting contributions.

Jobs

looking or a job? there are currently two offers: one by grosse8 in cologne and another by intermediate engineering in hamburg.

and in general this place seems to have some related listings: das auge

Contributions

two new ones

plus a work in progress

and a teaser

and quite a couple of updates
the DX11 pack by vux comes with fixes and new features and its further development can now be supported: if you're using the pack you should definitely consider becoming a patreon!

Gallery



Sincronización Láser con proyección by colorsound


that was it for february. anything to add? please do so in the comments!

joreg, Friday, Mar 2nd 2018 Digg | Tweet | Delicious 1 comments  

Who David Gann, schnellebuntebilder
When Sat, Apr 28th 2018 - 12:00 until Sat, Apr 28th 2018 - 18:00
Where schnellebuntebilder, Rudolfstr. 11, Berlin, Germany

Introduction

''VVVV.js features many essential JavaScript and WebGL programming methods packed in a set of over 300 nodes. The browser-based patch editor enables you to get started right now on any platform and it is possible to quickly deploy your application to web and mobile.
Recently VVVV.js received a huge update which implements advanced rendering techniques like physical based rendering, instancing and depth-buffer based post effects.

To jump right into action follow this link:https://tekcor.github.io/vvvv.js-examples/
There is also a very detailed overview in written form here:http://000.graphics/tutorial/02_VVVV.js_Introduction.html
or watch the video:

Workshop Content

In detail we will look at the following topics:

• Physical Based Rendering
• glTF Import and three.js model loading
• Instancing Engine
• Deferred Effects
• Collision Detection
• Terrain Rendering
• Multi-Texturing
• Particles
• Derivative Maps (Tangent free Normal and Parallax Occlusion Mapping)
• Shader and Node Development for VVVV.js

Booking and Fees

Reserve your workshop seat now via mailto:vvvvorkshop@schnellebuntebilder.de

There will be a fee of 50,00 € per attendee (recerving room + support for lecturer).
If you consider yourself a professional or your company sends you here, we use T.R.U.S.T to encourage you to pay a professional fee, which is 200,00 €.

Become a Patreon

If you can`t make it to berlin but want to learn it,
consider joining my online course or receive direct mentoring by becomming a Patreon. Your support will accelerate the development of this amazing framework.
https://www.patreon.com/davidgann

tekcor, Friday, Mar 2nd 2018 Digg | Tweet | Delicious 0 comments  

After a little while, here we are, a new version bump for dx11 rendering.

This as usual comes with some bug fixes and new features.

Bug fixes

First, there were 2 reasonably major issue which are now fixed:

  • Quad node would start to throw error if fed a nil anytime, and would not recover from it.
  • Deleting texture fx and renderer temp target would not release the associated resources, resulting in a leak (only while authoring, not while having a patch running).

New features

Next, of course there are new features, here are a few selected ones (full changelog below)

  • Kinect 2 nodes now also have help patches, so now all nodes from plugins do have a help file.
  • Sample and Hold for Buffers, 2d and 3d textures
  • Support for shared buffers. This is identical as shared textures, but for buffers, so you can share compute work cross process for example.
  • New library (TexProc), which contains some nodes for image processing which are not conveniently done using texture fx. Check RGBASplit , HSLASplit, ExtractChannel and Composite nodes.

Supporting DirectX11 development

For more than 6 years DX11 pack has been free, and will stay free.

The question about supporting development has been asked several times, and for now there was no official way to do so (except contacting privately).

So from now, dx11 contribution has a Patreon page, in which you can provide monthly donations to (various pledges with various rewards are available, including access to upcoming video workshop patches and custom support).

https://www.patreon.com/mrvux

Full changelog:

  • Pack version info is now integrated, which allows to use pack versioning feature (as well as diffing).
  • Kinect 2 nodes now all have help patches as well, so now every node in the pack has a help file.
  • Fix spelling on Frustum (Transform)
  • Fix spelling on FrustumTest (DX11.Validator)
  • Fix Quad layer which would not recover if fed a Nil input.
  • Renderer (DX11.TextureArray) now has a UAV pin (disabled by default), so texture can be written by compute shaders.
  • Softworld node did not allow to create contstraints.
  • Temp target renderer was not releasing resource when deleting the node, which was creating memory leak when authoring.
  • Fix shader releasing their resources when deleting them from patch.
  • Add ExtractChannel (DX11.Texture), which allows to pick individual channel of a texture (also auto handling input/output formats when required).
  • Add RGBASplit (DX11.Texture), extract all texture channels in a separate texture.
  • Add HSLASplit (DX11.Texture), extract all texture channels in a separate texture (converts into either HSL or HSV)
  • Add Composite (DX11.Texture), combines a spread of texture into a single one, each texture can have individual blend mode,opacity and texture transform
  • AsSharedTexture (DX11.Texture) , now forces evaluation by default
  • Add AsSharedResource (DX11.Buffer) , to allow to share a dx11 buffer between various processes.
  • Add FromSharedResource (DX11.Buffer Structured) , receiver side for shared buffer.
  • Add FrameDelay (DX11.Texture 3d) , orthogonal to all framedalys, for 3d textures.
  • Add WriteMask (DX11.RenderState) : Allows to control which channels are written to
  • Add WithinSphere (DX11.Validator) : Only draw objects which have a bounding box contained within a sphere.
  • Added ConstantFactor preset in Blend (DX11.RenderState), to allow to use BlendFactor (DX11.RenderState) more easily.
  • All Create Body nodes now have custom string input (which was missing from previous version)
  • IsYoungerThan (Bullet Rigid.Filter) new node
  • Add AlphaOperation (DX11.RenderState) : Allows to control how the alpha channel is written in the texture (independently of color blending).
  • Add S+H (DX11.Texture 2d) , Same as standard S+H nodes, copies a resource if the set pin is on, blocks evaluation and render otherwise (also optimize resource flags/usage behind the scenes).
  • Add S+H (DX11.Texture 3d) , for 3d textures
  • Add S+H (DX11.Buffer Structured) , for structured buffers

Download here:
directx11-nodes

vux, Saturday, Feb 17th 2018 Digg | Tweet | Delicious 6 comments  

Who maarja, id144, nissidis
When Tue, Feb 13th 2018 - 20:00 until Tue, Feb 13th 2018 - 21:00
Where Prague, Františka Křížka 36, 170 00 Prague, Czech Republic

Everywhen is dark, depressive and captivating contemplation on the recurrence in history. Everywhen orbits around two sides of life - the personal and the political. An often caring, gentle and well-meaning personal life is contrasted here with the reality of the social individual, who can often be sinister, vengeful and hateful. But how can we be critical to our own world views when they are created by those closest to us?

Trailer https://vimeo.com/249193177

Visuals, concept: Mária Júdová
Dance, concept: Soňa Ferienčíková
Music, concept: Alexandra Timpau
Lights: Ints Plavnieks
Technical support: Andrej Boleslavský, Constantine Nisidis
Produced by: BOD.Y – Zuzana Hájková
Supported using public funding by Slovak Arts Council

maarja, Tuesday, Feb 13th 2018 Digg | Tweet | Delicious 0 comments  

When we talk with our trusted VL pioneers we often find them implementing timeline like applications, which come with the main problem to find the keyframe that is the closest to a given time, often even finding the two closest keyframes and interpolate between them weighted by the position of the current time.

Easy? Just order all keyframes by time and start at the first keyframe and go thru the collection until you find one that has a time greater than the time you are looking for. This is called linear search and might work very well at first, but obviously has two performance problems:

  • The bigger the time you are looking for gets, the more checks you have to perform
  • The more keyframes you have, the more checks you have to perform

Enter Binary Search

Binary search does the same task in a much smarter way: It starts with a keyframe in the middle of the collection and checks whether the time you are looking for is greater or smaller than this middle keyframe. Now it can rule out half of all keyframes already and search in the interesting half in the same way: Take the middle keyframe and compare its time. As this rules out half of all remaining keyframes in every step, the search is over very quickly. In fact it's so stupid fast that on a 64-bit machine the maximum steps it has to perform is 64, because the machine cannot manage memory with more than 2^64 elements.

VL Nodes

The VL nodes cover several use cases. Depending on how your data is present you can choose from the following options.

All nodes expect that the input collection is ordered by the search key from low to high.
Only Values

The most simple node is just called BinarySearch and takes a collection of values. It returns the element that is lower and the one that is higher, their indices and a success boolean indicating whether the search key was in the range of the input values at all:

Key Value Pairs

For simple scenarios that don't require a custom keyframe data type the BinarySearch (KeyValuePair) version can be used. It operates on the simple data type KeyValuePair that comes with VL.CoreLib and returns the values, keys and indices:

It also comes as BinarySearch (KeyValuePair Lerp) with an integrated linear interpolation between the values that is weighted by how far the search key is from the two found keyframes:

Custom Data Types

If you have your own keyframe data type the BinarySearch (KeySelector) is your friend. It can be created as a region with a delegate inside that tells the binary search how to get the key from your custom type:

There is also BinarySearch (KeySelector Lerp) which has the same delegate and needs a Lerp defined for your keyframe that it can use internally. You keyframe data type could look like this:

The usage is then basically the same:

Other usages

A timeline is of course just one use case where binary search is useful. All data that can be sorted by a specific key can be searched by it.
Speaking of sorting, if you add elements to a sorted collection binary search can help you to find the index at which to insert the new element. Use the Upper Index output as insert index like this:

So it can help you to keep the very same collection up to date that you use to lookup the elements.
A usage example can be found in girlpower\VL\_Basics\ValueRecorder.

Enjoy the search!

Yours,
devvvvs

tonfilm, Monday, Feb 12th 2018 Digg | Tweet | Delicious 17 comments  

In the VVVV world you'll find four new nodes, UploadImage and UploadImage (Async) - both for DX9 and DX11 returning a texture. The former just takes an image and when requested uploads the image to the GPU, the latter takes an IObservable<IImage> and will upload whenever a new image gets pushed.
In the VL world you'll find ToImage nodes which allow you to build images out of arbitrary data. Here is a little Game Of Life example:

Generating images in VL
Rendering images in DX9 and DX11

That one image is gray and the other red comes from the fact that we map a pixel format with one red channel to a format with one luminance channel in DX9 - not entirly correct, but better than seeing nothing at all.

The interface in detail

So what is this new image interface exactly? Well it came up in the past (https://discourse.vvvv.org/t/bitmap-data-type/6612) and re-surfaced again in VL - the topic of how to exchange images from different libraries. Nearly all of them come with their own image representation, like a Mat in OpenCV, a Sample in GStreamer, a Bitmap in GDI, an Image in WPF or just plain pointers in CEF - just to name a few we stumbled accross in the past.
All of those libraries provide different sets of operations one can perform on their image representation, they have different sets of supported pixel formats and they also differ in how they reason about the lifetime of an image. In the end though we want all those node sets which will be built around those libraries to work together.

We therefore decided to add a new interface - simply called IImage - to our base types in VL with the intention to allow different node libraries to exchange their images. The idea is that the node libraries itself work with the image type they see fit and only provide ToImage and FromImage nodes which will act as the exit and entry points. Whether or not those entry and exit points have to copy the image is up to the library designer and probably also the library itself. For some it will be possible to write simple lightweight wrappers, for others a full copy will have to be done. If a certain pixel format is not supported by the library it is fine to throw an UnsupportedPixelFormatException which will inform the user to either change the whole image pipeline to a different pixel format or insert a conversion node so the sink can deal with it.

Before diving any deeper here are two screenshots from a little example image pipeline, getting images pushed in the streaming thread from a GStreamer based video player, using OpenCV to apply a dilate operator on them and passing them down to vvvv for rendering:

The image interface comes with a property Info returning a little struct of type ImageInfo containing size and pixel format information. With this struct it's easy to check whether the size or the pixel format of an image changed. The pixel format is an enumeration with just a few entries of what we thought are the most commonly used formats. Since there're many many others the image info comes also with a OriginalFormat property where an image source can simply put in the original format string - whatever that is. But it at least gives sinks a little chance to interpret the image data correctly.

/// <summary>
/// Gives read-only access to images.
/// </summary>
public interface IImage
{
    /// <summary>
    /// A structure containing size and format information of the image.
    /// </summary>
    ImageInfo Info { get; }
 
    /// <summary>
    /// Gives access to image's data. Must be disposed after being used.
    /// </summary>
    IImageData GetData();
 
    /// <summary>
    /// A volatile image is only valid in the current call stack.
    /// </summary>
    bool IsVolatile { get; }
}

The second method on the interface called GetData is used for reading the image. It returns the IImageData interface pointing to the actual memory. Since the IImageData inherits from IDisposable the returned image data needs to be disposed by the caller. With this design it should be possible to implement all sorts of image reading facilities - as pin/unpin, map/unmap, lock/unlock etc.

/// <summary>
/// Used for reading images.
/// </summary>
public interface IImageData : IDisposable
{
    /// <summary>
    /// The pointer to the data.
    /// </summary>
    IntPtr Pointer { get; }
 
    /// <summary>
    /// The data size in bytes.
    /// </summary>
    int Size { get; }
 
    /// <summary>
    /// The scan size (one row of pixels including padding) in bytes.
    /// </summary>
    /// <remarks>If the scan size times the image height is not equal to the size data copying has to be done row by row.</remarks>
    int ScanSize { get; }
}

In order to avoid copying data the image interface comes with a last property IsVolatile which when set tells a sink that the data in the image is only valid in the current call stack - so it can either read from the image immediately or if that is not possible it will need to clone it. We expect image implementations to return data of the default image in case the read access happended too late. Imagine one puts volatile images into a queue without copying them first, the result should be a bunch of white quads so those errors should become visible immediately.
In case the volatile flag is not set we expect the image data to stay the same so no further copying is necessary on the sink. It can hold on to the image as long as it wants.

We further provide a couple of helpful extension methods to the IImage interface like Clone/CloneEmpty or making an image accessible as an System.IO.Stream

With this in mind let's look how to expose library specific image types:

  • In case the library newly allocates the memory for the image on the managed heap, not much has to be done except of writing a little wrapper implementing our image interface, returning false on the IsVolatile property and basically just forwarding all interface calls to the original image type.
  • The library takes the memory from a pool or uses some ref count mechanism. In this case it's most certainly mandatory to ensure that the original image gets disposed. If the image gets pushed from the library we recommend to simply push the image further and dispose it right after. If the image needs to get pulled from the library the wrapper should also implement the IDisposable interface and hand it downstream inside the resource provider monad so that the disposal behavior is correct once all the sinks are done using the wrapper. The third option is to simply copy the data into a private image one can hand downstream.
  • The library always returns an image pointing to the same memory. Similiar to the previous case except that one must not call dispose on the original image.

Example implementations can be found in VL.Core, VL.OpenCV and VL.GStreamer

Elias, Monday, Feb 5th 2018 Digg | Tweet | Delicious 0 comments  

previously on vvvv: vvvvhat happened in December 2017


jannuary 2018,

or as i'd like to call it: a new dawn.

so many things...where to start... probly here if you haven't yet: vvvv-in-numbers-2017
then an apology for the current release-candidate hiatus. we've been too optimistic end of december, when we let out the first. meanwhile 3 more things got finalized:

a new RC is scheduled to be announced this week.

also, the five part vl for vvvv users series of videos is now complete: part 1, part 2, part 3, part 4, part 5. it is basically the workshop i gave at node17. it picks you up where you are as a vvvv user and shows you how the basic things are mostly the same in vl but only when it comes to spreading you need to learn about loops instead. and once you're there you'll not want to look back...

...like e.g. this doctor, who was kind enough to give us an update on the status of his latest developments. must watch!

what next:
we have a few independent libraries in the works at the moment that we're planning to announce properly in the coming weeks each. for the bravvvve ones among you, go check our public repositories already:

and even more to come... but beware: there aren't really instructions yet on how to use those. so you might as well want to wait for the announcements.

with beta36 hopefully out soon we'll then make plans for the next release. high priorities are endless, will be some tough decisions to make again.

vvvv Academy

it happened. it was great. 6 participants from zero to vvovv in 6 days. a few impressions are here. we're planning to do this again, stay tuned!

Contributions

here is a big one: u7angel open sourced his Automata UI and in addition is also giving it away for free now for commercial projects! you be stoopid not use it and get him at least a drink the next time you see him. thanks man!

further quite a load of new stuff:

and updates to many top contributions:

Gallery

Recursive Infinity - Endless Procedural Crazyshit by evvvvil

otherwise sadly not so much in the gallery last month. seems everyone is too busy networking their stuff socially. and then i stumbled upon this: https://vimeo.com/search/sort:latest?q=vvvv with many more recent uploads.. but please don't forget to share your works also in our gallery to show people having their first contact with vvvv.org, what you're doing with it.

and on a final note: tekcor has announced a workshop titled Chaos - Noise - Motion that will take place on march 10th in leipzig.


that was it for jannuary. anything to add? please do so in the comments!

joreg, Sunday, Feb 4th 2018 Digg | Tweet | Delicious 2 comments  

Dynamic Buffers

Current vvvv alpha and upcoming vvvv beta36 has a new set of nodes that allows you to quickly upload data from VL to the graphics card. We had a WIP forum discussion about it here: VL - Custom Dynamic Buffer

On the VL side the nodes are called ToBufferDescription and we have them for the basic data types that usually hold big chunks of data: Spread, Array, IntPtr and Stream. The vvvv side is rather easy and only has one node called UploadBuffer (DX11.Buffer).

Primitive Data Types

Primitive types work out of the box and don't need any special treatment. Just make sure you define the correct Buffer type in the shader. This works for Integers, Floats, Vectors and so on, everything that is available in the shader as primitive type. Here is an example for Float32:

The only exception is Matrix it needs to be transposed in order to work like a normal transformation input. If you send a large amount of individual matrices to the shader the most efficient way is to do the transpose in the shader directly:

If the same matrix is re-used very often or you don't have access to the shader code simply transpose in VL:

Custom Data Types

If you want to define your own data types like light information or a custom vertex type in the shader then you need to pack the data accordingly in the buffer description. For this task the ToBufferDescription (Stride) nodes are used. They allow you to make a buffer description out of primitive types like float or even byte and set the stride size of your custom type in bytes so that the shader can read the custom type directly out of the buffer.

Matrix hint: If you define a matrix in a custom type in the shader you can use the row_major modifier to automate the transpose operation.

struct MyLightType
{
    float3 Direction;
    float Brightness; 
    row_major float4x4 Transformation; //set matrix type
};

Performance hint: If you can, design your custom types in a way that the byte count is a multiple of 16, sometimes it makes sense to insert unused floats as padding:

//would have 20 bytes, but blown up to 32 bytes (2 x 16) for faster read performance
struct Circle
{
    float4 Position;
    float  Radius;
    float pad0;
    float pad1;
    float pad2;
};

More info: https://developer.nvidia.com/content/understanding-structured-buffer-performance

Custom types in C#

If you are a C# coder you can also define a struct in C# with attribute StructLayout(LayoutKind.Sequential) and the same byte layout, import it in VL and pass that directly into the buffer. Then you don't need the node with version StrideSize because the data type size already matches.

[StructLayout(LayoutKind.Sequential)]
public struct Circle
{
    public Vector4 Position;
    public float Radius;
    float pad0;
    float pad1;
    float pad2;
 
    public Circle(Vector4 position, float radius)
    {
        Position = position;
        Radius = radius;
    }
}

Dynamic Raw Buffers

While in the process of doing the dynamic buffer nodes it was easy to add raw buffers. These buffers are from older shader models and can only be filled with bytes. On the shader side however you can also define Custom types. Only difference in HLSL is that you write Buffer<YourType> instead of StructuredBuffer<YourType>.

The node set is basically the same except that the VL part is not generic and only accepts bytes as input. The node names are ToRawBufferDescription in VL and UploadBuffer (DX11.Buffer Raw) in vvvv.

Raw buffers have no advantage except when you have to deal with an older graphics card, driver or shader code.

Examples

A VL patch with shader code can be found in latest alphas girlpower\VL\DX\DynamicBuffersAndTextures.v4p. And it is also used by @mburk for material management in his latest superphysical pack.

So now you can start sending your data up to the card and enjoy the speed. As always, if any questions arise hit us up in the forums.

yours,
devvvvs

tonfilm, Thursday, Feb 1st 2018 Digg | Tweet | Delicious 3 comments  

anonymous user login

Shoutbox

~7min ago

ggml: how to hide vl window from vvvv ?

~21h ago

CeeYaa: https://experiments.withgoogle.com/collection/ai/move-mirror/view Skeleton Tracking with my Browser - cool AI stuff

~2d ago

woei: everyone who likes or has to work with 3d models: something you might wanna try scenegraph

~4d ago

tonfilm: Saving and loading your own data types to disk was never easier: vl-serialization #vvvv #vl #dotNet #visualprogramming

~6d ago

stulloyd: @dominikKoller my little brother works for them.

~11d ago

vasilis: @readme I already did this...but when I reopen my patch and make some changes I press save all..and then the same again. It opens 2

~11d ago

readme: vasilis, Alt+R in your vvvv instance, delete it from vvvv root, save. Otherwise vvvv loads up the patch by default.