port from perforce

ifs4k/ifs4k.sln

@@ -0,0 +1,33 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ifs4k", "src\ifs4k\ifs4k.vcproj", "{213903DE-E40A-4D23-9310-E520AC2B412E}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Compress (Slow)|Win32 = Compress (Slow)|Win32
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{213903DE-E40A-4D23-9310-E520AC2B412E}.Compress (Slow)|Win32.ActiveCfg = Compress (Slow)|Win32
+		{213903DE-E40A-4D23-9310-E520AC2B412E}.Compress (Slow)|Win32.Build.0 = Compress (Slow)|Win32
+		{213903DE-E40A-4D23-9310-E520AC2B412E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{213903DE-E40A-4D23-9310-E520AC2B412E}.Debug|Win32.Build.0 = Debug|Win32
+		{213903DE-E40A-4D23-9310-E520AC2B412E}.Release|Win32.ActiveCfg = Release|Win32
+		{213903DE-E40A-4D23-9310-E520AC2B412E}.Release|Win32.Build.0 = Release|Win32
+		{E0A366EF-1805-44C7-B644-426FEE32B9D9}.Compress (Slow)|Win32.ActiveCfg = Debug|Win32
+		{E0A366EF-1805-44C7-B644-426FEE32B9D9}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E0A366EF-1805-44C7-B644-426FEE32B9D9}.Debug|Win32.Build.0 = Debug|Win32
+		{E0A366EF-1805-44C7-B644-426FEE32B9D9}.Release|Win32.ActiveCfg = Debug|Win32
+		{EAA2A155-BC7B-4DE4-98DA-4574A06F2772}.Compress (Slow)|Win32.ActiveCfg = Release|Win32
+		{EAA2A155-BC7B-4DE4-98DA-4574A06F2772}.Compress (Slow)|Win32.Build.0 = Release|Win32
+		{EAA2A155-BC7B-4DE4-98DA-4574A06F2772}.Debug|Win32.ActiveCfg = Debug|Win32
+		{EAA2A155-BC7B-4DE4-98DA-4574A06F2772}.Debug|Win32.Build.0 = Debug|Win32
+		{EAA2A155-BC7B-4DE4-98DA-4574A06F2772}.Release|Win32.ActiveCfg = Release|Win32
+		{EAA2A155-BC7B-4DE4-98DA-4574A06F2772}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

ifs4k/src/ifs4k/Shaders.cpp

