mirror/openlara
1
0
Fork 0
mirror of https://github.com/XProger/OpenLara.git synced 2025-08-11 07:34:33 +02:00
Code Issues Releases Wiki Activity

convert tabs to spaces

Browse Source
This commit is contained in:
Gagiev Timur
2016-08-29 11:06:13 +03:00
parent 6af424cee8
commit 0b670a1846
13 changed files with 2599 additions and 2659 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
src/camera.h
View File

@@ -4,45 +4,45 @@
#include "core.h"
struct Camera {
float fov, znear, zfar;
vec3 pos, angle, offset;
float fov, znear, zfar;
vec3 pos, angle, offset;
void update() {
#ifdef FREE_CAMERA
vec3 dir = vec3(sinf(angle.y - PI) * cosf(-angle.x), -sinf(-angle.x), cosf(angle.y - PI) * cosf(-angle.x));
vec3 v = vec3(0);
void update() {
#ifdef FREE_CAMERA
vec3 dir = vec3(sinf(angle.y - PI) * cosf(-angle.x), -sinf(-angle.x), cosf(angle.y - PI) * cosf(-angle.x));
vec3 v = vec3(0);
if (Input::down[ikW]) v = v + dir;
if (Input::down[ikS]) v = v - dir;
if (Input::down[ikD]) v = v + dir.cross(vec3(0, 1, 0));
if (Input::down[ikA]) v = v - dir.cross(vec3(0, 1, 0));
pos = pos + v.normal() * (Core::deltaTime * 2048.0f);
#endif
if (Input::down[ikW]) v = v + dir;
if (Input::down[ikS]) v = v - dir;
if (Input::down[ikD]) v = v + dir.cross(vec3(0, 1, 0));
if (Input::down[ikA]) v = v - dir.cross(vec3(0, 1, 0));
pos = pos + v.normal() * (Core::deltaTime * 2048.0f);
#endif
if (Input::down[ikMouseL]) {
vec2 delta = Input::mouse.pos - Input::mouse.start.L;
angle.x -= delta.y * 0.01f;
angle.y -= delta.x * 0.01f;
angle.x = min(max(angle.x, -PI * 0.5f + EPS), PI * 0.5f - EPS);
Input::mouse.start.L = Input::mouse.pos;
}
}
if (Input::down[ikMouseL]) {
vec2 delta = Input::mouse.pos - Input::mouse.start.L;
angle.x -= delta.y * 0.01f;
angle.y -= delta.x * 0.01f;
angle.x = min(max(angle.x, -PI * 0.5f + EPS), PI * 0.5f - EPS);
Input::mouse.start.L = Input::mouse.pos;
}
}
void setup() {
Core::mView.identity();
Core::mView.translate(vec3(-offset.x, -offset.y, -offset.z));
Core::mView.rotateZ(-angle.z);
Core::mView.rotateX(-angle.x);
Core::mView.rotateY(-angle.y);
Core::mView.translate(vec3(-pos.x, -pos.y, -pos.z));
Core::mView.scale(vec3(-1, -1, 1));
void setup() {
Core::mView.identity();
Core::mView.translate(vec3(-offset.x, -offset.y, -offset.z));
Core::mView.rotateZ(-angle.z);
Core::mView.rotateX(-angle.x);
Core::mView.rotateY(-angle.y);
Core::mView.translate(vec3(-pos.x, -pos.y, -pos.z));
Core::mView.scale(vec3(-1, -1, 1));
Core::mProj = mat4(fov, (float)Core::width / (float)Core::height, znear, zfar);
Core::mViewProj = Core::mProj * Core::mView;
Core::mProj = mat4(fov, (float)Core::width / (float)Core::height, znear, zfar);
Core::viewPos = Core::mView.inverse().getPos();
}
Core::mViewProj = Core::mProj * Core::mView;
Core::viewPos = Core::mView.inverse().getPos();
}
};
#endif

783
src/controller.h
View File

