void setXSwapInterval(int interval)
{
if(glXSwapIntervalEXT)
{
DENG2_ASSERT(de::CanvasWindow::mainExists());
glXSwapIntervalEXT(QX11Info::display(), de::CanvasWindow::main().canvas().winId(), interval);
}
}
void attach(GLShader const *shader)
{
DENG2_ASSERT(shader->isReady());
alloc();
glAttachShader(name, shader->glName());
LIBGUI_ASSERT_GL_OK();
shaders.insert(holdRef(shader));
}
void assetAvailabilityChanged(String const &identifier, filesys::AssetObserver::Event event) override
{
LOG_RES_MSG("Model asset \"%s\" is now %s")
<< identifier
<< (event == filesys::AssetObserver::Added? "available" :
"unavailable");
if (event == filesys::AssetObserver::Added)
{
bank.add(identifier, App::asset(identifier).absolutePath("path"));
// Begin loading the model right away.
bank.load(identifier);
}
else
{
auto const &model = bank.model<render::Model const>(identifier);
// Unload programs used by the various rendering passes.
for (auto const &pass : model.passes)
{
DENG2_ASSERT(pass.program);
unloadProgram(*static_cast<Program *>(pass.program));
}
// Alternatively, the entire model may be using a single program.
if (model.passes.isEmpty())
{
if (model.program())
{
unloadProgram(*static_cast<Program *>(model.program()));
}
}
else
{
DENG2_ASSERT(!model.program());
}
bank.remove(identifier);
{
DENG2_GUARD(pendingModels);
pendingModels.value.remove(identifier);
}
}
}
void GLSubBuffer::setVertices(dsize count, void const *data)
{
DENG2_ASSERT(count <= d->hostRange.size());
dsize const elementSize = d->format.first->stride;
d->host->setData(elementSize * d->hostRange.start, data,
elementSize * count);
d->size = count;
}
angle_t Mobj_AimAtTarget(mobj_t *mob)
{
DENG2_ASSERT(mob);
if(auto const *target = mob->target)
{
return Mobj_AimAtPoint2(mob, target->origin, target->flags & MF_SHADOW);
}
return mob->angle;
}
void NativeFile::close()
{
DENG2_GUARD(this);
flush();
DENG2_ASSERT(!d->out);
d->closeInput();
}
void OperatorExpression::verifyAssignable(Value *value)
{
DENG2_ASSERT(value != 0);
if (!dynamic_cast<RefValue *>(value))
{
throw NotAssignableError("OperatorExpression::verifyAssignable",
"Cannot assign to: " + value->asText());
}
}
void GLShader::compile(Type shaderType, IByteArray const &source)
{
#ifndef LIBGUI_GLES2
// With non-ES OpenGL, ignore the precision attributes.
static QByteArray prefix("#ifndef GL_ES\n#define lowp\n#define mediump\n#define highp\n#endif\n");
#endif
DENG2_ASSERT(shaderType == Vertex || shaderType == Fragment);
setState(NotReady);
// Keep a copy of the source for possible recompilation.
d->compiledSource = source;
d->type = shaderType;
d->alloc();
// Additional predefined symbols for the shader.
QByteArray predefs;
if (shaderType == Vertex)
{
predefs = QByteArray("#define DENG_VERTEX_SHADER\n");
}
else
{
predefs = QByteArray("#define DENG_FRAGMENT_SHADER\n");
}
// Prepare the shader source. This would be the time to substitute any
// remaining symbols in the shader source.
Block src = prefixToSource(source, prefix + predefs);
char const *srcPtr = src.constData();
LIBGUI_GL.glShaderSource(d->name, 1, &srcPtr, 0);
LIBGUI_GL.glCompileShader(d->name);
// Check the compilation status.
GLint status;
LIBGUI_GL.glGetShaderiv(d->name, GL_COMPILE_STATUS, &status);
if (!status)
{
dint32 logSize = 0;
dint32 count = 0;
LIBGUI_GL.glGetShaderiv(d->name, GL_INFO_LOG_LENGTH, &logSize);
Block log(logSize);
LIBGUI_GL.glGetShaderInfoLog(d->name, logSize, &count, reinterpret_cast<GLchar *>(log.data()));
throw CompilerError("GLShader::compile",
"Compilation of " + String(d->type == Fragment? "fragment" : "vertex") +
" shader failed:\n" + log);
}
setState(Ready);
}
LogSink &LogSink::operator << (LogEntry const &entry)
{
DENG2_ASSERT(formatter());
foreach (String line, formatter()->logEntryToTextLines(entry))
{
*this << line;
}
return *this;
}
dd_bool Smoother_Evaluate(Smoother const *sm, coord_t *xyz)
{
DENG2_ASSERT(sm);
pos_t const *past = &sm->past;
pos_t const *now = &sm->now;
if(!Smoother_IsValid(sm))
return false;
if(sm->at < past->time)
{
// Before our time.
xyz[VX] = past->xyz[VX];
xyz[VY] = past->xyz[VY];
xyz[VZ] = past->xyz[VZ];
//LOGDEV_XVERBOSE("Smoother %p falling behind") << sm;
return true;
}
//DENG_ASSERT(sm->at <= now->time);
if(now->time <= past->time)
{
// Too far in the ever-shifting future.
xyz[VX] = now->xyz[VX];
xyz[VY] = now->xyz[VY];
xyz[VZ] = now->xyz[VZ];
//LOGDEV_XVERBOSE("Smoother %p stalling") << sm;
return true;
}
// We're somewhere between past and now.
float const t = (sm->at - past->time) / (now->time - past->time);
for(int i = 0; i < 3; ++i)
{
// Linear interpolation.
xyz[i] = now->xyz[i] * t + past->xyz[i] * (1-t);
}
/*#ifdef _DEBUG
{
float dt = sm->at - sm->prevAt;
//Smoother_Debug(sm);
if(dt > 0)
{
float diff[2] = { xyz[0] - sm->prevEval[0], xyz[1] - sm->prevEval[1] };
LOGDEV_MSG("Smoother_Evaluate: [%05.3f] diff = %06.3f %06.3f")
<< dt << diff[0]/dt << diff[1]/dt;
((Smoother *)sm)->prevEval[0] = xyz[0];
((Smoother *)sm)->prevEval[1] = xyz[1];
}
((Smoother *)sm)->prevAt = sm->at;
}
#endif*/
return true;
}
AABoxd Contact::objectBounds() const
{
switch(_type)
{
case ContactLumobj: return objectAs<Lumobj>().bounds();
case ContactMobj: return Mobj_Bounds(objectAs<mobj_t>());
default: break;
}
DENG2_ASSERT(false);
return AABoxd();
}
ddouble Contact::objectRadius() const
{
switch(_type)
{
case ContactLumobj: return objectAs<Lumobj>().radius();
case ContactMobj: return Mobj_VisualRadius(objectAs<mobj_t>());
default: break;
}
DENG2_ASSERT(false);
return 0;
}
inline Rule const &anchorPos(Rule::Semantic anchorInput)
{
if(anchorInput == Rule::AnchorX)
{
return *normalizedAnchorX;
}
else
{
DENG2_ASSERT(anchorInput == Rule::AnchorY);
return *normalizedAnchorY;
}
}
PathTree::Node &PathTree::insert(Path const &path)
{
DENG2_GUARD(this);
PathTree::Node *node = d->buildNodesForPath(path);
DENG2_ASSERT(node != 0);
// There is now one more unique path in the tree.
d->size++;
return *node;
}
void Counted::release() const
{
Counted const *c = (!_delegate? this : _delegate);
//qDebug() << "Counted" << c << typeid(*c).name() << "ref dec'd to" << c->_refCount - 1;
DENG2_ASSERT(c->_refCount > 0);
if(!--c->_refCount)
{
delete c;
}
}
Vector3d Contact::objectOrigin() const
{
switch(_type)
{
case ContactLumobj: return objectAs<Lumobj>().origin();
case ContactMobj: return Mobj_Origin(objectAs<mobj_t>());
default: break;
}
DENG2_ASSERT(false);
return Vector3d();
}
/// Sets the currently executed statement.
void setCurrent(Statement const *statement)
{
if (controlFlow.size())
{
evaluator.reset();
flow().setCurrent(statement);
}
else
{
DENG2_ASSERT(statement == NULL);
}
}
void GLSubBuffer::setBatchVertices(int batchIndex, dsize elementCount, void *data)
{
DENG2_ASSERT(d->batchIndexOffset >= 0);
dsize const elementSize = d->format.first->stride;
duint8 *elems = reinterpret_cast<duint8 *>(data);
for (dsize i = 0; i < elementCount; ++i)
{
*reinterpret_cast<float *>(elems + d->batchIndexOffset + i * elementSize)
= float(batchIndex);
}
setVertices(elementCount, data);
}
mobj_t *Mobj_LaunchMissileAtAngle2(mobj_t *mob, mobj_t *missile, angle_t angle,
coord_t const targetPos[], coord_t const sourcePos[], coord_t extraMomZ)
{
DENG2_ASSERT(mob);
if(missile)
{
// Remember the source (i.e., us) for tracking kills, etc...
missile->target = mob;
}
return P_LaunchMissile(missile, angle, targetPos, sourcePos, extraMomZ);
}
void writeMisc()
{
#if __JHEXEN__
beginSegment(ASEG_MISC);
for (int i = 0; i < MAXPLAYERS; ++i)
{
Writer_WriteInt32(writer, localQuakeHappening[i]);
}
#endif
#if __JDOOM__
DENG2_ASSERT(theBossBrain != 0);
theBossBrain->write(thisPublic);
#endif
}
void FoldPanelWidget::panelDismissed()
{
PanelWidget::panelDismissed();
if(d->title)
{
d->title->setOpacity(.8f, .5f);
}
content().notifySelfAndTree(&Widget::deinitialize);
DENG2_ASSERT(d->container == 0);
d->container = takeContent();
}
void T_BuildPillar(pillar_t *pillar)
{
DENG2_ASSERT(pillar);
// First, raise the floor
result_e res1 = T_MovePlane(pillar->sector, pillar->floorSpeed, pillar->floorDest, pillar->crush, 0, pillar->direction); // floorOrCeiling, direction
// Then, lower the ceiling
result_e res2 = T_MovePlane(pillar->sector, pillar->ceilingSpeed, pillar->ceilingDest, pillar->crush, 1, -pillar->direction);
if(res1 == pastdest && res2 == pastdest)
{
P_ToXSector(pillar->sector)->specialData = 0;
SN_StopSequenceInSec(pillar->sector);
P_NotifySectorFinished(P_ToXSector(pillar->sector)->tag);
Thinker_Remove(&pillar->thinker);
}
}
void writePolyobjs()
{
#if __JHEXEN__
beginSegment(ASEG_POLYOBJS);
Writer_WriteInt32(writer, numpolyobjs);
for (int i = 0; i < numpolyobjs; ++i)
{
Polyobj *po = Polyobj_ById(i);
DENG2_ASSERT(po != 0);
po->write(thisPublic);
}
// endSegment();
#endif
}
void AbstractLink::disconnect()
{
if (d->status != Disconnected)
{
DENG2_ASSERT(d->socket.get() != 0);
d->timeout = 0;
d->socket->close(); // emits signal
d->status = Disconnected;
QObject::disconnect(d->socket.get(), SIGNAL(addressResolved()), this, SIGNAL(addressResolved()));
QObject::disconnect(d->socket.get(), SIGNAL(connected()), this, SLOT(socketConnected()));
QObject::disconnect(d->socket.get(), SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
QObject::disconnect(d->socket.get(), SIGNAL(messagesReady()), this, SIGNAL(packetsReady()));
}
}
QVariant parseString()
{
QVarLengthArray<QChar, 1024> result;
QChar c = next();
DENG2_ASSERT(c == '\"');
forever
{
c = nextNoSkip();
if(c == '\\')
{
// Escape.
c = nextNoSkip();
if(c == '\"' || c == '\\' || c == '/')
result.append(c);
else if(c == 'b')
result.append('\b');
else if(c == 'f')
result.append('\f');
else if(c == 'n')
result.append('\n');
else if(c == 'r')
result.append('\r');
else if(c == 't')
result.append('\t');
else if(c == 'u')
{
QString code = source.mid(pos, 4);
pos += 4;
result.append(QChar(ushort(code.toLong(0, 16))));
}
else error("unknown escape sequence in string");
}
else if(c == '\"')
{
// End of string.
break;
}
else
{
result.append(c);
}
}
return QString(result.constData(), result.size());
}
~Impl()
{
qDeleteAll(eventHandlers);
// The base class will delete all children, but we need to deinitialize
// them first.
self().notifyTree(&Widget::deinitialize);
deinitBlur();
/*
* Deinitialization must occur before destruction so that GL resources
* are not leaked. Derived classes are responsible for deinitializing
* first before beginning destruction.
*/
#ifdef DENG2_DEBUG
if (inited) qDebug() << "GuiWidget" << thisPublic << self().name() << "is still inited!";
DENG2_ASSERT(!inited);
#endif
}
void buildSubspaceGeometries()
{
for(ConvexSubspaceProxy const &subspace : subspaces)
{
/// @todo Move BSP leaf construction here?
BspLeaf &bspLeaf = *subspace.bspLeaf();
subspace.buildGeometry(bspLeaf, *mesh);
// Account the new segments.
/// @todo Refactor away.
for(OrderedSegment const &oseg : subspace.segments())
{
if(oseg.segment->hasHEdge())
{
// There is now one more line segment.
segmentCount += 1;
}
}
}
/*
* Finalize the built geometry by adding a twin half-edge for any
* which don't yet have one.
*/
for(ConvexSubspaceProxy const &convexSet : subspaces)
for(OrderedSegment const &oseg : convexSet.segments())
{
LineSegmentSide *seg = oseg.segment;
if(seg->hasHEdge() && !seg->back().hasHEdge())
{
HEdge *hedge = &seg->hedge();
DENG2_ASSERT(!hedge->hasTwin());
// Allocate the twin from the same mesh.
hedge->setTwin(hedge->mesh().newHEdge(seg->back().from()));
hedge->twin().setTwin(hedge);
}
}
}
void createFileLogSink(bool truncate)
{
if (!outputPath.isEmpty())
{
File *existing = (!truncate? App::rootFolder().tryLocate<File>(outputPath) : nullptr);
if (!existing)
{
outputFile = &App::rootFolder().replaceFile(outputPath);
}
else
{
outputFile = existing;
}
outputFile->audienceForDeletion() += this;
// Add a sink for the file.
DENG2_ASSERT(!fileLogSink);
fileLogSink = new FileLogSink(*outputFile);
sinks.insert(fileLogSink);
}
}
/**
* Compose a new backing store with an optimal layout.
*/
void defragment()
{
DENG2_ASSERT(hasBacking());
IAllocator::Allocations const oldLayout = allocator->allocs();
if (!allocator->optimize())
{
// Optimization did not work out.
mayDefrag = false;
return;
}
Image defragged(QImage(QSize(backing.size().x, backing.size().y), backing.qtFormat()));
defragged.fill(Image::Color(0, 0, 0, 0));
// Copy all the images to their optimal places.
IAllocator::Allocations optimal = allocator->allocs();
DENG2_FOR_EACH(IAllocator::Allocations, i, optimal)
{
defragged.draw(backing.subImage(oldLayout[i.key()]),
i.value().topLeft);
}
bool LineEditWidget::handleEvent(Event const &event)
{
// There are only key press events.
DENG2_ASSERT(event.type() == Event::KeyPress);
KeyEvent const &ev = event.as<KeyEvent>();
bool eaten = true;
// Insert text?
if(!ev.text().isEmpty())
{
insert(ev.text());
}
else
{
// Control character.
eaten = handleControlKey(ev.key());
}
if(eaten) return true;
return TextWidget::handleEvent(event);
}
