random-mirrors
/
librw
mirror of https://github.com/aap/librw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

wrote basic skeleton; clumpview

This commit is contained in:
aap 2017-08-10 00:42:33 +02:00
parent 70739e354e
commit 497796e550
16 changed files with 977 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
premake5.lua
View File

@ -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" }

3
rw.h
View File

@ -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"

184
skeleton/glfw.cpp Normal file
View File

@ -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

57
skeleton/skeleton.cpp Normal file
View File

@ -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;
}
}

91
skeleton/skeleton.h Normal file
View File

@ -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);

217
skeleton/win.cpp Normal file
View File

@ -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

20
src/base.cpp
View File

@ -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)
{

10
src/engine.cpp
View File

@ -128,6 +128,16 @@ Engine::start(EngineStartParams *p)
return 1;
}
void
Engine::term(void)
{
}
void
Engine::close(void)
{
}
void
Engine::stop(void)
{

7
src/frame.cpp
View File

@ -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)
{

1
src/rwbase.h
View File

@ -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

2
src/rwengine.h
View File

@ -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);
};

3
src/rwobjects.h
View File

@ -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);

134
tools/clumpview/camera.cpp Normal file
View File

@ -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;
}

26
tools/clumpview/camera.h Normal file
View File

@ -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);
};

181
tools/clumpview/main.cpp Normal file
View File

@ -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;
}

BIN
tools/clumpview/teapot.dff Normal file
View File

Binary file not shown.