bool isMirrored(TreeNode* l, TreeNode* r)
{
if(l == NULL ^ r == NULL)return false;
if(l != NULL)
return l->val == r->val &&isMirrored(l->left,r->right)&&isMirrored(l->right,r->left);
return true;
}
QRectF NSParser::readRect(Symbol* symbol, VariableList& variables)
{
QRectF r;
if (symbol->type == NON_TERMINAL)
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
Symbol* fixedSymbol = searchChild(symbol, SYM_FIXED_RECT);
if (fixedSymbol)
{
r = readFixedRect(fixedSymbol, variables);
switch(nt->ruleIndex)
{
case PROD_RECT_AUTO_REVERSED:
r = Tools::autoMirror(r, isMirrored(), getTableWidth());
break;
case PROD_RECT_REVERSED:
r = Tools::autoMirror(r, true, getTableWidth());
break;
case PROD_RECT:
break;
}
}
}
return r;
}
Tools::RPoint NSParser::readPoint(Symbol* symbol)
{
Tools::RPoint point;
if (symbol->type == NON_TERMINAL)
{
if (symbol->symbolIndex == SYM_FIXED_POINT)
point = readFixedPoint(symbol);
else
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
Symbol* fixedPointSymbol = searchChild(symbol, SYM_FIXED_POINT);
if (fixedPointSymbol)
{
point = readFixedPoint(fixedPointSymbol);
switch(nt->ruleIndex)
{
case PROD_POINT_AUTO_REVERSED:
point = Tools::autoMirror(point, isMirrored(), getTableWidth());
break;
case PROD_POINT_REVERSED:
point = Tools::autoMirror(point, true, getTableWidth());
break;
case PROD_POINT:
break;
}
}
}
}
return point;
}
double NSParser::readAngleInRadian(Symbol* symbol)
{
double value = 0.0;
if (symbol->type == NON_TERMINAL)
{
NonTerminal* nt = static_cast<NonTerminal*>(symbol);
Symbol* fixedSymbol = searchChild(symbol, SYM_FIXED_ANGLE);
if (fixedSymbol)
{
value = readFixedAngleInRadian(fixedSymbol);
switch(nt->ruleIndex)
{
case PROD_ANGLE_AUTO_REVERSED:
value = Tools::autoMirror(value, isMirrored());
break;
case PROD_ANGLE_REVERSED:
value = Tools::autoMirror(value, true);
break;
case PROD_ANGLE:
break;
}
}
else
{
value = readFixedAngleInRadian(symbol);
}
}
return value;
}
// Called every frame
void ARotatingGear::Tick( float DeltaTime )
{
Super::Tick( DeltaTime );
if(!active()){
return;
}
FRotator rotation = this->GetActorRotation();
rotation.Roll += DeltaTime * speed *(isMirrored()? 1 : -1);
this->SetActorRotation(rotation);
}
bool insertCompletedWord() {
if (completer->list->isVisible() && maxWritten>curStart && completer->list->currentIndex().isValid()) {
QDocumentCursor cursor=editor->cursor();
editor->document()->beginMacro();
QVariant v=completer->list->model()->data(completer->list->currentIndex(),Qt::DisplayRole);
if (!v.isValid() || !v.canConvert<CompletionWord>()) return false;
CompletionWord cw= v.value<CompletionWord>();
completer->listModel->incUsage(completer->list->currentIndex());
//int alreadyWrittenLen=editor->cursor().columnNumber()-curStart;
//remove current text for correct case
if(completer->forcedRef){
while(!cursor.atLineEnd() && cursor.nextChar()!='}')
cursor.deleteChar();
if(cursor.nextChar()=='}')
cursor.deleteChar();
}
if(isMirrored() && (cw.lines.first().startsWith("\\begin")||cw.lines.first().startsWith("\\end"))){
QString text=cw.lines.first();
int i=cursor.columnNumber()-curStart;
text.remove(0,i);
text.remove('}');
while(!cursor.atLineEnd() && cursor.nextChar()!='}'){
cursor.deleteChar();
}
insertText(text);
return true;
}
for (int i=maxWritten-cursor.columnNumber(); i>0; i--) cursor.deleteChar();
for (int i=cursor.columnNumber()-curStart; i>0; i--) cursor.deletePreviousChar();
if (!autoOverridenText.isEmpty()){
cursor.insertText(autoOverridenText);
cursor.movePosition(autoOverridenText.length(), QDocumentCursor::Left);
editor->resizeAutoOverridenPlaceholder(cursor, autoOverridenText.size());
autoOverridenText="";
}
//cursor.endEditBlock(); //doesn't work and lead to crash when auto indentation is enabled => TODO:figure out why
// cursor.setColumnNumber(curStart);
cw.insertAt(editor,&cursor,LatexCompleter::config && LatexCompleter::config->usePlaceholders,true);
editor->document()->endMacro();
return true;
}
return false;
}
void QSGDefaultRenderer::render()
{
#if defined (QML_RUNTIME_TESTING)
static bool dumpTree = qApp->arguments().contains(QLatin1String("--dump-tree"));
if (dumpTree) {
printf("\n\n");
QSGNodeDumper::dump(rootNode());
}
#endif
#ifdef RENDERER_DEBUG
debugTimer.invalidate();
debugTimer.start();
geometryNodesDrawn = 0;
materialChanges = 0;
#endif
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND);
glFrontFace(isMirrored() ? GL_CW : GL_CCW);
glDisable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthMask(true);
glDepthFunc(GL_GREATER);
#if defined(QT_OPENGL_ES)
glClearDepthf(0);
#else
glClearDepth(0);
#endif
glDisable(GL_SCISSOR_TEST);
glClearColor(m_clear_color.redF(), m_clear_color.greenF(), m_clear_color.blueF(), m_clear_color.alphaF());
#ifdef RENDERER_DEBUG
int debugtimeSetup = debugTimer.elapsed();
#endif
bindable()->clear(clearMode());
#ifdef RENDERER_DEBUG
int debugtimeClear = debugTimer.elapsed();
#endif
QRect r = viewportRect();
glViewport(r.x(), deviceRect().bottom() - r.bottom(), r.width(), r.height());
m_current_projection_matrix = projectionMatrix();
m_current_model_view_matrix.setToIdentity();
m_currentClip = 0;
glDisable(GL_STENCIL_TEST);
m_currentMaterial = 0;
m_currentProgram = 0;
m_currentMatrix = 0;
if (m_rebuild_lists) {
m_opaqueNodes.reset();
m_transparentNodes.reset();
m_currentRenderOrder = 1;
buildLists(rootNode());
m_rebuild_lists = false;
}
#ifdef RENDERER_DEBUG
int debugtimeLists = debugTimer.elapsed();
#endif
if (m_needs_sorting) {
if (!m_opaqueNodes.isEmpty()) {
qSort(&m_opaqueNodes.first(), &m_opaqueNodes.first() + m_opaqueNodes.size(),
m_sort_front_to_back
? nodeLessThanWithRenderOrder
: nodeLessThan);
}
m_needs_sorting = false;
}
#ifdef RENDERER_DEBUG
int debugtimeSorting = debugTimer.elapsed();
#endif
m_renderOrderMatrix.setToIdentity();
m_renderOrderMatrix.scale(1, 1, qreal(1) / m_currentRenderOrder);
glDisable(GL_BLEND);
glDepthMask(true);
#ifdef QML_RUNTIME_TESTING
if (m_render_opaque_nodes)
#endif
{
#if defined (QML_RUNTIME_TESTING)
if (dumpTree)
qDebug() << "Opaque Nodes:";
#endif
renderNodes(m_opaqueNodes);
}
#ifdef RENDERER_DEBUG
int debugtimeOpaque = debugTimer.elapsed();
int opaqueNodes = geometryNodesDrawn;
int opaqueMaterialChanges = materialChanges;
#endif
glEnable(GL_BLEND);
glDepthMask(false);
#ifdef QML_RUNTIME_TESTING
if (m_render_alpha_nodes)
#endif
{
#if defined (QML_RUNTIME_TESTING)
if (dumpTree)
qDebug() << "Alpha Nodes:";
#endif
renderNodes(m_transparentNodes);
}
#ifdef RENDERER_DEBUG
int debugtimeAlpha = debugTimer.elapsed();
#endif
if (m_currentProgram)
m_currentProgram->deactivate();
#ifdef RENDERER_DEBUG
if (debugTimer.elapsed() > DEBUG_THRESHOLD) {
printf(" --- Renderer breakdown:\n"
" - setup=%d, clear=%d, building=%d, sorting=%d, opaque=%d, alpha=%d\n"
" - material changes: opaque=%d, alpha=%d, total=%d\n"
" - geometry ndoes: opaque=%d, alpha=%d, total=%d\n",
debugtimeSetup,
debugtimeClear - debugtimeSetup,
debugtimeLists - debugtimeClear,
debugtimeSorting - debugtimeLists,
debugtimeOpaque - debugtimeSorting,
debugtimeAlpha - debugtimeOpaque,
opaqueMaterialChanges, materialChanges - opaqueMaterialChanges, materialChanges,
opaqueNodes, geometryNodesDrawn - opaqueNodes, geometryNodesDrawn);
}
#endif
}
