11 files changed, 1041 insertions, 0 deletions

diff --git a/tools/camera/CMakeLists.txt b/tools/camera/CMakeLists.txt
new file mode 100644
index 0000000..6f0dd5f
--- /dev/null
+++ b/tools/camera/CMakeLists.txt
@@ -0,0 +1,19 @@
+add_executable(camera WIN32
+    main.cpp
+    camexamp.cpp
+    viewer.cpp
+)
+
+target_link_libraries(camera
+    PRIVATE
+        librw::skeleton
+        librw::librw
+)
+
+add_custom_command(
+    TARGET camera POST_BUILD
+    COMMAND "${CMAKE_COMMAND}" -E make_directory "$<TARGET_FILE_DIR:camera>/files"
+    COMMAND "${CMAKE_COMMAND}" -E copy_directory "${CMAKE_CURRENT_SOURCE_DIR}/files" "$<TARGET_FILE_DIR:camera>/files"
+)
+
+librw_platform_target(camera)
diff --git a/tools/camera/camexamp.cpp b/tools/camera/camexamp.cpp
new file mode 100644
index 0000000..5f072c6
--- /dev/null
+++ b/tools/camera/camexamp.cpp
@@ -0,0 +1,395 @@
+#include <rw.h>
+#include <skeleton.h>
+
+#include "viewer.h"
+#include "camexamp.h"
+
+#define TEXSIZE 256
+
+rw::Camera *MainCamera;
+rw::Camera *SubCamera;
+
+rw::Raster *SubCameraRaster;
+rw::Raster *SubCameraZRaster;
+rw::Raster *SubCameraMainCameraSubRaster;
+rw::Raster *SubCameraMainCameraSubZRaster;
+
+TextureCamera CameraTexture;
+
+rw::int32 CameraSelected = 0;
+rw::int32 ProjectionIndex = 0;
+bool SubCameraMiniView = true;
+
+CameraData SubCameraData;
+
+void
+CameraQueryData(CameraData *data, CameraDataType type, rw::Camera *camera)
+{
+	data->camera = camera;
+	if(type & FARCLIPPLANE) data->farClipPlane = camera->farPlane;
+	if(type & NEARCLIPPLANE) data->nearClipPlane = camera->nearPlane;
+	if(type & PROJECTION) data->projection = camera->projection;
+	if(type & OFFSET) data->offset = camera->viewOffset;
+	if(type & VIEWWINDOW) data->viewWindow = camera->viewWindow;
+	if(type & MATRIX) data->matrix = &camera->getFrame()->matrix;
+}
+
+void
+CameraSetData(CameraData *data, CameraDataType type)
+{
+	if(type & FARCLIPPLANE) data->camera->setFarPlane(data->farClipPlane);
+	if(type & NEARCLIPPLANE) data->camera->setNearPlane(data->nearClipPlane);
+	if(type & PROJECTION) data->camera->setProjection(data->projection);
+	if(type & OFFSET) data->camera->setViewOffset(&data->offset);
+	if(type & VIEWWINDOW) data->camera->setViewWindow(&data->viewWindow);
+}
+
+void
+ProjectionCallback(void)
+{
+	if(ProjectionIndex == 0)
+		SubCameraData.projection = rw::Camera::PERSPECTIVE;
+	else
+		SubCameraData.projection = rw::Camera::PARALLEL;
+	CameraSetData(&SubCameraData, PROJECTION);
+}
+
+void
+ClipPlaneCallback(void)
+{
+	CameraSetData(&SubCameraData, (CameraDataType)(NEARCLIPPLANE | FARCLIPPLANE));
+}
+
+void
+ChangeViewOffset(float deltaX, float deltaY)
+{
+	SubCameraData.offset.x += deltaX;
+	SubCameraData.offset.y += deltaY;
+	if(SubCameraData.offset.x > 5.0f)
+		SubCameraData.offset.x = 5.0f;
+	if(SubCameraData.offset.x < -5.0f)
+		SubCameraData.offset.x = -5.0f;
+	if(SubCameraData.offset.y > 5.0f)
+		SubCameraData.offset.y = 5.0f;
+	if(SubCameraData.offset.y < -5.0f)
+		SubCameraData.offset.y = -5.0f;
+	CameraSetData(&SubCameraData, OFFSET);
+}
+
+void
+ChangeViewWindow(float deltaX, float deltaY)
+{
+	SubCameraData.viewWindow.x += deltaX;
+	SubCameraData.viewWindow.y += deltaY;
+	if(SubCameraData.viewWindow.x > 5.0f)
+		SubCameraData.viewWindow.x = 5.0f;
+	if(SubCameraData.viewWindow.x < 0.01f)
+		SubCameraData.viewWindow.x = 0.01f;
+	if(SubCameraData.viewWindow.y > 5.0f)
+		SubCameraData.viewWindow.y = 5.0f;
+	if(SubCameraData.viewWindow.y < 0.01f)
+		SubCameraData.viewWindow.y = 0.01f;
+	CameraSetData(&SubCameraData, VIEWWINDOW);
+}
+
+void
+CamerasCreate(rw::World *world)
+{
+	rw::V3d offset = { 3.0f, 0.0f, 8.0f };
+	float rotate = -90.0f;
+
+	SubCamera = ViewerCreate(world);
+	ViewerMove(SubCamera, &offset);
+	ViewerRotate(SubCamera, rotate, 0.0f);
+
+	MainCamera = ViewerCreate(world);
+
+	CameraQueryData(&SubCameraData, ALL, SubCamera);
+
+	SubCameraData.nearClipPlane = 0.3f;
+	CameraSetData(&SubCameraData, NEARCLIPPLANE);
+
+	SubCameraData.farClipPlane = 5.0f;
+	CameraSetData(&SubCameraData, FARCLIPPLANE);
+
+	CameraTexture.camera = SubCamera;
+	CameraTextureInit(&CameraTexture);
+
+	SubCameraData.cameraTexture = &CameraTexture;
+
+
+	SubCameraMainCameraSubRaster = rw::Raster::create(0, 0, 0, rw::Raster::CAMERA);
+	SubCameraMainCameraSubZRaster = rw::Raster::create(0, 0, 0, rw::Raster::ZBUFFER);
+}
+
+void
+CamerasDestroy(rw::World *world)
+{
+	SubCameraMiniViewSelect(false);
+
+	if(MainCamera){
+		ViewerDestroy(MainCamera, world);
+		MainCamera = nil;
+	}
+
+	if(SubCamera){
+		ViewerDestroy(SubCamera, world);
+		SubCamera = nil;
+	}
+
+	CameraTextureTerm(&CameraTexture);
+
+	if(SubCameraMainCameraSubRaster){
+		SubCameraMainCameraSubRaster->destroy();
+		SubCameraMainCameraSubRaster = nil;
+	}
+
+	if(SubCameraMainCameraSubZRaster){
+		SubCameraMainCameraSubZRaster->destroy();
+		SubCameraMainCameraSubZRaster = nil;
+	}
+}
+
+void
+UpdateSubRaster(rw::Camera *camera, rw::Rect *rect)
+{
+	rw::Rect subRect;
+
+	subRect.x = rect->w * 0.75f;
+	subRect.y = 0;
+
+	subRect.w = rect->w * 0.25f;
+	subRect.h = rect->h * 0.25f;
+
+	SubCameraMainCameraSubRaster->subRaster(camera->frameBuffer, &subRect);
+	SubCameraMainCameraSubZRaster->subRaster(camera->zBuffer, &subRect);
+}
+
+void
+CameraSizeUpdate(rw::Rect *rect, float viewWindow, float aspectRatio)
+{
+	static bool RasterInit;
+
+	if(MainCamera == nil)
+		return;
+
+	sk::CameraSize(MainCamera, rect, viewWindow, aspectRatio);
+
+	UpdateSubRaster(MainCamera, rect);
+
+	if(RasterInit)
+		SubCameraMiniViewSelect(false);
+
+	sk::CameraSize(SubCamera, rect, viewWindow, aspectRatio);
+
+	SubCameraRaster = SubCamera->frameBuffer;
+	SubCameraZRaster = SubCamera->zBuffer;
+
+	RasterInit = true;
+	SubCameraMiniViewSelect(CameraSelected == 0);
+
+	CameraQueryData(&SubCameraData, VIEWWINDOW, SubCamera);
+}
+
+void
+RenderSubCamera(rw::RGBA *backgroundColor, rw::int32 clearMode, rw::World *world)
+{
+	SubCamera->clear(backgroundColor, clearMode);
+	SubCamera->beginUpdate();
+	world->render();
+	SubCamera->endUpdate();
+}
+
+void
+RenderTextureCamera(rw::RGBA *foregroundColor, rw::int32 clearMode, rw::World *world)
+{
+	rw::Raster *saveRaster, *saveZRaster;
+
+	saveRaster = CameraTexture.camera->frameBuffer;
+	saveZRaster = CameraTexture.camera->zBuffer;
+	CameraTexture.camera->frameBuffer = CameraTexture.raster;
+	CameraTexture.camera->zBuffer = CameraTexture.zRaster;
+
+	CameraTexture.camera->clear(foregroundColor, clearMode);
+	CameraTexture.camera->beginUpdate();
+	world->render();
+	CameraTexture.camera->endUpdate();
+
+
+	CameraTexture.camera->frameBuffer = saveRaster;
+	CameraTexture.camera->zBuffer = saveZRaster;
+}
+
+void
+SubCameraMiniViewSelect(bool select)
+{
+	if(select){
+		SubCamera->frameBuffer = SubCameraMainCameraSubRaster;
+		SubCamera->zBuffer = SubCameraMainCameraSubZRaster;
+	}else{
+		SubCamera->frameBuffer = SubCameraRaster;
+		SubCamera->zBuffer = SubCameraZRaster;
+	}
+}
+
+
+
+void
+CameraTextureInit(TextureCamera *ct)
+{
+	ct->raster = rw::Raster::create(TEXSIZE, TEXSIZE, 0, rw::Raster::CAMERATEXTURE);
+	assert(ct->raster);
+	ct->zRaster = rw::Raster::create(TEXSIZE, TEXSIZE, 0, rw::Raster::ZBUFFER);
+	assert(ct->zRaster);
+
+	ct->texture = rw::Texture::create(ct->raster);
+	ct->texture->setFilter(rw::Texture::FilterMode::LINEAR);
+}
+
+void
+CameraTextureTerm(TextureCamera *ct)
+{
+	if(ct->raster){	
+		ct->raster->destroy();
+		ct->raster = nil;
+	}
+
+	if(ct->zRaster){	
+		ct->zRaster->destroy();
+		ct->zRaster = nil;
+	}
+
+	if(ct->texture){
+		ct->texture->raster = nil;
+		ct->texture->destroy();
+		ct->texture = nil;
+	}
+}
+
+
+
+void
+DrawCameraFrustum(CameraData *c)
+{
+	rw::RGBA yellow = { 255, 255, 0, 64 };
+	rw::RGBA red = { 255, 0, 0, 255 };
+	rw::RWDEVICE::Im3DVertex frustum[13];
+	// lines
+	rw::uint16 indicesL[] = {
+		1,  2,  2,  3,  3,  4,  4,  1,
+		5,  6,  6,  7,  7,  8,  8,  5,
+		9, 10, 10, 11, 11, 12, 12,  9,
+		5,  9,  6, 10,  7, 11,  8, 12,
+		0,  0
+	};
+	// triangles
+	rw::uint16 indicesT[] = {
+		 5,  6, 10,
+		10,  9,  5,
+		 6,  7, 11,
+		11, 10,  6,
+		 7,  8, 12,
+		12, 11,  7,
+		 8,  5,  9,
+		 9, 12,  8,
+		
+		 7,  6,  5,
+		 5,  8,  7,
+		 9, 10, 11,
+		11, 12,  9
+	};
+	float signs[4][2] = {
+		{  1,  1 },
+		{ -1,  1 },
+		{ -1, -1 },
+		{  1, -1 }
+	};
+
+	float depth[3];
+	depth[0] = 1.0f;	// view window
+	depth[1] = c->nearClipPlane;
+	depth[2] = c->farClipPlane;
+
+	int k = 0;
+	frustum[k].setX(c->offset.x);
+	frustum[k].setY(c->offset.y);
+	frustum[k].setZ(0.0f);
+	k++;
+
+	for(int i = 0; i < 3; i++)	// depths
+		for(int j = 0; j < 4; j++){	// planes
+			if(c->projection == rw::Camera::PERSPECTIVE){
+				frustum[k].setX(-c->offset.x + depth[i]*(signs[j][0]*c->viewWindow.x + c->offset.x));
+				frustum[k].setY(c->offset.y + depth[i]*(signs[j][1]*c->viewWindow.y - c->offset.y));
+				frustum[k].setZ(depth[i]);
+			}else{
+				frustum[k].setX(-c->offset.x + signs[j][0]*c->viewWindow.x + depth[i]*c->offset.x);
+				frustum[k].setY(c->offset.y + signs[j][1]*c->viewWindow.y - depth[i]*c->offset.y);
+				frustum[k].setZ(depth[i]);
+			}
+			k++;
+		}
+
+	for(int i = 0; i < 5; i++)
+		frustum[i].setColor(red.red, red.green, red.blue, red.alpha);
+	for(int i = 5; i < 13; i++)
+		frustum[i].setColor(yellow.red, yellow.green, yellow.blue, 255);
+
+	rw::SetRenderStatePtr(rw::TEXTURERASTER, nil);
+
+	rw::im3d::Transform(frustum, 13, c->camera->getFrame()->getLTM(), rw::im3d::ALLOPAQUE);
+	rw::im3d::RenderIndexedPrimitive(rw::PRIMTYPELINELIST, indicesL, 34);
+	rw::im3d::End();
+
+	for(int i = 5; i < 13; i++)
+		frustum[i].setColor(yellow.red, yellow.green, yellow.blue, yellow.alpha);
+
+	rw::SetRenderState(rw::VERTEXALPHA, 1);
+
+	rw::im3d::Transform(frustum, 13, c->camera->getFrame()->getLTM(), rw::im3d::ALLOPAQUE);
+	rw::im3d::RenderIndexedPrimitive(rw::PRIMTYPETRILIST, indicesT, 36);
+	rw::im3d::End();
+}
+
+void
+DrawCameraViewplaneTexture(CameraData *c)
+{
+	rw::RGBA white = { 255, 255, 255, 255 };
+	rw::RWDEVICE::Im3DVertex frustum[4];
+	rw::uint16 indicesV[] = {
+		2, 1, 0,
+		0, 3, 2,
+		0, 1, 2,
+		2, 3, 0
+	};
+	float uvValues[4][2] = {
+		{ 0.0f, 0.0f },
+		{ 1.0f, 0.0f },
+		{ 1.0f, 1.0f },
+		{ 0.0f, 1.0f }
+	};
+	float signs[4][2] = {
+		{  1,  1 },
+		{ -1,  1 },
+		{ -1, -1 },
+		{  1, -1 }
+	};
+
+	for(int j = 0; j < 4; j++){
+		frustum[j].setX(signs[j][0]*c->viewWindow.x);
+		frustum[j].setY(signs[j][1]*c->viewWindow.y);
+		frustum[j].setZ(1.0f);
+	}
+	for(int i = 0; i < 4; i++){
+		frustum[i].setColor(white.red, white.green, white.blue, white.alpha);
+		frustum[i].setU(uvValues[i][0]);
+		frustum[i].setV(uvValues[i][1]);
+	}
+
+	rw::SetRenderState(rw::VERTEXALPHA, 1);
+	rw::SetRenderStatePtr(rw::TEXTURERASTER, c->cameraTexture->texture->raster);
+
+	rw::im3d::Transform(frustum, 4, c->camera->getFrame()->getLTM(), rw::im3d::VERTEXUV);
+	rw::im3d::RenderIndexedPrimitive(rw::PRIMTYPETRILIST, indicesV, 12);
+	rw::im3d::End();
+}
diff --git a/tools/camera/camexamp.h b/tools/camera/camexamp.h
new file mode 100644
index 0000000..7df301f
--- /dev/null
+++ b/tools/camera/camexamp.h
@@ -0,0 +1,62 @@
+struct TextureCamera
+{
+	rw::Raster *raster;
+	rw::Raster *zRaster;
+	rw::Camera *camera;
+	rw::Texture *texture;
+};
+
+struct CameraData
+{
+	float farClipPlane;
+	float nearClipPlane;
+	rw::uint32 projection;
+	rw::V2d offset;
+	rw::V2d viewWindow;
+	rw::Camera *camera;
+	TextureCamera *cameraTexture;
+	rw::Matrix *matrix;
+};
+
+enum CameraDataType
+{
+	NONE            = 0x00,
+	FARCLIPPLANE    = 0x01,
+	NEARCLIPPLANE   = 0x02,
+	PROJECTION      = 0x04,
+	OFFSET          = 0x08,
+	VIEWWINDOW      = 0x10,
+	MATRIX          = 0x20,
+	ALL             = 0xFF
+};
+
+extern rw::Camera *MainCamera;
+extern rw::Camera *SubCamera;
+
+extern rw::int32 CameraSelected;
+extern rw::int32 ProjectionIndex;
+
+extern CameraData SubCameraData;
+
+void CameraQueryData(CameraData *data, CameraDataType type, rw::Camera *camera);
+void CameraSetData(CameraData *data, CameraDataType type);
+
+void ChangeViewOffset(float deltaX, float deltaY);
+void ChangeViewWindow(float deltaX, float deltaY);
+void ProjectionCallback(void);
+void ClipPlaneCallback(void);
+
+void CamerasCreate(rw::World *world);
+void CamerasDestroy(rw::World *world);
+void CameraSizeUpdate(rw::Rect *rect, float viewWindow, float aspectRatio);
+void RenderSubCamera(rw::RGBA *foregroundColor, rw::int32 clearMode, rw::World *world);
+void RenderTextureCamera(rw::RGBA *foregroundColor, rw::int32 clearMode, rw::World *world);
+void SubCameraMiniViewSelect(bool select);
+
+void CameraTextureInit(TextureCamera *ct);
+void CameraTextureTerm(TextureCamera *ct);
+void DrawCameraFrustum(CameraData *c);
+void DrawCameraViewplaneTexture(CameraData *c);
+
+void ViewerRotate(rw::Camera *camera, float deltaX, float deltaY);
+void ViewerTranslate(rw::Camera *camera, float deltaX, float deltaY);
diff --git a/tools/camera/files/clump.dff b/tools/camera/files/clump.dff
new file mode 100644
index 0000000..960354f
--- /dev/null
+++ b/tools/camera/files/clump.dff
diff --git a/tools/camera/files/clump/shinarm.png b/tools/camera/files/clump/shinarm.png
new file mode 100644
index 0000000..1dbc402
--- /dev/null
+++ b/tools/camera/files/clump/shinarm.png
diff --git a/tools/camera/files/clump/shinbody.png b/tools/camera/files/clump/shinbody.png
new file mode 100644
index 0000000..645b198
--- /dev/null
+++ b/tools/camera/files/clump/shinbody.png
diff --git a/tools/camera/files/clump/shinface.png b/tools/camera/files/clump/shinface.png
new file mode 100644
index 0000000..014ca32
--- /dev/null
+++ b/tools/camera/files/clump/shinface.png
diff --git a/tools/camera/files/clump/shinleg.png b/tools/camera/files/clump/shinleg.png
new file mode 100644
index 0000000..e56c1c3
--- /dev/null
+++ b/tools/camera/files/clump/shinleg.png
diff --git a/tools/camera/main.cpp b/tools/camera/main.cpp
new file mode 100644
index 0000000..b50b40e
--- /dev/null
+++ b/tools/camera/main.cpp
@@ -0,0 +1,508 @@
+#include <rw.h>
+#include <skeleton.h>
+#include <assert.h>
+
+#include "viewer.h"
+#include "camexamp.h"
+
+rw::V3d zero = { 0.0f, 0.0f, 0.0f };
+rw::EngineOpenParams engineOpenParams;
+float FOV = 70.0f;
+
+rw::RGBA ForegroundColor = { 200, 200, 200, 255 };
+rw::RGBA BackgroundColor = { 64, 64, 64, 0 };
+rw::RGBA BackgroundColorSub = { 74, 74, 74, 0 };
+
+rw::World *World;
+rw::Charset *Charset;
+
+rw::V3d Xaxis = { 1.0f, 0.0, 0.0f };
+rw::V3d Yaxis = { 0.0f, 1.0, 0.0f };
+rw::V3d Zaxis = { 0.0f, 0.0, 1.0f };
+
+float TimeDelta;
+
+rw::Clump *Clump;
+
+rw::World*
+CreateWorld(void)
+{
+	rw::BBox bb;
+
+	bb.inf.x = bb.inf.y = bb.inf.z = -100.0f;
+	bb.sup.x = bb.sup.y = bb.sup.z = 100.0f;
+
+	return rw::World::create(&bb);
+}
+
+void
+LightsCreate(rw::World *world)
+{
+	rw::Light *light = rw::Light::create(rw::Light::AMBIENT);
+	assert(light);
+	World->addLight(light);
+
+	light = rw::Light::create(rw::Light::DIRECTIONAL);
+	assert(light);
+	rw::Frame *frame = rw::Frame::create();
+	assert(frame);
+	frame->rotate(&Xaxis, 30.0f, rw::COMBINEREPLACE);
+	frame->rotate(&Yaxis, 30.0f, rw::COMBINEPOSTCONCAT);
+	light->setFrame(frame);
+	World->addLight(light);
+}
+
+rw::Clump*
+ClumpCreate(rw::World *world)
+{
+	rw::Clump *clump;
+	rw::StreamFile in;
+
+	rw::Image::setSearchPath("files/clump/");
+	const char *filename = "files/clump.dff";
+	if(in.open(filename, "rb") == NULL){
+		printf("couldn't open file\n");
+		return nil;
+	}
+	if(!rw::findChunk(&in, rw::ID_CLUMP, NULL, NULL))
+		return nil;
+	clump = rw::Clump::streamRead(&in);
+	in.close();
+	if(clump == nil)
+		return nil;
+
+	rw::Frame *frame = clump->getFrame();
+	rw::V3d pos = { 0.0f, 0.0f, 8.0f };
+	frame->translate(&pos, rw::COMBINEREPLACE);
+	World->addClump(clump);
+	return clump;
+}
+
+void
+ClumpRotate(rw::Clump *clump, rw::Camera *camera, float xAngle, float yAngle)
+{
+	rw::Matrix *cameraMatrix = &camera->getFrame()->matrix;
+	rw::Frame *clumpFrame = clump->getFrame();
+	rw::V3d pos = clumpFrame->matrix.pos;
+
+	pos = rw::scale(pos, -1.0f);
+	clumpFrame->translate(&pos, rw::COMBINEPOSTCONCAT);
+
+	clumpFrame->rotate(&cameraMatrix->up, xAngle, rw::COMBINEPOSTCONCAT);
+	clumpFrame->rotate(&cameraMatrix->right, yAngle, rw::COMBINEPOSTCONCAT);
+
+	pos = rw::scale(pos, -1.0f);
+	clumpFrame->translate(&pos, rw::COMBINEPOSTCONCAT);
+}
+
+void
+ClumpTranslate(rw::Clump *clump, rw::Camera *camera, float xDelta, float yDelta)
+{
+	rw::Matrix *cameraMatrix = &camera->getFrame()->matrix;
+	rw::Frame *clumpFrame = clump->getFrame();
+
+	rw::V3d deltaX = rw::scale(cameraMatrix->right, xDelta);
+	rw::V3d deltaZ = rw::scale(cameraMatrix->at, yDelta);
+	rw::V3d delta = rw::add(deltaX, deltaZ);
+
+	clumpFrame->translate(&delta, rw::COMBINEPOSTCONCAT);
+}
+
+void
+ClumpSetPosition(rw::Clump *clump, rw::V3d *position)
+{
+	clump->getFrame()->translate(position, rw::COMBINEREPLACE);
+}
+
+void
+Initialize(void)
+{
+	sk::globals.windowtitle = "Camera example";
+	sk::globals.width = 1280;
+	sk::globals.height = 800;
+	sk::globals.quit = 0;
+}
+
+bool
+Initialize3D(void)
+{
+	if(!sk::InitRW())
+		return false;
+
+	Charset = rw::Charset::create(&ForegroundColor, &BackgroundColor);
+
+	World = CreateWorld();
+
+	CamerasCreate(World);
+	LightsCreate(World);
+
+	Clump = ClumpCreate(World);
+
+	rw::SetRenderState(rw::CULLMODE, rw::CULLBACK);
+	rw::SetRenderState(rw::ZTESTENABLE, 1);
+	rw::SetRenderState(rw::ZWRITEENABLE, 1);
+
+	ImGui_ImplRW_Init();
+	ImGui::StyleColorsClassic();
+
+	rw::Rect r;
+	r.x = 0;
+	r.y = 0;
+	r.w = sk::globals.width;
+	r.h = sk::globals.height;
+	CameraSizeUpdate(&r, 0.5f, 4.0f/3.0f);
+
+	return true;
+}
+
+void
+DestroyLight(rw::Light *light, rw::World *world)
+{
+	world->removeLight(light);
+	rw::Frame *frame = light->getFrame();
+	if(frame){
+		light->setFrame(nil);
+		frame->destroy();
+	}
+	light->destroy();
+}
+
+void
+Terminate3D(void)
+{
+	if(Clump){
+		World->removeClump(Clump);
+		Clump->destroy();
+		Clump = nil;
+	}
+
+	FORLIST(lnk, World->globalLights){
+		rw::Light *light = rw::Light::fromWorld(lnk);
+		DestroyLight(light, World);
+	}
+	FORLIST(lnk, World->localLights){
+		rw::Light *light = rw::Light::fromWorld(lnk);
+		DestroyLight(light, World);
+	}
+
+	CamerasDestroy(World);
+
+	if(World){
+		World->destroy();
+		World = nil;
+	}
+
+	if(Charset){
+		Charset->destroy();
+		Charset = nil;
+	}
+
+	sk::TerminateRW();
+}
+
+bool
+attachPlugins(void)
+{
+	rw::ps2::registerPDSPlugin(40);
+	rw::ps2::registerPluginPDSPipes();
+
+	rw::registerMeshPlugin();
+	rw::registerNativeDataPlugin();
+	rw::registerAtomicRightsPlugin();
+	rw::registerMaterialRightsPlugin();
+	rw::xbox::registerVertexFormatPlugin();
+	rw::registerSkinPlugin();
+	rw::registerUserDataPlugin();
+	rw::registerHAnimPlugin();
+	rw::registerMatFXPlugin();
+	rw::registerUVAnimPlugin();
+	rw::ps2::registerADCPlugin();
+	return true;
+}
+
+void
+DisplayOnScreenInfo(void)
+{
+	char str[256];
+	sprintf(str, "View window (%.2f, %.2f)", SubCameraData.viewWindow.x, SubCameraData.viewWindow.y);
+	Charset->print(str, 100, 100, 0);
+	sprintf(str, "View offset (%.2f, %.2f)", SubCameraData.offset.x, SubCameraData.offset.y);
+	Charset->print(str, 100, 120, 0);
+}
+
+void
+ResetCameraAndClump(void)
+{
+        SubCameraData.nearClipPlane = 0.3f;
+        SubCameraData.farClipPlane = 5.0f;
+        SubCameraData.projection = rw::Camera::PERSPECTIVE;
+        SubCameraData.offset.x = 0.0f;
+        SubCameraData.offset.y = 0.0f;
+        SubCameraData.viewWindow.x = 0.5f;
+        SubCameraData.viewWindow.y = 0.38f;
+	CameraSetData(&SubCameraData, ALL);
+	ProjectionIndex = 0;
+
+	rw::V3d position = { 3.0f, 0.0f, 8.0f };
+	rw::V3d point = { 0.0f, 0.0f, 8.0f };
+	ViewerSetPosition(SubCameraData.camera, &position);
+	ViewerRotate(SubCamera, -90.0f, 0.0f);
+
+	ClumpSetPosition(Clump, &point);
+}
+
+void
+Gui(void)
+{
+	static bool showCameraWindow = true;
+	ImGui::Begin("Camera", &showCameraWindow);
+
+	ImGui::RadioButton("Main camera", &CameraSelected, 0);
+	ImGui::RadioButton("Sub camera", &CameraSelected, 1);
+
+	if(ImGui::RadioButton("Perspective", &ProjectionIndex, 0))
+		ProjectionCallback();
+	if(ImGui::RadioButton("Parallel", &ProjectionIndex, 1))
+		ProjectionCallback();
+
+	if(ImGui::SliderFloat("Near clip-plane", &SubCameraData.nearClipPlane, 0.1f, SubCameraData.farClipPlane-0.1f))
+		ClipPlaneCallback();
+	if(ImGui::SliderFloat("Far clip-plane", &SubCameraData.farClipPlane, SubCameraData.nearClipPlane+0.1f, 20.0f))
+		ClipPlaneCallback();
+
+	if(ImGui::Button("Reset"))
+		ResetCameraAndClump();
+
+	ImGui::End();
+}
+
+void
+MainCameraRender(rw::Camera *camera)
+{
+	RenderTextureCamera(&BackgroundColorSub, rw::Camera::CLEARIMAGE|rw::Camera::CLEARZ, World);
+
+	camera->clear(&BackgroundColor, rw::Camera::CLEARIMAGE|rw::Camera::CLEARZ);
+
+	camera->beginUpdate();
+
+	ImGui_ImplRW_NewFrame(TimeDelta);
+
+	World->render();
+
+	DrawCameraViewplaneTexture(&SubCameraData);
+	DrawCameraFrustum(&SubCameraData);
+
+	DisplayOnScreenInfo();
+
+	Gui();
+	ImGui::EndFrame();
+	ImGui::Render();
+
+	ImGui_ImplRW_RenderDrawLists(ImGui::GetDrawData());
+
+	camera->endUpdate();
+
+
+	RenderSubCamera(&BackgroundColorSub, rw::Camera::CLEARIMAGE|rw::Camera::CLEARZ, World);
+}
+
+void
+SubCameraRender(rw::Camera *camera)
+{
+	camera->clear(&BackgroundColor, rw::Camera::CLEARIMAGE|rw::Camera::CLEARZ);
+
+	camera->beginUpdate();
+
+	ImGui_ImplRW_NewFrame(TimeDelta);
+
+	World->render();
+
+	DisplayOnScreenInfo();
+
+	Gui();
+	ImGui::EndFrame();
+	ImGui::Render();
+
+	ImGui_ImplRW_RenderDrawLists(ImGui::GetDrawData());
+
+	camera->endUpdate();
+}
+
+void
+Render(void)
+{
+	rw::Camera *camera;
+
+	SubCameraMiniViewSelect(CameraSelected == 0);
+
+	switch(CameraSelected){
+	default:
+	case 0:
+		camera = MainCamera;
+		MainCameraRender(camera);
+		break;
+	case 1:
+		camera = SubCamera;
+		SubCameraRender(camera);
+		break;
+	}
+	camera->showRaster(0);
+}
+
+void
+Idle(float timeDelta)
+{
+	TimeDelta = timeDelta;
+	Render();
+}
+
+int MouseX, MouseY;
+int MouseDeltaX, MouseDeltaY;
+int MouseButtons;
+
+bool RotateClump;
+bool TranslateClump;
+bool RotateCamera;
+bool TranslateCamera;
+bool ViewXWindow;
+bool ViewYWindow;
+bool ViewXOffset;
+bool ViewYOffset;
+
+bool Ctrl, Alt, Shift;
+
+void
+KeyUp(int key)
+{
+	switch(key){
+	case sk::KEY_LCTRL:
+	case sk::KEY_RCTRL:
+		Ctrl = false;
+		break;
+	case sk::KEY_LALT:
+	case sk::KEY_RALT:
+		Alt = false;
+		break;
+	case sk::KEY_LSHIFT:
+	case sk::KEY_RSHIFT:
+		Shift = false;
+		break;
+	}
+}
+
+void
+KeyDown(int key)
+{
+	switch(key){
+	case sk::KEY_LCTRL:
+	case sk::KEY_RCTRL:
+		Ctrl = true;
+		break;
+	case sk::KEY_LALT:
+	case sk::KEY_RALT:
+		Alt = true;
+		break;
+	case sk::KEY_LSHIFT:
+	case sk::KEY_RSHIFT:
+		Shift = true;
+		break;
+	case sk::KEY_ESC:
+		sk::globals.quit = 1;
+		break;
+	}
+}
+
+void
+MouseBtn(sk::MouseState *mouse)
+{
+	MouseButtons = mouse->buttons;
+	RotateClump = !Ctrl && !Alt && !Shift && !!(MouseButtons&1);
+	TranslateClump = !Ctrl && !Alt && !Shift && !!(MouseButtons&4);
+	RotateCamera = Ctrl && !!(MouseButtons&1);
+	TranslateCamera = Ctrl && !!(MouseButtons&4);
+	ViewXWindow = Shift && !!(MouseButtons&1);
+	ViewYWindow = Shift && !!(MouseButtons&4);
+	ViewXOffset = Alt && !!(MouseButtons&1);
+	ViewYOffset = Alt && !!(MouseButtons&4);
+}
+
+void
+MouseMove(sk::MouseState *mouse)
+{
+	MouseDeltaX = mouse->posx - MouseX;
+	MouseDeltaY = mouse->posy - MouseY;
+	MouseX = mouse->posx;
+	MouseY = mouse->posy;
+
+	if(RotateClump)
+		ClumpRotate(Clump, MainCamera, MouseDeltaX, -MouseDeltaY);
+	if(TranslateClump)
+		ClumpTranslate(Clump, MainCamera, -MouseDeltaX*0.01f, -MouseDeltaY*0.1f);
+	if(RotateCamera)
+		ViewerRotate(SubCamera, -MouseDeltaX*0.1f, MouseDeltaY*0.1f);
+	if(TranslateCamera)
+		ViewerTranslate(SubCamera, -MouseDeltaX*0.01f, -MouseDeltaY*0.01f);
+	if(ViewXWindow)
+		ChangeViewWindow(-MouseDeltaY*0.01f, 0.0f);
+	if(ViewYWindow)
+		ChangeViewWindow(0.0f, -MouseDeltaY*0.01f);
+	if(ViewXOffset)
+		ChangeViewOffset(-MouseDeltaY*0.01f, 0.0f);
+	if(ViewYOffset)
+		ChangeViewOffset(0.0f, -MouseDeltaY*0.01f);
+}
+
+sk::EventStatus
+AppEventHandler(sk::Event e, void *param)
+{
+	using namespace sk;
+	Rect *r;
+	MouseState *ms;
+
+	ImGuiEventHandler(e, param);
+	ImGuiIO &io = ImGui::GetIO();
+
+	switch(e){
+	case INITIALIZE:
+		Initialize();
+		return EVENTPROCESSED;
+	case RWINITIALIZE:
+		return Initialize3D() ? EVENTPROCESSED : EVENTERROR;
+	case RWTERMINATE:
+		Terminate3D();
+		return EVENTPROCESSED;
+	case PLUGINATTACH:
+		return attachPlugins() ? EVENTPROCESSED : EVENTERROR;
+	case KEYDOWN:
+		KeyDown(*(int*)param);
+		return EVENTPROCESSED;
+	case KEYUP:
+		KeyUp(*(int*)param);
+		return EVENTPROCESSED;
+	case MOUSEBTN:
+		if(!io.WantCaptureMouse){
+			ms = (MouseState*)param;
+			MouseBtn(ms);
+		}else
+			MouseButtons = 0;
+		return EVENTPROCESSED;
+	case MOUSEMOVE:
+		MouseMove((MouseState*)param);
+		return EVENTPROCESSED;
+	case RESIZE:
+		r = (Rect*)param;
+		// TODO: register when we're minimized
+		if(r->w == 0) r->w = 1;
+		if(r->h == 0) r->h = 1;
+
+		sk::globals.width = r->w;
+		sk::globals.height = r->h;
+
+		CameraSizeUpdate(r, 0.5f, 4.0f/3.0f);
+		break;
+	case IDLE:
+		Idle(*(float*)param);
+		return EVENTPROCESSED;
+	}
+	return sk::EVENTNOTPROCESSED;
+}
diff --git a/tools/camera/viewer.cpp b/tools/camera/viewer.cpp
new file mode 100644
index 0000000..b9732d3
--- /dev/null
+++ b/tools/camera/viewer.cpp
@@ -0,0 +1,51 @@
+#include <rw.h>
+#include <skeleton.h>
+
+rw::Camera*
+ViewerCreate(rw::World *world)
+{
+	rw::Camera *camera = sk::CameraCreate(sk::globals.width, sk::globals.height, 1);
+	assert(camera);
+	camera->setNearPlane(0.1f);
+	camera->setFarPlane(500.0f);
+	world->addCamera(camera);
+	return camera;
+}
+
+void
+ViewerDestroy(rw::Camera *camera, rw::World *world)
+{
+	if(camera && world){
+		world->removeCamera(camera);
+		sk::CameraDestroy(camera);
+	}
+}
+
+void
+ViewerMove(rw::Camera *camera, rw::V3d *offset)
+{
+	sk::CameraMove(camera, offset);
+}
+
+void
+ViewerRotate(rw::Camera *camera, float deltaX, float deltaY)
+{
+	sk::CameraTilt(camera, nil, deltaY);
+	sk::CameraPan(camera, nil, deltaX);
+}
+
+void
+ViewerTranslate(rw::Camera *camera, float deltaX, float deltaY)
+{
+	rw::V3d offset;
+	offset.x = deltaX;
+	offset.y = deltaY;
+	offset.z = 0.0f;
+	sk::CameraMove(camera, &offset);
+}
+
+void
+ViewerSetPosition(rw::Camera *camera, rw::V3d *position)
+{
+	camera->getFrame()->translate(position, rw::COMBINEREPLACE);
+}
diff --git a/tools/camera/viewer.h b/tools/camera/viewer.h
new file mode 100644
index 0000000..acd5d79
--- /dev/null
+++ b/tools/camera/viewer.h
@@ -0,0 +1,6 @@
+rw::Camera *ViewerCreate(rw::World *world);
+void ViewerDestroy(rw::Camera *camera, rw::World *world);
+void ViewerMove(rw::Camera *camera, rw::V3d *offset);
+void ViewerRotate(rw::Camera *camera, float deltaX, float deltaY);
+void ViewerTranslate(rw::Camera *camera, float deltaX, float deltaY);
+void ViewerSetPosition(rw::Camera *camera, rw::V3d *position);