//------------------------------------------------------------------------------------------------
// zacatek 3d kresleni
//------------------------------------------------------------------------------------------------
void ddx2StartRender2D(void)
{
set_matrix_2d(SCREEN_XRES, SCREEN_YRES);
glColor4f(1, 1, 1, 1);
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_LEQUAL, 0);
specular_off();
specular_color(0, 0, 0);
}
void HORN_SCHUNCK_WARP
(
/*****************************************************/
float **f1_orig, /* in : 1st image (original resolution) */
float **f2_orig, /* in : 2nd image (original resolution) */
int nx_orig, /* in : size in x-direction (original resolution)*/
int ny_orig, /* in : size in y-direction (original resoluiton)*/
float **f1_res, /* in+out : 1st image, resampled */
float **f2_res, /* in+out : 2nd image, resampled */
float **f2_res_warp, /* in+out : 2nd image, resampled and warped */
float **du, /* in+out : x-component of flow increment */
float **dv, /* in+out : y-component of flow increment */
float **u, /* in+out : x-component of flow field */
float **v, /* in+out : y-component of flow field */
float **tmp, /* in+out : temporary aray for resampling */
int nx_fine, /* in : size in x-direction (current resolution) */
int ny_fine, /* in : size in y-direction (current resolution) */
int bx, /* in : boundary size in x-direction */
int by, /* in : boundary size in y-direction */
float hx_fine, /* in : spacing in x-direction (current resol.) */
float hy_fine, /* in : spacing in y-direction (current resol.) */
float m_alpha, /* in : smoothness weight */
float epsilon_d, /* in : diffusivity param data term */
float epsilon_s,
float w_bright_grad,
int num_iter_inner, /* in : inner solver iterations */
int num_iter_outer, /* in : outer nonlin update iterations */
float n_omega, /* in : SOR overrelaxation parameter */
float n_warp_eta, /* in : warping reduction factor between levels */
int max_rec_depth, /* in : maximum recursion depth */
int rec_depth /* in : current recursion depth */
/*****************************************************/
)
/* implements warping for the Horn and Schunck method */
{
/************************************************/
int nx_coarse,ny_coarse; /* dimensions on previous coarser grid */
float hx_coarse,hy_coarse; /* grid sizes on previous coarser grid */
/************************************************/
/* compute dimensions and grid sizes for previous coarser grid */
nx_coarse=(int)ceil(nx_orig*pow(n_warp_eta,rec_depth+1));
ny_coarse=(int)ceil(ny_orig*pow(n_warp_eta,rec_depth+1));
hx_coarse=(float)nx_orig/(float)nx_coarse;
hy_coarse=(float)ny_orig/(float)ny_coarse;
/* start at coarsest level by recursively calling the routine */
if (rec_depth<max_rec_depth)
{
HORN_SCHUNCK_WARP(f1_orig, f2_orig, nx_orig, ny_orig,
f1_res, f2_res, f2_res_warp,
du, dv, u, v, tmp,
nx_coarse, ny_coarse, bx, by, hx_coarse, hy_coarse,
m_alpha, epsilon_d,epsilon_s, w_bright_grad,
num_iter_inner,num_iter_outer, n_omega, n_warp_eta,
max_rec_depth,rec_depth+1);
}
/* ---- resample images ---------------------------------------------------- */
/* restrict original image pair to resolution of current level */
resample_2d(f1_orig,nx_orig,ny_orig,bx,by,f1_res,nx_fine,ny_fine,tmp);
resample_2d(f2_orig,nx_orig,ny_orig,bx,by,f2_res,nx_fine,ny_fine,tmp);
/* ---- get overall flow field from previous resolution level -------------- */
/* if on coarsest resolution */
if(rec_depth==max_rec_depth)
{
/* set flow field zero */
set_matrix_2d(u,nx_fine+2*bx,ny_fine+2*by,0,0,(float)0.0);
set_matrix_2d(v,nx_fine+2*bx,ny_fine+2*by,0,0,(float)0.0);
}
/* if not on coarsest resolution */
else
{
/* interpolate solution from previous coarser level */
resample_2d(u,nx_coarse,ny_coarse,bx,by,u,nx_fine,ny_fine,tmp);
resample_2d(v,nx_coarse,ny_coarse,bx,by,v,nx_fine,ny_fine,tmp);
}
/* ---- set up difference problem at current resolution -------------------- */
/* warp second image by overall flow field from previous coarser resolution */
backward_registration(f1_res,f2_res,f2_res_warp,u,v,
nx_fine,ny_fine,bx,by,hx_fine,hy_fine);
/* ---- solve difference problem at current resolution --------------------- */
/* solve difference problem at current resolution to obtain increment */
HORN_SCHUNCK_WARP_LEVEL(f1_res, f2_res_warp, du, dv, u, v,
nx_fine, ny_fine, bx, by, hx_fine, hy_fine,
m_alpha, epsilon_d, epsilon_s, w_bright_grad,
num_iter_inner, num_iter_outer, n_omega);
/* ---- compute overall flow field at current resolution ------------------- */
/* sum up flow increment */
add_matrix_2d(u,du,u,nx_fine,ny_fine,bx,by);
add_matrix_2d(v,dv,v,nx_fine,ny_fine,bx,by);
// printf (" current depth: -- %d -- \n", rec_depth);
}
int main(int argc, char **argv) {
srand(time(NULL));
rand();
if (argc == 2 || argc == 3) {
char *hostname = argv[1];
int port = DEFAULT_PORT;
if (argc == 3) {
port = atoi(argv[2]);
}
db_disable();
client_enable();
client_connect(hostname, port);
client_start();
}
if (!glfwInit()) {
return -1;
}
create_window();
if (!window) {
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glfwSwapInterval(VSYNC);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, on_key);
glfwSetMouseButtonCallback(window, on_mouse_button);
glfwSetScrollCallback(window, on_scroll);
#ifndef __APPLE__
if (glewInit() != GLEW_OK) {
return -1;
}
#endif
if (db_init()) {
return -1;
}
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LINE_SMOOTH);
glLogicOp(GL_INVERT);
glClearColor(0.53, 0.81, 0.92, 1.00);
GLuint texture;
glGenTextures(1, &texture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
load_png_texture("texture.png");
GLuint block_program = load_program(
"shaders/block_vertex.glsl", "shaders/block_fragment.glsl");
GLuint matrix_loc = glGetUniformLocation(block_program, "matrix");
GLuint camera_loc = glGetUniformLocation(block_program, "camera");
GLuint sampler_loc = glGetUniformLocation(block_program, "sampler");
GLuint timer_loc = glGetUniformLocation(block_program, "timer");
GLuint position_loc = glGetAttribLocation(block_program, "position");
GLuint normal_loc = glGetAttribLocation(block_program, "normal");
GLuint uv_loc = glGetAttribLocation(block_program, "uv");
GLuint line_program = load_program(
"shaders/line_vertex.glsl", "shaders/line_fragment.glsl");
GLuint line_matrix_loc = glGetUniformLocation(line_program, "matrix");
GLuint line_position_loc = glGetAttribLocation(line_program, "position");
GLuint item_position_buffer = 0;
GLuint item_normal_buffer = 0;
GLuint item_uv_buffer = 0;
int previous_block_type = 0;
Chunk chunks[MAX_CHUNKS];
int chunk_count = 0;
Player players[MAX_PLAYERS];
int player_count = 0;
FPS fps = {0, 0};
float matrix[16];
float x = (rand_double() - 0.5) * 10000;
float z = (rand_double() - 0.5) * 10000;
float y = 0;
float dy = 0;
float rx = 0;
float ry = 0;
double px = 0;
double py = 0;
int loaded = db_load_state(&x, &y, &z, &rx, &ry);
ensure_chunks(chunks, &chunk_count, x, y, z, 1);
if (!loaded) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
glfwGetCursorPos(window, &px, &py);
double previous = glfwGetTime();
while (!glfwWindowShouldClose(window)) {
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
update_fps(&fps, SHOW_FPS);
double now = glfwGetTime();
double dt = MIN(now - previous, 0.2);
previous = now;
if (exclusive && (px || py)) {
double mx, my;
glfwGetCursorPos(window, &mx, &my);
float m = 0.0025;
rx += (mx - px) * m;
ry -= (my - py) * m;
if (rx < 0) {
rx += RADIANS(360);
}
if (rx >= RADIANS(360)){
rx -= RADIANS(360);
}
ry = MAX(ry, -RADIANS(90));
ry = MIN(ry, RADIANS(90));
px = mx;
py = my;
}
else {
glfwGetCursorPos(window, &px, &py);
}
int szlast = sz;
int sxlast = sx;
sz = 0;
sx = 0;
ortho = glfwGetKey(window, 'F');
fov = glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) ? 15.0 : 65.0;
if (glfwGetKey(window, 'Q')) break;
if (glfwGetKey(window, 'W')) sz--;
if (glfwGetKey(window, 'S')) sz++;
if (glfwGetKey(window, 'A')) sx--;
if (glfwGetKey(window, 'D')) sx++;
if (sx != 0 || sz !=0 && flying == 0){
acc = walking_speed > acc && acc > 0 ? acc + (acc - (acc / 3)) : walking_speed; }
else{
if(sx == 0 && sz == 0 && flying == 0){
if(acc > 1 && acc > 0){
acc = acc - (acc / 1.45);
if(szlast != 0){sz = szlast; };
if(sxlast != 0){sx = sxlast; };}
else{
acc = .8;
}
}
}
float m = dt * 1.0;
if (glfwGetKey(window, GLFW_KEY_LEFT)) rx -= m;
if (glfwGetKey(window, GLFW_KEY_RIGHT)) rx += m;
if (glfwGetKey(window, GLFW_KEY_UP)) ry += m;
if (glfwGetKey(window, GLFW_KEY_DOWN)) ry -= m;
float vx, vy, vz;
get_motion_vector(flying, sz, sx, rx, ry, &vx, &vy, &vz);
if (glfwGetKey(window, GLFW_KEY_SPACE)) {
if (flying) {
vy = 1;
}
else if (dy == 0) {
dy = 8;
}
}
if (glfwGetKey(window, 'Z')) {
vx = -1; vy = 0; vz = 0;
}
if (glfwGetKey(window, 'X')) {
vx = 1; vy = 0; vz = 0;
}
if (glfwGetKey(window, 'C')) {
vx = 0; vy = -1; vz = 0;
}
if (glfwGetKey(window, 'V')) {
vx = 0; vy = 1; vz = 0;
}
if (glfwGetKey(window, 'B')) {
vx = 0; vy = 0; vz = -1;
}
if (glfwGetKey(window, 'N')) {
vx = 0; vy = 0; vz = 1;
}
float speed = flying ? 20 : acc;
int step = 8;
float ut = dt / step;
vx = vx * ut * speed;
vy = vy * ut * speed;
vz = vz * ut * speed;
for (int i = 0; i < step; i++) {
if (flying) {
dy = 0;
}
else {
dy -= ut * 25;
dy = MAX(dy, -250);
}
x += vx;
y += vy + dy * ut;
z += vz;
if (collide(chunks, chunk_count, 2, &x, &y, &z)) {
dy = 0;
}
}
if (y < 0) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
if (left_click) {
left_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
&hx, &hy, &hz);
if (hy > 0 && is_destructable(hw)) {
set_block(chunks, chunk_count, hx, hy, hz, 0, 1);
int above = get_block(chunks, chunk_count, hx, hy + 1, hz);
if (is_plant(above)) {
set_block(chunks, chunk_count, hx, hy + 1, hz, 0, 1);
}
}
}
if (right_click) {
right_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 1, x, y, z, rx, ry,
&hx, &hy, &hz);
if (is_obstacle(hw)) {
if (!player_intersects_block(2, x, y, z, hx, hy, hz)) {
set_block(chunks, chunk_count, hx, hy, hz, block_type, 1);
}
}
}
if (middle_click) {
middle_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
&hx, &hy, &hz);
if (is_selectable(hw)) {
block_type = hw;
}
}
if (teleport) {
teleport = 0;
if (player_count) {
int index = rand_int(player_count);
Player *player = players + index;
x = player->x; y = player->y; z = player->z;
rx = player->rx; ry = player->ry;
ensure_chunks(chunks, &chunk_count, x, y, z, 1);
}
}
client_position(x, y, z, rx, ry);
char buffer[RECV_BUFFER_SIZE];
while (client_recv(buffer, RECV_BUFFER_SIZE)) {
float ux, uy, uz, urx, ury;
if (sscanf(buffer, "U,%*d,%f,%f,%f,%f,%f",
&ux, &uy, &uz, &urx, &ury) == 5)
{
x = ux; y = uy; z = uz; rx = urx; ry = ury;
ensure_chunks(chunks, &chunk_count, x, y, z, 1);
y = highest_block(chunks, chunk_count, x, z) + 2;
}
int bx, by, bz, bw;
if (sscanf(buffer, "B,%*d,%*d,%d,%d,%d,%d",
&bx, &by, &bz, &bw) == 4)
{
set_block(chunks, chunk_count, bx, by, bz, bw, 0);
if (player_intersects_block(2, x, y, z, bx, by, bz)) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
}
int pid;
float px, py, pz, prx, pry;
if (sscanf(buffer, "P,%d,%f,%f,%f,%f,%f",
&pid, &px, &py, &pz, &prx, &pry) == 6)
{
Player *player = find_player(players, player_count, pid);
if (!player && player_count < MAX_PLAYERS) {
player = players + player_count;
player_count++;
player->id = pid;
player->position_buffer = 0;
player->normal_buffer = 0;
player->uv_buffer = 0;
printf("%d other players are online\n", player_count);
}
if (player) {
update_player(player, px, py, pz, prx, pry);
}
}
if (sscanf(buffer, "D,%d", &pid) == 1) {
delete_player(players, &player_count, pid);
printf("%d other players are online\n", player_count);
}
}
int p = chunked(x);
int q = chunked(z);
ensure_chunks(chunks, &chunk_count, x, y, z, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
set_matrix_3d(matrix, width, height, x, y, z, rx, ry, fov, ortho);
// render chunks
glUseProgram(block_program);
glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
glUniform3f(camera_loc, x, y, z);
glUniform1i(sampler_loc, 0);
glUniform1f(timer_loc, glfwGetTime());
for (int i = 0; i < chunk_count; i++) {
Chunk *chunk = chunks + i;
if (chunk_distance(chunk, p, q) > RENDER_CHUNK_RADIUS) {
continue;
}
if (y < 100 && !chunk_visible(chunk, matrix)) {
continue;
}
draw_chunk(chunk, position_loc, normal_loc, uv_loc);
}
// render players
for (int i = 0; i < player_count; i++) {
Player *player = players + i;
draw_player(player, position_loc, normal_loc, uv_loc);
}
// render focused block wireframe
int hx, hy, hz;
int hw = hit_test(
chunks, chunk_count, 0, x, y, z, rx, ry, &hx, &hy, &hz);
if (is_obstacle(hw)) {
glUseProgram(line_program);
glLineWidth(1);
glEnable(GL_COLOR_LOGIC_OP);
glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
GLuint wireframe_buffer = gen_wireframe_buffer(hx, hy, hz, 0.51);
draw_lines(wireframe_buffer, line_position_loc, 3, 48);
glDeleteBuffers(1, &wireframe_buffer);
glDisable(GL_COLOR_LOGIC_OP);
}
set_matrix_2d(matrix, width, height);
// render crosshairs
glUseProgram(line_program);
glLineWidth(4);
glEnable(GL_COLOR_LOGIC_OP);
glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
GLuint crosshair_buffer = gen_crosshair_buffer(width, height);
draw_lines(crosshair_buffer, line_position_loc, 2, 4);
glDeleteBuffers(1, &crosshair_buffer);
glDisable(GL_COLOR_LOGIC_OP);
// render selected item
set_matrix_item(matrix, width, height);
if (block_type != previous_block_type) {
previous_block_type = block_type;
gen_item_buffers(
&item_position_buffer, &item_normal_buffer, &item_uv_buffer,
block_type);
}
glUseProgram(block_program);
glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
glUniform3f(camera_loc, 0, 0, 5);
glUniform1i(sampler_loc, 0);
glUniform1f(timer_loc, glfwGetTime());
glDisable(GL_DEPTH_TEST);
draw_cube(
item_position_buffer, item_normal_buffer, item_uv_buffer,
position_loc, normal_loc, uv_loc);
glEnable(GL_DEPTH_TEST);
glfwSwapBuffers(window);
glfwPollEvents();
}
client_stop();
db_save_state(x, y, z, rx, ry);
db_close();
glfwTerminate();
return 0;
}
void HORN_SCHUNCK_WARP_LEVEL
(
/*****************************************************/
float **f1, /* in : 1st image */
float **f2, /* in : 2nd image */
float **du, /* in+out : x-component of flow increment */
float **dv, /* in+out : y-component of flow increment */
float **u, /* in+out : x-component of flow field */
float **v, /* in+out : y-component of flow field */
int nx, /* in : size in x-direction */
int ny, /* in : size in y-direction */
int bx, /* in : boundary size in x-direction */
int by, /* in : boundary size in y-direction */
float hx, /* in : grid spacing in x-direction */
float hy, /* in : grid spacing in y-direction */
float m_alpha, /* in : smoothness weight */
float epsilon_d, /* in : diffusivity param data term */
float epsilon_s, /* in : diffusivity type data term */
float w_bright_grad,
int num_iter_inner, /* in : inner solver iterations */
int num_iter_outer, /* in : outer nonlin update iterations */
float n_omega /* in : SOR overrelaxation parameter */
/*****************************************************/
)
{
/*****************************************************/
int i,j; /* loop variable */
float **J_11; /* entry 11 of the motion tensor */
float **J_22; /* entry 22 of the motion tensor */
float **J_33; /* entry 33 of the motion tensor */
float **J_12; /* entry 12 of the motion tensor */
float **J_13; /* entry 13 of the motion tensor */
float **J_23; /* entry 23 of the motion tensor */
float **psi_prime_d; /* nonlinearitys of data term */
float **psi_prime_s;
/*****************************************************/
/* ---- alloc memory ---- */
malloc_multi(8,2,sizeof(float),nx,ny,bx,by,0,0,&J_11,&J_22,&J_33,&J_12,&J_13,
&J_23,&psi_prime_d, &psi_prime_s);
/* ---- initialise displacement field with zero ---- */
set_matrix_2d(du,nx+2*bx,ny+2*by,0,0,(float)0.0);
set_matrix_2d(dv,nx+2*bx,ny+2*by,0,0,(float)0.0);
/* ---- compute motion tensor ---- */
compute_motion_tensor(f1,f2,nx,ny,bx,by,hx,hy,w_bright_grad,
J_11,J_22,J_33,J_12,J_13,J_23);
/* ---- perform SOR iterations ---- */
for(j=0;j<num_iter_outer;j++)
{
update_nonlinearities(J_11, J_22, J_33, J_12, J_13, J_23, du, dv,
psi_prime_d, epsilon_d, nx,
ny, bx, by);
update_nonlinearities_reg(u,v,du,dv,psi_prime_s,epsilon_s,nx,ny,bx,by,
hx,hy);
for(i=1;i<=num_iter_inner;i++)
{
horn_schunck_warp_sor(J_11, J_22, J_33, J_12, J_13, J_23,
du, dv, u, v, psi_prime_d, psi_prime_s,nx, ny, bx, by, hx, hy,
m_alpha, n_omega);
}
}
/* ---- free memory ---- */
free_multi(8,2,sizeof(float),nx,ny,bx,by,0,0,&J_11,&J_22,&J_33,&J_12,&J_13,
&J_23,&psi_prime_d, &psi_prime_s);
}
