dx9texture.cpp

用于GPU通用计算的编程语言BrookGPU 0.4

        inData, width*inStride, inStride,
        width, height, components*sizeof(float), inRank, inExtents  );
    }
    else
    {
      setDataAT( inData, inRank, inDomainMin, inDomainMax, inExtents, components*sizeof(float),
        info.pBits, info.Pitch, rectWidth, rectHeight, internalComponents*sizeof(float), baseX, baseY );
    }

    result = shadowSurface->UnlockRect();
    DX9AssertResult( result, "UnlockRect failed" );
  }
}

void DX9Texture::getPixelAt( int x, int y, float4& outResult ) {

  unsigned int domainMin[2] = { y, x };
  unsigned int domainMax[2] = { y+1, x+1 };
  unsigned int extents[2] = { height, width };

  getData( (float*) &outResult, components*sizeof(float), 2,
    2, domainMin, domainMax, extents, false );
}

void DX9Texture::findRectForCopy( unsigned int inRank, const unsigned int* inDomainMin, const unsigned int* inDomainMax,
  const unsigned int* inExtents, bool inUsesAddressTranslation, RECT& outRect, bool& outFullBuffer )
{
  RECT rect;
  if( inRank == 1 )
  {
    rect.left = inDomainMin[0];
    rect.top = 0;
    rect.right = inDomainMax[0];
    rect.bottom = 1;
  }
  else
  {
    rect.left = inDomainMin[1];
    rect.top = inDomainMin[0];
    rect.right = inDomainMax[1];
    rect.bottom = inDomainMax[0];
  }
  outRect = rect;

  int domainWidth = rect.right - rect.left;
  int domainHeight = rect.bottom - rect.top;

  if( domainWidth != width || domainHeight != height )
  {
    outFullBuffer = false;
  }
  else
    outFullBuffer = true;
}

void DX9Texture::copyData( void* toBuffer, size_t toRowStride, size_t toElementStride,
  const void* fromBuffer, size_t fromRowStride, size_t fromElementStride,
  size_t columnCount, size_t rowCount, size_t elementSize )
{
  char* outputLine = (char*)toBuffer;
  const char* inputLine = (const char*)fromBuffer;

  size_t componentCount = elementSize / sizeof(float);

  for( size_t y = 0; y < rowCount; y++ )
  {
    char* outputPixel = outputLine;
    const char* inputPixel = inputLine;
    for( size_t x = 0; x < columnCount; x++ )
    {
      // TIM: for now we assume floating-point components
      float* output = (float*) outputPixel;
      const float* input = (const float*) inputPixel;
      for( size_t c = 0; c < componentCount; c++ )
        *output++ = *input++;

      inputPixel += fromElementStride;
      outputPixel += toElementStride;
    }
    inputLine += fromRowStride;
    outputLine += toRowStride;
  }
}

void DX9Texture::findRectForCopyAT( unsigned int inRank, const unsigned int* inDomainMin, const unsigned int* inDomainMax,
  const unsigned int* inExtents, bool inUsesAddressTranslation, RECT& outRect, bool& outFullBuffer,
  size_t inWidth, size_t inHeight, size_t& outBaseX, size_t& outBaseY )
{
  size_t r;
  size_t rank = inRank;

  size_t stride = 1;
  size_t minIndex = 0;
  size_t maxIndex = 0;
  bool wholeBuffer = true;
  for( r = 0; r < rank; r++ )
  {
    size_t d = rank - (r+1);

    size_t domainMin = inDomainMin[d];
    size_t domainMax = inDomainMax[d];
    size_t domainExtent = domainMax - domainMin;
    size_t streamExtent = inExtents[d];

    if( streamExtent != domainExtent )
      wholeBuffer = false;

    minIndex += domainMin * stride;
    maxIndex += (domainMax-1) * stride;
    stride *= streamExtent;
  }

  size_t minX, minY, maxX, maxY;

  minX = minIndex % inWidth;
  minY = minIndex / inWidth;
  maxX = maxIndex % inWidth;
  maxY = maxIndex / inWidth;

  RECT rect;
  rect.left = (minY == maxY) ? minX : 0;
  rect.top = minY;
  rect.right = (minY == maxY) ? maxX+1 : inWidth;
  rect.bottom = maxY+1;

  outRect = rect;
  outFullBuffer = wholeBuffer;
  outBaseX = minX;
  outBaseY = minY;
}

void DX9Texture::copyAllDataAT( void* toBuffer, size_t toRowStride, size_t toElementStride,
  const void* fromBuffer, size_t fromRowStride, size_t fromElementStride,
  size_t columnCount, size_t rowCount, size_t elementSize, size_t inRank, const unsigned int* inExtents )
{
  size_t elementCount = 1;
  for( size_t r = 0; r < inRank; r++ )
    elementCount *= inExtents[r];

  char* outputLine = (char*)toBuffer;
  const char* inputLine = (const char*)fromBuffer;

  size_t componentCount = elementSize / sizeof(float);

  size_t copiedElementCount = 0;
  for( size_t y = 0; y < rowCount; y++ )
  {
    char* outputPixel = outputLine;
    const char* inputPixel = inputLine;
    for( size_t x = 0; x < columnCount; x++ )
    {

      // TIM: for now we assume floating-point components
      float* output = (float*) outputPixel;
      const float* input = (const float*) inputPixel;
      for( size_t c = 0; c < componentCount; c++ )
        *output++ = *input++;

      inputPixel += fromElementStride;
      outputPixel += toElementStride;

      copiedElementCount++;
      if( copiedElementCount == elementCount )
        return;
    }
    inputLine += fromRowStride;
    outputLine += toRowStride;
  }
}

