void DX9VB::create(int sizeInBytes, int stride, HDResourceMgr *pMgr) { ASSERT(sizeInBytes > 0); ASSERT(stride > 0); ASSERT(pMgr); destroy(); // DX9ResourceMgr* pDX9Mgr = (DX9ResourceMgr*)pMgr; IDirect3DDevice9* pDev = pDX9Mgr->getDX9Device(); HRESULT hr; hr = pDev->CreateVertexBuffer(sizeInBytes, D3DUSAGE_WRITEONLY, // usage 0, // FVF D3DPOOL_MANAGED, &m_pVB, NULL); if(FAILED(hr)) { LOG("vertex buffer create failed, size = %d\r\n", sizeInBytes); throw HDAPIException("vertex buffer create failed."); } // m_sizeInBytes = sizeInBytes; m_stride = stride; }
IDirect3DVertexBuffer9* MythRenderD3D9::CreateVertexBuffer(IDirect3DTexture9* texture) { D3D9Locker locker(this); IDirect3DDevice9* dev = locker.Acquire(); if (!dev) return NULL; if (texture && !m_textures.contains(texture)) return false; IDirect3DVertexBuffer9* temp_vbuf = NULL; HRESULT hr = dev->CreateVertexBuffer( sizeof(TEXTUREVERTEX)*4, D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, D3DFVF_TEXTUREVERTEX, D3DPOOL_DEFAULT, &temp_vbuf, NULL); if (FAILED(hr)) { VERBOSE(VB_IMPORTANT, D3DERR + "Failed to create vertex buffer"); return false; } m_vertexbuffers[temp_vbuf] = MythD3DVertexBuffer(texture); return temp_vbuf; }
bool VertexBuffer::Create() { Release(); if (!vertexCount_ || !elementMask_) return true; if (graphics_) { if (graphics_->IsDeviceLost()) { URHO3D_LOGWARNING("Vertex buffer creation while device is lost"); return true; } IDirect3DDevice9* device = graphics_->GetImpl()->GetDevice(); HRESULT hr = device->CreateVertexBuffer( vertexCount_ * vertexSize_, usage_, 0, (D3DPOOL)pool_, (IDirect3DVertexBuffer9**)&object_, 0); if (FAILED(hr)) { URHO3D_SAFE_RELEASE(object_); URHO3D_LOGD3DERROR("Could not create vertex buffer", hr); return false; } } return true; }
bool VertexBuffer::Create() { Release(); if (!vertexCount_ || !elementMask_) return true; if (graphics_) { if (graphics_->IsDeviceLost()) { LOGWARNING("Vertex buffer creation while device is lost"); return true; } IDirect3DDevice9* device = graphics_->GetImpl()->GetDevice(); if (!device || FAILED(device->CreateVertexBuffer( vertexCount_ * vertexSize_, usage_, 0, (D3DPOOL)pool_, (IDirect3DVertexBuffer9**)&object_, 0))) { LOGERROR("Could not create vertex buffer"); return false; } } return true; }
bool CSprite::_CreateBuffer() { const int iVertexCount = 6; const UINT bufferSize = sizeof(SFaceVertex) * iVertexCount; HRESULT hr; CGraphicsManager *pGraphicsManager = CGraphicsManager::GetInstance(); IDirect3DDevice9 *pDevice = pGraphicsManager->GetDevice(); hr = pDevice->CreateVertexBuffer(bufferSize, 0, SFaceVertex::_fvf, D3DPOOL_DEFAULT, &m_pVertexBuffer, NULL); if(FAILED(hr)) { LogErrorHr("Failed to create vertex buffer for image rectangle", hr); return false; } SFaceVertex *pVertices = NULL; hr = m_pVertexBuffer->Lock(0, bufferSize, (void**)&pVertices, 0); if(FAILED(hr)) { LogErrorHr("Failed to lock image rectangle vertex buffer", hr); return false; } _FillRectVertices(pVertices); hr = m_pVertexBuffer->Unlock(); if(FAILED(hr)) { LogErrorHr("Failed to unlock image rectangle vertex buffer", hr); return false; } return true; }
bool GPUContextDX9::initialize() { _window = DX9Window::create(); if( _window == NULL ) { DX9WARN << "Could not create offscreen window."; return false; } HWND windowHandle = _window->getWindowHandle(); _direct3D = Direct3DCreate9( D3D_SDK_VERSION ); if( _direct3D == NULL ) { DX9WARN << "Could not create Direct3D interface."; return false; } D3DPRESENT_PARAMETERS deviceDesc; ZeroMemory( &deviceDesc, sizeof(deviceDesc) ); deviceDesc.Windowed = TRUE; deviceDesc.SwapEffect = D3DSWAPEFFECT_DISCARD; deviceDesc.BackBufferFormat = D3DFMT_UNKNOWN; deviceDesc.EnableAutoDepthStencil = FALSE; deviceDesc.AutoDepthStencilFormat = D3DFMT_D24S8; HRESULT result = _direct3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, windowHandle, D3DCREATE_HARDWARE_VERTEXPROCESSING, &deviceDesc, &_device ); if( FAILED(result) ) { DX9WARN << "Could not create Direct3D device."; return false; } // create vertex buffer static const int kMaxVertexCount = 64; result = _device->CreateVertexBuffer( kMaxVertexCount*sizeof(DX9Vertex), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &_vertexBuffer, NULL ); DX9AssertResult( result, "CreateVertexBuffer failed" ); result = _device->CreateVertexDeclaration( kDX9VertexElements, &_vertexDecl ); DX9AssertResult( result, "CreateVertexDeclaration failed" ); // TIM: set up initial state result = _device->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE ); GPUAssert( !FAILED(result), "SetRenderState failed" ); _passthroughVertexShader = createVertexShader( kPassthroughVertexShaderSource ); _passthroughPixelShader = createPixelShader( kPassthroughPixelShaderSource ); for( size_t i = 0; i < kMaximumOutputCount; i++ ) _boundOutputs[i] = NULL; for( size_t t = 0; t < kMaximumSamplerCount; t++ ) _boundTextures[t] = NULL; return true; }
gl::Error Blit9::initialize() { if (mGeometryLoaded) { return gl::Error(GL_NO_ERROR); } static const float quad[] = { -1, -1, -1, 1, 1, -1, 1, 1 }; IDirect3DDevice9 *device = mRenderer->getDevice(); HRESULT result = device->CreateVertexBuffer(sizeof(quad), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &mQuadVertexBuffer, NULL); if (FAILED(result)) { ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY); return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal blit vertex shader, result: 0x%X.", result); } void *lockPtr = NULL; result = mQuadVertexBuffer->Lock(0, 0, &lockPtr, 0); if (FAILED(result) || lockPtr == NULL) { ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY); SafeRelease(mQuadVertexBuffer); return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal blit vertex shader, result: 0x%X.", result); } memcpy(lockPtr, quad, sizeof(quad)); mQuadVertexBuffer->Unlock(); static const D3DVERTEXELEMENT9 elements[] = { { 0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, D3DDECL_END() }; result = device->CreateVertexDeclaration(elements, &mQuadVertexDeclaration); if (FAILED(result)) { ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY); SafeRelease(mQuadVertexBuffer); return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal blit vertex declaration, result: 0x%X.", result); } mGeometryLoaded = true; return gl::Error(GL_NO_ERROR); }
//---------------------------------------------------------------------------- PdrVertexBuffer::PdrVertexBuffer (Renderer* renderer, const VertexBuffer* vbuffer) { IDirect3DDevice9* device = renderer->mData->mDevice; UINT numBytes = (UINT)vbuffer->GetNumBytes(); DWORD usage = gDX9BufferUsage[vbuffer->GetUsage()]; HRESULT hr = device->CreateVertexBuffer(numBytes, usage, 0, D3DPOOL_DEFAULT, &mBuffer, 0); WM5_UNUSED(hr); assertion(hr == D3D_OK, "Failed to create vertex buffer: %s\n", DXGetErrorString(hr)); void* data = Lock(Buffer::BL_WRITE_ONLY); memcpy(data, vbuffer->GetData(), vbuffer->GetNumBytes()); Unlock(); }
void Blit::initGeometry() { static const float quad[] = { -1, -1, -1, 1, 1, -1, 1, 1 }; IDirect3DDevice9 *device = getDevice(); HRESULT result = device->CreateVertexBuffer(sizeof(quad), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &mQuadVertexBuffer, NULL); if (FAILED(result)) { ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY); return error(GL_OUT_OF_MEMORY); } void *lockPtr = NULL; result = mQuadVertexBuffer->Lock(0, 0, &lockPtr, 0); if (FAILED(result) || lockPtr == NULL) { ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY); return error(GL_OUT_OF_MEMORY); } memcpy(lockPtr, quad, sizeof(quad)); mQuadVertexBuffer->Unlock(); static const D3DVERTEXELEMENT9 elements[] = { { 0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, D3DDECL_END() }; result = device->CreateVertexDeclaration(elements, &mQuadVertexDeclaration); if (FAILED(result)) { ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY); return error(GL_OUT_OF_MEMORY); } }
f2dGraphics2DImpl::f2dGraphics2DImpl(f2dRenderDeviceImpl* pParent, fuInt VertexBufferCount, fuInt IndexBufferCount) : f2dGraphicsImpl(pParent), m_pVB(NULL), m_pIB(NULL), m_VBMaxCount(VertexBufferCount), m_IBMaxCount(IndexBufferCount), m_VBUsedCount(0), m_IBUsedCount(0), m_VBAlloced(0), m_IBAlloced(0), m_pVBData(NULL), m_pIBData(NULL), m_ColorBlendType(F2DGRAPH2DBLENDTYPE_ADD) { // 设置默认的投影矩阵 SetProjTransform(fcyMatrix4::GetOrthoOffCenterLH( 0.f, (float)pParent->GetBufferWidth(), (float)pParent->GetBufferHeight(), 0.f, 0.f, 100.f )); // 创建缓存 HRESULT tHR; IDirect3DDevice9* pDev = (IDirect3DDevice9*)m_pParent->GetHandle(); if(FAILED(tHR = pDev->CreateVertexBuffer( m_VBMaxCount * sizeof(f2dGraphics2DVertex), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, FVF, D3DPOOL_DEFAULT, &m_pVB, NULL))) { throw fcyWin32COMException("f2dGraphics2DImpl::f2dGraphics2DImpl", "IDirect3DDevice9::CreateVertexBuffer Failed.", tHR); } if(FAILED(tHR = pDev->CreateIndexBuffer( m_IBMaxCount * sizeof(fuShort), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_pIB, NULL))) { FCYSAFEKILL(m_pVB); throw fcyWin32COMException("f2dGraphics2DImpl::f2dGraphics2DImpl", "IDirect3DDevice9::CreateIndexBuffer Failed.", tHR); } // 注册监听器 m_pParent->AttachListener(this); }
void f2dGraphics2DImpl::OnRenderDeviceReset() { IDirect3DDevice9* pDev = (IDirect3DDevice9*)m_pParent->GetHandle(); pDev->CreateVertexBuffer( m_VBMaxCount * sizeof(f2dGraphics2DVertex), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, FVF, D3DPOOL_DEFAULT, &m_pVB, NULL); pDev->CreateIndexBuffer( m_IBMaxCount * sizeof(fuShort), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_pIB, NULL); }
sge::d3d9::vertex::d3d_buffer_unique_ptr sge::d3d9::devicefuncs::create_vertex_buffer( IDirect3DDevice9 &_device, sge::renderer::size_type const _size, D3DPOOL const _pool, sge::d3d9::usage const _usage ) { IDirect3DVertexBuffer9 *ret; if( _device.CreateVertexBuffer( fcppt::cast::size< UINT >( _size ), _usage.get(), 0, // no FVF _pool, &ret, nullptr ) != D3D_OK ) throw sge::renderer::exception{ FCPPT_TEXT("Cannot create vertex buffer!") }; return sge::d3d9::vertex::d3d_buffer_unique_ptr( ret ); }
bool VertexBuffer::Create() { Release(); if (!vertexCount_ || elements_.Empty()) return true; if (graphics_) { if (graphics_->IsDeviceLost()) { ATOMIC_LOGWARNING("Vertex buffer creation while device is lost"); return true; } unsigned pool = dynamic_ ? D3DPOOL_DEFAULT : D3DPOOL_MANAGED; unsigned d3dUsage = dynamic_ ? D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY : 0; IDirect3DDevice9* device = graphics_->GetImpl()->GetDevice(); HRESULT hr = device->CreateVertexBuffer( vertexCount_ * vertexSize_, d3dUsage, 0, (D3DPOOL)pool, (IDirect3DVertexBuffer9**)&object_.ptr_, 0); if (FAILED(hr)) { ATOMIC_SAFE_RELEASE(object_.ptr_); ATOMIC_LOGD3DERROR("Could not create vertex buffer", hr); return false; } } return true; }
bool CBasicObjects::_FillBoxVBNormal() { HRESULT hr; const int iTriangleCount = 2 * 6; SNormalVertex boxCorners[2][2][2]; SNormalVertex boxTriangles[iTriangleCount * 3]; memset(boxCorners, 0, sizeof(boxCorners)); memset(boxTriangles, 0, sizeof(boxTriangles)); IDirect3DDevice9 * pDevice = CGraphicsManager::GetInstance()->GetDevice(); int iX, iY, iZ; // fill corners for(iX = 0; iX < 2; iX++) { for(iY = 0; iY < 2; iY++) { for(iZ = 0; iZ < 2; iZ++) { boxCorners[iX][iY][iZ].x = (float)iX; boxCorners[iX][iY][iZ].y = (float)iY; boxCorners[iX][iY][iZ].z = (float)iZ; } } } SNormalVertex * pBoxPoint = boxTriangles; // fill triangles // bottom *pBoxPoint = boxCorners[0][0][0]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][0]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][0]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][0]; pBoxPoint++; *pBoxPoint = boxCorners[1][1][0]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][0]; pBoxPoint++; _SetPrevFaceNormals(pBoxPoint, 0.0f, 0.0f, -1.0f); // back *pBoxPoint = boxCorners[0][0][0]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][0]; pBoxPoint++; *pBoxPoint = boxCorners[0][0][1]; pBoxPoint++; *pBoxPoint = boxCorners[0][0][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][0]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][1]; pBoxPoint++; _SetPrevFaceNormals(pBoxPoint, 0.0f, -1.0f, 0.0f); // left *pBoxPoint = boxCorners[0][0][0]; pBoxPoint++; *pBoxPoint = boxCorners[0][0][1]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][0]; pBoxPoint++; *pBoxPoint = boxCorners[0][0][1]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][1]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][0]; pBoxPoint++; _SetPrevFaceNormals(pBoxPoint, -1.0f, 0.0f, 0.0f); // front *pBoxPoint = boxCorners[0][1][0]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][1][0]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][1][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][1][0]; pBoxPoint++; _SetPrevFaceNormals(pBoxPoint, 0.0f, 1.0f, 0.0f); // right *pBoxPoint = boxCorners[1][1][0]; pBoxPoint++; *pBoxPoint = boxCorners[1][1][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][0]; pBoxPoint++; *pBoxPoint = boxCorners[1][1][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][0]; pBoxPoint++; _SetPrevFaceNormals(pBoxPoint, 1.0f, 0.0f, 0.0f); // top *pBoxPoint = boxCorners[0][0][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][1]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][0][1]; pBoxPoint++; *pBoxPoint = boxCorners[1][1][1]; pBoxPoint++; *pBoxPoint = boxCorners[0][1][1]; pBoxPoint++; _SetPrevFaceNormals(pBoxPoint, 0.0f, 0.0f, 1.0f); if(m_pNormalBox != NULL) { LogError("Expected normal box VB to be NULL"); return false; } hr = pDevice->CreateVertexBuffer(sizeof(boxTriangles), 0, SNormalVertex::_fvf, D3DPOOL_DEFAULT, &m_pNormalBox, NULL); if(FAILED(hr)) { LogErrorHr("Failed to create vertex buffer for normal box", hr); return false; } VOID * pDevBox = NULL; hr = m_pNormalBox->Lock(0, sizeof(boxTriangles), (void**)&pDevBox, 0); if(FAILED(hr)) { LogErrorHr("Failed to create vertex buffer for normal box", hr); return false; } memcpy(pDevBox, boxTriangles, sizeof(boxTriangles)); hr = m_pNormalBox->Unlock(); if(FAILED(hr)) { LogErrorHr("Failed to create vertex buffer for normal box", hr); return false; } return true; }
void NX::Sphere::CreateTriangles() { int nV = (m_iStacks - 1) * (m_iSlices + 1) + 2, r, c; int nI = (m_iStacks - 2) * (m_iSlices + 1) * 2 + (m_iSlices + 2) * 2; float rr = kfPiOver2, rc, dr = kfPi / m_iStacks, dc = kf2Pi / m_iSlices; float sr, cr, sc, cc; IDirect3DDevice9 *pDevice = glb_GetD3DDevice(); m_pVertexs = new Vertex[nV]; {//calculate vertex data Vertex *pVertex = m_pVertexs; *pVertex++ = { 0.f, m_fRadius, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f }; for (r = 1; r < m_iStacks; ++r) { rr -= dr; rc = 0.f; cr = std::cosf(rr), sr = std::sinf(rr); for (c = 0; c <= m_iSlices; ++c) { sc = std::sinf(rc); cc = std::cosf(rc); *pVertex++ = { m_fRadius * cr * cc, m_fRadius * sr, m_fRadius * cr * sc, c * 1.f / m_iSlices, r * 1.f / m_iStacks, cr * cc, sr, cr * sc }; rc += dc; } } *pVertex = { 0.f, -m_fRadius, 0.f, 0.f, 1.f, 0.f, -1.f, 0.f }; pDevice->CreateVertexBuffer(sizeof(Vertex) * nV, D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &m_pVertexBuffer, nullptr); void *pBase = nullptr; m_pVertexBuffer->Lock(0, 0, &pBase, D3DLOCK_DISCARD); memcpy(pBase, m_pVertexs, sizeof(Vertex) * nV); m_pVertexBuffer->Unlock(); } {//vertex desc D3DVERTEXELEMENT9 VertexDesc[] = { { 0, CLS_MEM_OFFSET(Vertex, x), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, { 0, CLS_MEM_OFFSET(Vertex, u), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 }, { 0, CLS_MEM_OFFSET(Vertex,nx), D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 }, D3DDECL_END(), }; pDevice->CreateVertexDeclaration(VertexDesc, &m_pVertexDesc); } {//calculate index data pDevice->CreateIndexBuffer(nI * sizeof(int), D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &m_pIndexBuffer, nullptr); int *pBase = nullptr; m_pIndexBuffer->Lock(0, 0, (void**)&pBase, D3DLOCK_DISCARD); for (int i = 0; i <= m_iSlices + 1; ++i) {//first stack, triangle_fan *pBase++ = i; } int a = 1; for (int i = 1; i < m_iStacks - 1; ++i) {//inner stacks, triangle_list for (int j = 0; j <= m_iSlices; ++j) { *pBase++ = a; *pBase++ = a + m_iSlices + 1; ++a; } } *pBase++ = (m_iStacks - 1) * (m_iSlices + 1) + 1; for (int i = 0; i <= m_iSlices; ++i) { *pBase++ = (m_iStacks - 2) * (m_iSlices + 1) + 1 + i; } m_pIndexBuffer->Unlock(); } }
void MythRenderD3D9::DrawRect(const QRect &rect, const QColor &color, int alpha) { D3D9Locker locker(this); IDirect3DDevice9* dev = locker.Acquire(); if (!dev) return; if (!m_rect_vertexbuffer) { HRESULT hr = dev->CreateVertexBuffer( sizeof(VERTEX)*4, D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, D3DFVF_VERTEX, D3DPOOL_DEFAULT, &m_rect_vertexbuffer, NULL); if (FAILED(hr)) { VERBOSE(VB_IMPORTANT, D3DERR + "Failed to create vertex buffer"); return; } } EnableBlending(dev, true); SetTextureVertices(dev, false); MultiTexturing(dev, false); SetTexture(dev, NULL, 0); int alphamod = (int)(color.alpha() * (alpha / 255.0)); D3DCOLOR clr = D3DCOLOR_ARGB(alphamod, color.red(), color.green(), color.blue()); VERTEX *p_vertices; HRESULT hr = m_rect_vertexbuffer->Lock(0, 0, (VOID **)(&p_vertices), D3DLOCK_DISCARD); if (FAILED(hr)) { VERBOSE(VB_IMPORTANT, D3DERR + "Failed to lock vertex buffer."); return; } p_vertices[0].x = (float)rect.left(); p_vertices[0].y = (float)rect.top(); p_vertices[0].z = 0.0f; p_vertices[0].diffuse = clr; p_vertices[0].rhw = 1.0f; p_vertices[1].x = (float)(rect.left() + rect.width()); p_vertices[1].y = (float)rect.top(); p_vertices[1].z = 0.0f; p_vertices[1].diffuse = clr; p_vertices[1].rhw = 1.0f; p_vertices[2].x = (float)(rect.left() + rect.width()); p_vertices[2].y = (float)(rect.top() + rect.height()); p_vertices[2].z = 0.0f; p_vertices[2].diffuse = clr; p_vertices[2].rhw = 1.0f; p_vertices[3].x = (float)rect.left(); p_vertices[3].y = (float)(rect.top() + rect.height()); p_vertices[3].z = 0.0f; p_vertices[3].diffuse = clr; p_vertices[3].rhw = 1.0f; hr = m_rect_vertexbuffer->Unlock(); if (FAILED(hr)) { VERBOSE(VB_IMPORTANT, D3DERR + "Failed to unlock vertex buffer"); return; } hr = dev->SetStreamSource(0, m_rect_vertexbuffer, 0, sizeof(VERTEX)); if (FAILED(hr)) { VERBOSE(VB_IMPORTANT, D3DERR + "SetStreamSource() failed"); return; } hr = dev->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, 2); if (FAILED(hr)) { VERBOSE(VB_IMPORTANT, D3DERR + "DrawPrimitive() failed"); return; } }
int __stdcall WinMain(HINSTANCE, HINSTANCE, LPSTR, int){ Application app("Okienko"); // Inicjalizacja Direct3D IDirect3D9* d3d = Direct3DCreate9(D3D_SDK_VERSION); // Parametry urzadzenia D3DPRESENT_PARAMETERS d3dpp; ZeroMemory(&d3dpp, sizeof(d3dpp)); d3dpp.Windowed = true; d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; d3dpp.BackBufferCount = 1; d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8; d3dpp.BackBufferHeight = app.get_height(); d3dpp.BackBufferWidth = app.get_width(); d3dpp.EnableAutoDepthStencil = true; d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8; // Tworzenie urzadzenia IDirect3DDevice9* dev; d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, app.window_handle(), D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &dev); app.init_font(dev, "Courier New"); dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); // Brak obcinania scian dev->SetRenderState(D3DRS_LIGHTING, false); // Brak swiatla // Inicjalizacja kamery // D3DXVECTOR3 eye(0, 5, -10); D3DXVECTOR3 target(0, 0, 0); D3DXVECTOR3 up(0, 1, 0); D3DXMATRIXA16 view; D3DXMATRIX mProjection; D3DXMatrixPerspectiveFovLH(&mProjection, D3DX_PI * 0.5f, app.get_width()/(float)app.get_height(), 1, 50); dev->SetTransform(D3DTS_PROJECTION, &mProjection); // Model pudelka Vertex box[] = { // X Y Z Color { 1, 1, 1, D3DCOLOR_XRGB(255, 255, 255)}, {-1, 1, 1, D3DCOLOR_XRGB(0, 255, 255)}, {-1, 1, -1, D3DCOLOR_XRGB(0, 255, 0)}, { 1, 1, -1, D3DCOLOR_XRGB(255, 255, 0)}, { 1, -1, 1, D3DCOLOR_XRGB(255, 0, 255)}, {-1, -1, 1, D3DCOLOR_XRGB(0, 0, 255)}, {-1, -1, -1, D3DCOLOR_XRGB(0, 0, 0)}, { 1, -1, -1, D3DCOLOR_XRGB(255, 0, 0)}, box[0], box[4], box[1], box[5], box[2], box[6], box[3], box[7], box[0], box[4] }; int box_size = (16 + 2) * sizeof(Vertex); // Tworzenie bufora wierzcholkow IDirect3DVertexBuffer9* box_buffer; dev->CreateVertexBuffer(box_size, 0, Vertex_Format, D3DPOOL_MANAGED, &box_buffer, NULL); VOID* pVoid; box_buffer->Lock(0, box_size, (void**)&pVoid, 0); memcpy(pVoid, box, box_size); box_buffer->Unlock(); dev->SetFVF(Vertex_Format); dev->SetStreamSource(0, box_buffer, 0, sizeof(Vertex)); float radius = 3; while(app.running()){ float alfa = app.get_alfa(); float beta = app.get_beta(); // Aktualizujemy kamere D3DXVECTOR3 eye( radius * cos(alfa) * sin(beta), radius * cos(beta), radius * sin(alfa) * sin(beta) ); D3DXMatrixLookAtLH(&view, &eye, &target, &up); dev->SetTransform(D3DTS_VIEW, &view); // Rysujemy pudeleczko dev->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0); dev->BeginScene(); for(int i = 0; i < 2; i++) dev->DrawPrimitive(D3DPT_TRIANGLEFAN, i*4, 2); dev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 8, 8); app.print(10, 10, "Mysz X = %d", app.get_mouse_x()); app.print(10, 24, "Mysz Y = %d", app.get_mouse_y()); dev->EndScene(); dev->Present(NULL, NULL, NULL, NULL); } // Zwalniamy zasoby box_buffer->Release(); dev->Release(); d3d->Release(); return 0; }
void CFullscreenTriangleDrawer::CreateDX9Resources() { HRESULT hr = S_OK; float VertexData[] = { -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 3.0f, 1.0f, 0.0f, 2.0f, 0.0f, -1.0f, -3.0f, 0.0f, 0.0f, 2.0f, }; IDirect3DDevice9* pDevice = static_cast<IDirect3DDevice9*>( gD3DDevice ); // Vertex buffer hr = pDevice->CreateVertexBuffer( sizeof( VertexData ), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &m_pVertexBuffer, NULL ); CRY_ASSERT( SUCCEEDED( hr ) ); float* pVertexBuffer = NULL; hr = m_pVertexBuffer->Lock( 0, 0, ( void** )&pVertexBuffer, 0 ); CRY_ASSERT( SUCCEEDED( hr ) ); memcpy( pVertexBuffer, VertexData, sizeof( VertexData ) ); m_pVertexBuffer->Unlock(); // Vertex declaration D3DVERTEXELEMENT9 VertexElements[] = { {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0}, {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0}, D3DDECL_END() }; hr = pDevice->CreateVertexDeclaration( VertexElements, &m_pVertexDeclaration ); CRY_ASSERT( SUCCEEDED( hr ) ); // Vertex shader /* // FSTriangle.vs // fxc /O2 /T vs_2_0 /E VSMain float Width : register(c0); float Height : register(c1); struct VertexPT { float4 PositionL : POSITION0; float2 TexCoord : TEXCOORD0; }; VertexPT VSMain(VertexPT vsIn) { vsIn.PositionL += float4(-0.5 / Width, 0.5 / Height, 0, 0); return vsIn; } */ const char CompiledVS[] = { 0x00, 0x02, 0xfe, 0xff, 0xfe, 0xff, 0x28, 0x00, 0x43, 0x54, 0x41, 0x42, 0x1c, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x00, 0x02, 0xfe, 0xff, 0x02, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x06, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0xab, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57, 0x69, 0x64, 0x74, 0x68, 0x00, 0x76, 0x73, 0x5f, 0x32, 0x5f, 0x30, 0x00, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x28, 0x52, 0x29, 0x20, 0x48, 0x4c, 0x53, 0x4c, 0x20, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20, 0x39, 0x2e, 0x32, 0x39, 0x2e, 0x39, 0x35, 0x32, 0x2e, 0x33, 0x31, 0x31, 0x31, 0x00, 0xab, 0xab, 0x51, 0x00, 0x00, 0x05, 0x02, 0x00, 0x0f, 0xa0, 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x0f, 0x90, 0x1f, 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x80, 0x01, 0x00, 0x0f, 0x90, 0x06, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0xa0, 0x05, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0xa0, 0x06, 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x80, 0x01, 0x00, 0x00, 0xa0, 0x05, 0x00, 0x00, 0x03, 0x00, 0x00, 0x02, 0x80, 0x01, 0x00, 0x00, 0x80, 0x02, 0x00, 0x55, 0xa0, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x80, 0x02, 0x00, 0xaa, 0xa0, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0f, 0xc0, 0x00, 0x00, 0xe4, 0x80, 0x00, 0x00, 0xe4, 0x90, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0xe0, 0x01, 0x00, 0xe4, 0x90, 0xff, 0xff, 0x00, 0x00, }; hr = pDevice->CreateVertexShader( ( DWORD* )CompiledVS, &m_pVertexShader9 ); CRY_ASSERT( SUCCEEDED( hr ) ); // Pixel shader /* // FSTriangle.ps // fxc /O2 /T ps_2_0 /E PSMain texture Texture : register(s0); sampler PointSampler = sampler_state { Texture = <Texture>; MinFilter = Point; MagFilter = Point; MipFilter = Point; MaxAnisotropy = 1; AddressU = CLAMP; AddressV = CLAMP; }; struct VertexPT { float4 PositionL : POSITION0; float2 TexCoord : TEXCOORD0; }; float4 PSMain(VertexPT psIn) : COLOR { return tex2D(PointSampler, psIn.TexCoord); } */ const char CompiledPS[] = { 0x00, 0x02, 0xff, 0xff, 0xfe, 0xff, 0x23, 0x00, 0x43, 0x54, 0x41, 0x42, 0x1c, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x00, 0xab, 0xab, 0xab, 0x04, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x73, 0x5f, 0x32, 0x5f, 0x30, 0x00, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x28, 0x52, 0x29, 0x20, 0x48, 0x4c, 0x53, 0x4c, 0x20, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20, 0x39, 0x2e, 0x32, 0x39, 0x2e, 0x39, 0x35, 0x32, 0x2e, 0x33, 0x31, 0x31, 0x31, 0x00, 0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x03, 0xb0, 0x1f, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x90, 0x00, 0x08, 0x0f, 0xa0, 0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0f, 0x80, 0x00, 0x00, 0xe4, 0xb0, 0x00, 0x08, 0xe4, 0xa0, 0x01, 0x00, 0x00, 0x02, 0x00, 0x08, 0x0f, 0x80, 0x00, 0x00, 0xe4, 0x80, 0xff, 0xff, 0x00, 0x00, }; hr = pDevice->CreatePixelShader( ( DWORD* )CompiledPS, &m_pPixelShader9 ); CRY_ASSERT( SUCCEEDED( hr ) ); hr = pDevice->CreateStateBlock( D3DSBT_ALL, &m_pStateBlock ); CRY_ASSERT( SUCCEEDED( hr ) ); }
void CShowPoints9::SetMesh(LPD3DXMESH pNewMesh, LPD3DXSKININFO pNewSkin) { HRESULT hr = S_OK; NumPoints = 0; UnskinnedVB.resize(0); SAFE_RELEASE(SkinnedVB); SAFE_RELEASE(Skin); if(pNewMesh == NULL) return; IDirect3DDevice9* device = DXUTGetD3D9Device(); {//EFFECT V( device->CreateVertexDeclaration( Elements, &Declaration ) ); ID3DXBuffer* pErrors = NULL; V( SASCreateEffectFromResource( device, NULL, MAKEINTRESOURCE(IDR_SHOWLINES9FX), MAKEINTRESOURCE(RT_RCDATA), NULL, NULL, 0, NULL, &Effect, &pErrors)); if(pErrors) DXVGetApp().OutputA( (const char*)pErrors->GetBufferPointer() ); SAFE_RELEASE(pErrors); }//EFFECT D3DVERTEXELEMENT9 declIn[ MAX_FVF_DECL_SIZE ]; V( pNewMesh->GetDeclaration(declIn) ); int iPos= -1; int iNorm= -1; for( int i = 0 ; declIn[i].Stream != 255 && i < MAX_FVF_DECL_SIZE; i++) { if(declIn[i].Usage == D3DDECLUSAGE_POSITION && declIn[i].UsageIndex == 0) iPos = i; if(declIn[i].Usage == D3DDECLUSAGE_NORMAL && declIn[i].UsageIndex == 0) iNorm = i; } if(iPos == -1 || iNorm == -1) return; if( (( declIn[iPos].Type & (D3DDECLTYPE_FLOAT3|D3DDECLTYPE_FLOAT4)) == 0 ) || (( declIn[iNorm].Type & (D3DDECLTYPE_FLOAT3|D3DDECLTYPE_FLOAT4)) == 0 ) ) return; NumPoints = pNewMesh->GetNumVertices(); int MeshStride = pNewMesh->GetNumBytesPerVertex(); if(pNewSkin) { V( pNewSkin->Clone( &Skin ) ); V( Skin->SetDeclaration(Elements) ); } //GET VERTEX DATA BYTE* pSrcVB= NULL; V( pNewMesh->LockVertexBuffer( D3DLOCK_READONLY, (LPVOID*)&pSrcVB ) ); UnskinnedVB.resize(pNewMesh->GetNumVertices()); for( DWORD iVert = 0; iVert < pNewMesh->GetNumVertices(); iVert++) { Vertex& v0 = UnskinnedVB[iVert]; v0.Position = *(D3DXVECTOR3*) (pSrcVB+(MeshStride*iVert)+declIn[iPos].Offset); } V( pNewMesh->UnlockVertexBuffer() ); V( device->CreateVertexBuffer( NumPoints*Stride , D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &SkinnedVB, NULL) ); //Fill in with initial values so unskinned meshes do not have to do this every render. pSrcVB=(BYTE*)(void*)&UnskinnedVB.front(); BYTE* pDstVB=NULL; V( SkinnedVB->Lock(0, 0, (void**)&pDstVB, 0 ) ); { memcpy( pDstVB, pSrcVB, Stride*pNewMesh->GetNumVertices() ); } V( SkinnedVB->Unlock() ); }
bool CBasicObjects::_FillRectVB() { HRESULT hr; DWORD dwColor = 0xff00ff00; IDirect3DDevice9 * pDevice = CGraphicsManager::GetInstance()->GetDevice(); SFaceVertex corners[3 * 2]; memset(corners, 0, sizeof(corners)); SFaceVertex baseCorners[4]; memset(baseCorners, 0, sizeof(baseCorners)); // lower left baseCorners[0].x = 0.0f; baseCorners[0].y = 0.0f; baseCorners[0].z = 0.0f; baseCorners[0].tu = 0.0f; baseCorners[0].tv = 1.0f; // upper left baseCorners[1].x = 0.0f; baseCorners[1].y = 1.0f; baseCorners[1].z = 0.0f; baseCorners[1].tu = 0.0f; baseCorners[1].tv = 0.0f; // upper left baseCorners[2].x = 1.0f; baseCorners[2].y = 1.0f; baseCorners[2].z = 0.0f; baseCorners[2].tu = 1.0f; baseCorners[2].tv = 0.0f; // lower right baseCorners[3].x = 1.0f; baseCorners[3].y = 0.0f; baseCorners[3].z = 0.0f; baseCorners[3].tu = 1.0f; baseCorners[3].tv = 1.0f; corners[0] = baseCorners[0]; corners[1] = baseCorners[1]; corners[2] = baseCorners[2]; corners[3] = baseCorners[2]; corners[4] = baseCorners[3]; corners[5] = baseCorners[0]; if(m_pRectVB != NULL) { LogError("Expected rect VB to be NULL"); return false; } hr = pDevice->CreateVertexBuffer(sizeof(corners), 0, SFaceVertex::_fvf, D3DPOOL_DEFAULT, &m_pRectVB, NULL); if(FAILED(hr)) { LogErrorHr("Failed to create vertex buffer for rect", hr); return false; } VOID * pDevRect = NULL; hr = m_pRectVB->Lock(0, sizeof(corners), (void**)&pDevRect, 0); if(FAILED(hr)) { LogErrorHr("Failed to lock vertex buffer for rect", hr); return false; } memcpy(pDevRect, corners, sizeof(corners)); hr = m_pRectVB->Unlock(); if(FAILED(hr)) { LogErrorHr("Failed to lock vertex buffer for rect", hr); return false; } return true; }
bool CBasicObjects::_FillPolesVB() { HRESULT hr; const int iPoleCount = (g_iGridSize + 1) * (g_iGridSize + 1); DWORD dwColor = 0xff00ff00; SLineVertex lines[2 * iPoleCount]; memset(lines, 0, sizeof(lines)); IDirect3DDevice9 * pDevice = CGraphicsManager::GetInstance()->GetDevice(); float fCoorMax = ((float)g_iGridSize) / 2.0f; for(int iX = 0; iX <= g_iGridSize; iX++) { for(int iY = 0; iY <= g_iGridSize; iY++) { lines[2 * (iX + iY * (g_iGridSize + 1)) + 0].x = -fCoorMax + (float)iX; lines[2 * (iX + iY * (g_iGridSize + 1)) + 0].y = -fCoorMax + (float)iY; lines[2 * (iX + iY * (g_iGridSize + 1)) + 0].z = 0.0f; lines[2 * (iX + iY * (g_iGridSize + 1)) + 0].color = dwColor; lines[2 * (iX + iY * (g_iGridSize + 1)) + 1].x = -fCoorMax + (float)iX; lines[2 * (iX + iY * (g_iGridSize + 1)) + 1].y = -fCoorMax + (float)iY; lines[2 * (iX + iY * (g_iGridSize + 1)) + 1].z = 1.0f; lines[2 * (iX + iY * (g_iGridSize + 1)) + 1].color = dwColor; } } if(m_pPolesVB != NULL) { LogError("Expected Box VB to be NULL"); return false; } hr = pDevice->CreateVertexBuffer(sizeof(lines), 0, SLineVertex::_fvf, D3DPOOL_DEFAULT, &m_pPolesVB, NULL); if(FAILED(hr)) { LogErrorHr("Failed to create vertex buffer for poles", hr); return false; } VOID * pDevPoles = NULL; hr = m_pPolesVB->Lock(0, sizeof(lines), (void**)&pDevPoles, 0); if(FAILED(hr)) { LogErrorHr("Failed to lock vertex buffer for poles", hr); return false; } memcpy(pDevPoles, lines, sizeof(lines)); hr = m_pPolesVB->Unlock(); if(FAILED(hr)) { LogErrorHr("Failed to lock vertex buffer for poles", hr); return false; } return true; }
bool CBasicObjects::_FillGridVB() { HRESULT hr; SLineVertex lines[(g_iGridSize + 1) * 2 * 2]; memset(lines, 0, sizeof(lines)); const float fGridStart = ((float)g_iGridSize) / 2.0f; const float fGridSize = (float)g_iGridSize; DWORD dwGridColor = 0xff0000ff; IDirect3DDevice9 * pDevice = CGraphicsManager::GetInstance()->GetDevice(); for(int iGridLineIndex = 0; iGridLineIndex <= g_iGridSize; iGridLineIndex++) { // parallel to y axis lines[4 * iGridLineIndex + 0].x = -fGridStart + (float)(iGridLineIndex); lines[4 * iGridLineIndex + 0].y = -fGridStart; lines[4 * iGridLineIndex + 0].color = dwGridColor; lines[4 * iGridLineIndex + 1].x = -fGridStart + (float)(iGridLineIndex); lines[4 * iGridLineIndex + 1].y = fGridStart; lines[4 * iGridLineIndex + 1].color = dwGridColor; // parallel to x axis lines[4 * iGridLineIndex + 2].x = -fGridStart; lines[4 * iGridLineIndex + 2].y = -fGridStart + (float)(iGridLineIndex); lines[4 * iGridLineIndex + 2].color = dwGridColor; lines[4 * iGridLineIndex + 3].x = fGridStart; lines[4 * iGridLineIndex + 3].y = -fGridStart + (float)(iGridLineIndex); lines[4 * iGridLineIndex + 3].color = dwGridColor; } if(m_pGridVB != NULL) { LogError("Expected Box VB to be NULL"); return false; } hr = pDevice->CreateVertexBuffer(sizeof(lines), 0, SLineVertex::_fvf, D3DPOOL_DEFAULT, &m_pGridVB, NULL); if(FAILED(hr)) { LogErrorHr("Failed to create vertex buffer for grid", hr); return false; } VOID * pDevGrid = NULL; hr = m_pGridVB->Lock(0, sizeof(lines), (void**)&pDevGrid, 0); if(FAILED(hr)) { LogErrorHr("Failed to lock vertex buffer for grid", hr); return false; } memcpy(pDevGrid, lines, sizeof(lines)); hr = m_pGridVB->Unlock(); if(FAILED(hr)) { LogErrorHr("Failed to unlock vertex buffer for grid", hr); return false; } return true; }