/**----------------------------------------------------------------------------- * 초기화 객체들 소거 *------------------------------------------------------------------------------ */ VOID Cleanup() { if ( g_pTexNormal != NULL ) { g_pTexNormal->Release(); } if ( g_pTexHeight != NULL ) { g_pTexHeight->Release(); } if ( g_pTexDiffuse != NULL ) { g_pTexDiffuse->Release(); } if ( g_pIB != NULL ) { g_pIB->Release(); } if ( g_pVB != NULL ) { g_pVB->Release(); } if ( g_pd3dDevice != NULL ) { g_pd3dDevice->Release(); } if ( g_pD3D != NULL ) { g_pD3D->Release(); } }
bool AlphaMap::init(bool pAlphaCheck, LPDIRECT3DTEXTURE9 pTexture) { d_solid = true; if (!pAlphaCheck) return false; D3DSURFACE_DESC surfaceDesc; pTexture->GetLevelDesc(0, &surfaceDesc); d_width = surfaceDesc.Width; d_height = surfaceDesc.Height; d_mask.resize(d_width * d_height); D3DLOCKED_RECT lockedRect; if (SUCCEEDED(pTexture->LockRect(0, &lockedRect, NULL, D3DLOCK_DISCARD))) { unsigned char* bits = (unsigned char*)lockedRect.pBits; for (int y = 0; y < d_height; ++y) { for (int x = 0; x < d_width; ++x) { bool solid = (bits[x * 4 + y * lockedRect.Pitch + 3] != 0); d_mask[x + y * d_width] = solid; if (!solid) d_solid = false; } } pTexture->UnlockRect(0); } return true; }
void DevState::blit(unsigned int x, unsigned int y, unsigned int w, unsigned int h) { // Blit is called often. Thus, we do not want to always log here. #ifdef EXTENDED_OVERLAY_DEBUGOUTPUT ods("D3D9: Blit %d %d %d %d", x, y, w, h); #endif if (! texTexture || !a_ucTexture) return; D3DLOCKED_RECT lr; if ((x == 0) && (y == 0) && (w == uiWidth) && (h == uiHeight)) { if (texTexture->LockRect(0, &lr, NULL, D3DLOCK_DISCARD) != D3D_OK) return; } else { RECT r; r.left = x; r.top = y; r.right = x + w; r.bottom = y + h; if (texTexture->LockRect(0, &lr, &r, 0) != D3D_OK) return; } for (unsigned int r=0;r < h;++r) { unsigned char *dptr = reinterpret_cast<unsigned char *>(lr.pBits) + r * lr.Pitch; unsigned char *sptr = a_ucTexture + 4 * ((y + r) * uiWidth + x); memcpy(dptr, sptr, w * 4); } texTexture->UnlockRect(0); }
//------------------------------------------------------------------------------------------------- sdMemoryTexture::sdMemoryTexture(LPDIRECT3DTEXTURE9 spD3DTexture) { NIASSERT(spD3DTexture); // 获取渲染设备 NiDX9Renderer* spRenderer = NiDX9Renderer::GetRenderer(); NIASSERT(spRenderer); // 提取格式信息 D3DSURFACE_DESC kLevelDesc; spD3DTexture->GetLevelDesc(0, &kLevelDesc); m_uiWidth = kLevelDesc.Width; m_uiHeight = kLevelDesc.Height; m_uiLevel = spD3DTexture->GetLevelCount(); m_eFormat = kLevelDesc.Format; // m_spD3DTexture = spD3DTexture; m_spD3DTexture->AddRef(); // 创建GB纹理对象 m_spTexture = spRenderer->CreateNiTextureFromD3DTexture(m_spD3DTexture); NIASSERT(m_spTexture); }
int RendererD3D::InitializeTextureFromBits(byte* pImageBits, int width, int height) { HRESULT result; LPDIRECT3DSURFACE9 surface=NULL; LPDIRECT3DTEXTURE9 texture = NULL; result = D3DXCreateTexture( m_pd3dDevice, width, height, D3DX_DEFAULT, 0, D3DFMT_R8G8B8,D3DPOOL_MANAGED, &texture); texture->GetSurfaceLevel(0, &surface); RECT rect; rect.top = 0; rect.left = 0; rect.bottom = height; rect.right = width; result = D3DXLoadSurfaceFromMemory(surface,NULL,NULL,pImageBits,D3DFMT_R8G8B8, width*3*sizeof(byte),NULL,&rect,D3DX_DEFAULT,0); surface->Release(); assert(result == D3D_OK); m_textureList.push_back(texture); return (m_textureList.size()-1); }
void DevState::blit(unsigned int x, unsigned int y, unsigned int w, unsigned int h) { ods("D3D9: Blit %d %d %d %d", x, y, w, h); if (! texTexture || !a_ucTexture) return; D3DLOCKED_RECT lr; if ((x == 0) && (y == 0) && (w == uiWidth) && (h == uiHeight)) { if (texTexture->LockRect(0, &lr, NULL, D3DLOCK_DISCARD) != D3D_OK) return; } else { RECT r; r.left = x; r.top = y; r.right = x + w; r.bottom = y + h; if (texTexture->LockRect(0, &lr, &r, 0) != D3D_OK) return; } for (unsigned int r=0;r < h;++r) { unsigned char *dptr = reinterpret_cast<unsigned char *>(lr.pBits) + r * lr.Pitch; unsigned char *sptr = a_ucTexture + 4 * ((y + r) * uiWidth + x); memcpy(dptr, sptr, w * 4); } texTexture->UnlockRect(0); }
static void d3d_unlock_region(ALLEGRO_BITMAP *bitmap) { ALLEGRO_BITMAP_D3D *d3d_bmp = (ALLEGRO_BITMAP_D3D *)bitmap; d3d_bmp->modified = true; if (bitmap->locked_region.format != 0 && bitmap->locked_region.format != bitmap->format) { if (!(bitmap->lock_flags & ALLEGRO_LOCK_READONLY)) { _al_convert_bitmap_data( bitmap->locked_region.data, bitmap->locked_region.format, bitmap->locked_region.pitch, d3d_bmp->locked_rect.pBits, bitmap->format, d3d_bmp->locked_rect.Pitch, 0, 0, 0, 0, bitmap->lock_w, bitmap->lock_h); } al_free(bitmap->locked_region.data); } if (d3d_bmp->is_backbuffer) { ALLEGRO_DISPLAY_D3D *d3d_disp = (ALLEGRO_DISPLAY_D3D *)bitmap->display; d3d_disp->render_target->UnlockRect(); } else { LPDIRECT3DTEXTURE9 texture; if (_al_d3d_render_to_texture_supported()) texture = d3d_bmp->system_texture; else texture = d3d_bmp->video_texture; texture->UnlockRect(0); if (bitmap->lock_flags & ALLEGRO_LOCK_READONLY) return; d3d_do_upload(d3d_bmp, bitmap->lock_x, bitmap->lock_y, bitmap->lock_w, bitmap->lock_h, false); } }
lpta::LptaTexture::DATA LptaD3DTextureManager::GenerateDefaultData(void) { LPDIRECT3DTEXTURE9 textureData = nullptr; D3DLOCKED_RECT d3dLockedRect; HRESULT result = d3ddev->CreateTexture( DEFAULT_TEXTURE_WIDTH, DEFAULT_TEXTURE_HEIGHT, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &textureData, nullptr ); if (FAILED(result)) { throw TextureD3DFailure("could not obtain texture object for default"); } result = textureData->LockRect(0, &d3dLockedRect, nullptr, 0); if (FAILED(result)) { textureData->Release(); throw TextureD3DFailure("failed to lock rectangle to set default texture color"); } unsigned long *rawData = (unsigned long *)d3dLockedRect.pBits; for (unsigned long *pixel = rawData; pixel < rawData + (DEFAULT_TEXTURE_WIDTH * DEFAULT_TEXTURE_HEIGHT); ++pixel) { *pixel = DEFAULT_TEXTURE_COLOR; } textureData->UnlockRect(0); return (lpta::LptaTexture::DATA)textureData; }
/**----------------------------------------------------------------------------- * 초기화 객체들 소거 *------------------------------------------------------------------------------ */ VOID Cleanup() { if ( g_pTexHeight != NULL ) { g_pTexHeight->Release(); } if ( g_pTexDiffuse != NULL ) { g_pTexDiffuse->Release(); } if ( g_pIB != NULL ) { g_pIB->Release(); } if ( g_pVB != NULL ) { g_pVB->Release(); } if ( g_pd3dDevice != NULL ) { g_pd3dDevice->Release(); } if ( g_pD3D != NULL ) { g_pD3D->Release(); } delete[] g_pvHeightMap; }
D3DFORMAT CDxtexDoc::GetFormat(LPDIRECT3DBASETEXTURE9 ptex) { LPDIRECT3DTEXTURE9 pmiptex = NULL; LPDIRECT3DCUBETEXTURE9 pcubetex = NULL; LPDIRECT3DVOLUMETEXTURE9 pvoltex = NULL; D3DFORMAT fmt = D3DFMT_UNKNOWN; if (IsVolumeMap()) pvoltex = (LPDIRECT3DVOLUMETEXTURE9)ptex; else if (IsCubeMap()) pcubetex = (LPDIRECT3DCUBETEXTURE9)ptex; else pmiptex = (LPDIRECT3DTEXTURE9)ptex; if (pvoltex != NULL) { D3DVOLUME_DESC vd; pvoltex->GetLevelDesc(0, &vd); fmt = vd.Format; } else if (pcubetex != NULL) { D3DSURFACE_DESC sd; pcubetex->GetLevelDesc(0, &sd); fmt = sd.Format; } else if( pmiptex != NULL ) { D3DSURFACE_DESC sd; pmiptex->GetLevelDesc(0, &sd); fmt = sd.Format; } return fmt; }
int l_Image_Load( lua_State* L ) { D3DXIMAGE_INFO imgInfo; const char* fileName = lua_tostring( L, 1 ); bool dxtCompression = false; D3DFORMAT d3dfmt = D3DFMT_UNKNOWN; //check for dds format { if( _strcmpi( "dds", fileName + strlen( fileName ) - 3 ) == 0 ) { DDSHEAD header; FILE* f; if(fopen_s( &f, fileName, "rb" ) == 0) { if( fread( &header, sizeof(header), 1, f ) == 1 ) { if( strncmp( (const char*)header.Signature, "DDS ", 4 ) == 0 && ( header.FourCC == D3DFMT_DXT1 || header.FourCC == D3DFMT_DXT3 || header.FourCC == D3DFMT_DXT5 ) ) { d3dfmt = D3DFMT_A8R8G8B8; } } fclose(f); } } } LPDIRECT3DTEXTURE9 texture; HRESULT hr = D3DXCreateTextureFromFileEx( g_pd3dDevice, fileName, D3DX_DEFAULT_NONPOW2, D3DX_DEFAULT_NONPOW2, D3DX_FROM_FILE, 0, d3dfmt, D3DPOOL_SCRATCH, D3DX_DEFAULT, D3DX_DEFAULT, 0, &imgInfo, 0, &texture ); if( FAILED( hr ) ) { return 0; } ImageData* imgData = createImage(); imgData->width = imgInfo.Width; imgData->height = imgInfo.Height; imgData->format = getFormatByD3D( imgInfo.Format ); imgData->imgData = malloc( imgData->width * imgData->height * imgData->format->bytesPerPixel ); D3DLOCKED_RECT rect; texture->LockRect(0, &rect, 0, 0 ); memcpy( imgData->imgData, rect.pBits, imgData->width * imgData->height * imgData->format->bytesPerPixel ); texture->UnlockRect( 0 ); texture->Release(); //lua_pushlightuserdata( L, imgData ); ImageData** luaData = lua_pushimage( L ); *luaData = imgData; return 1; }
static bool convert_compressed(LPDIRECT3DTEXTURE9 dest, LPDIRECT3DTEXTURE9 src, int x, int y, int width, int height) { #ifdef ALLEGRO_CFG_D3DX9 bool ok = true; LPDIRECT3DSURFACE9 dest_texture_surface = NULL; LPDIRECT3DSURFACE9 src_texture_surface = NULL; if (dest->GetSurfaceLevel(0, &dest_texture_surface) != D3D_OK) { ALLEGRO_ERROR("convert_compressed: GetSurfaceLevel failed on dest.\n"); ok = false; } if (ok && src->GetSurfaceLevel(0, &src_texture_surface) != D3D_OK) { ALLEGRO_ERROR("convert_compressed: GetSurfaceLevel failed on src.\n"); ok = false; } RECT rect; rect.left = x; rect.top = y; rect.right = x + width; rect.bottom = y + height; if (ok && _al_imp_D3DXLoadSurfaceFromSurface && _al_imp_D3DXLoadSurfaceFromSurface(dest_texture_surface, NULL, &rect, src_texture_surface, NULL, &rect, D3DX_FILTER_NONE, 0) != D3D_OK) { ALLEGRO_ERROR("convert_compressed: D3DXLoadSurfaceFromSurface failed.\n"); ok = false; } int i; if (src_texture_surface) { if ((i = src_texture_surface->Release()) != 0) { ALLEGRO_DEBUG("convert_compressed (src) ref count == %d\n", i); } } if (dest_texture_surface) { if ((i = dest_texture_surface->Release()) != 0) { // This can be non-zero ALLEGRO_DEBUG("convert_compressed (dest) ref count == %d\n", i); } } return ok; #else (void)dest; (void)src; (void)x; (void)y; (void)width; (void)height; return false; #endif }
/* Copy bitmap->memory to texture memory */ static void d3d_sync_bitmap_texture(ALLEGRO_BITMAP *bitmap, int x, int y, int width, int height) { D3DLOCKED_RECT locked_rect; RECT rect; ALLEGRO_BITMAP_D3D *d3d_bmp = (ALLEGRO_BITMAP_D3D *)bitmap; LPDIRECT3DTEXTURE9 texture; rect.left = x; rect.top = y; rect.right = x + width; rect.bottom = y + height; if (_al_d3d_render_to_texture_supported()) texture = d3d_bmp->system_texture; else texture = d3d_bmp->video_texture; if (texture->LockRect(0, &locked_rect, &rect, 0) == D3D_OK) { _al_convert_bitmap_data(bitmap->memory, bitmap->format, bitmap->w*al_get_pixel_size(bitmap->format), locked_rect.pBits, bitmap->format, locked_rect.Pitch, x, y, 0, 0, width, height); /* Copy an extra row and column so the texture ends nicely */ if (rect.bottom > bitmap->h) { _al_convert_bitmap_data( bitmap->memory, bitmap->format, bitmap->w*al_get_pixel_size(bitmap->format), locked_rect.pBits, bitmap->format, locked_rect.Pitch, 0, bitmap->h-1, 0, height, width, 1); } if (rect.right > bitmap->w) { _al_convert_bitmap_data( bitmap->memory, bitmap->format, bitmap->w*al_get_pixel_size(bitmap->format), locked_rect.pBits, bitmap->format, locked_rect.Pitch, bitmap->w-1, 0, width, 0, 1, height); } if (rect.bottom > bitmap->h && rect.right > bitmap->w) { _al_convert_bitmap_data( bitmap->memory, bitmap->format, bitmap->w*al_get_pixel_size(bitmap->format), locked_rect.pBits, bitmap->format, locked_rect.Pitch, bitmap->w-1, bitmap->h-1, width, height, 1, 1); } texture->UnlockRect(0); } else { ALLEGRO_ERROR("d3d_sync_bitmap_texture: Couldn't lock texture to upload.\n"); } }
void Game_End() { if (imgShip) imgShip->Release(); if (imgAsteroid) imgAsteroid->Release(); DirectInput_Shutdown(); Direct3D_Shutdown(); }
void freeTexture() { if (hmap_o) delete[] hmap_o; hmap_o = NULL; if (dmap ) delete[] dmap ; dmap = NULL; if (tnrm) tnrm->Release(); tnrm = NULL; if (thgt) thgt->Release(); thgt = NULL; if (tcol) tcol->Release(); tcol = NULL; }
LPDIRECT3DTEXTURE9 D3D9::CreateTexture(int texWidth, int texHeight, D3DCOLOR color) { LPDIRECT3DTEXTURE9 pTexture; HRESULT hr = D3DXCreateTexture(d3ddevice_, texWidth, texHeight, 0, 0, D3DFMT_A8R8G8B8, // 4 bytes for a pixel D3DPOOL_MANAGED, &pTexture); if (FAILED(hr)) { MessageBox(NULL, L"Create texture failed", L"Error", 0); } // Lock the texture and fill in color D3DLOCKED_RECT lockedRect; hr = pTexture->LockRect(0, &lockedRect, NULL, 0); if (FAILED(hr)) { MessageBox(NULL, L"Lock texture failed!", L"Error", 0); } DWORD sideColor = 0xff000000; // the side line color int side_width = 10; // Calculate number of rows in the locked Rect int rowCount = (texWidth * texHeight * 4 ) / lockedRect.Pitch; for (int i = 0; i < texWidth; ++i) { for (int j = 0; j < texHeight; ++j) { int index = i * rowCount + j; int* pData = (int*)lockedRect.pBits; if (i <= side_width || i >= texWidth - side_width || j <= side_width || j >= texHeight - side_width) { memcpy(&pData[index], &sideColor, 4); } else { memcpy(&pData[index], &color, 4); } } } pTexture->UnlockRect(0); return pTexture; }
void Cleanup() { // 폰트를 release 한다. if (gpFont) { gpFont->Release(); gpFont = NULL; } // 모델을 release 한다. if (gpSphere) { gpSphere->Release(); gpSphere = NULL; } // 쉐이더를 release 한다. if (gpNormalMappingShader) { gpNormalMappingShader->Release(); gpNormalMappingShader = NULL; } // 텍스처를 release 한다. if (gpStoneDM) { gpStoneDM->Release(); gpStoneDM = NULL; } if (gpStoneSM) { gpStoneSM->Release(); gpStoneSM = NULL; } if (gpStoneNM) { gpStoneNM->Release(); gpStoneNM = NULL; } // D3D를 release 한다. if (gpD3DDevice) { gpD3DDevice->Release(); gpD3DDevice = NULL; } if (gpD3D) { gpD3D->Release(); gpD3D = NULL; } }
//------------------------------------------------------------- // Name: InitDeviceObjects() // Desc: 디바이스가 생성된후의 초기화 // 프레임버퍼 포맷과 디바이스 종류가 변한뒤에 호출 // 여기서 확보한 메모리는 DeleteDeviceObjects()에서 해제 //------------------------------------------------------------- HRESULT CMyD3DApplication::InitDeviceObjects() { HRESULT hr; LPDIRECT3DTEXTURE9 pHeightTexture; D3DSURFACE_DESC desc; // 법선맵 생성 D3DUtil_CreateTexture( m_pd3dDevice,// 높이맵 읽기 _T("height.bmp"), &pHeightTexture ); pHeightTexture->GetLevelDesc(0,&desc);// 텍스처 정보 얻기 D3DXCreateTexture(m_pd3dDevice, desc.Width, desc.Height, 0, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &m_pNormalMap);// 텍스처 생성 D3DXComputeNormalMap(m_pNormalMap, // 법선맵 생성 pHeightTexture, NULL, 0, D3DX_CHANNEL_RED, 1.0f); SAFE_RELEASE( pHeightTexture ); // 필요없어진 리소스 해제 // 정점선언 오브젝트 생성 if( FAILED( hr = m_pd3dDevice->CreateVertexDeclaration( decl, &m_pDecl ))) return DXTRACE_ERR ("CreateVertexDeclaration", hr); // 주전자 읽기 if(FAILED(hr=m_pMesh ->Create( m_pd3dDevice, _T("t-pot.x")))) return DXTRACE_ERR( "Load Object", hr ); // 지형 읽기 if(FAILED(hr=m_pMeshBg->Create( m_pd3dDevice, _T("map.x")))) return DXTRACE_ERR( "Load Ground", hr ); // 셰이더 읽기 LPD3DXBUFFER pErr=NULL; if( FAILED( hr = D3DXCreateEffectFromFile( m_pd3dDevice, "hlsl.fx", NULL, NULL, 0 , NULL, &m_pEffect, &pErr ))){ // 셰이더 읽기 실패 MessageBox( NULL, (LPCTSTR)pErr->GetBufferPointer() , "ERROR", MB_OK); }else{ m_hTechnique = m_pEffect->GetTechniqueByName( "TShader" ); m_hmWVP = m_pEffect->GetParameterByName( NULL, "mWVP" ); m_hvLightDir = m_pEffect->GetParameterByName( NULL, "vLightDir" ); m_hvColor = m_pEffect->GetParameterByName( NULL, "vColor" ); m_hvEyePos = m_pEffect->GetParameterByName( NULL, "vEyePos" ); m_htDecaleTex= m_pEffect->GetParameterByName( NULL, "DecaleTex" ); m_htNormalMap= m_pEffect->GetParameterByName( NULL, "NormalMap" ); } SAFE_RELEASE(pErr); // 폰트 m_pFont->InitDeviceObjects( m_pd3dDevice ); return S_OK; }
// シーンの描画 void DrawScene(void* data) { #if 1 struct vertex { FLOAT x, y, z, rhw; FLOAT tu, tv; }; vertex v[4] = { {0, 0, 0.0f, 1.0f, 0.0f, 0.0f}, {SCREEN_WIDTH, 0, 0.0f, 1.0f, 1.0f, 0.0f}, {0, SCREEN_HEIGHT, 0.0f, 1.0f, 0.0f, 1.0f}, {SCREEN_WIDTH, SCREEN_HEIGHT, 0.0f, 1.0f, 1.0f, 1.0f}, }; D3DLOCKED_RECT pRect; DWORD time,lasttime; lasttime = timeGetTime(); time = lasttime; while(true) { time = timeGetTime(); if(time-lasttime >= 1000*10) { g_tex->LockRect(0, &pRect, NULL, D3DLOCK_DISCARD); for(int y = 0; y<SCREEN_HEIGHT; y++) { for(int x = 0; x<SCREEN_WIDTH; x++) { DWORD color = 0x00ff00ff; color = (edupt::to_int(image[y*SCREEN_WIDTH+x].x_)<<16) + (edupt::to_int(image[y*SCREEN_WIDTH+x].y_)<<8) + edupt::to_int(image[y*SCREEN_WIDTH+x].z_); memcpy((BYTE*)pRect.pBits+pRect.Pitch*y + 4*x, &color, sizeof(DWORD)); } } g_tex->UnlockRect(0); lasttime = time; } g_pD3DDev->BeginScene(); g_pD3DDev->Clear(0,NULL,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,D3DCOLOR_RGBA(128,128,128,0),1.0f,0); g_pD3DDev->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1); g_pD3DDev->SetTexture(0, g_tex); g_pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, v, sizeof(vertex)); g_pD3DDev->EndScene(); g_pD3DDev->Present(NULL, NULL, NULL, NULL); } #endif }
void SetD3DResourcePrivateData(LPDIRECT3DRESOURCE9 res, const char* FName) { #if R3D_SET_DEBUG_D3D_NAMES DWORD sz = strlen(FName); res->SetPrivateData(WKPDID_D3DDebugObjectName, FName, sz, 0); void* p = 0; res->QueryInterface(IID_IDirect3DTexture9, &p); if(p) { LPDIRECT3DTEXTURE9 t = (LPDIRECT3DTEXTURE9)p; int mipsCount = t->GetLevelCount(); for (int i = 0; i < mipsCount; ++i) { LPDIRECT3DSURFACE9 surf; t->GetSurfaceLevel(i, &surf); surf->SetPrivateData(WKPDID_D3DDebugObjectName, FName, sz, 0); surf->Release(); } t->Release(); return; } p = 0; res->QueryInterface(IID_IDirect3DCubeTexture9, &p); if(p) { LPDIRECT3DCUBETEXTURE9 t = (LPDIRECT3DCUBETEXTURE9)p; int mipsCount = t->GetLevelCount(); for (int i = 0; i < mipsCount; ++i) { for (int j = D3DCUBEMAP_FACE_POSITIVE_X; j <= D3DCUBEMAP_FACE_NEGATIVE_Z; ++j) { LPDIRECT3DSURFACE9 surf; t->GetCubeMapSurface((D3DCUBEMAP_FACES)j, i, &surf); surf->SetPrivateData(WKPDID_D3DDebugObjectName, FName, sz, 0); surf->Release(); } } t->Release(); return; } #endif }
bool Atlas::createTexure_( Logger & _logger, const MAGIC_CHANGE_ATLAS & c, LPDIRECT3DTEXTURE9 * _texture ) { uint32_t image_width; uint32_t image_height; unsigned char * pixels = nullptr; if( c.data == nullptr ) { pixels = imageLoadFromFile( c.file, image_width, image_height ); } else { pixels = imageLoadFromMemory( c.data, c.length, image_width, image_height ); } unsigned char * correct_pixels = pixels; UINT texture_width = getTexturePOW2( image_width ); UINT texture_height = getTexturePOW2( image_height ); LPDIRECT3DTEXTURE9 texture = NULL; if( m_pDevice->CreateTexture( texture_width, texture_height, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, NULL ) != D3D_OK ) { return false; } D3DLOCKED_RECT lockedRect; DXCALL texture->LockRect( 0, &lockedRect, NULL, D3DLOCK_DISCARD ); if( lockedRect.pBits == NULL || lockedRect.Pitch == 0 ) { return false; } for( size_t i = 0; i != image_height; ++i ) { unsigned char * image = correct_pixels + i * image_width * 4; unsigned char * bits = static_cast<unsigned char *>(lockedRect.pBits) + lockedRect.Pitch * i; std::copy( image, image + image_width * 4, bits ); } DXCALL texture->UnlockRect( 0 ); imageFree( pixels ); *_texture = texture; return true; }
VOID Cleanup() { if ( g_pMeshMaterials != NULL ) delete[] g_pMeshMaterials; if ( g_pMeshTextures ) { for ( DWORD i = 0; i < g_dwNumMaterials; ++i ) { if ( g_pMeshTextures[i] ) { g_pMeshTextures[i]->Release(); } } } if ( g_pMesh ) { g_pMesh->Release(); } if ( g_pTexture1 != NULL ) { g_pTexture1->Release(); } if ( g_pTexture2 != NULL ) { g_pTexture2->Release(); } if ( g_pVB1 != NULL ) { g_pVB1->Release(); } if ( g_pVB2 != NULL ) { g_pVB2->Release(); } if ( g_pd3dDevice != NULL ) { g_pd3dDevice->Release(); } if ( g_pD3D != NULL ) { g_pD3D->Release(); } }
/**----------------------------------------------------------------------------- * 정점버퍼를 생성하고 정점값을 채워넣는다. * HeightMap정보도 여기서 초기화한다. *------------------------------------------------------------------------------ */ HRESULT InitVB() { D3DSURFACE_DESC ddsd; D3DLOCKED_RECT d3drc; g_pTexHeight->GetLevelDesc( 0, &ddsd ); // 텍스처의 정보 g_cxHeight = ddsd.Width; // 텍스처의 가로크기 g_czHeight = ddsd.Height; // 텍스처의 세로크기 g_pLog->Log( "Texture Size:[%d,%d]", g_cxHeight, g_czHeight ); g_pvHeightMap = new D3DXVECTOR3[g_cxHeight * g_czHeight]; // 높이맵배열 생성 if ( FAILED( g_pd3dDevice->CreateVertexBuffer( ddsd.Width*ddsd.Height*sizeof( CUSTOMVERTEX ), 0, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &g_pVB, NULL ) ) ) { return E_FAIL; } // 텍스처 메모리 락! g_pTexHeight->LockRect( 0, &d3drc, NULL, D3DLOCK_READONLY ); VOID* pVertices; // 정점버퍼 락! if ( FAILED( g_pVB->Lock( 0, g_cxHeight*g_czHeight*sizeof( CUSTOMVERTEX ), (void**)&pVertices, 0 ) ) ) { return E_FAIL; } CUSTOMVERTEX v; CUSTOMVERTEX* pV = (CUSTOMVERTEX*)pVertices; for ( DWORD z = 0; z < g_czHeight; z++ ) { for ( DWORD x = 0; x < g_cxHeight; x++ ) { v.p.x = (float)x - g_cxHeight / 2.0f; // 정점의 x좌표(메시를 원점에 정렬) v.p.z = -( (float)z - g_czHeight / 2.0f ); // 정점의 z좌표(메시를 원점에 정렬), z축이 모니터안쪽이므로 -를 곱한다. v.p.y = ( (float)( *( (LPDWORD)d3drc.pBits + x + z*( d3drc.Pitch / 4 ) ) & 0x000000ff ) ) / 10.0f; /// DWORD이므로 pitch/4 v.n.x = v.p.x; v.n.y = v.p.y; v.n.z = v.p.z; D3DXVec3Normalize( &v.n, &v.n ); v.t.x = (float)x / ( g_cxHeight - 1 ); v.t.y = (float)z / ( g_czHeight - 1 ); *pV++ = v; // 정점버퍼에 정점 저장 g_pvHeightMap[z * g_cxHeight + x] = v.p; // 높이맵에 정점 저장 } } g_pVB->Unlock(); g_pTexHeight->UnlockRect( 0 ); return S_OK; }
HRESULT VertexObject::CreateTextureFromSurface(LPDIRECT3DSURFACE9 pSurface, RECT* pSrcRect, RECT* pDestRect, LPDIRECT3DTEXTURE9* ppTexture) { int width, height; RECT Src; D3DSURFACE_DESC surfDesc; pSurface->GetDesc(&surfDesc); if( !pSrcRect ) { width = surfDesc.Width; height = surfDesc.Height; Src.left = Src.top = 0; Src.right = width; Src.bottom = height; } else { width = pSrcRect->right - pSrcRect->left; // + 1; height = pSrcRect->bottom - pSrcRect->top; // + 1; Src = *pSrcRect; } D3DXCreateTexture(DDevice, width, height, 1, 0, surfDesc.Format, D3DPOOL_DEFAULT, ppTexture) ; // Retrieve the surface image of the texture. LPDIRECT3DSURFACE9 pTexSurface; LPDIRECT3DTEXTURE9 pTexture = *ppTexture; pTexture->GetLevelDesc(0, &surfDesc); pTexture->GetSurfaceLevel(0, &pTexSurface); // Create a clean surface to clear the texture with. LPDIRECT3DSURFACE9 pCleanSurface; D3DLOCKED_RECT lockRect; DDevice->CreateOffscreenPlainSurface( surfDesc.Width, surfDesc.Height, surfDesc.Format, D3DPOOL_DEFAULT, &pCleanSurface, NULL); pCleanSurface->LockRect(&lockRect, NULL, 0) ; memset((BYTE*)lockRect.pBits, 0, surfDesc.Height * lockRect.Pitch); pCleanSurface->UnlockRect() ; DDevice->UpdateSurface(pCleanSurface, NULL, pTexSurface, NULL); pCleanSurface->Release(); // Copy the image to the texture. POINT destPoint = { 0, 0 }; DDevice->UpdateSurface(pSurface, &Src, pTexSurface, &destPoint); pTexSurface->Release(); return S_OK; }
/* CDirect3D::BlankTexture clears a texture (fills it with zeroes) IN: texture - the texture to be blanked ----- returns true if successful, false otherwise */ bool CDirect3D::BlankTexture(LPDIRECT3DTEXTURE9 texture) { D3DLOCKED_RECT lr; HRESULT hr; if(FAILED(hr = texture->LockRect(0, &lr, NULL, 0))) { DXTRACE_ERR_MSGBOX(TEXT("Unable to lock texture"), hr); return false; } else { memset(lr.pBits, 0, lr.Pitch * quadTextureSize); texture->UnlockRect(0); return true; } }
int surface_create(int width, int height, bool depthbuffer, bool, bool) { LPDIRECT3DTEXTURE9 texture = NULL; d3ddev->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL); enigma::Surface* surface = new enigma::Surface(); enigma::DX9Texture* gmTexture = new enigma::DX9Texture(texture); const int texid = enigma::textures.size(); enigma::textures.push_back(gmTexture); //d3ddev->CreateRenderTarget(width, height, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_2_SAMPLES, 2, false, &surface->surf, NULL); texture->GetSurfaceLevel(0,&surface->surf); surface->texture = texid; surface->width = width; surface->height = height; enigma::surfaces.push_back(surface); return enigma::surfaces.size() - 1; }
void AmjuGLDX9::SetTexture( AmjuGL::TextureHandle* th, AmjuGL::TextureType tt, AmjuGL::TextureDepth td, int width, int height, uint8* data) { AMJU_CALL_STACK; HRESULT res = D3DXCreateTexture( dd, //LPDIRECT3DDEVICE9 pDevice, width, //UINT Width, height, //UINT Height, 0, // Mip Levels: 0 means create all D3DUSAGE_DYNAMIC, //DWORD Usage, (td == AmjuGL::AMJU_RGB ? D3DFMT_R8G8B8 : D3DFMT_A8R8G8B8), //D3DFORMAT Format, D3DPOOL_DEFAULT, // Pool, reinterpret_cast<LPDIRECT3DTEXTURE9*>(th) //LPDIRECT3DTEXTURE9 * ppTexture ); LPDIRECT3DTEXTURE9 pTex = reinterpret_cast<LPDIRECT3DTEXTURE9>(*th); D3DLOCKED_RECT lockedRect; pTex->LockRect(0, &lockedRect, NULL, 0); switch (td) { case AmjuGL::AMJU_RGB: CopyRGBTexture((uint8*)lockedRect.pBits, lockedRect.Pitch, data, width, height); break; case AmjuGL::AMJU_RGBA: CopyRGBATexture((uint8*)lockedRect.pBits, lockedRect.Pitch, data, width, height); break; } pTex->UnlockRect(0); // TODO Create data for each mipmap level. // NB We want the same functionality as screenshot shrinking. IDirect3DSurface9 * pSurfaceLevel; for (unsigned int iLevel = 0; iLevel < pTex->GetLevelCount(); iLevel++) { pTex->GetSurfaceLevel(iLevel, &pSurfaceLevel); // TODO Write this mip map pSurfaceLevel->Release(); } }
VOID Cleanup() { if (NULL != g_pMeshMaterials0) { delete [] g_pMeshMaterials0; } if (g_pMeshTextures0) { for (DWORD i = 0; i < g_dwNumMaterials; ++i) { if (g_pMeshTextures0[i]) { g_pMeshTextures0[i]->Release(); } } delete [] g_pMeshTextures0; } if (NULL != g_pMesh0) { g_pMesh0->Release(); } if (NULL != g_pTexture0) { g_pTexture0->Release(); } if (NULL != g_pTexture1) { g_pTexture1->Release(); } if (NULL != g_pVertexBuffer0) { g_pVertexBuffer0->Release(); } if (NULL != g_pVertexBuffer1) { g_pVertexBuffer1->Release(); } if (NULL != g_pD3DDevice) { g_pD3DDevice->Release(); } if (NULL != g_pD3D) { g_pD3D->Release(); } }
// returns the index this texture is in class int CNumberToSprite::AddTexture(IDirect3DDevice9* pd3dDevice, LPCWSTR numberFileName) { HRESULT hr; LPDIRECT3DTEXTURE9 pTex; V( D3DXCreateTextureFromFile(pd3dDevice, numberFileName, &pTex) ); // get length D3DSURFACE_DESC desc; V( pTex->GetLevelDesc(0, &desc) ); m_vSpacing.push_back((float)desc.Width / m_nSYMBOLS); m_vpTex.push_back(pTex); return (int)(m_vpTex.size() - 1); }
virtual const char* lock_framebuffer( void *& buffer, unsigned & pitch ) { if ( retry_count && !restore_objects() ) return "Lock failed"; lptex->GetLevelDesc(0, &d3dsd); if ( lptex->GetSurfaceLevel(0, &lpsurface) != D3D_OK ) return "Lock failed"; if ( lpsurface->LockRect(&d3dlr, 0, flags.lock) != D3D_OK ) return "Lock failed"; buffer = d3dlr.pBits; pitch = d3dlr.Pitch; return buffer != 0 ? 0 : "Lock failed"; }