Пример #1
0
void CLWrapper::copyTo( CLWrapper *target, int srcOffset, int dstOffset, int count ) {
    if( !onDevice ) {
        throw std::runtime_error("Must have called copyToDevice() or createOnDevice() before calling copyTo(CLWrapper*)");
    }
    if( !target->onDevice ) {
        throw std::runtime_error("Must have called copyToDevice() or createOnDevice() on target before calling copyTo(target)");
    }
    if( srcOffset + count > N ) {
      throw std::runtime_error("copyTo: not enough source elements, given offset " + easycl::toString(srcOffset) + " and count " + easycl::toString(count));
    }
    if( dstOffset + count > target->N ) {
      throw std::runtime_error("copyTo: not enough destation elements, given offset " + easycl::toString(dstOffset) + " and count " + easycl::toString(count));
    }
    if( getElementSize() != target->getElementSize() ) {
        throw std::runtime_error("copyTo: element size mismatch between source and target CLWrapper objects");
    }
    // can assume that we have our data on the device now, because of if check
    // just now
    // we will also assume that destination CLWrapper* is valid
    cl_event event = NULL;
    cl_int err = clEnqueueCopyBuffer( *(cl->queue), devicearray, target->devicearray, 
        srcOffset * getElementSize(), dstOffset * getElementSize(), count * getElementSize(),
        0, NULL, &event );
    if (err != CL_SUCCESS) {
        throw std::runtime_error("copyTo failed with " + easycl::toString( err ) );
    }
    else {
        /* Wait for calculations to be finished. */
//        err = clWaitForEvents(1, &event);
    }
    clReleaseEvent(event);
    target->markDeviceDirty();
}
Пример #2
0
UINT DataArray::operator[](size_t index) const {
  switch(getElementSize()) {
  case 1 : return ByteArray::operator[](index);
  case 2 : return *(unsigned short*)(ByteArray::getData() + index * sizeof(short));
  case 4 : return *(unsigned int  *)(ByteArray::getData() + index * sizeof(int));
  default: return *(unsigned int  *)(ByteArray::getData() + index * getElementSize());
  }
}
Пример #3
0
void DataArray::setElement(BYTE *e, UINT value) {
  switch(getElementSize()) {
  case 1 : *e                    = (BYTE)value;           break;
  case 2 : *((unsigned short*)e) = (unsigned short)value; break;
  default: *((unsigned int*)e)   = value;                 break;
  }
}
Пример #4
0
	bool CD3D11Texture3D::copyDataToAnotherTexture(ITexture* dest)
	{
		if (!dest)
			return false;

		if (dest->getType() != ETT_TEXTURE_3D) {
			GF_PRINT_CONSOLE_INFO("Texture's data cannot be copied between different types\n");
			return false;
		}

		CD3D11Texture3D* pAnotherTexture = dynamic_cast<CD3D11Texture3D*>(dest);

		if (getElementSize() != pAnotherTexture->getElementSize())
		{
			GF_PRINT_CONSOLE_INFO("Buffers with different element size couldn't copy data with each other.\n");
			return false;
		}

		if (mTextureWidth > pAnotherTexture->getWidth() 
			|| mTextureHeight > pAnotherTexture->getHeight()
			|| mTextureDepth > pAnotherTexture->getDepth())
		{
			GF_PRINT_CONSOLE_INFO("Destination Buffer' size is smaller than Source Buffer.\n");
			return false;
		}

		md3dDeviceContext->CopyResource(pAnotherTexture->md3dTexture, md3dTexture);
		return true;
	}
Пример #5
0
/**
 *  Finalize at most the first 'count' elements of the allocation by applying
 *  the finalizer to each element in turn, from last to first,  thus ensuring
 *  that elements of the array are destroyed in the opposite order to that in
 *  which they were created.
 */
