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;
}
