int main(void)
{
try {
/*
* First Forge call should be a window creation call
* so that necessary OpenGL context is created for any
* other fg::* object to be created successfully
*/
fg::Window wnd(DIMX, DIMY, "Fractal Demo");
wnd.makeCurrent();
/* create an font object and load necessary font
* and later pass it on to window object so that
* it can be used for rendering text */
fg::Font fnt;
#ifdef OS_WIN
fnt.loadSystemFont("Calibri", 32);
#else
fnt.loadSystemFont("Vera", 32);
#endif
wnd.setFont(&fnt);
/*
* Split the window into grid regions
*/
wnd.grid(WIN_ROWS, WIN_COLS);
/* Create several plot objects which creates the necessary
* vertex buffer objects to hold the different plot types
*/
fg::Plot plt0(SIZE, fg::f32); //create a default plot
fg::Plot plt1(SIZE, fg::f32, fg::FG_LINE, fg::FG_NONE); //or specify a specific plot type
fg::Plot plt2(SIZE, fg::f32, fg::FG_LINE, fg::FG_TRIANGLE); //last parameter specifies marker shape
fg::Plot plt3(SIZE, fg::f32, fg::FG_SCATTER, fg::FG_POINT);
/*
* Set plot colors
*/
plt0.setColor(fg::FG_YELLOW);
plt1.setColor(fg::FG_BLUE);
plt2.setColor(fg::FG_WHITE); //use a forge predefined color
plt3.setColor((fg::Color) 0xABFF01FF); //or any hex-valued color
/*
* Set draw limits for plots
*/
plt0.setAxesLimits(FRANGE_END, FRANGE_START, 1.1f, -1.1f);
plt1.setAxesLimits(FRANGE_END, FRANGE_START, 1.1f, -1.1f);
plt2.setAxesLimits(FRANGE_END, FRANGE_START, 1.1f, -1.1f);
plt3.setAxesLimits(FRANGE_END, FRANGE_START, 1.1f, -1.1f);
Platform plat = getPlatform();
// Select the default platform and create a context using this platform and the GPU
#if defined(OS_MAC)
CGLContextObj cgl_current_ctx = CGLGetCurrentContext();
CGLShareGroupObj cgl_share_group = CGLGetShareGroup(cgl_current_ctx);
cl_context_properties cps[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)cgl_share_group,
0
};
#elif defined(OS_LNX)
cl_context_properties cps[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wnd.context(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)wnd.display(),
CL_CONTEXT_PLATFORM, (cl_context_properties)plat(),
0
};
#else /* OS_WIN */
cl_context_properties cps[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wnd.context(),
CL_WGL_HDC_KHR, (cl_context_properties)wnd.display(),
CL_CONTEXT_PLATFORM, (cl_context_properties)plat(),
0
};
#endif
std::vector<Device> devs;
plat.getDevices(CL_DEVICE_TYPE_GPU, &devs);
Device device;
for (auto& d : devs) {
if (checkExtnAvailability(d, CL_GL_SHARING_EXT)) {
device = d;
break;
}
}
Context context(device, cps);
CommandQueue queue(context, device);
cl::Buffer devOut(context, CL_MEM_READ_WRITE, sizeof(float) * SIZE * 2);
kernel(devOut, queue);
/* copy your data into the vertex buffer object exposed by
* fg::Plot class and then proceed to rendering.
* To help the users with copying the data from compute
* memory to display memory, Forge provides copy headers
* along with the library to help with this task
*/
fg::copy(plt0, devOut, queue);
fg::copy(plt1, devOut, queue);
fg::copy(plt2, devOut, queue);
fg::copy(plt3, devOut, queue);
do {
wnd.draw(0, 0, plt0, NULL );
wnd.draw(0, 1, plt1, "sinf_line_blue" );
wnd.draw(1, 1, plt2, "sinf_line_triangle" );
wnd.draw(1, 0, plt3, "sinf_scatter_point" );
// draw window and poll for events last
wnd.swapBuffers();
} while(!wnd.close());
}catch (fg::Error err) {
std::cout << err.what() << "(" << err.err() << ")" << std::endl;
} catch (cl::Error err) {
std::cout << err.what() << "(" << err.err() << ")" << std::endl;
}
return 0;
}
int main(void)
{
try {
/*
* First Forge call should be a window creation call
* so that necessary OpenGL context is created for any
* other fg::* object to be created successfully
*/
fg::Window wnd(DIMX, DIMY, "Fractal Demo");
wnd.makeCurrent();
/* create an font object and load necessary font
* and later pass it on to window object so that
* it can be used for rendering text */
fg::Font fnt;
#ifdef OS_WIN
fnt.loadSystemFont("Calibri", 32);
#else
fnt.loadSystemFont("Vera", 32);
#endif
wnd.setFont(&fnt);
/* Create an image object which creates the necessary
* textures and pixel buffer objects to hold the image
* */
fg::Image img(DIMX, DIMY, fg::FG_RGBA, fg::u8);
Platform plat = getPlatform();
// Select the default platform and create a context using this platform and the GPU
#if defined(OS_MAC)
CGLContextObj cgl_current_ctx = CGLGetCurrentContext();
CGLShareGroupObj cgl_share_group = CGLGetShareGroup(cgl_current_ctx);
cl_context_properties cps[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)cgl_share_group,
0
};
#elif defined(OS_LNX)
cl_context_properties cps[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wnd.context(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)wnd.display(),
CL_CONTEXT_PLATFORM, (cl_context_properties)plat(),
0
};
#else /* OS_WIN */
cl_context_properties cps[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wnd.context(),
CL_WGL_HDC_KHR, (cl_context_properties)wnd.display(),
CL_CONTEXT_PLATFORM, (cl_context_properties)plat(),
0
};
#endif
std::vector<Device> devs;
plat.getDevices(CL_DEVICE_TYPE_GPU, &devs);
Device device;
for (auto& d : devs) {
if (checkExtnAvailability(d, CL_GL_SHARING_EXT)) {
device = d;
break;
}
}
Context context(device, cps);
CommandQueue queue(context, device);
/* copy your data into the pixel buffer object exposed by
* fg::Image class and then proceed to rendering.
* To help the users with copying the data from compute
* memory to display memory, Forge provides copy headers
* along with the library to help with this task
*/
cl::Buffer devOut(context, CL_MEM_READ_WRITE, IMG_SIZE);
kernel(devOut, queue);
fg::copy(img, devOut, queue);
do {
wnd.draw(img);
} while(!wnd.close());
}catch (fg::Error err) {
std::cout << err.what() << "(" << err.err() << ")" << std::endl;
} catch (cl::Error err) {
std::cout << err.what() << "(" << err.err() << ")" << std::endl;
}
return 0;
}
int main(void)
{
try {
/*
* First Forge call should be a window creation call
* so that necessary OpenGL context is created for any
* other fg::* object to be created successfully
*/
fg::Window wnd(DIMX, DIMY, "Histogram Demo");
wnd.makeCurrent();
/* create an font object and load necessary font
* and later pass it on to window object so that
* it can be used for rendering text */
fg::Font fnt;
#ifdef OS_WIN
fnt.loadSystemFont("Calibri", 32);
#else
fnt.loadSystemFont("Vera", 32);
#endif
wnd.setFont(&fnt);
/*
* Split the window into grid regions
*/
wnd.grid(WIN_ROWS, WIN_COLS);
/* Create an image object which creates the necessary
* textures and pixel buffer objects to hold the image
* */
fg::Image img(DIMX, DIMY, fg::FG_RGBA, fg::u8);
/*
* Create histogram object while specifying desired number of bins
*/
fg::Histogram hist(NBINS, fg::u8);
/*
* Set histogram colors
*/
hist.setBarColor(fg::FG_YELLOW);
/* set x axis limits to maximum and minimum values of data
* and y axis limits to range [0, nBins]*/
hist.setAxesLimits(1, 0, 1000, 0);
Platform plat = getPlatform();
// Select the default platform and create a context using this platform and the GPU
#if defined(OS_MAC)
CGLContextObj cgl_current_ctx = CGLGetCurrentContext();
CGLShareGroupObj cgl_share_group = CGLGetShareGroup(cgl_current_ctx);
cl_context_properties cps[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)cgl_share_group,
0
};
#elif defined(OS_LNX)
cl_context_properties cps[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wnd.context(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)wnd.display(),
CL_CONTEXT_PLATFORM, (cl_context_properties)plat(),
0
};
#else /* OS_WIN */
cl_context_properties cps[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wnd.context(),
CL_WGL_HDC_KHR, (cl_context_properties)wnd.display(),
CL_CONTEXT_PLATFORM, (cl_context_properties)plat(),
0
};
#endif
std::vector<Device> devs;
plat.getDevices(CL_DEVICE_TYPE_GPU, &devs);
Device device;
for (auto& d : devs) {
if (checkExtnAvailability(d, CL_GL_SHARING_EXT)) {
device = d;
break;
}
}
Context context(device, cps);
CommandQueue queue(context, device);
cl::Buffer devOut(context, CL_MEM_READ_WRITE, IMG_SIZE);
cl::Buffer histOut(context, CL_MEM_READ_WRITE, NBINS * sizeof(int));
/*
* generate image, and prepare data to pass into
* Histogram's underlying vertex buffer object
*/
kernel(devOut, histOut, queue);
/* To help the users with copying the data from compute
* memory to display memory, Forge provides copy headers
* along with the library to help with this task
*/
fg::copy(img, devOut, queue);
fg::copy(hist, histOut, queue);
do {
kernel(devOut, histOut, queue);
fg::copy(img, devOut, queue);
// limit histogram update frequency
if(fmod(persistance, 0.5f) < 0.01)
fg::copy(hist, histOut, queue);
// draw window and poll for events last
wnd.draw(0, 0, img, "Dynamic Perlin Noise" );
wnd.draw(1, 0, hist, "Histogram of Noisy Image");
wnd.swapBuffers();
} while(!wnd.close());
}catch (fg::Error err) {
std::cout << err.what() << "(" << err.err() << ")" << std::endl;
} catch (cl::Error err) {
std::cout << err.what() << "(" << err.err() << ")" << std::endl;
}
return 0;
}
int main(void)
{
try {
/*
* First Forge call should be a window creation call
* so that necessary OpenGL context is created for any
* other fg::* object to be created successfully
*/
fg::Window wnd(DIMX, DIMY, "Plot3d Demo");
wnd.makeCurrent();
/* create an font object and load necessary font
* and later pass it on to window object so that
* it can be used for rendering text */
fg::Font fnt;
#ifdef OS_WIN
fnt.loadSystemFont("Calibri", 32);
#else
fnt.loadSystemFont("Vera", 32);
#endif
wnd.setFont(&fnt);
/* Create several plot objects which creates the necessary
* vertex buffer objects to hold the different plot types
*/
fg::Plot3 plot3(ZSIZE, fg::f32);
/*
* Set draw limits for plots
*/
plot3.setAxesLimits(1.1f, -1.1f, 1.1f, -1.1f, 10.f, 0.f);
/*
* Set draw limits for plots
*/
plot3.setAxesLimits(1.1f, -1.1f, 1.1f, -1.1f, 10.f, 0.f);
/*
* Set axis titles
*/
plot3.setAxesTitles("x-axis", "y-axis", "z-axis");
Platform plat = getPlatform();
// Select the default platform and create a context using this platform and the GPU
#if defined(OS_MAC)
CGLContextObj cgl_current_ctx = CGLGetCurrentContext();
CGLShareGroupObj cgl_share_group = CGLGetShareGroup(cgl_current_ctx);
cl_context_properties cps[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)cgl_share_group,
0
};
#elif defined(OS_LNX)
cl_context_properties cps[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wnd.context(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)wnd.display(),
CL_CONTEXT_PLATFORM, (cl_context_properties)plat(),
0
};
#else /* OS_WIN */
cl_context_properties cps[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wnd.context(),
CL_WGL_HDC_KHR, (cl_context_properties)wnd.display(),
CL_CONTEXT_PLATFORM, (cl_context_properties)plat(),
0
};
#endif
std::vector<Device> devs;
plat.getDevices(CL_DEVICE_TYPE_GPU, &devs);
Device device;
CommandQueue queue;
Context context;
for (auto& d : devs) {
if (checkExtnAvailability(d, CL_GL_SHARING_EXT)) {
device = d;
context = Context(device, cps);
try {
queue = CommandQueue(context, device);
break;
} catch (cl::Error err) {
continue;
}
}
}
cl::Buffer devOut(context, CL_MEM_READ_WRITE, sizeof(float) * ZSIZE * 3);
static float t=0;
kernel(devOut, queue, t);
/* copy your data into the pixel buffer object exposed by
* fg::Surface class and then proceed to rendering.
* To help the users with copying the data from compute
* memory to display memory, Forge provides copy headers
* along with the library to help with this task
*/
fg::copy(plot3, devOut, queue);
do {
t+=0.01;
kernel(devOut, queue, t);
fg::copy(plot3, devOut, queue);
// draw window and poll for events last
wnd.draw(plot3);
} while(!wnd.close());
}catch (fg::Error err) {
std::cout << err.what() << "(" << err.err() << ")" << std::endl;
} catch (cl::Error err) {
std::cout << err.what() << "(" << err.err() << ")" << std::endl;
}
return 0;
}