ZFX + Developia

Code: Alles auswählen

ILinfo ImageInfo;
iluGetImageInfo(&ImageInfo);
image->setDataSize(ImageInfo.SizeOfData);

Code: Alles auswählen

// load an image for the texture using DevIL codec
brGraphics::brImageManager& imgMgr = brGraphics::brImageManager::getInstance();
boost::shared_ptr<brGraphics::brImage> image = imgMgr.getImage("data/textures/testTexture.png");

LPDIRECT3DTEXTURE9  texture = 0;
unsigned int size = image->getDataSize();

//try map immage to texture
hr = D3DXCreateTextureFromFileInMemory(d3ddev,
                                                                image->getImageData(),
                                                                size,
                                                                &texture);

if (FAILED(hr))
 {
     throw brCore::brIllegalStateException(
         "Couldn't create valid D3D9Texture!: " + std::string(DXGetErrorString9(hr)));
}

// set texture sampler infos
d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);

Code: Alles auswählen

     // load an image for the texture
      brGraphics::brImageManager& imgMgr = brGraphics::brImageManager::getInstance();
      boost::shared_ptr<brGraphics::brImage> image = imgMgr.getImage("data/textures/testTexture.png");
    
      // create the texture
      GLuint texture[1];
      glGenTextures(1, &texture[0]);					

      // Typical Texture Generation Using Data From The Bitmap
      glBindTexture(GL_TEXTURE_2D, texture[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, 3, image->getWidth(), image->getHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE, image->getImageData());
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

Code: Alles auswählen

 hr = D3DXCreateTexture( d3ddev,
                            image->getWidth(),
                            image->getHeight(),
                            1,
                            D3DUSAGE_DYNAMIC,
                            D3DFMT_R5G6B5,
                            D3DPOOL_DEFAULT,
                            &texture );

    if (FAILED(hr))
    {
 	      throw brCore::brIllegalStateException(
          "Couldn't create empty D3D9Texture! " + std::string(DXGetErrorString9(hr)));
    }

    // Lock the texture and copy the pixel data into it
    D3DLOCKED_RECT lr;
    hr = texture->LockRect( 0, &lr, 0, 0 );        // --> Hier ist Ende
    if(FAILED(hr))
    {
         throw brCore::brIllegalStateException(
         "Unable to lock D3D9Texture! " + std::string(DXGetErrorString9(hr)));
    }

Code: Alles auswählen

    LPDIRECT3DTEXTURE9  texture = 0;
    boost::shared_ptr<brGraphics::brImage> image = imgMgr.getImage("data/textures/testTexture.png");

    // determine texture pixel format
    D3DFORMAT dxPixelFormat = brRenderer::brD3D9Mapping::getDXPixelFormat(image->getPixelFormat());
    log << output(brLog::OUT_CON_LOG) << time << "Dx9 pixel format: " << brRenderer::brD3D9Mapping::getDXPixelFormatName(dxPixelFormat) << std::endl;

    // create empty texture
    hr = D3DXCreateTexture( d3ddev,
                            image->getWidth(),
                            image->getHeight(),
                            0,                   
                            D3DUSAGE_DYNAMIC,
                            dxPixelFormat,
                            D3DPOOL_DEFAULT,
                            &texture );

    if (FAILED(hr))
    {
 	  throw brCore::brIllegalStateException(
          "Couldn't create empty D3D9Texture! " + std::string(DXGetErrorString9(hr)));
    }

    // Lock the texture and copy the pixel data into it
    D3DLOCKED_RECT lr;
    hr = texture->LockRect( 0, &lr, 0, 0 );
    if(FAILED(hr))
    {
         throw brCore::brIllegalStateException(
         "Unable to lock D3D9Texture! " + std::string(DXGetErrorString9(hr)));
    }

    unsigned int dwBytes = lr.Pitch * image->getHeight();
    memcpy(lr.pBits, (LPVOID)image->getImageData(), dwBytes);

    // Unlock the texture
    hr = texture->UnlockRect(0);
    if(FAILED(hr))
    {
         throw brCore::brIllegalStateException(
          "Unable to unlock D3D9Texture! " + std::string(DXGetErrorString9(hr)));
    }

   // defining texture samplers
   d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
   d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);

Code: Alles auswählen

    // the number of bytes consumed by one row of the image
    unsigned int pitch = lr.Pitch;
    log << output(brLog::OUT_CON_LOG) << time << "Pitch: " << pitch << std::endl;

    //checksum to get the image bytes per pixel for a single row
    unsigned int byPP = (image->getBpp()/8) * image->getWidth();
    log << output(brLog::OUT_CON_LOG) << time << "Checksum: " << byPP << std::endl;

    if(pitch>byPP){

       // Precompute as much as possible
       int rows   = image->getHeight();
       int stride = byPP;

       for(int y=0; y<rows; y++){

          // Defintion of the destination where lr.pBits is the
          // pointer to the DX texture data
          BYTE* dst = (BYTE*)lr.pBits + lr.Pitch * y;

          // Defintion of the source where we read from
          BYTE* src = (BYTE*)image->getImageData() + stride * y;

          memcpy(dst, src, stride);
       }
    }

Code: Alles auswählen

    hr = D3DXCreateTexture( d3ddev,
                            image->getWidth(),
                            image->getHeight(),
                            0,                                            //Mipmaps level
                            D3DUSAGE_DYNAMIC,
                            D3DFMT_R8G8B8,                    //Pixelformat
                            D3DPOOL_DEFAULT,
                            &texture );