ffxCreateContextDescUpscale create_ffx_upscale_context{};
create_ffx_upscale_context.header.type = FFX_API_CREATE_CONTEXT_DESC_TYPE_UPSCALE;
create_ffx_upscale_context.header.pNext = &backend_vk_desc.header;
create_ffx_upscale_context.maxUpscaleSize = {WINDOW_SIZE.x, WINDOW_SIZE.y};
create_ffx_upscale_context.maxRenderSize = {WINDOW_SIZE.x, WINDOW_SIZE.y};
create_ffx_upscale_context.flags |= FFX_UPSCALE_ENABLE_AUTO_EXPOSURE;
create_ffx_upscale_context.flags |= FFX_UPSCALE_ENABLE_HIGH_DYNAMIC_RANGE;
create_ffx_upscale_context.flags |= FFX_UPSCALE_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION;
create_ffx_upscale_context.flags |= FFX_UPSCALE_ENABLE_NON_LINEAR_COLORSPACE;
create_ffx_upscale_context.flags |= FFX_UPSCALE_ENABLE_DEPTH_INFINITE;
create_ffx_upscale_context.flags |= FFX_UPSCALE_ENABLE_DEPTH_INVERTED;
create_ffx_upscale_context.fpMessage = nullptr;


auto prev = std::chrono::high_resolution_clock::now();
while (!quit) {
        // delta t
        auto now = std::chrono::high_resolution_clock::now();
        float delta_t_ms = std::chrono::duration<float, std::milli>(now - prev).count();
        prev = now;

        // jitter
        float aspect = float(RENDER_SIZE.x) / float(RENDER_SIZE.y);
        glm::vec2 jitter;
        const int32_t jitter_phase_count = ffxFsr3GetJitterPhaseCount(RENDER_SIZE.x, WINDOW_SIZE.x);
        ffxFsr3GetJitterOffset(&jitter.x, &jitter.y, frame_number % jitter_phase_count, jitter_phase_count);
        glm::vec2 jitterNDC{2.0f * jitter.x / (float)RENDER_SIZE.x, 2.0f * jitter.y / (float)RENDER_SIZE.y};
        camera.updateMatrices(aspect, jitterNDC);

        // camera.updateMatrices
        float m_fov = 39.0f;
        float m_near = 0.1f;
        float m_far  = 1000.0f;

        glm::mat4 Camera::projMatrix(float aspect, glm::vec2 jitterNDC) const {
                glm::mat4 proj = glm::perspective(glm::radians(m_fov), aspect, m_near, m_far);

                glm::mat4 trans = glm::translate(glm::mat4(1.0), glm::vec3(jitterNDC.x, jitterNDC.y, 0));

                return trans * proj;
        }

        void Camera::updateMatrices(float aspect, glm::vec2 jitterNDC) {
                glm::mat4 view = glm::lookAt(m_pos, m_pos + m_dir, glm::vec3(0, 1, 0));
                glm::mat4 proj = glm::perspective(glm::radians(m_fov), aspect, m_near, m_far);
                glm::mat4 trans = glm::translate(glm::mat4(1.0), glm::vec3(jitterNDC.x, jitterNDC.y, 0));

                glm::mat4 viewProjJittered = trans * proj * view;

                prev_inv_view_proj_jittered = inv_view_proj_jittered;
                inv_view_proj_jittered = glm::inverse(viewProjJittered);
        }


        // FSR
        ffxDispatchDescUpscale ffx_upscale_dispatch_context{};
        ffx_upscale_dispatch_context.header.type = FFX_API_DISPATCH_DESC_TYPE_UPSCALE;
        ffx_upscale_dispatch_context.header.pNext = nullptr;
        ffx_upscale_dispatch_context.commandList = cmd;
        ffx_upscale_dispatch_context.color = ffxApiGetResourceVK(draw_image.image, ffxApiGetImageResourceDescriptionVK(draw_image.image, draw_image.create_info, 0), FFX_API_RESOURCE_STATE_PIXEL_COMPUTE_READ);
        ffx_upscale_dispatch_context.depth = ffxApiGetResourceVK(depth_image.image, ffxApiGetImageResourceDescriptionVK(depth_image.image, depth_image.create_info, 0), FFX_API_RESOURCE_STATE_PIXEL_COMPUTE_READ);
        ffx_upscale_dispatch_context.motionVectors = ffxApiGetResourceVK(motion_image.image, ffxApiGetImageResourceDescriptionVK(motion_image.image, motion_image.create_info, 0), FFX_API_RESOURCE_STATE_PIXEL_COMPUTE_READ);
        ffx_upscale_dispatch_context.exposure = ffxApiGetResourceVK(nullptr, {}, FFX_API_RESOURCE_STATE_PIXEL_COMPUTE_READ);
        ffx_upscale_dispatch_context.reactive = ffxApiGetResourceVK(nullptr, {}, FFX_API_RESOURCE_STATE_PIXEL_COMPUTE_READ);
        ffx_upscale_dispatch_context.transparencyAndComposition = ffxApiGetResourceVK(nullptr, {}, FFX_API_RESOURCE_STATE_PIXEL_COMPUTE_READ);
        ffx_upscale_dispatch_context.output = ffxApiGetResourceVK(output_image.image, ffxApiGetImageResourceDescriptionVK(output_image.image, output_image.create_info, 0), FFX_API_RESOURCE_STATE_UNORDERED_ACCESS);
        ffx_upscale_dispatch_context.jitterOffset.x = jitter.x;
        ffx_upscale_dispatch_context.jitterOffset.y = jitter.y;
        ffx_upscale_dispatch_context.motionVectorScale.x = float(RENDER_SIZE.x);
        ffx_upscale_dispatch_context.motionVectorScale.y = float(RENDER_SIZE.y);
        ffx_upscale_dispatch_context.reset = false;
        ffx_upscale_dispatch_context.enableSharpening = false;
        ffx_upscale_dispatch_context.sharpness = 0.8;
        ffx_upscale_dispatch_context.frameTimeDelta = delta_t_ms; // FSR expects milliseconds
        // ffx_upscale_dispatch_context.preExposure = 0.5f;
        ffx_upscale_dispatch_context.renderSize.width = float(RENDER_SIZE.x);
        ffx_upscale_dispatch_context.renderSize.height = float(RENDER_SIZE.y);
        ffx_upscale_dispatch_context.upscaleSize.width = float(WINDOW_SIZE.x);
        ffx_upscale_dispatch_context.upscaleSize.height = float(WINDOW_SIZE.y);
        ffx_upscale_dispatch_context.cameraFovAngleVertical = glm::radians(camera.fov());
        ffx_upscale_dispatch_context.cameraFar = std::numeric_limits<float>::infinity();
        ffx_upscale_dispatch_context.cameraNear = camera.near();
}


