diff --git a/premake5.lua b/premake5.lua
index b1934e6..984fcab 100755
--- a/premake5.lua
+++ b/premake5.lua
@@ -71,3 +71,48 @@ project "dumprwtree"
 	includedirs { "." }
 	libdirs { Libdir }
 	links { "librw" }
+
+function findlibs()
+	filter { "platforms:linux*gl3" }
+		links { "GL", "GLEW", "glfw" }
+	filter { "platforms:win*gl3" }
+		defines { "GLEW_STATIC" }
+	filter { "platforms:win-amd64-gl3" }
+		libdirs { path.join(GLEWdir, "lib/Release/x64") }
+		libdirs { path.join(GLFW64dir, "lib-vc2015") }
+	filter { "platforms:win-x86-gl3" }
+		libdirs { path.join(GLEWdir, "lib/Release/Win32") }
+	filter { "platforms:win*gl3" }
+		links { "glew32s", "glfw3", "opengl32" }
+	filter { "platforms:*d3d9" }
+		links { "d3d9", "Xinput9_1_0" }
+	filter {}
+end
+
+function skeleton()
+	files { "skeleton/*.cpp", "skeleton/*.h" }
+	includedirs { "skeleton" }
+end
+
+function skeltool(dir)
+	targetdir (Bindir)
+	files { path.join("tools", dir, "*.cpp"),
+	        path.join("tools", dir, "*.h") }
+	vpaths {
+		{["src"] = { path.join("tools", dir, "*") }},
+		{["skeleton"] = { "skeleton/*" }},
+	}
+	skeleton()
+	debugdir ( path.join("tools", dir) )
+	includedirs { "." }
+	libdirs { Libdir }
+	links { "librw" }
+	findlibs()
+end
+
+project "clumpview"
+	kind "WindowedApp"
+	characterset ("MBCS")
+	skeltool("clumpview")
+	flags { "WinMain" }
+	removeplatforms { "*null" }
diff --git a/rw.h b/rw.h
index 8638793..af7d6eb 100644
--- a/rw.h
+++ b/rw.h
@@ -15,9 +15,6 @@
 #include "src/d3d/rwd3d.h"
 #include "src/d3d/rwd3d8.h"
 #include "src/d3d/rwd3d9.h"
-#ifdef RW_OPENGL
-#include <GL/glew.h>
-#endif
 #include "src/gl/rwwdgl.h"
 #include "src/gl/rwgl3.h"
 #include "src/gl/rwgl3shader.h"
