void initCL()
{
	ocl::createContextEx(CL_DEVICE_TYPE_ALL, clPlatform, clDevices, clContext, clQueues);
	cl_int clError = CL_SUCCESS;

	std::ifstream t("kmeans.cl");
	std::string code((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>());

	std::string header = "#define DIM ";
	header +=  util::toString(DIM);
	header += "\n";
	header += "#define K ";
	header += util::toString(K);
	header += "\n";
	header += "#define N ";
	header += util::toString(N);
	header += "\n";
	header += "#define AM_LWS ";
	header += util::toString(AM_LWS);
	header += "\n";
	header += "#define RP_LWS ";
	header += util::toString(RP_LWS);
	header += "\n\n\n";

	code = header + code;

	try {
		cl::Program::Sources source(1, std::make_pair(code.c_str(), code.size()));
		clProgram = cl::Program(clContext, source);
		clProgram.build(clDevices, "-cl-fast-relaxed-math -cl-unsafe-math-optimizations -cl-mad-enable");

		std::string info("");
		for (std::vector<cl::Device>::iterator itr = clDevices.begin(); itr != clDevices.end(); ++itr) {
			clProgram.getBuildInfo(*itr, CL_PROGRAM_BUILD_LOG, &info);
			if (info.size() > 0)
				std::cout << "Build log: " << info << std::endl;
		}

		for (int i = 0; i < clDevices.size(); ++i) {
			clClusterAssignment.push_back(cl::Kernel(clProgram, "cluster_assignment", &clError));
			clClusterReposition.push_back(cl::Kernel(clProgram, "cluster_reposition", &clError));
			clClusterReposition_k.push_back(cl::Kernel(clProgram, "cluster_reposition_k", &clError));
			clClusterReposition_k_c.push_back(cl::Kernel(clProgram, "c_cluster_reposition", &clError));
			clComputeCost.push_back(cl::Kernel(clProgram, "compute_cost", &clError));
		}

	} catch (const cl::Error& err) {
		std::cout << "OpenCL Error 4: " << err.what() << " (" << err.err() << ")" << std::endl;
		std::string info("");
		for (std::vector<cl::Device>::iterator itr = clDevices.begin(); itr != clDevices.end(); ++itr) {
			clProgram.getBuildInfo(*itr, CL_PROGRAM_BUILD_LOG, &info);
			if (info.size() > 0)
				std::cout << "Build log: " << info << std::endl;
		}
		std::cin.get();
	}
}

void InitCL()
{
	//cl_int err = CL_SUCCESS;
	try
	{
		//Identify platforms
		cl::Platform::get(&clPlatformList);
		//Select first platform with any GPU devices
		for(unsigned int i=0; i<clPlatformList.size(); i++)
		{
			clPlatformList[i].getDevices(CL_DEVICE_TYPE_GPU, &clDeviceList);
			if(!clDeviceList.empty())	break;
		}

		//Set Context Properties: Get associated cl_platform_id using getInfo() on the first GPU
		//Thus conveniently avoiding previous C++ bindings issues :)
		cl_context_properties clProps[] = 
		{
			CL_GL_CONTEXT_KHR,		(cl_context_properties)wglGetCurrentContext(),
			CL_WGL_HDC_KHR,			(cl_context_properties)wglGetCurrentDC(),
			CL_CONTEXT_PLATFORM,	(cl_context_properties)clDeviceList[0].getInfo<CL_DEVICE_PLATFORM>(),
			0
		};
		//Create interop context from GPU devices
		clContext = cl::Context(CL_DEVICE_TYPE_GPU, clProps);

		//Generate program with source and build
		std::string progFile = ReadKernels(KERNEL_FILE);
		cl::Program::Sources clSource(1, std::make_pair(progFile.c_str(), progFile.size()));
		clProgram = cl::Program(clContext, clSource);
		clProgram.build(clDeviceList);
		//Initialize kernels
		for(int i=0; i<NUM_KERNELS; i++)
		{
			clKernels[i] = cl::Kernel(clProgram, kernelName[i]);
		}
		//Create Command Queue with profiling enabled
		clQueue = cl::CommandQueue(clContext, clDeviceList[0], CL_QUEUE_PROFILING_ENABLE);
	}
	catch(cl::Error e)
	{
		cout << "OpenCL initialization failure: " << e.what() << endl
			<< "Error code: " << e.err() << endl;
		if(e.err() == -11)
		{
			std::string clProgLog;
			clProgram.getBuildInfo(clDeviceList[0], CL_PROGRAM_BUILD_LOG, &clProgLog);
			cout << clProgLog;
			system("pause");
			exit(EXIT_FAILURE);
		}
		throw;
	}
}

string Host::buildLog(cl::Program prog) {
    string options, blog, status;
    ostringstream info;

    prog.getBuildInfo(_devices[d_index], CL_PROGRAM_BUILD_OPTIONS, &options);
    prog.getBuildInfo(_devices[d_index], CL_PROGRAM_BUILD_LOG, &blog);
    prog.getBuildInfo(_devices[d_index], CL_PROGRAM_BUILD_STATUS, &status);

    info << "Building kernels" << endl
         << "Build Options: " << options << endl
         << "Build Status: " << status << endl
         << endl << "Build Log: " << blog << endl;

    return info.str();
}

    void buildProgram(cl::Program &prog, const int num_files,
                      const char **ker_strs, const int *ker_lens, std::string options)
    {
        try {
            Program::Sources setSrc;
            setSrc.emplace_back(USE_DBL_SRC_STR.c_str(), USE_DBL_SRC_STR.length());
            setSrc.emplace_back(KParam_hpp, KParam_hpp_len);

            for (int i = 0; i < num_files; i++) {
                setSrc.emplace_back(ker_strs[i], ker_lens[i]);
            }

            static std::string defaults =
                std::string(" -cl-std=CL1.1") + std::string(" -D dim_type=") +
                std::string(dtype_traits<dim_type>::getName());


            prog = cl::Program(getContext(), setSrc);
            std::vector<cl::Device> targetDevices;
            targetDevices.push_back(getDevice());
            prog.build(targetDevices, (defaults + options).c_str());

        } catch (...) {
            SHOW_BUILD_INFO(prog);
            throw;
        }
    }

void initSimulation() {
    // source: http://stackoverflow.com/questions/26517114/how-to-compile-opencl-project-with-kernels

    try {
        std::vector<cl::Platform> platforms;
        cl::Platform::get(&platforms);

        std::vector<cl::Device> devices;
        platforms[PLATFORM_ID].getDevices(CL_DEVICE_TYPE_CPU | CL_DEVICE_TYPE_GPU, &devices);

        context = cl::Context(devices);
        queue = cl::CommandQueue(context, devices[DEVICE_ID]);

        std::ifstream sourceFile{"kernels/programs.cl"};
        std::string sourceCode(std::istreambuf_iterator<char>(sourceFile), (std::istreambuf_iterator<char>()));
        cl::Program::Sources source(1, std::make_pair(sourceCode.c_str(), sourceCode.length()));

        simulationProgram = cl::Program(context, source);
        simulationProgram.build(devices);

        visualizationBufferGPU = cl::Buffer(context, CL_MEM_WRITE_ONLY,
                                            sizeof(unsigned char) * 4 * fieldWidth * fieldHeight,
                                            nullptr, nullptr);
        randomizeField();

        stepKernel = cl::Kernel(simulationProgram, "tick");
        stepKernel.setArg(0, fieldWidth);
        stepKernel.setArg(1, fieldHeight);
        stepKernel.setArg(3, visualizationBufferGPU);
    } catch (cl::Error err) {
        std::cout << "Error: " << err.what() << "(" << err.err() << ")" << std::endl;
        exit(2);
    }
}

void initCL()
{
    dumpCLinfo();

    EGLDisplay mEglDisplay = eglGetCurrentDisplay();
    if (mEglDisplay == EGL_NO_DISPLAY)
        LOGE("initCL: eglGetCurrentDisplay() returned 'EGL_NO_DISPLAY', error = %x", eglGetError());

    EGLContext mEglContext = eglGetCurrentContext();
    if (mEglContext == EGL_NO_CONTEXT)
        LOGE("initCL: eglGetCurrentContext() returned 'EGL_NO_CONTEXT', error = %x", eglGetError());

    cl_context_properties props[] =
    {   CL_GL_CONTEXT_KHR,   (cl_context_properties) mEglContext,
        CL_EGL_DISPLAY_KHR,  (cl_context_properties) mEglDisplay,
        CL_CONTEXT_PLATFORM, 0,
        0 };

    try
    {
        cl::Platform p = cl::Platform::getDefault();
        std::string ext = p.getInfo<CL_PLATFORM_EXTENSIONS>();
        if(ext.find("cl_khr_gl_sharing") == std::string::npos)
            LOGE("Warning: CL-GL sharing isn't supported by PLATFORM");
        props[5] = (cl_context_properties) p();

        theContext = cl::Context(CL_DEVICE_TYPE_GPU, props);
        std::vector<cl::Device> devs = theContext.getInfo<CL_CONTEXT_DEVICES>();
        LOGD("Context returned %d devices, taking the 1st one", devs.size());
        ext = devs[0].getInfo<CL_DEVICE_EXTENSIONS>();
        if(ext.find("cl_khr_gl_sharing") == std::string::npos)
            LOGE("Warning: CL-GL sharing isn't supported by DEVICE");

        theQueue = cl::CommandQueue(theContext, devs[0]);

        cl::Program::Sources src(1, std::make_pair(oclProgI2I, sizeof(oclProgI2I)));
        theProgI2I = cl::Program(theContext, src);
        theProgI2I.build(devs);

        cv::ocl::attachContext(p.getInfo<CL_PLATFORM_NAME>(), p(), theContext(), devs[0]());
        if( cv::ocl::useOpenCL() )
            LOGD("OpenCV+OpenCL works OK!");
        else
            LOGE("Can't init OpenCV with OpenCL TAPI");
    }
    catch(cl::Error& e)
    {
        LOGE("cl::Error: %s (%d)", e.what(), e.err());
    }
    catch(std::exception& e)
    {
        LOGE("std::exception: %s", e.what());
    }
    catch(...)
    {
        LOGE( "OpenCL info: unknown error while initializing OpenCL stuff" );
    }
    LOGD("initCL completed");
}

int main(int argc, char *argv[])
{
	cl_int err = CL_SUCCESS;
	cl::Event evt;

	std::vector<cl::Platform> platforms;
	cl::Platform::get(&platforms);
	if (platforms.size() == 0) {
		return false;
	}
	platform_ = platforms[0];

	cl_context_properties properties[] = 
		{ CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(), 0};
	context_ = cl::Context(CL_DEVICE_TYPE_GPU, properties, NULL, NULL, &err); 
	CHECK_CL_ERROR(err, "cl::Context");

	std::vector<cl::Device> devices = context_.getInfo<CL_CONTEXT_DEVICES>();
	if (devices.size() == 0) {
		return false;
	}
	device_ = devices[0];

	sources_.push_back(std::make_pair(source_str.c_str(), source_str.size()));
	program_ = cl::Program(context_, sources_);
	err = program_.build(devices);
	if (err != CL_SUCCESS) {
		std::string log = program_.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[0]);
		std::cout << "program.build() ERROR: " << log.c_str() << std::endl;
		return false;
	}

	kernel_ = cl::Kernel(program_, "hello", &err); 
	CHECK_CL_ERROR(err, "cl::Kernel");

	buf_ = cl::Buffer(context_, CL_MEM_READ_ONLY, 1024, NULL, &err);

	queue_ = cl::CommandQueue(context_, device_, 0, &err);
	CHECK_CL_ERROR(err, "cl::CommandQueue");

	kernel_.setArg(0, buf_);

	err = queue_.enqueueNDRangeKernel(kernel_, cl::NullRange, cl::NDRange(10, 10), cl::NullRange, NULL, &evt); 
	evt.wait();
	CHECK_CL_ERROR(err, "queue.enqueueNDRangeKernel()");

	return 0;
}

