/*
 * Copyright 2011-2016 Blender Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

CCL_NAMESPACE_BEGIN

/* This kernel enqueues rays of different ray state into their
 * appropriate queues:
 *
 * 1. Rays that have been determined to hit the background from the
 *    "kernel_scene_intersect" kernel are enqueued in
 *    QUEUE_HITBG_BUFF_UPDATE_TOREGEN_RAYS;
 * 2. Rays that have been determined to be actively participating in pat
 *    -iteration will be enqueued into QUEUE_ACTIVE_AND_REGENERATED_RAYS.
 *
 * State of queue during other times this kernel is called:
 * At entry,
 *   - QUEUE_ACTIVE_AND_REGENERATED_RAYS will be empty.
 *   - QUEUE_HITBG_BUFF_UPDATE_TOREGEN_RAYS will contain RAY_TO_REGENERATE
 *     and RAY_UPDATE_BUFFER rays.
 * At exit,
 *   - QUEUE_ACTIVE_AND_REGENERATED_RAYS will be filled with RAY_ACTIVE rays.
 *   - QUEUE_HITBG_BUFF_UPDATE_TOREGEN_RAYS will be filled with
 *     RAY_TO_REGENERATE, RAY_UPDATE_BUFFER, RAY_HIT_BACKGROUND rays.
 */
ccl_device void kernel_queue_enqueue(KernelGlobals *kg,
                                     ccl_local_param QueueEnqueueLocals *locals)
{
	/* We have only 2 cases (Hit/Not-Hit) */
	int lidx = ccl_local_id(1) * ccl_local_size(0) + ccl_local_id(0);
	int ray_index = ccl_global_id(1) * ccl_global_size(0) + ccl_global_id(0);

	if(lidx == 0) {
		locals->queue_atomics[0] = 0;
		locals->queue_atomics[1] = 0;
	}
	ccl_barrier(CCL_LOCAL_MEM_FENCE);

	int queue_number = -1;

	if(IS_STATE(kernel_split_state.ray_state, ray_index, RAY_HIT_BACKGROUND) ||
	   IS_STATE(kernel_split_state.ray_state, ray_index, RAY_UPDATE_BUFFER) ||
	   IS_STATE(kernel_split_state.ray_state, ray_index, RAY_TO_REGENERATE)) {
		queue_number = QUEUE_HITBG_BUFF_UPDATE_TOREGEN_RAYS;
	}
	else if(IS_STATE(kernel_split_state.ray_state, ray_index, RAY_ACTIVE) ||
	        IS_STATE(kernel_split_state.ray_state, ray_index, RAY_REGENERATED)) {
		queue_number = QUEUE_ACTIVE_AND_REGENERATED_RAYS;
	}

	unsigned int my_lqidx;
	if(queue_number != -1) {
		my_lqidx = get_local_queue_index(queue_number, locals->queue_atomics);
	}
	ccl_barrier(CCL_LOCAL_MEM_FENCE);

	if(lidx == 0) {
		locals->queue_atomics[QUEUE_ACTIVE_AND_REGENERATED_RAYS] =
		        get_global_per_queue_offset(QUEUE_ACTIVE_AND_REGENERATED_RAYS,
		                                    locals->queue_atomics,
		                                    kernel_split_params.queue_index);
		locals->queue_atomics[QUEUE_HITBG_BUFF_UPDATE_TOREGEN_RAYS] =
		        get_global_per_queue_offset(QUEUE_HITBG_BUFF_UPDATE_TOREGEN_RAYS,
		                                    locals->queue_atomics,
		                                    kernel_split_params.queue_index);
	}
	ccl_barrier(CCL_LOCAL_MEM_FENCE);

	unsigned int my_gqidx;
	if(queue_number != -1) {
		my_gqidx = get_global_queue_index(queue_number,
		                                  kernel_split_params.queue_size,
		                                  my_lqidx,
		                                  locals->queue_atomics);
		kernel_split_state.queue_data[my_gqidx] = ray_index;
	}
}

CCL_NAMESPACE_END