Moving From Drupal to Hugo 08 Feb, 2016
My content management system of choice is Drupal. It has served me pretty well and allowed me to do a lot of things I probably could never have done without it. However, it has become such an attention seeker these days; with security issues, module upgrades, heavy comment spam and database blowouts seemingly weekly events. Also, upgrading to the newest version is never as smooth as promised. Thus, instead of upgrading my blog to Drupal 8, I have dumped it entirely and moved to a completely static site using Hugo.
Understanding WebGL 05 Jan, 2016
My biggest issue with WebGL, and actually all non-immediate-mode OpenGL, is constantly fighting with the requirements of vertex buffers and attributes. I seem to be always looking for ways to minimise and optimise memory whereas vertex buffer objects always seem to want me to waste large amounts of it with duplicate attributes. However, reconciling that requirement in my own mind has actually given me a bit of insight into potentially alternate uses for the WebGL render pipeline.
BIM and NatHERS Headaches 21 Nov, 2015
Given that my blog doesn't get updated much and there is no other obvious output, lots of people ask me what exactly I am working on at the moment and why it seems to be taking forever. Usually I just mutter the odd platitude, but today I thought I would combine a bit of a rant with an actual example of the kind of problems I am currently and seemingly constantly wrestling with. This one involves the ideal of determining NatHERS compliance directly from a fully integrated building information model (BIM).
Web Experiments 30 Sep, 2015
PerformativeDesign.com has gone into a short code-freeze for some external testing now so I have finally got a bit of time to catch my breath. As part of that work, I have had to do quite a few small experiments and proofs-of-concept, just as a way of seeing what was possible and then working out the best ways to do various things. Some of these were a bit interesting and often a lot of fun so I thought I'd polish up a few and make them available as a small taster of things to come, hopefully quite soon.
Earth/Sun Relationship Update 12 Jun, 2014
I've been doing a fair bit of low-level optimisation work on my solar calculations code recently and, whilst I have a reasonably extensive test suite for it, nothing beats being able to actually see things in action and interactively put them through their paces. Also, I've been wanting to update my old Earth/Sun Relationship app for a while now with some new ideas and graphics, so the synthesis seemed pretty logical. Thus, I just finished a brand new version with lots of new features as a way of both examining and visualising the relationships involved and letting me test and validate the core code.
Processing Libraries - Where are They? 26 May, 2014
As I've mentioned in previous posts, I have been working on a graphical user interface and 3D modelling library in Processing for some time now. I originally chose Processing because it was truly cross-platform and the only tool that also supported embedded web applets. I got to a reasonably advanced state in v1.5.1 and then, of course, everything changed. Processing 2 moved entirely to OpenGL and completely abandoned web applets.
Dynamic Charts in WPF 02 Aug, 2013
There are a plethora of WPF charting solutions out there, both commercial and open source. I have tried quite a few but have yet to find one that is capable of handling highly dynamic data whilst also providing useful customisations such as centered axis or generating polar diagrams. I do most of my dynamic charts in OpenGL but labelling axis and data points using textured fonts lacks some of the polish I have seen in many WPF-based solutions. Thus I thought that, for my Windows apps, I would try porting my OpenGL chart library to WPF.
The New Normal 07 Apr, 2013
My wife and I had a bouncing baby boy late last year and man, did he arrive like a shrieking banshee from hell. That was four months I hope never to experience again and, thanks to some serious and prolonged lack of REM sleep, I hope soon to forget. Like all new parents, you just dig in and pray for things to slowly get back to normal. However, with the passing of time comes the dawning realisation that this is the new normal. Even though I really liked my previous life, this post isn't a rant about that. It's about some of the things I've discovered about my new one.
Event Handling in Analysis Classes 22 Mar, 2013
As I have mentioned in a couple of other posts, I have been working on the API for a suite of building performance analysis classes, with a particular focus on dynamic visualisation and interactive manipulation. Part of this involves implementing an event notification system so that changes can propagate through even the most complex object hierarchies without the user having to worry about the internal plumbing. Unfortunately the standard approaches that I have found aren't particularly suitable here, so I have had to hack out something of my own.
Where's the Point in 3D APIs 28 Sep, 2012
Whilst working on an analysis library recently, I have been trying to reconcile how best to define positional and directional information. Most 3D frameworks and Application Programming Interfaces (API) use a single
Vector class (or similar) to define a generic object with X, Y and Z properties, which is then used interchangeably to describe both points in space and direction vectors. The closer I look, however, the more I think that it's important to clearly distinguish between the two and treat them as separate classes in an API in order to avoid inadvertent user mistakes. Unfortunately there is no single knock-out justification for either approach, so the following are some simple contemplations on the subject as I try to work out which way to go.
Designing for Sub-Classing in Java 23 Sep, 2012
One of the projects I have been working on over the last few months is a graphical user-interface (GUI) library for Processing. The Java API to the library makes extensive use of sub-classing and the intention is that it be easily sub-classed by the end user to allow for deep customisation of its functionality. Deep customisation means allowing for any property in any of its classes to be easily overridden. Sounds trivial as this is what object-oriented programming and Java is all about, but it actually leads to an interesting code-design dilemma.
Fast 3D Vector Text in Processing 07 Jan, 2012
Technical illustrations and 3D graphs tend to need lots of different kinds of text - some bold/italic, some large/small, and often in a range of different colors or shades of grey. Having struggled with image-based font glyphs in 3D for ages, I've kinda had enough - so set out to develop my own parametric vector text in Processing/OpenGL. This applet is a demo of some of the types of 3D text object I've been playing with as well as some experiments with annotation arrows.
Music Composition with Reason 01 Jan, 2012
I recently upgraded to Reason 6 and had a bit of time over Christmas for some remixing and further experiments. Okay, I know what you are thinking, but I do have history here as I used to have a great MIDI setup in the late 80s and early 90s when I was a student. I've had Reason 4 for a while, but never the time to properly finish anything before. They're not everyone's cup of tea, but if you are interested in a little electronic music...
Dynamically Dimensioning 3D Models 28 Dec, 2011
When interactively manipulating objects in 3D, having clear dimensions that update dynamically while dragging around allows for much greater confidence and accuracy in the process. This is especially true on a tablet where accurate alignment is well near impossible as your finger (and sometimes hand) effectively obscures the drag point. However, what started out as a quick experiment ended up sucking me into a 6 day vortex, swirling around with quaternion maths and 3D text manipulation in an attempt to get radial dimensions visible when viewed from any direction. This tiny applet is the result of those 6 days.
gluUnproject() for P3D and OPENGL Sketches 04 Dec, 2011
I have been struggling for a while in Processing with the reverse projection of 2D screen coordinates back into 3D world coordinates. It's relatively straightforward in OPENGL sketches using the JOGL view matrices and the GLU.gluUnproject() function. However, I could never get anything solid when using the P3D renderer or the PGraphics3D matrices. For some reason there was always a slight scaling issue which varied with different views. Previously I've used fudge factors to get it pretty close but, as I still prefer P3D for browser embedded work, I finally spent some time on it and made the breakthrough I needed. This is a brief description of what I learnt along the way as well as a demo applet and custom gluUnproject() function.