@@ -6,456 +6,455 @@
#define GRAVITY 7.0f
struct Controller {
TR::Level *level;
int entity;
TR::Level *level;
int entity;
TR::Animation *anim;
float fTime;
TR::Animation *anim;
float fTime;
vec3 pos, velocity;
float angle;
vec3 pos, velocity;
float angle;
int state; // target state
int lastFrame;
int state; // target state
int lastFrame;
int sc;
bool lState;
bool onGround;
int sc;
bool lState;
bool onGround;
Controller(TR::Level *level, int entity) : level(level), entity(entity), pos(0.0f), velocity(0.0f), angle(0.0f), fTime(0.0f) {
anim = &level->anims[getModel().animation];
lastFrame = 0;
Controller(TR::Level *level, int entity) : level(level), entity(entity), pos(0.0f), velocity(0.0f), angle(0.0f), fTime(0.0f) {
anim = &level->anims[getModel().animation];
lastFrame = 0;
TR::Entity &e = level->entities[entity];
pos = vec3(e.x, e.y, e.z);
angle = e.rotation / 16384.0f * PI * 0.5f;
TR::Entity &e = level->entities[entity];
pos = vec3(e.x, e.y, e.z);
angle = e.rotation / 16384.0f * PI * 0.5f;
sc = 0;
lState = false;
sc = 0;
lState = false;
state = TR::STATE_STOP;
}
state = TR::STATE_STOP;
}
void update() {
float rot = 0.0f;
enum { LEFT = 1, RIGHT = 2, FORTH = 4, BACK = 8, JUMP = 16, WALK = 32, ACTION = 64, WEAPON = 128, ROLL = 256, GROUND = 512, WATER = 1024, DEATH = 2048,
PULL = 4096, PICKUP = 8192, SWITCH_ON = 16 * 1024, SWITCH_OFF = 32 * 1024, KEY = 64 * 1024, PUZZLE = 128 * 1024, HANG = 256 * 1024, FALL = 512 * 1024, COMPRESS = 1024 * 1024};
int mask = 0;
void update() {
float rot = 0.0f;
if (Input::down[ikW] || Input::joy.L.y < 0) mask |= FORTH;
if (Input::down[ikS] || Input::joy.L.y > 0) mask |= BACK;
if (Input::down[ikA] || Input::joy.L.x < 0) mask |= LEFT;
if (Input::down[ikD] || Input::joy.L.x > 0) mask |= RIGHT;
if (Input::down[ikSpace] || Input::down[ikJoyX]) mask |= JUMP;
if (Input::down[ikShift] || Input::down[ikJoyLT]) mask |= WALK;
if (Input::down[ikE] || /*Input::down[ikMouseL] ||*/ Input::down[ikJoyA]) mask |= ACTION;
if (Input::down[ikQ] || Input::down[ikMouseR] || Input::down[ikJoyY]) mask |= WEAPON;
if (onGround) mask |= GROUND;
if (getRoom().flags & 1) mask |= WATER;
if (velocity.y > 2048) mask |= FALL;
if (anim->state == TR::STATE_COMPRESS) mask |= COMPRESS;
enum { LEFT = 1, RIGHT = 2, FORTH = 4, BACK = 8,
JUMP = 16, WALK = 32, ACTION = 64, WEAPON = 128, ROLL = 256,
GROUND = 512, WATER = 1024, DEATH = 2048,
PULL = 4096, PICKUP = 8192, SWITCH_ON = 16 * 1024, SWITCH_OFF = 32 * 1024, KEY = 64 * 1024, PUZZLE = 128 * 1024, HANG = 256 * 1024, FALL = 512 * 1024, COMPRESS = 1024 * 1024};
int mask = 0;
if (Input::down[ikW] || Input::joy.L.y < 0) mask |= FORTH;
if (Input::down[ikS] || Input::joy.L.y > 0) mask |= BACK;
if (Input::down[ikA] || Input::joy.L.x < 0) mask |= LEFT;
if (Input::down[ikD] || Input::joy.L.x > 0) mask |= RIGHT;
if (Input::down[ikSpace] || Input::down[ikJoyX]) mask |= JUMP;
if (Input::down[ikShift] || Input::down[ikJoyLT]) mask |= WALK;
if (Input::down[ikE] || /*Input::down[ikMouseL] ||*/ Input::down[ikJoyA]) mask |= ACTION;
if (Input::down[ikQ] || Input::down[ikMouseR] || Input::down[ikJoyY]) mask |= WEAPON;
if (onGround) mask |= GROUND;
if (getRoom().flags & 1) mask |= WATER;
if (velocity.y > 2048) mask |= FALL;
if (anim->state == TR::STATE_COMPRESS) mask |= COMPRESS;
int origMask = mask;
if (origMask & (FORTH | BACK))
mask &= ~(LEFT | RIGHT);
int stateMask[TR::STATE_MAX];
for (int i = 0; i < TR::STATE_MAX; i++)
stateMask[i] = -1;
stateMask[TR::STATE_WALK] = GROUND | FORTH | WALK;
stateMask[TR::STATE_RUN] = GROUND | FORTH;
stateMask[TR::STATE_STOP] = GROUND;
stateMask[TR::STATE_FORWARD_JUMP] = GROUND | JUMP | FORTH;
// stateMask[TR::STATE_FAST_TURN] = 0;
stateMask[TR::STATE_FAST_BACK] = GROUND | BACK;
stateMask[TR::STATE_TURN_RIGHT] = GROUND | RIGHT;
stateMask[TR::STATE_TURN_LEFT] = GROUND | LEFT;
stateMask[TR::STATE_DEATH] = DEATH;
stateMask[TR::STATE_FAST_FALL] = FALL;
stateMask[TR::STATE_HANG] = HANG | ACTION;
stateMask[TR::STATE_REACH] = ACTION;
// stateMask[TR::STATE_SPLAT]
// stateMask[TR::STATE_TREAD]
// stateMask[TR::STATE_FAST_TURN_14]
stateMask[TR::STATE_COMPRESS] = GROUND | JUMP;
stateMask[TR::STATE_BACK] = GROUND | WALK | BACK;
stateMask[TR::STATE_SWIM] = WATER | FORTH;
// stateMask[TR::STATE_GLIDE]
// stateMask[TR::STATE_NULL_19]
// stateMask[TR::STATE_FAST_TURN_20]
stateMask[TR::STATE_FAST_TURN_20] = GROUND | LEFT | RIGHT;
stateMask[TR::STATE_STEP_RIGHT] = GROUND | WALK | RIGHT;
stateMask[TR::STATE_STEP_LEFT] = GROUND | WALK | LEFT;
stateMask[TR::STATE_ROLL] = GROUND | ROLL;
// stateMask[TR::STATE_SLIDE]
stateMask[TR::STATE_BACK_JUMP] = GROUND | COMPRESS | BACK;
stateMask[TR::STATE_RIGHT_JUMP] = GROUND | COMPRESS | RIGHT;
stateMask[TR::STATE_LEFT_JUMP] = GROUND | COMPRESS | LEFT;
stateMask[TR::STATE_UP_JUMP] = GROUND | COMPRESS;
stateMask[TR::STATE_DIVE] = WATER;
stateMask[TR::STATE_PUSH_PULL_READY] = GROUND | ACTION | PULL;
stateMask[TR::STATE_PICK_UP] = GROUND | ACTION | PICKUP;
stateMask[TR::STATE_SWITCH_ON] = GROUND | ACTION | SWITCH_ON;
stateMask[TR::STATE_SWITCH_OFF] = GROUND | ACTION | SWITCH_OFF;
stateMask[TR::STATE_USE_KEY] = GROUND | ACTION | KEY;
stateMask[TR::STATE_USE_PUZZLE] = GROUND | ACTION | PUZZLE;
stateMask[TR::STATE_SWAN_DIVE] = JUMP | WALK | FORTH;
int origMask = mask;
if (origMask & (FORTH | BACK))
mask &= ~(LEFT | RIGHT);
fTime += Core::deltaTime;
int fCount = anim->frameEnd - anim->frameStart + 1;
int fIndex = int(fTime * 30.0f);
state = -1;
int maxMask = 0;
if (stateMask[anim->state] != mask)
for (int i = 0; i < anim->scCount; i++) {
TR::AnimState &sc = level->states[anim->scOffset + i];
if (sc.state >= TR::STATE_MAX || stateMask[sc.state] == -1)
LOG("unknown state %d\n", sc.state);
else
if (stateMask[sc.state] > maxMask && ((stateMask[sc.state] & mask) == stateMask[sc.state])) {
maxMask = stateMask[sc.state];
state = anim->scOffset + i;
}
}
int stateMask[TR::STATE_MAX];
for (int i = 0; i < TR::STATE_MAX; i++)
stateMask[i] = -1;
stateMask[TR::STATE_WALK] = GROUND | FORTH | WALK;
stateMask[TR::STATE_RUN] = GROUND | FORTH;
stateMask[TR::STATE_STOP] = GROUND;
stateMask[TR::STATE_FORWARD_JUMP] = GROUND | JUMP | FORTH;
// stateMask[TR::STATE_FAST_TURN] = 0;
stateMask[TR::STATE_FAST_BACK] = GROUND | BACK;
stateMask[TR::STATE_TURN_RIGHT] = GROUND | RIGHT;
stateMask[TR::STATE_TURN_LEFT] = GROUND | LEFT;
stateMask[TR::STATE_DEATH] = DEATH;
stateMask[TR::STATE_FAST_FALL] = FALL;
stateMask[TR::STATE_HANG] = HANG | ACTION;
stateMask[TR::STATE_REACH] = ACTION;
// stateMask[TR::STATE_SPLAT]
// stateMask[TR::STATE_TREAD]
// stateMask[TR::STATE_FAST_TURN_14]
stateMask[TR::STATE_COMPRESS] = GROUND | JUMP;
stateMask[TR::STATE_BACK] = GROUND | WALK | BACK;
stateMask[TR::STATE_SWIM] = WATER | FORTH;
// stateMask[TR::STATE_GLIDE]
// stateMask[TR::STATE_NULL_19]
// stateMask[TR::STATE_FAST_TURN_20]
stateMask[TR::STATE_FAST_TURN_20] = GROUND | LEFT | RIGHT;
stateMask[TR::STATE_STEP_RIGHT] = GROUND | WALK | RIGHT;
stateMask[TR::STATE_STEP_LEFT] = GROUND | WALK | LEFT;
stateMask[TR::STATE_ROLL] = GROUND | ROLL;
// stateMask[TR::STATE_SLIDE]
stateMask[TR::STATE_BACK_JUMP] = GROUND | COMPRESS | BACK;
stateMask[TR::STATE_RIGHT_JUMP] = GROUND | COMPRESS | RIGHT;
stateMask[TR::STATE_LEFT_JUMP] = GROUND | COMPRESS | LEFT;
stateMask[TR::STATE_UP_JUMP] = GROUND | COMPRESS;
stateMask[TR::STATE_DIVE] = WATER;
stateMask[TR::STATE_PUSH_PULL_READY] = GROUND | ACTION | PULL;
stateMask[TR::STATE_PICK_UP] = GROUND | ACTION | PICKUP;
stateMask[TR::STATE_SWITCH_ON] = GROUND | ACTION | SWITCH_ON;
stateMask[TR::STATE_SWITCH_OFF] = GROUND | ACTION | SWITCH_OFF;
stateMask[TR::STATE_USE_KEY] = GROUND | ACTION | KEY;
stateMask[TR::STATE_USE_PUZZLE] = GROUND | ACTION | PUZZLE;
stateMask[TR::STATE_SWAN_DIVE] = JUMP | WALK | FORTH;
fTime += Core::deltaTime;
int fCount = anim->frameEnd - anim->frameStart + 1;
int fIndex = int(fTime * 30.0f);
state = -1;
int maxMask = 0;
if (stateMask[anim->state] != mask)
for (int i = 0; i < anim->scCount; i++) {
TR::AnimState &sc = level->states[anim->scOffset + i];
if (sc.state >= TR::STATE_MAX || stateMask[sc.state] == -1)
LOG("unknown state %d\n", sc.state);
else
if (stateMask[sc.state] > maxMask && ((stateMask[sc.state] & mask) == stateMask[sc.state])) {
maxMask = stateMask[sc.state];
state = anim->scOffset + i;
}
}
if (state > -1 && anim->state != level->states[state].state) {
TR::AnimState &sc = level->states[state];
for (int j = 0; j < sc.rangesCount; j++) {
TR::AnimRange &range = level->ranges[sc.rangesOffset + j];
if ( anim->frameStart + fIndex >= range.low && anim->frameStart + fIndex <= range.high) {
int st = anim->state;
anim = &level->anims[range.nextAnimation];
fIndex = range.nextFrame - anim->frameStart;
fCount = anim->frameEnd - anim->frameStart + 1;
fTime = fIndex / 30.0f;
break;
}
}
}
if (state > -1 && anim->state != level->states[state].state) {
TR::AnimState &sc = level->states[state];
for (int j = 0; j < sc.rangesCount; j++) {
TR::AnimRange &range = level->ranges[sc.rangesOffset + j];
if ( anim->frameStart + fIndex >= range.low && anim->frameStart + fIndex <= range.high) {
int st = anim->state;
anim = &level->anims[range.nextAnimation];
fIndex = range.nextFrame - anim->frameStart;
fCount = anim->frameEnd - anim->frameStart + 1;
fTime = fIndex / 30.0f;
break;
}
}
}
#ifdef _DEBUG
if (Input::down[ikEnter]) {
if (!lState) {
lState = true;
// state = TR::STATE_ROLL;
// fTime = 0;
if (Input::down[ikEnter]) {
if (!lState) {
lState = true;
// state = TR::STATE_ROLL;
// fTime = 0;
// sc = (sc + 1) % level->statesCount;
// anim = &level->anims[146];//level->ranges[ level->states[sc].rangesOffset ].nextAnimation ];
// fTime = 0;
// state = level->states[sc].state;
LOG("state: %d\n", anim->state);
for (int i = 0; i < anim->scCount; i++) {
auto &sc = level->states[anim->scOffset + i];
LOG("-> %d : ", (int)sc.state);
for (int j = 0; j < sc.rangesCount; j++) {
TR::AnimRange &range = level->ranges[sc.rangesOffset + j];
LOG("%d ", range.nextAnimation);
//range.
}
LOG("\n");
}
}
} else
lState = false;
// sc = (sc + 1) % level->statesCount;
// anim = &level->anims[146];//level->ranges[ level->states[sc].rangesOffset ].nextAnimation ];
// fTime = 0;
// state = level->states[sc].state;
LOG("state: %d\n", anim->state);
for (int i = 0; i < anim->scCount; i++) {
auto &sc = level->states[anim->scOffset + i];
LOG("-> %d : ", (int)sc.state);
for (int j = 0; j < sc.rangesCount; j++) {
TR::AnimRange &range = level->ranges[sc.rangesOffset + j];
LOG("%d ", range.nextAnimation);
//range.
}
LOG("\n");
}
}
} else
lState = false;
#endif
if (anim->state == TR::STATE_RUN ||
anim->state == TR::STATE_FAST_BACK ||
anim->state == TR::STATE_WALK ||
anim->state == TR::STATE_BACK ||
anim->state == TR::STATE_TURN_LEFT ||
anim->state == TR::STATE_TURN_RIGHT) {
if (anim->state == TR::STATE_RUN ||
anim->state == TR::STATE_FAST_BACK ||
anim->state == TR::STATE_WALK ||
anim->state == TR::STATE_BACK ||
anim->state == TR::STATE_TURN_LEFT ||
anim->state == TR::STATE_TURN_RIGHT) {
if (origMask & LEFT) angle -= Core::deltaTime * PI;
if (origMask & RIGHT) angle += Core::deltaTime * PI;
}
if (origMask & LEFT) angle -= Core::deltaTime * PI;
if (origMask & RIGHT) angle += Core::deltaTime * PI;
}
float d = 0.0f;
switch (anim->state) {
case TR::STATE_BACK :
case TR::STATE_BACK_JUMP :
case TR::STATE_FAST_BACK :
d = PI;
break;
case TR::STATE_STEP_LEFT :
case TR::STATE_LEFT_JUMP :
d = -PI * 0.5f;
break;
case TR::STATE_STEP_RIGHT :
case TR::STATE_RIGHT_JUMP :
d = PI * 0.5f;
break;
}
d += angle;
float d = 0.0f;
switch (anim->state) {
case TR::STATE_BACK :
case TR::STATE_BACK_JUMP :
case TR::STATE_FAST_BACK :
d = PI;
break;
case TR::STATE_STEP_LEFT :
case TR::STATE_LEFT_JUMP :
d = -PI * 0.5f;
break;
case TR::STATE_STEP_RIGHT :
case TR::STATE_RIGHT_JUMP :
d = PI * 0.5f;
break;
}
d += angle;
bool endFrame = fIndex >= fCount;
bool endFrame = fIndex >= fCount;
int16 *ptr = &level->commands[anim->animCommand];
int16 *ptr = &level->commands[anim->animCommand];
for (int i = 0; i < anim->acCount; i++) {
switch (*ptr++) {
case 0x01 : { // cmd position
int16 sx = *ptr++;
int16 sy = *ptr++;
int16 sz = *ptr++;
LOG("move: %d %d\n", (int)sx, (int)sy, (int)sz);
break;
}
case 0x02 : { // cmd jump speed
int16 sy = *ptr++;
int16 sz = *ptr++;
if (endFrame) {
LOG("jump: %d %d\n", (int)sy, (int)sz);
velocity.x = sinf(d) * sz;
velocity.y = sy;
velocity.z = cosf(d) * sz;
onGround = false;
}
break;
}
case 0x03 : // empty hands
break;
case 0x04 : // kill
break;
case 0x05 : { // play sound
int frame = (*ptr++);
int id = (*ptr++) & 0x3FFF;
if (fIndex == frame - anim->frameStart && fIndex != lastFrame) {
auto a = level->soundsMap[id];
auto b = level->soundsInfo[a].index;
auto c = level->soundOffsets[b];
for (int i = 0; i < anim->acCount; i++) {
switch (*ptr++) {
case 0x01 : { // cmd position
int16 sx = *ptr++;
int16 sy = *ptr++;
int16 sz = *ptr++;
LOG("move: %d %d\n", (int)sx, (int)sy, (int)sz);
break;
}
case 0x02 : { // cmd jump speed
int16 sy = *ptr++;
int16 sz = *ptr++;
if (endFrame) {
LOG("jump: %d %d\n", (int)sy, (int)sz);
velocity.x = sinf(d) * sz;
velocity.y = sy;
velocity.z = cosf(d) * sz;
onGround = false;
}
break;
}
case 0x03 : // empty hands
break;
case 0x04 : // kill
break;
case 0x05 : { // play sound
int frame = (*ptr++);
int id = (*ptr++) & 0x3FFF;
if (fIndex == frame - anim->frameStart && fIndex != lastFrame) {
auto a = level->soundsMap[id];
auto b = level->soundsInfo[a].index;
auto c = level->soundOffsets[b];
void *p = &level->soundData[c];
void *p = &level->soundData[c];
PlaySound((LPSTR)p, NULL, SND_ASYNC | SND_MEMORY);
}
break;
}
case 0x06 :
if (fIndex != lastFrame && fIndex + anim->frameStart == ptr[0]) {
if (ptr[1] == 0) {
angle = angle + PI;
}
}
ptr += 2;
break;
}
}
PlaySound((LPSTR)p, NULL, SND_ASYNC | SND_MEMORY);
}
break;
}
case 0x06 :
if (fIndex != lastFrame && fIndex + anim->frameStart == ptr[0]) {
if (ptr[1] == 0) {
angle = angle + PI;
}
}
ptr += 2;
break;
}
}
float dt = Core::deltaTime * 30.0f;
float dt = Core::deltaTime * 30.0f;
if (onGround) {
float speed = anim->speed.toFloat() + anim->accel.toFloat() * (fTime * 30.0f);
velocity.x = sinf(d) * speed;
velocity.z = cosf(d) * speed;
}
velocity.y += GRAVITY * dt;
if (onGround) {
float speed = anim->speed.toFloat() + anim->accel.toFloat() * (fTime * 30.0f);
velocity.x = sinf(d) * speed;
velocity.z = cosf(d) * speed;
}
velocity.y += GRAVITY * dt;
if (endFrame) {
fIndex = anim->nextFrame;
int id = anim->nextAnimation;
anim = &level->anims[anim->nextAnimation];
fIndex -= anim->frameStart;
fTime = fIndex / 30.0f;
fCount = anim->frameEnd - anim->frameStart + 1;
}
if (endFrame) {
fIndex = anim->nextFrame;
int id = anim->nextAnimation;
anim = &level->anims[anim->nextAnimation];
fIndex -= anim->frameStart;
fTime = fIndex / 30.0f;
fCount = anim->frameEnd - anim->frameStart + 1;
}
move(velocity * dt);
collide();
move(velocity * dt);
collide();
lastFrame = fIndex;
}
lastFrame = fIndex;
}
void move(const vec3 &offset) {
vec3 p = pos;
pos = pos + offset;
void move(const vec3 &offset) {
vec3 p = pos;
pos = pos + offset;
updateEntity();
updateEntity();
TR::Room &room = getRoom();
TR::Entity &entity = getEntity();
TR::Room &room = getRoom();
TR::Entity &entity = getEntity();
int dx, dz;
TR::Room::Sector &s = getSector(dx, dz);
int dx, dz;
TR::Room::Sector &s = getSector(dx, dz);
int d = entity.y - s.floor * 256;
if (d >= 256 * 4) {
pos.x = p.x;//vec3(entity.x, entity.y, entity.z);
pos.z = p.z;
updateEntity();
if (d >= 256 * 4)
anim = &level->anims[53]; // forward smash
else
anim = &level->anims[11]; // instant stand
state = anim->state;
fTime = 0;
}
}
int d = entity.y - s.floor * 256;
if (d >= 256 * 4) {
pos.x = p.x;//vec3(entity.x, entity.y, entity.z);
pos.z = p.z;
updateEntity();
if (d >= 256 * 4)
anim = &level->anims[53]; // forward smash
else
anim = &level->anims[11]; // instant stand
state = anim->state;
fTime = 0;
}
}
void updateEntity() {
TR::Entity &e = getEntity();
e.x = int(pos.x);
e.y = int(pos.y);
e.z = int(pos.z);
e.rotation = int(angle / (PI * 0.5f) * 16384.0f);
}
void updateEntity() {
TR::Entity &e = getEntity();
e.x = int(pos.x);
e.y = int(pos.y);
e.z = int(pos.z);
e.rotation = int(angle / (PI * 0.5f) * 16384.0f);
}
bool insideRoom(const vec3 &pos, int room) {
TR::Room &r = level->rooms[room];
vec3 min = vec3(r.info.x, r.info.yTop, r.info.z);
vec3 max = min + vec3(r.xSectors * 1024, r.info.yBottom - r.info.yTop, r.zSectors * 1024);
bool insideRoom(const vec3 &pos, int room) {
TR::Room &r = level->rooms[room];
vec3 min = vec3(r.info.x, r.info.yTop, r.info.z);
vec3 max = min + vec3(r.xSectors * 1024, r.info.yBottom - r.info.yTop, r.zSectors * 1024);
return pos.x >= min.x && pos.x <= max.x &&
pos.y >= min.y && pos.y <= max.y &&
pos.z >= min.z && pos.z <= max.z;
}
return pos.x >= min.x && pos.x <= max.x &&
pos.y >= min.y && pos.y <= max.y &&
pos.z >= min.z && pos.z <= max.z;
}
TR::Entity& getEntity() {
return level->entities[entity];
}
TR::Entity& getEntity() {
return level->entities[entity];
}
TR::Model& getModel() {
TR::Entity &entity = getEntity();
for (int i = 0; i < level->modelsCount; i++)
if (entity.id == level->models[i].id)
return level->models[i];
}
TR::Model& getModel() {
TR::Entity &entity = getEntity();
for (int i = 0; i < level->modelsCount; i++)
if (entity.id == level->models[i].id)
return level->models[i];
}
TR::Room& getRoom() {
return level->rooms[getEntity().room];
}
TR::Room& getRoom() {
return level->rooms[getEntity().room];
}
TR::Room::Sector& getSector(int &dx, int &dz) {
TR::Room &room = getRoom();
TR::Entity &entity = getEntity();
TR::Room::Sector& getSector(int &dx, int &dz) {
TR::Room &room = getRoom();
TR::Entity &entity = getEntity();
dx = entity.x - room.info.x;
dz = entity.z - room.info.z;
int sx = dx / 1024;
int sz = dz / 1024;
dx -= sx * 1024;
dz -= sz * 1024;
dx = entity.x - room.info.x;
dz = entity.z - room.info.z;
int sx = dx / 1024;
int sz = dz / 1024;
dx -= sx * 1024;
dz -= sz * 1024;
return room.sectors[sx * room.zSectors + sz];
}
return room.sectors[sx * room.zSectors + sz];
}
void collide() {
int dx, dz;
TR::Room::Sector &s = getSector(dx, dz);
TR::Entity &entity = getEntity();
float bottom = s.floor * 256;
void collide() {
int dx, dz;
TR::Room::Sector &s = getSector(dx, dz);
TR::Entity &entity = getEntity();
float fx = dx / 1024.0f, fz = dz / 1024.0f;
float bottom = s.floor * 256;
// dx -= 512;
// dz -= 512;
float fx = dx / 1024.0f, fz = dz / 1024.0f;
uint16 cmd, *d = &level->floors[s.floorIndex];
// dx -= 512;
// dz -= 512;
if (s.floorIndex)
do {
cmd = *d++;
int func = cmd & 0x00FF; // function
int sub = (cmd & 0x7F00) >> 8; // sub function
uint16 cmd, *d = &level->floors[s.floorIndex];
switch (func) {
case 1 :
entity.room = *d++;
break;
case 2 :
case 3 : {
int8 sx = (int8)(*d & 0x00FF);
int8 sz = (int8)((*d & 0xFF00) >> 8);
if (s.floorIndex)
do {
cmd = *d++;
int func = cmd & 0x00FF; // function
int sub = (cmd & 0x7F00) >> 8; // sub function
if (func == 2) {
if (sx > 0)
bottom += (int)sx * (1024 - dx) >> 2;
else
bottom -= (int)sx * dx >> 2;
if (sz > 0)
bottom += (int)sz * (1024 - dz) >> 2;
else
bottom -= (int)sz * dz >> 2;
} else {
/*
if (sx < 0) {
p[0].y += sx;
p[3].y += sx;
} else {
p[1].y -= sx;
p[2].y -= sx;
}
switch (func) {
case 1 :
entity.room = *d++;
break;
case 2 :
case 3 : {
int8 sx = (int8)(*d & 0x00FF);
int8 sz = (int8)((*d & 0xFF00) >> 8);
if (sz > 0) {
p[0].y -= sz;
p[1].y -= sz;
} else {
p[3].y += sz;
p[2].y += sz;
}
*/
}
d++;
break;
}
case 4 : {
/*
//*d++; // trigger setup
if (sub == 0x00) LOG("trigger\n");
if (sub == 0x01) LOG("pad\n");
if (sub == 0x02) LOG("switch\n");
if (sub == 0x03) LOG("key\n");
if (sub == 0x04) LOG("pickup\n");
if (sub == 0x05) LOG("heavy-trigger\n");
if (sub == 0x06) LOG("anti-pad\n");
if (sub == 0x07) LOG("combat\n");
if (sub == 0x08) LOG("dummy\n");
if (sub == 0x09) LOG("anti-trigger\n");
*/
uint16 act;
do {
act = *d++; // trigger action
} while (!(act & 0x8000));
break;
}
default :
LOG("unknown func: %d\n", func);
}
if (func == 2) {
if (sx > 0)
bottom += (int)sx * (1024 - dx) >> 2;
else
bottom -= (int)sx * dx >> 2;
} while (!(cmd & 0x8000));
if (sz > 0)
bottom += (int)sz * (1024 - dz) >> 2;
else
bottom -= (int)sz * dz >> 2;
} else {
/*
if (sx < 0) {
p[0].y += sx;
p[3].y += sx;
} else {
p[1].y -= sx;
p[2].y -= sx;
}
if (sz > 0) {
p[0].y -= sz;
p[1].y -= sz;
} else {
p[3].y += sz;
p[2].y += sz;
}
*/
}
d++;
break;
}
case 4 : {
/*
//*d++; // trigger setup
if (sub == 0x00) LOG("trigger\n");
if (sub == 0x01) LOG("pad\n");
if (sub == 0x02) LOG("switch\n");
if (sub == 0x03) LOG("key\n");
if (sub == 0x04) LOG("pickup\n");
if (sub == 0x05) LOG("heavy-trigger\n");
if (sub == 0x06) LOG("anti-pad\n");
if (sub == 0x07) LOG("combat\n");
if (sub == 0x08) LOG("dummy\n");
if (sub == 0x09) LOG("anti-trigger\n");
*/
uint16 act;
do {
act = *d++; // trigger action
} while (!(act & 0x8000));
break;
}
default :
LOG("unknown func: %d\n", func);
}
} while (!(cmd & 0x8000));
onGround = pos.y > bottom;
if (onGround) {
onGround = true;
if (s.roomBelow != 255) {
entity.room = s.roomBelow;
onGround = false;
return;
}
pos.y = bottom;
velocity.y = 0.0f;
}
onGround = pos.y > bottom;
if (onGround) {
onGround = true;
if (s.roomBelow != 255) {
entity.room = s.roomBelow;
onGround = false;
return;
}
pos.y = bottom;
velocity.y = 0.0f;
}
entity.y = (int)pos.y;
}
entity.y = (int)pos.y;
}
};

