/*
========================
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);
}