cl_int CLFW::Build(cl::Program &program, cl::Program::Sources &sources, cl::Context &context, cl::Device &device) {
  cl_int error;
  program = cl::Program(context, sources, &error);
  if (error != CL_SUCCESS) {
	  Print("Error creating program:", errorFG, errorBG);
	  return error;
  }

  error = program.build({ device });
  if (error != CL_SUCCESS) {
    Print("Error building program:", errorFG, errorBG);
    Print(program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device), errorFG, errorBG);
  }
  else {
    Print("Success building OpenCL program. ", successFG, successBG);
  }
  
  return error;
}

cl_int CLFW::get(std::unordered_map<cl::STRING_CLASS, cl::Kernel> &Kernels, cl::Program &program) {
  Kernels.clear();
  std::vector<cl::Kernel> tempKernels;
  cl_int error = program.createKernels(&tempKernels);
  if (error != CL_SUCCESS) {
    Print("Unable to create kernels.", errorFG, errorBG);
    return error;
  }
  for (int i = 0; i < tempKernels.size(); ++i) {
	  std::string temp = std::string(tempKernels[i].getInfo<CL_KERNEL_FUNCTION_NAME>());
    
    //For some reason, OpenCL string's lengths are 1 char longer than they should be.
    temp = temp.substr(0, temp.length() - 1);
    Kernels[temp] = tempKernels[i];
  }
  for (auto i : Kernels) {
    Print("Created Kernel " + i.first, successFG, successBG);
  }
  return CL_SUCCESS;
}