void Header::finalize(count_t count)
{
    if (finalizer_t f = getFinalizer())                  // Not yet finalized?
    {
        size_t  n = getElementSize();                    // ...size of element
        size_t  c = std::min(getElementCount(),count);   // ...el's to destroy
        byte_t* p = getPayload();                        // ...head of payload
        byte_t* q = p + c * n;                           // ...tail of payload

     /* Clear the 'finalizer' flag to signal that the finalization has been
        taken care of. We do so *before* invoking 'f', in case 'f' goes and
        frees the entire allocation in which the header sits, as happens to
        the underlying pages of class ScopedArena, for example...*/

        _flags &= ~finalizer;                            // ...taken care of

     /* Finalize each of the elements from the end of the array back toward
        its beginning, that is, in the opposite order to that in which they
        were first constructed...*/

        for (size_t i=0; i!=c; ++i)                      // ...for each element
        {
            f(q -= n);                                   // ....call finalizer
        }

     /* It is now no longer safe to access any of this object's members...*/
    }
}
void CC3VertexBoneWeights::setBoneWeights( GLfloat* weights, GLuint vtxIndex )
{
	GLfloat* vtxWeights = getBoneWeightsAt(vtxIndex);
	GLint numWts = getElementSize();
	for (int i = 0; i < numWts; i++) 
		vtxWeights[i] = weights[i];
}
Пример #7
0
void DataArray::init() {
  UINT i;
  reset();
  BYTE        *ep       = (BYTE*)getData();
  const size_t n        = size();
  const UINT   elemSize = getElementSize();

  UINT maxValue;
  switch(elemSize) {
  case 1 : maxValue = min((UINT)n, 0xff  ); break;
  case 2 : maxValue = min((UINT)n, 0xffff); break;
  default: maxValue = (UINT)n;              break;
  }
  switch(m_param.m_initMethod) {
  case IDC_RADIO_RANDOM:
    { switch(m_param.m_randomizationMethod) {
      case FIXED_SEED       : m_param.m_random.setSeed(m_param.m_seed);       break;
      case SAME_RANDOM_SEED : m_param.m_random.setSeed(m_param.m_randomSeed); break;
      case RANDOM_SEED      : m_param.m_random.randomize();                   break;
      }
      for(i = 0; i < n; i++, ep += elemSize) {
        setElement(ep, m_param.m_random.nextInt(maxValue));
      }
    }
    break;

  case IDC_RADIO_SORTED:
    for(i = 0; i < n; i++, ep += elemSize) {
      setElement(ep, (UINT)((i*maxValue)/n));
    }
    break;

  case IDC_RADIO_INVERSESORTED:
    for(i = 0; i < n; i++, ep += elemSize) {
      setElement(ep, (UINT)((n-i)*maxValue/n));
    }
    break;

  case IDC_RADIO_SINUS:
    for(i = 0; i < n; i++, ep += elemSize) {
      setElement(ep, (unsigned int)(maxValue * (0.5*(1.0+sin(M_PI*2*i / (n-1)*m_param.m_periodCount)))));
    }
    break;

  case IDC_RADIO_FILEDATA:
    for(i = 0; i < n; i++, ep += elemSize) {
      setElement(ep, m_param.m_fileData[i]);
    }
    break;

  default:
    throwException(_T("DataArray::init:Unknown initmethod (=%d)"), m_param.m_initMethod);
    break;
  }
}
Пример #8
0
void CLWrapper::createOnDevice() {
    if(onDevice) {
        throw std::runtime_error("createOnDevice(): already on device");
    }
//        std::cout << "creating buffer on device of " << N << " elements" << std::endl;
    devicearray = clCreateBuffer(*(cl->context), CL_MEM_READ_WRITE, getElementSize() * N, 0, &error);
    cl->checkError(error);
    onDevice = true;
    deviceDirty = false;
//        std::cout << "... created ok" << std::endl;
}
Пример #9
0
nuElementBuffer::nuElementBuffer(ELEMENT_TYPE type, ui32 element_num, nuGResource::RESOURCE_USAGE usage)
    : nuGResource(nuGResource::ELEMENT_BUFFER, usage),
      mpBuffer(nullptr),
      mSize(0),
      mCommitSize(0),
      mElementBufferID(0),
      mElementNum(element_num),
      mElementType(type)
{
  mSize = getElementSize(mElementType) * mElementNum;
}
Пример #10
0
	void VertexDecl::bindArray()
	{
		bool haveTex = false;
		for ( InfoVec::iterator iter = mInfoVec.begin() , itEnd = mInfoVec.end(); 
			iter != itEnd; ++iter )
		{
			Info& info = *iter;
			switch( info.semantic )
			{
			case Vertex::ePosition:
				glEnableClientState( GL_VERTEX_ARRAY );
				glVertexPointer( getElementSize( info.format ) , getFormatType( info.format ) , mVertexSize , (void*)info.offset );
				break;
			case Vertex::eNormal:
				assert( getElementSize( info.format ) == 3 );
				glEnableClientState( GL_NORMAL_ARRAY );
				glNormalPointer( getFormatType( info.format ) , mVertexSize , (void*)info.offset );
				break;
			case Vertex::eColor:
				if ( info.idx == 0 )
				{
					glEnableClientState( GL_COLOR_ARRAY );
					glColorPointer( getElementSize( info.format ) , getFormatType( info.format ) , mVertexSize , (void*)info.offset );
				}
				else
				{
					glEnableClientState( GL_SECONDARY_COLOR_ARRAY );
					glSecondaryColorPointer( getElementSize( info.format ) , getFormatType( info.format ) , mVertexSize , (void*)info.offset );
				}
				break;
			case Vertex::eTexcoord:
				glClientActiveTexture( GL_TEXTURE0 + info.idx );
				glEnableClientState( GL_TEXTURE_COORD_ARRAY );
				glTexCoordPointer( getElementSize( info.format ) , getFormatType( info.format ) , mVertexSize , (void*)info.offset );
				haveTex = true;
				break;
			}
		}
	}