diff --git a/skeleton/glfw.cpp b/skeleton/glfw.cpp
new file mode 100644
index 0000000..5690a04
--- /dev/null
+++ b/skeleton/glfw.cpp
@@ -0,0 +1,184 @@
+#include <Windows.h>
+#include <rw.h>
+#include "skeleton.h"
+
+using namespace sk;
+using namespace rw;
+
+#ifdef RW_OPENGL
+
+GLFWwindow *window;
+int keymap[GLFW_KEY_LAST+1];
+
+static void
+initkeymap(void)
+{
+	int i;
+	for(i = 0; i < GLFW_KEY_LAST+1; i++)
+		keymap[i] = KEY_NULL;
+	keymap[GLFW_KEY_SPACE] = ' ';
+	keymap[GLFW_KEY_APOSTROPHE] = '\'';
+	keymap[GLFW_KEY_COMMA] = ',';
+	keymap[GLFW_KEY_MINUS] = '-';
+	keymap[GLFW_KEY_PERIOD] = '.';
+	keymap[GLFW_KEY_SLASH] = '/';
+	keymap[GLFW_KEY_0] = '0';
+	keymap[GLFW_KEY_1] = '1';
+	keymap[GLFW_KEY_2] = '2';
+	keymap[GLFW_KEY_3] = '3';
+	keymap[GLFW_KEY_4] = '4';
+	keymap[GLFW_KEY_5] = '5';
+	keymap[GLFW_KEY_6] = '6';
+	keymap[GLFW_KEY_7] = '7';
+	keymap[GLFW_KEY_8] = '8';
+	keymap[GLFW_KEY_9] = '9';
+	keymap[GLFW_KEY_SEMICOLON] = ';';
+	keymap[GLFW_KEY_EQUAL] = '=';
+	keymap[GLFW_KEY_A] = 'A';
+	keymap[GLFW_KEY_B] = 'B';
+	keymap[GLFW_KEY_C] = 'C';
+	keymap[GLFW_KEY_D] = 'D';
+	keymap[GLFW_KEY_E] = 'E';
+	keymap[GLFW_KEY_F] = 'F';
+	keymap[GLFW_KEY_G] = 'G';
+	keymap[GLFW_KEY_H] = 'H';
+	keymap[GLFW_KEY_I] = 'I';
+	keymap[GLFW_KEY_J] = 'J';
+	keymap[GLFW_KEY_K] = 'K';
+	keymap[GLFW_KEY_L] = 'L';
+	keymap[GLFW_KEY_M] = 'M';
+	keymap[GLFW_KEY_N] = 'N';
+	keymap[GLFW_KEY_O] = 'O';
+	keymap[GLFW_KEY_P] = 'P';
+	keymap[GLFW_KEY_Q] = 'Q';
+	keymap[GLFW_KEY_R] = 'R';
+	keymap[GLFW_KEY_S] = 'S';
+	keymap[GLFW_KEY_T] = 'T';
+	keymap[GLFW_KEY_U] = 'U';
+	keymap[GLFW_KEY_V] = 'V';
+	keymap[GLFW_KEY_W] = 'W';
+	keymap[GLFW_KEY_X] = 'X';
+	keymap[GLFW_KEY_Y] = 'Y';
+	keymap[GLFW_KEY_Z] = 'Z';
+	keymap[GLFW_KEY_LEFT_BRACKET] = '[';
+	keymap[GLFW_KEY_BACKSLASH] = '\\';
+	keymap[GLFW_KEY_RIGHT_BRACKET] = ']';
+	keymap[GLFW_KEY_GRAVE_ACCENT] = '`';
+	keymap[GLFW_KEY_ESCAPE] = KEY_ESC;
+	keymap[GLFW_KEY_ENTER] = KEY_ENTER;
+	keymap[GLFW_KEY_TAB] = KEY_TAB;
+	keymap[GLFW_KEY_BACKSPACE] = KEY_BACKSP;
+	keymap[GLFW_KEY_INSERT] = KEY_INS;
+	keymap[GLFW_KEY_DELETE] = KEY_DEL;
+	keymap[GLFW_KEY_RIGHT] = KEY_RIGHT;
+	keymap[GLFW_KEY_LEFT] = KEY_LEFT;
+	keymap[GLFW_KEY_DOWN] = KEY_DOWN;
+	keymap[GLFW_KEY_UP] = KEY_UP;
+	keymap[GLFW_KEY_PAGE_UP] = KEY_PGUP;
+	keymap[GLFW_KEY_PAGE_DOWN] = KEY_PGDN;
+	keymap[GLFW_KEY_HOME] = KEY_HOME;
+	keymap[GLFW_KEY_END] = KEY_END;
+	keymap[GLFW_KEY_CAPS_LOCK] = KEY_CAPSLK;
+	keymap[GLFW_KEY_SCROLL_LOCK] = KEY_NULL;
+	keymap[GLFW_KEY_NUM_LOCK] = KEY_NULL;
+	keymap[GLFW_KEY_PRINT_SCREEN] = KEY_NULL;
+	keymap[GLFW_KEY_PAUSE] = KEY_NULL;
+
+	keymap[GLFW_KEY_F1] = KEY_F1;
+	keymap[GLFW_KEY_F2] = KEY_F2;
+	keymap[GLFW_KEY_F3] = KEY_F3;
+	keymap[GLFW_KEY_F4] = KEY_F4;
+	keymap[GLFW_KEY_F5] = KEY_F5;
+	keymap[GLFW_KEY_F6] = KEY_F6;
+	keymap[GLFW_KEY_F7] = KEY_F7;
+	keymap[GLFW_KEY_F8] = KEY_F8;
+	keymap[GLFW_KEY_F9] = KEY_F9;
+	keymap[GLFW_KEY_F10] = KEY_F10;
+	keymap[GLFW_KEY_F11] = KEY_F11;
+	keymap[GLFW_KEY_F12] = KEY_F12;
+	keymap[GLFW_KEY_F13] = KEY_NULL;
+	keymap[GLFW_KEY_F14] = KEY_NULL;
+	keymap[GLFW_KEY_F15] = KEY_NULL;
+	keymap[GLFW_KEY_F16] = KEY_NULL;
+	keymap[GLFW_KEY_F17] = KEY_NULL;
+	keymap[GLFW_KEY_F18] = KEY_NULL;
+	keymap[GLFW_KEY_F19] = KEY_NULL;
+	keymap[GLFW_KEY_F20] = KEY_NULL;
+	keymap[GLFW_KEY_F21] = KEY_NULL;
+	keymap[GLFW_KEY_F22] = KEY_NULL;
+	keymap[GLFW_KEY_F23] = KEY_NULL;
+	keymap[GLFW_KEY_F24] = KEY_NULL;
+	keymap[GLFW_KEY_F25] = KEY_NULL;
+	keymap[GLFW_KEY_KP_0] = KEY_NULL;
+	keymap[GLFW_KEY_KP_1] = KEY_NULL;
+	keymap[GLFW_KEY_KP_2] = KEY_NULL;
+	keymap[GLFW_KEY_KP_3] = KEY_NULL;
+	keymap[GLFW_KEY_KP_4] = KEY_NULL;
+	keymap[GLFW_KEY_KP_5] = KEY_NULL;
+	keymap[GLFW_KEY_KP_6] = KEY_NULL;
+	keymap[GLFW_KEY_KP_7] = KEY_NULL;
+	keymap[GLFW_KEY_KP_8] = KEY_NULL;
+	keymap[GLFW_KEY_KP_9] = KEY_NULL;
+	keymap[GLFW_KEY_KP_DECIMAL] = KEY_NULL;
+	keymap[GLFW_KEY_KP_DIVIDE] = KEY_NULL;
+	keymap[GLFW_KEY_KP_MULTIPLY] = KEY_NULL;
+	keymap[GLFW_KEY_KP_SUBTRACT] = KEY_NULL;
+	keymap[GLFW_KEY_KP_ADD] = KEY_NULL;
+	keymap[GLFW_KEY_KP_ENTER] = KEY_NULL;
+	keymap[GLFW_KEY_KP_EQUAL] = KEY_NULL;
+	keymap[GLFW_KEY_LEFT_SHIFT] = KEY_LSHIFT;
+	keymap[GLFW_KEY_LEFT_CONTROL] = KEY_LCTRL;
+	keymap[GLFW_KEY_LEFT_ALT] = KEY_LALT;
+	keymap[GLFW_KEY_LEFT_SUPER] = KEY_NULL;
+	keymap[GLFW_KEY_RIGHT_SHIFT] = KEY_RSHIFT;
+	keymap[GLFW_KEY_RIGHT_CONTROL] = KEY_RCTRL;
+	keymap[GLFW_KEY_RIGHT_ALT] = KEY_RALT;
+	keymap[GLFW_KEY_RIGHT_SUPER] = KEY_NULL;
+	keymap[GLFW_KEY_MENU] = KEY_NULL;
+}
+
+static void KeyUp(int key) { EventHandler(KEYUP, &key); }
+static void KeyDown(int key) { EventHandler(KEYDOWN, &key); }
+
+static void
+keypress(GLFWwindow *window, int key, int scancode, int action, int mods)
+{
+	if(key >= 0 && key <= GLFW_KEY_LAST){
+		if(action == GLFW_RELEASE) KeyUp(keymap[key]);
+		else if(action == GLFW_PRESS)   KeyDown(keymap[key]);
+		else if(action == GLFW_REPEAT)  KeyDown(keymap[key]);
+	}
+}
+
+int
+main(int argc, char *argv[])
+{
+	EventHandler(INITIALIZE, nil);
+
+	engineStartParams.width = sk::globals.width;
+	engineStartParams.height = sk::globals.height;
+	engineStartParams.windowtitle = sk::globals.windowtitle;
+	engineStartParams.window = &window;
+
+	if(EventHandler(RWINITIALIZE, nil) == EVENTERROR)
+		return 0;
+
+	initkeymap();
+	glfwSetKeyCallback(window, keypress);
+
+	float lastTime = glfwGetTime()*1000;
+	while(!sk::globals.quit && !glfwWindowShouldClose(window)){
+		float currTime  = glfwGetTime()*1000;
+		float timeDelta = (currTime - lastTime)*0.001f;
+		glfwPollEvents();
+
+		EventHandler(IDLE, &timeDelta);
+
+		lastTime = currTime;
+	}
+
+	EventHandler(RWTERMINATE, nil);
+
+	return 0;
+}
+#endif
diff --git a/skeleton/skeleton.cpp b/skeleton/skeleton.cpp
new file mode 100644
index 0000000..d0bdb55
--- /dev/null
+++ b/skeleton/skeleton.cpp
@@ -0,0 +1,57 @@
+#include <rw.h>
+#include "skeleton.h"
+
+namespace sk {
+
+Globals globals;
+
+bool
+InitRW(void)
+{
+	if(!rw::Engine::init())
+		return false;
+	if(AppEventHandler(sk::PLUGINATTACH, nil) == EVENTERROR)
+		return false;
+	if(!rw::Engine::open())
+		return false;
+	if(!rw::Engine::start(&engineStartParams))
+		return false;
+	rw::engine->loadTextures = 1;
+
+	rw::TexDictionary::setCurrent(rw::TexDictionary::create());
+	rw::Image::setSearchPath(".");
+	return true;
+}
+
+void
+TerminateRW(void)
+{
+	// TODO: delete all tex dicts
+	rw::Engine::stop();
+	rw::Engine::close();
+	rw::Engine::term();
+}
+
+EventStatus
+EventHandler(Event e, void *param)
+{
+	EventStatus s;
+	s = AppEventHandler(e, param);
+	if(e == QUIT){
+		globals.quit = 1;
+		return EVENTPROCESSED;
+	}
+	if(s == EVENTNOTPROCESSED)
+		switch(e){
+		case RWINITIALIZE:
+			return InitRW() ? EVENTPROCESSED : EVENTERROR;
+		case RWTERMINATE:
+			TerminateRW();
+			return EVENTPROCESSED;
+		default:
+			break;
+		}
+	return s;
+}
+
+}
diff --git a/skeleton/skeleton.h b/skeleton/skeleton.h
new file mode 100644
index 0000000..dc049d7
--- /dev/null
+++ b/skeleton/skeleton.h
@@ -0,0 +1,91 @@
+extern rw::EngineStartParams engineStartParams;
+
+namespace sk {
+
+using namespace rw;
+
+// same as RW skeleton
+enum Key
+{
+	// ascii...
+
+	KEY_ESC   = 128,
+
+	KEY_F1    = 129,
+	KEY_F2    = 130,
+	KEY_F3    = 131,
+	KEY_F4    = 132,
+	KEY_F5    = 133,
+	KEY_F6    = 134,
+	KEY_F7    = 135,
+	KEY_F8    = 136,
+	KEY_F9    = 137,
+	KEY_F10   = 138,
+	KEY_F11   = 139,
+	KEY_F12   = 140,
+
+	KEY_INS   = 141,
+	KEY_DEL   = 142,
+	KEY_HOME  = 143,
+	KEY_END   = 144,
+	KEY_PGUP  = 145,
+	KEY_PGDN  = 146,
+
+	KEY_UP    = 147,
+	KEY_DOWN  = 148,
+	KEY_LEFT  = 149,
+	KEY_RIGHT = 150,
+
+	// some stuff ommitted
+
+	KEY_BACKSP = 168,
+	KEY_TAB    = 169,
+	KEY_CAPSLK = 170,
+	KEY_ENTER  = 171,
+	KEY_LSHIFT = 172,
+	KEY_RSHIFT = 173,
+	KEY_LCTRL  = 174,
+	KEY_RCTRL  = 175,
+	KEY_LALT   = 176,
+	KEY_RALT   = 177,
+
+	KEY_NULL,	// unused
+	KEY_NUMKEYS,
+};
+
+enum EventStatus
+{
+	EVENTERROR,
+	EVENTPROCESSED,
+	EVENTNOTPROCESSED
+};
+
+enum Event
+{
+	INITIALIZE,
+	RWINITIALIZE,
+	RWTERMINATE,
+	SELECTDEVICE,
+	PLUGINATTACH,
+	KEYDOWN,
+	KEYUP,
+	IDLE,
+	QUIT
+};
+
+struct Globals
+{
+	const char *windowtitle;
+	int32 width;
+	int32 height;
+	bool32 quit;
+};
+extern Globals globals;
+
+bool InitRW(void);
+void TerminateRW(void);
+EventStatus EventHandler(Event e, void *param);
+
+}
+
+sk::EventStatus AppEventHandler(sk::Event e, void *param);
diff --git a/skeleton/win.cpp b/skeleton/win.cpp
new file mode 100644
index 0000000..b8cc034
--- /dev/null
+++ b/skeleton/win.cpp
@@ -0,0 +1,217 @@
+#include <Windows.h>
+#include <rw.h>
+#include "skeleton.h"
+
+using namespace sk;
+using namespace rw;
+
+#ifdef RW_D3D9
+
+static int keymap[256];
+static void
+initkeymap(void)
+{
+	int i;
+	for(i = 0; i < 256; i++)
+		keymap[i] = KEY_NULL;
+	keymap[VK_SPACE] = ' ';
+	keymap[VK_OEM_7] = '\'';
+	keymap[VK_OEM_COMMA] = ',';
+	keymap[VK_OEM_MINUS] = '-';
+	keymap[VK_OEM_PERIOD] = '.';
+	keymap[VK_OEM_2] = '/';
+	for(i = '0'; i <= '9'; i++)
+		keymap[i] = i;
+	keymap[VK_OEM_1] = ';';
+	keymap[VK_OEM_NEC_EQUAL] = '=';
+	for(i = 'A'; i <= 'Z'; i++)
+		keymap[i] = i;
+	keymap[VK_OEM_4] = '[';
+	keymap[VK_OEM_5] = '\\';
+	keymap[VK_OEM_6] = ']';
+	keymap[VK_OEM_3] = '`';
+	keymap[VK_ESCAPE] = KEY_ESC;
+	keymap[VK_RETURN] = KEY_ENTER;
+	keymap[VK_TAB] = KEY_TAB;
+	keymap[VK_BACK] = KEY_BACKSP;
+	keymap[VK_INSERT] = KEY_INS;
+	keymap[VK_DELETE] = KEY_DEL;
+	keymap[VK_RIGHT] = KEY_RIGHT;
+	keymap[VK_LEFT] = KEY_LEFT;
+	keymap[VK_DOWN] = KEY_DOWN;
+	keymap[VK_UP] = KEY_UP;
+	keymap[VK_PRIOR] = KEY_PGUP;
+	keymap[VK_NEXT] = KEY_PGDN;
+	keymap[VK_HOME] = KEY_HOME;
+	keymap[VK_END] = KEY_END;
+	keymap[VK_MODECHANGE] = KEY_CAPSLK;
+	for(i = VK_F1; i <= VK_F24; i++)
+		keymap[i] = i-VK_F1+KEY_F1;
+	keymap[VK_LSHIFT] = KEY_LSHIFT;
+	keymap[VK_LCONTROL] = KEY_LCTRL;
+	keymap[VK_LMENU] = KEY_LALT;
+	keymap[VK_RSHIFT] = KEY_RSHIFT;
+	keymap[VK_RCONTROL] = KEY_RCTRL;
+	keymap[VK_RMENU] = KEY_RALT;
+}
+bool running;
+
+static void KeyUp(int key) { EventHandler(KEYUP, &key); }
+static void KeyDown(int key) { EventHandler(KEYDOWN, &key); }
+
+LRESULT CALLBACK
+WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	switch(msg){
+	case WM_DESTROY:
+		PostQuitMessage(0);
+		break;
+
+	case WM_SYSKEYDOWN:
+	case WM_KEYDOWN:
+		if(wParam == VK_MENU){
+			if(GetKeyState(VK_LMENU) & 0x8000) KeyDown(keymap[VK_LMENU]);
+			if(GetKeyState(VK_RMENU) & 0x8000) KeyDown(keymap[VK_RMENU]);
+		}else if(wParam == VK_CONTROL){
+			if(GetKeyState(VK_LCONTROL) & 0x8000) KeyDown(keymap[VK_LCONTROL]);
+			if(GetKeyState(VK_RCONTROL) & 0x8000) KeyDown(keymap[VK_RCONTROL]);
+		}else if(wParam == VK_SHIFT){
+			if(GetKeyState(VK_LSHIFT) & 0x8000) KeyDown(keymap[VK_LSHIFT]);
+			if(GetKeyState(VK_RSHIFT) & 0x8000) KeyDown(keymap[VK_RSHIFT]);
+		}else
+			KeyDown(keymap[wParam]);
+		break;
+
+	case WM_SYSKEYUP:
+	case WM_KEYUP:
+		if(wParam == VK_MENU){
+			if((GetKeyState(VK_LMENU) & 0x8000) == 0) KeyUp(keymap[VK_LMENU]);
+			if((GetKeyState(VK_RMENU) & 0x8000) == 0) KeyUp(keymap[VK_RMENU]);
+		}else if(wParam == VK_CONTROL){
+			if((GetKeyState(VK_LCONTROL) & 0x8000) == 0) KeyUp(keymap[VK_LCONTROL]);
+			if((GetKeyState(VK_RCONTROL) & 0x8000) == 0) KeyUp(keymap[VK_RCONTROL]);
+		}else if(wParam == VK_SHIFT){
+			if((GetKeyState(VK_LSHIFT) & 0x8000) == 0) KeyUp(keymap[VK_LSHIFT]);
+			if((GetKeyState(VK_RSHIFT) & 0x8000) == 0) KeyUp(keymap[VK_RSHIFT]);
+		}else
+			KeyUp(keymap[wParam]);
+		break;
+
+	case WM_CLOSE:
+		DestroyWindow(hwnd);
+		break;
+
+	case WM_QUIT:
+		running = false;
+		break;
+	}
+	return DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+HWND
+MakeWindow(HINSTANCE instance, int width, int height, const char *title)
+{
+	WNDCLASS wc;
+	wc.style         = CS_HREDRAW | CS_VREDRAW;
+	wc.lpfnWndProc   = WndProc;
+	wc.cbClsExtra    = 0;
+	wc.cbWndExtra    = 0;
+	wc.hInstance     = instance;
+	wc.hIcon         = LoadIcon(0, IDI_APPLICATION);
+	wc.hCursor       = LoadCursor(0, IDC_ARROW);
+	wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
+	wc.lpszMenuName  = 0;
+	wc.lpszClassName = "librwD3D9";
+	if(!RegisterClass(&wc)){
+		MessageBox(0, "RegisterClass() - FAILED", 0, 0);
+		return 0;
+	}
+
+	HWND win;
+	win = CreateWindow("librwD3D9", title,
+		WS_BORDER | WS_CAPTION | WS_SYSMENU |
+		            WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
+		0, 0, width, height, 0, 0, instance, 0);
+	if(!win){
+		MessageBox(0, "CreateWindow() - FAILED", 0, 0);
+		return 0;
+	}
+	ShowWindow(win, SW_SHOW);
+	UpdateWindow(win);
+	return win;
+}
+
+void
+pollEvents(void)
+{
+	MSG msg;
+	while(PeekMessage(&msg, 0, 0, 0, PM_REMOVE)){
+		if(msg.message == WM_QUIT){
+			running = false;
+			break;
+		}else{
+			TranslateMessage(&msg);
+			DispatchMessage(&msg);
+		}
+	}
+}
+
+int WINAPI
+WinMain(HINSTANCE instance, HINSTANCE,
+        PSTR cmdLine, int showCmd)
+{
+	AllocConsole();
+	freopen("CONIN$", "r", stdin);
+	freopen("CONOUT$", "w", stdout);
+	freopen("CONOUT$", "w", stderr);
+
+	EventHandler(INITIALIZE, nil);
+
+	HWND win = MakeWindow(instance,
+		sk::globals.width, sk::globals.height,
+		sk::globals.windowtitle);
+	if(win == 0){
+		MessageBox(0, "MakeWindow() - FAILED", 0, 0);
+		return 0;
+	}
+	engineStartParams.window = win;
+	initkeymap();
+
+	if(EventHandler(RWINITIALIZE, nil) == EVENTERROR)
+		return 0;
+
+	float lastTime = (float)GetTickCount();
+	running = true;
+	while(pollEvents(), !globals.quit){
+		float currTime  = (float)GetTickCount();
+		float timeDelta = (currTime - lastTime)*0.001f;
+
+		EventHandler(IDLE, &timeDelta);
+
+		lastTime = currTime;
+	}
+
+	EventHandler(RWTERMINATE, nil);
+
+	return 0;
+}
+#endif
+
+#ifdef RW_OPENGL
+int main(int argc, char *argv[]);
+
+int WINAPI
+WinMain(HINSTANCE instance, HINSTANCE,
+        PSTR cmdLine, int showCmd)
+{
+	char *argv[1] = {
+		"clumpview",
+	};
+	AllocConsole();
+	freopen("CONIN$", "r", stdin);
+	freopen("CONOUT$", "w", stdout);
+	freopen("CONOUT$", "w", stderr);
+
+	return main(1, argv);
+}
+#endif
diff --git a/src/base.cpp b/src/base.cpp
index 7ac5f11..98a1678 100644
--- a/src/base.cpp
+++ b/src/base.cpp
@@ -301,6 +301,26 @@ Matrix::scale(V3d *scale, CombineOp op)
 	return this;
 }
 
