int main(int argc, char** argv) { init_ogl(p_state); create_perspective_matrix(&p_state->p_matrix, 45, 1.0, 0.1, 100); identity(&p_state->mv_matrix); identity(&p_state->send_mv_matrix); rotate_matrix(&p_state->send_mv_matrix, 180, 1.0, 0, 0); translate_matrix(&p_state->send_mv_matrix, 0, 0, -5); //rotate_matrix(&p_state->mv_matrix, 45, 1.0, 0, 0); translate_matrix(&p_state->mv_matrix, 0, 0, -5); init_shaders(p_state); init_framebuffer(p_state); init_textures(p_state); encode_loop(p_state); while(1) { } // return NULL; }
glm::mat4 translate(glm::mat4 matrix, glm::vec3 translate_vector){ glm::mat4 translate_matrix(1.0); translate_matrix[3].x = translate_vector.x; translate_matrix[3].y = translate_vector.y; translate_matrix[3].z = translate_vector.z; //return translate_matrix; return matrix * translate_matrix; //return glm::translate(matrix, translate_vector); }
void *render_task(void *dummy) { init_ogl(p_state); create_perspective_matrix(&p_state->p_matrix, 45, 1.0, 0.1, 100); identity(&p_state->mv_matrix); identity(&p_state->send_mv_matrix); rotate_matrix(&p_state->send_mv_matrix, 180, 1.0, 0, 0); translate_matrix(&p_state->send_mv_matrix, 0, 0, -5); //rotate_matrix(&p_state->mv_matrix, 45, 1.0, 0, 0); translate_matrix(&p_state->mv_matrix, 0, -10, -15); init_shaders(p_state); init_framebuffer(p_state); init_textures(p_state); encode_loop(p_state, &robot); return NULL; }
void f_translate (void) { array_t *matrix; double x, y, z; Matrix current_matrix; Matrix trans_matrix; Matrix final_matrix; int i; if ((sp - 1)->type != T_REAL) { bad_arg(3, F_TRANSLATE); } if (sp->type != T_REAL) { bad_arg(4, F_TRANSLATE); } /* * get arguments from stack. */ matrix = (sp - 3)->u.arr; x = (sp - 2)->u.real; y = (sp - 1)->u.real; z = sp->u.real; sp -= 3; /* * convert vec matrix to float matrix. */ for (i = 0; i < 16; i++) { current_matrix[i] = matrix->item[i].u.real; } /* * create translation matrix. */ translate_matrix(x, y, z, trans_matrix); /* * compute transformed matrix. */ mult_matrix(current_matrix, trans_matrix, final_matrix); /* * convert float matrix to vec matrix. */ for (i = 0; i < 16; i++) { matrix->item[i].u.real = final_matrix[i]; } }
zimg_filter *zimg2_colorspace_create(const zimg_colorspace_params *params) { assert(params); API_VERSION_ASSERT(params->version); try { std::unique_ptr<zimg::IZimgFilter> colorspace_filter; zimg::colorspace::ColorspaceDefinition csp_in{}; zimg::colorspace::ColorspaceDefinition csp_out{}; zimg::PixelType pixel_type{}; unsigned width = 0; unsigned height = 0; unsigned depth = 0; bool range_in = false; bool range_out = false; if (params->version >= 2) { width = params->width; height = params->height; csp_in.matrix = translate_matrix(params->matrix_in); csp_in.transfer = translate_transfer(params->transfer_in); csp_in.primaries = translate_primaries(params->primaries_in); csp_out.matrix = translate_matrix(params->matrix_out); csp_out.transfer = translate_transfer(params->transfer_out); csp_out.primaries = translate_primaries(params->primaries_out); pixel_type = translate_pixel_type(params->pixel_type); depth = params->depth; range_in = translate_pixel_range(params->range_in); range_out = translate_pixel_range(params->range_out); } colorspace_filter.reset(new zimg::colorspace::ColorspaceConversion2{ width, height, csp_in, csp_out, g_cpu_type }); if (pixel_type != zimg::PixelType::FLOAT) { std::unique_ptr<zimg::IZimgFilter> to_float; std::unique_ptr<zimg::IZimgFilter> from_float; std::unique_ptr<zimg::IZimgFilter> pair_filter1; std::unique_ptr<zimg::IZimgFilter> pair_filter2; zimg::PixelFormat pixel_format = zimg::default_pixel_format(pixel_type); zimg::PixelFormat float_format = zimg::default_pixel_format(zimg::PixelType::FLOAT); bool yuv_in = csp_in.matrix != zimg::colorspace::MatrixCoefficients::MATRIX_RGB; bool yuv_out = csp_out.matrix != zimg::colorspace::MatrixCoefficients::MATRIX_RGB; pixel_format.depth = depth; pixel_format.fullrange = range_in; to_float.reset(create_depth_color_filter(width, height, pixel_format, float_format, yuv_in)); pixel_format.fullrange = range_out; from_float.reset(create_depth_color_filter(width, height, float_format, pixel_format, yuv_out)); pair_filter1.reset(new zimg::PairFilter{ to_float.get(), colorspace_filter.get() }); to_float.release(); colorspace_filter.release(); pair_filter2.reset(new zimg::PairFilter{ pair_filter1.get(), from_float.get() }); pair_filter1.release(); from_float.release(); return pair_filter2.release(); } else { return colorspace_filter.release(); } } catch (const zimg::ZimgException &e) { handle_exception(e); return nullptr; } catch (const std::bad_alloc &e) { handle_exception(e); return nullptr; } }
static void test_color_brush(void) { D2D1_MATRIX_3X2_F matrix, tmp_matrix; D2D1_BRUSH_PROPERTIES brush_desc; D2D1_COLOR_F color, tmp_color; ID2D1SolidColorBrush *brush; IDXGISwapChain *swapchain; ID2D1RenderTarget *rt; ID3D10Device1 *device; IDXGISurface *surface; D2D1_RECT_F rect; float opacity; HWND window; HRESULT hr; if (!(device = create_device())) { skip("Failed to create device, skipping tests.\n"); return; } window = CreateWindowA("static", "d2d1_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, 640, 480, NULL, NULL, NULL, NULL); swapchain = create_swapchain(device, window, TRUE); hr = IDXGISwapChain_GetBuffer(swapchain, 0, &IID_IDXGISurface, (void **)&surface); ok(SUCCEEDED(hr), "Failed to get buffer, hr %#x.\n", hr); rt = create_render_target(surface); ok(!!rt, "Failed to create render target.\n"); ID2D1RenderTarget_SetDpi(rt, 192.0f, 48.0f); ID2D1RenderTarget_SetAntialiasMode(rt, D2D1_ANTIALIAS_MODE_ALIASED); set_color(&color, 0.0f, 0.0f, 0.0f, 0.0f); hr = ID2D1RenderTarget_CreateSolidColorBrush(rt, &color, NULL, &brush); ok(SUCCEEDED(hr), "Failed to create brush, hr %#x.\n", hr); opacity = ID2D1SolidColorBrush_GetOpacity(brush); ok(opacity == 1.0f, "Got unexpected opacity %.8e.\n", opacity); set_matrix_identity(&matrix); ID2D1SolidColorBrush_GetTransform(brush, &tmp_matrix); ok(!memcmp(&tmp_matrix, &matrix, sizeof(matrix)), "Got unexpected matrix {%.8e, %.8e, %.8e, %.8e, %.8e, %.8e}.\n", tmp_matrix._11, tmp_matrix._12, tmp_matrix._21, tmp_matrix._22, tmp_matrix._31, tmp_matrix._32); tmp_color = ID2D1SolidColorBrush_GetColor(brush); ok(!memcmp(&tmp_color, &color, sizeof(color)), "Got unexpected color {%.8e, %.8e, %.8e, %.8e}.\n", tmp_color.r, tmp_color.g, tmp_color.b, tmp_color.a); ID2D1SolidColorBrush_Release(brush); set_color(&color, 0.0f, 1.0f, 0.0f, 0.8f); brush_desc.opacity = 0.3f; set_matrix_identity(&matrix); scale_matrix(&matrix, 2.0f, 2.0f); brush_desc.transform = matrix; hr = ID2D1RenderTarget_CreateSolidColorBrush(rt, &color, &brush_desc, &brush); ok(SUCCEEDED(hr), "Failed to create brush, hr %#x.\n", hr); opacity = ID2D1SolidColorBrush_GetOpacity(brush); ok(opacity == 0.3f, "Got unexpected opacity %.8e.\n", opacity); ID2D1SolidColorBrush_GetTransform(brush, &tmp_matrix); ok(!memcmp(&tmp_matrix, &matrix, sizeof(matrix)), "Got unexpected matrix {%.8e, %.8e, %.8e, %.8e, %.8e, %.8e}.\n", tmp_matrix._11, tmp_matrix._12, tmp_matrix._21, tmp_matrix._22, tmp_matrix._31, tmp_matrix._32); tmp_color = ID2D1SolidColorBrush_GetColor(brush); ok(!memcmp(&tmp_color, &color, sizeof(color)), "Got unexpected color {%.8e, %.8e, %.8e, %.8e}.\n", tmp_color.r, tmp_color.g, tmp_color.b, tmp_color.a); ID2D1RenderTarget_BeginDraw(rt); set_color(&color, 0.0f, 0.0f, 1.0f, 1.0f); ID2D1RenderTarget_Clear(rt, &color); ID2D1SolidColorBrush_SetOpacity(brush, 1.0f); set_rect(&rect, 40.0f, 120.0f, 120.0f, 360.0f); ID2D1RenderTarget_FillRectangle(rt, &rect, (ID2D1Brush *)brush); set_matrix_identity(&matrix); scale_matrix(&matrix, 0.5f, 2.0f); translate_matrix(&matrix, 320.0f, 240.0f); rotate_matrix(&matrix, M_PI / 4.0f); ID2D1RenderTarget_SetTransform(rt, &matrix); set_color(&color, 1.0f, 0.0f, 0.0f, 0.625f); ID2D1SolidColorBrush_SetColor(brush, &color); ID2D1SolidColorBrush_SetOpacity(brush, 0.75f); set_rect(&rect, -80.0f, -60.0f, 80.0f, 60.0f); ID2D1RenderTarget_FillRectangle(rt, &rect, (ID2D1Brush *)brush); hr = ID2D1RenderTarget_EndDraw(rt, NULL, NULL); ok(SUCCEEDED(hr), "Failed to end draw, hr %#x.\n", hr); ok(compare_surface(surface, "6d1218fca5e21fb7e287b3a439d60dbc251f5ceb"), "Surface does not match.\n"); ID2D1SolidColorBrush_Release(brush); ID2D1RenderTarget_Release(rt); IDXGISurface_Release(surface); IDXGISwapChain_Release(swapchain); ID3D10Device1_Release(device); DestroyWindow(window); }
static void test_bitmap_brush(void) { D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode; D2D1_MATRIX_3X2_F matrix, tmp_matrix; D2D1_BITMAP_PROPERTIES bitmap_desc; ID2D1Bitmap *bitmap, *tmp_bitmap; D2D1_RECT_F src_rect, dst_rect; D2D1_EXTEND_MODE extend_mode; IDXGISwapChain *swapchain; ID2D1BitmapBrush *brush; ID2D1RenderTarget *rt; ID3D10Device1 *device; IDXGISurface *surface; D2D1_COLOR_F color; D2D1_SIZE_U size; ULONG refcount; float opacity; HWND window; HRESULT hr; static const DWORD bitmap_data[] = { 0xffff0000, 0xffffff00, 0xff00ff00, 0xff00ffff, 0xff0000ff, 0xffff00ff, 0xff000000, 0xff7f7f7f, 0xffffffff, 0xffffffff, 0xffffffff, 0xff000000, 0xffffffff, 0xff000000, 0xff000000, 0xff000000, }; if (!(device = create_device())) { skip("Failed to create device, skipping tests.\n"); return; } window = CreateWindowA("static", "d2d1_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, 640, 480, NULL, NULL, NULL, NULL); swapchain = create_swapchain(device, window, TRUE); hr = IDXGISwapChain_GetBuffer(swapchain, 0, &IID_IDXGISurface, (void **)&surface); ok(SUCCEEDED(hr), "Failed to get buffer, hr %#x.\n", hr); rt = create_render_target(surface); ok(!!rt, "Failed to create render target.\n"); ID2D1RenderTarget_SetDpi(rt, 192.0f, 48.0f); ID2D1RenderTarget_SetAntialiasMode(rt, D2D1_ANTIALIAS_MODE_ALIASED); set_size_u(&size, 4, 4); bitmap_desc.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM; bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE; bitmap_desc.dpiX = 96.0f; bitmap_desc.dpiY = 96.0f; hr = ID2D1RenderTarget_CreateBitmap(rt, size, bitmap_data, 4 * sizeof(*bitmap_data), &bitmap_desc, &bitmap); ok(SUCCEEDED(hr), "Failed to create bitmap, hr %#x.\n", hr); /* Creating a brush with a NULL bitmap crashes on Vista, but works fine on * Windows 7+. */ hr = ID2D1RenderTarget_CreateBitmapBrush(rt, bitmap, NULL, NULL, &brush); ok(SUCCEEDED(hr), "Failed to create brush, hr %#x.\n", hr); ID2D1BitmapBrush_GetBitmap(brush, &tmp_bitmap); ok(tmp_bitmap == bitmap, "Got unexpected bitmap %p, expected %p.\n", tmp_bitmap, bitmap); ID2D1Bitmap_Release(tmp_bitmap); opacity = ID2D1BitmapBrush_GetOpacity(brush); ok(opacity == 1.0f, "Got unexpected opacity %.8e.\n", opacity); set_matrix_identity(&matrix); ID2D1BitmapBrush_GetTransform(brush, &tmp_matrix); ok(!memcmp(&tmp_matrix, &matrix, sizeof(matrix)), "Got unexpected matrix {%.8e, %.8e, %.8e, %.8e, %.8e, %.8e}.\n", tmp_matrix._11, tmp_matrix._12, tmp_matrix._21, tmp_matrix._22, tmp_matrix._31, tmp_matrix._32); extend_mode = ID2D1BitmapBrush_GetExtendModeX(brush); ok(extend_mode == D2D1_EXTEND_MODE_CLAMP, "Got unexpected extend mode %#x.\n", extend_mode); extend_mode = ID2D1BitmapBrush_GetExtendModeY(brush); ok(extend_mode == D2D1_EXTEND_MODE_CLAMP, "Got unexpected extend mode %#x.\n", extend_mode); interpolation_mode = ID2D1BitmapBrush_GetInterpolationMode(brush); ok(interpolation_mode == D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, "Got unexpected interpolation mode %#x.\n", interpolation_mode); ID2D1BitmapBrush_Release(brush); hr = ID2D1RenderTarget_CreateBitmapBrush(rt, bitmap, NULL, NULL, &brush); ok(SUCCEEDED(hr), "Failed to create brush, hr %#x.\n", hr); set_matrix_identity(&matrix); translate_matrix(&matrix, 40.0f, 120.0f); scale_matrix(&matrix, 20.0f, 60.0f); ID2D1BitmapBrush_SetTransform(brush, &matrix); ID2D1BitmapBrush_SetInterpolationMode(brush, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR); ID2D1RenderTarget_BeginDraw(rt); set_color(&color, 0.0f, 0.0f, 1.0f, 1.0f); ID2D1RenderTarget_Clear(rt, &color); set_rect(&dst_rect, 40.0f, 120.0f, 120.0f, 360.0f); ID2D1RenderTarget_FillRectangle(rt, &dst_rect, (ID2D1Brush *)brush); set_matrix_identity(&matrix); scale_matrix(&matrix, 0.5f, 2.0f); translate_matrix(&matrix, 320.0f, 240.0f); rotate_matrix(&matrix, M_PI / 4.0f); ID2D1RenderTarget_SetTransform(rt, &matrix); set_matrix_identity(&matrix); translate_matrix(&matrix, -80.0f, -60.0f); scale_matrix(&matrix, 40.0f, 30.0f); ID2D1BitmapBrush_SetTransform(brush, &matrix); ID2D1BitmapBrush_SetOpacity(brush, 0.75f); set_rect(&dst_rect, -80.0f, -60.0f, 80.0f, 60.0f); ID2D1RenderTarget_FillRectangle(rt, &dst_rect, (ID2D1Brush *)brush); set_matrix_identity(&matrix); translate_matrix(&matrix, 200.0f, 120.0f); scale_matrix(&matrix, 20.0f, 60.0f); ID2D1RenderTarget_SetTransform(rt, &matrix); ID2D1RenderTarget_DrawBitmap(rt, bitmap, NULL, 0.25f, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, NULL); set_rect(&dst_rect, -4.0f, 12.0f, -8.0f, 8.0f); ID2D1RenderTarget_DrawBitmap(rt, bitmap, &dst_rect, 0.75f, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, NULL); set_rect(&dst_rect, 0.0f, 8.0f, 4.0f, 12.0f); set_rect(&src_rect, 2.0f, 1.0f, 4.0f, 3.0f); ID2D1RenderTarget_DrawBitmap(rt, bitmap, &dst_rect, 1.0f, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, &src_rect); hr = ID2D1RenderTarget_EndDraw(rt, NULL, NULL); ok(SUCCEEDED(hr), "Failed to end draw, hr %#x.\n", hr); ok(compare_surface(surface, "393636185359a550d459e1e5f0e25411814f724c"), "Surface does not match.\n"); ID2D1BitmapBrush_Release(brush); refcount = ID2D1Bitmap_Release(bitmap); ok(!refcount, "Bitmap has %u references left.\n", refcount); ID2D1RenderTarget_Release(rt); IDXGISurface_Release(surface); IDXGISwapChain_Release(swapchain); ID3D10Device1_Release(device); DestroyWindow(window); }