bool RenderFrameSet::userResize(MouseEvent* evt)
{
if (!m_isResizing) {
if (needsLayout())
return false;
if (evt->type() == eventNames().mousedownEvent && evt->button() == LeftButton) {
startResizing(m_cols, evt->pageX() - xPos());
startResizing(m_rows, evt->pageY() - yPos());
if (m_cols.m_splitBeingResized != noSplit || m_rows.m_splitBeingResized != noSplit) {
setIsResizing(true);
return true;
}
}
} else {
if (evt->type() == eventNames().mousemoveEvent || (evt->type() == eventNames().mouseupEvent && evt->button() == LeftButton)) {
continueResizing(m_cols, evt->pageX() - xPos());
continueResizing(m_rows, evt->pageY() - yPos());
if (evt->type() == eventNames().mouseupEvent && evt->button() == LeftButton) {
setIsResizing(false);
return true;
}
}
}
return false;
}
IntRect RenderReplaced::selectionRect()
{
if (!isSelected())
return IntRect();
if (!m_inlineBoxWrapper)
// We're a block-level replaced element. Just return our own dimensions.
return absoluteBoundingBoxRect();
RenderBlock* cb = containingBlock();
if (!cb)
return IntRect();
RootInlineBox* root = m_inlineBoxWrapper->root();
int selectionTop = root->selectionTop();
int selectionHeight = root->selectionHeight();
int selectionLeft = xPos();
int selectionRight = xPos() + width();
int absx, absy;
cb->absolutePosition(absx, absy);
if (cb->hasOverflowClip())
cb->layer()->subtractScrollOffset(absx, absy);
return IntRect(selectionLeft + absx, selectionTop + absy, selectionRight - selectionLeft, selectionHeight);
}
static void rectControl(FILE *fp, object ctl)
{
CTLTYPE_RECT_t v;
char *cp, name[81];
static int id = 1;
return;
gGetControlParameters(ctl, &v);
if (!strcmp(v.name, "STATIC"))
sprintf(name, "staticText%d", id++);
else
strcpy(name, v.name);
fprintf(fp, "createClassObject(mx.controls.Label, \"%s\", getNextHighestDepth(), {});\n", name);
fprintf(fp, "%s.move(%d * ScalingFactor, %d * ScalingFactor);\n", name, xPos(v.xPos), yPos(v.yPos));
fprintf(fp, "%s.setSize(%d * ScalingFactor, %d * ScalingFactor);\n", name, width(v.width), height(v.height));
fprintf(fp, "box(%d, %d, %d, %d);\n", yPos(v.yPos), xPos(v.xPos), width(v.width), height(v.height));
setFont(fp, ctl, name);
if (v.DT_Format & DT_CENTER)
fprintf(fp, "%s.setStyle(\"textAlign\", \"%s\");\n", name, "center");
else if (v.DT_Format & DT_RIGHT)
fprintf(fp, "%s.setStyle(\"textAlign\", \"%s\");\n", name, "right");
if (v.hidden == 'Y')
fprintf(fp, "%s.visible = false;\n", name);
/*
if (v.disabled == 'Y')
fprintf(fp, "%s.enabled = false;\n", name);
*/
cp = gStringValue(ctl);
fprintf(fp, "%s.text = \"%s\";\n", name, cp?cp:"");
fprintf(fp, "\n");
}
void RootInlineBox::placeEllipsis(const AtomicString& ellipsisStr, bool ltr, int blockEdge, int ellipsisWidth,
InlineBox* markupBox)
{
// Create an ellipsis box.
EllipsisBox* ellipsisBox = new (m_object->renderArena()) EllipsisBox(m_object, ellipsisStr, this,
ellipsisWidth - (markupBox ? markupBox->width() : 0),
yPos(), height(), baseline(), !prevRootBox(),
markupBox);
if (!gEllipsisBoxMap)
gEllipsisBoxMap = new EllipsisBoxMap();
gEllipsisBoxMap->add(this, ellipsisBox);
m_hasEllipsisBox = true;
if (ltr && (xPos() + width() + ellipsisWidth) <= blockEdge) {
ellipsisBox->m_x = xPos() + width();
return;
}
// Now attempt to find the nearest glyph horizontally and place just to the right (or left in RTL)
// of that glyph. Mark all of the objects that intersect the ellipsis box as not painting (as being
// truncated).
bool foundBox = false;
ellipsisBox->m_x = placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox);
}
int InlineTextBox::textPos() const
{
if (xPos() == 0)
return 0;
RenderBlock *blockElement = object()->containingBlock();
return direction() == RTL ? xPos() - blockElement->borderRight() - blockElement->paddingRight()
: xPos() - blockElement->borderLeft() - blockElement->paddingLeft();
}
void GameplayScreen::onEntry() {
b2Vec2 gravity(0.0f, -25.0);
m_world = std::make_unique<b2World>(gravity);
m_debugRenderer.init();
// Make the ground
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, -20.0f);
b2Body* groundBody = m_world->CreateBody(&groundBodyDef);
// Make the ground fixture
b2PolygonShape groundBox;
groundBox.SetAsBox(50.0f, 10.0f);
groundBody->CreateFixture(&groundBox, 0.0f);
// Load the texture
m_texture = Bengine::ResourceManager::getTexture("Assets/bricks_top.png");
// Make a bunch of boxes
std::mt19937 randGenerator;
std::uniform_real_distribution<float> xPos(-10.0, 10.0f);
std::uniform_real_distribution<float> yPos(-10.0, 25.0f);
std::uniform_real_distribution<float> size(0.5, 2.5f);
std::uniform_int_distribution<int> color(50, 255);
const int NUM_BOXES = 100;
for (int i = 0; i < NUM_BOXES; i++) {
Bengine::ColorRGBA8 randColor;
randColor.r = color(randGenerator);
randColor.g = color(randGenerator);
randColor.b = color(randGenerator);
randColor.a = 255;
Box newBox;
newBox.init(m_world.get(), glm::vec2(xPos(randGenerator), yPos(randGenerator)), glm::vec2(size(randGenerator), size(randGenerator)), m_texture, randColor, false);
m_boxes.push_back(newBox);
}
// Initialize spritebatch
m_spriteBatch.init();
// Shader init
// Compile our color shader
m_textureProgram.compileShaders("Shaders/textureShading.vert", "Shaders/textureShading.frag");
m_textureProgram.addAttribute("vertexPosition");
m_textureProgram.addAttribute("vertexColor");
m_textureProgram.addAttribute("vertexUV");
m_textureProgram.linkShaders();
// Init camera
m_camera.init(m_window->getScreenWidth(), m_window->getScreenHeight());
m_camera.setScale(32.0f);
// Init player
m_player.init(m_world.get(), glm::vec2(0.0f, 30.0f), glm::vec2(1.0f, 2.0f), Bengine::ColorRGBA8(255, 255, 255, 255));
}
void SpectrumWidget::paintBands( QPainter* p )
{
if ( m_type == AbsorptionSpectrum )
{
for ( double va = startValue; va <= endValue ; va += 0.1 )
{
int x = xPos( va );
p->setPen( linecolor( va ) );
p->drawLine( x,0,x, m_realHeight );
}
p->setPen( Qt::black );
}
int i = 0;
int x = 0;
int temp = 0;
for ( QValueList<Spectrum::band>::Iterator it = m_spectrum->bandlist()->begin();
it != m_spectrum->bandlist()->end();
++it )
{
if ( ( *it ).wavelength < startValue || ( *it ).wavelength > endValue )
continue;
x = xPos( ( *it ).wavelength );
temp = 0;
switch ( m_type )
{
case EmissionSpectrum:
p->setPen( linecolor( ( *it ).wavelength ) );
p->drawLine( x,0,x, m_realHeight-1 );
p->setPen( Qt::black );
// p->drawLine( x,m_realHeight,x, m_realHeight );
break;
case AbsorptionSpectrum:
p->setPen( Qt::black );
p->drawLine( x,0,x, m_realHeight-1 );
break;
}
i++;
}
}
IntRect RenderSVGInlineText::computeAbsoluteRectForRange(int startPos, int endPos)
{
IntRect rect;
RenderBlock* cb = containingBlock();
if (!cb || !cb->container())
return rect;
RenderSVGRoot* root = findSVGRootObject(parent());
if (!root)
return rect;
for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
rect.unite(box->selectionRect(0, 0, startPos, endPos));
// Mimic RenderBox::computeAbsoluteRepaintRect() functionality. But only the subset needed for SVG and respecting SVG transformations.
int x, y;
cb->container()->absolutePosition(x, y);
// Remove HTML parent translation offsets here! These need to be retrieved from the RenderSVGRoot object.
// But do take the containingBlocks's container position into account, ie. SVG text in scrollable <div>.
AffineTransform htmlParentCtm = root->RenderContainer::absoluteTransform();
FloatRect fixedRect(narrowPrecisionToFloat(rect.x() + x - xPos() - htmlParentCtm.e()), narrowPrecisionToFloat(rect.y() + y - yPos() - htmlParentCtm.f()), rect.width(), rect.height());
return enclosingIntRect(absoluteTransform().mapRect(fixedRect));
}
FloatRect RenderSVGText::relativeBBox(bool includeStroke) const
{
FloatRect repaintRect;
for (InlineRunBox* runBox = firstLineBox(); runBox; runBox = runBox->nextLineBox()) {
ASSERT(runBox->isInlineFlowBox());
InlineFlowBox* flowBox = static_cast<InlineFlowBox*>(runBox);
for (InlineBox* box = flowBox->firstChild(); box; box = box->nextOnLine())
repaintRect.unite(FloatRect(box->xPos(), box->yPos(), box->width(), box->height()));
}
// SVG needs to include the strokeWidth(), not the textStrokeWidth().
if (includeStroke && style()->svgStyle()->hasStroke()) {
float strokeWidth = SVGRenderStyle::cssPrimitiveToLength(this, style()->svgStyle()->strokeWidth(), 0.0f);
#if ENABLE(SVG_FONTS)
const Font& font = style()->font();
if (font.primaryFont()->isSVGFont()) {
float scale = font.unitsPerEm() > 0 ? font.size() / font.unitsPerEm() : 0.0f;
if (scale != 0.0f)
strokeWidth /= scale;
}
#endif
repaintRect.inflate(strokeWidth);
}
repaintRect.move(xPos(), yPos());
return repaintRect;
}
void CRepositoryBrowser::SaveDividerPosition()
{
RECT rc;
GetDlgItem(IDC_REPOTREE)->GetClientRect(&rc);
CRegDWORD xPos(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\RepobrowserDivider"));
xPos = rc.right - rc.left;
}
//--------------------------------------------------------------------------------------------------
/// Draw the axis labels
//--------------------------------------------------------------------------------------------------
void OverlayNavigationCube::renderAxisLabels(OpenGLContext* oglContext, bool software, const MatrixState& matrixState)
{
// Multiply with 1.08 will slightly pull the labels away from the corresponding arrow head
Vec3f xPos(1.08f, 0, 0);
Vec3f yPos(0, 1.08f, 0);
Vec3f zPos(0, 0, 1.08f);
DrawableText drawableText;
drawableText.setFont(m_font.p());
drawableText.setCheckPosVisible(false);
drawableText.setDrawBorder(false);
drawableText.setDrawBackground(false);
drawableText.setVerticalAlignment(TextDrawer::CENTER);
drawableText.setTextColor(m_textColor);
if (!m_xLabel.isEmpty()) drawableText.addText(m_xLabel, xPos);
if (!m_yLabel.isEmpty()) drawableText.addText(m_yLabel, yPos);
if (!m_zLabel.isEmpty()) drawableText.addText(m_zLabel, zPos);
// Do the actual rendering
// -----------------------------------------------
if (software)
{
drawableText.renderSoftware(oglContext, matrixState);
}
else
{
ref<ShaderProgram> textShader = oglContext->resourceManager()->getLinkedTextShaderProgram(oglContext);
drawableText.render(oglContext, textShader.p(), matrixState);
}
}
void RootInlineBox::paintCustomHighlight(RenderObject::PaintInfo& paintInfo, int tx, int ty, const AtomicString& highlightType)
{
if (!object()->shouldPaintWithinRoot(paintInfo) || object()->style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseForeground)
return;
// Get the inflated rect so that we can properly hit test.
FloatRect rootRect(tx + xPos(), ty + selectionTop(), width(), selectionHeight());
FloatRect inflatedRect = object()->document()->frame()->customHighlightLineRect(highlightType, rootRect);
if (inflatedRect.intersects(paintInfo.rect))
object()->document()->frame()->paintCustomHighlight(highlightType, rootRect, rootRect, false, true);
}
void PrimitiveMeshHelper::WireAxis(float size) {
DrawCmdData<Vertex> cmd;
cmd.draw_mode = kDrawLines;
VertexList &vert_list = cmd.vertex_list;
//vertex list 생성
vec3 xPos(size, 0, 0);
vec3 yPos(0, size, 0);
vec3 zPos(0, 0, size);
vec3 zero(0, 0, 0);
sora::vec4ub red(255, 0, 0, 255);
sora::vec4ub green(0, 255, 0, 255);
sora::vec4ub blue(0, 0, 255, 255);
{
// x axis - r
Vertex x_zero_vert;
x_zero_vert.color = red;
x_zero_vert.pos = zero;
vert_list.push_back(x_zero_vert);
Vertex x_one_vert;
x_one_vert.color = red;
x_one_vert.pos = xPos;
vert_list.push_back(x_one_vert);
}
{
//y axis - g
Vertex zero_vert;
zero_vert.color = green;
zero_vert.pos = zero;
vert_list.push_back(zero_vert);
Vertex y_vert;
y_vert.color = green;
y_vert.pos = yPos;
vert_list.push_back(y_vert);
}
{
//z axis - b
Vertex zero_vert;
zero_vert.color = blue;
zero_vert.pos = zero;
vert_list.push_back(zero_vert);
Vertex z_vert;
z_vert.color = blue;
z_vert.pos = zPos;
vert_list.push_back(z_vert);
}
this->cmd_list_->push_back(cmd);
}
int DiagramItem::avgChildPos() const
{
DiagramItem *di;
int c=children->count();
if (c==0) // no children -> don't move
return xPos();
if ((di=children->getFirst())->isInList()) // children should be in a list
return di->xPos();
if (c&1) // odd number of children -> get pos of middle child
return children->at(c/2)->xPos();
else // even number of children -> get middle of most middle children
return (children->at(c/2-1)->xPos()+children->at(c/2)->xPos())/2;
}
void InlineTextBox::paintCustomHighlight(int tx, int ty, const AtomicString& type)
{
Frame* frame = object()->document()->frame();
if (!frame)
return;
Page* page = frame->page();
if (!page)
return;
RootInlineBox* r = root();
FloatRect rootRect(tx + r->xPos(), ty + selectionTop(), r->width(), selectionHeight());
FloatRect textRect(tx + xPos(), rootRect.y(), width(), rootRect.height());
page->chrome()->client()->paintCustomHighlight(object()->node(), type, textRect, rootRect, true, false);
}
void RenderSVGTSpan::absoluteRects(Vector<IntRect>& rects, int, int, bool)
{
InlineRunBox* firstBox = firstLineBox();
SVGRootInlineBox* rootBox = firstBox ? static_cast<SVGInlineTextBox*>(firstBox)->svgRootInlineBox() : 0;
RenderObject* object = rootBox ? rootBox->object() : 0;
if (!object)
return;
int xRef = object->xPos() + xPos();
int yRef = object->yPos() + yPos();
for (InlineRunBox* curr = firstBox; curr; curr = curr->nextLineBox()) {
FloatRect rect(xRef + curr->xPos(), yRef + curr->yPos(), curr->width(), curr->height());
rects.append(enclosingIntRect(absoluteTransform().mapRect(rect)));
}
}
FloatRect RenderSVGText::relativeBBox(bool includeStroke) const
{
FloatRect repaintRect;
for (InlineRunBox* runBox = firstLineBox(); runBox; runBox = runBox->nextLineBox()) {
ASSERT(runBox->isInlineFlowBox());
InlineFlowBox* flowBox = static_cast<InlineFlowBox*>(runBox);
for (InlineBox* box = flowBox->firstChild(); box; box = box->nextOnLine())
repaintRect.unite(FloatRect(box->xPos(), box->yPos(), box->width(), box->height()));
}
// SVG needs to include the strokeWidth(), not the textStrokeWidth().
if (includeStroke && style()->svgStyle()->hasStroke())
repaintRect.inflate(narrowPrecisionToFloat(KSVGPainterFactory::cssPrimitiveToLength(this, style()->svgStyle()->strokeWidth(), 0.0)));
repaintRect.move(xPos(), yPos());
return repaintRect;
}
void RenderSVGTextPath::absoluteQuads(Vector<FloatQuad>& quads, bool)
{
InlineRunBox* firstBox = firstLineBox();
SVGRootInlineBox* rootBox = firstBox ? static_cast<SVGInlineTextBox*>(firstBox)->svgRootInlineBox() : 0;
RenderObject* object = rootBox ? rootBox->object() : 0;
if (!object)
return;
int xRef = object->xPos() + xPos();
int yRef = object->yPos() + yPos();
for (InlineRunBox* curr = firstBox; curr; curr = curr->nextLineBox()) {
FloatRect rect(xRef + curr->xPos(), yRef + curr->yPos(), curr->width(), curr->height());
// FIXME: broken with CSS transforms
quads.append(absoluteTransform().mapRect(rect));
}
}
//------------------------------ PUBLIC SLOTS ----------------------------------
void ViewPort::showPage(int p_number)
{
curPixmapNumber = p_number;
scene->clear();
qreal xPos(5);
qreal yPos(5);
if (m_thumb){
// Режим наготков :) рисуем все а стр с номером p_number выделяем
for (int i=0;i<m_pixmap_list.size();i++){
if (i == curPixmapNumber){
yPos = addPairItem(xPos,yPos,i,true);
}else{
yPos = addPairItem(xPos,yPos,i,false);
}
}
}else{
// Рисуем одну страницу на весь экран
if (m_pixmap_list.contains(curPixmapNumber)){
yPos = addPairItem(xPos,yPos,curPixmapNumber,false);
}
}
}
void GameplayScreen::onEntry() {
b2Vec2 gravity(0.0f, -25.0);
m_world = std::make_unique<b2World>(gravity);
m_debugRenderer.init();
// Make the ground
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, -20.0f);
b2Body* groundBody = m_world->CreateBody(&groundBodyDef);
// Make the ground fixture
b2PolygonShape groundBox;
groundBox.SetAsBox(50.0f, 10.0f);
groundBody->CreateFixture(&groundBox, 0.0f);
// Load the texture
m_texture = Bengine::ResourceManager::getTexture("Assets/bricks_top.png");
// Make a bunch of boxes
std::mt19937 randGenerator;
std::uniform_real_distribution<float> xPos(-10.0, 10.0f);
std::uniform_real_distribution<float> yPos(-10.0, 25.0f);
std::uniform_real_distribution<float> size(0.5, 2.5f);
std::uniform_int_distribution<int> color(50, 255);
const int NUM_BOXES = 10;
for (int i = 0; i < NUM_BOXES; i++) {
Bengine::ColorRGBA8 randColor;
randColor.r = color(randGenerator);
randColor.g = color(randGenerator);
randColor.b = color(randGenerator);
randColor.a = 255;
Box newBox;
newBox.init(m_world.get(), glm::vec2(xPos(randGenerator), yPos(randGenerator)), glm::vec2(size(randGenerator), size(randGenerator)), m_texture, randColor, false);
m_boxes.push_back(newBox);
}
// Initialize spritebatch
m_spriteBatch.init();
// Shader init
// Compile our texture
m_textureProgram.compileShaders("Shaders/textureShading.vert", "Shaders/textureShading.frag");
m_textureProgram.addAttribute("vertexPosition");
m_textureProgram.addAttribute("vertexColor");
m_textureProgram.addAttribute("vertexUV");
m_textureProgram.linkShaders();
// Compile our light shader
m_lightProgram.compileShaders("Shaders/lightShading.vert", "Shaders/lightShading.frag");
m_lightProgram.addAttribute("vertexPosition");
m_lightProgram.addAttribute("vertexColor");
m_lightProgram.addAttribute("vertexUV");
m_lightProgram.linkShaders();
// Init camera
m_camera.init(m_window->getScreenWidth(), m_window->getScreenHeight());
m_camera.setScale(32.0f);
// Init player
m_player.init(m_world.get(), glm::vec2(0.0f, 30.0f), glm::vec2(2.0f), glm::vec2(1.0f, 1.8f), Bengine::ColorRGBA8(255, 255, 255, 255));
// Init the UI
m_gui.init("GUI");
m_gui.loadScheme("TaharezLook.scheme");
m_gui.setFont("DejaVuSans-10");
CEGUI::PushButton* testButton = static_cast<CEGUI::PushButton*>(m_gui.createWidget("TaharezLook/Button", glm::vec4(0.5f, 0.5f, 0.1f, 0.05f), glm::vec4(0.0f), "TestButton"));
testButton->setText("Hello World!");
CEGUI::Combobox* TestCombobox = static_cast<CEGUI::Combobox*>(m_gui.createWidget("TaharezLook/Combobox", glm::vec4(0.2f, 0.2f, 0.1f, 0.05f), glm::vec4(0.0f), "TestCombobox"));
m_gui.setMouseCursor("TaharezLook/MouseArrow");
m_gui.showMouseCursor();
SDL_ShowCursor(0);
}
VisiblePosition RenderContainer::positionForCoordinates(int x, int y)
{
// no children...return this render object's element, if there is one, and offset 0
if (!m_firstChild)
return VisiblePosition(element(), 0, DOWNSTREAM);
if (isTable() && element()) {
int right = contentWidth() + borderRight() + paddingRight() + borderLeft() + paddingLeft();
int bottom = contentHeight() + borderTop() + paddingTop() + borderBottom() + paddingBottom();
if (x < 0 || x > right || y < 0 || y > bottom) {
if (x <= right / 2)
return VisiblePosition(Position(element(), 0));
else
return VisiblePosition(Position(element(), maxDeepOffset(element())));
}
}
// Pass off to the closest child.
int minDist = INT_MAX;
RenderObject* closestRenderer = 0;
int newX = x;
int newY = y;
if (isTableRow()) {
newX += xPos();
newY += yPos();
}
for (RenderObject* renderer = m_firstChild; renderer; renderer = renderer->nextSibling()) {
if (!renderer->firstChild() && !renderer->isInline() && !renderer->isBlockFlow()
|| renderer->style()->visibility() != VISIBLE)
continue;
int top = borderTop() + paddingTop() + (isTableRow() ? 0 : renderer->yPos());
int bottom = top + renderer->contentHeight();
int left = borderLeft() + paddingLeft() + (isTableRow() ? 0 : renderer->xPos());
int right = left + renderer->contentWidth();
if (x <= right && x >= left && y <= top && y >= bottom) {
if (renderer->isTableRow())
return renderer->positionForCoordinates(x + newX - renderer->xPos(), y + newY - renderer->yPos());
return renderer->positionForCoordinates(x - renderer->xPos(), y - renderer->yPos());
}
// Find the distance from (x, y) to the box. Split the space around the box into 8 pieces
// and use a different compare depending on which piece (x, y) is in.
IntPoint cmp;
if (x > right) {
if (y < top)
cmp = IntPoint(right, top);
else if (y > bottom)
cmp = IntPoint(right, bottom);
else
cmp = IntPoint(right, y);
} else if (x < left) {
if (y < top)
cmp = IntPoint(left, top);
else if (y > bottom)
cmp = IntPoint(left, bottom);
else
cmp = IntPoint(left, y);
} else {
if (y < top)
cmp = IntPoint(x, top);
else
cmp = IntPoint(x, bottom);
}
int x1minusx2 = cmp.x() - x;
int y1minusy2 = cmp.y() - y;
int dist = x1minusx2 * x1minusx2 + y1minusy2 * y1minusy2;
if (dist < minDist) {
closestRenderer = renderer;
minDist = dist;
}
}
if (closestRenderer)
return closestRenderer->positionForCoordinates(newX - closestRenderer->xPos(), newY - closestRenderer->yPos());
return VisiblePosition(element(), 0, DOWNSTREAM);
}
void VisibilityLayout::layout(GraphAttributes &GA, const UpwardPlanRep &UPROrig)
{
UpwardPlanRep UPR = UPROrig;
//clear some data
for(edge e : GA.constGraph().edges) {
GA.bends(e).clear();
}
int minGridDist = 1;
for(node v : GA.constGraph().nodes) {
if (minGridDist < max(GA.height(v), GA.width(v)))
minGridDist = (int) max(GA.height(v), GA.width(v));
}
minGridDist = max(minGridDist*2+1, m_grid_dist);
CombinatorialEmbedding &gamma = UPR.getEmbedding();
//add edge (s,t)
adjEntry adjSrc = nullptr;
for(adjEntry adj : UPR.getSuperSource()->adjEntries) {
if (gamma.rightFace(adj) == gamma.externalFace())
adjSrc = adj;
break;
}
OGDF_ASSERT(adjSrc != nullptr);
edge e_st = UPR.newEdge(adjSrc, UPR.getSuperSink()); // on the right
gamma.computeFaces();
gamma.setExternalFace(gamma.rightFace(e_st->adjSource()));
constructVisibilityRepresentation(UPR);
// the preliminary postion
NodeArray<int> xPos(UPR);
NodeArray<int> yPos(UPR);
// node Position
for(node v : UPR.nodes) {
NodeSegment vVis = nodeToVis[v];
int x = (int) (vVis.x_l + vVis.x_r)/2 ; // median positioning
xPos[v] = x;
yPos[v] = vVis.y;
if (UPR.original(v) != nullptr) {
node vOrig = UPR.original(v);
//final position
GA.x(vOrig) = x * minGridDist;
GA.y(vOrig) = vVis.y * minGridDist;
}
}
//compute bendpoints
for(edge e : GA.constGraph().edges) {
const List<edge> &chain = UPR.chain(e);
for(edge eUPR : chain) {
EdgeSegment eVis = edgeToVis[eUPR];
if (chain.size() == 1) {
if ((yPos[eUPR->target()] - yPos[eUPR->source()]) > 1) {
DPoint p1(eVis.x*minGridDist, (yPos[eUPR->source()]+1)*minGridDist);
DPoint p2(eVis.x*minGridDist, (yPos[eUPR->target()]-1)*minGridDist);
GA.bends(e).pushBack(p1);
if (yPos[eUPR->source()]+1 != yPos[eUPR->target()]-1)
GA.bends(e).pushBack(p2);
}
}
else {
//short edge
if ((yPos[eUPR->target()] - yPos[eUPR->source()]) == 1) {
if (UPR.original(eUPR->target()) == nullptr) {
node tgtUPR = eUPR->target();
DPoint p(xPos[tgtUPR]*minGridDist, yPos[tgtUPR]*minGridDist);
GA.bends(e).pushBack(p);
}
}
//long edge
else {
DPoint p1(eVis.x*minGridDist, (yPos[eUPR->source()]+1)*minGridDist);
DPoint p2(eVis.x*minGridDist, (yPos[eUPR->target()]-1)*minGridDist);
GA.bends(e).pushBack(p1);
if (yPos[eUPR->source()]+1 != yPos[eUPR->target()]-1)
GA.bends(e).pushBack(p2);
if (UPR.original(eUPR->target()) == nullptr) {
node tgtUPR = eUPR->target();
DPoint p(xPos[tgtUPR]*minGridDist, yPos[tgtUPR]*minGridDist);
GA.bends(e).pushBack(p);
}
}
}
}
DPolyline &poly = GA.bends(e);
DPoint pSrc(GA.x(e->source()), GA.y(e->source()));
DPoint pTgt(GA.x(e->target()), GA.y(e->target()));
poly.normalize(pSrc, pTgt);
}
}
void LevelOneScreen::initLevel(){
std::mt19937 randomEngine((unsigned int)time(NULL));
std::uniform_int_distribution<int> randMonster(0, MONSTER_KIND-1);
std::uniform_int_distribution<int> randomMovement(0,1000);
std::uniform_int_distribution<int> randomItemNum(1, 10);
std::uniform_int_distribution<int> randomItemKind(0, ITEM_KIND - 1);
glm::vec4 playerArea;
_level = std::make_unique<LevelManager>("Levels/Version1/level1.txt");
// Objects Creation code goes here.
std::uniform_int_distribution<int> yPos(3, _level->getHeight() - 3);
std::uniform_int_distribution<int> xPos(3, _level->getWidth() - 3);
//Monsters
int i = 0;
int count = 2;
int numMonster = _level->getNumMonsters();
_monsters.reserve(numMonster);
while(i < numMonster){
int temp = randMonster(randomEngine);
int x = xPos(randomEngine);
int y = yPos(randomEngine);
int movement = ((randomMovement(randomEngine) * count) % MAX_MOVEMENT + count/2);
if (_level->getSymbol(x, y) == '.'){
glm::vec2 pos = glm::vec2(x * TILE_WIDTH, y * TILE_WIDTH);
if (temp == 0){
_monsters.push_back(new Werewolf);
_monsters.back()->init(4, 2, pos, 10);
}
else if (temp == 1){
_monsters.push_back(new Orga);
_monsters.back()->init(3, 3, pos, 30);
}
else{
_monsters.push_back(new Wolf);
_monsters.back()->init(2, 2, pos, movement);
//std::cout << "Movement : " << movement << std::endl;
}
i++;
}
count++;
}
//Testing
/*_monsters.push_back(new Wolf);
_monsters.back()->init(3, 3, glm::vec2(500, 1000));*/
int numItem = randomItemNum(randomEngine);
int j = 0;
while (j < numItem) {
int temp = randomItemKind(randomEngine);
int x = xPos(randomEngine);
int y = yPos(randomEngine);
if (_level->getSymbol(x, y) == '.') {
glm::vec2 pos = glm::vec2(x * TILE_WIDTH, y * TILE_WIDTH);
switch (temp) {
case 0:
_items.push_back(new BigPotion);
break;
case 1:
_items.push_back(new SmallPotion);
break;
case 2:
_items.push_back(new GoodMeat);
break;
case 3:
_items.push_back(new BadMeat);
break;
case 4:
_items.push_back(new GoodFish);
break;
case 5:
_items.push_back(new BadFish);
}
_items.back()->init(pos);
j++;
}
}
//Initialize player.
_player = Player::getInstance();
_player->init(_level->getStartPlayerPosition(), PLAYER_SPEED);
//Testing for weapon.
_items.push_back(new Sword);
_items.back()->init(glm::vec2(200, 1000));
}
void Mirror::printPos() const
{
post("/MirrorPos: %f, %f, %f", xPos(), yPos(), zPos());
}
void GameplayScreen::init()
{
b2Vec2 gravity(0.0f, -50.0f);
//create up world
mWorld = std::make_unique<b2World>(gravity);
//Add Ground body
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, -20.0f); // units of meters
b2Body* groundBody = mWorld->CreateBody(&groundBodyDef);
//Shape is a polygon, fixture keeps them together
b2PolygonShape groundBox;
groundBox.SetAsBox(50.0f, 10.0f);
groundBody->CreateFixture(&groundBox, 0.0f);
//Load texture
mTexture = WebEngine::ResourceManager::getTexture("Assets/bricks_top.png");
WebEngine::ColorRGBA8 color(255, 0, 0, 255);
//Add a bunch of boxes
std::mt19937 randGenerator(time(nullptr));
std::uniform_real_distribution<float> xPos(-10.0f, 10.0f);
std::uniform_real_distribution<float> yPos(-15.0f, 15.0f);
std::uniform_real_distribution<float> size(0.5f, 2.5f);
std::uniform_int_distribution<unsigned int> randColor(0, 255);
const int numBoxes = 20;
for (int i = 0; i < numBoxes; i++)
{
WebEngine::ColorRGBA8 color(randColor(randGenerator), randColor(randGenerator), randColor(randGenerator), 255);
Box newBox;
newBox.init(mWorld.get(), glm::vec2(xPos(randGenerator), yPos(randGenerator)), glm::vec2(size(randGenerator), size(randGenerator)), mTexture, color);
//Box memory can be discraded because the important bits are stored in the world
mBoxes.push_back(newBox);
}
//Initialize shaders
//Compile texture shader
mTextureProgram.compileShaders("Shaders/textureShading.vert", "Shaders/textureShading.frag");
mTextureProgram.addAttribute("vertexPosition");
mTextureProgram.addAttribute("vertexColor");
mTextureProgram.addAttribute("vertexUV");
mTextureProgram.linkShaders();
//Compile light shader
mLightProgram.compileShaders("Shaders/lightShading.vert", "Shaders/lightShading.frag");
mLightProgram.addAttribute("vertexPosition");
mLightProgram.addAttribute("vertexColor");
mLightProgram.addAttribute("vertexUV");
mLightProgram.linkShaders();
mDebugRenderer.init();
m_CameraController.init(&mCamera, mTime);
//Initialize spritebatch
mSpriteBatch.init();
//Init camera
mCamera.init(mWindow->getScreenWidth(), mWindow->getScreenHeight());
mCamera.setScale(32.0f); //32 pixels per meter, good scale
mPlayer.init(mWorld.get(), glm::vec2(0.0f, 30.0f), glm::vec2(1.0f), glm::vec2(0.5f, 1.0f), WebEngine::ColorRGBA8(255, 255, 255, 255));
}
void iEyeDotWindow::setDotPos(int x, int y)
{
qreal xPos((x - m_region.left()) * m_hscale);
qDebug() << xPos;
m_dot->setPos(QPointF(std::max(qreal(0), qreal(xPos)), qreal(y)));
}