+Matrix*
+Matrix::transform(Matrix *mat, CombineOp op)
+{
+	Matrix tmp;
+	switch(op){
+	case COMBINEREPLACE:
+		*this = *mat;
+		break;
+	case COMBINEPRECONCAT:
+		mult(&tmp, mat, this);
+		*this = tmp;
+		break;
+	case COMBINEPOSTCONCAT:
+		mult(&tmp, this, mat);
+		*this = tmp;
+		break;
+	}
+	return this;
+}
+
 void
 Matrix::lookAt(const V3d &dir, const V3d &up)
 {
diff --git a/src/engine.cpp b/src/engine.cpp
index 5b78309..d9d5043 100644
--- a/src/engine.cpp
+++ b/src/engine.cpp
@@ -128,6 +128,16 @@ Engine::start(EngineStartParams *p)
 	return 1;
 }
 
+void
+Engine::term(void)
+{
+}
+
+void
+Engine::close(void)
+{
+}
+
 void
 Engine::stop(void)
 {
diff --git a/src/frame.cpp b/src/frame.cpp
index d868039..80fbe41 100644
--- a/src/frame.cpp
+++ b/src/frame.cpp
@@ -269,6 +269,13 @@ Frame::scale(V3d *scl, CombineOp op)
 	updateObjects();
 }
 
