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

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