Пример #11
0
BitSet &DataArray::getModified(BitSet &dst, const DataArray &a) const {
  dst.setCapacity(size());
  dst.clear();
  const int n           = size();
  const int elementSize = getElementSize();
  switch(elementSize) {
  case sizeof(BYTE):
    { const BYTE *p1 = (const BYTE*)getData();
      const BYTE *p2 = (const BYTE*)a.getData();
      for(int i = 0; i < n; i++) {
        if(*(p1++) != *(p2++)) {
          dst.add(i);
        }
      }
    }
    break;
  case sizeof(unsigned short):
    { const unsigned short *p1 = (const unsigned short*)getData();
      const unsigned short *p2 = (const unsigned short*)a.getData();
      for(int i = 0; i < n; i++) {
        if(*(p1++) != *(p2++)) {
          dst.add(i);
        }
      }
    }
    break;
  case sizeof(unsigned int):
    { const unsigned int *p1 = (const unsigned int*)getData();
      const unsigned int *p2 = (const unsigned int*)a.getData();
      for(int i = 0; i < n; i++) {
        if(*(p1++) != *(p2++)) {
          dst.add(i);
        }
      }
    }
    break;
  default:
    { const BYTE *p1 = (const BYTE*)getData();
      const BYTE *p2 = (const BYTE*)a.getData();
      for(int i = 0; i < n; i++, p1 += elementSize, p2 += elementSize) {
        if(*((unsigned int*)p1) != *((unsigned int*)p2)) {
          dst.add(i);
        }
      }
    }
    break;

  }
  return dst;
}
Пример #12
0
void CLWrapper::copyToHost() {
    if(!onDevice) {
        throw std::runtime_error("copyToHost(): not on device");
    }
//    cl->finish();
    cl_event event = NULL;
    error = clEnqueueReadBuffer(*(cl->queue), devicearray, CL_TRUE, 0, getElementSize() * N, getHostArray(), 0, NULL, &event);    
    cl->checkError(error);
    cl_int err = clWaitForEvents(1, &event);
    clReleaseEvent(event);
    if (err != CL_SUCCESS) {
        throw std::runtime_error("wait for event on copytohost failed with " + easycl::toString( err ) );
    }
    deviceDirty = false;
}
Пример #13
0
	void fillTempBuffer(dae_reader_t *reader, geometry_t const *geometry, int meshIndex, vector<float>& rawData)
	{
		const vector<int> &triangles = geometry->triangles[meshIndex];
		int v = geometry->vertexOffset[meshIndex];
		int n = geometry->normalOffset[meshIndex];
		int t = geometry->texcoordOffset[meshIndex];
		int elementSize = getElementSize(reader);
		int x = reader->x;
		int y = reader->y;
		int z = reader->z;

		int elementCount = 1;
		elementCount += n != -1 ? 1 : 0;
		elementCount += t != -1 ? 1 : 0;

		for (uint32_t i = 0, j = 0; i < triangles.size(); i += elementCount, j++)
		{
			int vSrc = i + v;
			int trv = triangles[vSrc];
			trv *= 3;
			rawData.push_back(geometry->vertices[trv + x]);
			rawData.push_back(geometry->vertices[trv + y]);
			rawData.push_back(geometry->vertices[trv + z]);

			if (n > -1)
			{
				int nSrc = i + n;
				int trn = triangles[nSrc];
				trn *= 3;
				rawData.push_back(geometry->normals[trn + x]);
				rawData.push_back(geometry->normals[trn + y]);
				rawData.push_back(geometry->normals[trn + z]);
			}

			if (t > -1)
			{
				int tSrc = i + t;
				int trt = 2 * triangles[tSrc];
				rawData.push_back(geometry->texcoords[trt + 0]);
				rawData.push_back(geometry->texcoords[trt + 1]);
			}
		}
	}