+void
+Frame::transform(Matrix *mat, CombineOp op)
+{
+	this->matrix.transform(mat, op);
+	updateObjects();
+}
+
 void
 Frame::updateObjects(void)
 {
diff --git a/src/rwbase.h b/src/rwbase.h
index 7955006..7497601 100644
--- a/src/rwbase.h
+++ b/src/rwbase.h
@@ -231,6 +231,7 @@ struct Matrix
 	Matrix *rotate(const Quat &q, CombineOp op);
 	Matrix *translate(V3d *translation, CombineOp op);
 	Matrix *scale(V3d *scl, CombineOp op);
+	Matrix *transform(Matrix *mat, CombineOp op);
 	void lookAt(const V3d &dir, const V3d &up);
 
 	// helper functions. consider private
diff --git a/src/rwengine.h b/src/rwengine.h
index 1428c1e..a1c835c 100644
--- a/src/rwengine.h
+++ b/src/rwengine.h
@@ -123,6 +123,8 @@ struct Engine
 	static bool32 init(void);
 	static bool32 open(void);
 	static bool32 start(EngineStartParams*);
+	static void term(void);
+	static void close(void);
 	static void stop(void);
 };
 
diff --git a/src/rwobjects.h b/src/rwobjects.h
index 5bbf75b..d38373a 100644
--- a/src/rwobjects.h
+++ b/src/rwobjects.h
@@ -125,7 +125,8 @@ struct Frame : PluginBase<Frame>
 	Matrix *getLTM(void);
 	void rotate(V3d *axis, float32 angle, CombineOp op);
 	void translate(V3d *trans, CombineOp op);