void CLHelper::compileProgram(
	cl::Program& program,
	std::vector<cl::Device>& devices,
	const char* options,
	void (CL_CALLBACK * notifyFptr)(cl_program, void *),
	void* data)
{
	cl_int err;

	err = program.build(devices, options, NULL, NULL);
	if(err != CL_SUCCESS) {
		std::cout << "Build error! Showing build log:" << std::endl << std::endl;

		std::string errorLog;
		std::vector<cl::Device>::iterator device;
		for(device = devices.begin(); device != devices.end(); device++)
		{
			errorLog = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(*device);
			std::cout << errorLog << std::endl;
		}
		CHECK_OPENCL_ERROR(err, "cl::Program::build() failed.");
	}
}

bool RenderThread::tick()
{
	for(int i = 0; i < RenderThread::taskList.getSize(); i++)
	{
		if(!RenderThread::taskList[i]->invoke())
		{
			GlobalThread::stop = true;
		}
	}

	RenderThread::taskList.clear();

	if(RenderThread::skipRender)
	{
		return true;
	}

	GameStates::swapPendingRendering();

	GameStates::GameState* state = GameStates::renderingState;

	if(GLWindow::instance->rescaled)
	{
		glViewport(0, 0, GLWindow::instance->width, GLWindow::instance->height);
		GLWindow::instance->rescaled = false;
	}
		
	normalShaderProgram->bind();
	gfxu::Uniforms::camPos.set(state->cam.pos);
	gfxu::Uniforms::setColor(1.0f, 1.0f, 1.0f, 1.0f);
	if(GlobalThread::world.getBlock(floorf(state->cam.pos.x), floorf(state->cam.pos.y), floorf(state->cam.pos.z)) != Blocks::water)
	{
		glClearColor(0.5f, 0.875f, 1.0f, 1.0f);
		gfxu::Uniforms::setFogColor(0.5f, 0.875f, 1.0f, 1.0f);
		gfxu::Uniforms::fogDist.set(16.0f * renderDistance);
	}
	else
	{
		glClearColor(0.0f, 0.0f, 0.1f, 1.0f);
		gfxu::Uniforms::setFogColor(0.0f, 0.0f, 0.1f, 1.0f);
		gfxu::Uniforms::fogDist.set(16.0f);
	}
	gfxu::Uniforms::reset();
	gfxu::Uniforms::PMS.mult(geom::Matrix::perspective(state->FOV, (float)GLWindow::instance->width / (float)GLWindow::instance->height, 0.1f, 16.0f * renderDistance));
	gfxu::Uniforms::PMS.mult(geom::Matrix::rotate(state->cam.rot.x, 1.0f, 0.0f, 0.0f));
	gfxu::Uniforms::PMS.mult(geom::Matrix::rotate(state->cam.rot.y, 0.0f, 1.0f, 0.0f));
	gfxu::Uniforms::PMS.mult(geom::Matrix::rotate(state->cam.rot.z, 0.0f, 0.0f, 1.0f));
	gfxu::Uniforms::PMS.mult(geom::Matrix::translate(-state->cam.pos.x, -state->cam.pos.y, -state->cam.pos.z));

	float cScale = 1.0f + 90.0f / state->FOV;
	int xCam = floorf(state->cam.pos.x / 16.0f);
	int yCam = floorf(state->cam.pos.y / 16.0f);
	int zCam = floorf(state->cam.pos.z / 16.0f);

	geom::Matrix projectionMatrix = gfxu::Uniforms::PMS.getTopmost();
	projectionMatrixBuffer.write(commandQueue, projectionMatrix.data);

	const size_t global_ws_1[] = {renderDistance * 2 + 2, renderDistance * 2 + 2, renderDistance * 2 + 2};
	const size_t local_ws_1[] = {1, 1, 1};

	if(!program.prepare("gridTransform")) return false;
	if(!program.setArgument(sizeof(const unsigned int), &renderDistance)) return false;
	if(!program.setArgument(sizeof(cl_mem), &projectionMatrixBuffer)) return false;
	if(!program.setArgument(sizeof(const int), &xCam)) return false;
	if(!program.setArgument(sizeof(const int), &yCam)) return false;
	if(!program.setArgument(sizeof(const int), &zCam)) return false;
	if(!program.setArgument(sizeof(cl_mem), &boolBuffer)) return false;
	if(!program.invoke(commandQueue, 3, global_ws_1, local_ws_1)) return false;

	const size_t global_ws_2[] = {renderDistance * 2 + 1, renderDistance * 2 + 1, renderDistance * 2 + 1};
	const size_t local_ws_2[] = {1, 1, 1};

	if(!program.prepare("arrayInsideCheck")) return false;
	if(!program.setArgument(sizeof(const unsigned int), &renderDistance)) return false;
	if(!program.setArgument(sizeof(cl_mem), &gridBuffer)) return false;
	if(!program.setArgument(sizeof(cl_mem), &boolBuffer)) return false;
	if(!program.invoke(commandQueue, 3, global_ws_2, local_ws_2)) return false;

	if(!gridBuffer.read(commandQueue, bGrid)) return false;

	getError();

	/*for(int i = 0; i <= renderDistance * 2; i++)
	{
		int f1 = i - renderDistance;
		for(int j = 0; j <= renderDistance * 2; j++)
		{
			int f2 = j - renderDistance;
			for(int k = 0; k <= renderDistance * 2; k++)
			{
				int f3 = k - renderDistance;
				bGrid[i][j][k] = cube.inside((gfxu::Uniforms::PMS.getTopmost() * geom::Vector((xCam + f1) * 16.0f, (yCam + f2) * 16.0f, (zCam + f3) * 16.0f)).wDivide());
			}
		}
	}*/

	GlobalThread::world.chunkMapLock.lock();
	GlobalThread::world.additionQueueLock.lock();
	while(!GlobalThread::world.additionQueue.empty())
	{
//.........这里部分代码省略.........

void RenderThread::preStart()
{
	const size_t gridSize = sizeof(bool) * (renderDistance * 2 + 1) * (renderDistance * 2 + 1) * (renderDistance * 2 + 1);

	commandQueue.create();
	projectionMatrixBuffer.create(sizeof(float) * 16, CL_MEM_READ_ONLY);
	gridBuffer.create(gridSize, CL_MEM_WRITE_ONLY);
	boolBuffer.create(sizeof(unsigned char) * (renderDistance * 2 + 2) * (renderDistance * 2 + 2) * (renderDistance * 2 + 2), CL_MEM_READ_WRITE);

	std::wstring filePath(IOUtil::EXE_DIR);
	filePath += L"\\programs\\frustumclip.cl";
	program.create(filePath);

	grid = new VertexStream();
	for(int i = -8; i <= 8; i++)
	{
		for(int j = -8; j <= 8; j++)
		{
			grid->put(Vertex(i, j, -8));
			grid->put(Vertex(i, j, 8));
			grid->put(Vertex(i, -8, j));
			grid->put(Vertex(i, 8, j));
			grid->put(Vertex(-8, i, j));
			grid->put(Vertex(8, i, j));
		}
	}

	square = new VertexStream();
	square->put(Vertex(0.0f, 0.0f, 0.0f));
	square->put(Vertex(1.0f, 0.0f, 0.0f));
	square->put(Vertex(1.0f, 0.0f, 1.0f));
	square->put(Vertex(1.0f, 0.0f, 1.0f));
	square->put(Vertex(0.0f, 0.0f, 1.0f));
	square->put(Vertex(0.0f, 0.0f, 0.0f));

	GLWindow::instance->initGL();
	
	if(!GLWindow::instance->isOK())
	{
		return;
	}

	filePath = IOUtil::EXE_DIR;
	filePath += L"\\shaders\\normal.vert";
	normalVShader = new gfxu::VertexShader(filePath);

	filePath = IOUtil::EXE_DIR;
	filePath += L"\\shaders\\normal.frag";
	normalFShader = new gfxu::FragmentShader(filePath);

	normalShaderProgram = new gfxu::ShaderProgram(normalVShader, nullptr, normalFShader);

	filePath = IOUtil::EXE_DIR;
	filePath += L"\\shaders\\noTex.vert";
	noTexVShader = new gfxu::VertexShader(filePath);

	filePath = IOUtil::EXE_DIR;
	filePath += L"\\shaders\\noTex.frag";
	noTexFShader = new gfxu::FragmentShader(filePath);

	noTexShaderProgram = new gfxu::ShaderProgram(noTexVShader, nullptr, noTexFShader);

	gfxu::Uniforms::reset();

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

void PTWeekend::setup()
{
    
    /* Scene data */
    camera.lookAt(glm::vec3(-2,1,1), vec3(0, 0, -1.0f), vec3(0,1,0));
    camera.setPerspective( 45.0f, getWindowAspectRatio(), 0.01f, 100.0f );
    cameraUI = CameraUi(&camera, getWindow());
    
    
    
    glm::vec3 bottom_sky_color(1.0, 1.0, 1.0);
    glm::vec3 top_sky_color(0.5, 0.7, 1.0);
    
    CGLContextObj glContext = CGLGetCurrentContext();
    CGLShareGroupObj shareGroup = CGLGetShareGroup(glContext);
    
    GLuint imgTexName;
    
    const char* program_file_str = "../../../assets/path_tracing.cl";
    
    /* Obtain a platform */
    std::vector<cl::Platform> platforms;
    clStatus = cl::Platform::get(&platforms);
    pt_assert(clStatus, "Could not find an OpenCL platform.");
    
    /* Obtain a device and determinte max local size */
    std::vector<cl::Device> devices;
    clStatus = platforms[0].getDevices(CL_DEVICE_TYPE_GPU, &devices);
    pt_assert(clStatus, "Could not find a GPU device.");
    device = devices[0];
    
    /* Create an OpenCL context for the device */
    cl_context_properties properties[] = {
        CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,
        (cl_context_properties)shareGroup,
        0
    };
    
    context = cl::Context({device}, properties, NULL, NULL, &clStatus);
    pt_assert(clStatus, "Could not create a context for device.");
    
    /* Load and build a program */
    std::ifstream program_file(program_file_str);
    std::string program_str(std::istreambuf_iterator<char>(program_file), (std::istreambuf_iterator<char>()));
    cl::Program::Sources sources(1, std::make_pair(program_str.c_str(), program_str.length() + 1));
    program = cl::Program(context, sources);
    clStatus = program.build({device}, "-I ../../../assets/ -cl-denorms-are-zero");
    
    if (clStatus != CL_SUCCESS)
    {
        std::string log = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device);
        std::cerr << log << "\n";
        exit(EXIT_FAILURE);
    }
    
    /* Create command queue */
    cmd_queue = cl::CommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, &clStatus);
    pt_assert(clStatus, "Could not create command queue");
    
    /* create kernel and set the kernel arguments */
    kernel = cl::Kernel(program, "path_tracing", &clStatus);
    pt_assert(clStatus, "Could not create kernel");
    
    img_width = getWindowWidth();
    img_height = getWindowHeight();
    
    true_img_width = getWindowWidth();
    true_img_height = getWindowHeight();
    
    local_size = device.getInfo<CL_DEVICE_MAX_WORK_GROUP_SIZE>(); //TODO: throws
    local_width = (size_t)pow(2, ceilf(log2f((floorf(sqrtf(local_size))))));
    local_height = local_size / local_width;
    
    img_width = ceilf((float)img_width / (float)local_width) * local_width;
    img_height = ceilf((float)img_height / (float)local_height) * local_height;
    
    
    unsigned int samples = 16;
    
    /* Create GL texture and CL wrapper */
    glGenTextures(1, &imgTexName);
    glBindTexture(GL_TEXTURE_2D, imgTexName);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img_width, img_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
    glBindTexture(GL_TEXTURE_2D, 0);
    imgTex = gl::Texture2d::create(GL_TEXTURE_2D, imgTexName, img_width, img_height, true);
    glFinish();
    
    img_buffer.push_back(cl::Image2DGL(context, CL_MEM_WRITE_ONLY, GL_TEXTURE_2D, 0, imgTexName, &clStatus));
    pt_assert(clStatus, "Could not create buffer");
    
    /* Create all buffers */
    cam_buffer = cl::Buffer(context, CL_MEM_READ_ONLY, sizeof(cl_pinhole_cam), NULL, &clStatus);
    pt_assert(clStatus, "Could not create camera buffer");
    
    primitive_buffer = cl::Buffer (context, CL_MEM_READ_ONLY, MAX_PRIMITIVES * sizeof(cl_sphere), NULL, &clStatus);
    pt_assert(clStatus, "Could not create primitive buffer");
//.........这里部分代码省略.........

bool MaxValueSimple::initialize(cl_device_type type) {
	if (type == CL_DEVICE_TYPE_CPU)
		TYPE = CLCPU;
	else if (type == CL_DEVICE_TYPE_GPU)
		TYPE = CLGPU;
	else {
		TYPE = CPU;
		return true;
	}

	try {
		/*** Hole OpenCL-Plattformen z.B. AMD APP, NVIDIA CUDA ***/
		cl::Platform::get(&platforms);

		/*** Hole OpenCL-Device des geforderten Typs z.B. GPU, CPU ***/
		std::vector < cl::Device > devTmp;
		for (std::vector<cl::Platform>::iterator it = platforms.begin(); it
				!= platforms.end(); ++it) {
			it->getDevices(type, &devTmp);
			devices.insert(devices.end(), devTmp.begin(), devTmp.end());
			devTmp.clear();
		}

		std::cerr << "[DEBUG] OpenCL device: " << devices[0].getInfo<
				CL_DEVICE_NAME> () << std::endl;

		/*** Erstelle OpenCL-Context und CommandQueue ***/
		context = cl::Context(devices);
		cmdQ = cl::CommandQueue(context, devices[0], CL_QUEUE_PROFILING_ENABLE);

		/*** OpenCL-Quellcode einlesen ***/
		std::string src = readFile(KERNEL_PATH);
		cl::Program::Sources source;
		source.push_back(std::make_pair(src.data(), src.length()));

		/*** OpenCL-Programm aus Quellcode erstellen ***/
		program = cl::Program(context, source);
		try {
			program.build(devices);
		} catch (cl::Error & err) {
			/* TODO logging
			 Logger::logDebug(
			 "initCL",
			 Logger::sStream << err.what() << "\nBuild-Log fuer \""
			 << devices.front().getInfo<CL_DEVICE_NAME> () << "\":\n"
			 << program.getBuildInfo<CL_PROGRAM_BUILD_LOG> (devices.front()));
			 */
			throw err;
		}
		kernel = cl::Kernel(program, "maxInt");
		event = cl::Event();
		return true;
	} catch (cl::Error& err) {
		// TODO Logger::logError(METHOD, Logger::sStream << err.what());
		std::cerr << "[ERROR] MaxValueSimple::initialize(cl_device_type): "
				<< err.what() << " (" << err.err() << ")" << std::endl;
		return false;
	} catch (std::exception& err) {
		// TODO Logger::logError(METHOD, Logger::sStream << err.what());
		std::cerr << "[ERROR] MaxValueSimple::initialize(cl_device_type): "
				<< err.what() << std::endl;
		return false;
	}
}

int main()
{
    try {
        std::vector<cl::Device> devices;

        // select platform
        cl::Platform platform = selectPlatform();

        // select device
        platform.getDevices(CL_DEVICE_TYPE_ALL, &devices);
        cl::Device device = selectDevice(devices);

        // create context
        context = cl::Context(devices);

        // create command queue
        queue = cl::CommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE);

        // load opencl source
        std::ifstream cl_file("inclusive_scan.cl");

        std::string cl_string{std::istreambuf_iterator<char>(cl_file),
                    std::istreambuf_iterator<char>()};

        cl::Program::Sources source(1,
                                    std::make_pair(cl_string.c_str(),
                                                   cl_string.length() + 1));

        // create programm
        program = cl::Program(context, source);

        // compile opencl source
        try {
            program.build(devices);

            size_t input_size;
            std::ifstream input_file("input.txt");
            input_file >> input_size;

            std::vector<float> input(input_size);

//            for (size_t i = 0; i < input_size; ++i) {
//                input[i] = i % 10;
//            }

            for (int i = 0; i < input_size; i++) {
                input_file >> input[i];
            }

            std::vector<float> output(input_size, 0);

            cl::Buffer dev_input (context, CL_MEM_READ_ONLY, sizeof(float) * input_size);
            queue.enqueueWriteBuffer(dev_input, CL_TRUE, 0, sizeof(float) * input_size, &input[0]);

            cl::Buffer dev_output = inclusive_scan(dev_input, input_size);

            queue.enqueueReadBuffer(dev_output, CL_TRUE, 0, sizeof(float) * input_size, &output[0]);
            queue.finish();

            cpu_check(input, output);

            std::ofstream output_file("output.txt");
            for (int i = 0; i < input_size; i++) {
                output_file << output[i] << " ";
            }

        }
        catch (cl::Error const & e) {
            std::string log_str = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device);
            std::cout << std::endl << e.what() << " : " << e.err() << std::endl;
            std::cout << log_str;
            return 0;
        }


    }
    catch (cl::Error const & e) {
        std::cout << "Error: " << e.what() << " #" << e.err() << std::endl;
    }

    return 0;
}

