visualize this! @visualizethis - Tumblr Blog

Daily DSP tip :-)

So, I played a bit with software synthesizers in the past and last week I took the project up for revision. Doing so, I came up with the following easy waveform generators:

Sine: double wave_sine(double x) { return sin(x); }

Square: double wave_square(double x) { return (abs(x)-floor(abs(x)))<0.5?-1.0:1.0; }

Saw tooth: double wave_saw(double x) { return (abs(x)-floor(abs(x))); }

Triangle: double wave_triangle(double x) { return abs(abs(x)-floor(abs(x)))*2.0-1.0); }

Having the basic generators, we move on to making them "easy" controlable by Hz rather than [0;1] or [0;] when it comes to sine. I use these generators in relation to sound - and most sound is generated at 44k1Hz, i.e. 44100 samples per second per channel. With this in mind, we get that each period should be transformed from/to [0;44100]. Let i be the current sample index in the stream; we'll observe that output[i]=wave_sine((Hz*/44100.0)*x) if we set Hz=440.0 we get a nice sine A-note. In addition, a square/saw/triangle A-note can be output[i]=wave_triangle((Hz/44100.0)*x).

I hope this is useful to some one else than me :-)

#c++#dsp #saw tooth #sine #square #triangle #waveform #wave generator #code

WINPROMPT is a very small tool that can be helpful when writing Windows batch scripts. It allows the batch script to query the user for input and present errors and information boxes to the user.

Read more about NetCheck

#netcheck #windows #network monitoring #tool #freeware

Easy Frame Buffer Object class

So, I've been fiddling a lot with frame buffer objects lately. And before you get to it - Yes, I know I'm several years behind :-)

For those of you who don't know what Frame Buffer Objects are - they are frame buffers stored in your video memory which can be used as any other texture in OpenGL. It replaces the insanely slow glCopyPixels which copy an area of the current context into conventional memory for processing.

Why is this cool? Well, let's say you want to do glow, motion blur, radial blur or some other post processing - you'll have to follow this recipe:

Draw scene

Copy scene for processing

Perform post-processing

Blit post-processing

Using glCopyPixels you'll have to transfer data from video memory to conventional memory in step 2 and vice versa in step 4.

With frame buffer objects the data transfer is happening internally in the video memory, i.e. step 2 transfers data from the render context into the frame buffer object and vice versa in step 4.

.... and here's the code:

