void set_matrix_3d(
float *matrix, int width, int height,
float x, float y, float z, float rx, float ry, float fov, int ortho)
{
float a[16];
float b[16];
float aspect = (float)width / height;
mat_identity(a);
mat_translate(b, -x, -y - 0.1, -z);
mat_multiply(a, b, a);
mat_rotate(b, cosf(rx), 0, sinf(rx), ry);
mat_multiply(a, b, a);
mat_rotate(b, 0, 1, 0, -rx);
mat_multiply(a, b, a);
if (ortho) {
int size = 32;
mat_ortho(b, -size * aspect, size * aspect, -size, size, -256, 256);
}
else {
mat_perspective(b, fov, aspect, 1 / 8.0, 256.0);
}
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
void make_rotated_cube(float *data, float ao[6][4], float light[6][4],
int left, int right, int top, int bottom, int front, int back,
float x, float y, float z, float n, float rx, float ry, float rz,
int w, const int blocks[256][6]) {
int wleft = blocks[w][0];
int wright = blocks[w][1];
int wtop = blocks[w][2];
int wbottom = blocks[w][3];
int wfront = blocks[w][4];
int wback = blocks[w][5];
make_cube_faces(
data, ao, light,
left, right, top, bottom, front, back,
wleft, wright, wtop, wbottom, wfront, wback,
n);
float ma[16];
float mb[16];
mat_identity(ma);
/* Create rotation transformation */
mat_rotate(mb, 0, 1, 0, ry);
mat_multiply(ma, mb, ma);
mat_rotate(mb, 1, 0, 0, rx);
mat_multiply(ma, mb, ma);
mat_rotate(mb, 0, 0, 1, rz);
mat_multiply(ma, mb, ma);
/* Apply to normals */
mat_apply(data, ma, (left + right + top + bottom + front + back)*6, 3, 10);
/* Create translation transformation */
mat_translate(mb, x, y, z);
/* Merge with rotation transformation */
mat_multiply(ma, mb, ma);
/* Apply to vertices */
mat_apply(data, ma, (left + right + top + bottom + front + back)*6, 0, 10);
}
void set_matrix_3d(
float *matrix, int width, int height,
float x, float y, float z, float rx, float ry,
float fov, int ortho, int radius)
{
float a[16];
float b[16];
float aspect = (float)width / height;
float znear = 0.125;
float zfar = radius * 32 + 64;
mat_identity(a);
mat_translate(b, -x, -y, -z);
mat_multiply(a, b, a);
mat_rotate(b, cosf(rx), 0, sinf(rx), ry);
mat_multiply(a, b, a);
mat_rotate(b, 0, 1, 0, -rx);
mat_multiply(a, b, a);
if (ortho) {
int size = ortho;
mat_ortho(b, -size * aspect, size * aspect, -size, size, -zfar, zfar);
}
else {
mat_perspective(b, fov, aspect, znear, zfar);
}
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
void make_player(
float *data,
float x, float y, float z, float rx, float ry)
{
float ao[6][4] = {0};
float light[6][4] = {
{0.8, 0.8, 0.8, 0.8},
{0.8, 0.8, 0.8, 0.8},
{0.8, 0.8, 0.8, 0.8},
{0.8, 0.8, 0.8, 0.8},
{0.8, 0.8, 0.8, 0.8},
{0.8, 0.8, 0.8, 0.8}
};
make_cube_faces(
data, ao, light,
1, 1, 1, 1, 1, 1,
226, 224, 241, 209, 225, 227,
0, 0, 0, 0.4);
float ma[16];
float mb[16];
mat_identity(ma);
mat_rotate(mb, 0, 1, 0, rx);
mat_multiply(ma, mb, ma);
mat_rotate(mb, cosf(rx), 0, sinf(rx), -ry);
mat_multiply(ma, mb, ma);
mat_apply(data, ma, 36, 3, 10);
mat_translate(mb, x, y, z);
mat_multiply(ma, mb, ma);
mat_apply(data, ma, 36, 0, 10);
}
void update_matrix_3d(
float *matrix, float x, float y, float z, float rx, float ry)
{
float a[16];
float b[16];
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
float aspect = (float)width / height;
mat_identity(a);
mat_translate(b, -x, -y, -z);
mat_multiply(a, b, a);
mat_rotate(b, cosf(rx), 0, sinf(rx), ry);
mat_multiply(a, b, a);
mat_rotate(b, 0, 1, 0, -rx);
mat_multiply(a, b, a);
if (ortho) {
int size = 32;
mat_ortho(b, -size * aspect, size * aspect, -size, size, -256, 256);
}
else {
mat_perspective(b, fov, aspect, 0.1, 1024.0);
}
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
void make_rotated_cube(
float *vertex, float *normal, float *texture,
float x, float y, float z, float n, int w, float rx, float ry)
{
make_cube(vertex, normal, texture, 1, 1, 1, 1, 1, 1, 0, 0, 0, n, w);
float a[16];
float b[16];
float vec[4] = {0};
vec[3] = 1;
mat_identity(a);
mat_rotate(b, 0, 1, 0, rx);
mat_multiply(a, b, a);
mat_rotate(b, cosf(rx), 0, sinf(rx), -ry);
mat_multiply(a, b, a);
mat_translate(b, x, y, z);
mat_multiply(a, b, a);
for (int i = 0; i < 36; i++) {
// vertex
float *v = vertex + i * 3;
vec[0] = *(v++); vec[1] = *(v++); vec[2] = *(v++);
mat_vec_multiply(vec, a, vec);
v = vertex + i * 3;
*(v++) = vec[0]; *(v++) = vec[1]; *(v++) = vec[2];
// normal
float *d = normal + i * 3;
vec[0] = *(d++); vec[1] = *(d++); vec[2] = *(d++);
mat_vec_multiply(vec, a, vec);
d = normal + i * 3;
*(d++) = vec[0]; *(d++) = vec[1]; *(d++) = vec[2];
}
}
void update_matrix_3d(
float *matrix, float x, float y, float z, float rx, float ry)
{
float a[16];
float b[16];
int width, height;
glfwGetWindowSize(&width, &height);
glViewport(0, 0, width, height);
float aspect = (float)width / height;
mat_identity(a);
mat_translate(b, -x, -y, -z);
mat_multiply(a, b, a);
mat_rotate(b, cosf(rx), 0, sinf(rx), ry);
mat_multiply(a, b, a);
mat_rotate(b, 0, 1, 0, -rx);
mat_multiply(a, b, a);
if (ortho) {
int size = 32;
mat_ortho(b, -size * aspect, size * aspect, -size, size, -256, 256);
}
else {
mat_perspective(b, 65.0, aspect, 0.1, 1024.0);
}
mat_multiply(a, b, a);
for (int i = 0; i < 16; i++) {
matrix[i] = a[i];
}
}
static void recompute_mask(tdflippo_instance_t* inst)
{
float xpos=(float)inst->width*inst->center[0];
float ypos=(float)inst->height*inst->center[1];
float **mat=mat_translate(xpos,ypos,0.0);
if(inst->flip[0]!=0.5)
mat=matmult(mat,mat_rotate(AXIS_X,(inst->flip[0]-0.5)*TWO_PI));
if(inst->flip[1]!=0.5)
mat=matmult(mat,mat_rotate(AXIS_Y,(inst->flip[1]-0.5)*TWO_PI));
if(inst->flip[2]!=0.5)
mat=matmult(mat,mat_rotate(AXIS_Z,(inst->flip[2]-0.5)*TWO_PI));
mat=matmult(mat,mat_translate(-xpos,-ypos,0.0));
#if 0
fprintf(stderr,"Resarra %.2f %.2f %.2f %.2f | %.2f %.2f %.2f %.2f | %.2f %.2f %.2f %.2f | %.2f %.2f %.2f %.2f\n",
mat[0][0],mat[0][1],mat[0][2],mat[0][3],
mat[1][0],mat[1][1],mat[1][2],mat[1][3],
mat[2][0],mat[2][1],mat[2][2],mat[2][3],
mat[3][0],mat[3][1],mat[3][2],mat[3][3]);
#endif
int x,y,nx,ny,pos;
float xf,yf,zf;
if(!inst->dontblank)
memset(inst->mask,0xff,sizeof(int)*inst->fsize);
for(y=0,pos=0;y<inst->height;y++)
for(x=0;x<inst->width;x++,pos++)
{
xf=x;
yf=y;
zf=0.0;
vetmat(mat,&xf,&yf,&zf);
nx=(int)(xf+0.5);
ny=(int)(yf+0.5);
if(nx>=0 && nx<inst->width && ny>=0 && ny<inst->height)
{
if(!inst->invertrot)
inst->mask[ny*inst->width+nx]=pos;
else
inst->mask[pos]=ny*inst->width+nx;
}
}
matfree(mat);
}
void make_plant(
float *data, float ao, float light,
float px, float py, float pz, float n, int w, float rotation)
{
static const float positions[4][4][3] = {
{{ 0, -1, -1}, { 0, -1, +1}, { 0, +1, -1}, { 0, +1, +1}},
{{ 0, -1, -1}, { 0, -1, +1}, { 0, +1, -1}, { 0, +1, +1}},
{{-1, -1, 0}, {-1, +1, 0}, {+1, -1, 0}, {+1, +1, 0}},
{{-1, -1, 0}, {-1, +1, 0}, {+1, -1, 0}, {+1, +1, 0}}
};
static const float normals[4][3] = {
{-1, 0, 0},
{+1, 0, 0},
{0, 0, -1},
{0, 0, +1}
};
static const float uvs[4][4][2] = {
{{0, 0}, {1, 0}, {0, 1}, {1, 1}},
{{1, 0}, {0, 0}, {1, 1}, {0, 1}},
{{0, 0}, {0, 1}, {1, 0}, {1, 1}},
{{1, 0}, {1, 1}, {0, 0}, {0, 1}}
};
static const float indices[4][6] = {
{0, 3, 2, 0, 1, 3},
{0, 3, 1, 0, 2, 3},
{0, 3, 2, 0, 1, 3},
{0, 3, 1, 0, 2, 3}
};
float *d = data;
float s = 0.0625;
float a = 0;
float b = s;
struct item_list *plant = get_item_by_id(ABS(w));
float du = (plant->tile->sprite % 16) * s;
float dv = (plant->tile->sprite / 16) * s;
for (int i = 0; i < 4; i++) {
for (int v = 0; v < 6; v++) {
int j = indices[i][v];
*(d++) = n * positions[i][j][0];
*(d++) = n * positions[i][j][1];
*(d++) = n * positions[i][j][2];
*(d++) = normals[i][0];
*(d++) = normals[i][1];
*(d++) = normals[i][2];
*(d++) = du + (uvs[i][j][0] ? b : a);
*(d++) = dv + (uvs[i][j][1] ? b : a);
*(d++) = ao;
*(d++) = light;
}
}
float ma[16];
float mb[16];
mat_identity(ma);
mat_rotate(mb, 0, 1, 0, RADIANS(rotation));
mat_multiply(ma, mb, ma);
mat_apply(data, ma, 24, 3, 10);
mat_translate(mb, px, py, pz);
mat_multiply(ma, mb, ma);
mat_apply(data, ma, 24, 0, 10);
}
static void get_camera_frame(vector x, vector y, vector z)
{
matrix m;
vec_set(x, 1.0f, 0.0f, 0.0f);
vec_set(y, 0.0f, 1.0f, 0.0f);
vec_set(z, 0.0f, 0.0f, 1.0f);
mat_rotate(m, y, y_rot);
mat_mul_vector(x, m, x);
mat_mul_vector(z, m, z);
mat_rotate(m, x, x_rot);
mat_mul_vector(y, m, y);
mat_mul_vector(z, m, z);
}
void
ui_set_modelview_matrix(struct matrix *mv)
{
struct matrix ry, rx, rm;
struct vector p, o;
struct matrix c, t, r, v;
mat_make_rotation_around_y(&ry, ui.rotation);
mat_make_rotation_around_x(&rx, ui.tilt);
mat_mul_copy(&rm, &ry, &rx);
vec_zero(&o); /* look at */
vec_set(&p, 0.f, 0.f, -ui.distance); /* camera position */
mat_rotate(&p, &rm);
mat_make_look_at(&c, &o, &p);
vec_neg(&p);
mat_make_translation_from_vec(&t, &p);
mat_mul_copy(&v, &c, &t);
mat_make_rotation_around_x(&r, -M_PI/2.);
mat_mul_copy(mv, &v, &r);
}
void set_matrix_item(float *matrix, int width, int height) {
float a[16];
float b[16];
float aspect = (float)width / height;
float size = 64;
float box = height / size / 2;
float xoffset = 1 - size / width * 2;
float yoffset = 1 - size / height * 2;
mat_identity(a);
mat_rotate(b, 0, 1, 0, -PI / 4);
mat_multiply(a, b, a);
mat_rotate(b, 1, 0, 0, -PI / 10);
mat_multiply(a, b, a);
mat_ortho(b, -box * aspect, box * aspect, -box, box, -1, 1);
mat_multiply(a, b, a);
mat_translate(b, -xoffset, -yoffset, 0);
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
void set_matrix_item_r(float *matrix, int width, int height, float scale,
float xoffset, float yoffset, float rx, float ry, float rz) {
float a[16];
float b[16];
float aspect = (float)width / height;
float size = 64 * scale;
float box = height / size / 2;
mat_identity(a);
mat_rotate(b, 0, 1, 0, rx);
mat_multiply(a, b, a);
mat_rotate(b, 1, 0, 0, ry);
mat_multiply(a, b, a);
mat_rotate(b, 0, 0, 1, rz);
mat_multiply(a, b, a);
mat_ortho(b, -box * aspect, box * aspect, -box, box, -3, 2);
mat_multiply(a, b, a);
mat_translate(b, -xoffset, -yoffset, 0);
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
MatP* pivot_local_transform(const struct Pivot* pivot, Mat local_transform) {
Mat rotation = {0};
quat_invert(pivot->orientation, rotation);
mat_rotate(NULL, rotation, rotation);
Mat translation = {0};
vec_invert(pivot->position, translation);
mat_translate(NULL, translation, translation);
mat_mul(translation, rotation, local_transform);
return local_transform;
}
void update_matrix_item(float *matrix) {
float a[16];
float b[16];
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
float aspect = (float)width / height;
float size = 64;
float box = height / size / 2;
float xoffset = 1 - size / width * 2;
float yoffset = 1 - size / height * 2;
mat_identity(a);
mat_rotate(b, 0, 1, 0, PI / 4);
mat_multiply(a, b, a);
mat_rotate(b, 1, 0, 0, -PI / 10);
mat_multiply(a, b, a);
mat_ortho(b, -box * aspect, box * aspect, -box, box, -1, 1);
mat_multiply(a, b, a);
mat_translate(b, -xoffset, -yoffset, 0);
mat_multiply(a, b, a);
mat_identity(matrix);
mat_multiply(matrix, a, matrix);
}
int32_t main(int32_t argc, char *argv[]) {
printf("<<watchlist//>>\n");
if( init_sdl2() ) {
return 1;
}
uint32_t width = 1280;
uint32_t height = 720;
SDL_Window* window;
sdl2_window("test-canvas", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, &window);
SDL_GLContext* context;
sdl2_glcontext(3, 2, window, &context);
if( init_shader() ) {
return 1;
}
if( init_canvas() ) {
return 1;
}
printf("sizeof(struct Canvas): %zu\n", sizeof(struct Canvas));
printf("MAX_OGL_PRIMITIVES: %d\n", MAX_OGL_PRIMITIVES);
struct Arcball arcball = {0};
arcball_create(width, height, (Vec4f){1.0,2.0,8.0,1.0}, (Vec4f){0.0,0.0,0.0,1.0}, 0.01, 1000.0, &arcball);
struct Character symbols[256] = {0};
default_font_create(symbols);
struct Shader shader = {0};
shader_create(&shader);
shader_attach(&shader, GL_VERTEX_SHADER, "prefix.vert", 1, "volumetric_lines.vert");
shader_attach(&shader, GL_FRAGMENT_SHADER, "prefix.frag", 1, "volumetric_lines.frag");
shader_make_program(&shader, SHADER_DEFAULT_NAMES, "lines_shader");
struct Font font = {0};
font_create_from_characters(L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;", 256, symbols, 9, 3, global_default_font_palette, &font);
struct Canvas text_canvas = {0};
canvas_create("text_canvas", &text_canvas);
canvas_add_attribute(&text_canvas, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT);
canvas_add_attribute(&text_canvas, SHADER_ATTRIBUTE_VERTEX_COLOR, 4, GL_UNSIGNED_BYTE);
canvas_add_attribute(&text_canvas, SHADER_ATTRIBUTE_VERTEX_TEXCOORD, 2, GL_FLOAT);
log_assert( canvas_add_shader(&text_canvas, shader.name, &shader) < MAX_CANVAS_SHADER );
log_assert( canvas_add_font(&text_canvas, "other_font", &font) < MAX_CANVAS_FONTS );
struct GameTime time = {0};
gametime_create(1.0f / 60.0f, &time);
SDL_SetEventFilter(event_filter, NULL);
while (true) {
SDL_Event event;
while( sdl2_poll_event(&event) ) {
if( sdl2_handle_quit(event) ) {
goto done;
}
sdl2_handle_resize(event);
arcball_handle_resize(&arcball, event);
arcball_handle_mouse(&arcball, event);
}
gametime_advance(&time, sdl2_time_delta());
sdl2_debug( SDL_GL_SetSwapInterval(1) );
ogl_debug( glClearDepth(1.0f);
glClearColor(.0f, .0f, .0f, 1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); );
draw_grid(&text_canvas, 0, (Mat)IDENTITY_MAT, (Color){20, 180, 240, 255}, 0.02f, 12.0f, 12.0f, 12);
draw_basis(&text_canvas, 1, (Mat)IDENTITY_MAT, 0.02f, 1.0f);
Mat text_matrix = {0};
Quat text_rotation = {0};
quat_from_axis_angle((Vec4f){1.0, 0.0, 0.0, 1.0}, PI/2, text_rotation);
mat_rotate(NULL, text_rotation, text_matrix);
mat_translate(text_matrix, (Vec4f){-3.5, -1.0, 6.25, 1.0}, text_matrix);
Vec4f world_cursor = {0,0,0,1};
text_put_world(&text_canvas, 0, world_cursor, text_matrix, (Color){0, 255, 255, 255}, 0.5f, "other_font", L"Dies ist ein Test\n");
text_put_world(&text_canvas, 0, world_cursor, text_matrix, (Color){255, 255, 0, 255}, 0.5f, "other_font", L"fuer einen Text");
gametime_integrate(&time);
Vec4f screen_cursor = {0,0,0,1};
double fps = text_show_fps(&global_dynamic_canvas, 0, screen_cursor, 0, 0, (Color){255, 255, 255, 255}, 20.0f, "default_font", time.frame);
/* text_show_time(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){255, 255, 255, 255}, 0, 0, time.t); */
/* text_put_screen(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){255, 210, 255, 255}, 0, 0, L"LALA singt das Meerschweinchen\n"); */
/* text_put_screen(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){0, 210, 255, 255}, 0, 0, L"FICKEN immer und ueberall\n"); */
/* text_put_screen(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){20, 210, 110, 255}, 0, 0, L"FUMMELN den ganzen Tag lang\n"); */
/* text_printf(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){255, 40, 60, 255}, 0, 0, L"PRINTF %d Luftballons\n", 99); */
canvas_render_layers(&text_canvas, 0, MAX_CANVAS_LAYERS, &arcball.camera, (Mat)IDENTITY_MAT);
canvas_clear(&text_canvas);
canvas_render_layers(&global_dynamic_canvas, 0, MAX_CANVAS_LAYERS, &arcball.camera, (Mat)IDENTITY_MAT);
canvas_clear(&global_dynamic_canvas);
sdl2_debug( SDL_GL_SwapWindow(window) );
}
int32_t main(int32_t argc, char *argv[]) {
if( init_sdl2() ) {
return 1;
}
int width = 1280;
int height = 720;
SDL_Window* window;
sdl2_window("cute3d: " __FILE__, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, &window);
SDL_GLContext* context;
sdl2_glcontext(3, 2, window, &context);
if( init_shader() ) {
return 1;
}
if( init_canvas(width, height) ) {
return 1;
}
canvas_create("global_dynamic_canvas", &global_dynamic_canvas);
canvas_create("global_static_canvas", &global_static_canvas);
struct Vbo vbo = {0};
vbo_create(&vbo);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_NORMAL, 3, GL_FLOAT, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_COLOR, 4, GL_UNSIGNED_BYTE, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_NORMAL, NORMAL_SIZE, GL_FLOAT, GL_STATIC_DRAW);
struct Ibo ibo = {0};
ibo_create(GL_TRIANGLES, GL_UNSIGNED_INT, GL_STATIC_DRAW, &ibo);
struct SolidTetrahedron hard_tetrahedron = {0};
struct SolidBox hard_cube = {0};
struct SolidSphere16 hard_sphere16 = {0};
struct SolidSphere32 hard_sphere32 = {0};
solid_tetrahedron_create(1.0, (Color){255, 0, 0, 255}, &hard_tetrahedron);
solid_cube_create(0.5, (Color){0, 255, 0, 255}, &hard_cube);
solid_sphere16_create(16, 8, 0.75, (Color){0, 255, 255, 255}, &hard_sphere16);
solid_sphere32_create(32, 16, 0.75, (Color){255, 255, 0, 255}, &hard_sphere32);
solid_optimize((struct Solid*)&hard_tetrahedron);
solid_optimize((struct Solid*)&hard_cube);
solid_optimize((struct Solid*)&hard_sphere16);
solid_optimize((struct Solid*)&hard_sphere32);
struct VboMesh hard_tetrahedron_mesh, hard_box_mesh, hard_cube_mesh, hard_sphere16_mesh, hard_sphere32_mesh;
vbo_mesh_create_from_solid((struct Solid*)&hard_tetrahedron, &vbo, &ibo, &hard_tetrahedron_mesh);
vbo_mesh_create_from_solid((struct Solid*)&hard_cube, &vbo, &ibo, &hard_cube_mesh);
vbo_mesh_create_from_solid((struct Solid*)&hard_sphere16, &vbo, &ibo, &hard_sphere16_mesh);
vbo_mesh_create_from_solid((struct Solid*)&hard_sphere32, &vbo, &ibo, &hard_sphere32_mesh);
struct SolidTetrahedron smooth_tetrahedron = {0};
struct SolidBox smooth_cube = {0};
struct SolidSphere16 smooth_sphere16 = {0};
struct SolidSphere32 smooth_sphere32 = {0};
solid_tetrahedron_create(1.0, (Color){255, 0, 0, 255}, &smooth_tetrahedron);
solid_cube_create(0.5, (Color){0, 255, 0, 255}, &smooth_cube);
solid_sphere16_create(16, 8, 0.75, (Color){0, 255, 255, 255}, &smooth_sphere16);
solid_sphere32_create(32, 16, 0.75, (Color){255, 255, 0, 255}, &smooth_sphere32);
solid_optimize((struct Solid*)&smooth_tetrahedron);
solid_optimize((struct Solid*)&smooth_cube);
solid_optimize((struct Solid*)&smooth_sphere16);
solid_optimize((struct Solid*)&smooth_sphere32);
solid_smooth_normals((struct Solid*)&smooth_tetrahedron, smooth_tetrahedron.normals, smooth_tetrahedron.normals);
solid_smooth_normals((struct Solid*)&smooth_cube, smooth_cube.normals, smooth_cube.normals);
solid_smooth_normals((struct Solid*)&smooth_sphere16, smooth_sphere16.normals, smooth_sphere16.normals);
solid_smooth_normals((struct Solid*)&smooth_sphere32, smooth_sphere32.normals, smooth_sphere32.normals);
struct VboMesh smooth_tetrahedron_mesh, smooth_box_mesh, smooth_cube_mesh, smooth_sphere16_mesh, smooth_sphere32_mesh;
vbo_mesh_create_from_solid((struct Solid*)&smooth_tetrahedron, &vbo, &ibo, &smooth_tetrahedron_mesh);
vbo_mesh_create_from_solid((struct Solid*)&smooth_cube, &vbo, &ibo, &smooth_cube_mesh);
vbo_mesh_create_from_solid((struct Solid*)&smooth_sphere16, &vbo, &ibo, &smooth_sphere16_mesh);
vbo_mesh_create_from_solid((struct Solid*)&smooth_sphere32, &vbo, &ibo, &smooth_sphere32_mesh);
struct Arcball arcball = {0};
arcball_create(width, height, (Vec4f){2.5,17.0,17.0,1.0}, (Vec4f){2.5,0.0,0.0,1.0}, 0.1, 100.0, &arcball);
float circular_motion_angle = 0.0f;
float circular_motion_speed = (2.0f*PI)/30;
float circular_motion_radius = 12.0f;
Vec3f light_position = { circular_motion_radius, 10.0, circular_motion_radius };
Vec3f light_direction = {0};
vec_sub((Vec3f){0.0f, 0.0f, 0.0f}, light_position, light_direction);
vec_normalize(light_direction, light_direction);
Vec3f eye_position = {0};
vec_copy3f(arcball.camera.pivot.position, eye_position);
Color ambiance = {50, 25, 150, 255};
Color specular = {255, 255, 255, 255};
float material_shininess = 1.0;
Vec4f material_coefficients = { 0.8, 0.2, 0.0, 0.0 };
// flat
struct Shader flat_shader = {0};
shader_create(&flat_shader);
shader_attach(&flat_shader, GL_VERTEX_SHADER, "prefix.vert", 1, "flat_shading.vert");
shader_attach(&flat_shader, GL_FRAGMENT_SHADER, "prefix.frag", 1, "flat_shading.frag");
shader_make_program(&flat_shader, SHADER_DEFAULT_NAMES, "flat_shader");
shader_set_uniform_3f(&flat_shader, flat_shader.program, SHADER_UNIFORM_LIGHT_DIRECTION, 3, GL_FLOAT, light_direction);
shader_set_uniform_4f(&flat_shader, flat_shader.program, SHADER_UNIFORM_AMBIENT_LIGHT, 4, GL_UNSIGNED_BYTE, ambiance);
// gouraud
struct Shader gouraud_shader = {0};
shader_create(&gouraud_shader);
shader_attach(&gouraud_shader, GL_VERTEX_SHADER, "prefix.vert", 1, "gouraud_shading.vert");
shader_attach(&gouraud_shader, GL_FRAGMENT_SHADER, "prefix.frag", 1, "gouraud_shading.frag");
shader_make_program(&gouraud_shader, SHADER_DEFAULT_NAMES, "gouraud_shader");
shader_set_uniform_3f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_LIGHT_POSITION, 3, GL_FLOAT, light_position);
shader_set_uniform_3f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_EYE_POSITION, 3, GL_FLOAT, eye_position);
shader_set_uniform_4f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_AMBIENT_LIGHT, 4, GL_UNSIGNED_BYTE, ambiance);
shader_set_uniform_4f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_SPECULAR_LIGHT, 4, GL_UNSIGNED_BYTE, specular);
shader_set_uniform_1f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_MATERIAL_SHININESS, 1, GL_FLOAT, &material_shininess);
shader_set_uniform_4f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_MATERIAL_COEFFICIENTS, 4, GL_FLOAT, material_coefficients);
shader_set_uniform_3f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_EYE_POSITION, 3, GL_FLOAT, &arcball.camera.pivot.position);
Mat identity = IDENTITY_MAT;
draw_grid(&global_static_canvas, 0, identity, (Color){127, 127, 127, 255}, 0.03f, 12.0f, 12.0f, 12);
Mat shading_label_transform = IDENTITY_MAT;
Quat text_rotation = IDENTITY_QUAT;
quat_from_axis_angle((Vec3f)X_AXIS, -PI/2.0f, text_rotation);
mat_rotate(shading_label_transform, text_rotation, shading_label_transform);
mat_translate(shading_label_transform, (float[4]){ 6.5, 0.0, -2.5, 1.0 }, shading_label_transform);
void make_plant(
float *vertex, float *normal, float *texture,
float x, float y, float z, float n, int w, float rotation)
{
float *v = vertex;
float *d = normal;
float *t = texture;
float s = 0.0625;
float a = 0;
float b = s;
float du, dv;
w--;
du = (w % 16) * s;
dv = (w / 16 * 3) * s;
// left
*(v++) = x; *(v++) = y - n; *(v++) = z - n;
*(v++) = x; *(v++) = y + n; *(v++) = z + n;
*(v++) = x; *(v++) = y + n; *(v++) = z - n;
*(v++) = x; *(v++) = y - n; *(v++) = z - n;
*(v++) = x; *(v++) = y - n; *(v++) = z + n;
*(v++) = x; *(v++) = y + n; *(v++) = z + n;
*(d++) = -1; *(d++) = 0; *(d++) = 0;
*(d++) = -1; *(d++) = 0; *(d++) = 0;
*(d++) = -1; *(d++) = 0; *(d++) = 0;
*(d++) = -1; *(d++) = 0; *(d++) = 0;
*(d++) = -1; *(d++) = 0; *(d++) = 0;
*(d++) = -1; *(d++) = 0; *(d++) = 0;
*(t++) = a + du; *(t++) = a + dv;
*(t++) = b + du; *(t++) = b + dv;
*(t++) = a + du; *(t++) = b + dv;
*(t++) = a + du; *(t++) = a + dv;
*(t++) = b + du; *(t++) = a + dv;
*(t++) = b + du; *(t++) = b + dv;
// right
*(v++) = x; *(v++) = y - n; *(v++) = z - n;
*(v++) = x; *(v++) = y + n; *(v++) = z + n;
*(v++) = x; *(v++) = y - n; *(v++) = z + n;
*(v++) = x; *(v++) = y - n; *(v++) = z - n;
*(v++) = x; *(v++) = y + n; *(v++) = z - n;
*(v++) = x; *(v++) = y + n; *(v++) = z + n;
*(d++) = 1; *(d++) = 0; *(d++) = 0;
*(d++) = 1; *(d++) = 0; *(d++) = 0;
*(d++) = 1; *(d++) = 0; *(d++) = 0;
*(d++) = 1; *(d++) = 0; *(d++) = 0;
*(d++) = 1; *(d++) = 0; *(d++) = 0;
*(d++) = 1; *(d++) = 0; *(d++) = 0;
*(t++) = b + du; *(t++) = a + dv;
*(t++) = a + du; *(t++) = b + dv;
*(t++) = a + du; *(t++) = a + dv;
*(t++) = b + du; *(t++) = a + dv;
*(t++) = b + du; *(t++) = b + dv;
*(t++) = a + du; *(t++) = b + dv;
// front
*(v++) = x - n; *(v++) = y - n; *(v++) = z;
*(v++) = x + n; *(v++) = y - n; *(v++) = z;
*(v++) = x + n; *(v++) = y + n; *(v++) = z;
*(v++) = x - n; *(v++) = y - n; *(v++) = z;
*(v++) = x + n; *(v++) = y + n; *(v++) = z;
*(v++) = x - n; *(v++) = y + n; *(v++) = z;
*(d++) = 0; *(d++) = 0; *(d++) = -1;
*(d++) = 0; *(d++) = 0; *(d++) = -1;
*(d++) = 0; *(d++) = 0; *(d++) = -1;
*(d++) = 0; *(d++) = 0; *(d++) = -1;
*(d++) = 0; *(d++) = 0; *(d++) = -1;
*(d++) = 0; *(d++) = 0; *(d++) = -1;
*(t++) = b + du; *(t++) = a + dv;
*(t++) = a + du; *(t++) = a + dv;
*(t++) = a + du; *(t++) = b + dv;
*(t++) = b + du; *(t++) = a + dv;
*(t++) = a + du; *(t++) = b + dv;
*(t++) = b + du; *(t++) = b + dv;
// back
*(v++) = x - n; *(v++) = y - n; *(v++) = z;
*(v++) = x + n; *(v++) = y + n; *(v++) = z;
*(v++) = x + n; *(v++) = y - n; *(v++) = z;
*(v++) = x - n; *(v++) = y - n; *(v++) = z;
*(v++) = x - n; *(v++) = y + n; *(v++) = z;
*(v++) = x + n; *(v++) = y + n; *(v++) = z;
*(d++) = 0; *(d++) = 0; *(d++) = 1;
*(d++) = 0; *(d++) = 0; *(d++) = 1;
*(d++) = 0; *(d++) = 0; *(d++) = 1;
*(d++) = 0; *(d++) = 0; *(d++) = 1;
*(d++) = 0; *(d++) = 0; *(d++) = 1;
*(d++) = 0; *(d++) = 0; *(d++) = 1;
*(t++) = a + du; *(t++) = a + dv;
*(t++) = b + du; *(t++) = b + dv;
*(t++) = b + du; *(t++) = a + dv;
*(t++) = a + du; *(t++) = a + dv;
*(t++) = a + du; *(t++) = b + dv;
*(t++) = b + du; *(t++) = b + dv;
// rotate the plant
float mat[16];
float vec[4] = {0};
mat_rotate(mat, 0, 1, 0, RADIANS(rotation));
for (int i = 0; i < 24; i++) {
// vertex
v = vertex + i * 3;
vec[0] = *(v++) - x; vec[1] = *(v++) - y; vec[2] = *(v++) - z;
mat_vec_multiply(vec, mat, vec);
v = vertex + i * 3;
*(v++) = vec[0] + x; *(v++) = vec[1] + y; *(v++) = vec[2] + z;
// normal
d = normal + i * 3;
vec[0] = *(d++); vec[1] = *(d++); vec[2] = *(d++);
mat_vec_multiply(vec, mat, vec);
d = normal + i * 3;
*(d++) = vec[0]; *(d++) = vec[1]; *(d++) = vec[2];
}
}