int main(int argc, char **argv)
{
    TS ts; //Time stepper
    Vec soln; //Holds the solution vector, including all the primitive
              //variables. 
    DM dmda; //Manages the computational grid and parallelization.

    int X1Start, X2Start;
    int X1Size, X2Size;

    PetscInitialize(&argc, &argv, PETSC_NULL, help);

    // Create the computational domain.
    DMDACreate2d(PETSC_COMM_WORLD, 
                 DM_BOUNDARY_GHOSTED, DM_BOUNDARY_GHOSTED,
                 DMDA_STENCIL_STAR,
                 N1, N2,
                 PETSC_DECIDE, PETSC_DECIDE,
                 DOF, NG, PETSC_NULL, PETSC_NULL, &dmda);

    // When running in parallel, each process computes from
    // [X1Start, X1Start+X1Size] x [X2Start, X2Start+X2Size]
    DMDAGetCorners(dmda, 
                   &X1Start, &X2Start, NULL,
                   &X1Size, &X2Size, NULL);

    // Create the solution vector.
    DMCreateGlobalVector(dmda, &soln);

    // Create the time stepper and link it to the computational grid and the
    // residual evaluation function.
    TSCreate(PETSC_COMM_WORLD, &ts);
    TSSetDM(ts, dmda);
    TSSetIFunction(ts, PETSC_NULL, ComputeResidual, NULL);

    // OpenCL boilerplate code.
    clErr = cl::Platform::get(&platforms);
    CheckCLErrors(clErr, "cl::Platform::get");

    // Select computation device here.
    clErr = platforms.at(1).getDevices(CL_DEVICE_TYPE_CPU, &devices);
    CheckCLErrors(clErr, "cl::Platform::getDevices");

    context = cl::Context(devices, NULL, NULL, NULL, &clErr);
    CheckCLErrors(clErr, "cl::Context::Context");

    queue = cl::CommandQueue(context, devices.at(0), 0, &clErr);
    CheckCLErrors(clErr, "cl::CommandQueue::CommandQueue");

    std::ifstream sourceFile("computeresidual.cl");
    std::string sourceCode((std::istreambuf_iterator<char>(sourceFile)),
                            std::istreambuf_iterator<char>());
    cl::Program::Sources source(1, std::make_pair(sourceCode.c_str(),
                                sourceCode.length()+1));
    
    program = cl::Program(context, source, &clErr);
    CheckCLErrors(clErr, "cl::Program::Program");

    // Pass in constants to the OpenCL kernel as compiler switches. This is an
    // efficient way to handle constants such as domain sizes in OpenCL.
    std::string BuildOptions("\
                              -D X1_SIZE=" +
                             std::to_string(X1Size) +
                             " -D X2_SIZE=" + 
                             std::to_string(X2Size) +
                             " -D TOTAL_X1_SIZE=" + 
                             std::to_string(X1Size+2*NG) + 
                             " -D TOTAL_X2_SIZE=" +
                             std::to_string(X2Size+2*NG));

    // Compile the OpenCL program and extract the kernel.
    PetscScalar start = std::clock();
    clErr = program.build(devices, BuildOptions.c_str(), NULL, NULL);
    const char *buildlog = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(
                                                devices.at(0),
                                                &clErr).c_str();
    PetscPrintf(PETSC_COMM_WORLD, "%s\n", buildlog);
    CheckCLErrors(clErr, "cl::Program::build");
    PetscScalar end = std::clock();

    PetscScalar time = (end - start)/(PetscScalar)CLOCKS_PER_SEC;
    PetscPrintf(PETSC_COMM_WORLD, 
                "Time taken for kernel compilation = %f\n", time);


    kernel = cl::Kernel(program, "ComputeResidual", &clErr);
    CheckCLErrors(clErr, "cl::Kernel::Kernel");

    // How much memory is the kernel using?
    cl_ulong localMemSize = kernel.getWorkGroupInfo<CL_KERNEL_LOCAL_MEM_SIZE>(
                                        devices.at(0), &clErr);
    cl_ulong privateMemSize = kernel.getWorkGroupInfo<CL_KERNEL_PRIVATE_MEM_SIZE>(
                                        devices.at(0), &clErr);
    printf("Local memory used = %llu\n", (unsigned long long)localMemSize);
    printf("Private memory used = %llu\n", (unsigned long long)privateMemSize);


    // Set initial conditions.
    InitialCondition(ts, soln);

//.........这里部分代码省略.........

	CL_helper(const char *kernelFileName, std::vector<std::string> kernelNames, bool loadBinary, bool writeBinary,
				bool usePreProcArgs = false, std::map<std::string, std::string> preProcArgs = std::map<std::string, std::string>()){
		

		cl::Platform::get(&platforms);
		if(platforms.size()==0)
			throw std::runtime_error("No OpenCL platforms found.\n");

 
		int selectedPlatform=0;
		platform=platforms.at(selectedPlatform);
		platform.getDevices(CL_DEVICE_TYPE_ALL, &devices);  
		if(devices.size()==0)
			throw std::runtime_error("No opencl devices found.\n");

		int selectedDevice=0;
		device=devices.at(selectedDevice);
		context = cl::Context(devices);

		

		try{


			if(loadBinary){
				std::string vendor=platform.getInfo<CL_PLATFORM_VENDOR>();
				size_t found = vendor.find("NVIDIA");
				if(found != std::string::npos){
					FILE* fp;
					fp = fopen("src/kernels/julia_filter.ptx", "r");
					if (!fp) {
						std::cerr << "Error loading kernel binary" << std::endl;
						std::cerr << "Building kernel from .cl file" << std::endl;
						loadBinary = false;

					} else {
						fseek(fp, 0, SEEK_END);
						size_t kernel_sz = ftell(fp);
						rewind(fp);

						char* kernel_str = (char*)malloc(kernel_sz);
						unsigned bytes = fread(kernel_str, 1, kernel_sz, fp);
						fclose(fp);

						binaries.push_back(std::make_pair((void*)kernel_str,kernel_sz+1));
				
						program = cl::Program(context, devices, binaries);	

						program.build(devices);
					}
				} else{
					std::cerr << "Vendor not NVIDIA, cannot load .ptx binary" << std::endl;
					std::cerr << "Building kernel from .cl file" << std::endl;
					loadBinary = false;
				}

			}
			if(!loadBinary){
				std::string kernelSource=CL_helper::LoadSource(kernelFileName);
				sources.push_back(std::make_pair(kernelSource.c_str(), kernelSource.size()+1)); 

				program = cl::Program(context, sources);

				if(usePreProcArgs && !preProcArgs.empty()){
					std::string preProcArgsString;
					for(auto& arg : preProcArgs) { 
						preProcArgsString += "-D" + arg.first + "=" + arg.second + " ";
					}
					program.build(devices, preProcArgsString.c_str()); 
				} else {
					//std::string params = "-cl-unsafe-math-optimizations";
					program.build(devices);
				}
			}

		}catch (cl::Error er) {
			for(unsigned i=0;i<devices.size();i++){
					std::cerr <<"Log for device " << devices[i].getInfo<CL_DEVICE_NAME>().c_str()<<std::endl;
					std::cerr << program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[i]).c_str() <<std::endl;
				}
			std::cerr << "ERROR:" << er.what() << " Code " << er.err()<<std::endl;
			throw;
		}


		for(unsigned i=0; i<kernelNames.size();i++){
			kernels.push_back( cl::Kernel(program, kernelNames.at(i).c_str()) );
		}

		queue = cl::CommandQueue(context, device);


		if(writeBinary){
			size_t bin_sz;
			program.getInfo( CL_PROGRAM_BINARY_SIZES, &bin_sz);
			
			unsigned char *bin = (unsigned char *)malloc(bin_sz);
			
			program.getInfo(CL_PROGRAM_BINARIES, &bin);

//.........这里部分代码省略.........

 void initOpenCL()
 {
     // OpenCL
     try
     {
         // Get available platforms
         vector<cl::Platform> platforms;
         cl::Platform::get(&platforms);
         LOG_INFO<<platforms.front().getInfo<CL_PLATFORM_VERSION>();
         
         // context sharing is OS specific
         #if defined (__APPLE__) || defined(MACOSX)
             CGLContextObj curCGLContext = CGLGetCurrentContext();
             CGLShareGroupObj curCGLShareGroup = CGLGetShareGroup(curCGLContext);
             
             cl_context_properties properties[] =
             {
                 CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,
                 (cl_context_properties)curCGLShareGroup,
                 0
             };
         #elif defined WIN32
             cl_context_properties properties[] =
             {
                 CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),
                 CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
                 CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(),
                 0
             };
         #else
             cl_context_properties properties[] =
             {
                 CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
                 CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
                 CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(),
                 0
             };
         #endif
         
         m_context = cl::Context( CL_DEVICE_TYPE_GPU, properties);
         
         // Get a list of devices on this platform
         vector<cl::Device> devices = m_context.getInfo<CL_CONTEXT_DEVICES>();
         m_device = devices[0];
         
         // Create a command queue and use the first device
         m_queue = cl::CommandQueue(m_context, devices[0]);
         
         // Read source file
         std::string sourceCode = kinski::readFile("kernels.cl");
         
         // Make program of the source code in the context
         m_program = cl::Program(m_context, sourceCode);
         
         // Build program for these specific devices
         m_program.build();
         
         m_particleKernel = cl::Kernel(m_program, "updateParticles");
         m_imageKernel = cl::Kernel(m_program, "set_colors_from_image");
     }
     catch(cl::Error &error)
     {
         LOG_ERROR << error.what() << "(" << oclErrorString(error.err()) << ")";
         LOG_ERROR << "Build Status: " << m_program.getBuildInfo<CL_PROGRAM_BUILD_STATUS>(m_device);
         LOG_ERROR << "Build Options:\t" << m_program.getBuildInfo<CL_PROGRAM_BUILD_OPTIONS>(m_device);
         LOG_ERROR << "Build Log:\t " << m_program