Пример #14
0
static void convertInputElements(D3D11_INPUT_ELEMENT_DESC* out, JBKShaderInputElement* elements, uint32_t elementCount) {
	uint32_t offsets[16] = { 0 };

	for (uint32_t i = 0; i < elementCount; i++) {
		uint32_t slot = elements[i].slot;
		JBKShaderFormat format = elements[i].format;
		uint8_t instanced = isInstanced(format);

		out[i].SemanticName = elements[i].name;
		out[i].SemanticIndex = elements[i].index;
		out[i].Format = JBKD3DUtils_ConvertFormat(format);
		out[i].InputSlot = slot;
		out[i].AlignedByteOffset = offsets[slot];
		out[i].InputSlotClass = instanced ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA;
		out[i].InstanceDataStepRate = instanced ? 1 : 0;

		offsets[slot] += getElementSize(format);
	}
}
Пример #15
0
void CLWrapper::copyToDevice() {
    if(!onHost ) {
        throw std::runtime_error("copyToDevice(): not on host");
    }
    if( onDevice ) {
        error = clEnqueueWriteBuffer(*(cl->queue), devicearray, CL_TRUE, 0, getElementSize() * N, getHostArray(), 0, NULL, NULL);    
        cl->checkError(error);
        deviceDirty = false;
    } else {
//        std::cout << "copying buffer to device of " << N << " elements" << std::endl;
//        for( int i = 0; i < N; i++ ) { 
//           std::cout << "i " << i << " " << ((float*)getHostArrayConst())[i] << std::endl;
//        }
        devicearray = clCreateBuffer(*(cl->context), CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, getElementSize() * N, (void *)getHostArrayConst(), &error);
        cl->checkError(error);
        onDevice = true;
        deviceDirty = false;
    }
}
Пример #16
0
	void fillIndices(dae_reader_t *reader, uint32_t geometryID, vector<float>& rawData)
	{
		geometry_t *geometry = &reader->geometry[geometryID];
		elements_t elements = getElementOffsets(geometry);
		int totalTrianglesSize = getTrianglesSize(geometry);
		vector<uint32_t>& indices = geometry->indices;
		int elementSize = getElementSize(reader);

		indices.resize(totalTrianglesSize / elements.elementsCount);
		memset(indices.data(), 0xFF, indices.size() * sizeof(uint32_t));

		int baseIdx = 0;

		for (uint32_t i = 0; i < geometryID; i++)
		{
			baseIdx += reader->geometry[i].maxIndex;
		}

		int idx = geometryID == 0 ? 0 : baseIdx + 1;

		for (uint32_t i = 0; i < indices.size(); i++)
		{
			if (indices[i] != -1) continue;

			indices[i] = idx;
			addVertex(rawData, geometry->bufferData, i*elementSize, elementSize);

			for (uint32_t j = i + 1; j < indices.size(); j++)
			{
				if (!compareVertices(rawData, i, j, elementSize))
				{
					indices[j] = idx;
				}
			}

			idx++;
		}

		geometry->maxIndex = idx - baseIdx - 1;
	}
Пример #17
0
//virtual 
S32	LLSDMessageReader::getSize(const char *blockname, S32 blocknum, 
							   const char *varname)
{
	return getElementSize(mMessage[blockname][blocknum][varname]);
}