void klsMiniMap::update(GLPoint2f origin, GLPoint2f endpoint) { //wxClientDC dc(this); //dc.FloodFill(0, 0, *wxWHITE); this->origin = origin; this->endpoint = endpoint; generateImage(); //***************************** //Edit by Joshua Lansford 4/9/07 //In search of determineing the //cause of the miniMap spazz bug //I refactored update and //OnPaint. //Instead of update doing both //jobs, I now have OnPaint //handling the painting //and update handling the update- //ing. It didn't seem right //for the update to be grabbing //the hardware and rendering //to it when we were not servicing //a onPaint request. //*************************** //wxBitmap mapBitmap(mapImage); //dc.DrawBitmap(mapBitmap, 0, 0, true); Refresh( false ); //Update makes it so that we don't lag //when the user is moveing the cavase around wxWindow::Update(); }
static void generateImages(const ofxOBJGroup& group, int& i) { ofLogVerbose() << "writing group images: " << group.name; for (const auto& face : group.faces) { generateImage(face, i); i++; } }
/** * @class cs::Background */ Background::Background(const cs::Settings &s, const glm::ivec2 &window_size) : mSettings(s) , mWorkerWindowSize(window_size) , mWorkerColor(s.mBackgroundColor) { // Setup mHasWorkerSurface = false; // Create the mesh const glm::vec2 tc_ul(0.0f, 0.0f), tc_ur(1.0f, 0.0f), tc_lr(1.0f, 1.0f), tc_ll(0.0f, 1.0f); const float fw = static_cast<float>(window_size.x), fh = static_cast<float>(window_size.y); ci::gl::VboMeshRef mesh = ci::gl::VboMesh::create(ci::geom::Rect(ci::Rectf(0, 0, fw, fh)).texCoords(tc_ul, tc_ur, tc_lr, tc_ll)); if (!mesh) throw std::runtime_error("Background vbo can't create vbo mesh"); // Create shader auto shader = ci::gl::getStockShader(ci::gl::ShaderDef().texture()); if (!shader) throw std::runtime_error("Background vbo can't create shader"); // Create batch mBatch = ci::gl::Batch::create(mesh, shader); if (!mBatch) throw std::runtime_error("Background vbo can't create batch"); // Generate background mThread = std::thread([this](){generateImage();}); }
void MainWindow::on_actionGenerate_triggered() { QSettings settings; auto path = QFileDialog::getSaveFileName(this, tr("Generate disk image"), settings.value(cSettingsGenerateFileDirectory).toString(), tr("Disk Image (*.img)")); if (!path.isEmpty()) { generateImage(path); } }
void GameWidget::loadGraphism(QString repertoire) { int size; if (repertoire == tr("Classique")) // Si graphisme par défaut repertoire = ":/ressources/widget/"; else repertoire = QString("graphismes")+QString(QDir::separator())+repertoire+QString(QDir::separator()); if (!avalanche.load(repertoire+"avalanche.png")) std::cout << "Error chargement de avalanche" << std::endl; if (!neige.load(repertoire+"neige.png")) std::cout << "Error chargement de neige" << std::endl; if (!tuxfisher_vivant.load(repertoire+"tuxfisher_vivant.png")) std::cout << "Error chargement de TuxFisher :P" << std::endl; if (!tuxfisher_gagne.load(repertoire+"tuxfisher_gagne.png")) std::cout << "Error chargement de TuxFisher :P" << std::endl; if (!tuxfisher_mort.load(repertoire+"tuxfisher_mort.png")) std::cout << "Error chargement de TuxFisher :P" << std::endl; if (!fish.load(repertoire+"fish.png")) std::cout << "Error chargement de fish" << std::endl; if (!montagne.load(repertoire+"montagne.png")) std::cout << "Error chargement de montagne" << std::endl; if (!vide.load(repertoire+"vide.png")) std::cout << "Error chargement de vide" << std::endl; // Redimensionne correctement les cases (pour les différentes résolutions d'écrans) if (QApplication::desktop()->width()>1024 && QApplication::desktop()->height()>768) // ]1024*768;infini[ size=32; else if (QApplication::desktop()->width()>800 && QApplication::desktop()->height()>600) // ]800*600;1024*768] size=30; else if (QApplication::desktop()->width()>600 && QApplication::desktop()->height()>480) // ]600*480;800*600] size=22; else size=16; avalanche=avalanche.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); neige=neige.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); tuxfisher_vivant=tuxfisher_vivant.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); tuxfisher_gagne=tuxfisher_gagne.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); tuxfisher_mort=tuxfisher_mort.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); fish=fish.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); montagne=montagne.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); vide=vide.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); if (moteur->gameOver()) tuxfisher = tuxfisher_mort; else tuxfisher = tuxfisher_vivant; case_width=avalanche.width(); case_height=avalanche.height(); // La size des cases peut avoir set if (!afficher_accueil) bufferimage = QImage(QSize(nbcase_width*case_width,nbcase_height*case_height),QImage::Format_ARGB32); // Nouvelle size du buffer generateImage(true); }
void ModuleView::updateWidget(QWidget& widget) { { SYNC_WITH(console); if(lastModulInfoTimeStamp == console.moduleInfo.timeStamp) return; } generateImage(); ((ModuleWidget*)(&widget))->image = image; widget.update(); }
QMimeData* PictureBase::dragObject(QWidget * dragSource, const char * name) { Q_UNUSED(dragSource); QImage image(generateImage(getOriginalSize())); if (image.isNull()) return 0; else { QMimeData* mimeData = new QMimeData(); mimeData->setImageData(image); mimeData->setObjectName(name); return mimeData; // XXX: Qt3 use dragsource here? } }
void Plot2D::exportImageToFile(int w, int h) { QString filename = QFileDialog::getSaveFileName(this, tr("Export Image"), // caption ".", // folder tr( "JPEG (*.jpeg)\n" // filters "PNG (*.png)\n" "Bitmap (*.bmp)\n")); if (!filename.isEmpty()) { generateImage(toPath(filename), w, h); } }
bool GameWidget::loadMap(int x, int y, QByteArray datasmap) { tuxfisher = tuxfisher_vivant; if (datasmap.size()!=x*y) return false; afficher_accueil=false; nbcase_width=x; nbcase_height=y; bufferimage = QImage(QSize(nbcase_width*case_width,nbcase_height*case_height),QImage::Format_ARGB32); moteur->loadMap(nbcase_width, nbcase_height, datasmap.data()); generateImage(true); return true; }
video::IImage* TextureSource::generateImageFromScratch(std::string name) { /*infostream<<"generateImageFromScratch(): " "\""<<name<<"\""<<std::endl;*/ video::IVideoDriver *driver = m_device->getVideoDriver(); assert(driver); /* Get the base image */ video::IImage *baseimg = NULL; char separator = '^'; // Find last meta separator in name s32 last_separator_position = name.find_last_of(separator); /* If separator was found, construct the base name and make the base image using a recursive call */ std::string base_image_name; if(last_separator_position != -1) { // Construct base name base_image_name = name.substr(0, last_separator_position); baseimg = generateImageFromScratch(base_image_name); } /* Parse out the last part of the name of the image and act according to it */ std::string last_part_of_name = name.substr(last_separator_position+1); // Generate image according to part of name if(!generateImage(last_part_of_name, baseimg)) { errorstream<<"generateImageFromScratch(): " "failed to generate \""<<last_part_of_name<<"\"" <<std::endl; return NULL; } return baseimg; }
GameWidget::GameWidget(QWidget *parent) : QGLWidget(QGLFormat(QGL::SampleBuffers), parent) // QWidget(parent) // { moteur = new GameEngine(); audio = SoundManager::getInstance(); son_montagne = son_avalanche = son_mort = son_fish = son_victoire = 0; setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum); animation_en_cours=false; avalancheTombant=false; afficher_accueil=true; timer_animation = new QTimer(this); connect(timer_animation, SIGNAL(timeout()), this, SLOT(animation())); generateImage(); setFocus(); }
void GameWidget::animation() { bool tuxfisher_deja_mort=moteur->gameOver(); animation_en_cours=true; if(avalancheTombant) { if(moteur->dropAvalanche()) generateImage(); else { if (moteur->gameOver() && !tuxfisher_deja_mort) { tuxfisher = tuxfisher_mort; audio->playSound(son_mort, false); generateImage(true); } avalancheTombant=false; audio->playSound(son_avalanche, true); } return; } if(moteur->fallingAvalanche()) avalancheTombant=true; else { // Animation terminée avalancheTombant=false; animation_en_cours=false; timer_animation->stop(); if (moteur->gameOver()) // On signale le gameover si tuxfisher est mort et que l'animation est terminée emit gameOver(); } }
void PdfImageGenerator::startGeneration(void) { int page; QRectF highlight; QImage img; QPair<int,QRectF> demand; while (!this->requestedPages.isEmpty()) { demand = requestedPages.takeLast(); page = demand.first; highlight = demand.second; img = generateImage(page); if (!img.isNull()) { /* image size estimation */ if (this->passes < this->minpasses) { ++passes; avgw += img.width(); avgh += img.height(); } /* search result highlight * cuts out the highlighted word and darkens the rest of the page */ if (highlight.isValid()) { QRect highlightRect = scaleHighlightRect(highlight); highlightRect.adjust(-2, -2, 2, 2); QImage hImage = img.copy(highlightRect); QPainter painter; painter.begin(&img); painter.fillRect(img.rect(), QColor(0, 0, 0, 32)); painter.drawImage(highlightRect, hImage); painter.end(); } emit imageFinished(img, page); } } if (this->passes == minpasses) { pageSize.setWidth((int)(avgw/passes)); pageSize.setHeight((int)(avgh/passes)); ++passes; emit newPageSize(pageSize); } emit generationFinished(); }
void PowerDevilRunner::addMatch(PowerDevilRunner::PowerDevilAction action, Sprinter::MatchData &matchData) { Sprinter::QueryMatch match; switch (action) { case DimTotalAction: match.setText(i18n("Dim screen completely")); break; case DimHalfAction: match.setText(i18n("Dim screen halfway")); break; case DimNotAction: match.setText(i18n("Make screen bright")); break; case SuspendAction: match.setText(i18n("Suspend to RAM")); break; case HibernateAction: match.setText(i18n("Suspend to Disk")); break; case ChangeBrightnessAction: Q_ASSERT_X(false, "PowerDevilRunner::addMatch", "Please use PowerDevilRunner::addBrightnessMatch"); return; default: Q_ASSERT_X(false, "PowerDevilRunner::addMatch", "PowerDevilAction type does not exist"); return; } match.setType(Sprinter::QuerySession::HardwareType); match.setSource(Sprinter::QuerySession::FromLocalService); match.setPrecision(Sprinter::QuerySession::ExactMatch); match.setImage(generateImage(m_actionIcons.value(action), matchData.queryContext())); QStringList data; data.append(QLatin1String("PowerDevilAction")); data.append(QString::number((int)action)); match.setData(data.join(ParameterSeperator)); matchData << match; }
void PowerDevilRunner::addBrightnessMatch(int brightness, Sprinter::MatchData &matchData) { brightness = qBound(0, brightness, 100); Sprinter::QueryMatch match; match.setType(Sprinter::QuerySession::HardwareType); match.setSource(Sprinter::QuerySession::FromLocalService); match.setImage(generateImage(m_actionIcons.value(ChangeBrightnessAction), matchData.queryContext())); match.setText(i18n("Set Brightness to %1", brightness)); match.setPrecision(Sprinter::QuerySession::ExactMatch); QStringList data; data.append(QLatin1String("PowerDevilAction")); data.append(QString::number((int)ChangeBrightnessAction)); data.append(QLatin1String("Brightness")); data.append(QString::number(brightness)); match.setData(data.join(ParameterSeperator)); matchData << match; }
ccRasterizeTool::ccRasterizeTool(ccGenericPointCloud* cloud, QWidget* parent/*=0*/) : QDialog(parent, Qt::WindowMaximizeButtonHint) , cc2Point5DimEditor() , Ui::RasterizeToolDialog() , m_cloud(cloud) { setupUi(this); #ifndef CC_GDAL_SUPPORT generateRasterPushButton->setDisabled(true); generateRasterPushButton->setChecked(false); #endif connect(buttonBox, SIGNAL(accepted()), this, SLOT(testAndAccept())); connect(buttonBox, SIGNAL(rejected()), this, SLOT(testAndReject())); connect(gridStepDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateGridInfo())); connect(gridStepDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(gridOptionChanged())); connect(emptyValueDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(gridOptionChanged())); connect(resampleCloudCheckBox, SIGNAL(toggled(bool)), this, SLOT(gridOptionChanged())); connect(dimensionComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(projectionDirChanged(int))); connect(heightProjectionComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(projectionTypeChanged(int))); connect(scalarFieldProjection, SIGNAL(currentIndexChanged(int)), this, SLOT(sfProjectionTypeChanged(int))); connect(fillEmptyCellsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(fillEmptyCellStrategyChanged(int))); connect(updateGridPushButton, SIGNAL(clicked()), this, SLOT(updateGridAndDisplay())); connect(generateCloudPushButton, SIGNAL(clicked()), this, SLOT(generateCloud())); connect(generateImagePushButton, SIGNAL(clicked()), this, SLOT(generateImage())); connect(generateRasterPushButton, SIGNAL(clicked()), this, SLOT(generateRaster())); connect(generateASCIIPushButton, SIGNAL(clicked()), this, SLOT(generateASCIIMatrix())); connect(generateMeshPushButton, SIGNAL(clicked()), this, SLOT(generateMesh())); connect(generateContoursPushButton, SIGNAL(clicked()), this, SLOT(generateContours())); connect(exportContoursPushButton, SIGNAL(clicked()), this, SLOT(exportContourLines())); connect(clearContoursPushButton, SIGNAL(clicked()), this, SLOT(removeContourLines())); connect(activeLayerComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(activeLayerChanged(int))); //custom bbox editor ccBBox gridBBox = m_cloud ? m_cloud->getOwnBB() : ccBBox(); if (gridBBox.isValid()) { createBoundingBoxEditor(gridBBox, this); connect(editGridToolButton, SIGNAL(clicked()), this, SLOT(showGridBoxEditor())); } else { editGridToolButton->setEnabled(false); } if (m_cloud) { cloudNameLabel->setText(m_cloud->getName()); pointCountLabel->setText(QString::number(m_cloud->size())); interpolateSFFrame->setEnabled(cloud->hasScalarFields()); //populate layer box activeLayerComboBox->addItem(GetDefaultFieldName(PER_CELL_HEIGHT)); if (cloud->isA(CC_TYPES::POINT_CLOUD) && cloud->hasScalarFields()) { ccPointCloud* pc = static_cast<ccPointCloud*>(cloud); for (unsigned i=0; i<pc->getNumberOfScalarFields(); ++i) activeLayerComboBox->addItem(pc->getScalarField(i)->getName()); } else { activeLayerComboBox->setEnabled(false); } //add window create2DView(mapFrame); } loadSettings(); updateGridInfo(); gridIsUpToDate(false); }
void SkScalerContext::getImage(const SkGlyph& origGlyph) { const SkGlyph* glyph = &origGlyph; SkGlyph tmpGlyph; // in case we need to call generateImage on a mask-format that is different // (i.e. larger) than what our caller allocated by looking at origGlyph. SkAutoMalloc tmpGlyphImageStorage; // If we are going to draw-from-path, then we cannot generate color, since // the path only makes a mask. This case should have been caught up in // generateMetrics(). SkASSERT(!fGenerateImageFromPath || SkMask::kARGB32_Format != origGlyph.fMaskFormat); if (fMaskFilter) { // restore the prefilter bounds tmpGlyph.initGlyphIdFrom(origGlyph); // need the original bounds, sans our maskfilter SkMaskFilter* mf = fMaskFilter; fMaskFilter = nullptr; // temp disable this->getMetrics(&tmpGlyph); fMaskFilter = mf; // restore // we need the prefilter bounds to be <= filter bounds SkASSERT(tmpGlyph.fWidth <= origGlyph.fWidth); SkASSERT(tmpGlyph.fHeight <= origGlyph.fHeight); if (tmpGlyph.fMaskFormat == origGlyph.fMaskFormat) { tmpGlyph.fImage = origGlyph.fImage; } else { tmpGlyphImageStorage.reset(tmpGlyph.computeImageSize()); tmpGlyph.fImage = tmpGlyphImageStorage.get(); } glyph = &tmpGlyph; } if (fGenerateImageFromPath) { SkPath devPath, fillPath; SkMatrix fillToDevMatrix; SkMask mask; this->internalGetPath(*glyph, &fillPath, &devPath, &fillToDevMatrix); glyph->toMask(&mask); if (fRasterizer) { mask.fFormat = SkMask::kA8_Format; sk_bzero(glyph->fImage, mask.computeImageSize()); if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, nullptr, fMaskFilter, &mask, SkMask::kJustRenderImage_CreateMode)) { return; } if (fPreBlend.isApplicable()) { applyLUTToA8Mask(mask, fPreBlend.fG); } } else { SkASSERT(SkMask::kARGB32_Format != mask.fFormat); generateMask(mask, devPath, fPreBlend); } } else { generateImage(*glyph); } if (fMaskFilter) { SkMask srcM, dstM; SkMatrix matrix; // the src glyph image shouldn't be 3D SkASSERT(SkMask::k3D_Format != glyph->fMaskFormat); SkAutoSMalloc<32*32> a8storage; glyph->toMask(&srcM); if (SkMask::kARGB32_Format == srcM.fFormat) { // now we need to extract the alpha-channel from the glyph's image // and copy it into a temp buffer, and then point srcM at that temp. srcM.fFormat = SkMask::kA8_Format; srcM.fRowBytes = SkAlign4(srcM.fBounds.width()); size_t size = srcM.computeImageSize(); a8storage.reset(size); srcM.fImage = (uint8_t*)a8storage.get(); extract_alpha(srcM, (const SkPMColor*)glyph->fImage, glyph->rowBytes()); } fRec.getMatrixFrom2x2(&matrix); if (fMaskFilter->filterMask(&dstM, srcM, matrix, nullptr)) { int width = SkFastMin32(origGlyph.fWidth, dstM.fBounds.width()); int height = SkFastMin32(origGlyph.fHeight, dstM.fBounds.height()); int dstRB = origGlyph.rowBytes(); int srcRB = dstM.fRowBytes; const uint8_t* src = (const uint8_t*)dstM.fImage; uint8_t* dst = (uint8_t*)origGlyph.fImage; if (SkMask::k3D_Format == dstM.fFormat) { // we have to copy 3 times as much height *= 3; } // clean out our glyph, since it may be larger than dstM //sk_bzero(dst, height * dstRB); while (--height >= 0) { memcpy(dst, src, width); src += srcRB; dst += dstRB; } SkMask::FreeImage(dstM.fImage); if (fPreBlendForFilter.isApplicable()) { applyLUTToA8Mask(srcM, fPreBlendForFilter.fG); } } } }
void gateImage::update() { setViewport(); generateImage(); }
/* This method generates all the textures */ u32 TextureSource::getTextureIdDirect(const std::string &name) { //infostream<<"getTextureIdDirect(): name=\""<<name<<"\""<<std::endl; // Empty name means texture 0 if(name == "") { infostream<<"getTextureIdDirect(): name is empty"<<std::endl; return 0; } /* Calling only allowed from main thread */ if(get_current_thread_id() != m_main_thread) { errorstream<<"TextureSource::getTextureIdDirect() " "called not from main thread"<<std::endl; return 0; } /* See if texture already exists */ { JMutexAutoLock lock(m_textureinfo_cache_mutex); std::map<std::string, u32>::iterator n; n = m_name_to_id.find(name); if(n != m_name_to_id.end()) { /*infostream<<"getTextureIdDirect(): \""<<name <<"\" found in cache"<<std::endl;*/ return n->second; } } /*infostream<<"getTextureIdDirect(): \""<<name <<"\" NOT found in cache. Creating it."<<std::endl;*/ /* Get the base image */ char separator = '^'; /* This is set to the id of the base image. If left 0, there is no base image and a completely new image is made. */ u32 base_image_id = 0; // Find last meta separator in name s32 last_separator_position = -1; for(s32 i=name.size()-1; i>=0; i--) { if(name[i] == separator) { last_separator_position = i; break; } } /* If separator was found, construct the base name and make the base image using a recursive call */ std::string base_image_name; if(last_separator_position != -1) { // Construct base name base_image_name = name.substr(0, last_separator_position); /*infostream<<"getTextureIdDirect(): Calling itself recursively" " to get base image of \""<<name<<"\" = \"" <<base_image_name<<"\""<<std::endl;*/ base_image_id = getTextureIdDirect(base_image_name); } //infostream<<"base_image_id="<<base_image_id<<std::endl; video::IVideoDriver* driver = m_device->getVideoDriver(); assert(driver); video::ITexture *t = NULL; /* An image will be built from files and then converted into a texture. */ video::IImage *baseimg = NULL; // If a base image was found, copy it to baseimg if(base_image_id != 0) { JMutexAutoLock lock(m_textureinfo_cache_mutex); TextureInfo *ti = &m_textureinfo_cache[base_image_id]; if(ti->img == NULL) { infostream<<"getTextureIdDirect(): WARNING: NULL image in " <<"cache: \""<<base_image_name<<"\"" <<std::endl; } else { core::dimension2d<u32> dim = ti->img->getDimension(); baseimg = driver->createImage(video::ECF_A8R8G8B8, dim); ti->img->copyTo( baseimg, // target v2s32(0,0), // position in target core::rect<s32>(v2s32(0,0), dim) // from ); /*infostream<<"getTextureIdDirect(): Loaded \"" <<base_image_name<<"\" from image cache" <<std::endl;*/ } } /* Parse out the last part of the name of the image and act according to it */ std::string last_part_of_name = name.substr(last_separator_position+1); //infostream<<"last_part_of_name=\""<<last_part_of_name<<"\""<<std::endl; // Generate image according to part of name if(!generateImage(last_part_of_name, baseimg)) { errorstream<<"getTextureIdDirect(): " "failed to generate \""<<last_part_of_name<<"\"" <<std::endl; } // If no resulting image, print a warning if(baseimg == NULL) { errorstream<<"getTextureIdDirect(): baseimg is NULL (attempted to" " create texture \""<<name<<"\""<<std::endl; } if(baseimg != NULL) { // Create texture from resulting image t = driver->addTexture(name.c_str(), baseimg); } /* Add texture to caches (add NULL textures too) */ JMutexAutoLock lock(m_textureinfo_cache_mutex); u32 id = m_textureinfo_cache.size(); TextureInfo ti(name, t, baseimg); m_textureinfo_cache.push_back(ti); m_name_to_id[name] = id; /*infostream<<"getTextureIdDirect(): " <<"Returning id="<<id<<" for name \""<<name<<"\""<<std::endl;*/ return id; }
int main(int argc, char** argv) { // parse command unsigned int pos = 1; unsigned int mask = (argc >= 2) ? 0 : 0xFFFF; while(pos < argc) { unsigned int sceneNumber = atoi(argv[pos++]); mask |= 1 << sceneNumber; } // Initialize phong p32(32.0f); phong p64(64.0f); phong p16(16.0f); diffuse d; constantAlbedo red(color(1.0f, 0.0f, 0.0f)); constantAlbedo green(color(0.0f, 1.0f, 0.0f)); constantAlbedo blue(color(0.0f, 0.0f, 1.0f)); constantAlbedo white(color(1.0f, 1.0f, 1.0f)); std::vector<triangle> sphere = createSphere( vec3d(0.0f, 0.0f, 0.0f), 1.0f, 16, 16 ); std::vector<triangle> plane = createPlane( vec3d(-1.0f, -1.0f, 0.0f), vec3d(0.0f, 2.0f, 0.0f), vec3d(2.0f, 0.0f, 0.0f) ); material redMaterial; redMaterial.addComponent( reflectanceComponent(&red, &d) ); redMaterial.addComponent( reflectanceComponent(&white, &p32) ); material greenMaterial; greenMaterial.addComponent( reflectanceComponent(&green, &d) ); greenMaterial.addComponent( reflectanceComponent(&white, &p64) ); material blueMaterial; blueMaterial.addComponent( reflectanceComponent(&blue, &d) ); blueMaterial.addComponent( reflectanceComponent(&white, &p16) ); material whiteMaterial; whiteMaterial.addComponent( reflectanceComponent(&white, &d) ); triangleMesh redSphere(sphere, redMaterial); triangleMesh greenSphere(sphere, greenMaterial); triangleMesh blueSphere(sphere, blueMaterial); triangleMesh whitePlane(plane, whiteMaterial); sceneGraphObject redSphereObject(redSphere); sceneGraphObject greenSphereObject(greenSphere); sceneGraphObject blueSphereObject(blueSphere); sceneGraphObject whitePlaneObject(whitePlane); camera cam( vec3d(0.0f, 0.0f, 5.0f), vec3d(0.0f, 0.0f, -1.0f), vec3d(0.0f, 1.0f, 0.0f), 35.0f * M_PI / 180.0f, 512, 512 ); directionalLightsource ls( color(1.0f, 1.0f, 1.0f), vec3d(0.0f, -1.0f, -1.0f) ); directionalLightsource frontal( color(1.0f, 1.0f, 1.0f), vec3d(0.0f, 0.0f, -1.0f) ); ///////////////////////////////////////////////////// if((mask & 2) != 0) { sceneGraphNode sg1; sg1.addChildNode(redSphereObject); std::cout << "Generating Image 1." << std::endl; image result1 = generateImage(cam, sg1, ls); result1.save("hw4-result1.ppm"); } ///////////////////////////////////////////////////// if((mask & 4) != 0) { sceneGraphNode sg2node1(translation3d(vec3d(+1.0f, 0.0f, 0.0f))); sg2node1.addChildNode(redSphereObject); sceneGraphNode sg2node2(translation3d(vec3d(-1.0f, 0.0f, 0.0f))); sg2node2.addChildNode(blueSphereObject); sceneGraphNode sg2; sg2.addChildNode(sg2node1); sg2.addChildNode(sg2node2); std::cout << "Generating Image 2." << std::endl; image result2 = generateImage(cam, sg2, ls); result2.save("hw4-result2.ppm"); } ///////////////////////////////////////////////////// if((mask & 8) != 0) { sceneGraphNode sg3node1(scale3d(2.0f, 0.5f, 0.5f)); sg3node1.addChildNode(greenSphereObject); sceneGraphNode sg3; sg3.addChildNode(sg3node1); std::cout << "Generating Image 3." << std::endl; image result3 = generateImage(cam, sg3, ls); result3.save("hw4-result3.ppm"); } ///////////////////////////////////////////////////// if((mask & 16) != 0) { sceneGraphNode sg2node1(translation3d(vec3d(+1.0f, 0.0f, 0.0f))); sg2node1.addChildNode(redSphereObject); sceneGraphNode sg2node2(translation3d(vec3d(-1.0f, 0.0f, 0.0f))); sg2node2.addChildNode(blueSphereObject); sceneGraphNode sg2; sg2.addChildNode(sg2node1); sg2.addChildNode(sg2node2); sceneGraphNode sg4node1(rotationY3d(M_PI)); sg4node1.addChildNode(sg2); sceneGraphNode sg4; sg4.addChildNode(sg4node1); std::cout << "Generating Image 4." << std::endl; image result4 = generateImage(cam, sg4, ls); result4.save("hw4-result4.ppm"); } ///////////////////////////////////////////////////// if((mask & 32) != 0) { sceneGraphNode sg5node0(scale3d(0.5f, 0.5f, 0.5f)); sceneGraphNode sg5node1(rotationY3d(0.5 * M_PI)); sceneGraphNode sg5node2(rotationX3d(0.5 * M_PI)); sceneGraphNode sg5node3(translation3d(vec3d(0.0f, 2.0f, 0.0f))); sceneGraphNode sg5node4(rotationX3d(0.5 * M_PI)); sceneGraphNode sg5node5(translation3d(vec3d(0.0f, 2.0f, 0.0f))); sceneGraphNode sg5node6(rotationX3d(0.5 * M_PI)); sceneGraphNode sg5node7(translation3d(vec3d(0.0f, 2.0f, 0.0f))); sceneGraphNode sg5node8(rotationX3d(0.5 * M_PI)); sceneGraphNode sg5node9(translation3d(vec3d(0.0f, 2.0f, 0.0f))); sceneGraphNode sg5; sg5.addChildNode(sg5node0); sg5node0.addChildNode(sg5node1); sg5node1.addChildNode(sg5node2); sg5node2.addChildNode(sg5node3); sg5node3.addChildNode(redSphereObject); sg5node3.addChildNode(sg5node4); sg5node4.addChildNode(sg5node5); sg5node5.addChildNode(greenSphereObject); sg5node5.addChildNode(sg5node6); sg5node6.addChildNode(sg5node7); sg5node7.addChildNode(blueSphereObject); sg5node7.addChildNode(sg5node8); sg5node8.addChildNode(sg5node9); sg5node9.addChildNode(blueSphereObject); std::cout << "Generating Image 5." << std::endl; image result5 = generateImage(cam, sg5, ls); result5.save("hw4-result5.ppm"); } ///////////////////////////////////////////////////// if((mask & 64) != 0) { sceneGraphNode cubeside( translation3d(vec3d(0.0f, 0.0f, 1.0f)) ); cubeside.addChildNode(whitePlaneObject); sceneGraphNode cubeNode1( rotationY3d(0.0f / 2.0f * M_PI) ); cubeNode1.addChildNode(cubeside); sceneGraphNode cubeNode2( rotationY3d(1.0f / 2.0f * M_PI) ); cubeNode2.addChildNode(cubeside); sceneGraphNode cubeNode3( rotationY3d(2.0f / 2.0f * M_PI) ); cubeNode3.addChildNode(cubeside); sceneGraphNode cubeNode4( rotationY3d(3.0f / 2.0f * M_PI) ); cubeNode4.addChildNode(cubeside); sceneGraphNode cubeNode5( rotationX3d(0.5f * M_PI) ); cubeNode5.addChildNode(cubeside); sceneGraphNode cubeNode6( rotationX3d(-0.5f * M_PI) ); cubeNode6.addChildNode(cubeside); sceneGraphNode cube; cube.addChildNode(cubeNode1); cube.addChildNode(cubeNode2); cube.addChildNode(cubeNode3); cube.addChildNode(cubeNode4); cube.addChildNode(cubeNode5); cube.addChildNode(cubeNode6); sceneGraphNode sg6( rotation3d(0.25*M_PI, vec3d(1.0f, 0.75f, 0.5f)) ); sg6.addChildNode(cube); std::cout << "Generating Image 6." << std::endl; image result6 = generateImage(cam, sg6, frontal); result6.save("hw4-result6.ppm"); } // Done. return 0; }
void GameWidget::keyPressEvent(QKeyEvent *event) { if (animation_en_cours || moteur->gameOver() || moteur->levelCompleted()) { //event->ignore(); QWidget::keyPressEvent(event); return; } RETOURMVT retourmvt=RET_MONTAGNE; switch (event->key()) { case Qt::Key_Left: retourmvt=moteur->moveTuxFisher(MVT_GAUCHE); break; case Qt::Key_Right: retourmvt=moteur->moveTuxFisher(MVT_DROITE); break; case Qt::Key_Down: retourmvt=moteur->moveTuxFisher(MVT_BAS); break; case Qt::Key_Up: retourmvt=moteur->moveTuxFisher(MVT_HAUT); break; case Qt::Key_Backspace: retourmvt = moteur->getBackToPrevMap(); break; default: QWidget::keyPressEvent(event); //event->ignore(); return; } switch (retourmvt) { case RET_POISSON: timer_animation->start(0); emit addMove(true); audio->playSound(son_fish, false); break; case RET_MONTAGNE: case RET_AVALANCHE: case RET_RIEN: audio->playSound(son_montagne, false); break; case RET_RETOUR: emit addMove(false); break; case RET_NEIGE: case RET_VIDE: timer_animation->start(0); emit addMove(true); break; default: break; } if (moteur->levelCompleted()) { tuxfisher = tuxfisher_gagne; audio->playSound(son_victoire); emit levelCompleted(); } generateImage(); }