void CubeDemo::buildVertexBuffer() { HR(gd3dDevice->CreateVertexBuffer(8*sizeof(VertexPos), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mVB, 0)); VertexPos *v = 0; HR(mVB->Lock(0, 0, (void**)&v, 0)); v[0] = VertexPos(-1.0f, -1.0f, -1.0f); v[1] = VertexPos(-1.0f, 1.0f, -1.0f); v[2] = VertexPos( 1.0f, 1.0f, -1.0f); v[3] = VertexPos( 1.0f, -1.0f, -1.0f); v[4] = VertexPos(-1.0f, -1.0f, 1.0f); v[5] = VertexPos(-1.0f, 1.0f, 1.0f); v[6] = VertexPos( 1.0f, 1.0f, 1.0f); v[7] = VertexPos( 1.0f, -1.0f, 1.0f); HR(mVB->Unlock()); }
void RLines::initOpenGL() { {//Setup initial vertex positions std::vector<float> VertexPos(3 * _N * 2, 0.0); for (size_t i(0); i < _N; ++i) { VertexPos[6*i+0] = i * 1.0f / _N; VertexPos[6*i+1] = i * 1.0f / _N; VertexPos[6*i+2] = i * 1.0f / _N; VertexPos[6*i+3] = i * 1.0f / _N; VertexPos[6*i+4] = (i + 0.5f) * 1.0f / _N; VertexPos[6*i+5] = i * 1.0f / _N; } setGLPositions(VertexPos); } { std::vector<cl_uchar4> VertexColor(_N * 2); for (size_t icol = 0; icol < _N * 2; ++icol) { VertexColor[icol].s[0] = 255; VertexColor[icol].s[1] = 255; VertexColor[icol].s[2] = 255; VertexColor[icol].s[3] = 255; } setGLColors(VertexColor); } {//Setup initial element data std::vector<int> ElementData(2 * _N, 0); for (size_t i(0); i < _N; ++i) { ElementData[2 * i + 0] = 2 * i + 0; ElementData[2 * i + 1] = 2 * i + 1; } setGLElements(ElementData); } }
void RVolume::initOpenCL() { { float vertices[] = {-1,-1,-1, 1,-1,-1, 1, 1,-1, -1, 1,-1, -1,-1, 1, -1, 1, 1, 1, 1, 1, 1,-1, 1}; std::vector<float> VertexPos(vertices, vertices + sizeof(vertices) / sizeof(float)); setGLPositions(VertexPos); } { int elements[] = {3,2,1,0, 6,7,1,2, 5,4,7,6, 3,0,4,5, 6,2,3,5, 7,4,0,1 }; std::vector<int> ElementData(elements, elements + sizeof(elements) / sizeof(int)); setGLElements(ElementData); } }
void RSurface::init(const std::shared_ptr<magnet::thread::TaskQueue>& systemQueue) { RTriangles::init(systemQueue); {//Setup initial vertex positions std::vector<float> VertexPos(3 * _N * _N, 0.0); Vector axis1step = _axis1 / (_N-1), axis2step = _axis2 / (_N-1); for (size_t i = 0; i < _N; ++i) for (size_t j = 0; j < _N; ++j) { Vector pos = i * axis1step + j * axis2step + _origin; VertexPos[0 + 3 * (i + _N * j)] = pos[0]; VertexPos[1 + 3 * (i + _N * j)] = pos[1]; VertexPos[2 + 3 * (i + _N * j)] = pos[2]; } setGLPositions(VertexPos); } {//Setup inital normal vectors std::vector<float> VertexNormals(3 * _N * _N, 0.0); Vector normal = _axis3 / _axis3.nrm(); for (size_t i = 0; i < _N; ++i) for (size_t j = 0; j < _N; ++j) { VertexNormals[0 + 3 * (i + _N * j)] = normal[0]; VertexNormals[1 + 3 * (i + _N * j)] = normal[1]; VertexNormals[2 + 3 * (i + _N * j)] = normal[2]; } setGLNormals(VertexNormals); } {//Setup initial Colors std::vector<GLubyte> VertexColor(_N * _N * 4); for (size_t i = 0; i < _N; ++i) for (size_t j = 0; j < _N; ++j) { VertexColor[(i + _N * j) * 4 + 0] = 255; VertexColor[(i + _N * j) * 4 + 1] = 255; VertexColor[(i + _N * j) * 4 + 2] = 255; VertexColor[(i + _N * j) * 4 + 3] = 255; } setGLColors(VertexColor); } {//Setup initial element data std::vector<GLuint> ElementData(3*2*(_N-1)*(_N-1), 0.0); for (size_t i = 0; i < _N - 1; i++) for (size_t j = 0; j < _N - 1; j++) { ElementData[6 * (i + (_N - 1) * j) + 0] = i + _N * j; ElementData[6 * (i + (_N - 1) * j) + 1] = i + _N * (j + 1); ElementData[6 * (i + (_N - 1) * j) + 2] = i + 1 + _N * (j + 1); ElementData[6 * (i + (_N - 1) * j) + 3] = i + _N * j; ElementData[6 * (i + (_N - 1) * j) + 4] = i + 1 + _N * (j + 1); ElementData[6 * (i + (_N - 1) * j) + 5] = i + 1 + _N * j; } setGLElements(ElementData); } }
void RTSpheres::init(const std::tr1::shared_ptr<magnet::thread::TaskQueue>& systemQueue) { RTriangles::init(systemQueue); magnet::GL::Context& context = magnet::GL::Context::getContext(); //Build the sort functor now so we can grab the padding sortFunctor.build(context.getCLCommandQueue(), context.getCLContext()); //We must pad the sort data out to a multiple of sortFunctor.padding() cl_uint padding = std::max(sortFunctor.padding(), size_t(1024)); cl_uint paddedN = ((_N + padding - 1) / padding) * padding; { _spherePositions = cl::Buffer(context.getCLContext(), CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_ONLY, sizeof(cl_float4) * _N); _sortKeys = cl::Buffer(context.getCLContext(), CL_MEM_READ_WRITE, sizeof(cl_float) * paddedN); _sortData = cl::Buffer(context.getCLContext(), CL_MEM_READ_WRITE, sizeof(cl_uint) * paddedN); _sphereColors = cl::Buffer(context.getCLContext(), CL_MEM_READ_ONLY, sizeof(cl_uchar4) * paddedN); cl_float4* Pos = (cl_float4*)context.getCLCommandQueue().enqueueMapBuffer(_spherePositions, true, CL_MAP_WRITE, 0, _N * sizeof(cl_float4)); const float density = 0.1; cl_float particleDiam = std::pow(1 * density / _N, float(1.0 / 3.0)); //Generates positions on a simple cubic lattice for (size_t partID(0); partID < _N; ++partID) { Pos[partID].x = ((1.0 * rand()) / RAND_MAX) - 0.5; Pos[partID].y = ((1.0 * rand()) / RAND_MAX) - 0.5; Pos[partID].z = ((1.0 * rand()) / RAND_MAX) - 0.5; Pos[partID].w = particleDiam * 0.5; } //Start copying this data to the graphics card context.getCLCommandQueue().enqueueUnmapMemObject(_spherePositions, (void*)Pos); } {//Setup initial vertex positions size_t nVertice = 0; for (std::vector<SphereDetails>::const_iterator iPtr = _renderDetailLevels.begin(); iPtr != _renderDetailLevels.end(); ++iPtr) nVertice += iPtr->_type.getVertexCount() * iPtr->_nSpheres; std::vector<float> VertexPos(3 * nVertice, 0.0); setGLPositions(VertexPos); } {//Setup inital normal vectors size_t nNormals = 0; for (std::vector<SphereDetails>::const_iterator iPtr = _renderDetailLevels.begin(); iPtr != _renderDetailLevels.end(); ++iPtr) nNormals += iPtr->_type.getVertexCount() * iPtr->_nSpheres; std::vector<float> VertexNormals(3 * nNormals, 0.0); nNormals = 0; for (std::vector<SphereDetails>::const_iterator iPtr = _renderDetailLevels.begin(); iPtr != _renderDetailLevels.end(); ++iPtr) { for (size_t i = 0; i < iPtr->_nSpheres; ++i) for (int j = 0; j < 3 * iPtr->_type.getVertexCount(); ++j) VertexNormals[nNormals + 3 * iPtr->_type.getVertexCount() * i + j] = iPtr->_type.getVertices()[j]; nNormals += 3 * iPtr->_nSpheres * iPtr->_type.getVertexCount(); } setGLNormals(VertexNormals); } {//Setup initial Colors size_t nColors = 0; for (std::vector<SphereDetails>::const_iterator iPtr = _renderDetailLevels.begin(); iPtr != _renderDetailLevels.end(); ++iPtr) nColors += iPtr->_type.getVertexCount() * iPtr->_nSpheres; std::vector<GLubyte> VertexColor(nColors * 4); for (size_t icol = 0; icol < nColors; ++icol) { VertexColor[icol * 4 + 0] = 255; VertexColor[icol * 4 + 1] = 255; VertexColor[icol * 4 + 2] = 255; VertexColor[icol * 4 + 3] = 255; } setGLColors(VertexColor); } {//Setup initial element data size_t nElements = 0; for (std::vector<SphereDetails>::const_iterator iPtr = _renderDetailLevels.begin(); iPtr != _renderDetailLevels.end(); ++iPtr) nElements += 3 * iPtr->_type.getFaceCount() * iPtr->_nSpheres; std::vector<GLuint> ElementData(nElements, 0.0); nElements = 0; size_t nSphereVertices = 0; for (std::vector<SphereDetails>::const_iterator iPtr = _renderDetailLevels.begin(); iPtr != _renderDetailLevels.end(); ++iPtr) { for (size_t i = 0; i < iPtr->_nSpheres; ++i) for (int j = 0; j < 3 * iPtr->_type.getFaceCount(); ++j) ElementData[nElements + 3 * iPtr->_type.getFaceCount() * i + j] = i * iPtr->_type.getVertexCount() + iPtr->_type.getFaces()[j] + nSphereVertices; nSphereVertices += iPtr->_type.getVertexCount() * iPtr->_nSpheres; nElements += 3 * iPtr->_type.getFaceCount() * iPtr->_nSpheres; } setGLElements(ElementData); } std::stringstream fullSource; //It is ideal if the workgroup size divides by 3(coords), 64 //(warp/wave) AND the number of vertices per particle (not so important) //An Icosahedron, of order 0 (12), fits exactly into //3x32x2=192=12x16 _workgroupsize = 2*32*3; _globalsize = _workgroupsize * (std::min((_N +_workgroupsize-1) / _workgroupsize, _workgroupsize*(9216 / _workgroupsize))); fullSource << "#define WORKGROUP_SIZE " << _workgroupsize << "\n"; fullSource << sphereKernelSource; //Need to make the c_str() point to a valid data area, so copy the string std::string finalSource = fullSource.str(); cl::Program::Sources kernelSource; kernelSource.push_back(std::pair<const char*, ::size_t> (finalSource.c_str(), finalSource.size())); _program = cl::Program(context.getCLCommandQueue().getInfo<CL_QUEUE_CONTEXT>(), kernelSource); std::string buildOptions; cl::Device clDevice = context.getCLCommandQueue().getInfo<CL_QUEUE_DEVICE>(); try { _program.build(std::vector<cl::Device>(1, clDevice), buildOptions.c_str()); } catch(cl::Error& err) { std::string msg = _program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(context.getCLDevice()); std::cout << "Compilation failed for device " << context.getCLDevice().getInfo<CL_DEVICE_NAME>() << "\nBuild Log:" << msg; throw; } _renderKernel = cl::Kernel(_program, "SphereRenderKernel"); _sortDataKernel = cl::Kernel(_program, "GenerateData"); _colorKernel = cl::Kernel(_program, "SphereColorKernel"); _pickingKernel = cl::Kernel(_program, "SpherePickingKernel"); _sortDataKernelFunc = _sortDataKernel.bind(context.getCLCommandQueue(), cl::NDRange(paddedN), cl::NDRange(256)); _renderKernelFunc = _renderKernel.bind(context.getCLCommandQueue(), cl::NDRange(_globalsize), cl::NDRange(_workgroupsize)); _pickingKernelFunc = _pickingKernel.bind(context.getCLCommandQueue(), cl::NDRange(_globalsize), cl::NDRange(_workgroupsize)); for (std::vector<SphereDetails>::iterator iPtr = _renderDetailLevels.begin(); iPtr != _renderDetailLevels.end(); ++iPtr) iPtr->setupCLBuffers(context); }