228
src/core.h
View File

@@ -10,56 +10,56 @@
#include "input.h"
#ifdef WIN32
#if defined(_MSC_VER) // Visual Studio
#define GetProcOGL(x) *(void**)&x=(void*)wglGetProcAddress(#x);
#else // GCC
#define GetProcOGL(x) x=(typeof(x))wglGetProcAddress(#x);
#endif
#if defined(_MSC_VER) // Visual Studio
#define GetProcOGL(x) *(void**)&x=(void*)wglGetProcAddress(#x);
#else // GCC
#define GetProcOGL(x) x=(typeof(x))wglGetProcAddress(#x);
#endif
// Texture
PFNGLACTIVETEXTUREPROC glActiveTexture;
PFNGLACTIVETEXTUREPROC glActiveTexture;
// Shader
PFNGLCREATEPROGRAMPROC glCreateProgram;
PFNGLDELETEPROGRAMPROC glDeleteProgram;
PFNGLLINKPROGRAMPROC glLinkProgram;
PFNGLUSEPROGRAMPROC glUseProgram;
PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
PFNGLCREATESHADERPROC glCreateShader;
PFNGLDELETESHADERPROC glDeleteShader;
PFNGLSHADERSOURCEPROC glShaderSource;
PFNGLATTACHSHADERPROC glAttachShader;
PFNGLCOMPILESHADERPROC glCompileShader;
PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
PFNGLUNIFORM1IVPROC glUniform1iv;
PFNGLUNIFORM3FVPROC glUniform3fv;
PFNGLUNIFORM4FVPROC glUniform4fv;
PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation;
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
PFNGLCREATEPROGRAMPROC glCreateProgram;
PFNGLDELETEPROGRAMPROC glDeleteProgram;
PFNGLLINKPROGRAMPROC glLinkProgram;
PFNGLUSEPROGRAMPROC glUseProgram;
PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
PFNGLCREATESHADERPROC glCreateShader;
PFNGLDELETESHADERPROC glDeleteShader;
PFNGLSHADERSOURCEPROC glShaderSource;
PFNGLATTACHSHADERPROC glAttachShader;
PFNGLCOMPILESHADERPROC glCompileShader;
PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
PFNGLUNIFORM1IVPROC glUniform1iv;
PFNGLUNIFORM3FVPROC glUniform3fv;
PFNGLUNIFORM4FVPROC glUniform4fv;
PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation;
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
// Mesh
PFNGLGENBUFFERSARBPROC glGenBuffers;
PFNGLDELETEBUFFERSARBPROC glDeleteBuffers;
PFNGLBINDBUFFERARBPROC glBindBuffer;
PFNGLBUFFERDATAARBPROC glBufferData;
PFNGLGENBUFFERSARBPROC glGenBuffers;
PFNGLDELETEBUFFERSARBPROC glDeleteBuffers;
PFNGLBINDBUFFERARBPROC glBindBuffer;
PFNGLBUFFERDATAARBPROC glBufferData;
#endif
namespace Core {
int width, height;
float deltaTime;
mat4 mView, mProj, mViewProj, mModel;
vec3 viewPos;
vec3 lightPos;
vec4 lightColor;
vec3 ambient;
vec4 color;
int width, height;
float deltaTime;
mat4 mView, mProj, mViewProj, mModel;
vec3 viewPos;
vec3 lightPos;
vec4 lightColor;
vec3 ambient;
vec4 color;
struct {
int dips;
int tris;
} stats;
struct {
int dips;
int tris;
} stats;
}
#include "texture.h"
@@ -71,87 +71,87 @@ enum BlendMode { bmNone, bmAlpha, bmAdd, bmMultiply, bmScreen };
namespace Core {
void init() {
GetProcOGL(glActiveTexture);
void init() {
GetProcOGL(glActiveTexture);
GetProcOGL(glCreateProgram);
GetProcOGL(glDeleteProgram);
GetProcOGL(glLinkProgram);
GetProcOGL(glUseProgram);
GetProcOGL(glGetProgramInfoLog);
GetProcOGL(glCreateShader);
GetProcOGL(glDeleteShader);
GetProcOGL(glShaderSource);
GetProcOGL(glAttachShader);
GetProcOGL(glCompileShader);
GetProcOGL(glGetShaderInfoLog);
GetProcOGL(glGetUniformLocation);
GetProcOGL(glUniform1iv);
GetProcOGL(glUniform3fv);
GetProcOGL(glUniform4fv);
GetProcOGL(glUniformMatrix4fv);
GetProcOGL(glBindAttribLocation);
GetProcOGL(glEnableVertexAttribArray);
GetProcOGL(glDisableVertexAttribArray);
GetProcOGL(glVertexAttribPointer);
GetProcOGL(glCreateProgram);
GetProcOGL(glDeleteProgram);
GetProcOGL(glLinkProgram);
GetProcOGL(glUseProgram);
GetProcOGL(glGetProgramInfoLog);
GetProcOGL(glCreateShader);
GetProcOGL(glDeleteShader);
GetProcOGL(glShaderSource);
GetProcOGL(glAttachShader);
GetProcOGL(glCompileShader);
GetProcOGL(glGetShaderInfoLog);
GetProcOGL(glGetUniformLocation);
GetProcOGL(glUniform1iv);
GetProcOGL(glUniform3fv);
GetProcOGL(glUniform4fv);
GetProcOGL(glUniformMatrix4fv);
GetProcOGL(glBindAttribLocation);
GetProcOGL(glEnableVertexAttribArray);
GetProcOGL(glDisableVertexAttribArray);
GetProcOGL(glVertexAttribPointer);
GetProcOGL(glGenBuffers);
GetProcOGL(glDeleteBuffers);
GetProcOGL(glBindBuffer);
GetProcOGL(glBufferData);
}
GetProcOGL(glGenBuffers);
GetProcOGL(glDeleteBuffers);
GetProcOGL(glBindBuffer);
GetProcOGL(glBufferData);
}
void free() {
//
}
void free() {
//
}
void clear(const vec4 &color) {
glClearColor(color.x, color.y, color.z, color.w);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void clear(const vec4 &color) {
glClearColor(color.x, color.y, color.z, color.w);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void setViewport(int x, int y, int width, int height) {
glViewport(x, y, width, height);
}
void setViewport(int x, int y, int width, int height) {
glViewport(x, y, width, height);
}
void setCulling(CullMode mode) {
switch (mode) {
case cfNone :
glDisable(GL_CULL_FACE);
case cfBack :
glCullFace(GL_BACK);
break;
case cfFront :
glCullFace(GL_FRONT);
break;
}
void setCulling(CullMode mode) {
switch (mode) {
case cfNone :
glDisable(GL_CULL_FACE);
case cfBack :
glCullFace(GL_BACK);
break;
case cfFront :
glCullFace(GL_FRONT);
break;
}
if (mode != bmNone)
glEnable(GL_CULL_FACE);
}
if (mode != bmNone)
glEnable(GL_CULL_FACE);
}
void setBlending(BlendMode mode) {
switch (mode) {
case bmNone :
glDisable(GL_BLEND);
break;
case bmAlpha :
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
case bmAdd :
glBlendFunc(GL_ONE, GL_ONE);
break;
case bmMultiply :
glBlendFunc(GL_DST_COLOR, GL_ZERO);
break;
case bmScreen :
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
break;
}
void setBlending(BlendMode mode) {
switch (mode) {
case bmNone :
glDisable(GL_BLEND);
break;
case bmAlpha :
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
case bmAdd :
glBlendFunc(GL_ONE, GL_ONE);
break;
case bmMultiply :
glBlendFunc(GL_DST_COLOR, GL_ZERO);
break;
case bmScreen :
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
break;
}
if (mode != bmNone)
glEnable(GL_BLEND);
}
if (mode != bmNone)
glEnable(GL_BLEND);
}
}
#endif

170
src/debug.h
View File

@@ -5,109 +5,109 @@
namespace Debug {
namespace Draw {
namespace Draw {
void begin() {
glMatrixMode(GL_PROJECTION);
glLoadMatrixf((GLfloat*)&Core::mProj);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glLoadMatrixf((GLfloat*)&Core::mView);
void begin() {
glMatrixMode(GL_PROJECTION);
glLoadMatrixf((GLfloat*)&Core::mProj);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glLoadMatrixf((GLfloat*)&Core::mView);
glLineWidth(3);
glPointSize(32);
glLineWidth(3);
glPointSize(32);
glUseProgram(0);
}
glUseProgram(0);
}
void end() {
//
}
void end() {
//
}
void box(const vec3 &min, const vec3 &max) {
glBegin(GL_LINES);
glVertex3f(min.x, min.y, min.z);
glVertex3f(max.x, min.y, min.z);
glVertex3f(min.x, max.y, min.z);
glVertex3f(max.x, max.y, min.z);
void box(const vec3 &min, const vec3 &max) {
glBegin(GL_LINES);
glVertex3f(min.x, min.y, min.z);
glVertex3f(max.x, min.y, min.z);
glVertex3f(min.x, max.y, min.z);
glVertex3f(max.x, max.y, min.z);
glVertex3f(min.x, min.y, max.z);
glVertex3f(max.x, min.y, max.z);
glVertex3f(min.x, max.y, max.z);
glVertex3f(max.x, max.y, max.z);
glVertex3f(min.x, min.y, max.z);
glVertex3f(max.x, min.y, max.z);
glVertex3f(min.x, max.y, max.z);
glVertex3f(max.x, max.y, max.z);
glVertex3f(min.x, min.y, min.z);
glVertex3f(min.x, min.y, max.z);
glVertex3f(min.x, max.y, min.z);
glVertex3f(min.x, max.y, max.z);
glVertex3f(min.x, min.y, min.z);
glVertex3f(min.x, min.y, max.z);
glVertex3f(min.x, max.y, min.z);
glVertex3f(min.x, max.y, max.z);
glVertex3f(max.x, min.y, min.z);
glVertex3f(max.x, min.y, max.z);
glVertex3f(max.x, max.y, min.z);
glVertex3f(max.x, max.y, max.z);
glVertex3f(max.x, min.y, min.z);
glVertex3f(max.x, min.y, max.z);
glVertex3f(max.x, max.y, min.z);
glVertex3f(max.x, max.y, max.z);
glVertex3f(min.x, min.y, min.z);
glVertex3f(min.x, max.y, min.z);
glVertex3f(min.x, min.y, min.z);
glVertex3f(min.x, max.y, min.z);
glVertex3f(max.x, min.y, min.z);
glVertex3f(max.x, max.y, min.z);
glVertex3f(min.x, min.y, min.z);
glVertex3f(min.x, max.y, min.z);
glVertex3f(max.x, min.y, min.z);
glVertex3f(max.x, max.y, min.z);
glVertex3f(min.x, min.y, min.z);
glVertex3f(min.x, max.y, min.z);
glVertex3f(max.x, min.y, max.z);
glVertex3f(max.x, max.y, max.z);
glVertex3f(min.x, min.y, max.z);
glVertex3f(min.x, max.y, max.z);
glEnd();
}
glVertex3f(max.x, min.y, max.z);
glVertex3f(max.x, max.y, max.z);
glVertex3f(min.x, min.y, max.z);
glVertex3f(min.x, max.y, max.z);
glEnd();
}
void sphere(const vec3 &center, const float radius, const vec4 &color) {
const float k = PI * 2.0f / 18.0f;
void sphere(const vec3 &center, const float radius, const vec4 &color) {
const float k = PI * 2.0f / 18.0f;
glColor4fv((GLfloat*)&color);
for (int j = 0; j < 3; j++) {
glBegin(GL_LINE_STRIP);
for (int i = 0; i < 19; i++) {
vec3 p = vec3(sinf(i * k), cosf(i * k), 0.0f) * radius;
glVertex3f(p[j] + center.x, p[(j + 1) % 3] + center.y, p[(j + 2) % 3] + center.z);
}
glEnd();
}
}
glColor4fv((GLfloat*)&color);
for (int j = 0; j < 3; j++) {
glBegin(GL_LINE_STRIP);
for (int i = 0; i < 19; i++) {
vec3 p = vec3(sinf(i * k), cosf(i * k), 0.0f) * radius;
glVertex3f(p[j] + center.x, p[(j + 1) % 3] + center.y, p[(j + 2) % 3] + center.z);
}
glEnd();
}
}
void mesh(vec3 *vertices, Index *indices, int iCount) {
glBegin(GL_LINES);
for (int i = 0; i < iCount; i += 3) {
vec3 &a = vertices[indices[i + 0]];
vec3 &b = vertices[indices[i + 1]];
vec3 &c = vertices[indices[i + 2]];
glVertex3fv((GLfloat*)&a);
glVertex3fv((GLfloat*)&b);
void mesh(vec3 *vertices, Index *indices, int iCount) {
glBegin(GL_LINES);
for (int i = 0; i < iCount; i += 3) {
vec3 &a = vertices[indices[i + 0]];
vec3 &b = vertices[indices[i + 1]];
vec3 &c = vertices[indices[i + 2]];
glVertex3fv((GLfloat*)&a);
glVertex3fv((GLfloat*)&b);
glVertex3fv((GLfloat*)&b);
glVertex3fv((GLfloat*)&c);
glVertex3fv((GLfloat*)&b);
glVertex3fv((GLfloat*)&c);
glVertex3fv((GLfloat*)&c);
glVertex3fv((GLfloat*)&a);
}
glEnd();
}
glVertex3fv((GLfloat*)&c);
glVertex3fv((GLfloat*)&a);
}
glEnd();
}
void axes(float size) {
glBegin(GL_LINES);
glColor3f(1, 0, 0); glVertex3f(0, 0, 0); glVertex3f(size, 0, 0);
glColor3f(0, 1, 0); glVertex3f(0, 0, 0); glVertex3f( 0, size, 0);
glColor3f(0, 0, 1); glVertex3f(0, 0, 0); glVertex3f( 0, 0, size);
glEnd();
}
void axes(float size) {
glBegin(GL_LINES);
glColor3f(1, 0, 0); glVertex3f(0, 0, 0); glVertex3f(size, 0, 0);
glColor3f(0, 1, 0); glVertex3f(0, 0, 0); glVertex3f( 0, size, 0);
glColor3f(0, 0, 1); glVertex3f(0, 0, 0); glVertex3f( 0, 0, size);
glEnd();
}
void point(const vec3 &p, const vec4 &color) {
glColor4fv((GLfloat*)&color);
glBegin(GL_POINTS);
glVertex3fv((GLfloat*)&p);
glEnd();
}
}
void point(const vec3 &p, const vec4 &color) {
glColor4fv((GLfloat*)&color);
glBegin(GL_POINTS);
glVertex3fv((GLfloat*)&p);
glEnd();
}
}
}
#endif

1290
src/format.h
View File

File diff suppressed because it is too large Load Diff

36
src/game.h
View File

@@ -8,30 +8,30 @@
#include "level.h"
namespace Game {
Level *level;
Level *level;
void init() {
Core::init();
level = new Level("data\\GYM.PHD");
}
void init() {
Core::init();
level = new Level("data\\GYM.PHD");
}
void free() {
delete level;
void free() {
delete level;
Core::free();
}
Core::free();
}
void update() {
level->update();
}
void update() {
level->update();
}
void render() {
Core::clear(vec4(0.0f));
Core::setViewport(0, 0, Core::width, Core::height);
Core::setBlending(bmAlpha);
void render() {
Core::clear(vec4(0.0f));
Core::setViewport(0, 0, Core::width, Core::height);
Core::setBlending(bmAlpha);
level->render();
}
level->render();
}
}
#endif

128
src/input.h
View File

@@ -3,81 +3,81 @@
#include "utils.h"
enum InputKey { ikNone,
// keyboard
ikLeft, ikRight, ikUp, ikDown, ikSpace, ikEnter, ikEscape, ikShift, ikCtrl, ikAlt,
ik0, ik1, ik2, ik3, ik4, ik5, ik6, ik7, ik8, ik9,
ikA, ikB, ikC, ikD, ikE, ikF, ikG, ikH, ikI, ikJ, ikK, ikL, ikM,
ikN, ikO, ikP, ikQ, ikR, ikS, ikT, ikU, ikV, ikW, ikX, ikY, ikZ,
// mouse
ikMouseL, ikMouseR, ikMouseM,
// touch
ikTouchA, ikTouchB,
// gamepad
ikJoyA, ikJoyB, ikJoyX, ikJoyY, ikJoyLB, ikJoyRB, ikJoyL, ikJoyR, ikJoySelect, ikJoyStart, ikJoyLT, ikJoyRT, ikJoyDP,
ikMAX };
enum InputKey { ikNone,
// keyboard
ikLeft, ikRight, ikUp, ikDown, ikSpace, ikEnter, ikEscape, ikShift, ikCtrl, ikAlt,
ik0, ik1, ik2, ik3, ik4, ik5, ik6, ik7, ik8, ik9,
ikA, ikB, ikC, ikD, ikE, ikF, ikG, ikH, ikI, ikJ, ikK, ikL, ikM,
ikN, ikO, ikP, ikQ, ikR, ikS, ikT, ikU, ikV, ikW, ikX, ikY, ikZ,
// mouse
ikMouseL, ikMouseR, ikMouseM,
// touch
ikTouchA, ikTouchB,
// gamepad
ikJoyA, ikJoyB, ikJoyX, ikJoyY, ikJoyLB, ikJoyRB, ikJoyL, ikJoyR, ikJoySelect, ikJoyStart, ikJoyLT, ikJoyRT, ikJoyDP,
ikMAX };
namespace Input {
bool down[ikMAX];
bool down[ikMAX];
struct {
vec2 pos;
struct {
vec2 L, R, M;
} start;
} mouse;
struct {
vec2 pos;
struct {
vec2 L, R, M;
} start;
} mouse;
struct {
vec2 L, R;
float LT, RT, DP;
} joy;
struct {
vec2 L, R;
float LT, RT, DP;
} joy;
struct {
vec2 A, B;
struct {
vec2 A, B;
struct {
vec2 A, B;
} start;
} touch;
struct {
vec2 A, B;
} start;
} touch;
void reset() {
memset(down, 0, sizeof(down));
memset(&mouse, 0, sizeof(mouse));
memset(&joy, 0, sizeof(joy));
memset(&touch, 0, sizeof(touch));
}
void reset() {
memset(down, 0, sizeof(down));
memset(&mouse, 0, sizeof(mouse));
memset(&joy, 0, sizeof(joy));
memset(&touch, 0, sizeof(touch));
}
void setDown(InputKey key, bool value) {
if (down[key] == value)
return;
if (value)
switch (key) {
case ikMouseL : mouse.start.L = mouse.pos; break;
case ikMouseR : mouse.start.R = mouse.pos; break;
case ikMouseM : mouse.start.M = mouse.pos; break;
case ikTouchA : touch.start.A = touch.A; break;
case ikTouchB : touch.start.B = touch.B; break;
}
void setDown(InputKey key, bool value) {
if (down[key] == value)
return;
down[key] = value;
}
if (value)
switch (key) {
case ikMouseL : mouse.start.L = mouse.pos; break;
case ikMouseR : mouse.start.R = mouse.pos; break;
case ikMouseM : mouse.start.M = mouse.pos; break;
case ikTouchA : touch.start.A = touch.A; break;
case ikTouchB : touch.start.B = touch.B; break;
}
void setPos(InputKey key, const vec2 &pos) {
switch (key) {
case ikMouseL :
case ikMouseR :
case ikMouseM : mouse.pos = pos; break;
case ikJoyL : joy.L = pos; break;
case ikJoyR : joy.R = pos; break;
case ikJoyLT : joy.LT = pos.x; break;
case ikJoyRT : joy.RT = pos.x; break;
case ikJoyDP : joy.DP = pos.x; break;
case ikTouchA : touch.A = pos; break;
case ikTouchB : touch.B = pos; break;
}
}
down[key] = value;
}
void setPos(InputKey key, const vec2 &pos) {
switch (key) {
case ikMouseL :
case ikMouseR :
case ikMouseM : mouse.pos = pos; break;
case ikJoyL : joy.L = pos; break;
case ikJoyR : joy.R = pos; break;
case ikJoyLT : joy.LT = pos.x; break;
case ikJoyRT : joy.RT = pos.x; break;
case ikJoyDP : joy.DP = pos.x; break;
case ikTouchA : touch.A = pos; break;
case ikTouchB : touch.B = pos; break;
}
}
}
#endif

1961
src/level.h
View File

File diff suppressed because it is too large Load Diff

74
src/mesh.h
View File

@@ -6,55 +6,55 @@
typedef unsigned short Index;
struct Vertex {
short3 coord;
short2 texCoord;
short4 normal;
ubyte4 color;
short3 coord;
short2 texCoord;
short4 normal;
ubyte4 color;
};
struct MeshRange {
int iStart;
int iCount;
int vStart;
int iStart;
int iCount;
int vStart;
};
struct Mesh {
GLuint ID[2];
int iCount;
int vCount;
GLuint ID[2];
int iCount;
int vCount;
Mesh(Index *indices, int iCount, Vertex *vertices, int vCount) : iCount(iCount), vCount(vCount) {
glGenBuffers(2, ID);
bind();
glBufferData(GL_ELEMENT_ARRAY_BUFFER, iCount * sizeof(Index), indices, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, vCount * sizeof(Vertex), vertices, GL_STATIC_DRAW);
}
Mesh(Index *indices, int iCount, Vertex *vertices, int vCount) : iCount(iCount), vCount(vCount) {
glGenBuffers(2, ID);
bind();
glBufferData(GL_ELEMENT_ARRAY_BUFFER, iCount * sizeof(Index), indices, GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, vCount * sizeof(Vertex), vertices, GL_STATIC_DRAW);
}
virtual ~Mesh() {
glDeleteBuffers(2, ID);
}
virtual ~Mesh() {
glDeleteBuffers(2, ID);
}
void bind() {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ID[0]);
glBindBuffer(GL_ARRAY_BUFFER, ID[1]);
void bind() {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ID[0]);
glBindBuffer(GL_ARRAY_BUFFER, ID[1]);
glEnableVertexAttribArray(aCoord);
glEnableVertexAttribArray(aTexCoord);
glEnableVertexAttribArray(aNormal);
glEnableVertexAttribArray(aColor);
}
glEnableVertexAttribArray(aCoord);
glEnableVertexAttribArray(aTexCoord);
glEnableVertexAttribArray(aNormal);
glEnableVertexAttribArray(aColor);
}
void render(const MeshRange &range) {
Vertex *v = (Vertex*)(range.vStart * sizeof(Vertex));
glVertexAttribPointer(aCoord, 3, GL_SHORT, false, sizeof(Vertex), &v->coord);
glVertexAttribPointer(aTexCoord, 2, GL_SHORT, true, sizeof(Vertex), &v->texCoord);
glVertexAttribPointer(aNormal, 4, GL_SHORT, true, sizeof(Vertex), &v->normal);
glVertexAttribPointer(aColor, 4, GL_UNSIGNED_BYTE, true, sizeof(Vertex), &v->color);
glDrawElements(GL_TRIANGLES, range.iCount, GL_UNSIGNED_SHORT, (GLvoid*)(range.iStart * sizeof(Index)));
void render(const MeshRange &range) {
Vertex *v = (Vertex*)(range.vStart * sizeof(Vertex));
glVertexAttribPointer(aCoord, 3, GL_SHORT, false, sizeof(Vertex), &v->coord);
glVertexAttribPointer(aTexCoord, 2, GL_SHORT, true, sizeof(Vertex), &v->texCoord);
glVertexAttribPointer(aNormal, 4, GL_SHORT, true, sizeof(Vertex), &v->normal);
glVertexAttribPointer(aColor, 4, GL_UNSIGNED_BYTE, true, sizeof(Vertex), &v->color);
glDrawElements(GL_TRIANGLES, range.iCount, GL_UNSIGNED_SHORT, (GLvoid*)(range.iStart * sizeof(Index)));
Core::stats.dips++;
Core::stats.tris += range.iCount / 3;
}
Core::stats.dips++;
Core::stats.tris += range.iCount / 3;
}
};
#endif

