UnitConverter::UnitConverter() : unit(), up_axis(COLLADAFW::FileInfo::Z_UP)
{
unit_m4(x_up_mat4);
rotate_m4(x_up_mat4, 'Y', -0.5 * M_PI);
unit_m4(y_up_mat4);
rotate_m4(y_up_mat4, 'X', 0.5 * M_PI);
unit_m4(z_up_mat4);
unit_m4(scale_mat4);
}
static void object_warp_calc_view_matrix(float r_mat_view[4][4], float r_center_view[3],
Object *obedit, float viewmat[4][4], const float center[3],
const float offset_angle)
{
float mat_offset[4][4];
float viewmat_roll[4][4];
/* apply the rotation offset by rolling the view */
unit_m4(mat_offset);
rotate_m4(mat_offset, 'Z', offset_angle);
mul_m4_m4m4(viewmat_roll, mat_offset, viewmat);
/* apply the view and the object matrix */
mul_m4_m4m4(r_mat_view, viewmat_roll, obedit->obmat);
/* get the view-space cursor */
mul_v3_m4v3(r_center_view, viewmat_roll, center);
}
/* Get 4x4 transformation matrix which corresponds to
* stabilization data and used for easy coordinate
* transformation.
*
* NOTE: The reason it is 4x4 matrix is because it's
* used for OpenGL drawing directly.
*/
void BKE_tracking_stabilization_data_to_mat4(int width, int height, float aspect,
float translation[2], float scale, float angle,
float mat[4][4])
{
float translation_mat[4][4], rotation_mat[4][4], scale_mat[4][4],
center_mat[4][4], inv_center_mat[4][4],
aspect_mat[4][4], inv_aspect_mat[4][4];
float scale_vector[3] = {scale, scale, scale};
unit_m4(translation_mat);
unit_m4(rotation_mat);
unit_m4(scale_mat);
unit_m4(center_mat);
unit_m4(aspect_mat);
/* aspect ratio correction matrix */
aspect_mat[0][0] = 1.0f / aspect;
invert_m4_m4(inv_aspect_mat, aspect_mat);
/* image center as rotation center
*
* Rotation matrix is constructing in a way rotation happens around image center,
* and it's matter of calculating translation in a way, that applying translation
* after rotation would make it so rotation happens around median point of tracks
* used for translation stabilization.
*/
center_mat[3][0] = (float)width / 2.0f;
center_mat[3][1] = (float)height / 2.0f;
invert_m4_m4(inv_center_mat, center_mat);
size_to_mat4(scale_mat, scale_vector); /* scale matrix */
add_v2_v2(translation_mat[3], translation); /* translation matrix */
rotate_m4(rotation_mat, 'Z', angle); /* rotation matrix */
/* compose transformation matrix */
mul_serie_m4(mat, translation_mat, center_mat, aspect_mat, rotation_mat, inv_aspect_mat,
scale_mat, inv_center_mat, NULL);
}
static void make_duplis_font(const DupliContext *ctx)
{
Object *par = ctx->object;
GHash *family_gh;
Object *ob;
Curve *cu;
struct CharTrans *ct, *chartransdata = NULL;
float vec[3], obmat[4][4], pmat[4][4], fsize, xof, yof;
int text_len, a;
size_t family_len;
const wchar_t *text = NULL;
bool text_free = false;
/* font dupliverts not supported inside groups */
if (ctx->group)
return;
copy_m4_m4(pmat, par->obmat);
/* in par the family name is stored, use this to find the other objects */
BKE_vfont_to_curve_ex(G.main, par, FO_DUPLI, NULL,
&text, &text_len, &text_free, &chartransdata);
if (text == NULL || chartransdata == NULL) {
return;
}
cu = par->data;
fsize = cu->fsize;
xof = cu->xof;
yof = cu->yof;
ct = chartransdata;
/* cache result */
family_len = strlen(cu->family);
family_gh = BLI_ghash_int_new_ex(__func__, 256);
/* advance matching BLI_strncpy_wchar_from_utf8 */
for (a = 0; a < text_len; a++, ct++) {
ob = find_family_object(cu->family, family_len, (unsigned int)text[a], family_gh);
if (ob) {
vec[0] = fsize * (ct->xof - xof);
vec[1] = fsize * (ct->yof - yof);
vec[2] = 0.0;
mul_m4_v3(pmat, vec);
copy_m4_m4(obmat, par->obmat);
if (UNLIKELY(ct->rot != 0.0f)) {
float rmat[4][4];
zero_v3(obmat[3]);
unit_m4(rmat);
rotate_m4(rmat, 'Z', -ct->rot);
mul_m4_m4m4(obmat, obmat, rmat);
}
copy_v3_v3(obmat[3], vec);
make_dupli(ctx, ob, obmat, a, false, false);
}
}
if (text_free) {
MEM_freeN((void *)text);
}
BLI_ghash_free(family_gh, NULL, NULL);
MEM_freeN(chartransdata);
}
CompBuf* node_composit_transform(CompBuf *cbuf, float x, float y, float angle, float scale, int filter_type)
{
CompBuf *stackbuf= alloc_compbuf(cbuf->x, cbuf->y, CB_RGBA, 1);
ImBuf *ibuf, *obuf;
float mat[4][4], lmat[4][4], rmat[4][4], smat[4][4], cmat[4][4], icmat[4][4];
float svec[3]= {scale, scale, scale}, loc[2]= {x, y};
unit_m4(rmat);
unit_m4(lmat);
unit_m4(smat);
unit_m4(cmat);
/* image center as rotation center */
cmat[3][0]= (float)cbuf->x/2.0f;
cmat[3][1]= (float)cbuf->y/2.0f;
invert_m4_m4(icmat, cmat);
size_to_mat4(smat, svec); /* scale matrix */
add_v2_v2(lmat[3], loc); /* tranlation matrix */
rotate_m4(rmat, 'Z', angle); /* rotation matrix */
/* compose transformation matrix */
mul_serie_m4(mat, lmat, cmat, rmat, smat, icmat, NULL, NULL, NULL);
invert_m4(mat);
ibuf= IMB_allocImBuf(cbuf->x, cbuf->y, 32, 0);
obuf= IMB_allocImBuf(stackbuf->x, stackbuf->y, 32, 0);
if (ibuf && obuf) {
int i, j;
ibuf->rect_float= cbuf->rect;
obuf->rect_float= stackbuf->rect;
for (j=0; j<cbuf->y; j++) {
for (i=0; i<cbuf->x;i++) {
float vec[3]= {i, j, 0};
mul_v3_m4v3(vec, mat, vec);
switch(filter_type) {
case 0:
neareast_interpolation(ibuf, obuf, vec[0], vec[1], i, j);
break;
case 1:
bilinear_interpolation(ibuf, obuf, vec[0], vec[1], i, j);
break;
case 2:
bicubic_interpolation(ibuf, obuf, vec[0], vec[1], i, j);
break;
}
}
}
IMB_freeImBuf(ibuf);
IMB_freeImBuf(obuf);
}
/* pass on output and free */
return stackbuf;
}
int main(void)
{
if(!glfwInit()) {
printf("Could not init GLFW");
getchar();
return -1;
}
glfwWindowHint(GLFW_SAMPLES, 4);
//Opengl 2.1
//glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
//glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
//Opengl 3.3
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // MacOS fix
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
if(window_init(&window, 640, 480, "Test")) {
fprintf( stderr, "Failed to open window.\n" );
getchar();
glfwTerminate();
};
window_set_size_callback(&window, window_size_callback);
glewExperimental = GL_TRUE; // Needed for core profile
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Failed to initialize GLEW\n");
getchar();
glfwTerminate();
return -1;
}
//#clear errors GLEW may trigger
printError();
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
GLuint VertexArrayID;
glGenVertexArrays(1, &VertexArrayID);
glBindVertexArray(VertexArrayID);
//Load model
//----------
Model cube;
model_init(&cube);
model_set_data_length(&cube, sizeof(cube_vertex_data));
model_set_vertices(&cube, cube_vertex_data);
model_set_colors(&cube, cube_color_data);
model_set_uv_map(&cube, cube_uv_data);
model_set_texture(&cube, "./textures/bricks.dds");
model_bind(&cube);
//Create shaders
//--------------
GLuint vertexShader, fragmentShader;
loadShader(&vertexShader, GL_VERTEX_SHADER, mvpVertexShaderSource);
loadShader(&fragmentShader, GL_FRAGMENT_SHADER, fragmentShaderSource);
//Create program
//--------------
GLuint program;
createProgram(&program, vertexShader, fragmentShader);
// Enable z-buffer
// ---------------
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// Enable culling
// --------------
glEnable(GL_CULL_FACE);
// Get MVP uniform
// ---------------
GLuint mvp_ul = glGetUniformLocation(program, "MVP");
// Model Matrix
// ------------
Mat4 s;
scale_m4(&s, 0.1f, 0.1f, 0.1f);
printf("Scale:\n");
print_m4(&s);
Mat4 r;
rotate_m4(&r, 0.0f, 1.0f, 0.0f, 0.0f);
printf("Rotate:\n");
print_m4(&r);
Mat4 t;
translate_m4(&t, 0.0f, 0.0f, 0.0f);
printf("Translate:\n");
print_m4(&t);
Mat4 rs;
printf("Rotated*Scaled:\n");
mul_m4(&rs, &r, &s);
print_m4(&rs);
Mat4 model;
printf("Model:\n");
mul_m4(&model, &t, &rs);
print_m4(&model);
// Camera
// ------
Vec3 pos;
Vec3 center;
Vec3 up;
Vec3 direction;
Vec3 right;
camera_init(&camera);
camera_set_fov(&camera, 1.0f);
camera_set_aspect(&camera, (float)window.width/(float)window.height);
Input input;
input_init(&input, &window, 0.5f, 0.5f, 0.8f, -5.7f, -2.7f);
do {
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glUseProgram(program);
input_get_data(&input, &pos, &direction, &right);
add_v3(¢er, &pos, &direction);
cross_v3(&up, &direction, &right);
camera_set_position(&camera, &pos);
camera_set_center(&camera, ¢er);
camera_set_up(&camera, &up);
// Mvp Matrix
// ----------
Mat4 vp;
camera_get_matrix(&camera, &vp);
Mat4 mvp;
mul_m4(&mvp, &vp, &model);
printf("Perspective:\n");
print_m4(&mvp);
// Set MVP transform
glUniformMatrix4fv(mvp_ul, 1, GL_TRUE, &mvp[0][0]);
model_render(&cube);
window_swap_buffers(&window);
glfwPollEvents();
} while(
glfwGetKey(window.handle, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&
glfwWindowShouldClose(window.handle) == 0
);
// Dispose
// -------
model_dispose(&cube);
glDeleteVertexArrays(1, &VertexArrayID);
glDetachShader(program, fragmentShader);
glDetachShader(program, vertexShader);
glDeleteShader(fragmentShader);
glDeleteShader(vertexShader);
glDeleteProgram(program);
glfwTerminate();
return 0;
}