// compute shader
void main() {
        vec2 texel_coord = vec2(gl_GlobalInvocationID.xy);

        // NDC space [-1, 1]
        vec2 ndc = (texel_coord / vec2(imageSize(color_image))) * 2.0 - 1.0;

        // Homogeneous clip space points
        vec4 near_point = ubo.inv_view_proj_jittered * vec4(ndc, 0.0, 1.0);
        vec4 far_point  = ubo.inv_view_proj_jittered * vec4(ndc, 1.0, 1.0);

        // Perspective divide
        near_point.xyz /= near_point.w;
        far_point.xyz  /= far_point.w;

        vec3 ray_pos = near_point.xyz;
        vec3 ray_dir = normalize(far_point.xyz - near_point.xyz);

        Hit hit = traceWorld(ray_pos, ray_dir);
        vec3 world_pos = ray_pos + ray_dir * hit.depth;

        imageStore(color_image, ivec2(texel_coord), hit.color);

        mat4 prev_view_proj_jittered = inverse(ubo.prev_inv_view_proj_jittered);
        mat4 curr_view_proj_jittered = inverse(ubo.inv_view_proj_jittered);

        // inverse depth
        float depth = 0.1 / hit.depth;

        imageStore(depth_image, ivec2(texel_coord), vec4(depth, 0.0, 0.0, 0.0));

        vec2 motion = vec2(0.0);
        if (hit.color.a > 0.0) {
                vec4 curr_clip = curr_view_proj_jittered * vec4(world_pos, 1.0);
                vec4 prev_clip = prev_view_proj_jittered * vec4(world_pos, 1.0);

                vec2 curr_ndc = curr_clip.xy / curr_clip.w;
                vec2 prev_ndc = prev_clip.xy / prev_clip.w;

                motion = (prev_ndc - curr_ndc) / 2.f;
        }

        imageStore(motion_vector_image, ivec2(texel_coord), vec4(motion, 0.0, 0.0));

}