void Player::flush(Map &map) { Sifteo::Int2 accel = _mainCube.cube()->physicalAccel().xy(); if (accel.x > 10 || accel.x < -10) _char._dir.x = accel.x; else _char._dir.x = 0; if (accel.y > 10 || accel.y < -10) _char._dir.y = accel.y; else _char._dir.y = 0; //_char._dir = accel; _mainCube.drawer().updateCharacters(_x, _y); int prevX = _x; int prevY = _y; _x = (_char.x() + 16) / 128; _y = (_char.y() + 16) / 128; if (_y != prevY || _x != prevX) { drawer().clean(); map.printCase(*this); drawer().initSort(); } _mainCube.drawer().flush(); }
// drawStuff just takes in a picking flag, and no curSS static void drawStuff(bool picking) { // Declare an empty uniforms Uniforms uniforms; // Get your projection matrix into proj mat as usual ... // send proj. matrix to be stored by uniforms, // as opposed to the current vtx shader sendProjectionMatrix(uniforms, projmat); // get your eyeRbt, invEyeRbt and stuff as usual ... // get the eye space coordinates of the two light as usual // suppose they are stored as Cvec3 eyeLight1 and eyeLight2 ... // send the eye space coordinates of lights to uniforms uniforms.put("uLight", eyeLight1); uniforms.put("uLight2", eyeLight2); if (!picking) { // initialize the drawer with our uniforms, as opposed to curSS Drawer drawer(invEyeRbt, uniforms); // draw as before g_world->accept(drawer); ... // draw arcball if neccessary }
void CBasicTreeDrawer::Draw(float treeDistance, bool drawReflection) { glBindTexture(GL_TEXTURE_2D, treetex); glEnable(GL_TEXTURE_2D); glEnable(GL_ALPHA_TEST); ISky::SetupFog(); glColor4f(1, 1, 1, 1); const int cx = (int)(camera->GetPos().x / (SQUARE_SIZE * TREE_SQUARE_SIZE)); const int cy = (int)(camera->GetPos().z / (SQUARE_SIZE * TREE_SQUARE_SIZE)); CBasicTreeSquareDrawer drawer(this, cx, cy, treeDistance * SQUARE_SIZE * TREE_SQUARE_SIZE); readMap->GridVisibility (camera, TREE_SQUARE_SIZE, drawer.treeDistance * 2.0f, &drawer); const int startClean = lastListClean * 20 % nTrees; const int endClean = gs->frameNum * 20 % nTrees; lastListClean = gs->frameNum; if (startClean > endClean) { for (TreeSquareStruct* pTSS = (trees + startClean); pTSS < (trees + nTrees); ++pTSS) { if ((pTSS->lastSeen < (gs->frameNum - 50)) && pTSS->dispList) { glDeleteLists(pTSS->dispList, 1); pTSS->dispList = 0; } if ((pTSS->lastSeenFar < (gs->frameNum - 50)) && pTSS->farDispList) { glDeleteLists(pTSS->farDispList, 1); pTSS->farDispList = 0; } } for (TreeSquareStruct* pTSS = trees; pTSS < (trees + endClean); ++pTSS) { if ((pTSS->lastSeen < (gs->frameNum - 50)) && pTSS->dispList) { glDeleteLists(pTSS->dispList, 1); pTSS->dispList = 0; } if ((pTSS->lastSeenFar < (gs->frameNum - 50)) && pTSS->farDispList) { glDeleteLists(pTSS->farDispList, 1); pTSS->farDispList = 0; } } } else { for (TreeSquareStruct* pTSS = (trees + startClean); pTSS < (trees + endClean); ++pTSS) { if (pTSS->lastSeen<gs->frameNum-50 && pTSS->dispList) { glDeleteLists(pTSS->dispList,1); pTSS->dispList=0; } if ((pTSS->lastSeenFar < (gs->frameNum - 50)) && pTSS->farDispList) { glDeleteLists(pTSS->farDispList, 1); pTSS->farDispList = 0; } } } glDisable(GL_FOG); glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); }
void MeshPicking::process() { utilgl::activateAndClearTarget(outport_, ImageType::ColorDepthPicking); MeshDrawerGL drawer(meshInport_.getData().get()); shader_.activate(); shader_.setUniform("pickingColor_", picking_.getPickingObject()->getPickingColor()); const auto& ct = meshInport_.getData()->getCoordinateTransformer(camera_.get()); mat4 dataToClip = ct.getWorldToClipMatrix() * glm::translate(position_.get()) * ct.getDataToWorldMatrix(); shader_.setUniform("dataToClip", dataToClip); { utilgl::GlBoolState depthTest(GL_DEPTH_TEST, true); utilgl::CullFaceState culling(cullFace_.get()); utilgl::DepthFuncState depthfunc(GL_ALWAYS); drawer.draw(); } shader_.deactivate(); utilgl::deactivateCurrentTarget(); compositePortsToOutport(outport_, ImageType::ColorDepthPicking, imageInport_); }
bool QgsRasterLayerRenderer::render() { if ( !mRasterViewPort ) return true; // outside of layer extent - nothing to do //R->draw( mPainter, mRasterViewPort, &mMapToPixel ); QTime time; time.start(); // // // The goal here is to make as many decisions as possible early on (outside of the rendering loop) // so that we can maximise performance of the rendering process. So now we check which drawing // procedure to use : // QgsRasterProjector *projector = mPipe->projector(); // TODO add a method to interface to get provider and get provider // params in QgsRasterProjector if ( projector ) { projector->setCRS( mRasterViewPort->mSrcCRS, mRasterViewPort->mDestCRS ); } // Drawer to pipe? QgsRasterIterator iterator( mPipe->last() ); QgsRasterDrawer drawer( &iterator ); drawer.draw( mPainter, mRasterViewPort, mMapToPixel ); QgsDebugMsg( QString( "total raster draw time (ms): %1" ).arg( time.elapsed(), 5 ) ); return true; }
void Application::run() { ra->init(); EventManager::getInstance()->subscribe(this); MapFileReader reader("res/map.txt"); graph = reader.getGraph(); graph->updateNeighborhood(); GraphDrawer drawer(graph, ra); Cell::Coord p1, p2; p1.x = 0; p1.y = 0; p2.x = graph->getWidth()-1; p2.y = graph->getHeight()-1; Dijkstra *astar = new Dijkstra(graph, p1, p2); drawer.createEdges(); drawer.createNodes(); astar->start(); while (running) { EventManager::getInstance()->captureEvent(); Application::lockRessources(); ra->display(); Application::unlockRessources(); } }
/** * Draws the listbox if owner draw. Calls the drawer pointer to function */ bool CListBox::draw(LPDRAWITEMSTRUCT dis) { if(drawer) { return drawer(getItem(dis->itemID), dis, this); } return false; }
void QvisKeyframePlotRangeWidget::mousePressEvent(QMouseEvent *e) { if(drawer()->handleRect(endpoints[0],2).contains(e->pos())) { movingPoint = 0; update(); } else if(drawer()->handleRect(endpoints[1],2).contains(e->pos())) { movingPoint = 1; update(); } else movingPoint = -1; setMouseTracking(movingPoint>=0); }
void ClassGraph::updateNodeSizes() { mPad.x = mNullDrawer->getPad(); mPad.y = mPad.x; ClassDrawer drawer(*mNullDrawer); for(auto &node : mNodes) { GraphSize size = drawer.drawNode(node); node.setSize(size); } }
void ObstacleVisualizer<PointT>::drawShapes( std::vector<ObjectModelPtr> obstacles, pcl::visualization::PCLVisualizer& viewer) { // Remove all old shapes... viewer.removeAllShapes(); // ...and draw all the new ones. ModelDrawer drawer(viewer); size_t const sz = obstacles.size(); for (size_t i = 0; i < sz; ++i) { obstacles[i]->accept(drawer); } }
void QvisKeyframePlotRangeWidget::mouseMoveEvent(QMouseEvent *e) { if(movingPoint != -1) { int id = drawer()->xToFrame(e->pos().x()); if(id != -1 && endpoints[movingPoint] != id) { endpoints[movingPoint] = id; update(); } } }
void CUserList::OnPaint() { CPaintDC dc(this); // device context for painting // TODO: 在此处添加消息处理程序代码 // 不为绘图消息调用 CDialog::OnPaint() RECT rc; GetClientRect(&rc); CDrawer drawer(dc.GetSafeHdc(), &rc); HGDIOBJ hfont = drawer.SelectObject(theApp.mpRoomData->m_Font.GetSafeHandle()); drawer.FillSolidRect(&rc, RGB(239, 247, 255)); if(mpTreeCtrl) mpTreeCtrl->Paint(drawer.GetSafeHdc()); drawer.SelectObject(hfont); }
void ciMain::run() { // Camera: Camera[0] = new gaCamera(Engine); Camera[1] = new gaCamera(Engine); setCameraActive(0); // Mesh: Mesh = Engine->makeMesh(); gaMeshDrawer drawer(Mesh); drawer.drawGrid(10, 10); //drawer.drawRandomWalk1(); //drawer.drawRandomWalk2(); drawer.drawCursor(); //drawer.drawTriangle(); // Entitys: EntityMax = 0; Entity[EntityMax++] = Engine->makeEntity(Mesh); Entity[EntityMax++] = Engine->makeEntity(Mesh); EntityMatrix[1].P.set(0.5f, 0, 0.5f); Entity[1]->setMatrix(EntityMatrix[1]); // Show: Engine->setInput(this); Engine->setTicker(this); Engine->run(); // Cleanup: delete Camera[0]; delete Camera[1]; for(int i = 0; i < EntityMax; i++) delete Entity[i]; delete Mesh; }
int main(int argc, char **argv) { // load in the mesh MT_Vector3 mesh_min,mesh_max; LOD_Decimation_InfoPtr LOD_info = NewVertsFromFile("beethoven.ply",mesh_min,mesh_max); // load the mesh data int load_result = LOD_LoadMesh(LOD_info); int preprocess_result = LOD_PreprocessMesh(LOD_info); if (!(load_result && preprocess_result)) { cout << " could not load mesh! \n"; return 0; } // make and install a mouse handler MEM_SmartPtr<MyGlutMouseHandler> mouse_handler(MyGlutMouseHandler::New()); GlutMouseManager::Instance()->InstallHandler(mouse_handler); // instantiate the drawing class MEM_SmartPtr<GlutMeshDrawer> drawer(GlutMeshDrawer::New()); GlutDrawManager::Instance()->InstallDrawer(drawer); drawer->SetLODInfo(LOD_info); drawer->SetMouseHandler(mouse_handler); // make and install a keyhandler MEM_SmartPtr<MyGlutKeyHandler> key_handler(MyGlutKeyHandler::New(LOD_info)); GlutKeyboardManager::Instance()->InstallHandler(key_handler); LOD_GhostTestApp LOD_app; LOD_app.InitApp(); init(mesh_min,mesh_max); LOD_app.Run(); return 0; /* ANSI C requires main to return int. */ }
void ComponentDiagram::updatePositionsInGraph(DiagramDrawer &nullDrawer) { ComponentDrawer drawer(*this, nullDrawer); int pad = nullDrawer.getPad(1) * 2; enum NodeVectorsIndex { NVI_ExtPackage, NVI_Lib, NVI_Exec, NVI_NumVecs }; NodeVectors nodeVectors[NVI_NumVecs]; int nodeSpacingY = 0; for(auto &node : mComponentGraph.getNodes()) { GraphSize size = drawer.drawNode(node); node.setSize(size); if(nodeSpacingY == 0) nodeSpacingY = size.y * 2; if(node.getComponentNodeType() == ComponentNode::CNT_ExternalPackage) { nodeVectors[NVI_ExtPackage].add(&node, size.x, pad); } else { if(node.getComponentType() == ComponentTypesFile::CT_StaticLib) { nodeVectors[NVI_Lib].add(&node, size.x, pad); } else { nodeVectors[NVI_Exec].add(&node, size.x, pad); } } } int biggestX = 0; for(auto const &vec : nodeVectors) { if(vec.nodesSizeX > biggestX) biggestX = vec.nodesSizeX; } for(size_t veci=0; veci<sizeof(nodeVectors)/sizeof(nodeVectors[0]); veci++) { int yPos = static_cast<int>(veci) * nodeSpacingY; int xPos = (biggestX - static_cast<int>(nodeVectors[veci].nodesSizeX)) / 2; for(auto const &node : nodeVectors[veci].nodeVector) { node->setPos(GraphPoint(xPos, yPos)); xPos += node->getRect().size.x + pad; } } }
T* make_widget(WRATHLayer *layer, WRATHShaderBrushSourceHoard &hoard, WRATHDrawType tp, WRATHImage *image) { T *widget; WRATHBrush brush(image); brush.flip_image_y(true); //the Node class has the static method set_shader_brush //to set the shader code associated for the brush //for details, see \ref WRATHLayerItemNodeBase::set_shader_brush T::Node::set_shader_brush(brush); //use the WRATHShaderBrushSourceHoard, m_shader_hoard, //to fetch/get the shader for the brush. const WRATHShaderSpecifier *sp; sp=&hoard.fetch(brush, WRATHBaseSource::mediump_precision, WRATHShaderBrushSourceHoard::linear_brush_mapping); //now pass that as the drawer for the rectwidget, //use the shader of sp and augment the GL state //with the brush WRATHRectItemTypes::Drawer drawer(sp, ExampleRectAttributePacker::fetch(), tp); //we need to add the brush draw state (i.e. what image, gradient, etc) //to the draw state of the item. hoard.add_state(brush, drawer.m_draw_passes[0].m_draw_state); widget=WRATHNew T(layer, drawer); /* packing of attribute data takes place on set_parameters, until this is called the rect does not have it's attribute data set. */ widget->set_parameters(ExampleRectAttributePacker::rect_properties()); //some properties of the brush need to be transmitted //to the node of the widget, set_from_brush() does that widget->set_from_brush(brush); return widget; }
void xlui::label::draw_event(xlui::draw_event &event) { xlui::drawer drawer(this); xlui::theme *t = xlui::app::get_theme(); t->draw_control(this, xlui::CT_Label, drawer); // // xlui::image image("/home/heresy/Bilder/27791.jpg"); // image = image.scale(100, 100); // drawer.image(image, 0, 0); // // // // xlui::image image2("/home/heresy/Bilder/27791.jpg"); // image2 = image2.scale(200,0,10,10,100,100); // drawer.image(image2, 0, 0); }
void NBodySim::save_image(unsigned int seq) const { bitmap_image image(m_img_width, m_img_height); image_drawer drawer(image); float max_val = std::max(std::max(std::fabs(m_max_initcharge), std::fabs(m_min_initcharge)), m_max_initmass); float norm = 255.0f / max_val; image.set_all_channels(0); for (unsigned int p = 0; p < m_n_particles; ++p) { float xr = std::round(m_x[p]); float yr = std::round(m_y[p]); if (0 <= xr && xr <= m_img_width - 1 && 0 <= yr && yr <= m_img_height - 1) { if (m_q[p] >= 0.0f) { drawer.pen_color(std::round(m_q[p] * norm), std::round(m_m[p] * norm), 0); } else if (m_q[p] < 0.0f) { drawer.pen_color(0, std::round(m_m[p] * norm), std::round(-m_q[p] * norm)); } drawer.plot_pixel(xr, yr); } } std::ostringstream oss; oss << m_img_prefix << std::setfill('0') << std::setw(5) << seq << ".bmp"; image.save_image(oss.str()); }
void TFGrayscaleAlphaPainter1D::updateFunctionView_(TFWorkCopy::Ptr workCopy) { viewFunctionBuffer_ = QPixmap(area_.width(), area_.height()); viewFunctionBuffer_.fill(noColor_); QPainter drawer(&viewFunctionBuffer_); drawer.setClipRect(inputArea_.x(), inputArea_.y(), inputArea_.width() + 1, inputArea_.height() + 1); TF::PaintingPoint origin(inputArea_.x(), inputArea_.y()); TF::Coordinates coordsBegin(1, 0); TF::Coordinates coordsEnd(1, 0); TF::Color colorBegin; TF::Color colorEnd; int x1, y1, x2, y2; for(int i = 0; i < inputArea_.width() - 1; ++i) { coordsBegin[0] = i; coordsEnd[0] = i + 1; colorBegin = workCopy->getColor(coordsBegin); colorEnd = workCopy->getColor(coordsEnd); x1 = origin.x + coordsBegin[0]; x2 = origin.x + coordsEnd[0]; y1 = origin.y + (1 - colorBegin.component1)*inputArea_.height(); y2 = origin.y + (1 - colorEnd.component1)*inputArea_.height(); drawer.setPen(component1_); drawer.drawLine(x1, y1, x2, y2); y1 = origin.y + (1 - colorBegin.alpha)*inputArea_.height(); y2 = origin.y + (1 - colorEnd.alpha)*inputArea_.height(); drawer.setPen(alpha_); drawer.drawLine(x1, y1, x2, y2); } }
void QgsRasterLayerRenderer::Feedback::onNewData() { if ( !renderPartialOutput() ) return; // we were not asked for partial renders and we may not have a temporary image for overwriting... // update only once upon a time // (preview itself takes some time) if ( mLastPreview.isValid() && mLastPreview.msecsTo( QTime::currentTime() ) < mMinimalPreviewInterval ) return; // TODO: update only the area that got new data QgsDebugMsg( QString( "new raster preview! %1" ).arg( mLastPreview.msecsTo( QTime::currentTime() ) ) ); QTime t; t.start(); QgsRasterBlockFeedback feedback; feedback.setPreviewOnly( true ); feedback.setRenderPartialOutput( true ); QgsRasterIterator iterator( mR->mPipe->last() ); QgsRasterDrawer drawer( &iterator ); drawer.draw( mR->mPainter, mR->mRasterViewPort, mR->mMapToPixel, &feedback ); QgsDebugMsg( QString( "total raster preview time: %1 ms" ).arg( t.elapsed() ) ); mLastPreview = QTime::currentTime(); }
void QvisKeyframePlotRangeWidget::paintEvent(QPaintEvent *event) { QPainter p(this); drawer()->drawPlotRange(&p, rect(), endpoints[0], endpoints[1], true, movingPoint); }
void xlui::radio_button::draw_event(xlui::draw_event &event) { xlui::drawer drawer(this); xlui::theme *t = xlui::app::get_theme(); t->draw_control(this, CT_RadioButton, drawer); }
void xlui::push_button::draw_event(xlui::draw_event &event) { xlui::drawer drawer(this); xlui::theme *t = xlui::app::get_theme(); t->draw_control(this, xlui::CT_PushButton, drawer); }
void ClassDiagram::drawDiagram(DiagramDrawer &diagDrawer) { ClassDrawer drawer(*this, diagDrawer); drawer.setZoom(getDesiredZoom()); drawer.drawDiagram(mClassGraph); }
void CAdvTreeDrawer::Draw(float treeDistance, bool drawReflection) { const int activeFarTex = (camera->forward.z < 0.0f)? treeGen->farTex[0]: treeGen->farTex[1]; const bool drawDetailed = ((treeDistance >= 4.0f) || drawReflection); CBaseGroundDrawer* gd = readmap->GetGroundDrawer(); Shader::IProgramObject* treeShader = NULL; #define L mapInfo->light glEnable(GL_ALPHA_TEST); glEnable(GL_TEXTURE_2D); if (globalRendering->drawFog) { glFogfv(GL_FOG_COLOR, mapInfo->atmosphere.fogColor); glEnable(GL_FOG); } if (shadowHandler->shadowsLoaded && !gd->DrawExtraTex()) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, activeFarTex); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, shadowHandler->shadowTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA); treeShader = treeShaders[TREE_PROGRAM_DIST_SHADOW]; treeShader->Enable(); if (globalRendering->haveGLSL) { treeShader->SetUniformMatrix4fv(7, false, &shadowHandler->shadowMatrix.m[0]); treeShader->SetUniform4fv(8, &(shadowHandler->GetShadowParams().x)); } else { treeShader->SetUniformTarget(GL_FRAGMENT_PROGRAM_ARB); treeShader->SetUniform4f(10, L.groundAmbientColor.x, L.groundAmbientColor.y, L.groundAmbientColor.z, 1.0f); treeShader->SetUniform4f(11, 0.0f, 0.0f, 0.0f, 1.0f - (sky->GetLight()->GetGroundShadowDensity() * 0.5f)); treeShader->SetUniformTarget(GL_VERTEX_PROGRAM_ARB); glMatrixMode(GL_MATRIX0_ARB); glLoadMatrixf(shadowHandler->shadowMatrix.m); glMatrixMode(GL_MODELVIEW); } } else { glBindTexture(GL_TEXTURE_2D, activeFarTex); } const int cx = int(camera->pos.x / (SQUARE_SIZE * TREE_SQUARE_SIZE)); const int cy = int(camera->pos.z / (SQUARE_SIZE * TREE_SQUARE_SIZE)); CAdvTreeSquareDrawer drawer(this, cx, cy, treeDistance * SQUARE_SIZE * TREE_SQUARE_SIZE, drawDetailed); GML_STDMUTEX_LOCK(tree); // Draw oldTreeDistance = treeDistance; // draw far-trees using map-dependent grid-visibility readmap->GridVisibility(camera, TREE_SQUARE_SIZE, drawer.treeDistance * 2.0f, &drawer); if (drawDetailed) { // draw near-trees const int xstart = std::max( 0, cx - 2); const int xend = std::min(gs->mapx / TREE_SQUARE_SIZE - 1, cx + 2); const int ystart = std::max( 0, cy - 2); const int yend = std::min(gs->mapy / TREE_SQUARE_SIZE - 1, cy + 2); if (shadowHandler->shadowsLoaded && !gd->DrawExtraTex()) { treeShader->Disable(); treeShader = treeShaders[TREE_PROGRAM_NEAR_SHADOW]; treeShader->Enable(); if (globalRendering->haveGLSL) { treeShader->SetUniformMatrix4fv(7, false, &shadowHandler->shadowMatrix.m[0]); treeShader->SetUniform4fv(8, &(shadowHandler->GetShadowParams().x)); } glActiveTexture(GL_TEXTURE1); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, treeGen->barkTex); glActiveTexture(GL_TEXTURE0); } else { glBindTexture(GL_TEXTURE_2D, treeGen->barkTex); treeShader = treeShaders[TREE_PROGRAM_NEAR_BASIC]; treeShader->Enable(); if (!globalRendering->haveGLSL) { #define MX (gs->pwr2mapx * SQUARE_SIZE) #define MY (gs->pwr2mapy * SQUARE_SIZE) treeShader->SetUniformTarget(GL_VERTEX_PROGRAM_ARB); treeShader->SetUniform4f(15, 1.0f / MX, 1.0f / MY, 1.0f / MX, 1.0f); #undef MX #undef MY } } if (globalRendering->haveGLSL) { treeShader->SetUniform3fv(0, &camera->right[0]); treeShader->SetUniform3fv(1, &camera->up[0]); treeShader->SetUniform2f(5, 0.20f * (1.0f / MAX_TREE_HEIGHT), 0.85f); } else { treeShader->SetUniformTarget(GL_VERTEX_PROGRAM_ARB); treeShader->SetUniform3f(13, camera->right.x, camera->right.y, camera->right.z); treeShader->SetUniform3f( 9, camera->up.x, camera->up.y, camera->up.z ); treeShader->SetUniform4f(11, L.groundSunColor.x, L.groundSunColor.y, L.groundSunColor.z, 0.85f); treeShader->SetUniform4f(14, L.groundAmbientColor.x, L.groundAmbientColor.y, L.groundAmbientColor.z, 0.85f); treeShader->SetUniform4f(12, 0.0f, 0.0f, 0.0f, 0.20f * (1.0f / MAX_TREE_HEIGHT)); // w = alpha/height modifier } glAlphaFunc(GL_GREATER, 0.5f); glDisable(GL_BLEND); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); varr = GetVertexArray(); varr->Initialize(); static FadeTree fadeTrees[3000]; FadeTree* pFT = fadeTrees; for (TreeSquareStruct* pTSS = trees + ystart * treesX; pTSS <= trees + yend * treesX; pTSS += treesX) { for (TreeSquareStruct* tss = pTSS + xstart; tss <= pTSS + xend; ++tss) { tss->lastSeen = gs->frameNum; varr->EnlargeArrays(12 * tss->trees.size(), 0, VA_SIZE_T); //!alloc room for all tree vertexes for (std::map<int, TreeStruct>::iterator ti = tss->trees.begin(); ti != tss->trees.end(); ++ti) { const TreeStruct* ts = &ti->second; const float3 pos(ts->pos); if (!camera->InView(pos + float3(0.0f, MAX_TREE_HEIGHT / 2.0f, 0.0f), MAX_TREE_HEIGHT / 2.0f)) { continue; } const float camDist = (pos - camera->pos).SqLength(); int type = ts->type; float dy = 0.0f; unsigned int displist; if (type < 8) { dy = 0.5f; displist = treeGen->pineDL + type; } else { type -= 8; dy = 0.0f; displist = treeGen->leafDL + type; } if (camDist < (SQUARE_SIZE * SQUARE_SIZE * 110 * 110)) { // draw detailed near-distance tree (same as mid-distance trees without alpha) treeShader->SetUniform3f(((globalRendering->haveGLSL)? 2: 10), pos.x, pos.y, pos.z); glCallList(displist); } else if (camDist < (SQUARE_SIZE * SQUARE_SIZE * 125 * 125)) { // draw mid-distance tree const float relDist = (pos.distance(camera->pos) - SQUARE_SIZE * 110) / (SQUARE_SIZE * 15); treeShader->SetUniform3f(((globalRendering->haveGLSL)? 2: 10), pos.x, pos.y, pos.z); glAlphaFunc(GL_GREATER, 0.8f + relDist * 0.2f); glCallList(displist); glAlphaFunc(GL_GREATER, 0.5f); // save for second pass pFT->pos = pos; pFT->deltaY = dy; pFT->type = type; pFT->relDist = relDist; ++pFT; } else { // draw far-distance tree DrawTreeVertex(varr, pos, type * 0.125f, dy, false); } } } } // reset the world-offset treeShader->SetUniform3f(((globalRendering->haveGLSL)? 2: 10), 0.0f, 0.0f, 0.0f); // draw trees that have been marked as falling for (std::list<FallingTree>::iterator fti = fallingTrees.begin(); fti != fallingTrees.end(); ++fti) { const float3 pos = fti->pos - UpVector * (fti->fallPos * 20); if (camera->InView(pos + float3(0.0f, MAX_TREE_HEIGHT / 2, 0.0f), MAX_TREE_HEIGHT / 2.0f)) { const float ang = fti->fallPos * PI; const float3 yvec(fti->dir.x * sin(ang), cos(ang), fti->dir.z * sin(ang)); const float3 zvec((yvec.cross(float3(-1.0f, 0.0f, 0.0f))).ANormalize()); const float3 xvec(yvec.cross(zvec)); CMatrix44f transMatrix(pos, xvec, yvec, zvec); glPushMatrix(); glMultMatrixf(&transMatrix[0]); int type = fti->type; int displist = 0; if (type < 8) { displist = treeGen->pineDL + type; } else { type -= 8; displist = treeGen->leafDL + type; } glCallList(displist); glPopMatrix(); } } if (shadowHandler->shadowsLoaded && !gd->DrawExtraTex()) { treeShader->Disable(); treeShader = treeShaders[TREE_PROGRAM_DIST_SHADOW]; treeShader->Enable(); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, activeFarTex); glActiveTexture(GL_TEXTURE0); } else { treeShader->Disable(); glBindTexture(GL_TEXTURE_2D, activeFarTex); } // draw far-distance trees varr->DrawArrayT(GL_QUADS); // draw faded mid-distance trees for (FadeTree* pFTree = fadeTrees; pFTree < pFT; ++pFTree) { varr = GetVertexArray(); varr->Initialize(); varr->CheckInitSize(12 * VA_SIZE_T); DrawTreeVertex(varr, pFTree->pos, pFTree->type * 0.125f, pFTree->deltaY, false); glAlphaFunc(GL_GREATER, 1.0f - (pFTree->relDist * 0.5f)); varr->DrawArrayT(GL_QUADS); } } if (shadowHandler->shadowsLoaded && !gd->DrawExtraTex()) { treeShader->Disable(); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE); } else { glBindTexture(GL_TEXTURE_2D, 0); } glDisable(GL_TEXTURE_2D); glDisable(GL_FOG); glDisable(GL_ALPHA_TEST); // clean out squares from memory that are no longer visible const int startClean = lastListClean * 20 % (nTrees); const int endClean = gs->frameNum * 20 % (nTrees); lastListClean = gs->frameNum; if (startClean > endClean) { for (TreeSquareStruct* pTSS = trees + startClean; pTSS < trees + nTrees; ++pTSS) { if ((pTSS->lastSeen < gs->frameNum - 50) && pTSS->displist) { glDeleteLists(pTSS->displist, 1); pTSS->displist = 0; } if ((pTSS->lastSeenFar < gs->frameNum - 50) && pTSS->farDisplist) { glDeleteLists(pTSS->farDisplist, 1); pTSS->farDisplist = 0; } } for (TreeSquareStruct* pTSS = trees; pTSS < trees + endClean; ++pTSS) { if ((pTSS->lastSeen < gs->frameNum - 50) && pTSS->displist) { glDeleteLists(pTSS->displist, 1); pTSS->displist = 0; } if ((pTSS->lastSeenFar < gs->frameNum - 50) && pTSS->farDisplist) { glDeleteLists(pTSS->farDisplist, 1); pTSS->farDisplist = 0; } } } else { for (TreeSquareStruct* pTSS = trees + startClean; pTSS < trees + endClean; ++pTSS) { if ((pTSS->lastSeen < gs->frameNum - 50) && pTSS->displist) { glDeleteLists(pTSS->displist, 1); pTSS->displist = 0; } if ((pTSS->lastSeenFar < gs->frameNum - 50) && pTSS->farDisplist) { glDeleteLists(pTSS->farDisplist, 1); pTSS->farDisplist = 0; } } } #undef L }
void ATOM_CellData::onPaint (ATOM_WidgetDrawClientEvent *event) { ATOM_STACK_TRACE(ATOM_CellData::onPaint); ATOM_Rect2Di outRect(ATOM_Point2Di(0, 0), event->canvas->getSize()); ATOM_Rect2Di inRect(_frameOffset, _frameOffset, outRect.size.w-_frameOffset*2, outRect.size.h-_frameOffset*2); bool inCD = (ATOM_INVALID_IMAGEID != _cooldownImageId) && _cooldownMax; if (_frameImageId != ATOM_INVALID_IMAGEID) { ATOM_GUIImage *image = getValidImage (_frameImageId); image->draw (event->state, event->canvas, outRect); } if (_clientImageId != ATOM_INVALID_IMAGEID) { ATOM_GUIImage *image = getValidImage (_clientImageId); if (!image) { image = ATOM_GUIImageList::getDefaultImageList().getImage (ATOM_IMAGEID_WINDOW_BKGROUND); ATOM_ASSERT(image); } if(_customColor) { image->draw (event->state, event->canvas, inRect, &_customColor); } else { image->draw (event->state, event->canvas, inRect); } } if (!_caption.empty()) { if (_textDirty) { calcTextLayout (); _textDirty = false; } ATOM_GUICanvas::DrawTextInfo info; info.textObject = _text.get(); info.textString = _text->getString(); info.font = _text->getFont(); info.x = _textPosition.x; info.y = _textPosition.y; info.shadowOffsetX = 0; info.shadowOffsetY = 0; info.textColor = getFontColor(); info.outlineColor = _widgetFontOutLineColor; info.shadowColor = 0; info.underlineColor = _underlineColor; info.flags = ATOM_GUICanvas::DRAWTEXT_TEXTOBJECT; if(_widgetFontOutLineColor.getByteA()) { info.flags |= ATOM_GUICanvas::DRAWTEXT_OUTLINE; } if(_underlineColor.getByteA()) { info.flags |= ATOM_GUICanvas::DRAWTEXT_UNDERLINE; } event->canvas->drawTextEx(&info); //event->canvas->drawText (_text.get(), _textPosition.x, _textPosition.y, getFontColor()); } //»æÖÆϱê×ÖÌå if (!_subscriptStr.empty()) { if (_subscirptTextDirty) { calcSubscriptTextLayout(); _subscirptTextDirty = false; } ATOM_GUICanvas::DrawTextInfo info; info.textObject = _subscriptText.get(); info.textString = _subscriptText->getString(); info.font = _subscriptText->getFont(); info.x = _subscriptTextPosition.x; info.y = _subscriptTextPosition.y; info.shadowOffsetX = 0; info.shadowOffsetY = 0; info.textColor = getFontColor(); info.outlineColor = _widgetFontOutLineColor; info.shadowColor = 0; info.underlineColor = _underlineColor; info.flags = ATOM_GUICanvas::DRAWTEXT_TEXTOBJECT; if(_widgetFontOutLineColor.getByteA()) { info.flags |= ATOM_GUICanvas::DRAWTEXT_OUTLINE; } if(_underlineColor.getByteA()) { info.flags |= ATOM_GUICanvas::DRAWTEXT_UNDERLINE; } event->canvas->drawTextEx(&info); //event->canvas->drawText (_text.get(), _textPosition.x, _textPosition.y, getFontColor()); } //»æÖÆϱêͼƬ if(_subscriptImageId != ATOM_INVALID_IMAGEID) { ATOM_GUIImage *image = getValidImage (_subscriptImageId); if(!image) { image = ATOM_GUIImageList::getDefaultImageList().getImage(ATOM_IMAGEID_WINDOW_BKGROUND); ATOM_ASSERT(image); } image->draw(event->state,event->canvas,ATOM_Rect2Di(inRect.point.x+_subscriptRect.point.x, inRect.point.y+_subscriptRect.point.y,_subscriptRect.size.w,_subscriptRect.size.h)); } if (_selectImageId != ATOM_INVALID_IMAGEID) { #if 1 ATOM_GUIImage *image = getValidImage (_selectImageId); #else const ATOM_GUIImageList *imagelist = getValidImageList (); ATOM_GUIImage *image = imagelist->getImage (_selectImageId); #endif if (!image) { image = ATOM_GUIImageList::getDefaultImageList().getImage (ATOM_IMAGEID_WINDOW_BKGROUND); ATOM_ASSERT(image); } image->draw (event->state, event->canvas, outRect); } // //bool inCD = (ATOM_INVALID_IMAGEID != _cooldownImageId) && _cooldownMax; //// »CELL±³¾° //if(cell->_texture.pointer) //{ // unsigned color = inCD ? 0xFF808080 : 0xFFFFFFFF; // canvas->drawTexturedRectEx(ATOM_Rect2Di(x*(xCellWidth+_xSpace), y*(yCellWidth+_ySpace), xCellWidth, yCellWidth), color, cell->_texture.pointer, cell->_region, false); //} //else if (_clientImageId != ATOM_INVALID_IMAGEID) //{ // imageDefault->draw (event->state, event->canvas, ATOM_Rect2Di(x*(xCellWidth+_xSpace), y*(yCellWidth+_ySpace), xCellWidth, yCellWidth)); //} //if(cell->_text.pointer) //{ // const char* str = cell->_text->getString(); // if (strcmp (str, "")) // { // ATOM_FontHandle font = ATOM_GUIFont::getFontHandle (getFont()); // int charmargin = ATOM_GUIFont::getFontCharMargin (getFont()); // int charset = ATOM_GUIFont::getFontCharSet (getFont()); // ATOM_SetCharMargin (charmargin); // int l, t, w, h; // ATOM_CalcStringBounds (font, charset, str, strlen(str), &l, &t, &w, &h); // canvas->drawText (cell->_text.pointer, x*(xCellWidth+_xSpace), y*(yCellWidth+_ySpace)-t, _fontColor); // } //} // »CD if(inCD) { #if 1 ATOM_GUIImage *image = getValidImage (_cooldownImageId); #else ATOM_GUIImage* image = getValidImageList()->getImage (_cooldownImageId); #endif if(image) { ATOM_Texture* texture = image->getTexture(WST_NORMAL); if(texture) { ATOM_CircleDrawer drawer(event->canvas, texture); drawer.DrawRemove(inRect, float(_cooldown)/float(_cooldownMax)); } } #if 0 char buffer[256]; sprintf (buffer, "%d", _cooldown); event->canvas->drawText (buffer, ATOM_GUIFont::getFontHandle(ATOM_GUIFont::getDefaultFont(10, 0)), 0, 0, 0xFFFFFFFF); #endif } }
void OutputStrings::_notification(int p_what) { switch (p_what) { case NOTIFICATION_DRAW: { if (following) { updating = true; v_scroll->set_value(v_scroll->get_max() - v_scroll->get_page()); updating = false; } RID ci = get_canvas_item(); Size2 size = get_size(); Ref<Font> font = get_font("font", "Tree"); Ref<StyleBox> tree_st = get_stylebox("bg", "Tree"); tree_st->draw(ci, Rect2(Point2(), size)); Color color = get_color("font_color", "Tree"); Ref<Texture> icon_error = get_icon("Error", "EditorIcons"); Ref<Texture> icon_warning = get_icon("Warning", "EditorIcons"); //int lines = (size_height-(int)margin.y) / font_height; Point2 ofs = tree_st->get_offset(); LineMap::Element *E = line_map.find(v_scroll->get_value()); float h_ofs = (int)h_scroll->get_value(); Point2 icon_ofs = Point2(0, (font_height - (int)icon_error->get_height()) / 2); FontDrawer drawer(font, Color(1, 1, 1)); while (E && ofs.y < (size_height - (int)margin.y)) { String str = E->get().text; Point2 line_ofs = ofs; switch (E->get().type) { case LINE_WARNING: { icon_warning->draw(ci, line_ofs + icon_ofs); } break; case LINE_ERROR: { icon_error->draw(ci, line_ofs + icon_ofs); } break; case LINE_LINK: { } break; default: { } } line_ofs.y += font->get_ascent(); line_ofs.x += icon_error->get_width() + 4; for (int i = 0; i < str.length(); i++) { if (line_ofs.x - h_ofs < 0) { line_ofs.x += font->get_char_size(str[i], str[i + 1]).width; } else if (line_ofs.x - h_ofs > size.width - margin.width) { break; } else { line_ofs.x += font->draw_char(ci, Point2(line_ofs.x - h_ofs, line_ofs.y), str[i], str[i + 1], color); } } ofs.y += font_height; E = E->next(); } } break; case NOTIFICATION_ENTER_TREE: case NOTIFICATION_RESIZED: { font_height = get_font("font", "Tree")->get_height(); size_height = get_size().height; update_scrollbars(); } break; } }
void testNavMesh() { Event::EventManager m; Event::ListenerRegister & reg = m.getListenerRegister(); AI::NavMesh::NavMeshGenerationEngine navMeshGenerationEngine; navMeshGenerationEngine.registerListeners(reg); vector<Threading::ThreadableInterface*> threadables; threadables.push_back(&m); Threading::Thread eventThread(threadables, 2); eventThread.start(); vector<Threading::ThreadableInterface*> threadables2; threadables2.push_back(&navMeshGenerationEngine); Threading::Thread generationThread(threadables2, 2); generationThread.start(); Event::EventQueue & queue = m.getEventQueue(); Geometry::Vec2Df lowerLeftPoint(0.f, 0.f); Geometry::Vec2Df upperRightPoint(128.f,128.f); queue << new AI::NavMesh::AreaCreatedEvent(lowerLeftPoint, upperRightPoint); // Create some obtacles queue << new AI::NavMesh::ObstacleAddedEvent(AI::NavMesh::Obstacle(Geometry::Vec2Df(110.f,110.f), Geometry::Vec2Df(119.f,119.f))); queue << new AI::NavMesh::ObstacleAddedEvent(AI::NavMesh::Obstacle(Geometry::Vec2Df(60.f,60.f), Geometry::Vec2Df(70.f,70.f))); queue << new AI::NavMesh::ObstacleAddedEvent(AI::NavMesh::Obstacle(Geometry::Vec2Df(10.f,10.f), Geometry::Vec2Df(15.f,15.f))); queue << new AI::NavMesh::NavMeshOverEvent(lowerLeftPoint,upperRightPoint); int k = 0; while (k < 20) { k++; Threading::sleep(Core::makeDurationMillis(200)); } eventThread.stop(); generationThread.stop(); // Draw navMesh Test::SvgDrawer drawer(256,256); const AI::NavMesh::NavMeshContainer::NavMeshesList& navMeshes = navMeshGenerationEngine.getNavMeshes().getNavMeshesList(); if(navMeshes.size() > 0) { AI::NavMesh::NavMesh* navMesh = navMeshes.at(0); // Path finding const Graph::PlanarGraph& graph = navMesh->getGraph(); const Graph::PlanarNode& startNode = graph.getNodes().front(); const Graph::PlanarNode& goalNode = graph.getNodes().back(); Graph::PlanarGraph::NodeCollection path; Graph::BasicAStar(graph, startNode, goalNode, path); drawNavMesh(*navMesh, drawer); //drawPath(path, drawer); //std::cout << drawer.getContent().str(); } // Test AI // Create entity Threading::ConcurrentRessource<Ecs::World> w( new Ecs::World(m.getEventQueue()) ); Ecs::Entity e1, e2; { Threading::ConcurrentWriter<Ecs::World> world = w.getWriter(); e1 = createNewCharacter( world, Geometry::Vec3Df(0.0,0.0,0.0), Geometry::Vec3Df(0.0,0.0,0.0), true, queue ); e2 = createNewCharacter( world, Geometry::Vec3Df(80.0,80.0,0.0), Geometry::Vec3Df(0.0,0.0,0.0), false, queue ); } // Create thrads for systems AI::AiSystem aiSystem(w); AI::Sensor::SensorSystem sensorSystem(w); Physics::MovementSystem movementSystem(w, m.getEventQueue()); AI::Subsystem::TargetingSystem targetingSystem(w); vector<Threading::ThreadableInterface*> aiSystemVector; vector<Threading::ThreadableInterface*> movementSystemVector; vector<Threading::ThreadableInterface*> targetingSystemVector; vector<Threading::ThreadableInterface*> sensorSystemVector; aiSystemVector.push_back(&sensorSystem); aiSystemVector.push_back(&targetingSystem); aiSystemVector.push_back(&aiSystem); movementSystemVector.push_back(&movementSystem); Threading::Thread aiThread(aiSystemVector, 20); //Threading::Thread sensorThread(sensorSystemVector, 5); //Threading::Thread targetingThread(targetingSystemVector, 5); Threading::Thread movementThread(movementSystemVector, 20); // Get the position component of e1 Ecs::ComponentGroup::ComponentTypeCollection types; types.insert(Geometry::PositionComponent::Type); Ecs::ComponentGroup prototype(types); Ecs::ComponentGroup componentsE1 = w.getWriter()->getEntityComponents( e1, prototype ); Ecs::ComponentGroup componentsE2 = w.getWriter()->getEntityComponents(e2, prototype); types.insert(AI::Subsystem::TargetingComponent::Type); Ecs::ComponentGroup components = w.getWriter()->getEntityComponents(e1, Ecs::ComponentGroup(types)); //sensorThread.start(); //targetingThread.start(); aiThread.start(); movementThread.start(); std::vector<Geometry::Vec2Df> positions; positions.push_back(Geometry::Vec2Df(0,0)); /* bool b = true; while(b) { Geometry::Vec2Df lastPos = positions.back(); Geometry::Vec3Df pos = positionComponentE1.getPosition(); if((pos -positionComponentE2.getPosition()).getLength() < 2.f) b = false; Threading::sleep(0,20); if(pos.getX() != lastPos.getX() && pos.getY() != lastPos.getY()) positions.push_back(Geometry::Vec2Df(pos.getX(), pos.getY())); } for (int j =0; j < 20; j++) { Threading::sleep(0,100); } */ std::vector<Geometry::Vec2Df> positionsE2; std::vector<Geometry::Vec2Df> targets; // Taget is moving slowly to the upper-right corner of the navMesh Geometry::Vec3Df offset(0.1, -0.2, 0.0); for (int j =0; j < 20*20; j++) { Threading::sleep(Core::makeDurationMillis(50)); ConcurrentReader<Geometry::PositionComponent> positionComponentE1 = getConcurrentReader<Ecs::Component, Geometry::PositionComponent>( componentsE1.getComponent(Geometry::PositionComponent::Type) ); ConcurrentWriter<Geometry::PositionComponent> positionComponentE2 = getConcurrentWriter<Ecs::Component, Geometry::PositionComponent>( componentsE2.getComponent(Geometry::PositionComponent::Type) ); ConcurrentReader<AI::Subsystem::TargetingComponent> targetingComponent = getConcurrentReader<Ecs::Component, AI::Subsystem::TargetingComponent>( components.getComponent(AI::Subsystem::TargetingComponent::Type) ); Geometry::Vec3Df pos1 = positionComponentE1->getPosition(); Geometry::Vec3Df pos2 = positionComponentE2->getPosition(); Geometry::Vec3Df target = targetingComponent->getTargetPosition(); Geometry::Vec3Df newPos = pos2 + offset; positionComponentE2->setPosition(newPos); positionsE2.push_back(Geometry::Vec2Df(newPos.getX(), newPos.getY())); positions.push_back(Geometry::Vec2Df(pos1.getX(), pos1.getY())); targets.push_back(Geometry::Vec2Df(target.getX(), target.getY())); } aiThread.stop(); //sensorThread.stop(); //targetingThread.stop(); movementThread.stop(); if(navMeshes.size() > 0) { ConcurrentWriter<Geometry::PositionComponent> positionComponentE2 = getConcurrentWriter<Ecs::Component, Geometry::PositionComponent>( componentsE2.getComponent(Geometry::PositionComponent::Type) ); AI::NavMesh::NavMesh* navMesh = navMeshes.at(0); // Path finding const Graph::PlanarGraph& graph = navMesh->getGraph(); Geometry::Vec3Df pos2 = positionComponentE2->getPosition(); Graph::PlanarNode startNode; navMesh->getNode( Geometry::Vec2Df(0, 0), startNode); Graph::PlanarNode goalNode; navMesh->getNode( Geometry::Vec2Df(pos2.getX(), pos2.getY()), goalNode); Graph::PlanarGraph::NodeCollection path; Graph::BasicAStar(graph, startNode, goalNode, path); drawPath(path, drawer); } for(unsigned int i = 0; i < positions.size(); i++) { Geometry::Vec2Df pos = positions[i]; drawer.drawCircle(pos.getX(), pos.getY(), 1, "green"); } for(unsigned int i = 0; i < positionsE2.size(); i++) { Geometry::Vec2Df pos = positionsE2[i]; drawer.drawCircle(pos.getX(), pos.getY(), 1, "orange"); Geometry::Vec2Df target = targets[i]; drawer.drawCircle(target.getX(), target.getY(), 1, "purple"); } drawer.end(); std::cout << drawer.getContent().str(); }
void battle() { generated_enemies = 0; cout << "\n-----Battle (" << date() << ")-----" << endl; cout << "Preparing UI... "; enemyArrow.setTexture(textureManager.get("game/arrow.png")); enemyArrow.setOrigin(20, 20); infoBackground.setTexture(textureManager.get("game/info.png")); infoBackground.setColor(sf::Color(255, 255, 255, 64)); HPbar.setTexture(textureManager.get("game/HPbar.png")); shieldBar.setTexture(textureManager.get("game/shieldBar.png")); regainingShieldBar.setTexture(textureManager.get("game/RegainingShieldBar.png")); ammoBar.setTexture(textureManager.get("game/ammoBar.png")); noAmmoBar.setTexture(textureManager.get("game/noAmmoBar.png")); cout << "[OK]" << endl; //Inicjalizacja czcionek, tekstów itd. FPStext.setFont(bitFont); FPStext.setCharacterSize(40); FPStext.setColor(sf::Color::Green); XPtext.setFont(bitFont); XPtext.setCharacterSize(50); XPtext.setColor(sf::Color::White); HPtext.setFont(bitFont); HPtext.setCharacterSize(20); HPtext.setColor(sf::Color::White); shieldText.setFont(bitFont); shieldText.setCharacterSize(20); shieldText.setColor(sf::Color::White); ammoText.setFont(bitFont); ammoText.setCharacterSize(20); ammoText.setColor(sf::Color::White); releaseButton.setFont(bitFont); releaseButton.setCharacterSize(20); releaseButton.setColor(sf::Color::Red); //------------ //Ustawianie parametrów statku i broni cout << "Loading enemyies weapons... "; enemyWeapons.loadFromFile("assets/xml/weapons2.xml"); cout << "[OK]" << endl; spaceship buf; statek = buf; cout << "Loading spaceship weapons... "; statek.Weapons.loadFromFile("assets/xml/weapons1.xml"); statek.Weapons.select(3); statek.Weapon = statek.Weapons.top(); cout << "[OK]" << endl; cout << "Loading game..."; statek.spaceMap.loadFromFile(workingDirectory + "assets/saves/save0/space.map"); sf::Image * img = new sf::Image; img -> create(statek.spaceMap.getSize().x, statek.spaceMap.getSize().y); for(int x = 0; x < statek.spaceMap.getSize().x; x++) for(int y = 0; y < statek.spaceMap.getSize().y; y++) { sf::Uint8 num = statek.spaceMap.getPureCharMap()[x][y] * 85; img -> setPixel(x, y, sf::Color(num, num, 128)); } statek.minimapTex.loadFromImage(*img); delete img; statek.minimapSprite.setTexture(statek.minimapTex); statek.minimapSprite.setScale(335.f / statek.minimapSprite.getGlobalBounds().width, 200.f / statek.minimapSprite.getGlobalBounds().height); statek.colorEfeect.setSize(sf::Vector2f(sf::VideoMode::getDesktopMode().width, sf::VideoMode::getDesktopMode().height)); statek.colorEfeect.setOrigin(statek.colorEfeect.getSize() / 2.f); ifstream file(workingDirectory + "assets/saves/save0/player.BOHsave"); sf::Vector2f tmp; file >> tmp.x; file.get(); file >> tmp.y; file.close(); view = app.getDefaultView(); view.reset(sf::FloatRect(screenCornerX + tmp.x * 1500.f, screenCornerY + tmp.y * 1500.f, screenX, screenY)); app.setView(view); screenCornerX = (tmp.x * 1500.f); screenCornerY = (tmp.y * 1500.f); mapCornerX = (tmp.x * 1500.f); mapCornerY = (tmp.y * 1500.f); map2CornerX = (tmp.x * 1500.f); map2CornerY = (tmp.y * 1500.f); map3CornerX = (tmp.x * 1500.f); map3CornerY = (tmp.y * 1500.f); cout << "[OK]" << endl; statek.HP = 500; statek.shield = 500; statek.XP = 0; statek.baseMovingSpeed = 20; statek.MovingSpeed = statek.baseMovingSpeed; statek.bulletsPerRegeneration = 10; statek.FramesForRegeneration = 1; statek.shieldMax = statek.shield; statek.maxHP = statek.HP; statek.shieldRegerationTimeInFrames = 120; statek.colorEfeect.setFillColor(sf::Color(0, 0, 0, 0)); statek.shieldTexture.loadFromFile(workingDirectory + "assets/graphics/spaceship/shields/active/3.png"); statek.shieldTexture.setSmooth(true); statek.shieldSprite.setTexture(statek.shieldTexture); statek.shieldSprite.setOrigin(Collision::GetSpriteSize(statek.shieldSprite).x / 2, Collision::GetSpriteSize(statek.shieldSprite).y / 2); statek.shieldSprite.setColor(sf::Color(255, 255, 255, 0)); statek.wybuch.loadAnimation(workingDirectory + "assets/graphics/spaceship/destroy.animation"); statek.eksplozja.loadAnimation(workingDirectory + "assets/graphics/spaceship/blood.animation"); statek.sprite.setPosition(screenX/2 - Collision::GetSpriteSize(statek.sprite).x / 2, screenY/2 - Collision::GetSpriteSize(statek.sprite).x / 2); statek.ammo = 2000; statek.ammoMax = 2000; //------------ //Mało / dużo amunicji etc. kursor.lowAmmoTexture.loadFromFile(workingDirectory + "assets/graphics/cursor/lowAmmo.png"); kursor.lowAmmoTexture.setSmooth(true); kursor.lowAmmoSprite.setTexture(kursor.lowAmmoTexture); kursor.lowAmmoSprite.setScale(settings.getCursorScale()); kursor.lowAmmoSprite.setOrigin((Collision::GetSpriteSize(kursor.lowAmmoSprite).x / kursor.lowAmmoSprite.getScale().x / 2), (Collision::GetSpriteSize(kursor.lowAmmoSprite).y / kursor.lowAmmoSprite.getScale().y / 2)); kursor.highAmmoTexture.loadFromFile(workingDirectory + "assets/graphics/cursor/highAmmo.png"); kursor.highAmmoTexture.setSmooth(true); kursor.highAmmoSprite.setTexture(kursor.highAmmoTexture); kursor.highAmmoSprite.setScale(settings.getCursorScale()); kursor.highAmmoSprite.setOrigin((Collision::GetSpriteSize(kursor.highAmmoSprite).x / kursor.highAmmoSprite.getScale().x / 2), (Collision::GetSpriteSize(kursor.highAmmoSprite).y / kursor.highAmmoSprite.getScale().y / 2)); kursor.hitTexture.loadFromFile(workingDirectory + "assets/graphics/cursor/hit.png"); kursor.hitTexture.setSmooth(true); kursor.hitSprite.setTexture(kursor.hitTexture); kursor.hitSprite.setScale(settings.getCursorScale()); kursor.hitSprite.setOrigin((Collision::GetSpriteSize(kursor.hitSprite).x / kursor.hitSprite.getScale().x / 2), (Collision::GetSpriteSize(kursor.hitSprite).y / kursor.hitSprite.getScale().y / 2)); kursor.hitSprite.setColor(sf::Color(255, 255, 255, 0)); //------------- statek.load_texture("assets/graphics/bullets/" + statek.Weapons.top().codeName + "/"); FPStext.setPosition(screenCornerX + screenX - 90, screenCornerY + 8); releaseButton.setString("Release SHOT button!"); //Ustawianie pozycji elementów UI terminal.create(screenX / 2.5, screenY / 3, sf::Color(10, 10, 10, 230)); terminal.setPosition(sf::Vector2f(screenCornerX, screenY + screenCornerY - terminal.getSize().y)); regainingShieldBar.setPosition(screenX + screenCornerX - 240, screenY + screenCornerY - 59); releaseButton.setPosition(screenX + screenCornerX - 158, screenY + screenCornerY - 100); shieldText.setPosition(screenX + screenCornerX - 315, screenY + screenCornerY - 67); shieldBar.setPosition(screenX + screenCornerX - 240, screenY + screenCornerY - 59); ammoText.setPosition(screenX + screenCornerX - 315, screenY + screenCornerY - 82); ammoBar.setPosition(screenX + screenCornerX - 240, screenY + screenCornerY - 74); noAmmoBar.setPosition(screenX + screenCornerX - 240, screenY + screenCornerY - 74); HPtext.setPosition(screenX + screenCornerX - 315, screenY + screenCornerY - 52); HPbar.setPosition(screenX + screenCornerX - 240, screenY + screenCornerY - 44); for(int i = 0; i < 3; i++) symbols[i].setPosition(screenX + screenCornerX - 335, screenY + screenCornerY - 73 + (i * 15)); FPStext.setPosition(screenCornerX + screenX - 110, screenCornerY); XPtext.setPosition(screenCornerX + 10, screenCornerY - 10); statek.colorEfeect.setPosition(screenX/2 + screenCornerX, screenY/2 + screenCornerY); //------------------------------- //Przygotowywanie kursora kursor.init("assets/graphics/cursor/cursorGrey.png", "cursorGrey.png"); kursor.init("assets/graphics/cursor/cursorRed.png", "cursorRed.png"); //----------------------- screenRect.height = screenY + 100; screenRect.width = screenX + 100; screenCenter = sf::Vector2f(screenCornerX + (screenX / 2), screenCornerY + (screenY / 2)); cout << "Loading drones... "; statek.addDrone("assets/graphics/bullets/" + statek.Weapons.top().codeName + "/drone.png", 130, -120, 0); statek.addDrone("assets/graphics/bullets/" + statek.Weapons.top().codeName + "/drone.png", 130, 120, 0); statek.addDrone("assets/graphics/bullets/" + statek.Weapons.top().codeName + "/drone.png", 190, -75, 1); statek.addDrone("assets/graphics/bullets/" + statek.Weapons.top().codeName + "/drone.png", 190, 75, 1); cout << "[OK]" << endl; Time = 0; counter = 0; Counter = 0; while (app.isOpen() and !statek.destroyed_end) { Time++; if(counter >= 101 - statek.Weapon.agility) { Ready_to_shot = true; counter = 0; } if(!Ready_to_shot) counter += timeModifier; if(Ready_to_shot) Ready_to_shot = (saws.size() <= 0); while (app >> event) { if(event.type == sf::Event::Closed) app.close(); //Zmiana broni if (event.type == sf::Event::MouseWheelMoved and Ready_to_shot) mouseWheelDelta += event.mouseWheel.delta; if(event.type == sf::Event::Resized) { screenX = event.size.width; screenY = event.size.height; } if(event.type == sf::Event::KeyPressed and event.key.code == sf::Keyboard::Tab) terminal.visible(!terminal.isVisible()); if(terminal.isVisible()) { if(event.type == sf::Event::KeyPressed and (event.key.code == sf::Keyboard::Left or event.key.code == sf::Keyboard::Right)) terminal.moveCursor(event.key.code == sf::Keyboard::Left ? -1 : 1); if(event.type == sf::Event::TextEntered and event.text.unicode < 128) terminal.insertCharacter(static_cast<char>(event.text.unicode)); terminal.update(); } else { if (characterControler.checkAction(characterControler.nextWeapon)) { statek.hideAddon = true; statek.newWeaponRequest = "next"; mouseWheelDelta = 0; } else if (characterControler.checkAction(characterControler.previousWeapon)) { statek.hideAddon = true; statek.newWeaponRequest = "previous"; mouseWheelDelta = 0; } //---------- //PAUZA if(characterControler.checkAction(characterControler.pause) and Time - lastTimePaused > 10) { app.soundsManager.pauseAll(); Pause(); controlClock.restart(); } //----- //Kontrolowanie dronów if(characterControler.checkAction(characterControler.droneShot)) { sf::Sprite px; sf::Texture pxT; pxT.create(5, 5); px.setPosition(kursor.sprite.getPosition()); px.setTexture(pxT); for(int i = enemies.size() - 1; i >= 0; i--) { if(Collision::PixelPerfectTest(enemies[i].sprite, px)) { cout << "Enemy selected!" << endl; statek.targetID = enemies[i].ID; } } } if(characterControler.checkAction(characterControler.dronesControl)) { statek.releaseTargets += timeModifier; if(statek.releaseTargets >= 10.f) { statek.enemySelected = false; statek.targetID = -1; } } else statek.releaseTargets = 0; //-------------------- } } //strzał nie-laserem if(characterControler.checkAction(characterControler.playerShot) and Ready_to_shot and statek.Weapon.codeName != "laser" and !statek.destroyed and Time > 100) { sf::Vector2f target = statek.sprite.getPosition(); target += sf::Vector2f(cos(statek.sprite.getRotation() * 0.0174532925f), sin(statek.sprite.getRotation() * 0.0174532925f)) * 1000.f; Shot(statek.Weapon, true, target, statek.sprite.getPosition(), &Ready_to_shot); if(statek.Weapon.baseAccuracyBonus > 0) statek.Weapon.baseAccuracyBonus--; } //------------------ //Spoczynek if(!characterControler.checkAction(characterControler.playerShot)) { statek.regenerate(true); if(statek.Weapon.baseAccuracyBonus < 4) statek.Weapon.baseAccuracyBonus++; } else statek.regenerate(false); //--------- //Informacje dodatkowe przy kursorze if(static_cast <float> (statek.ammo) / statek.ammoMax <= 0.3) kursor.lowAmmo = true; else kursor.lowAmmo = false; if(static_cast <float> (statek.ammo) / statek.ammoMax >= 0.7) kursor.highAmmo = true; else kursor.highAmmo = false; //---------------------------------- //Mierzenie czasu sf::Time iterationTime = controlClock.getElapsedTime(); timeModifier = iterationTime.asSeconds() / perfectFrameTime; frameTimes.push_back(iterationTime.asSeconds()); if(frameTimes.size() > 60) frameTimes.erase(frameTimes.begin()); controlClock.restart(); //--------------- //Wrogowie, poruszanie się, rysowanie, itp. screenCenter = sf::Vector2f(screenCornerX + (screenX / 2), screenCornerY + (screenY / 2)); enemyGenerator(); if(!statek.destroyed and !terminal.isVisible()) { sf::Vector2f newPos = statek.move(); for(int i = 0; i < meteors.size(); i++) { if(meteors[i].contains(statek.sprite.getPosition() + newPos, 0)) { sf::Vector2f p1 = meteors[i].getPosition(); meteors[i].push(statek.sprite.getPosition(), newPos, 1.f); newPos = p1 - meteors[i].getPosition(); newTiles = false; } } view.move(newPos); kursor.sprite.move(newPos); app.setView(view); screenCornerY += newPos.y; mapCornerY += newPos.y / 4; map2CornerY += newPos.y / 3; map3CornerY += newPos.y / 2; screenCornerX += newPos.x; mapCornerX += newPos.x / 4; map2CornerX += newPos.x / 3; map3CornerX += newPos.x / 2; //ustawianie pozycji statku statek.sprite.setPosition(screenX/2 + screenCornerX, screenY/2 + screenCornerY); //------------------------- direction -= kursor.sprite.getPosition(); } screenRect.left = screenCornerX - 100; screenRect.top = screenCornerY - 100; pSystems::soulsParticles.update(iterationTime); drawer(counter); if(quit) break; app.display(); app.soundsManager.cleaner(); //----------------------------------------- } if(terminal.isVisible()) terminal.visible(false); terminal.clear(); if(saws.size() > 0) saws.clear(); if(souls.size() > 0) souls.clear(); if(pociski.size() > 0) pociski.clear(); if(meteors.size() > 0) meteors.clear(); if(enemies.size() > 0) enemies.clear(); if(damageInfo.size() > 0) damageInfo.clear(); }
void SprayBrush::paint(KisPaintDeviceSP dev, const KisPaintInformation& info, const KoColor &color) { qreal x = info.pos().x(); qreal y = info.pos().y(); // initializing painter KisPainter drawer(dev); drawer.setPaintColor(color); // jitter radius int tmpRadius = m_radius; if (m_jitterSize){ m_radius = m_radius * drand48(); } // jitter movement if (m_jitterMovement){ x = x + (( 2 * m_radius * drand48() ) - m_radius) * m_amount; y = y + (( 2 * m_radius * drand48() ) - m_radius) * m_amount; } KisRandomAccessor accessor = dev->createRandomAccessor( qRound(x), qRound(y) ); m_pixelSize = dev->colorSpace()->pixelSize(); m_inkColor = color; m_counter++; // coverage: adaptively select how many objects are sprayed per paint if (m_useDensity){ m_particlesCount = (m_coverage * (M_PI * m_radius * m_radius) ); } // Metaballs are rendered little differently if (m_shape == 2 && m_object == 0){ paintMetaballs(dev, info, color); } qreal nx, ny; int ix, iy; qreal angle; qreal lengthX; qreal lengthY; for (int i = 0; i < m_particlesCount; i++){ // generate random angle angle = drand48() * M_PI * 2; // different X and Y length?? lengthY = lengthX = drand48(); // I hope we live the era where sin and cos is not slow for spray nx = (sin(angle) * m_radius * lengthX); ny = (cos(angle) * m_radius * lengthY); // transform nx *= m_scale; ny *= m_scale; // it is some shape (circle, ellipse, rectangle) if (m_object == 0) { // steps for single step in circle and ellipse int steps = 36; qreal random = drand48(); drawer.setFillColor(m_inkColor); drawer.setBackgroundColor(m_inkColor); drawer.setPaintColor(m_inkColor); // it is ellipse if (m_shape == 0){ // qreal ellipseA = m_width / 2.0; qreal ellipseB = m_height / 2.0; if (m_width == m_height) { if (m_jitterShapeSize){ paintCircle(drawer, nx + x, ny + y, int((random * ellipseA) + 1.5) , steps); } else{ paintCircle(drawer, nx + x, ny + y, qRound(ellipseA) , steps); } } else { if (m_jitterShapeSize){ paintEllipse(drawer, nx + x, ny + y,int((random * ellipseA) + 1.5) ,int((random * ellipseB) + 1.5), angle , steps); } else{ paintEllipse(drawer, nx + x, ny + y, qRound(ellipseA), qRound(ellipseB), angle , steps); } } } else if (m_shape == 1) { if (m_jitterShapeSize){ paintRectangle(drawer, nx + x, ny + y,int((random * m_width) + 1.5) ,int((random * m_height) + 1.5), angle , steps); } else{ paintRectangle(drawer, nx + x, ny + y, qRound(m_width), qRound(m_height), angle , steps); } } // it is pixel particle }else if (m_object == 1){ paintParticle(accessor,m_inkColor,nx + x, ny + y); } // it is pixel else if (m_object == 2) { ix = qRound(nx + x); iy = qRound(ny + y); accessor.moveTo(ix, iy); memcpy(accessor.rawData(), m_inkColor.data(), m_pixelSize); } } // hidden code for outline detection //m_inkColor.setOpacity(128); //paintOutline(dev,m_inkColor,x, y, m_radius * 2); // recover from jittering of color m_radius = tmpRadius; }