/*
* Start up GLUT and tell it what to do
*/
int main(int argc,char* argv[])
{
// Initialize GLUT
glutInit(&argc,argv);
// Request double buffered, true color window with Z buffering at 600x600
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(600,600);
glutCreateWindow("Nbody Simulator");
#ifdef USEGLEW
// Initialize GLEW
if (glewInit()!=GLEW_OK) Fatal("Error initializing GLEW\n");
if (!GLEW_VERSION_2_0) Fatal("OpenGL 2.0 not supported\n");
#endif
// Set callbacks
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutSpecialFunc(special);
glutKeyboardFunc(key);
glutIdleFunc(idle);
// Initialize stars
InitLoc();
// Initialize OpenCL
InitCL();
// Shader program
shader = CreateShaderProgGeom();
ErrCheck("init");
// Star texture
LoadTexBMP("star.bmp");
// Pass control to GLUT so it can interact with the user
glutMainLoop();
return 0;
}
int actualMain(int argc, char* argv[])
{
int ciErrNum = 0;
bool interop = false;
InitCL(-1,-1,interop);
for (int i=0;i<MAX_KERNEL_TESTS;i++)
testSapKernel_computePairsKernelOriginal(i);
testSolverKernel();
//int numPairs = pairCount.at(0);
clReleaseCommandQueue(g_cqCommandQue);
clReleaseContext(g_cxMainContext);
printf("the end\n");
return 0;
}
//-----------------------------------------------------------------------------
//! RestoreContextResources
// - this function restores all of the CL/D3D resources and contexts
//-----------------------------------------------------------------------------
HRESULT RestoreContextResources()
{
// Reinitialize D3D9 resources, CL resources/contexts
InitCL(0, NULL);
InitTextures();
RegisterD3D9ResourceWithCL();
return S_OK;
}
void CLPhysicsDemo::init(int preferredDevice, int preferredPlatform, bool useInterop)
{
InitCL(-1,-1,useInterop);
#define CUSTOM_CL_INITIALIZATION
#ifdef CUSTOM_CL_INITIALIZATION
g_deviceCL = new adl::DeviceCL();
g_deviceCL->m_deviceIdx = g_device;
g_deviceCL->m_context = g_cxMainContext;
g_deviceCL->m_commandQueue = g_cqCommandQue;
g_deviceCL->m_kernelManager = new adl::KernelManager;
#else
DeviceUtils::Config cfg;
cfg.m_type = DeviceUtils::Config::DEVICE_CPU;
g_deviceCL = DeviceUtils::allocate( TYPE_CL, cfg );
#endif
//adl::Solver<adl::TYPE_CL>::allocate(g_deviceCL->allocate(
m_data->m_linVelBuf = new adl::Buffer<btVector3>(g_deviceCL,MAX_CONVEX_BODIES_CL);
m_data->m_angVelBuf = new adl::Buffer<btVector3>(g_deviceCL,MAX_CONVEX_BODIES_CL);
m_data->m_bodyTimes = new adl::Buffer<float>(g_deviceCL,MAX_CONVEX_BODIES_CL);
m_data->m_localShapeAABB = new adl::Buffer<btAABBHost>(g_deviceCL,MAX_CONVEX_SHAPES_CL);
gLinVelMem = (cl_mem)m_data->m_linVelBuf->m_ptr;
gAngVelMem = (cl_mem)m_data->m_angVelBuf->m_ptr;
gBodyTimes = (cl_mem)m_data->m_bodyTimes->m_ptr;
narrowphaseAndSolver = new btGpuNarrowphaseAndSolver(g_deviceCL);
int maxObjects = btMax(256,MAX_CONVEX_BODIES_CL);
int maxPairsSmallProxy = 32;
btOverlappingPairCache* overlappingPairCache=0;
m_data->m_Broadphase = new btGridBroadphaseCl(overlappingPairCache,btVector3(4.f, 4.f, 4.f), 128, 128, 128,maxObjects, maxObjects, maxPairsSmallProxy, 100.f, 128,
g_cxMainContext ,g_device,g_cqCommandQue, g_deviceCL);
cl_program prog = btOpenCLUtils::compileCLProgramFromString(g_cxMainContext,g_device,interopKernelString,0,"",INTEROPKERNEL_SRC_PATH);
g_integrateTransformsKernel = btOpenCLUtils::compileCLKernelFromString(g_cxMainContext, g_device,interopKernelString, "integrateTransformsKernel" ,0,prog);
initFindPairs(gFpIO, g_cxMainContext, g_device, g_cqCommandQue, MAX_CONVEX_BODIES_CL);
}
int main(int argc,char **argv)
{
srandom(123456789);
init_particles();
InitGL(argc, argv);
InitCL();
glutDisplayFunc(mydisplayfunc);
glutKeyboardFunc(getout);
glutMainLoop();
}
int
main( int argc, char *argv[ ] )
{
glutInit( &argc, argv );
InitGraphics( );
InitLists( );
InitCL( );
Reset( );
InitGlui( );
glutMainLoop( );
return 0;
}
void CLPhysicsDemo::init(int preferredDevice, int preferredPlatform, bool useInterop)
{
InitCL(preferredDevice,preferredPlatform,useInterop);
m_narrowphaseAndSolver = new btGpuNarrowphaseAndSolver(g_cxMainContext,g_device,g_cqCommandQue);
g_narrowphaseAndSolver = m_narrowphaseAndSolver;
//adl::Solver<adl::TYPE_CL>::allocate(g_deviceCL->allocate(
m_data->m_linVelBuf = new btOpenCLArray<btVector3>(g_cxMainContext,g_cqCommandQue,MAX_CONVEX_BODIES_CL,false);
m_data->m_angVelBuf = new btOpenCLArray<btVector3>(g_cxMainContext,g_cqCommandQue,MAX_CONVEX_BODIES_CL,false);
m_data->m_bodyTimes = new btOpenCLArray<float>(g_cxMainContext,g_cqCommandQue,MAX_CONVEX_BODIES_CL,false);
m_data->m_localShapeAABBGPU = new btOpenCLArray<btAABBHost>(g_cxMainContext,g_cqCommandQue,MAX_CONVEX_SHAPES_CL,false);
m_data->m_localShapeAABBCPU = new btAlignedObjectArray<btAABBHost>;
int maxObjects = btMax(256,MAX_CONVEX_BODIES_CL);
int maxPairsSmallProxy = 32;
if (useSapGpuBroadphase)
{
m_data->m_BroadphaseSap = new btGpuSapBroadphase(g_cxMainContext ,g_device,g_cqCommandQue);//overlappingPairCache,btVector3(4.f, 4.f, 4.f), 128, 128, 128,maxObjects, maxObjects, maxPairsSmallProxy, 100.f, 128,
} else
{
btOverlappingPairCache* overlappingPairCache=0;
m_data->m_BroadphaseGrid = new btGridBroadphaseCl(overlappingPairCache,btVector3(4.f, 4.f, 4.f), 128, 128, 128,maxObjects, maxObjects, maxPairsSmallProxy, 100.f, 128,
g_cxMainContext ,g_device,g_cqCommandQue);
} //g_cxMainContext ,g_device,g_cqCommandQue);
m_data->m_pgsSolver = new btPgsJacobiSolver();
cl_program prog = btOpenCLUtils::compileCLProgramFromString(g_cxMainContext,g_device,interopKernelString,0,"",INTEROPKERNEL_SRC_PATH);
g_integrateTransformsKernel = btOpenCLUtils::compileCLKernelFromString(g_cxMainContext, g_device,interopKernelString, "integrateTransformsKernel" ,0,prog);
g_integrateTransformsKernel2 = btOpenCLUtils::compileCLKernelFromString(g_cxMainContext, g_device,interopKernelString, "integrateTransformsKernel2" ,0,prog);
initFindPairs(gFpIO, g_cxMainContext, g_device, g_cqCommandQue, MAX_CONVEX_BODIES_CL);
}
int main(int argc,char** argv)
{
InitCL(-1,-1);
BasicDemo ccdDemo(g_cxMainContext,g_device,g_cqCommandQueue);
ccdDemo.initPhysics();
#ifdef CHECK_MEMORY_LEAKS
ccdDemo.exitPhysics();
#else
glutmain(argc, argv,1024,600,"Bullet Physics Demo. http://bulletphysics.org",&ccdDemo);
#endif
// setupGUI(1024,768);
glutMainLoop();
//default glut doesn't return from mainloop
return 0;
}
//-----------------------------------------------------------------------------
// Program main
//-----------------------------------------------------------------------------
int main(int argc, char** argv)
{
pArgc = &argc;
pArgv = argv;
// start logs
shrQAStart(argc, argv);
shrSetLogFileName ("oclSimpleD3D9Texture.txt");
shrLog("%s Starting...\n\n", argv[0]);
// process command line arguments
if (argc > 1)
{
bQATest = shrCheckCmdLineFlag(argc, (const char **)argv, "qatest");
bNoPrompt = shrCheckCmdLineFlag(argc, (const char **)argv, "noprompt");
}
//
// create window
//
// Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
"OpenCL/D3D9 Texture InterOP", NULL };
RegisterClassEx( &wc );
int xBorder = ::GetSystemMetrics(SM_CXSIZEFRAME);
int yMenu = ::GetSystemMetrics(SM_CYMENU);
int yBorder = ::GetSystemMetrics(SM_CYSIZEFRAME);
// Create the application's window (padding by window border for uniform BB sizes across OSs)
HWND hWnd = CreateWindow( wc.lpszClassName, "OpenCL/D3D9 Texture InterOP",
WS_OVERLAPPEDWINDOW, 0, 0, g_WindowWidth + 2*xBorder, g_WindowHeight+ 2*yBorder+yMenu,
NULL, NULL, wc.hInstance, NULL );
ShowWindow(hWnd, SW_SHOWDEFAULT);
UpdateWindow(hWnd);
// init fps timer
shrDeltaT (1);
// Initialize Direct3D
if( SUCCEEDED( InitD3D9(hWnd) ) &&
SUCCEEDED( InitCL(argc, (const char **)argv) ) &&
SUCCEEDED( InitTextures() ) )
{
if (!g_bDeviceLost)
{
RegisterD3D9ResourceWithCL();
}
}
//
// the main loop
//
while(false == g_bDone)
{
RunCL();
DrawScene();
//
// handle I/O
//
MSG msg;
ZeroMemory( &msg, sizeof(msg) );
while( msg.message!=WM_QUIT )
{
if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
else
{
RunCL();
DrawScene();
if(bQATest)
{
for(int count=0;count<g_iFrameToCompare;count++)
{
RunCL();
DrawScene();
}
const char *ref_image_path = "ref_oclSimpleD3D9Texture.ppm";
const char *cur_image_path = "oclSimpleD3D9Texture.ppm";
// Save a reference of our current test run image
CheckRenderD3D9::BackbufferToPPM(g_pD3DDevice,cur_image_path);
// compare to offical reference image, printing PASS or FAIL.
g_bPassed = CheckRenderD3D9::PPMvsPPM(cur_image_path,ref_image_path,argv[0],MAX_EPSILON, 0.15f);
PostQuitMessage(0);
g_bDone = true;
}
}
}
};
// Unregister windows class
UnregisterClass( wc.lpszClassName, wc.hInstance );
// Cleanup and leave
Cleanup (g_bPassed ? EXIT_SUCCESS : EXIT_FAILURE);
}
bool Init(int argc, char** argv)
{
GetCLDev();
m_backend->Init(argc, argv);
m_aspectRatio = m_win_h / (float)m_win_w;
if (!m_backend->CreateWin(m_win_w, m_win_h, false, "OpenGL test app"))
{
fprintf(stderr, "Faild to create window");
return false;
}
GLenum res = glewInit();
if (res != GLEW_OK) {
fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
return false;
}
if (!InitCL())
{
return false;
}
wglSwapIntervalEXT(0);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glFrontFace(GL_CW);
//glCullFace(GL_BACK);
//glEnable(GL_CULL_FACE);
//glEnable(GL_DEPTH_TEST);
m_bodies.push_back(Body(Vector2f(-0.8f, -0.8f), Vector2f(0.021f, 0.0f), Vector2f(-0.05f, 0.11f), Vector2f(0.0f, 0.0f)));
m_bodies.push_back(Body(Vector2f(0.8f, 0.8f), Vector2f(0.021f, 0.0f), Vector2f(0.05f, -0.11f), Vector2f(0.0f, 0.0f)));
m_bodies.push_back(Body(Vector2f(-0.8f, 0.8f), Vector2f(0.014f, 0.0f), Vector2f(0.01f, 0.1f), Vector2f(0.0f, 0.0f)));
m_bodies.push_back(Body(Vector2f(0.8f, -0.8f), Vector2f(0.016f, 0.0f), Vector2f(0.01f, 0.1f), Vector2f(0.0f, 0.0f)));
m_bodies.push_back(Body(Vector2f(0.0f, 0.0f), Vector2f(0.3f, 0.0f), Vector2f(0.0f, 0.0f), Vector2f(0.0f, 0.0f)));
for (int i = 0; i < 5000; ++i)
{
m_bodies.push_back(Body(Vector2f((rand() % 100000) / 1000.0f - 1.0f, (rand() % 100000) / 1000.0f - 1.0f), Vector2f(rand() % 300 / 1000.0f, 0.0f), Vector2f((rand() % 2000) / 1000.0f - 1.0f, (rand() % 2000) / 1000.0f - 1.0f), Vector2f(0.0f, 0.0f)));
}
glGenBuffers(1, &m_VB);
glBindBuffer(GL_ARRAY_BUFFER, m_VB);
glBufferData(GL_ARRAY_BUFFER, sizeof(Body) * m_bodies.size(), &m_bodies[0], GL_DYNAMIC_DRAW);
cl_int ret = 0;
m_clVB = clCreateFromGLBuffer(m_clContext, CL_MEM_READ_WRITE, m_VB, &ret);
clErrNoAssert(ret);
ret = clSetKernelArg(m_kernelCalcForces, 0, sizeof(cl_mem), (void *)&m_clVB);
clErrNoAssert(ret);
ret = clSetKernelArg(m_kernelMove, 0, sizeof(cl_mem), (void *)&m_clVB);
clErrNoAssert(ret);
m_last_time_dt = 0;
m_time_shift = 1;
m_dt = 0.00001f;
m_shaderProgram = new CommonShaderProgram("vertexshader.txt", "pixelshader.txt", "geometryshader.txt");
m_shaderProgram->Compile();
m_shaderProgram->Apply();
m_shaderProgram->SetScale(m_scale);
m_shaderProgram->SetOffset(m_offset);
m_shaderProgram->SetAspectRatio(m_aspectRatio);
return true;
}
CLWContext::CLWContext(CLWDevice device)
{
devices_.push_back(device);
InitCL();
}
CLWContext::CLWContext(cl_context context, std::vector<CLWDevice>&& devices)
: ReferenceCounter<cl_context, clRetainContext, clReleaseContext>(context)
, devices_(devices)
{
InitCL();
}