-	void scale(V3d *trans, CombineOp op);
+	void scale(V3d *scale, CombineOp op);
+	void transform(Matrix *mat, CombineOp op);
 	void updateObjects(void);
 
 
diff --git a/tools/clumpview/camera.cpp b/tools/clumpview/camera.cpp
new file mode 100644
index 0000000..27185aa
--- /dev/null
+++ b/tools/clumpview/camera.cpp
@@ -0,0 +1,134 @@
+#include <cstdio>
+#include <cassert>
+
+#include <rw.h>
+
+#define PI 3.14159265359f
+#include "camera.h"
+
+using rw::Quat;
+using rw::V3d;
+
+void
+Camera::update(void)
+{
+	if(m_rwcam){
+		m_rwcam->nearPlane = m_near;
+		m_rwcam->farPlane = m_far;
+		m_rwcam->setFOV(m_fov, m_aspectRatio);
+
+		rw::Frame *f = m_rwcam->getFrame();
+		if(f){
+			V3d forward = normalize(sub(m_target, m_position));
+			V3d left = normalize(cross(m_up, forward));
+			V3d nup = cross(forward, left);
+			f->matrix.right = left; // lol
+			f->matrix.up = nup;
+			f->matrix.at = forward;
+			f->matrix.pos = m_position;
+			f->matrix.optimize();
+			f->updateObjects();
+		}
+	}
+}
+
+void
+Camera::setTarget(V3d target)
+{
+	m_position = sub(m_position, sub(m_target, target));
+	m_target = target;
+}
+
+float
+Camera::getHeading(void)
+{
+	V3d dir = sub(m_target, m_position);
+	float a = atan2(dir.y, dir.x)-PI/2.0f;
+	return m_localup.z < 0.0f ? a-PI : a;
+}
+
+void
+Camera::turn(float yaw, float pitch)
+{
+	V3d dir = sub(m_target, m_position);
+	Quat r = Quat::rotation(yaw, rw::makeV3d(0.0f, 0.0f, 1.0f));
+	dir = rotate(dir, r);
+	m_localup = rotate(m_localup, r);
+
+	V3d right = normalize(cross(dir, m_localup));
+	r = Quat::rotation(pitch, right);
+	dir = rotate(dir, r);
+	m_localup = normalize(cross(right, dir));
+	if(m_localup.z >= 0.0) m_up.z = 1.0;
+	else m_up.z = -1.0f;
+
+	m_target = add(m_position, dir);
+}
+
+void
+Camera::orbit(float yaw, float pitch)
+{
+	V3d dir = sub(m_target, m_position);
+	Quat r = Quat::rotation(yaw, rw::makeV3d(0.0f, 0.0f, 1.0f));
+	dir = rotate(dir, r);
+	m_localup = rotate(m_localup, r);
+
+	V3d right = normalize(cross(dir, m_localup));
+	r = Quat::rotation(-pitch, right);
+	dir = rotate(dir, r);
+	m_localup = normalize(cross(right, dir));
+	if(m_localup.z >= 0.0) m_up.z = 1.0;
+	else m_up.z = -1.0f;
+
+	m_position = sub(m_target, dir);
+}
+
+void
+Camera::dolly(float dist)
+{
+	V3d dir = setlength(sub(m_target, m_position), dist);
+	m_position = add(m_position, dir);
+	m_target = add(m_target, dir);
+}
+
+void
+Camera::zoom(float dist)
+{
+	V3d dir = sub(m_target, m_position);
+	float curdist = length(dir);
+	if(dist >= curdist)
+		dist = curdist-0.01f;
+	dir = setlength(dir, dist);
+	m_position = add(m_position, dir);
+}
+
+void
+Camera::pan(float x, float y)
+{
+	V3d dir = normalize(sub(m_target, m_position));
+	V3d right = normalize(cross(dir, m_up));
+	V3d localup = normalize(cross(right, dir));
+	dir = add(scale(right, x), scale(localup, y));
+	m_position = add(m_position, dir);
+	m_target = add(m_target, dir);
+}
+
+float
+Camera::distanceTo(V3d v)
+{
+	return length(sub(m_position, v));
+}
+
+Camera::Camera()
+{
+	m_position.set(0.0f, 6.0f, 0.0f);
+	m_target.set(0.0f, 0.0f, 0.0f);
+	m_up.set(0.0f, 0.0f, 1.0f);
+	m_localup = m_up;
+	m_fov = 70.0f;
+	m_aspectRatio = 1.0f;
+	m_near = 0.1f;
+	m_far = 100.0f;
+	m_rwcam = NULL;
+}
+
diff --git a/tools/clumpview/camera.h b/tools/clumpview/camera.h
new file mode 100644
index 0000000..8a0315d
--- /dev/null
+++ b/tools/clumpview/camera.h
@@ -0,0 +1,26 @@
+class Camera
+{
+public:
+	rw::Camera *m_rwcam;
+	rw::V3d m_position;
+	rw::V3d m_target;
+	rw::V3d m_up;
+	rw::V3d m_localup;
+
+	float m_fov, m_aspectRatio;
+	float m_near, m_far;
+
+
+	void setTarget(rw::V3d target);
+	float getHeading(void);
+
+	void turn(float yaw, float pitch);
+	void orbit(float yaw, float pitch);
+	void dolly(float dist);
+	void zoom(float dist);
+	void pan(float x, float y);
+
+	void update(void);
+	float distanceTo(rw::V3d v);
+	Camera(void);
+};
diff --git a/tools/clumpview/main.cpp b/tools/clumpview/main.cpp
new file mode 100644
index 0000000..124534d
--- /dev/null
+++ b/tools/clumpview/main.cpp
@@ -0,0 +1,181 @@
+#include <rw.h>
+#include <skeleton.h>
+#include "camera.h"
+#include <assert.h>
+
+rw::V3d zero = { 0.0f, 0.0f, 0.0f };
+Camera *camera;
+rw::Clump *clump;
+rw::World *world;
+rw::EngineStartParams engineStartParams;
+
+void
+Init(void)
+{
+	sk::globals.windowtitle = "Clump viewer";
+	sk::globals.width = 640;
+	sk::globals.height = 480;
+	sk::globals.quit = 0;
+}
+
+bool
+attachPlugins(void)
+{
+	rw::ps2::registerPDSPlugin(40);
+	rw::ps2::registerPluginPDSPipes();
+
+	rw::registerMeshPlugin();
+	rw::registerNativeDataPlugin();
+	rw::registerAtomicRightsPlugin();
+	rw::registerMaterialRightsPlugin();
+	rw::xbox::registerVertexFormatPlugin();
+	rw::registerSkinPlugin();
+	rw::registerHAnimPlugin();
+	rw::registerMatFXPlugin();
+	rw::registerUVAnimPlugin();
+	rw::ps2::registerADCPlugin();
+	return true;
+}
+
+bool
+InitRW(void)
+{
+//	rw::platform = rw::PLATFORM_D3D8;
+	if(!sk::InitRW())
+		return false;
+
+	char *filename = "teapot.dff";
+	rw::StreamFile in;
+	if(in.open(filename, "rb") == NULL){
+		printf("couldn't open file\n");
+		return false;
+	}
+	rw::findChunk(&in, rw::ID_CLUMP, NULL, NULL);
+	clump = rw::Clump::streamRead(&in);
+	assert(clump);
+	in.close();
+
+	clump->getFrame()->translate(&zero, rw::COMBINEREPLACE);
+
+	FORLIST(lnk, clump->atomics){
+		rw::Atomic *a = rw::Atomic::fromClump(lnk);
+		if(a->pipeline && a->pipeline->platform != rw::platform)
+			a->pipeline = NULL;
+	}
+
+
+	world = rw::World::create();
+
+	rw::Light *ambient = rw::Light::create(rw::Light::AMBIENT);
+	ambient->setColor(0.2f, 0.2f, 0.2f);
+	world->addLight(ambient);
+
+	rw::V3d xaxis = { 1.0f, 0.0f, 0.0f };
+	rw::Light *direct = rw::Light::create(rw::Light::DIRECTIONAL);
+	direct->setColor(0.8f, 0.8f, 0.8f);
+	direct->setFrame(rw::Frame::create());
+	direct->getFrame()->rotate(&xaxis, 180.0f, rw::COMBINEREPLACE);
+	world->addLight(direct);
+
+	camera = new Camera;
+	camera->m_rwcam = rw::Camera::create();
+	camera->m_rwcam->setFrame(rw::Frame::create());
+	camera->m_aspectRatio = 640.0f/480.0f;
+	camera->m_near = 0.1f;
+	camera->m_far = 450.0f;
+	camera->m_target.set(0.0f, 0.0f, 0.0f);
+	camera->m_position.set(0.0f, -10.0f, 0.0f);
+//	camera->setPosition(Vec3(0.0f, 5.0f, 0.0f));
+//	camera->setPosition(Vec3(0.0f, -70.0f, 0.0f));
+//	camera->setPosition(Vec3(0.0f, -1.0f, 3.0f));
+	camera->update();
+
+	world->addCamera(camera->m_rwcam);
+
+	return true;
+}
+
+void
+Draw(float timeDelta)
+{
+	static rw::RGBA clearcol = { 0x80, 0x80, 0x80, 0xFF };
+	camera->m_rwcam->clear(&clearcol, rw::Camera::CLEARIMAGE|rw::Camera::CLEARZ);
+	camera->update();
+	camera->m_rwcam->beginUpdate();
+
+	clump->render();
+
+	camera->m_rwcam->endUpdate();
+	camera->m_rwcam->showRaster();
+}
+
+
+void
+KeyUp(int key)
+{
+}
+
+void
+KeyDown(int key)
+{
+	switch(key){
+	case 'W':
+		camera->orbit(0.0f, 0.1f);
+		break;
+	case 'S':
+		camera->orbit(0.0f, -0.1f);
+		break;
+	case 'A':
+		camera->orbit(-0.1f, 0.0f);
+		break;
+	case 'D':
+		camera->orbit(0.1f, 0.0f);
+		break;
+	case sk::KEY_UP:
+		camera->turn(0.0f, 0.1f);
+		break;
+	case sk::KEY_DOWN:
+		camera->turn(0.0f, -0.1f);
+		break;
+	case sk::KEY_LEFT:
+		camera->turn(0.1f, 0.0f);
+		break;
+	case sk::KEY_RIGHT:
+		camera->turn(-0.1f, 0.0f);
+		break;
+	case 'R':
+		camera->zoom(0.1f);
+		break;
+	case 'F':
+		camera->zoom(-0.1f);
+		break;
+	case sk::KEY_ESC:
+		sk::globals.quit = 1;
+		break;
+	}
+}
+
+sk::EventStatus
+AppEventHandler(sk::Event e, void *param)
+{
+	using namespace sk;
+	switch(e){
+	case INITIALIZE:
+		Init();
+		return EVENTPROCESSED;
+	case RWINITIALIZE:
+		return ::InitRW() ? EVENTPROCESSED : EVENTERROR;
+	case PLUGINATTACH:
+		return attachPlugins() ? EVENTPROCESSED : EVENTERROR;
+	case KEYDOWN:
+		KeyDown(*(int*)param);
+		return EVENTPROCESSED;
+	case KEYUP:
+		KeyUp(*(int*)param);
+		return EVENTPROCESSED;
+	case IDLE:
+		Draw(*(float*)param);
+		return EVENTPROCESSED;
+	}
+	return sk::EVENTNOTPROCESSED;
+}
diff --git a/tools/clumpview/teapot.dff b/tools/clumpview/teapot.dff
new file mode 100644
index 0000000..7a65176
Binary files /dev/null and b/tools/clumpview/teapot.dff differ