class FBO { private: HANDLE render_texture_handle; unsigned int render_texture; unsigned int render_texture_x, render_texture_y; unsigned int render_fbo, render_rbo; public: unsigned int Texture() { return render_texture; } void Enable() { CViewport vp(render_texture_x, render_texture_y); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, render_fbo); } void Disable() { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); } FBO() { render_texture_x = COpenGL::WIDTH; render_texture_y = COpenGL::HEIGHT; // allocate texture glGenTextures(1, &render_texture); glBindTexture(GL_TEXTURE_2D, render_texture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, render_texture_x, render_texture_y, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // allocate framebuffer glGenFramebuffersEXT(1, &render_fbo); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, render_fbo); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, render_texture, 0); // bind framebuffer and renderbuffer glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, render_rbo); // check status GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { throw "FBO not ready"; } // clear texture Enable(); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); Disable(); } };

... and here is an example application in pseudo-c++:

void Render() { FragmentShader postproc; FBO fbo; Scene scene; while (true) { // turn fbo on fbo.Enable(); // render awesome scene scene.Render(); // disable fbo fbo.Disable(); // enable fragment shader for post processing postproc.Enable(); // bind the fbo texture handle glBindTexture2D(GL_TEXTURE_2D, fbo.Texture()); // draw quad that fills the whole screen glRecti(...); // disable fragment shader postproc.Disable(); } }

You can find my fragment shader class elsewhere on this blog

#c++#opengl #fbo #frame buffer objects #post processing #glow #motion blur #radial blur

½-page - second try :-)

So, here is my second try at using shaders in less than a half page of code. My first try used both SDL and GLEW which could be considered "cheating".

Second time around I use "raw" Win32 API and OpenGL to make everything work. Everything in 36 lines.

#include <windows.h> #include <gl/gl.h> #include <gl/glu.h> #include "glext.h" #include <string> #include <fstream> #include <iterator> #define F(x,y) ((x)wglGetProcAddress(y)) unsigned int CompileSrc(const char *src, GLenum dest) { unsigned int s = F(PFNGLCREATESHADERPROC,"glCreateShader")(dest); F(PFNGLSHADERSOURCEPROC,"glCreateShader")(s, 1, &src, NULL); F(PFNGLCOMPILESHADERPROC,"glCompileShader")(s); return s; } int main(int argc, char **argv) { static PIXELFORMATDESCRIPTOR pfd; pfd.dwFlags = PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER; pfd.cAlphaBits = 8; pfd.cColorBits = 24; HDC hDC = GetDC( CreateWindow("edit", 0, WS_POPUP|WS_VISIBLE, 0,0,1024,768,0,0,GetModuleHandle(NULL),0) ); SetPixelFormat(hDC, ChoosePixelFormat(hDC, &pfd), &pfd); wglMakeCurrent(hDC, wglCreateContext(hDC)); unsigned int sp = F(PFNGLCREATEPROGRAMPROC,"glCreateProgram")(); F(PFNGLATTACHSHADERPROC,"glAttachShader")(sp, CompileSrc(std::string((std::istreambuf_iterator<char>( std::ifstream("shader.fs") )), std::istreambuf_iterator<char>()).c_str(), GL_FRAGMENT_SHADER)); F(PFNGLATTACHSHADERPROC,"glAttachShader")(sp, CompileSrc(std::string((std::istreambuf_iterator<char>( std::ifstream("shader.vs") )), std::istreambuf_iterator<char>()).c_str(), GL_VERTEX_SHADER)); F(PFNGLLINKPROGRAMPROC,"glLinkProgram")(sp); F(PFNGLUSEPROGRAMPROC,"glUseProgram")(sp); while (!GetAsyncKeyState(VK_ESCAPE)) { glViewport(0,0,1024,768); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1,1,1,-1,0.1f, 100.0f); glRectf(-1,1,1,-1); SwapBuffers(hDC); } return 0;}

Shaders in ½ page?!

So, I read on a Danish webpage that it's not possbile to initialize and setup shaders in less than a ½ page of code. With this in mind I tried taking my engine code and cut off the bells and whistles - leaving nothing but raw code and no safety net.

What it does is:

Set up fullscreen 1024x768 in 32bpp

Load and compiles vertex shader from file

Load and compiles fragment shader from file

Links and attaches the shader program

Set up orthogonal projection

Render a fullscreen rectangle with the shader program

I brewed it down to a total of 30 lines. It's still readable and functional - though I haven't had the time to compile it yet. It uses glew, sdl, opengl and stl.

Here is the result:

#include <windows.h> #include <GL/glew.h> #include <GL/wglew.h> #include <gl/gl.h> #include <gl/glu.h> #include <sdl.h> #include <string> #include <ifstream> unsigned int CompileSrc(const char *src, GLenum dest) { unsigned int s = glCreateShader(dest); glShaderSource(s, 1, &src, NULL); glCompileShader(s); return s; } int main(int argc, char **argv) { SDL_Init(SDL_INIT_EVERYTHING); SDL_SetVideoMode( 1024, 768, 32, SDL_OPENGL | SDL_FULLSCREEN); glewInit(); unsigned int sp = glCreateProgram(); glAttachShader(sp, CompileSrc(std::string((std::istreambuf_iterator( std::ifstream("shader.fs") )), std::istreambuf_iterator()).c_str(), GL_FRAGMENT_SHADER)); glAttachShader(sp, CompileSrc(std::string((std::istreambuf_iterator( std::ifstream("shader.vs") )), std::istreambuf_iterator()).c_str(), GL_VERTEX_SHADER)); glLinkProgram(sp); glUseProgram(sp); while (true) { glViewport(0,0,1024,768); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1,1,1,-1,0.1f, 100.0f); glRectf(-1,1,1,-1); SDL_GL_SwapBuffers(); } return 0; }

#2011 #c++#shader setup

Ah, so. I'm back from the awesome Outline 2011 party held near Eindhoven, Holland. I released a PC Demo under the label Powerteam together with Booster, Farfar and Maytz.

The demo is fast paced and, hopefully, should be able to put the audience in a good mood.

You may download the demo and join the forum at Pouet.net

All the 2D graphics are made by Farfar (Mogens) and can be found in higher resolution at his website www.skjoldbroder.dk.The music is an old piece earlier releassed under the label Pitchworld.

As for the effects, well, they are all pretty simple and selfexplanatory but here goes anyways:

Strobo-rotator: rotating a set of circular lamps in doing simple additive blending

Env-rubber: simple 3d-object rotating using the good old "vector slime" principle making the object look gooey

Wtf-screen: random points are highlighted and focused on

Banging: 2d picture by farfar bouncing to music with zoom blur

Plasma: 2d plasma with bumpmapping made with fragment shaders

3d twister: poles made up of masking and blending texture of each pole and twisting them as we traverse the z-position

2d tunnel: tunnel made of primitive textures and zoom

Clouds: additive clouds fading to a nice landscape picture

2d bitmap effect: simple sin/cos/atan/sqrt 2d effect made with fragment shaders

Rotating cylinders: 3d cylinders mounted spherically and rotating

If you have any questions - feel free to ask me :-)

#outline 2011 #demo #code

Fish-eye rendering et al

So, I've taken some time off from work for the vinter holidays here in Denmark. These periods normally results in two things: 1) next to no computer interaction and 2) heaps of new ideas spring to mind.

I've been thinking of doing fish-eye and polar rendering for a while. And just the other day the most simple and straight forward technique came to mind.

Back in the old 2D-days I did a massive amount of tunnel and grid based effects. Imagine this: Render a 3D-scene to a texture and put use it as texture input for either the tunnel or the grid.

Doing polar rendering means that the world is rendered spherical from the center of the screen and not top-down. In a 2D-tunnel this equals to remove the depth/perspective division.

Rendering fish-eye effects can be rendered using grid effects where the grid warps the top-down rendered image to be at max zoom in the center and decrease by the distance to the center.

Making the output look good is an exercise to the reader: there are aleast two caveats regarding POV and seamless joints :-)

