/* ======================== idJointBuffer::MapBuffer ======================== */ float * idJointBuffer::MapBuffer( bufferMapType_t mapType ) const { assert( IsMapped() == false ); assert( mapType == BM_WRITE ); assert( apiObject != NULL ); int numBytes = GetAllocedSize(); void * buffer = NULL; qglBindBufferARB( GL_UNIFORM_BUFFER, reinterpret_cast< GLuint >( apiObject ) ); numBytes = numBytes; assert( GetOffset() == 0 ); //buffer = qglMapBufferARB( GL_UNIFORM_BUFFER, GL_WRITE_ONLY_ARB ); buffer = qglMapBufferRange( GL_UNIFORM_BUFFER, 0, GetAllocedSize(), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_UNSYNCHRONIZED_BIT ); if ( buffer != NULL ) { buffer = (byte *)buffer + GetOffset(); } SetMapped(); if ( buffer == NULL ) { idLib::FatalError( "idJointBuffer::MapBuffer: failed" ); } return (float *) buffer; }
void DXStagingTexture::CopyToTexture(const MathUtil::Rectangle<int>& src_rect, AbstractTexture* dst, const MathUtil::Rectangle<int>& dst_rect, u32 dst_layer, u32 dst_level) { ASSERT(m_type == StagingTextureType::Upload); ASSERT(src_rect.GetWidth() == dst_rect.GetWidth() && src_rect.GetHeight() == dst_rect.GetHeight()); ASSERT(src_rect.left >= 0 && static_cast<u32>(src_rect.right) <= GetWidth() && src_rect.top >= 0 && static_cast<u32>(src_rect.bottom) <= GetHeight()); ASSERT(dst_rect.left >= 0 && static_cast<u32>(dst_rect.right) <= dst->GetWidth() && dst_rect.top >= 0 && static_cast<u32>(dst_rect.bottom) <= dst->GetHeight()); if (IsMapped()) DXStagingTexture::Unmap(); if (static_cast<u32>(src_rect.GetWidth()) == dst->GetWidth() && static_cast<u32>(src_rect.GetHeight()) == dst->GetHeight()) { D3D::context->CopySubresourceRegion( static_cast<const DXTexture*>(dst)->GetD3DTexture(), D3D11CalcSubresource(dst_level, dst_layer, dst->GetLevels()), 0, 0, 0, m_tex, 0, nullptr); } else { CD3D11_BOX src_box(src_rect.left, src_rect.top, 0, src_rect.right, src_rect.bottom, 1); D3D::context->CopySubresourceRegion( static_cast<const DXTexture*>(dst)->GetD3DTexture(), D3D11CalcSubresource(dst_level, dst_layer, dst->GetLevels()), static_cast<u32>(dst_rect.left), static_cast<u32>(dst_rect.top), 0, m_tex, 0, &src_box); } }
void DXStagingTexture::CopyFromTexture(const AbstractTexture* src, const MathUtil::Rectangle<int>& src_rect, u32 src_layer, u32 src_level, const MathUtil::Rectangle<int>& dst_rect) { ASSERT(m_type == StagingTextureType::Readback || m_type == StagingTextureType::Mutable); ASSERT(src_rect.GetWidth() == dst_rect.GetWidth() && src_rect.GetHeight() == dst_rect.GetHeight()); ASSERT(src_rect.left >= 0 && static_cast<u32>(src_rect.right) <= src->GetWidth() && src_rect.top >= 0 && static_cast<u32>(src_rect.bottom) <= src->GetHeight()); ASSERT(dst_rect.left >= 0 && static_cast<u32>(dst_rect.right) <= m_config.width && dst_rect.top >= 0 && static_cast<u32>(dst_rect.bottom) <= m_config.height); if (IsMapped()) DXStagingTexture::Unmap(); if (static_cast<u32>(src_rect.GetWidth()) == GetWidth() && static_cast<u32>(src_rect.GetHeight()) == GetHeight()) { // Copy whole resource, needed for depth textures. D3D::context->CopySubresourceRegion( m_tex, 0, 0, 0, 0, static_cast<const DXTexture*>(src)->GetD3DTexture(), D3D11CalcSubresource(src_level, src_layer, src->GetLevels()), nullptr); } else { CD3D11_BOX src_box(src_rect.left, src_rect.top, 0, src_rect.right, src_rect.bottom, 1); D3D::context->CopySubresourceRegion( m_tex, 0, static_cast<u32>(dst_rect.left), static_cast<u32>(dst_rect.top), 0, static_cast<const DXTexture*>(src)->GetD3DTexture(), D3D11CalcSubresource(src_level, src_layer, src->GetLevels()), &src_box); } m_needs_flush = true; }
MappedFile::~MappedFile() { if (IsMapped()) { Unmap(); } } // MappedFile::~MappedFile
static void wxWinHintsSetLayer(Display *display, Window rootWnd, Window window, int layer) { wxX11ErrorsSuspender noerrors(display); XEvent xev; wxMAKE_ATOM( _WIN_LAYER, display ); if (IsMapped(display, window)) { xev.type = ClientMessage; xev.xclient.type = ClientMessage; xev.xclient.window = window; xev.xclient.message_type = _WIN_LAYER; xev.xclient.format = 32; xev.xclient.data.l[0] = (long)layer; xev.xclient.data.l[1] = CurrentTime; XSendEvent(display, rootWnd, False, SubstructureNotifyMask, (XEvent*) &xev); } else { long data[1]; data[0] = layer; XChangeProperty(display, window, _WIN_LAYER, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)data, 1); } }
static void wxWMspecSetState(Display *display, Window rootWnd, Window window, int operation, Atom state) { wxMAKE_ATOM(_NET_WM_STATE, display); if ( IsMapped(display, window) ) { XEvent xev; xev.type = ClientMessage; xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; xev.xclient.display = display; xev.xclient.window = window; xev.xclient.message_type = _NET_WM_STATE; xev.xclient.format = 32; xev.xclient.data.l[0] = operation; xev.xclient.data.l[1] = state; xev.xclient.data.l[2] = None; XSendEvent(display, rootWnd, False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); } // FIXME - must modify _NET_WM_STATE property list if the window // wasn't mapped! }
/* ======================== idJointBuffer::FreeBufferObject ======================== */ void idJointBuffer::FreeBufferObject() { if ( IsMapped() ) { UnmapBuffer(); } // if this is a sub-allocation inside a larger buffer, don't actually free anything. if ( OwnsBuffer() == false ) { ClearWithoutFreeing(); return; } if ( apiObject == NULL ) { return; } if ( r_showBuffers.GetBool() ) { idLib::Printf( "joint buffer free %p, api %p (%i joints)\n", this, GetAPIObject(), GetNumJoints() ); } GLuint buffer = reinterpret_cast< GLuint > ( apiObject ); qglBindBufferARB( GL_UNIFORM_BUFFER, 0 ); qglDeleteBuffersARB( 1, & buffer ); ClearWithoutFreeing(); }
/* ======================== idIndexBuffer::MapBuffer ======================== */ void * idIndexBuffer::MapBuffer( bufferMapType_t mapType ) const { assert( apiObject != NULL ); assert( IsMapped() == false ); void * buffer = NULL; GLuint bufferObject = reinterpret_cast< GLuint >( apiObject ); qglBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, bufferObject ); if ( mapType == BM_READ ) { //buffer = qglMapBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, GL_READ_ONLY_ARB ); buffer = qglMapBufferRange( GL_ELEMENT_ARRAY_BUFFER_ARB, 0, GetAllocedSize(), GL_MAP_READ_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_UNSYNCHRONIZED_BIT ); if ( buffer != NULL ) { buffer = (byte *)buffer + GetOffset(); } } else if ( mapType == BM_WRITE ) { //buffer = qglMapBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB ); buffer = qglMapBufferRange( GL_ELEMENT_ARRAY_BUFFER_ARB, 0, GetAllocedSize(), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_UNSYNCHRONIZED_BIT ); if ( buffer != NULL ) { buffer = (byte *)buffer + GetOffset(); } assert( IsWriteCombined( buffer ) ); } else { assert( false ); } SetMapped(); if ( buffer == NULL ) { idLib::FatalError( "idIndexBuffer::MapBuffer: failed" ); } return buffer; }
void InputMapper::AddDefaultMappingsForCurrentGameIfUnmapped() { // Clear default mappings. Default mappings are in the third slot. FOREACH_ENUM( GameController, i ) FOREACH_ENUM( GameButton, j) ClearFromInputMap( GameInput(i, j), 2 ); vector<AutoMappingEntry> aMaps; aMaps.reserve( 32 ); FOREACH_CONST( AutoMappingEntry, g_DefaultKeyMappings.m_vMaps, iter ) aMaps.push_back( *iter ); FOREACH_CONST( AutoMappingEntry, m_pInputScheme->m_pAutoMappings->m_vMaps, iter ) aMaps.push_back( *iter ); /* There may be duplicate GAME_BUTTON maps. Process the list backwards, * so game-specific mappings override g_DefaultKeyMappings. */ std::reverse( aMaps.begin(), aMaps.end() ); FOREACH( AutoMappingEntry, aMaps, m ) { DeviceButton key = m->m_deviceButton; DeviceInput DeviceI( DEVICE_KEYBOARD, key ); GameInput GameI( m->m_bSecondController ? GameController_2 : GameController_1, m->m_gb ); if( !IsMapped(DeviceI) ) // if this key isn't already being used by another user-made mapping { if( !GameI.IsValid() ) ClearFromInputMap( DeviceI ); else SetInputMap( DeviceI, GameI, 2 ); } }
void c4_Column::SetupSegments() { d4_assert(_segments.GetSize() == 0); d4_assert(_gap == 0); d4_assert(_slack == 0); // The last entry in the _segments array is either a partial block // or a null pointer, so calling "fSegIndex(_size)" is always allowed. int n = fSegIndex(_size) + 1; _segments.SetSize(n); // treat last block differently if it is a partial entry int last = n; if (fSegRest(_size)) --last; // this block is partial, size is 1 .. kSegMax-1 else --n; // the last block is left as a null pointer int id = - 1; if (_position < 0) { // special aside id, figure out the real position d4_assert(_persist != 0); id = ~_position; _position = _persist->LookupAside(id); d4_assert(_position >= 0); } if (IsMapped()) { // setup for mapped files is quick, just fill in the pointers d4_assert(_position > 1); d4_assert(_position + (n - 1) *kSegMax <= Strategy()._dataSize); const t4_byte *map = Strategy()._mapStart + _position; for (int i = 0; i < n; ++i) { _segments.SetAt(i, (t4_byte*)map); // loses const map += kSegMax; } } else { int chunk = kSegMax; t4_i32 pos = _position; // allocate buffers, load them if necessary for (int i = 0; i < n; ++i) { if (i == last) chunk = fSegRest(_size); t4_byte *p = d4_new t4_byte[chunk]; _segments.SetAt(i, p); if (_position > 0) { d4_dbgdef(int n = )Strategy().DataRead(pos, p, chunk); d4_assert(n == chunk); pos += chunk; } } }
void CMemStream::Close() { n_assert(IsOpen()); if (IsMapped()) Unmap(); if (SelfAlloc && pBuffer) n_free(pBuffer); pBuffer = NULL; Flags.Clear(IS_OPEN); //CStream::Close(); }
/* ======================== idJointBuffer::UnmapBuffer ======================== */ void idJointBuffer::UnmapBuffer() const { assert( apiObject != NULL ); assert( IsMapped() ); qglBindBufferARB( GL_UNIFORM_BUFFER, reinterpret_cast< GLuint >( apiObject ) ); if ( !qglUnmapBufferARB( GL_UNIFORM_BUFFER ) ) { idLib::Printf( "idJointBuffer::UnmapBuffer failed\n" ); } SetUnmapped(); }
DWORD CMemStream::Read(void* pData, DWORD Size) { n_assert(pBuffer && !IsMapped() && (AccessMode & SAM_READ)); DWORD BytesToRead = n_min(Size, DataSize - Pos); if (BytesToRead > 0) { memcpy(pData, pBuffer + Pos, BytesToRead); Pos += BytesToRead; } return BytesToRead; }
/* ======================== idIndexBuffer::Reference ======================== */ void idIndexBuffer::Reference( const idIndexBuffer & other ) { assert( IsMapped() == false ); //assert( other.IsMapped() == false ); // this happens when building idTriangles while at the same time setting up triIndex_t assert( other.GetAPIObject() != NULL ); assert( other.GetSize() > 0 ); FreeBufferObject(); size = other.GetSize(); // this strips the MAPPED_FLAG offsetInOtherBuffer = other.GetOffset(); // this strips the OWNS_BUFFER_FLAG apiObject = other.apiObject; assert( OwnsBuffer() == false ); }
/* ======================== idIndexBuffer::UnmapBuffer ======================== */ void idIndexBuffer::UnmapBuffer() const { assert( apiObject != NULL ); assert( IsMapped() ); GLuint bufferObject = reinterpret_cast< GLuint >( apiObject ); qglBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, bufferObject ); if ( !qglUnmapBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB ) ) { idLib::Printf( "idIndexBuffer::UnmapBuffer failed\n" ); } SetUnmapped(); }
/* ======================== idJointBuffer::Reference ======================== */ void idJointBuffer::Reference( const idJointBuffer & other ) { assert( IsMapped() == false ); assert( other.IsMapped() == false ); assert( other.GetAPIObject() != NULL ); assert( other.GetNumJoints() > 0 ); FreeBufferObject(); numJoints = other.GetNumJoints(); // this strips the MAPPED_FLAG offsetInOtherBuffer = other.GetOffset(); // this strips the OWNS_BUFFER_FLAG apiObject = other.apiObject; assert( OwnsBuffer() == false ); }
/* ======================== idIndexBuffer::Reference ======================== */ void idIndexBuffer::Reference( const idIndexBuffer & other, int refOffset, int refSize ) { assert( IsMapped() == false ); //assert( other.IsMapped() == false ); // this happens when building idTriangles while at the same time setting up triIndex_t assert( other.GetAPIObject() != NULL ); assert( refOffset >= 0 ); assert( refSize >= 0 ); assert( refOffset + refSize <= other.GetSize() ); FreeBufferObject(); size = refSize; offsetInOtherBuffer = other.GetOffset() + refOffset; apiObject = other.apiObject; assert( OwnsBuffer() == false ); }
/* ======================== idJointBuffer::Reference ======================== */ void idJointBuffer::Reference( const idJointBuffer & other, int jointRefOffset, int numRefJoints ) { assert( IsMapped() == false ); assert( other.IsMapped() == false ); assert( other.GetAPIObject() != NULL ); assert( jointRefOffset >= 0 ); assert( numRefJoints >= 0 ); assert( jointRefOffset + numRefJoints * sizeof( idJointMat ) <= other.GetNumJoints() * sizeof( idJointMat ) ); assert_16_byte_aligned( numRefJoints * 3 * 4 * sizeof( float ) ); FreeBufferObject(); numJoints = numRefJoints; offsetInOtherBuffer = other.GetOffset() + jointRefOffset; apiObject = other.apiObject; assert( OwnsBuffer() == false ); }
/* ======================== idJointBuffer::Update ======================== */ void idJointBuffer::Update( const float * joints, int numUpdateJoints ) const { assert( apiObject != NULL ); assert( IsMapped() == false ); assert_16_byte_aligned( joints ); assert( ( GetOffset() & 15 ) == 0 ); if ( numUpdateJoints > numJoints ) { idLib::FatalError( "idJointBuffer::Update: size overrun, %i > %i\n", numUpdateJoints, numJoints ); } const int numBytes = numUpdateJoints * 3 * 4 * sizeof( float ); qglBindBufferARB( GL_UNIFORM_BUFFER, reinterpret_cast< GLuint >( apiObject ) ); qglBufferSubDataARB( GL_UNIFORM_BUFFER, GetOffset(), (GLsizeiptrARB)numBytes, joints ); }
void DXStagingTexture::CopyToTexture(const MathUtil::Rectangle<int>& src_rect, AbstractTexture* dst, const MathUtil::Rectangle<int>& dst_rect, u32 dst_layer, u32 dst_level) { _assert_(m_type == StagingTextureType::Upload); _assert_(src_rect.GetWidth() == dst_rect.GetWidth() && src_rect.GetHeight() == dst_rect.GetHeight()); _assert_(src_rect.left >= 0 && static_cast<u32>(src_rect.right) <= m_config.width && src_rect.top >= 0 && static_cast<u32>(src_rect.bottom) <= m_config.height); _assert_(dst_rect.left >= 0 && static_cast<u32>(dst_rect.right) <= dst->GetConfig().width && dst_rect.top >= 0 && static_cast<u32>(dst_rect.bottom) <= dst->GetConfig().height); if (IsMapped()) DXStagingTexture::Unmap(); CD3D11_BOX src_box(src_rect.left, src_rect.top, 0, src_rect.right, src_rect.bottom, 1); D3D::context->CopySubresourceRegion( static_cast<const DXTexture*>(dst)->GetRawTexIdentifier()->GetTex(), D3D11CalcSubresource(dst_level, dst_layer, dst->GetConfig().levels), static_cast<u32>(dst_rect.left), static_cast<u32>(dst_rect.top), 0, m_tex, 0, &src_box); }
/* ======================== idVertexBuffer::Update ======================== */ void idVertexBuffer::Update( const void * data, int updateSize ) const { assert( apiObject != NULL ); assert( IsMapped() == false ); assert_16_byte_aligned( data ); assert( ( GetOffset() & 15 ) == 0 ); if ( updateSize > size ) { idLib::FatalError( "idVertexBuffer::Update: size overrun, %i > %i\n", updateSize, GetSize() ); } int numBytes = ( updateSize + 15 ) & ~15; GLuint bufferObject = reinterpret_cast< GLuint >( apiObject ); qglBindBufferARB( GL_ARRAY_BUFFER_ARB, bufferObject ); qglBufferSubDataARB( GL_ARRAY_BUFFER_ARB, GetOffset(), (GLsizeiptrARB)numBytes, data ); /* void * buffer = MapBuffer( BM_WRITE ); CopyBuffer( (byte *)buffer + GetOffset(), (byte *)data, numBytes ); UnmapBuffer(); */ }
void InputMapper::AddDefaultMappingsForCurrentGameIfUnmapped() { // Clear default mappings. Default mappings are in the third slot. for( int i=0; i<MAX_GAME_CONTROLLERS; i++ ) for( int j=0; j<MAX_GAME_BUTTONS; j++ ) ClearFromInputMap( GameInput((GameController)i,(GameButton)j), 2 ); const Game* pGame = GAMESTATE->GetCurrentGame(); for( int c=0; c<MAX_GAME_CONTROLLERS; c++ ) { for( int b=0; b<pGame->m_iButtonsPerController; b++ ) { int key = pGame->m_iDefaultKeyboardKey[c][b]; if( key == NO_DEFAULT_KEY ) continue; DeviceInput DeviceI( DEVICE_KEYBOARD, key ); GameInput GameI( (GameController)c, (GameButton)b ); if( !IsMapped(DeviceI) ) // if this key isn't already being used by another user-made mapping SetInputMap( DeviceI, GameI, 2 ); } } }
DWORD CMemStream::Write(const void* pData, DWORD Size) { n_assert(!IsMapped() && ((AccessMode & SAM_WRITE) || (AccessMode & SAM_APPEND))); if (Pos + Size > AllocSize) { AllocSize = Pos + Size; if (SelfAlloc) pBuffer = (char*)n_realloc(pBuffer, AllocSize); else { void* pOld = pBuffer; pBuffer = (char*)n_malloc(AllocSize); SelfAlloc = true; if (pOld) memcpy(pBuffer, pOld, DataSize); } n_assert(pBuffer); } memcpy(pBuffer + Pos, pData, Size); Pos += Size; if (Pos > DataSize) DataSize = Pos; return Size; }
void DXStagingTexture::CopyFromTexture(const AbstractTexture* src, const MathUtil::Rectangle<int>& src_rect, u32 src_layer, u32 src_level, const MathUtil::Rectangle<int>& dst_rect) { _assert_(m_type == StagingTextureType::Readback); _assert_(src_rect.GetWidth() == dst_rect.GetWidth() && src_rect.GetHeight() == dst_rect.GetHeight()); _assert_(src_rect.left >= 0 && static_cast<u32>(src_rect.right) <= src->GetConfig().width && src_rect.top >= 0 && static_cast<u32>(src_rect.bottom) <= src->GetConfig().height); _assert_(dst_rect.left >= 0 && static_cast<u32>(dst_rect.right) <= m_config.width && dst_rect.top >= 0 && static_cast<u32>(dst_rect.bottom) <= m_config.height); if (IsMapped()) DXStagingTexture::Unmap(); CD3D11_BOX src_box(src_rect.left, src_rect.top, 0, src_rect.right, src_rect.bottom, 1); D3D::context->CopySubresourceRegion( m_tex, 0, static_cast<u32>(dst_rect.left), static_cast<u32>(dst_rect.top), 0, static_cast<const DXTexture*>(src)->GetRawTexIdentifier()->GetTex(), D3D11CalcSubresource(src_level, src_layer, src->GetConfig().levels), &src_box); m_needs_flush = true; }
/* ======================== idIndexBuffer::FreeBufferObject ======================== */ void idIndexBuffer::FreeBufferObject() { if ( IsMapped() ) { UnmapBuffer(); } // if this is a sub-allocation inside a larger buffer, don't actually free anything. if ( OwnsBuffer() == false ) { ClearWithoutFreeing(); return; } if ( apiObject == NULL ) { return; } if ( r_showBuffers.GetBool() ) { idLib::Printf( "index buffer free %p, api %p (%i bytes)\n", this, GetAPIObject(), GetSize() ); } GLuint bufferObject = reinterpret_cast< GLuint >( apiObject ); qglDeleteBuffersARB( 1, & bufferObject ); ClearWithoutFreeing(); }
void GouraudRenderer::Draw() { assert(!IsMapped()); m_DeviceContext.DrawIndexed(m_IndexBuffer.GetNumNewElements(), m_IndexBuffer.GetFirstNewElementIndex(), 0); m_iNumDraws++; }
// KDE's kwin is Qt-centric so much than no normal method of fullscreen // mode will work with it. We have to carefully emulate the Qt way. static void wxSetKDEFullscreen(Display *display, Window rootWnd, Window w, bool fullscreen, wxRect *origRect) { long data[2]; unsigned lng; wxMAKE_ATOM(_NET_WM_WINDOW_TYPE, display); wxMAKE_ATOM(_NET_WM_WINDOW_TYPE_NORMAL, display); wxMAKE_ATOM(_KDE_NET_WM_WINDOW_TYPE_OVERRIDE, display); wxMAKE_ATOM(_NET_WM_STATE_STAYS_ON_TOP, display); if (fullscreen) { data[0] = _KDE_NET_WM_WINDOW_TYPE_OVERRIDE; data[1] = _NET_WM_WINDOW_TYPE_NORMAL; lng = 2; } else { data[0] = _NET_WM_WINDOW_TYPE_NORMAL; data[1] = None; lng = 1; } // it is necessary to unmap the window, otherwise kwin will ignore us: XSync(display, False); bool wasMapped = IsMapped(display, w); if (wasMapped) { XUnmapWindow(display, w); XSync(display, False); } XChangeProperty(display, w, _NET_WM_WINDOW_TYPE, XA_ATOM, 32, PropModeReplace, (unsigned char *) &data[0], lng); XSync(display, False); if (wasMapped) { XMapRaised(display, w); XSync(display, False); } wxWMspecSetState(display, rootWnd, w, fullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE, _NET_WM_STATE_STAYS_ON_TOP); XSync(display, False); if (!fullscreen) { // NB: like many other WMs, kwin ignores the first request for a window // position change after the window was mapped. This additional // move+resize event will ensure that the window is restored in // exactly the same position as before it was made fullscreen // (because wxTopLevelWindow::ShowFullScreen will call SetSize, thus // setting the position for the second time). XMoveResizeWindow(display, w, origRect->x, origRect->y, origRect->width, origRect->height); XSync(display, False); } }
bool InputMapper::IsMapped( StyleInput StyleI ) { GameInput GameI = GAMESTATE->m_pCurStyle->StyleInputToGameInput( StyleI ); return IsMapped( GameI ); }
bool CMemStream::IsEOF() const { n_assert(IsOpen() && !IsMapped() && Pos >= 0 && Pos <= DataSize); return Pos == DataSize; }
DXStagingTexture::~DXStagingTexture() { if (IsMapped()) DXStagingTexture::Unmap(); SAFE_RELEASE(m_tex); }