@@ -0,0 +1,254 @@
+#include "Shaders.h"
+#ifdef _DEBUG
+
+PFNGLCREATESHADERPROC glCreateShader = NULL;
+PFNGLSHADERSOURCEPROC glShaderSource = NULL;
+PFNGLCOMPILESHADERPROC glCompileShader = NULL;
+PFNGLGETSHADERIVPROC glGetShaderiv = NULL;
+PFNGLGETPROGRAMIVPROC glGetProgramiv = NULL;
+PFNGLCREATEPROGRAMPROC glCreateProgram = NULL;
+PFNGLATTACHSHADERPROC glAttachShader = NULL;
+PFNGLLINKPROGRAMPROC glLinkProgram = NULL;
+PFNGLUSEPROGRAMPROC glUseProgram = NULL;
+PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = NULL;
+PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = NULL;
+
+
+void useProgram(GLhandleARB ah_Program)
+{
+	glUseProgram(ah_Program);
+}
+
+
+void initShaders()
+{
+	glCreateShader = (PFNGLCREATESHADERPROC)myGetProcAddress("glCreateShader");
+	glShaderSource = (PFNGLSHADERSOURCEPROC)myGetProcAddress("glShaderSource");
+	glCompileShader = (PFNGLCOMPILESHADERPROC)myGetProcAddress("glCompileShader");
+	glGetShaderiv =	(PFNGLGETSHADERIVPROC)myGetProcAddress("glGetShaderiv");
+	glGetProgramiv = (PFNGLGETPROGRAMIVPROC)myGetProcAddress("glGetProgramiv");
+	glCreateProgram = (PFNGLCREATEPROGRAMPROC)myGetProcAddress("glCreateProgram");
+	glAttachShader = (PFNGLATTACHSHADERPROC)myGetProcAddress("glAttachShader");
+	glLinkProgram = (PFNGLLINKPROGRAMPROC)myGetProcAddress("glLinkProgram");
+	glUseProgram = (PFNGLUSEPROGRAMPROC)myGetProcAddress("glUseProgram");
+	glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)myGetProcAddress("glGetShaderInfoLog");
+	glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)myGetProcAddress("glGetProgramInfoLog");
+	
+	if (!(glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && glGetProgramiv && glCreateProgram && glAttachShader && glLinkProgram && glUseProgram && glGetShaderInfoLog && glGetProgramInfoLog))
+	{
+		std::cerr <<  "Some shader functions are not available!" << std::endl;
+	}
+}
+
+
+void PrintErrors()
+{
+	GLenum lr_Error = GL_NO_ERROR;
+	int li_ErrorCount = 5;
+	do
+	{
+		lr_Error = glGetError();
+		if (lr_Error != GL_NO_ERROR)
+		{
+			li_ErrorCount--;
+			char* ls_ErrorString = (char*)gluErrorString(lr_Error);
+			if (ls_ErrorString != 0)
+				std::cout << "OPENGL :: ERROR " << ls_ErrorString << std::endl;
+		}
+		if (li_ErrorCount == 0)
+		{
+			std::cout << "OPENGL :: ERROR Too many errors!" << std::endl;
+			break;
+		}
+	} while (lr_Error != GL_NO_ERROR);
+}
+
+
+GLhandleARB createVertexShader(const char* as_FileName)
+{
+	GLhandleARB lh_Shader = 0;
+	
+	char* ls_ShaderSource = textFileRead(as_FileName);
+
+	if (ls_ShaderSource == NULL)
+	{
+		std::cerr << "Error reading file: " << as_FileName << std::endl;
+		return lh_Shader;
+	}
+
+	lh_Shader = glCreateShader(GL_VERTEX_SHADER);
+
+	glShaderSource(lh_Shader, 1, (const char**)&ls_ShaderSource, NULL);
+	glCompileShader(lh_Shader);
+
+	free(ls_ShaderSource);
+
+	int li_Status = 0;
+	glGetShaderiv(lh_Shader, GL_COMPILE_STATUS, &li_Status);
+
+	if (li_Status == GL_FALSE)
+	{
+		std::cerr << "Error compiling vertex shader: " << as_FileName << std::endl;
+		printShaderInfoLog(lh_Shader);
+	}
+
+	return lh_Shader;
+}
+
+
+GLhandleARB createFragmentShader(const char* as_FileName)
+{
+	GLhandleARB lh_Shader = 0;
+
+	char* ls_ShaderSource = textFileRead(as_FileName);
+	if (ls_ShaderSource == NULL)
+	{
+		std::cerr << "Error reading file: " << as_FileName << std::endl;
+		return lh_Shader;
+	}
+
+	lh_Shader = glCreateShader(GL_FRAGMENT_SHADER);
+
+	glShaderSource(lh_Shader, 1, (const char**)&ls_ShaderSource, NULL);
+	glCompileShader(lh_Shader);
+
+	int li_Status = 0;
+
+	glGetShaderiv(lh_Shader, GL_COMPILE_STATUS, &li_Status);
+
+	if (li_Status == GL_FALSE)
+	{
+		std::cerr << "Error compiling fragment shader: " << as_FileName << std::endl;
+		printShaderInfoLog(lh_Shader);
+	}
+
+	free(ls_ShaderSource);
+
+	return lh_Shader;
+}
+
+
+GLhandleARB createProgram(GLhandleARB ah_VertexShader, GLhandleARB ah_FragmentShader)
+{
+	GLhandleARB lh_Program = 0;
+	
+	if (ah_VertexShader + ah_FragmentShader <= 1)
+	{
+		std::cerr << "Cannot create program." << std::endl;
+		return lh_Program;
+	}
+
+	lh_Program = glCreateProgram();
+
+	glAttachShader(lh_Program, ah_VertexShader);
+	glAttachShader(lh_Program, ah_FragmentShader);
+	glLinkProgram(lh_Program);
+
+	int li_Status = 0;
+
+	glGetProgramiv(lh_Program, GL_LINK_STATUS, &li_Status);
+
+	if (li_Status == GL_FALSE)
+	{
+		std::cerr << "Error linking shaders." << std::endl;
+		printProgramInfoLog(lh_Program);
+	}
+
+	return lh_Program;
+}
+
+
+char* textFileRead(const char* as_FileName) 
+{
+	FILE* lh_File;
+	char* ls_Content = NULL;
+	size_t li_Count = 0;
+
+	if (as_FileName != NULL) 
+	{
+		fopen_s(&lh_File, as_FileName, "rt");
+
+		if (lh_File != NULL) 
+		{
+			fseek(lh_File, 0, SEEK_END);
+			li_Count = ftell(lh_File);
+			rewind(lh_File);
+
+			if (li_Count > 0) 
+			{
+				ls_Content = (char*) malloc(sizeof(char) * (li_Count + 1));
+				li_Count = fread(ls_Content, sizeof(char), li_Count, lh_File);
+				ls_Content[li_Count] = '\0';
+			}
+
+			fclose(lh_File);
+		}
+	}
+
+	return ls_Content;
+}
+
+
+void printShaderInfoLog(GLhandleARB ah_Shader)
+{
+	int li_InfologLength = 0;
+	int li_CharsWritten = 0;
+	char* li_InfoLog;
+
+	glGetShaderiv(ah_Shader, GL_INFO_LOG_LENGTH, &li_InfologLength);
+
+	if (li_InfologLength > 0)
+	{
+		li_InfoLog = (char*) malloc(li_InfologLength);
+
+		glGetShaderInfoLog(ah_Shader, li_InfologLength, &li_CharsWritten, li_InfoLog);
+
+		std::cerr << li_InfoLog << std::endl;
+		free(li_InfoLog);
+	}
+}
+
+
+void printProgramInfoLog(GLhandleARB ah_Program)
+{
+	int li_InfologLength = 0;
+	int li_CharsWritten = 0;
+	char* ls_InfoLog;
+
+	glGetProgramiv(ah_Program, GL_INFO_LOG_LENGTH, &li_InfologLength);
+
+	if (li_InfologLength > 0)
+	{
+		ls_InfoLog = (char *)malloc(li_InfologLength);
+
+		glGetProgramInfoLog(ah_Program, li_InfologLength, &li_CharsWritten, ls_InfoLog);
+
+		std::cerr << ls_InfoLog << std::endl;
+		free(ls_InfoLog);
+	}
+}
+
+
+bool printShaderStatistics()
+{
+	if (GL_VERSION_2_1) std::cout <<  "Supports OpenGL 2.1. " << std::endl;
+	else if (GL_VERSION_2_0) std::cout <<  "Supports OpenGL 2.0. " << std::endl;
+	else if (GL_VERSION_1_5) std::cout <<  "Supports OpenGL 1.5. " << std::endl;
+	else if (GL_VERSION_1_4) std::cout <<  "Supports OpenGL 1.4. " << std::endl;
+	else if (GL_VERSION_1_3) std::cout <<  "Supports OpenGL 1.3. " << std::endl;
+	else if (GL_VERSION_1_2) std::cout <<  "Supports OpenGL 1.2. " << std::endl;
+	else if (GL_VERSION_1_1) std::cout <<  "Supports OpenGL 1.1. " << std::endl;
+
+	if (GL_ARB_shader_objects && GL_ARB_vertex_shader && GL_ARB_fragment_shader)
+	{
+		std::cout << "Status: Using GLSL " << glGetString(GL_SHADING_LANGUAGE_VERSION_ARB) << std::endl;
+	}
+	else
+	{
+		std::cerr <<  "No GLSL support!" << std::endl;
+		return false;
+	}
+
+	return true;
+}
+#endif