You may find fragment shader sources for 2D-tunnels and grid-renders at www.iquilezles.org/apps/shadertoy

Once I am happy with my implementation I'll drop some code for you guys to devour. Happy hacking!

#demo #ideas #effects

Part #5: Slow mover

In this post about my work place I'll look at the pace the organization is able to change direction with regards to processes etc.

Just looking at the size of the development organisation of 2.000 combined with the conservative image will paint crawling images of painfully slow development cycles.

When I first joined the company a raid of CMMI and a RUP-infested evangalists were crusading the corridors of the development department. It made managers and customers shiver and the development teams crawled deeper into the cowboy coding corners. I suspect this to be default behavior when management set sails for CMMI assessments - find the most thoroughly described development model and persuade everyone to follow it. The RUP-whale is hard for cowboy coders to adopt and is often sold as a cook book for project managers which in turn potentionally extends the project duration. In the beginning of last year a different crusade was set out - and agile became the new buzzword from top management. Nearly a year after and many pilot projects have been through it's life cycle generating happier customers and happier development teams. A happy developer and a happy customer makes a happy manager. Wheter the projects are conducted in shorter time or not isn't apparant - but I wouldn't care as long as everybody is happy. This post is part of a series about my work place. They are currently hiring IT-developers in the Copenhagen area. Just send me an e-mail if you are interested - no matter if you are Danish or not (hello jobless friends from Finland).

Links

Click here to see the other posts in the series

Click here to read what I'm actually doing at Danske Bank

#danske bank #work

How do you make a demo?

I've seen a multitude of tutorials on how to code actual demo effects; but I've never seen a clear article on the creative process that generates the demos. Here is one! In todays post I'd like to give you all a short insight in my creative process of making demos for competiting at parties. I suspect that my way isn't the ideal way, however it works for me and my busy schedule. Basicly the setup is as follows:

Code some basic effects

Find a mood that you'd like for the demo (angry, sad, happy, chill, etc)

Hook up with a musician that you think'll fit the mood

Listen to the music and imagine the flow of the demo

Build effects or visual sequences

Get input from graphicians

Re-iterate the code untill satisfied

Release demo

Profit

My busy schedule and my personality makes it preferable for me to work more or less solo. The majority of the creative process happens inside my head and is expressed via my fingers. Music and graphics could be ready made; as it is easier for me to create the overall visual flow and impression without having inputs from autonomous graphicians or musicians. Most of my releases are a result of this process. Working in teams is great, but only if you have the time. In a team I also find it important that one sole person takes the overall role as "master of creativity". This means that everyone is able to give input but one person should be responsible. I've only done few releases in teams; one of them was Weird in a strange way. In this production Maytz took the lead and hooked my code up with 3d, visuals from Farfar and Loft.

#demo #process

How to code a 4k intro

Coding a 4k intro is a matter of discipline and code magic. You have to be very good friends with the development environment you are working with and know it's inner details.

My work flow for coding a 4kb intro is either to go back to my source folder and just delete the effects and start over - or start from scratch using some of the ready made frameworks available on the net.

The best framework I've come across is the one made by spanish wonder boy Inigo Quilez aka iq of rgba. He has published frameworks for starting 4k and 1k coding in c/c++ using software rendering, opengl with/without shader and d3d9. You can safely download one of his framework and use as foundation without loosing any credits in among the tough guys in the scene. This will setup visual output and allow for easy coding of visuals.

Rendering music in a 4k is a huge effort. There are a multitude of stuff to take in consideration: precalculation of the music stream, sound quality, space consumption, etc. Coding your own synth is not a difficult task, since it's mostly about doing simple dsp operators and combining them for the end result. However, to get to the task quickly you could also go for one of the public synths like 4klang made by Dominik Ries and Paul Kraus aka Gopher and Powl of Alcatraz. 4klang is a modular synth with a VSTi plugin that can be used by your musician.

