static PyObject * wrap_calculate_matrix(PyObject *self, PyObject *args) { PyObject *result; PycairoSurface *py_surface; PycairoMatrix *py_matrix; cairo_matrix_t *matrix; float mm_x, mm_y, mm_width, mm_height; if (!PyArg_ParseTuple(args, "O!O!ffff", &PycairoImageSurface_Type, &py_surface, &PycairoMatrix_Type, &py_matrix, &mm_x, &mm_y, &mm_width, &mm_height)) return NULL; matrix = calculate_matrix(py_surface->surface, &py_matrix->matrix, mm_x, mm_y, mm_width, mm_height); if (matrix) { result = PycairoMatrix_FromMatrix(matrix); g_free(matrix); return result; } else { PyErr_SetString(PyExc_AssertionError, "Could not calculate the matrix!"); return NULL; } }
int main(int argc, const char *argv[]) { srandom(time(NULL)); crc_selftest(); a5_selftest(); if (argc < 2 || *(argv[1]) < '0' || *(argv[1]) > '3') { printf("Usage: precomp {0-3}\n"); exit(1); } u_int offset = *(argv[1]) - '0'; printf("calculating data for offset %d\n", offset); init_Kg(Kg); FILE *file = fopen(matrixnames[offset], "w"); if (! file) { perror("fopen"); exit(1); } for (u_int R4 = (1 << 10); R4 < 0x20000; R4++) { // for (u_int R4 = (1 << 10); R4 < 0x1000; R4++) { if ((R4 & (1 << 10)) == 0) { continue; } if (R4 % 1000 == 0) { printf("%08x\n", R4); } calculate_matrix(R4, offset, file); } fclose(file); return 0; }
void AffineUnit::process_package(LoadPackage *package) { AffinePackage *pkg = (AffinePackage*)package; int min_in_x = server->in_x; int min_in_y = server->in_y; int max_in_x = server->in_x + server->in_w - 1; int max_in_y = server->in_y + server->in_h - 1; int min_out_x = server->out_x; int min_out_y = server->out_y; int max_out_x = server->out_x + server->out_w; int max_out_y = server->out_y + server->out_h; // Amount to shift the input coordinates relative to the output coordinates // To get the pivots to line up int pivot_offset_x = server->in_pivot_x - server->out_pivot_x; int pivot_offset_y = server->in_pivot_y - server->out_pivot_y; // Calculate real coords float out_x1, out_y1, out_x2, out_y2, out_x3, out_y3, out_x4, out_y4; if(server->mode == AffineEngine::STRETCH || server->mode == AffineEngine::PERSPECTIVE || server->mode == AffineEngine::ROTATE) { out_x1 = (float)server->in_x + (float)server->x1 * server->in_w / 100; out_y1 = (float)server->in_y + (float)server->y1 * server->in_h / 100; out_x2 = (float)server->in_x + (float)server->x2 * server->in_w / 100; out_y2 = (float)server->in_y + (float)server->y2 * server->in_h / 100; out_x3 = (float)server->in_x + (float)server->x3 * server->in_w / 100; out_y3 = (float)server->in_y + (float)server->y3 * server->in_h / 100; out_x4 = (float)server->in_x + (float)server->x4 * server->in_w / 100; out_y4 = (float)server->in_y + (float)server->y4 * server->in_h / 100; } else { out_x1 = (float)server->in_x + (float)server->x1 * server->in_w / 100; out_y1 = server->in_y; out_x2 = out_x1 + server->in_w; out_y2 = server->in_y; out_x4 = (float)server->in_x + (float)server->x4 * server->in_w / 100; out_y4 = server->in_y + server->in_h; out_x3 = out_x4 + server->in_w; out_y3 = server->in_y + server->in_h; } // Rotation with OpenGL uses a simple quad. if(server->mode == AffineEngine::ROTATE && server->use_opengl) { #ifdef HAVE_GL server->output->to_texture(); server->output->enable_opengl(); server->output->init_screen(); server->output->bind_texture(0); server->output->clear_pbuffer(); int texture_w = server->output->get_texture_w(); int texture_h = server->output->get_texture_h(); float output_h = server->output->get_h(); float in_x1 = (float)server->in_x / texture_w; float in_x2 = (float)(server->in_x + server->in_w) / texture_w; float in_y1 = (float)server->in_y / texture_h; float in_y2 = (float)(server->in_y + server->in_h) / texture_h; glBegin(GL_QUADS); glNormal3f(0, 0, 1.0); glTexCoord2f(in_x1, in_y1); glVertex3f(out_x1, -output_h+out_y1, 0); glTexCoord2f(in_x2, in_y1); glVertex3f(out_x2, -output_h+out_y2, 0); glTexCoord2f(in_x2, in_y2); glVertex3f(out_x3, -output_h+out_y3, 0); glTexCoord2f(in_x1, in_y2); glVertex3f(out_x4, -output_h+out_y4, 0); glEnd(); server->output->set_opengl_state(VFrame::SCREEN); #endif } else if(server->mode == AffineEngine::PERSPECTIVE || server->mode == AffineEngine::SHEER || server->mode == AffineEngine::ROTATE) { AffineMatrix matrix; float temp; // swap points 3 & 4 temp = out_x4; out_x4 = out_x3; out_x3 = temp; temp = out_y4; out_y4 = out_y3; out_y3 = temp; calculate_matrix( server->in_x, server->in_y, server->in_x + server->in_w, server->in_y + server->in_h, out_x1, out_y1, out_x2, out_y2, out_x3, out_y3, out_x4, out_y4, &matrix); int interpolate = 1; int reverse = !server->forward; float tx, ty, tw; float xinc, yinc, winc; AffineMatrix m, im; float ttx = 0, tty = 0; int itx = 0, ity = 0; int tx1 = 0, ty1 = 0, tx2 = 0, ty2 = 0; if(reverse) { m.copy_from(&matrix); m.invert(&im); matrix.copy_from(&im); } else { matrix.invert(&m); } float dx1 = 0, dy1 = 0; float dx2 = 0, dy2 = 0; float dx3 = 0, dy3 = 0; float dx4 = 0, dy4 = 0; matrix.transform_point(server->in_x, server->in_y, &dx1, &dy1); matrix.transform_point(server->in_x + server->in_w, server->in_y, &dx2, &dy2); matrix.transform_point(server->in_x, server->in_y + server->in_h, &dx3, &dy3); matrix.transform_point(server->in_x + server->in_w, server->in_y + server->in_h, &dx4, &dy4); if(server->use_opengl) { #ifdef HAVE_GL static char *affine_frag = (char*)"uniform sampler2D tex;\n" "uniform mat3 affine_matrix;\n" "uniform vec2 texture_extents;\n" "uniform vec2 image_extents;\n" "uniform vec4 border_color;\n" "void main()\n" "{\n" " vec2 outcoord = gl_TexCoord[0].st;\n" " outcoord *= texture_extents;\n" " mat3 coord_matrix = mat3(\n" " outcoord.x, outcoord.y, 1.0, \n" " outcoord.x, outcoord.y, 1.0, \n" " outcoord.x, outcoord.y, 1.0);\n" " mat3 incoord_matrix = affine_matrix * coord_matrix;\n" " vec2 incoord = vec2(incoord_matrix[0][0], incoord_matrix[0][1]);\n" " incoord /= incoord_matrix[0][2];\n" " incoord /= texture_extents;\n" " if(incoord.x > image_extents.x || incoord.y > image_extents.y)\n" " gl_FragColor = border_color;\n" " else\n" " gl_FragColor = texture2D(tex, incoord);\n" "}\n"; float affine_matrix[9] = { (float)m.values[0][0], (float)m.values[1][0], (float)m.values[2][0], (float)m.values[0][1], (float)m.values[1][1], (float)m.values[2][1], (float)m.values[0][2], (float)m.values[1][2], (float)m.values[2][2] }; server->output->to_texture(); server->output->enable_opengl(); unsigned int frag_shader = VFrame::make_shader(0, affine_frag, 0); if(frag_shader > 0) { glUseProgram(frag_shader); glUniform1i(glGetUniformLocation(frag_shader, "tex"), 0); glUniformMatrix3fv(glGetUniformLocation(frag_shader, "affine_matrix"), 1, 0, affine_matrix); glUniform2f(glGetUniformLocation(frag_shader, "texture_extents"), (GLfloat)server->output->get_texture_w(), (GLfloat)server->output->get_texture_h()); glUniform2f(glGetUniformLocation(frag_shader, "image_extents"), (GLfloat)server->output->get_w() / server->output->get_texture_w(), (GLfloat)server->output->get_h() / server->output->get_texture_h()); float border_color[] = { 0, 0, 0, 0 }; if(BC_CModels::is_yuv(server->output->get_color_model())) { border_color[1] = 0.5; border_color[2] = 0.5; } if(!BC_CModels::has_alpha(server->output->get_color_model())) { border_color[3] = 1.0; } glUniform4fv(glGetUniformLocation(frag_shader, "border_color"), 1, (GLfloat*)border_color); server->output->init_screen(); server->output->bind_texture(0); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); server->output->draw_texture(); glUseProgram(0); server->output->set_opengl_state(VFrame::SCREEN); } return; #endif // HAVE_GL } #define ROUND(x) ((int)((x > 0) ? (x) + 0.5 : (x) - 0.5)) #define MIN4(a,b,c,d) MIN(MIN(MIN(a,b),c),d) #define MAX4(a,b,c,d) MAX(MAX(MAX(a,b),c),d) tx1 = ROUND(MIN4(dx1 - pivot_offset_x, dx2 - pivot_offset_x, dx3 - pivot_offset_x, dx4 - pivot_offset_x)); ty1 = ROUND(MIN4(dy1 - pivot_offset_y, dy2 - pivot_offset_y, dy3 - pivot_offset_y, dy4 - pivot_offset_y)); tx2 = ROUND(MAX4(dx1 - pivot_offset_x, dx2 - pivot_offset_x, dx3 - pivot_offset_x, dx4 - pivot_offset_x)); ty2 = ROUND(MAX4(dy1 - pivot_offset_y, dy2 - pivot_offset_y, dy3 - pivot_offset_y, dy4 - pivot_offset_y)); CLAMP(ty1, pkg->y1, pkg->y2); CLAMP(ty2, pkg->y1, pkg->y2); CLAMP(tx1, server->out_x, server->out_x + server->out_w); CLAMP(tx2, server->out_x, server->out_x + server->out_w); xinc = m.values[0][0]; yinc = m.values[1][0]; winc = m.values[2][0]; #define CUBIC_ROW(in_row, chroma_offset) \ transform_cubic(dx, \ in_row[col1_offset] - chroma_offset, \ in_row[col2_offset] - chroma_offset, \ in_row[col3_offset] - chroma_offset, \ in_row[col4_offset] - chroma_offset) #define TRANSFORM(components, type, temp_type, chroma_offset, max) \ { \ type **in_rows = (type**)server->input->get_rows(); \ float round_factor = 0.0; \ if(sizeof(type) < 4) round_factor = 0.5; \ for(int y = ty1; y < ty2; y++) \ { \ type *out_row = (type*)server->output->get_rows()[y]; \ \ if(!interpolate) \ { \ tx = xinc * (tx1 + 0.5) + \ m.values[0][1] * (y + pivot_offset_y + 0.5) + \ m.values[0][2] + \ pivot_offset_x * xinc; \ ty = yinc * (tx1 + 0.5) + \ m.values[1][1] * (y + pivot_offset_y + 0.5) + \ m.values[1][2] + \ pivot_offset_x * yinc; \ tw = winc * (tx1 + 0.5) + \ m.values[2][1] * (y + pivot_offset_y + 0.5) + \ m.values[2][2] + \ pivot_offset_x * winc; \ } \ else \ { \ tx = xinc * tx1 + \ m.values[0][1] * (y + pivot_offset_y) + \ m.values[0][2] + \ pivot_offset_x * xinc; \ ty = yinc * tx1 + \ m.values[1][1] * (y + pivot_offset_y) + \ m.values[1][2] + \ pivot_offset_x * yinc; \ tw = winc * tx1 + \ m.values[2][1] * (y + pivot_offset_y) + \ m.values[2][2] + \ pivot_offset_x * winc; \ } \ \ out_row += tx1 * components; \ for(int x = tx1; x < tx2; x++) \ { \ /* Normalize homogeneous coords */ \ if(tw == 0.0) \ { \ ttx = 0.0; \ tty = 0.0; \ } \ else \ if(tw != 1.0) \ { \ ttx = tx / tw; \ tty = ty / tw; \ } \ else \ { \ ttx = tx; \ tty = ty; \ } \ itx = (int)ttx; \ ity = (int)tty; \ \ int row1 = ity - 1; \ int row2 = ity; \ int row3 = ity + 1; \ int row4 = ity + 2; \ CLAMP(row1, min_in_y, max_in_y); \ CLAMP(row2, min_in_y, max_in_y); \ CLAMP(row3, min_in_y, max_in_y); \ CLAMP(row4, min_in_y, max_in_y); \ \ /* Set destination pixels if in clipping region */ \ if(!interpolate && \ x >= min_out_x && \ x < max_out_x) \ { \ if(itx >= min_in_x && \ itx <= max_in_x && \ ity >= min_in_y && \ ity <= max_in_y) \ { \ type *src = in_rows[ity] + itx * components; \ *out_row++ = *src++; \ *out_row++ = *src++; \ *out_row++ = *src++; \ if(components == 4) *out_row++ = *src; \ } \ else \ /* Fill with chroma */ \ { \ *out_row++ = 0; \ *out_row++ = chroma_offset; \ *out_row++ = chroma_offset; \ if(components == 4) *out_row++ = 0; \ } \ } \ else \ /* Bicubic algorithm */ \ if(interpolate && \ x >= min_out_x && \ x < max_out_x) \ { \ /* clipping region */ \ if ((itx + 2) >= min_in_x && \ (itx - 1) <= max_in_x && \ (ity + 2) >= min_in_y && \ (ity - 1) <= max_in_y) \ { \ float dx, dy; \ \ /* the fractional error */ \ dx = ttx - itx; \ dy = tty - ity; \ \ /* Row and column offsets in cubic block */ \ int col1 = itx - 1; \ int col2 = itx; \ int col3 = itx + 1; \ int col4 = itx + 2; \ CLAMP(col1, min_in_x, max_in_x); \ CLAMP(col2, min_in_x, max_in_x); \ CLAMP(col3, min_in_x, max_in_x); \ CLAMP(col4, min_in_x, max_in_x); \ int col1_offset = col1 * components; \ int col2_offset = col2 * components; \ int col3_offset = col3 * components; \ int col4_offset = col4 * components; \ \ type *row1_ptr = in_rows[row1]; \ type *row2_ptr = in_rows[row2]; \ type *row3_ptr = in_rows[row3]; \ type *row4_ptr = in_rows[row4]; \ temp_type r, g, b, a; \ \ r = (temp_type)(transform_cubic(dy, \ CUBIC_ROW(row1_ptr, 0x0), \ CUBIC_ROW(row2_ptr, 0x0), \ CUBIC_ROW(row3_ptr, 0x0), \ CUBIC_ROW(row4_ptr, 0x0)) + \ round_factor); \ \ row1_ptr++; \ row2_ptr++; \ row3_ptr++; \ row4_ptr++; \ g = (temp_type)(transform_cubic(dy, \ CUBIC_ROW(row1_ptr, chroma_offset), \ CUBIC_ROW(row2_ptr, chroma_offset), \ CUBIC_ROW(row3_ptr, chroma_offset), \ CUBIC_ROW(row4_ptr, chroma_offset)) + \ round_factor); \ g += chroma_offset; \ \ row1_ptr++; \ row2_ptr++; \ row3_ptr++; \ row4_ptr++; \ b = (temp_type)(transform_cubic(dy, \ CUBIC_ROW(row1_ptr, chroma_offset), \ CUBIC_ROW(row2_ptr, chroma_offset), \ CUBIC_ROW(row3_ptr, chroma_offset), \ CUBIC_ROW(row4_ptr, chroma_offset)) + \ round_factor); \ b += chroma_offset; \ \ if(components == 4) \ { \ row1_ptr++; \ row2_ptr++; \ row3_ptr++; \ row4_ptr++; \ a = (temp_type)(transform_cubic(dy, \ CUBIC_ROW(row1_ptr, 0x0), \ CUBIC_ROW(row2_ptr, 0x0), \ CUBIC_ROW(row3_ptr, 0x0), \ CUBIC_ROW(row4_ptr, 0x0)) + \ round_factor); \ } \ \ if(sizeof(type) < 4) \ { \ *out_row++ = CLIP(r, 0, max); \ *out_row++ = CLIP(g, 0, max); \ *out_row++ = CLIP(b, 0, max); \ if(components == 4) *out_row++ = CLIP(a, 0, max); \ } \ else \ { \ *out_row++ = r; \ *out_row++ = g; \ *out_row++ = b; \ if(components == 4) *out_row++ = a; \ } \ } \ else \ /* Fill with chroma */ \ { \ *out_row++ = 0; \ *out_row++ = chroma_offset; \ *out_row++ = chroma_offset; \ if(components == 4) *out_row++ = 0; \ } \ } \ else \ { \ out_row += components; \ } \ \ /* increment the transformed coordinates */ \ tx += xinc; \ ty += yinc; \ tw += winc; \ } \ } \ } switch(server->input->get_color_model()) { case BC_RGB_FLOAT: TRANSFORM(3, float, float, 0x0, 1.0) break; case BC_RGB888: TRANSFORM(3, unsigned char, int, 0x0, 0xff) break; case BC_RGBA_FLOAT: TRANSFORM(4, float, float, 0x0, 1.0) break; case BC_RGBA8888: TRANSFORM(4, unsigned char, int, 0x0, 0xff) break; case BC_YUV888: { unsigned char **in_rows = (unsigned char**)server->input->get_rows(); float round_factor = 0.0; if(sizeof(unsigned char) < 4) round_factor = 0.5; for(int y = ty1; y < ty2; y++) { unsigned char *out_row = (unsigned char*)server->output->get_rows()[y]; if(!interpolate) { tx = xinc * (tx1 + 0.5) + m.values[0][1] * (y + pivot_offset_y + 0.5) + m.values[0][2] + pivot_offset_x * xinc; ty = yinc * (tx1 + 0.5) + m.values[1][1] * (y + pivot_offset_y + 0.5) + m.values[1][2] + pivot_offset_x * yinc; tw = winc * (tx1 + 0.5) + m.values[2][1] * (y + pivot_offset_y + 0.5) + m.values[2][2] + pivot_offset_x * winc; } else { tx = xinc * tx1 + m.values[0][1] * (y + pivot_offset_y) + m.values[0][2] + pivot_offset_x * xinc; ty = yinc * tx1 + m.values[1][1] * (y + pivot_offset_y) + m.values[1][2] + pivot_offset_x * yinc; tw = winc * tx1 + m.values[2][1] * (y + pivot_offset_y) + m.values[2][2] + pivot_offset_x * winc; } out_row += tx1 * 3; for(int x = tx1; x < tx2; x++) { // Normalize homogeneous coords if(tw == 0.0) { ttx = 0.0; tty = 0.0; } else if(tw != 1.0) { ttx = tx / tw; tty = ty / tw; } else { ttx = tx; tty = ty; } itx = (int)ttx; ity = (int)tty; int row1 = ity - 1; int row2 = ity; int row3 = ity + 1; int row4 = ity + 2; CLAMP(row1, min_in_y, max_in_y); CLAMP(row2, min_in_y, max_in_y); CLAMP(row3, min_in_y, max_in_y); CLAMP(row4, min_in_y, max_in_y); // Set destination pixels if in clipping region if(!interpolate && x >= min_out_x && x < max_out_x) { if(itx >= min_in_x && itx <= max_in_x && ity >= min_in_y && ity <= max_in_y) { unsigned char *src = in_rows[ity] + itx * 3; *out_row++ = *src++; *out_row++ = *src++; *out_row++ = *src++; } else // Fill with chroma { *out_row++ = 0; *out_row++ = 0x80; *out_row++ = 0x80; } } else // Bicubic algorithm if(interpolate && x >= min_out_x && x < max_out_x) { // clipping region if((itx + 2) >= min_in_x && (itx - 1) <= max_in_x && (ity + 2) >= min_in_y && (ity - 1) <= max_in_y) { float dx, dy; // the fractional error dx = ttx - itx; dy = tty - ity; // Row and column offsets in cubic block int col1 = itx - 1; int col2 = itx; int col3 = itx + 1; int col4 = itx + 2; CLAMP(col1, min_in_x, max_in_x); CLAMP(col2, min_in_x, max_in_x); CLAMP(col3, min_in_x, max_in_x); CLAMP(col4, min_in_x, max_in_x); int col1_offset = col1 * 3; int col2_offset = col2 * 3; int col3_offset = col3 * 3; int col4_offset = col4 * 3; unsigned char *row1_ptr = in_rows[row1]; unsigned char *row2_ptr = in_rows[row2]; unsigned char *row3_ptr = in_rows[row3]; unsigned char *row4_ptr = in_rows[row4]; int r, g, b, a; r = (int)(transform_cubic(dy, CUBIC_ROW(row1_ptr, 0x0), CUBIC_ROW(row2_ptr, 0x0), CUBIC_ROW(row3_ptr, 0x0), CUBIC_ROW(row4_ptr, 0x0)) + round_factor); row1_ptr++; row2_ptr++; row3_ptr++; row4_ptr++; g = (int)(transform_cubic(dy, CUBIC_ROW(row1_ptr, 0x80), CUBIC_ROW(row2_ptr, 0x80), CUBIC_ROW(row3_ptr, 0x80), CUBIC_ROW(row4_ptr, 0x80)) + round_factor); g += 0x80; row1_ptr++; row2_ptr++; row3_ptr++; row4_ptr++; b = (int)(transform_cubic(dy, CUBIC_ROW(row1_ptr, 0x80), CUBIC_ROW(row2_ptr, 0x80), CUBIC_ROW(row3_ptr, 0x80), CUBIC_ROW(row4_ptr, 0x80)) + round_factor); b += 0x80; if(sizeof(unsigned char) < 4) { *out_row++ = CLIP(r, 0, 0xff); *out_row++ = CLIP(g, 0, 0xff); *out_row++ = CLIP(b, 0, 0xff); } else { *out_row++ = r; *out_row++ = g; *out_row++ = b; } } else // Fill with chroma { *out_row++ = 0; *out_row++ = 0x80; *out_row++ = 0x80; } } else { out_row += 3; } // increment the transformed coordinates tx += xinc; ty += yinc; tw += winc; } } } break; case BC_YUVA8888: TRANSFORM(4, unsigned char, int, 0x80, 0xff) break; case BC_RGB161616: TRANSFORM(3, uint16_t, int, 0x0, 0xffff) break; case BC_RGBA16161616: TRANSFORM(4, uint16_t, int, 0x0, 0xffff) break; case BC_YUV161616: TRANSFORM(3, uint16_t, int, 0x8000, 0xffff) break; case BC_YUVA16161616: TRANSFORM(4, uint16_t, int, 0x8000, 0xffff) break; } }
// The start of the Application int App::start(const std::vector<std::string> &args) { // Setup the window DisplayWindowDescription win_desc; win_desc.set_allow_resize(true); win_desc.set_title("Input Example"); win_desc.set_size(Size( 1000, 700 ), false); window = DisplayWindow(win_desc); // Connect the slots that we require Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); Slot slot_input_down = (window.get_ic().get_keyboard()).sig_key_down().connect(this, &App::on_input_down); Slot slot_mouse_down = (window.get_ic().get_mouse()).sig_key_down().connect(this, &App::on_mouse_down); Slot slot_mouse_dblclick = (window.get_ic().get_mouse()).sig_key_dblclk().connect(this, &App::on_mouse_down); std::vector<Slot> slot_joystick; int max_joysticks = window.get_ic().get_joystick_count(); for (int joystick_number=0; joystick_number < max_joysticks; joystick_number++) { Slot current_joystick = window.get_ic().get_joystick(joystick_number).sig_key_down().connect(this, &App::on_joystick_down, joystick_number); slot_joystick.push_back(current_joystick); } canvas = Canvas(window); font = clan::Font(canvas, "tahoma", 16); vector_font = VectorFont(canvas, "Bitstream Vera Sans", 256, "../../Display_Text/Font/Resources/bitstream_vera_sans/VeraBd.ttf"); calculate_matrix(canvas); while(!quit) { canvas.set_map_mode(map_2d_upper_left); canvas.fill_rect(Rect(0, 0, canvas.get_width(), canvas.get_height()/2), Gradient(Colorf(0.2f, 0.2f, 0.8f, 1.0f), Colorf(0.0f, 0.0f, 0.2f, 1.0f))); canvas.fill_rect(Rect(0, canvas.get_height()/2, canvas.get_width(), canvas.get_height()), Gradient(Colorf(0.0f, 0.0f, 0.2f, 1.0f), Colorf(0.2f, 0.2f, 0.8f, 1.0f))); font.draw_text(canvas, 8, 20, "Press any key, mouse button or joystick button to fire text. Use mouse to control direction."); int yoffset = canvas.get_height() - 20; const int y_gap = 20; // Draw Keyboard Information draw_keyboard_state(canvas, yoffset); yoffset -= y_gap; // Draw Mouse Information draw_mouse_state(canvas, yoffset); yoffset -= y_gap; // Draw Joysticks Information for (int joystick_number=0; joystick_number < max_joysticks; joystick_number++) { draw_joystick_state(canvas, joystick_number, yoffset); yoffset -= y_gap; } // Draw Tablet Information int max_tablets = window.get_ic().get_tablet_count(); for (int tablet_number=0; tablet_number < max_tablets; tablet_number++) { draw_tablet_state(canvas, tablet_number, yoffset); yoffset -= y_gap; } canvas.set_map_mode(map_user_projection); canvas.set_projection(projection_matrix); draw_text_shooter(canvas); window.flip(1); KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { // Setup the window CL_DisplayWindowDescription win_desc; win_desc.set_allow_resize(true); win_desc.set_title("Input Example"); win_desc.set_size(CL_Size( 700, 700 ), false); window = CL_DisplayWindow(win_desc); // Connect the slots that we require CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); CL_Slot slot_input_down = (window.get_ic().get_keyboard()).sig_key_down().connect(this, &App::on_input_down); CL_Slot slot_mouse_down = (window.get_ic().get_mouse()).sig_key_down().connect(this, &App::on_mouse_down); CL_Slot slot_mouse_dblclick = (window.get_ic().get_mouse()).sig_key_dblclk().connect(this, &App::on_mouse_down); std::vector<CL_Slot> slot_joystick; int max_joysticks = window.get_ic().get_joystick_count(); for (int joystick_number=0; joystick_number < max_joysticks; joystick_number++) { CL_Slot current_joystick = window.get_ic().get_joystick(joystick_number).sig_key_down().connect(this, &App::on_joystick_down, joystick_number); slot_joystick.push_back(current_joystick); } CL_GraphicContext gc = window.get_gc(); font = CL_Font(gc, "tahoma", 16); vector_font = CL_Font_Vector("../../Game/DiceWar/Resources/bitstream_vera_sans/VeraBd.ttf", 256); calculate_matrix(gc); while(!quit) { gc.set_map_mode(cl_map_2d_upper_left); CL_Draw::gradient_fill(gc, CL_Rect(0, 0, gc.get_width(), gc.get_height()/2), CL_Gradient(CL_Colorf(0.2f, 0.2f, 0.8f, 1.0f), CL_Colorf(0.0f, 0.0f, 0.2f, 1.0f))); CL_Draw::gradient_fill(gc, CL_Rect(0, gc.get_height()/2, gc.get_width(), gc.get_height()), CL_Gradient(CL_Colorf(0.0f, 0.0f, 0.2f, 1.0f), CL_Colorf(0.2f, 0.2f, 0.8f, 1.0f))); font.draw_text(gc, 8, 20, "Press any key, mouse button or joystick button to fire text. Use mouse to control direction."); int yoffset = gc.get_height() - 20; const int y_gap = 20; // Draw Keyboard Information draw_keyboard_state(gc, yoffset); yoffset -= y_gap; // Draw Mouse Information draw_mouse_state(gc, yoffset); yoffset -= y_gap; // Draw Joysticks Information for (int joystick_number=0; joystick_number < max_joysticks; joystick_number++) { draw_joystick_state(gc, joystick_number, yoffset); yoffset -= y_gap; } // Draw Tablet Information int max_tablets = window.get_ic().get_tablet_count(); for (int tablet_number=0; tablet_number < max_tablets; tablet_number++) { draw_tablet_state(gc, tablet_number, yoffset); yoffset -= y_gap; } gc.set_map_mode(cl_user_projection); gc.set_projection(projection_matrix); gc.set_modelview(modelview_matrix); draw_text_shooter(gc); window.flip(1); CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { // Setup the window CL_DisplayWindowDescription win_desc; win_desc.set_allow_resize(true); win_desc.set_title("3D GUI Example"); win_desc.set_size(CL_Size( 700, 700 ), false); window = CL_DisplayWindow(win_desc); // Connect the slots that we require CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); CL_Slot slot_input_down = (window.get_ic().get_keyboard()).sig_key_down().connect(this, &App::on_input_down); CL_GraphicContext gc = window.get_gc(); CL_Font font = CL_Font(gc, "tahoma", 16); // Initialise the GUI system GUI gui(this); // NOTE: The GUI component positions are still in 2D world, therefore // be careful not to overlap windows, else unpredicted results may occur! window1 = new Window1(gui, CL_Rect(0,0, CL_Size(256, 256))); slider_1_xrotation = new Slider(gui, CL_Rect(0, 512, CL_Size(200, 17))); slider_1_xrotation->object_matrix.translate_self(0.0f, 0.8f, 3.0f); slider_1_xrotation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_yrotation = new Slider(gui, CL_Rect(256*1, 512, CL_Size(200, 17))); slider_1_yrotation->object_matrix.translate_self(0.0f, 0.7f, 3.0f); slider_1_yrotation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_zrotation = new Slider(gui, CL_Rect(256*2, 512, CL_Size(200, 17))); slider_1_zrotation->object_matrix.translate_self(0.0f, 0.6f, 3.0f); slider_1_zrotation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_xtranslation = new Slider(gui, CL_Rect(256*3, 512, CL_Size(200, 17))); slider_1_xtranslation->object_matrix.translate_self(0.0f, 0.5f, 3.0f); slider_1_xtranslation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_xtranslation->component->set_position(500); slider_1_ytranslation = new Slider(gui, CL_Rect(256*4, 512, CL_Size(200, 17))); slider_1_ytranslation->object_matrix.translate_self(0.0f, 0.4f, 3.0f); slider_1_ytranslation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_ytranslation->component->set_position(500); slider_1_ztranslation = new Slider(gui, CL_Rect(256*5, 512, CL_Size(200, 17))); slider_1_ztranslation->object_matrix.translate_self(0.0f, 0.3f, 3.0f); slider_1_ztranslation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_ztranslation->component->set_position(500); while(!quit) { calculate_matrix(); gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(CL_MapMode(cl_map_2d_upper_left)); // Draw the gradient CL_Draw::gradient_fill(gc, CL_Rect(0, 0, gc.get_width(), gc.get_height()/2), CL_Gradient(CL_Colorf(0.2f, 0.2f, 0.8f, 1.0f), CL_Colorf(0.0f, 0.0f, 0.2f, 1.0f))); CL_Draw::gradient_fill(gc, CL_Rect(0, gc.get_height()/2, gc.get_width(), gc.get_height()), CL_Gradient(CL_Colorf(0.0f, 0.0f, 0.2f, 1.0f), CL_Colorf(0.2f, 0.2f, 0.8f, 1.0f))); font.draw_text(gc, 8, 20, "GUI3D"); int xoffset = 160; int yoffset = 70; const int ygap = 35; font.draw_text(gc, xoffset, yoffset, "X Rotation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "Y Rotation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "Z Rotation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "X Translation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "Y Translation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "Z Translation"); yoffset += ygap; if (!gui.run()) break; gc.set_map_mode(cl_user_projection); gc.set_projection(projection_matrix); gc.set_modelview(modelview_matrix); control_window(); gui.draw(); window.flip(1); CL_KeepAlive::process(); } return 0; }