void DX9Texture::getDataAT( void* streamData, unsigned int streamRank,
  const unsigned int* streamDomainMin, const unsigned int* streamDomainMax,
  const unsigned int* streamExtents, size_t streamElementStride,
  const void* textureData, size_t textureLineStride, size_t textureWidth, size_t textureHeight,
  size_t textureElementStride, size_t textureBaseX, size_t textureBaseY )
{
  size_t r;
  size_t rank = streamRank;
  size_t domainMin[4] = {0,0,0,0};
  size_t domainMax[4] = {1,1,1,1};
  size_t domainExtents[4] = {1,1,1,1};
  size_t extents[4] = {1,1,1,1};
  size_t strides[4] = {0,0,0,0};

  size_t stride = 1;
  for( r = 1; r <= rank; r++ )
  {
    size_t d = rank - r;

    domainMin[d] = streamDomainMin[r];
    domainMax[d] = streamDomainMax[r];
    extents[d] = streamExtents[r];

    domainExtents[d] = domainMax[d] - domainMin[d];
    strides[d] = stride;
    stride *= domainExtents[d];
  }

  const char* textureBuffer = (const char*) textureData;
  char* streamBuffer = (char*) streamData;

  size_t x, y, z, w;
  for( w = domainMin[3]; w < domainMax[3]; w++ )
  {
    size_t offsetW = w * strides[3];
    for( z = domainMin[2]; z < domainMax[2]; z++ )
    {
      size_t offsetZ = offsetW + z * strides[2];
      for( y = domainMin[1]; y < domainMax[1]; y++ )
      {
        size_t offsetY = offsetZ + y * strides[1];
        for( x = domainMin[0]; x < domainMax[0]; x++ )
        {
          size_t offsetX = offsetY + x * strides[0];
          size_t streamOffset = offsetX * streamElementStride;

          size_t textureX = (offsetX % textureWidth) - textureBaseX;
          size_t textureY = (offsetX / textureWidth) - textureBaseY;
          size_t textureOffset = textureY * textureLineStride + textureX * textureElementStride;

          const float* textureElement = (const float*) (textureBuffer + textureOffset);
          float* streamElement = (float*) (streamBuffer + streamOffset);

          for( int c = 0; c < components; c++ )
            *streamElement++ = *textureElement++;
        }
      }
    }
  }
}

void DX9Texture::setDataAT( const void* streamData, unsigned int streamRank,
                           const unsigned int* streamDomainMin, const unsigned int* streamDomainMax,
                           const unsigned int* streamExtents, size_t streamElementStride,
                           void* textureData, size_t textureLineStride, size_t textureWidth, size_t textureHeight,
                           size_t textureElementStride, size_t textureBaseX, size_t textureBaseY )
{
  size_t r;
  size_t rank = streamRank;
  size_t domainMin[4] = {0,0,0,0};
  size_t domainMax[4] = {1,1,1,1};
  size_t domainExtents[4] = {1,1,1,1};
  size_t extents[4] = {1,1,1,1};
  size_t strides[4] = {0,0,0,0};

  size_t stride = 1;
  for( r = 1; r <= rank; r++ )
  {
    size_t d = rank - r;

    domainMin[d] = streamDomainMin[r];
    domainMax[d] = streamDomainMax[r];
    extents[d] = streamExtents[r];

    domainExtents[d] = domainMax[d] - domainMin[d];
    strides[d] = stride;
    stride *= domainExtents[d];
  }

  char* textureBuffer = (char*) textureData;
  const char* streamBuffer = (const char*) streamData;

  size_t x, y, z, w;
  for( w = domainMin[3]; w < domainMax[3]; w++ )
  {
    size_t offsetW = w * strides[3];
    for( z = domainMin[2]; z < domainMax[2]; z++ )
    {
      size_t offsetZ = offsetW + z * strides[2];
      for( y = domainMin[1]; y < domainMax[1]; y++ )
      {
        size_t offsetY = offsetZ + y * strides[1];
        for( x = domainMin[0]; x < domainMax[0]; x++ )
        {
          size_t offsetX = offsetY + x * strides[0];
          size_t streamOffset = offsetX * streamElementStride;

          size_t textureX = (offsetX % textureWidth) - textureBaseX;
          size_t textureY = (offsetX / textureWidth) - textureBaseY;
          size_t textureOffset = textureY * textureLineStride + textureX * textureElementStride;

          float* textureElement = (float*) (textureBuffer + textureOffset);
          const float* streamElement = (const float*) (streamBuffer + streamOffset);

          for( int c = 0; c < components; c++ )
            *textureElement++ = *streamElement++;
        }
      }
    }
  }
}