116
src/shader.h
View File

@@ -3,80 +3,80 @@
#include "core.h"
enum AttribType { aCoord, aTexCoord, aNormal, aColor, aMAX };
enum SamplerType { sDiffuse, sMAX };
enum UniformType { uViewProj, uModel, uColor, uAmbient, uLightPos, uLightColor, uMAX };
enum AttribType { aCoord, aTexCoord, aNormal, aColor, aMAX };
enum SamplerType { sDiffuse, sMAX };
enum UniformType { uViewProj, uModel, uColor, uAmbient, uLightPos, uLightColor, uMAX };
const char *AttribName[aMAX] = { "aCoord", "aTexCoord", "aNormal", "aColor" };
const char *SamplerName[sMAX] = { "sDiffuse" };
const char *UniformName[uMAX] = { "uViewProj", "uModel", "uColor", "uAmbient", "uLightPos", "uLightColor" };
const char *AttribName[aMAX] = { "aCoord", "aTexCoord", "aNormal", "aColor" };
const char *SamplerName[sMAX] = { "sDiffuse" };
const char *UniformName[uMAX] = { "uViewProj", "uModel", "uColor", "uAmbient", "uLightPos", "uLightColor" };
struct Shader {
GLuint ID;
GLint uID[uMAX];
GLuint ID;
GLint uID[uMAX];
Shader(const char *text) {
#define GLSL_DEFINE "#version 110\n"
Shader(const char *text) {
#define GLSL_DEFINE "#version 110\n"
const int type[2] = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER };
const char *code[2][2] = {
{ GLSL_DEFINE "#define VERTEX\n", text },
{ GLSL_DEFINE "#define FRAGMENT\n", text }
};
const int type[2] = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER };
const char *code[2][2] = {
{ GLSL_DEFINE "#define VERTEX\n", text },
{ GLSL_DEFINE "#define FRAGMENT\n", text }
};
GLchar info[256];
GLchar info[256];
ID = glCreateProgram();
for (int i = 0; i < 2; i++) {
GLuint obj = glCreateShader(type[i]);
glShaderSource(obj, 2, code[i], NULL);
glCompileShader(obj);
glGetShaderInfoLog(obj, sizeof(info), NULL, info);
if (info[0]) LOG("! shader: %s\n", info);
ID = glCreateProgram();
for (int i = 0; i < 2; i++) {
GLuint obj = glCreateShader(type[i]);
glShaderSource(obj, 2, code[i], NULL);
glCompileShader(obj);
glAttachShader(ID, obj);
glDeleteShader(obj);
}
glGetShaderInfoLog(obj, sizeof(info), NULL, info);
if (info[0]) LOG("! shader: %s\n", info);
for (int at = 0; at < aMAX; at++)
glBindAttribLocation(ID, at, AttribName[at]);
glAttachShader(ID, obj);
glDeleteShader(obj);
}
glLinkProgram(ID);
for (int at = 0; at < aMAX; at++)
glBindAttribLocation(ID, at, AttribName[at]);
glGetProgramInfoLog(ID, sizeof(info), NULL, info);
if (info[0]) LOG("! program: %s\n", info);
glLinkProgram(ID);
bind();
for (int st = 0; st < sMAX; st++)
glUniform1iv(glGetUniformLocation(ID, (GLchar*)SamplerName[st]), 1, &st);
for (int ut = 0; ut < uMAX; ut++)
uID[ut] = glGetUniformLocation(ID, (GLchar*)UniformName[ut]);
}
virtual ~Shader() {
glDeleteProgram(ID);
}
glGetProgramInfoLog(ID, sizeof(info), NULL, info);
if (info[0]) LOG("! program: %s\n", info);
void bind() {
glUseProgram(ID);
}
bind();
for (int st = 0; st < sMAX; st++)
glUniform1iv(glGetUniformLocation(ID, (GLchar*)SamplerName[st]), 1, &st);
void setParam(UniformType uType, const vec3 &value, int count = 1) {
if (uID[uType] != -1)
glUniform3fv(uID[uType], count, (GLfloat*)&value);
}
for (int ut = 0; ut < uMAX; ut++)
uID[ut] = glGetUniformLocation(ID, (GLchar*)UniformName[ut]);
}
void setParam(UniformType uType, const vec4 &value, int count = 1) {
if (uID[uType] != -1)
glUniform4fv(uID[uType], count, (GLfloat*)&value);
}
virtual ~Shader() {
glDeleteProgram(ID);
}
void setParam(UniformType uType, const mat4 &value, int count = 1) {
if (uID[uType] != -1)
glUniformMatrix4fv(uID[uType], count, false, (GLfloat*)&value);
}
void bind() {
glUseProgram(ID);
}
void setParam(UniformType uType, const vec3 &value, int count = 1) {
if (uID[uType] != -1)
glUniform3fv(uID[uType], count, (GLfloat*)&value);
}
void setParam(UniformType uType, const vec4 &value, int count = 1) {
if (uID[uType] != -1)
glUniform4fv(uID[uType], count, (GLfloat*)&value);
}
void setParam(UniformType uType, const mat4 &value, int count = 1) {
if (uID[uType] != -1)
glUniformMatrix4fv(uID[uType], count, false, (GLfloat*)&value);
}
};
#endif

