That's great!
Will try it as soon as the OSX binaries are available.

I'll add the new web interface for Deken:
https://deken.puredata.info/

I didn't really use it yet, but it might be helpful for finding externals and libraries.

Was curious to know if someone attempted to recreate these weird one-liner symphonies in Pd. It should be possible right? Is there any bitwise math genius able to understand this?

t*(((t>>12)|(t>>8))&(63&(t>>4))));

There is a nice write up here and a funny JS toy to play with.

A bit OT and not exactly elegant, but if you need a general solution that also works with floats:

It's the only way I know to see whether an argument (symbol or float) has been provided or not. It takes advantage of a string escape bug, credit goes to the Pd list.

This is usually my approach:

Curious to know if there are simpler ways of doing it.

Well, if you want to simplify the patch you could also just use a creation argument for [moses] instead of the loadbang message.

@seb-harmonik.ar
THANKS

@seb-harmonik.ar said:

btw, another option is to use the tglgrid external https://github.com/nicklan/tglgrid. You'd have to have a route after the [tglgrid] that routes depending on if you're saving or playing.

That looks interesting, is there a binary available for OSX?
I can't find it on Github or Deken.

There is a bit of debate around this lately but I would suggest to try Ofelia. You just find it on Deken and the webcam support is great.
GEM is very robust and offers a great user experience, but Ofelia saves you a lot of time when it comes to video formats, streaming and images.

Thanks everyone!

I ended up using this solution:

The user won't be able to change value if the range is fixed.

Hi everyone, I'm working on the GUI of a patch and I need to display a static number. The user should not be able to change it directly from the GUI element.

I came up with two options:

• Making a canvas [cnv] object and sending a label message to it. This works, but I need to use [makefilename %d] because [cnv] complains if the label message contains only a float.
• Using a number or number2 object would be my ideal choice but I don't want the user to be able to change it. Is there a way to «disable» or make the number GUI element static?

Thanks

That looks pretty interesting @60htz, l'll have a closer look at your patches but it seems to be working really well. It's a good idea and I agree that Ofelia has a rather steep learning curve for a beginner, which is a shame because it's actually really powerful and easy to use once you understand the logic.

One thing I would do to make the development process a bit more comfortable is to use the [ofelia] object to import external Lua scripts instead of hard coding the script in each Pd abstraction. I find it much easier to develop complex Ofelia projects this way.

Hi everyone,

I've seen a message on the list about a user who is not able to register to the forum:
https://lists.puredata.info/pipermail/pd-list/2019-11/126253.html

Can one of the admins have a look into it?

@AllesDings I think you could do something like this in Ofelia:

local img = ofImage()
img:grabScreen(0, 0 , ofGetWidth(), ofGetHeight())
img:save("screenshot.png")

This is great, thanks for sharing!

Ofelia is a wrapper for openFrameworks that embed most of its functions and classes as Pd objects or Lua scripts. If you learn the logic and the syntax you could in theory program everything you can do in openFrameworks by just using Pd objects.

The problem is that while Gem has been designed with the final Pd user in mind, Ofelia is just a set functions. This means that it's much more flexible and powerful than Gem (where sometimes you are stuck with the way it was designed), but also that Ofelia in general ends up being very confusing and distracting for a beginner.

The solution for that would be to write better documentation and develop a set of abstractions to get stuff done quickly (like texturing on a 3D primitive, see here). This would have several advantages over Gem:

• These abstractions could either be done with just Ofelia Pd objects or with Lua scripts. Lua scripts are actually a big thing, maybe the most important achievement of Ofelia. You are now basically able to write Pd «externals» using a high level scripting language that hides all the complexity to the user (memory management and stuff like that).

• The graphic framework that Ofelia is built on has a very active community compared to Gem. This means that it is updated more often, uses updated software solutions and has a nice forum where a lot of questions have already been answered.

• Once you learn how to use openFrameworks in Pd, you can move on and script your own objects, either in Pd with Lua or in openFrameworks itself.

TLDR; I believe that Ofelia is a very young project with many usability issues, but it has a lot of potential and might actually replace Gem if enough people will start using it.

I started with Pd Extended myself, it was very fun to play with but got too messy for me. Sharing patches with Vanilla users was too difficult, there were too many redundant libraries and, as you say, the release of Deken together with the 64bit compatibility issue made it obsolete.

I think that Pd Vanilla is becoming better and better but I miss a well designed repository with all the «add-ons» available today. Many other programming frameworks share the same problem: someone develop a library in his spare time then move on to something else and abandon the project with the library eventually becoming obsolete. There is no official guideline on libraries or documentation.

TBH I think this lack of a clear communication strategy is true for Pd in general. There are way too many isolated communities: mailing lists, irc channels, discord, international and local pd forums, generic and library-specific facebook groups, reddit threads. It would be great to see all this energy channelled into a collective effort instead of seeing people reinventing the wheel everytime (me included).

Ofelia seems to require explicitly addressing the individual vertices of a mesh

@ddw_music Actually it's quite easy to texture an image on 3D primitives with Ofelia, but I agree that doing the same by connecting [gem_head] →[pix_image]→[pix_texture] →[cube] is much more exciting and less distracting for students working on a multimedia project for the first time.

-- Define my cube with height, width, depth
local cube = ofBoxPrimitive()
cube:set(100, 100, 100)

-- Load an image
local image = ofImage()
image:load(“image.jpg”)

-- Bind texture to the cube
image:getTexture():bind()
cube:draw()
image:getTexture():unbind()

I was an avid Gem user and I'm switching to Ofelia because it’s more flexible. Gem is a great tool and is very well documented, which is perfect for students, but you have to stick to its objects and the way they are designed. If you want to do things in a different way you can either write your external (IMHO not easy at all) or find a way around it, if possible.

Ofelia requires dealing with undocumented and confusing stuff but once you get your hands dirty you can basically do everything you do in Gem with much more control and flexibility.

@ddw_music said:

Or is there another Lua syntax for arrays? Just wondering how this is handled.

Like you say the right way to define arrays in Lua is M.array={}, Pd will complain if you use that in an object, but will let you do it in the «script view» of an [ofelia -k define] object.

Another approach would be to use the Pd bindings, this way you define an array in Pd with a unique name (array-1) and you can read it directly in an [ofelia function] object.