ifs4k/src/ifs4k/Shaders.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <windows.h>
+#include <iostream>
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include "glext.h"
+#define myGetProcAddress(name) wglGetProcAddress((LPCSTR)name)
+
+void initShaders();
+GLhandleARB createVertexShader(const char* as_FileName);
+GLhandleARB createFragmentShader(const char* as_FileName);
+GLhandleARB createProgram(GLhandleARB ah_VertexShader, GLhandleARB ah_FragmentShader);
+void PrintErrors();
+void useProgram(GLhandleARB ah_Program);
+char* textFileRead(const char* as_FileName);
+void printShaderInfoLog(GLhandleARB ah_Shader);
+void printProgramInfoLog(GLhandleARB ah_Program);
+bool printShaderStatistics();

ifs4k/src/ifs4k/debug.cpp

@@ -0,0 +1,228 @@
+#ifdef _DEBUG
+#include <time.h>
+#include <io.h>
+#include <process.h>
+#include "Shaders.h"
+#include "small.h"
+#include "synth.h"
+#include "glext.h"
+
+static const int gi_ScreenWidth = 640;
+static const int gi_ScreenHeight = 480;
+static const float gf_AspectRatio = 1.33f;
+//static const float gf_AspectRatio = 1.3281250000f; // smaller version for 4:3
+//static const float gf_AspectRatio = 1.7734375000f; // smaller version for 16:9
+//static const float gf_AspectRatio = 1.25f; // smaller version for 5:4
+//static const float gf_AspectRatio = 1.6015625000f; // smaller version for 16:10
+
+HANDLE gh_ShaderCompileEvent;
+static char** gs_LastShader_;
+static unsigned int gi_ShaderProgram;
+static unsigned int gi_LastShaderProgram;
+#pragma data_seg(".debuginfo")
+struct r_ShaderPack
+{
+	char* ms_VertexShader;
+	char* ms_FragmentShader;
+	GLhandleARB mh_Handle;
+	__time64_t mi_FsShaderChangedDate;
+	__time64_t mi_VsShaderChangedDate;
+};
+
+static r_ShaderPack gr_Shaders_[] = 
+{
+	{"transform.vs", "transform.fs", 0},
+	{"output.vs", "output.fs", 0},
+	{"pp.vs", "pp.fs", 0},
+	{0}
+};
+
+static const PIXELFORMATDESCRIPTOR pfd={
+	0, 1, PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, 32, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 8
+};
+
+static DEVMODE dmScreenSettings={
+	"",0,0,sizeof(dmScreenSettings),0,DM_PELSWIDTH|DM_PELSHEIGHT,
+	0,0,0,0,0,0,0,0,0,0,0,0,0,"",0,0,gi_ScreenWidth,gi_ScreenHeight
+};
+
+DWORD WINAPI filemon(void* args)
+{
+	while (true)
+	{
+		r_ShaderPack* lr_ShaderPtr_ = gr_Shaders_;
+		while (lr_ShaderPtr_->ms_VertexShader != 0)
+		{
+			_finddata_t fdata;
+			long hfile = _findfirst(lr_ShaderPtr_->ms_FragmentShader, &fdata);
+			if (hfile != -1)
+			{
+				if (fdata.time_write != lr_ShaderPtr_->mi_FsShaderChangedDate)
+				{
+					lr_ShaderPtr_->mi_FsShaderChangedDate = fdata.time_write;
+					::SetEvent(gh_ShaderCompileEvent);
+					::SwitchToThread();
+					break;
+				}
+				_findclose(hfile);
+			}
+
+			hfile = _findfirst(lr_ShaderPtr_->ms_VertexShader, &fdata);
+			if (hfile != -1)
+			{
+				if (fdata.time_write != lr_ShaderPtr_->mi_VsShaderChangedDate)
+				{
+					lr_ShaderPtr_->mi_VsShaderChangedDate = fdata.time_write;
+					::SetEvent(gh_ShaderCompileEvent);
+					::SwitchToThread();
+					break;
+				}
+				_findclose(hfile);
+			}
+			++lr_ShaderPtr_;
+		}
+		::Sleep(100);
+	}
+	return 0;
+}
+
+#define NUMBER_OF_POINTS 320
+
+void _cdecl main()
+{
+	//ChangeDisplaySettings (&dmScreenSettings,CDS_FULLSCREEN); 
+	//HDC hDC = GetDC(CreateWindow("edit", 0, WS_POPUP | WS_VISIBLE | WS_MAXIMIZE, 0, 0, 0, 0, 0, 0, 0, 0));
+	HDC hDC = GetDC(CreateWindow("static", "Test", WS_EX_APPWINDOW | WS_VISIBLE | WS_SYSMENU, 0, 0, gi_ScreenWidth, gi_ScreenHeight, 0, 0, 0, 0));
+	SetPixelFormat(hDC, ChoosePixelFormat(hDC, &pfd), &pfd);
+	wglMakeCurrent(hDC, wglCreateContext(hDC));
+	initShaders();
+	gh_ShaderCompileEvent = ::CreateEvent(NULL, FALSE, FALSE, TEXT("WriteEvent")); 
+	SetThreadPriority((HANDLE)CreateThread(0, 0, &filemon, 0, 0, 0), THREAD_PRIORITY_BELOW_NORMAL);
+
+	unsigned int textures;
+	glGenTextures(3, &textures);
+
+	glBindTexture(GL_TEXTURE_2D, textures);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, NUMBER_OF_POINTS, NUMBER_OF_POINTS, 0, GL_RGBA, GL_FLOAT, NULL);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+	glBindTexture(GL_TEXTURE_2D, textures+1);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, gi_ScreenWidth, gi_ScreenHeight, 0, GL_RGBA, GL_FLOAT, NULL);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+	glBindTexture(GL_TEXTURE_2D, textures+2);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, gi_ScreenWidth, gi_ScreenHeight, 0, GL_RGBA, GL_FLOAT, NULL);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+	unsigned int list = glGenLists(1);
+	glNewList(list, GL_COMPILE);
+	glPointSize(2);
+	glBegin(GL_POINTS);
+	for (float y = 0; y < 1; y += 1.0f/NUMBER_OF_POINTS)
+	{
+		for (float x = 0; x < 1; x += 1.0f/NUMBER_OF_POINTS)
+		{
+			glVertex2f(x, y);
+		}
+	}
+	glEnd();
+	glEndList();
+
+	unsigned int fbos;
+	((PFNGLGENFRAMEBUFFERSEXTPROC)wglGetProcAddress("glGenFramebuffersEXT"))(3, &fbos);
+	((PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT"))(GL_FRAMEBUFFER_EXT, fbos);
+	((PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)wglGetProcAddress("glFramebufferTexture2DEXT"))(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textures, 0);
+	((PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT"))(GL_FRAMEBUFFER_EXT, fbos+1);
+	((PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)wglGetProcAddress("glFramebufferTexture2DEXT"))(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textures+1, 0);
+	((PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT"))(GL_FRAMEBUFFER_EXT, fbos+2);
+	((PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)wglGetProcAddress("glFramebufferTexture2DEXT"))(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textures+2, 0);
+
+	InitSound();
+loop:
+	
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	if (::WaitForSingleObject(gh_ShaderCompileEvent, 0) == WAIT_OBJECT_0)
+	{
+		::Sleep(250);
+		r_ShaderPack* lr_ShaderPtr_ = gr_Shaders_;
+		while (lr_ShaderPtr_->ms_VertexShader != 0)
+		{
+			std::cout << "Compiling: " << lr_ShaderPtr_->ms_VertexShader << " and " << lr_ShaderPtr_->ms_FragmentShader << std::endl;
+			lr_ShaderPtr_->mh_Handle = createProgram(createVertexShader(lr_ShaderPtr_->ms_VertexShader), createFragmentShader(lr_ShaderPtr_->ms_FragmentShader));
+			++lr_ShaderPtr_;
+		}
+
+		PrintErrors();
+	}
+
+	MSG lr_Message;
+	if (PeekMessage(&lr_Message, NULL, 0, 0, PM_REMOVE))	
+	{
+		TranslateMessage(&lr_Message);				
+		DispatchMessage(&lr_Message);
+	}
+
+	float lf_Time = get_Time() * 20;
+	
+	((PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT"))(GL_FRAMEBUFFER_EXT, fbos);
+	((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(gr_Shaders_[0].mh_Handle);
+	glViewport(0, 0, NUMBER_OF_POINTS, NUMBER_OF_POINTS);
+	glColor3f(0, lf_Time, 0);
+	glRects(-1, -1, 1, 1);
+	
+	((PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT"))(GL_FRAMEBUFFER_EXT, fbos+1);
+	((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(gr_Shaders_[1].mh_Handle);
+	glViewport(0, 0, gi_ScreenWidth, gi_ScreenHeight);
+
+	glClear(GL_COLOR_BUFFER_BIT);
+	glBindTexture(GL_TEXTURE_2D, textures);
+
+	glEnable(GL_BLEND);
+	glLoadIdentity();
+	glRotatef(lf_Time * 3, 0.0, 1.0, 0.0);
+	glRotatef(lf_Time / 3, 1.0, 0.0, 0.0);
+	glCallList(list);
+	glLoadIdentity();
+	glDisable(GL_BLEND);
+
+	((PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT"))(GL_FRAMEBUFFER_EXT, fbos+2);
+	((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(gr_Shaders_[2].mh_Handle);
+	glBindTexture(GL_TEXTURE_2D, textures+1);
+
+	for (int i = 0; i < 4; ++i)
+	{
+		glRects(-1, -1, 1, 1);
+		glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, gi_ScreenWidth, gi_ScreenHeight);
+	}
+
+	((PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT"))(GL_FRAMEBUFFER_EXT, 0);
+	glBindTexture(GL_TEXTURE_2D, textures+2);
+	
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glColor4f(0,0,0,0.5f);
+	((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(0);
+	glRects(-1, -1, 1, 1);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+	((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(gr_Shaders_[2].mh_Handle);
+	glRects(-1, -1, 1, 1);
+	glDisable(GL_BLEND);
+
+	SwapBuffers(hDC);
+	if (!GetAsyncKeyState(VK_ESCAPE)) goto loop;	
+	ExitProcess(0);
+}
+#endif

ifs4k/src/ifs4k/ifs4k.vcproj

@@ -0,0 +1,359 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9,00"
+	Name="ifs4k"
+	ProjectGUID="{213903DE-E40A-4D23-9310-E520AC2B412E}"
+	RootNamespace="ifs4k"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)bin"
+			IntermediateDirectory="$(SolutionDir)obj\$(ProjectName)_$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="0"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+				CallingConvention="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="opengl32.lib winmm.lib glu32.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_$(ConfigurationName).exe"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="&quot;$(ProjectDir)&quot;"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				EntryPointSymbol="main"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)bin"
+			IntermediateDirectory="$(SolutionDir)obj\$(ProjectName)_$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="0"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+				CommandLine=""
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="1"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="2"
+				WholeProgramOptimization="false"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS"
+				ExceptionHandling="0"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="false"
+				RuntimeTypeInfo="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="0"
+				DebugInformationFormat="3"
+				CallingConvention="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/CRINKLER"
+				AdditionalDependencies="opengl32.lib winmm.lib libcmt.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_$(ConfigurationName).exe"
+				AdditionalLibraryDirectories="&quot;$(ProjectDir)&quot;"
+				GenerateManifest="false"
+				ManifestFile=""
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				LinkTimeCodeGeneration="0"
+				EntryPointSymbol="main"
+				RandomizedBaseAddress="0"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+				ErrorReporting="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Compress (Slow)|Win32"
+			OutputDirectory="$(SolutionDir)bin"
+			IntermediateDirectory="$(SolutionDir)obj\$(ProjectName)_$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="0"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+				CommandLine=""
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/QIfist"
+				Optimization="1"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="2"
+				WholeProgramOptimization="false"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS"
+				ExceptionHandling="0"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="false"
+				EnableFunctionLevelLinking="false"
+				FloatingPointModel="2"
+				RuntimeTypeInfo="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="0"
+				DebugInformationFormat="0"
+				CallingConvention="2"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/CRINKLER /COMPMODE:SLOW /ORDERTRIES:4000 /HASHSIZE:200 /HASHTRIES:100 /UNSAFEIMPORT /TRUNCATEFLOATS:24 /REPORT:report.html /RANGE:opengl32 /PROGRESSGUI /TRANSFORM:CALLS"
+				AdditionalDependencies="opengl32.lib winmm.lib"
+				OutputFile="$(OutDir)\$(ProjectName)_$(ConfigurationName).exe"
+				AdditionalLibraryDirectories="&quot;$(ProjectDir)&quot;"
+				GenerateManifest="false"
+				ManifestFile=""
+				GenerateDebugInformation="false"
+				SubSystem="2"
+				LinkTimeCodeGeneration="0"
+				EntryPointSymbol="main"
+				RandomizedBaseAddress="0"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+				ErrorReporting="0"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\debug.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\release.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\Shaders.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\synth.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\glext.h"
+				>
+			</File>
+			<File
+				RelativePath=".\Shaders.h"
+				>
+			</File>
+			<File
+				RelativePath=".\small.h"
+				>
+			</File>
+			<File
+				RelativePath=".\synth.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+		<File
+			RelativePath=".\4klang.obj"
+			>
+		</File>
+		<File
+			RelativePath=".\output.fs"
+			>
+		</File>
+		<File
+			RelativePath=".\output.vs"
+			>
+		</File>
+		<File
+			RelativePath=".\pp.fs"
+			>
+		</File>
+		<File
+			RelativePath=".\pp.vs"
+			>
+		</File>
+		<File
+			RelativePath=".\transform.fs"
+			>
+		</File>
+		<File
+			RelativePath=".\transform.vs"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

ifs4k/src/ifs4k/ifs4k.vcproj.FIARA.Frank.user

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioUserFile
+	ProjectType="Visual C++"
+	Version="9,00"
+	ShowAllFiles="false"
+	>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			>
+			<DebugSettings
+				Command="$(TargetPath)"
+				WorkingDirectory=""
+				CommandArguments=""
+				Attach="false"
+				DebuggerType="3"
+				Remote="1"
+				RemoteMachine="SHAIKUR"
+				RemoteCommand=""
+				HttpUrl=""
+				PDBPath=""
+				SQLDebugging=""
+				Environment=""
+				EnvironmentMerge="true"
+				DebuggerFlavor=""
+				MPIRunCommand=""
+				MPIRunArguments=""
+				MPIRunWorkingDirectory=""
+				ApplicationCommand=""
+				ApplicationArguments=""
+				ShimCommand=""
+				MPIAcceptMode=""
+				MPIAcceptFilter=""
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			>
+			<DebugSettings
+				Command="$(TargetPath)"
+				WorkingDirectory=""
+				CommandArguments=""
+				Attach="false"
+				DebuggerType="3"
+				Remote="1"
+				RemoteMachine="SHAIKUR"
+				RemoteCommand=""
+				HttpUrl=""
+				PDBPath=""
+				SQLDebugging=""
+				Environment=""
+				EnvironmentMerge="true"
+				DebuggerFlavor=""
+				MPIRunCommand=""
+				MPIRunArguments=""
+				MPIRunWorkingDirectory=""
+				ApplicationCommand=""
+				ApplicationArguments=""
+				ShimCommand=""
+				MPIAcceptMode=""
+				MPIAcceptFilter=""
+			/>
+		</Configuration>
+		<Configuration
+			Name="Compress (Slow)|Win32"
+			>
+			<DebugSettings
+				Command="$(TargetPath)"
+				WorkingDirectory=""
+				CommandArguments=""
+				Attach="false"
+				DebuggerType="3"
+				Remote="1"
+				RemoteMachine="SHAIKUR"
+				RemoteCommand=""
+				HttpUrl=""
+				PDBPath=""
+				SQLDebugging=""
+				Environment=""
+				EnvironmentMerge="true"
+				DebuggerFlavor=""
+				MPIRunCommand=""
+				MPIRunArguments=""
+				MPIRunWorkingDirectory=""
+				ApplicationCommand=""
+				ApplicationArguments=""
+				ShimCommand=""
+				MPIAcceptMode=""
+				MPIAcceptFilter=""
+			/>
+		</Configuration>
+	</Configurations>
+</VisualStudioUserFile>

ifs4k/src/ifs4k/ifs4k.vcproj.Shaikur.Frank.user

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioUserFile
+	ProjectType="Visual C++"
+	Version="9,00"
+	ShowAllFiles="true"
+	>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			>
+			<DebugSettings
+				Command="$(TargetPath)"
+				WorkingDirectory=""
+				CommandArguments=""
+				Attach="false"
+				DebuggerType="3"
+				Remote="1"
+				RemoteMachine="SHAIKUR"
+				RemoteCommand=""
+				HttpUrl=""
+				PDBPath=""
+				SQLDebugging=""
+				Environment=""
+				EnvironmentMerge="true"
+				DebuggerFlavor=""
+				MPIRunCommand=""
+				MPIRunArguments=""
+				MPIRunWorkingDirectory=""
+				ApplicationCommand=""
+				ApplicationArguments=""
+				ShimCommand=""
+				MPIAcceptMode=""
+				MPIAcceptFilter=""
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			>
+			<DebugSettings
+				Command="$(TargetPath)"
+				WorkingDirectory=""
+				CommandArguments=""
+				Attach="false"
+				DebuggerType="3"
+				Remote="1"
+				RemoteMachine="SHAIKUR"
+				RemoteCommand=""
+				HttpUrl=""
+				PDBPath=""
+				SQLDebugging=""
+				Environment=""
+				EnvironmentMerge="true"
+				DebuggerFlavor=""
+				MPIRunCommand=""
+				MPIRunArguments=""
+				MPIRunWorkingDirectory=""
+				ApplicationCommand=""
+				ApplicationArguments=""
+				ShimCommand=""
+				MPIAcceptMode=""
+				MPIAcceptFilter=""
+			/>
+		</Configuration>
+		<Configuration
+			Name="Compress (Slow)|Win32"
+			>
+			<DebugSettings
+				Command="$(TargetPath)"
+				WorkingDirectory=""
+				CommandArguments=""
+				Attach="false"
+				DebuggerType="3"
+				Remote="1"
+				RemoteMachine="SHAIKUR"
+				RemoteCommand=""
+				HttpUrl=""
+				PDBPath=""
+				SQLDebugging=""
+				Environment=""
+				EnvironmentMerge="true"
+				DebuggerFlavor=""
+				MPIRunCommand=""
+				MPIRunArguments=""
+				MPIRunWorkingDirectory=""
+				ApplicationCommand=""
+				ApplicationArguments=""
+				ShimCommand=""
+				MPIAcceptMode=""
+				MPIAcceptFilter=""
+			/>
+		</Configuration>
+	</Configurations>
+</VisualStudioUserFile>

ifs4k/src/ifs4k/output.fs

@@ -0,0 +1,5 @@
+varying vec4 color;
+void main()
+{
+	gl_FragColor = color;
+}

ifs4k/src/ifs4k/output.vs

@@ -0,0 +1,13 @@
+uniform sampler2D texture;
+varying vec4 color;
+
+void main()
+{	
+	vec4 position = tex2D(texture, gl_Vertex.xy);
+	color = vec4(
+	0.5 + 0.75*sin(0.6 + position.w),
+	0.5 + 0.75*sin(0.3 + position.w),
+	0.5 + 0.75*sin(0.0 + position.w),
+	1.0);
+	gl_Position = gl_ModelViewMatrix * vec4(position.xyz * 2 - 1, 1.0);
+}

ifs4k/src/ifs4k/pp.fs

@@ -0,0 +1,14 @@
+uniform sampler2D texture;
+varying vec2 pos;
+void main()
+{	
+	vec3 color = vec3(0);
+	float weight = 0;
+	for (float i = 0; i < 6.3; i += 0.6)
+	{
+		color += tex2D(texture, pos + 0.002*vec2(sin(i), cos(i)));
+		++weight;
+	}
+	color /= weight;
+	gl_FragColor = vec4(color, 1.0);
+}

ifs4k/src/ifs4k/pp.vs

@@ -0,0 +1,6 @@
+varying vec2 pos;
+void main()
+{	
+	pos = gl_Vertex.xy*0.5+0.5;
+	gl_Position = gl_Vertex;
+}

ifs4k/src/ifs4k/release.cpp

@@ -0,0 +1,79 @@
+#ifndef _DEBUG
+#define WIN32_LEAN_AND_MEAN
+#define WIN32_EXTRA_LEAN
+#include <windows.h>
+#include <stdio.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include "glext.h"
+#include "small.h"
+#include "synth.h"
+#include "release.h"
+
+#pragma data_seg(".vertexshader")
+static char* vsh = "varying vec4 Y;varying vec2 Z;void main(){Y=gl_Color;Z=(gl_Vertex.xy*vec2(Y.w,1))*.5+.5;gl_Position=gl_Vertex;}";
+
+#pragma data_seg(".resolutionX")
+static const int gi_ScreenWidth = 640;
+
+#pragma data_seg(".resolutionY")
+static const int gi_ScreenHeight = 480;
+
+#pragma data_seg(".aspectratio")
+static const float gf_AspectRatio = 1.3281250000f; // smaller version for 4:3
+//static const float gf_AspectRatio = 1.7734375000f; // smaller version for 16:9
+//static const float gf_AspectRatio = 1.25f; // smaller version for 5:4
+//static const float gf_AspectRatio = 1.6015625000f; // smaller version for 16:10
+
+#pragma data_seg(".pfd")
+static const PIXELFORMATDESCRIPTOR pfd={
+	0, 1, PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, 32, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 8
+};
+
+#pragma data_seg(".dms")
+static DEVMODE dmScreenSettings={
+	"",0,0,sizeof(dmScreenSettings),0,DM_PELSWIDTH|DM_PELSHEIGHT,
+	0,0,0,0,0,0,0,0,0,0,0,0,0,"",0,0,gi_ScreenWidth,gi_ScreenHeight
+};
+
+#pragma code_seg(".compile")
+__forceinline unsigned int compileShader(const char* vsh, const char* fsh)
+{
+	GLuint s,p;
+	p = ((PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram"))();
+	s = ((PFNGLCREATESHADERPROC)(wglGetProcAddress("glCreateShader")))(GL_VERTEX_SHADER);
+	((PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource")) (s, 1, &vsh, NULL);
+	((PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader"))(s);
+	((PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader")) (p,s);
+	s = ((PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader"))(GL_FRAGMENT_SHADER);	
+	((PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource")) (s, 1, &fsh, NULL);
+	((PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader"))(s);
+	((PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader")) (p,s);
+	((PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram"))(p);
+	((PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"))(p);
+	return p;
+}
+
+
+void _cdecl main()
+{
+	ChangeDisplaySettings (&dmScreenSettings,CDS_FULLSCREEN); 
+	HDC hDC = GetDC(CreateWindow("edit", 0, WS_POPUP | WS_VISIBLE | WS_MAXIMIZE, 0, 0, 0, 0, 0, 0, 0, 0));
+	//HDC hDC = GetDC(CreateWindow("static", "Test", WS_EX_APPWINDOW | WS_VISIBLE | WS_SYSMENU, 0, 0, gi_ScreenWidth, gi_ScreenHeight, 0, 0, 0, 0));
+	SetPixelFormat(hDC, ChoosePixelFormat(hDC, &pfd), &pfd);
+	wglMakeCurrent(hDC, wglCreateContext(hDC));
+	compileShader(vsh, fsh);
+
+	InitSound();
+loop:
+	ShowCursor(FALSE);
+
+	float lf_Time = get_Time() * 71.0f / 240.0f;
+	glColor4f(get_Envelope(7), lf_Time, get_Envelope(2), gf_AspectRatio);
+	glRects(-1, -1, 1, 1);
+	SwapBuffers(hDC);
+	if (!GetAsyncKeyState(VK_ESCAPE) && lf_Time < 30.0f) goto loop;	
+	ExitProcess(0);
+}
+#endif

ifs4k/src/ifs4k/small.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#pragma code_seg("sm0")
+
+DWORD x_Ftol(float af_Value)
+{
+	DWORD ldw_RetVal;
+	__asm fld af_Value
+	__asm fistp ldw_RetVal
+	return ldw_RetVal;
+}
+
+#pragma code_seg("sm1")
+
+__forceinline float x_Frac(float af_Value)
+{
+	return af_Value - x_Ftol(af_Value);
+}
+
+#pragma code_seg("sm2")
+
+__forceinline float x_Abs(float af_Value)
+{
+	__asm fld	af_Value
+	__asm fabs
+}
+
+#pragma code_seg("sm3")
+
+float x_Sin(float af_Value)
+{
+	__asm fld	af_Value
+	__asm fsin
+}
+
+#pragma code_seg("sm4")
+
+float x_Sign(float af_Value)
+{
+	if (af_Value != 0)
+		return af_Value / x_Abs(af_Value);
+
+	return 1.0f;
+}
+
+#pragma code_seg("sm5")
+
+float x_Sqrt(float af_Value)
+{
+	__asm fld af_Value
+	__asm fsqrt
+}
+
+#pragma code_seg("sm7")
+
+__forceinline void x_MemCopy(void* av_Dest_, const void* av_Src_, size_t ai_Size)
+{
+	__asm mov esi, av_Src_
+	__asm mov edi, av_Dest_
+	__asm mov ecx, ai_Size
+	__asm rep movsb
+}
+
+#pragma code_seg("sm8")
+
+float x_Fmod(float x, float y)
+{
+	__asm fld	y
+	__asm fld	x
+	__asm fprem
+	__asm fxch
+	__asm fstp	x
+}
+
+#pragma data_seg("smA")
+
+static unsigned long seed=0x12345678;
+
+#pragma code_seg("sm9")
+
+__forceinline void x_Randomize(unsigned long x)
+{
+	seed = x;
+}
+
+#pragma code_seg("smB")
+
+float x_Rand()
+{
+	seed = seed * 0x76364873 + 1234567;
+	return (float)(seed & 0x7FFFFFFF) * (const float)(2.0f / (float)0x7FFFFFFF) - 1.0f;
+}
+
+#pragma code_seg("smS")
+
+__forceinline size_t x_Strlen(const char* as_String)
+{
+	size_t li_Length = 0;
+	while (*as_String++) ++li_Length;
+	return li_Length;
+}
+
+#pragma code_seg("smP")
+
+float x_Pow(float x, float y){
+	float r;
+	__asm{
+		fld y
+		fld x
+		fyl2x
+		fld1
+		fld st(1)
+		fprem
+		f2xm1
+		faddp st(1),st
+		fscale
+		fxch st(1)
+		fstp st(0)
+		fstp r
+	}
+	return r;
+}
+
+extern "C" 
+{
+	int _fltused = 1;
+}

ifs4k/src/ifs4k/synth.cpp

@@ -0,0 +1,99 @@
+#define WIN32_LEAN_AND_MEAN
+#define WIN32_EXTRA_LEAN
+#include "windows.h"
+#include "mmsystem.h"
+#include "mmreg.h"
+
+// define this if you have a multicore cpu and can spare ~15 bytes for realtime playback
+// undef for sound precalc
+#define USE_SOUND_THREAD
+
+////////////////////////////////////////////////
+// sound
+////////////////////////////////////////////////
+#define SAMPLE_RATE 44100
+#define MAX_SAMPLES	SAMPLE_RATE*2*60*4
+
+#pragma bss_seg(".synthnothing")
+static float		lpSoundBuffer[MAX_SAMPLES];
+static HWAVEOUT	hWaveOut;
+
+/////////////////////////////////////////////////////////////////////////////////
+// initialized data
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma data_seg(".wavefmt")
+WAVEFORMATEX WaveFMT =
+{
+	WAVE_FORMAT_IEEE_FLOAT,
+	2, // channels
+	SAMPLE_RATE, // samples per sec
+	SAMPLE_RATE*4*2, // bytes per sec
+	8, // block alignment;
+	32, // bits per sample
+	0 // extension not needed
+};
+
+#pragma data_seg(".wavehdr")
+WAVEHDR WaveHDR = 
+{
+	(LPSTR)lpSoundBuffer, 
+	MAX_SAMPLES*4, 
+	0, 
+	0, 
+	0, 
+	0, 
+	0, 
+	0
+};
+
+#pragma data_seg(".mmtime")
+MMTIME MMTime = 
+{ 
+	TIME_SAMPLES,
+	0
+};
+
+// declaration of the external synth render function, you'll always need that
+extern "C" void	_4klang_render(float*);
+// declaration of the external envelope buffer. only include if you're song was exported with that option
+extern "C" float _4klang_envelope_buffer;
+
+/////////////////////////////////////////////////////////////////////////////////
+// Initialization
+/////////////////////////////////////////////////////////////////////////////////
+
+#ifdef USE_SOUND_THREAD
+#pragma code_seg(".sndthrd")
+DWORD WINAPI SoundThread( LPVOID lpParam )
+{
+	_4klang_render(lpSoundBuffer);
+	return 0;
+}
+#endif
+
+#pragma code_seg(".initsnd")
+extern "C" void InitSound()
+{
+#ifdef USE_SOUND_THREAD
+	CreateThread(0, 0, SoundThread, 0, 0, 0);
+#else
+	_4klang_render(lpSoundBuffer);
+#endif
+	waveOutOpen			( &hWaveOut, WAVE_MAPPER, &WaveFMT, NULL, 0, CALLBACK_NULL );
+	waveOutPrepareHeader( hWaveOut, &WaveHDR, sizeof(WaveHDR) );
+	waveOutWrite		( hWaveOut, &WaveHDR, sizeof(WaveHDR) );	
+}
+
+#pragma code_seg(".envelope")
+extern "C" float get_Envelope(int instrument)
+{
+	return (&_4klang_envelope_buffer)[((MMTime.u.sample >> 8) << 5) + 2*instrument];
+}
+
+#pragma code_seg(".time")
+extern "C" float get_Time()
+{
+	waveOutGetPosition(hWaveOut, &MMTime, sizeof(MMTIME));
+	return float(MMTime.u.sample) / SAMPLE_RATE;
+}

ifs4k/src/ifs4k/synth.h

@@ -0,0 +1,8 @@
+#pragma once
+
+extern "C" 
+{
+	void InitSound();
+	float get_Envelope(int instrument);
+	float get_Time();
+}

ifs4k/src/ifs4k/transform.fs

@@ -0,0 +1,171 @@
+// Parameters from our host
+// x: Noise intensity
+// y: #sceneid.#scenetime (float)
+// z: Snare drum intensity (amiga ball radius gain)
+// w: Aspect ratio
+varying vec4 Y; 
+
+// Position of the fragment
+varying vec2 Z; 
+
+float PI = 3.141592;
+
+// Pseudo random number base generator (credits go to iq/rgba)
+float rnd(vec3 x) 
+{
+	int n = int(x.x * 40 + x.y * 6400 + x.z * 4096000);
+	n = (n << 13) ^ n;
+	return 1 - float((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824;
+}
+
+// Convert the cipher range from [-1,1] to [0,1]
+float norm(float x)
+{
+	return x * 0.5 + 0.5;
+}
+
+vec3 swirl(vec3 p, float r, float theta)
+{
+    return vec3(r*cos(theta+r), r*sin(theta+r), p.z);
+}
+
+vec3 horseshoe(vec3 p, float r, float theta)
+{
+    return vec3(r*cos(2*theta), r*sin(2*theta), p.z);
+}
+
+vec3 polar(vec3 p, float r, float theta)
+{
+    return vec3(theta / PI, r-1, p.z);
+}
+
+vec3 linear(vec3 p, float r, float theta)
+{
+    return p;
+}
+ 
+vec3 sinusoidal(vec3 p, float r, float theta)
+{
+    return vec3(sin(p.x), sin(p.y), p.z);  // 2d
+}
+ 
+vec3 spherical(vec3 p, float r, float theta)
+{
+    return normalize(p);
+}
+
+vec3 handkerchief(vec3 p, float r, float theta)
+{
+    return vec3(r*sin(theta+r), r*cos(theta-r), p.z);
+}
+ 
+vec3 heart(vec3 p, float r, float theta)
+{
+    return vec3(r*sin(theta*r), -r*cos(theta*r), p.z);
+}
+ 
+vec3 disc(vec3 p, float r, float theta)
+{
+    return vec3(theta*sin(PI*r)/PI, theta*cos(PI*r)/PI, p.z);
+}
+ 
+vec3 spiral(vec3 p, float r, float theta)
+{
+    return vec3((cos(theta)+sin(r))/r, (sin(theta)-cos(r))/r, p.z);
+}
+ 
+vec3 hyperbolic(vec3 p, float r, float theta)
+{
+    return vec3(sin(theta)/r, cos(theta)*r, p.z);
+}
+ 
+vec3 diamond(vec3 p, float r, float theta)
+{
+    return vec3(sin(theta)*cos(r), cos(theta)*sin(r), p.z);
+}
+ 
+vec3 ex(vec3 p, float r, float theta)
+{
+    return vec3(r*pow(sin(theta+r), 3.0), r*pow(cos(theta-r), 3.0), p.z);
+}
+
+vec3 fisheye(vec3 p, float r, float theta)
+{
+    return vec3(2*r/(r+1)*p.xy, p.z);
+}
+ 
+vec3 cosine(vec3 p, float r, float theta)
+{
+    return vec3(cos(PI*p.x)*cosh(p.y), -sin(PI*p.x)*sinh(p.y), p.z);
+}
+ 
+// Simon's functions
+vec3 sphere(vec3 p, float r, float theta)
+{
+    return normalize(p);
+}
+
+void main()
+{
+	mat4[] transforms =
+	{
+		mat4(
+			vec4(1.1, 0.0, 0.0, 0.0),
+			vec4(0.0, 1.1, 0.0, 0.0),
+			vec4(0.0, 0.0, 1.1, 0.0),
+			vec4(0.0, 0.0, 0.1, 1.0)),
+		mat4(
+			vec4(1.0, 0.0, 0.0, 0.0),
+			vec4(0.0, 1.0, 0.0, 0.0),
+			vec4(0.0, 0.0, 1.0, 0.0),
+			vec4(0.0, 0.2, 0.0, 1.0)),
+		mat4(
+			vec4(1.0, 0.0, 0.0, 0.0),
+			vec4(0.0, 1.0, 0.0, 0.0),
+			vec4(0.0, 0.0, 1.0, 0.0),
+			vec4(0.2, 0.0, 0.0, 1.0)),
+		mat4(
+			vec4(cos(0.5), -sin(0.5), 0.0, 0.0),
+			vec4(sin(0.5), cos(0.5), 0.0, 0.0),
+			vec4(0.0, 0.0, 1.0, 0.0),
+			vec4(0.0, 0.0, 0.0, 1.0))
+	};
+	
+	float probability[] =
+	{
+		0.01,
+		0.02,
+		0.03,
+		1.0
+	};
+	
+	float seed = 0.0;
+	vec4 pos = vec4(0, 0, 0, 1);
+	int address = 0;
+	for (int i = 0; i < 64; ++i)
+	{
+		float prob = norm(rnd(vec3(Z*400, seed++)));
+		for (int j = 0; j < 4; ++j)
+		{
+			float scale = norm(rnd(vec3(Z*400, seed++))) * 0.5 + 0.5 + 0.5 * (norm(sin(Y.y/25))*1.2);
+			mat4 scaleMat = mat4(
+				vec4(scale, 0.0, 0.0, 0.0),
+				vec4(0.0, scale, 0.0, 0.0),
+				vec4(0.0, 0.0, scale, 0.0),
+				vec4(0.0, 0.0, 0.0, 1.0));
+			if (prob < probability[j])
+			{
+				pos = (scaleMat * transforms[j]) * pos;
+				address <<= 1;
+				address += j;
+				break;
+			}
+		}
+	}
+	
+	float r = length(pos)/2;
+    float theta = atan2(pos.x, pos.y);
+    float rho = acos(pos.z / r);
+    
+	gl_FragColor = vec4(cosine(pos.xyz, r, rho)*0.5+0.5, address / 65536.0);
+}

ifs4k/src/ifs4k/transform.vs

@@ -0,0 +1,9 @@
+varying vec4 Y;
+varying vec2 Z;
+
+void main()
+{
+	Y = gl_Color;
+	Z = (gl_Vertex.xy*vec2(Y.w,1.0))*0.5+0.5;
+	gl_Position = gl_Vertex;
+}