32
src/texture.h
View File

@@ -4,27 +4,27 @@
#include "core.h"
struct Texture {
GLuint ID;
int width, height;
GLuint ID;
int width, height;
Texture(int width, int height, int format, void *data) : width(width), height(height) {
glGenTextures(1, &ID);
bind(0);
Texture(int width, int height, int format, void *data) : width(width), height(height) {
glGenTextures(1, &ID);
bind(0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
}
virtual ~Texture() {
glDeleteTextures(1, &ID);
}
virtual ~Texture() {
glDeleteTextures(1, &ID);
}
void bind(int sampler) {
glActiveTexture(GL_TEXTURE0 + sampler);
glBindTexture(GL_TEXTURE_2D, ID);
}
void bind(int sampler) {
glActiveTexture(GL_TEXTURE0 + sampler);
glBindTexture(GL_TEXTURE_2D, ID);
}
};
#endif

26
src/utils.h
View File

@@ -131,23 +131,23 @@ struct quat {
w = cosf(angle);
}
quat quat::operator - () const {
quat operator - () const {
return quat(-x, -y, -z, -w);
}
quat quat::operator + (const quat &q) const {
quat operator + (const quat &q) const {
return quat(x + q.x, y + q.y, z + q.z, w + q.w);
}
quat quat::operator - (const quat &q) const {
quat operator - (const quat &q) const {
return quat(x - q.x, y - q.y, z - q.z, w - q.w);
}
quat quat::operator * (const float s) const {
quat operator * (const float s) const {
return quat(x * s, y * s, z * s, w * s);
}
quat quat::operator * (const quat &q) const {
quat operator * (const quat &q) const {
return quat(w * q.x + x * q.w + y * q.z - z * q.y,
w * q.y + y * q.w + z * q.x - x * q.z,
w * q.z + z * q.w + x * q.y - y * q.x,
@@ -166,19 +166,19 @@ struct quat {
return sqrtf(length2());
}
void quat::normalize() {
void normalize() {
*this = normal();
}
quat quat::normal() const {
quat normal() const {
return *this * (1.0f / length());
}
quat quat::conjugate() const {
quat conjugate() const {
return quat(-x, -y, -z, w);
}
quat quat::inverse() const {
quat inverse() const {
return conjugate() * (1.0f / length2());
}
@@ -382,7 +382,7 @@ struct mat4 {
return r;
}
quat mat4::getRot() const {
quat getRot() const {
float t, s;
t = 1.0f + e00 + e11 + e22;
if (t > EPS) {
@@ -402,7 +402,7 @@ struct mat4 {
}
}
void mat4::setRot(const quat &rot) {
void setRot(const quat &rot) {
float sx = rot.x * rot.x,
sy = rot.y * rot.y,
sz = rot.z * rot.z,
@@ -430,11 +430,11 @@ struct mat4 {
e12 = (t1 - t2) * inv;
}
vec3 mat4::getPos() const {
vec3 getPos() const {
return offset.xyz;
}
void mat4::setPos(const vec3 &pos) {
void setPos(const vec3 &pos) {
offset.xyz = pos;
}
};

348
src/win/main.cpp
View File

@@ -1,246 +1,246 @@
#ifdef _DEBUG
#include "crtdbg.h"
#include "crtdbg.h"
#endif
#include "game.h"
DWORD getTime() {
#ifdef DEBUG
LARGE_INTEGER Freq, Count;
QueryPerformanceFrequency(&Freq);
QueryPerformanceCounter(&Count);
return (DWORD)(Count.QuadPart * 1000L / Freq.QuadPart);
LARGE_INTEGER Freq, Count;
QueryPerformanceFrequency(&Freq);
QueryPerformanceCounter(&Count);
return (DWORD)(Count.QuadPart * 1000L / Freq.QuadPart);
#else
timeBeginPeriod(0);
return timeGetTime();
timeBeginPeriod(0);
return timeGetTime();
#endif
}
InputKey keyToInputKey(int code) {
int codes[] = {
VK_LEFT, VK_RIGHT, VK_UP, VK_DOWN, VK_SPACE, VK_RETURN, VK_ESCAPE, VK_SHIFT, VK_CONTROL, VK_MENU,
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
};
int codes[] = {
VK_LEFT, VK_RIGHT, VK_UP, VK_DOWN, VK_SPACE, VK_RETURN, VK_ESCAPE, VK_SHIFT, VK_CONTROL, VK_MENU,
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
};
for (int i = 0; i < sizeof(codes) / sizeof(codes[0]); i++)
if (codes[i] == code)
return (InputKey)(ikLeft + i);
return ikNone;
for (int i = 0; i < sizeof(codes) / sizeof(codes[0]); i++)
if (codes[i] == code)
return (InputKey)(ikLeft + i);
return ikNone;
}
InputKey mouseToInputKey(int msg) {
return (msg >= WM_LBUTTONDOWN || msg <= WM_LBUTTONDBLCLK) ? ikMouseL :
(msg >= WM_RBUTTONDOWN || msg <= WM_RBUTTONDBLCLK) ? ikMouseR : ikMouseM;
return (msg >= WM_LBUTTONDOWN || msg <= WM_LBUTTONDBLCLK) ? ikMouseL :
(msg >= WM_RBUTTONDOWN || msg <= WM_RBUTTONDBLCLK) ? ikMouseR : ikMouseM;
}
#define JOY_DEAD_ZONE_STICK 0.3f
#define JOY_DEAD_ZONE_TRIGGER 0.01f
#define JOY_DEAD_ZONE_STICK 0.3f
#define JOY_DEAD_ZONE_TRIGGER 0.01f
bool joyReady;
void joyInit() {
JOYINFOEX info;
info.dwSize = sizeof(info);
info.dwFlags = JOY_RETURNALL;
joyReady = joyGetPosEx(0, &info) == JOYERR_NOERROR;
JOYINFOEX info;
info.dwSize = sizeof(info);
info.dwFlags = JOY_RETURNALL;
joyReady = joyGetPosEx(0, &info) == JOYERR_NOERROR;
}
void joyFree() {
joyReady = false;
memset(&Input::joy, 0, sizeof(Input::joy));
for (int ik = ikJoyA; ik <= ikJoyDP; ik++)
Input::down[ik] = false;
joyReady = false;
memset(&Input::joy, 0, sizeof(Input::joy));
for (int ik = ikJoyA; ik <= ikJoyDP; ik++)
Input::down[ik] = false;
}
float joyAxis(int x, int xMin, int xMax) {
return ((x - xMin) / (float)(xMax - xMin)) * 2.0f - 1.0f;
return ((x - xMin) / (float)(xMax - xMin)) * 2.0f - 1.0f;
}
vec2 joyDir(float ax, float ay) {
vec2 dir = vec2(ax, ay);
float dist = min(1.0f, dir.length());
if (dist < JOY_DEAD_ZONE_STICK) dist = 0;
vec2 dir = vec2(ax, ay);
float dist = min(1.0f, dir.length());
if (dist < JOY_DEAD_ZONE_STICK) dist = 0;
return dir.normal() * dist;
return dir.normal() * dist;
}
void joyUpdate() {
if (!joyReady) return;
if (!joyReady) return;
JOYINFOEX info;
info.dwSize = sizeof(info);
info.dwFlags = JOY_RETURNALL;
JOYINFOEX info;
info.dwSize = sizeof(info);
info.dwFlags = JOY_RETURNALL;
if (joyGetPosEx(0, &info) == JOYERR_NOERROR) {
JOYCAPS caps;
joyGetDevCaps(0, &caps, sizeof(caps));
if (joyGetPosEx(0, &info) == JOYERR_NOERROR) {
JOYCAPS caps;
joyGetDevCaps(0, &caps, sizeof(caps));
Input::setPos(ikJoyL, joyDir(joyAxis(info.dwXpos, caps.wXmin, caps.wXmax),
joyAxis(info.dwYpos, caps.wYmin, caps.wYmax)));
Input::setPos(ikJoyL, joyDir(joyAxis(info.dwXpos, caps.wXmin, caps.wXmax),
joyAxis(info.dwYpos, caps.wYmin, caps.wYmax)));
if ((caps.wCaps & JOYCAPS_HASR) && (caps.wCaps & JOYCAPS_HASU))
Input::setPos(ikJoyR, joyDir(joyAxis(info.dwUpos, caps.wUmin, caps.wUmax),
joyAxis(info.dwRpos, caps.wRmin, caps.wRmax)));
if ((caps.wCaps & JOYCAPS_HASR) && (caps.wCaps & JOYCAPS_HASU))
Input::setPos(ikJoyR, joyDir(joyAxis(info.dwUpos, caps.wUmin, caps.wUmax),
joyAxis(info.dwRpos, caps.wRmin, caps.wRmax)));
if (caps.wCaps & JOYCAPS_HASZ) {
float z = joyAxis(info.dwZpos, caps.wZmin, caps.wZmax);
if (fabsf(z) > JOY_DEAD_ZONE_TRIGGER)
Input::setPos(z > 0.0f ? ikJoyLT : ikJoyRT, vec2(fabsf(z), 0.0f));
}
if (caps.wCaps & JOYCAPS_HASPOV && info.dwPOV != JOY_POVCENTERED)
Input::setPos(ikJoyDP, vec2((float)(1 + info.dwPOV / 4500), 0));
if (caps.wCaps & JOYCAPS_HASZ) {
float z = joyAxis(info.dwZpos, caps.wZmin, caps.wZmax);
if (fabsf(z) > JOY_DEAD_ZONE_TRIGGER)
Input::setPos(z > 0.0f ? ikJoyLT : ikJoyRT, vec2(fabsf(z), 0.0f));
}
for (int i = 0; i < 10; i++)
Input::setDown((InputKey)(ikJoyA + i), (info.dwButtons & (1 << i)) > 0);
} else
joyFree();
if (caps.wCaps & JOYCAPS_HASPOV && info.dwPOV != JOY_POVCENTERED)
Input::setPos(ikJoyDP, vec2((float)(1 + info.dwPOV / 4500), 0));
for (int i = 0; i < 10; i++)
Input::setDown((InputKey)(ikJoyA + i), (info.dwButtons & (1 << i)) > 0);
} else
joyFree();
}
static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
switch (msg) {
case WM_ACTIVATE :
Input::reset();
break;
// keyboard
case WM_KEYDOWN :
case WM_KEYUP :
case WM_SYSKEYDOWN :
case WM_SYSKEYUP :
Input::setDown(keyToInputKey(wParam), msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN);
break;
// mouse
case WM_LBUTTONDOWN :
case WM_LBUTTONUP :
case WM_LBUTTONDBLCLK :
case WM_RBUTTONDOWN :
case WM_RBUTTONUP :
case WM_RBUTTONDBLCLK :
case WM_MBUTTONDOWN :
case WM_MBUTTONUP :
case WM_MBUTTONDBLCLK : {
InputKey key = mouseToInputKey(msg);
Input::setPos(key, vec2((float)(short)LOWORD(lParam), (float)(short)HIWORD(lParam)));
bool down = msg != WM_LBUTTONUP && msg != WM_RBUTTONUP && msg != WM_MBUTTONUP;
Input::setDown(key, down);
if (down)
SetCapture(hWnd);
else
ReleaseCapture();
break;
}
case WM_MOUSEMOVE :
Input::setPos(ikMouseL, vec2((float)(short)LOWORD(lParam), (float)(short)HIWORD(lParam)));
break;
// gamepad
case WM_DEVICECHANGE :
joyInit();
return 1;
// touch
// ...
case WM_SIZE :
Core::width = LOWORD(lParam);
Core::height = HIWORD(lParam);
break;
case WM_DESTROY :
PostQuitMessage(0);
break;
default :
return DefWindowProc(hWnd, msg, wParam, lParam);
}
return 0;
switch (msg) {
case WM_ACTIVATE :
Input::reset();
break;
// keyboard
case WM_KEYDOWN :
case WM_KEYUP :
case WM_SYSKEYDOWN :
case WM_SYSKEYUP :
Input::setDown(keyToInputKey(wParam), msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN);
break;
// mouse
case WM_LBUTTONDOWN :
case WM_LBUTTONUP :
case WM_LBUTTONDBLCLK :
case WM_RBUTTONDOWN :
case WM_RBUTTONUP :
case WM_RBUTTONDBLCLK :
case WM_MBUTTONDOWN :
case WM_MBUTTONUP :
case WM_MBUTTONDBLCLK : {
InputKey key = mouseToInputKey(msg);
Input::setPos(key, vec2((float)(short)LOWORD(lParam), (float)(short)HIWORD(lParam)));
bool down = msg != WM_LBUTTONUP && msg != WM_RBUTTONUP && msg != WM_MBUTTONUP;
Input::setDown(key, down);
if (down)
SetCapture(hWnd);
else
ReleaseCapture();
break;
}
case WM_MOUSEMOVE :
Input::setPos(ikMouseL, vec2((float)(short)LOWORD(lParam), (float)(short)HIWORD(lParam)));
break;
// gamepad
case WM_DEVICECHANGE :
joyInit();
return 1;
// touch
// ...
case WM_SIZE :
Core::width = LOWORD(lParam);
Core::height = HIWORD(lParam);
break;
case WM_DESTROY :
PostQuitMessage(0);
break;
default :
return DefWindowProc(hWnd, msg, wParam, lParam);
}
return 0;
}
HGLRC initGL(HDC hDC) {
PIXELFORMATDESCRIPTOR pfd;
memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.cColorBits = 32;
pfd.cDepthBits = 24;
PIXELFORMATDESCRIPTOR pfd;
memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.cColorBits = 32;
pfd.cDepthBits = 24;
int format = ChoosePixelFormat(hDC, &pfd);
SetPixelFormat(hDC, format, &pfd);
HGLRC hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
return hRC;
int format = ChoosePixelFormat(hDC, &pfd);
SetPixelFormat(hDC, format, &pfd);
HGLRC hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
return hRC;
}
void freeGL(HGLRC hRC) {
wglMakeCurrent(0, 0);
wglDeleteContext(hRC);
wglMakeCurrent(0, 0);
wglDeleteContext(hRC);
}
int main() {
#ifdef _DEBUG
_CrtMemState _ms;
_CrtMemCheckpoint(&_ms);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDOUT);
_CrtMemState _ms;
_CrtMemCheckpoint(&_ms);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDOUT);
#endif
RECT r = { 0, 0, 1280, 720 };
AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, false);
RECT r = { 0, 0, 1280, 720 };
AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, false);
HWND hWnd = CreateWindow("static", "OpenLara", WS_OVERLAPPEDWINDOW, 0, 0, r.right - r.left, r.bottom - r.top, 0, 0, 0, 0);
HWND hWnd = CreateWindow("static", "OpenLara", WS_OVERLAPPEDWINDOW, 0, 0, r.right - r.left, r.bottom - r.top, 0, 0, 0, 0);
joyInit();
joyInit();
HDC hDC = GetDC(hWnd);
HGLRC hRC = initGL(hDC);
Game::init();
HDC hDC = GetDC(hWnd);
HGLRC hRC = initGL(hDC);
Game::init();
SetWindowLong(hWnd, GWL_WNDPROC, (LONG)&WndProc);
ShowWindow(hWnd, SW_SHOWDEFAULT);
SetWindowLong(hWnd, GWL_WNDPROC, (LONG)&WndProc);
ShowWindow(hWnd, SW_SHOWDEFAULT);
DWORD time, lastTime = getTime();
MSG msg;
msg.message = WM_PAINT;
DWORD fps = 0, fpsTime = getTime() + 1000;
DWORD time, lastTime = getTime();
while (msg.message != WM_QUIT)
if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
} else {
time = getTime();
if (time <= lastTime)
continue;
Core::deltaTime = (time - lastTime) * 0.001f;
lastTime = time;
MSG msg;
msg.message = WM_PAINT;
joyUpdate();
DWORD fps = 0, fpsTime = getTime() + 1000;
Core::stats.dips = 0;
Core::stats.tris = 0;
while (msg.message != WM_QUIT)
if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
} else {
time = getTime();
if (time <= lastTime)
continue;
Game::update();
Game::render();
Core::deltaTime = (time - lastTime) * 0.001f;
lastTime = time;
SwapBuffers(hDC);
joyUpdate();
if (fpsTime < getTime()) {
LOG("FPS: %d DIP: %d TRI: %d\n", fps, Core::stats.dips, Core::stats.tris);
fps = 0;
fpsTime = getTime() + 1000;
} else
fps++;
}
Game::free();
freeGL(hRC);
ReleaseDC(hWnd, hDC);
Core::stats.dips = 0;
Core::stats.tris = 0;
DestroyWindow(hWnd);
Game::update();
Game::render();
SwapBuffers(hDC);
if (fpsTime < getTime()) {
LOG("FPS: %d DIP: %d TRI: %d\n", fps, Core::stats.dips, Core::stats.tris);
fps = 0;
fpsTime = getTime() + 1000;
} else
fps++;
}
Game::free();
freeGL(hRC);
ReleaseDC(hWnd, hDC);
DestroyWindow(hWnd);
#ifdef _DEBUG
_CrtMemDumpAllObjectsSince(&_ms);
system("pause");
_CrtMemDumpAllObjectsSince(&_ms);
system("pause");
#endif
return 0;
return 0;
}