Having the audio and the visuals ready we should now look at compression suites. A 4k is normally a compressed version of an executeable of much larger size, sometimes up to 100 kb before compression. Aske Christensen and Rune Stubbe aka Blueberry of Loonies and Mentor of TBC has developed an executable compressing linker for Windows named Crinkler. Crinkler can be integrated with Visual Studio as part of the build process replacing the ordinary linker. This compressor has become the defacto standard for compressing 4kb intros since it's initial release in 2005.

I guess this is pretty much it. The rest is up to you - may the compiler be with you!

The screen shot is from a 4kb intro that I helped Martin Christensen aka Maytz of Loonies with back in 2007. It competed at the Assembly party held in Helsinki, Finland. I made the framework and the synth for Maytz to work his magic. The intro was named Clusterstorm and ranked 5th in the competition. See below for video links.

Links:

Clusterstorm by Loonies

IQ's framework

Crinkler

4klang

#4k

Part #4: Ancient development environment

The technology is old alas the surrounding tools must be just as old.

This is actually true.

We have heaps of tools that requires access via 3270 terminal software to the mainframe.

In addition, we also have a range of Windows based tools. As many of you know, the financial industry is sleeping tight with IBM when it comes to technology and tools. On the development tools this means that we are using Eclipse based tools both for modelling (UML) and developing (Cobol, PL/1, Java, etc).

#danske bank #work

Part #3: Everyone is old?

Working with mainframes every one is bound to be old, right? Well yes and no. During the life time of the IT department there has been quite a lot of expansion.

The official figures are currently 2.000 in the development department - and I'm pretty sure this has increased dramatically since 1980s. In my department the majority of developers are around the age of 30 (give and take 5 years). Management is a bit older.

This post is part of a series about my work place. They are currently hiring IT-developers in the Copenhagen area. Just send me an e-mail if you are interested.

#danske bank #working

Part #2: Conservative work environment

If you google the word "conservative" it'll give you a range of definitions such as "resistant to change", "avoiding excess", et. Which are all plausible when looking at the IT-department of a bank from the out side. Most applications are ran on mainframes and written in Cobol and PL/1. That's a technology which has had little change since it's birth in the late 70s (apart from hardware upgrades). And yes, sitting at my desk surrounded by applications written in PL/1 and Cobol running on mainframes accessing the central database - it can be seen as ancient technology. However, why fix something that ain't broken? Most code in my department is focused on business rules. There is little utility code involved. So why not write/maintain the code in a COmmon Business Oriented Language? Our front-ends are written in a variety of different programming languages such as C#, Java, Visual Basic and other new languages. And this is actually a problem. Each language doesn't exactly pose a problem. However, comparing to the mainframe environment the constant evolution of runtime environments on the desktop causes a great deal of head aches.

This post is part of a series about my work place. They are currently hiring IT-developers in the Copenhagen area. Just send me an e-mail if you are interested.

#danske bank #working

Part #1: Real life experiences

Working in the development department of the largest financial institution in Denmark has many facets. The strongest aspect is the social part and the informal atmosphere. Before joining the bank I had the default set of prejudices against the financial sector:

Conservative work place

Every one is old

Ancient development environment

Slow mover

Instead of just babling on, I will comment on each bullet elaborating the prejudice and give my current toughts after 4 years in company. Just to make clear, I am not doing any speaking on behalf of my company nor the department which I am assigned to. I will not reveal any company secrets or write about stuff that isn't publicly available elsewhere.

My work place is currently hiring IT-developers in the Copenhagen area. Just send me an e-mail if you are interested.

Follow my blog the next days and get the true facts.

#danske bank #working

Code snippet for loading textures

Yeah, well. Loading textures is something that has to be done and over the years I have used a variety of different image loading libraries like devIL, sdl_image, etc. They are all great but mostly require an extra external dll residing next to the compiled binary.

To remove the dependency on external dll's I've found a public domain image loader by Sean Barett. It loads jpg, png, bmp, tga and psds and consists of a single file that could be split into a .h and .c file.

Using the library for loading textures into OpenGL can be done very easily like this:

namespace ImageLoader { unsigned int Load(const char* imgfilename, const char* folder) { unsigned int id=0; glPushAttrib(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D); int width, height, components; char name[_MAX_PATH]; sprintf(name, "%s/%s", folder, imgfilename); unsigned char * data = stbi_load(name, &width, &height, &components, 4); if (data) { glGenTextures(1, &id); glBindTexture(GL_TEXTURE_2D, id); glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); } else { char buffer[8192]; sprintf(buffer, "Error loading '%s'\n", name); OutputDebugString(buffer); } stbi_image_free(data); glDisable(GL_TEXTURE_2D); glPopAttrib(); return id; } }

#c++#opengl #stbi #image loading #textures

Trending Blogs

Recently Viewed Blogs

visualize this!