/*!\brief Base constructor. * * It sets default values for class attributes. It initializes the filter and applies it to a white noise to generate the final noise (#loadNoise). * \arg tStep = 0.01 * \arg tDurAdd = 1.0 * \arg tFirst = 5.0 * \arg tLast = -20.0 * \arg NoiseType = Filter * \arg alpha coefficients of #NFilter = 0 (see Filter#alpha) * \arg beta parameter of #NFilter = 1 (see Filter#beta) * \arg NbDataStab parameter of #NFilter = 0 (see Filter#NbDataStab) */ NoiseTwoFilter::NoiseTwoFilter() { tStep = 0.01; tDurAdd = 1.0; tFirst = 5.0; tLast = -20.0; /*! \todo Make a function to compute a int from a double. Is there a reason to no call rint ?*/ NbData = (int)((tFirst-tLast)/tStep+100*PRECISION); vector< vector<double> > alpha_tmp(0); vector< vector<double> > beta_tmp(0); vector<double> TmpVect(1); TmpVect.push_back(1.0); beta_tmp.push_back(TmpVect); NFilter.init(alpha_tmp, beta_tmp, 0); NFilter_2.init(alpha_tmp, beta_tmp, 0); loadNoise(); strcpy(NoiseType,"Filter"); }
/*! \brief Constructor. * * It sets class attributes including the noise filter. * It applies the filter to a white noise to generate the final noise (see #loadNoise)). * #NoiseType attribute is set to \p File. * \param tStep_n Value of #tStep. * \param tDurAdd_n Value of #tDurAdd. * \param tFirst_n Value of #tFirst. * \param tLast_n Value of #tLast. * \param NFilter_n Filter for #NFilter. * \param NFilter_n2 Filter for #NFilter. */ NoiseTwoFilter::NoiseTwoFilter( double tStep_n, double tDurAdd_n, double tFirst_n, double tLast_n, Filter NFilter_n, Filter NFilter_n2) { //cout << "In Noise Filter" << endl; settStep(tStep_n); settDurAdd(tDurAdd_n); settFirst(tFirst_n); settLast(tLast_n); NbData = (int)((tFirst-tLast)/tStep+100*PRECISION); NFilter.Copy(NFilter_n); NFilter_2.Copy(NFilter_n2); loadNoise(); strcpy(NoiseType,"NoiseTwoFilter"); // ????? }
/** * Start speech * @remarks Originally called 'parole' */ void SpeechManager::startSpeech(int rep, int ht, int typ) { uint16 savph[501]; int tempo; if (_vm->_soundOff) return; _phonemeNumb = rep; int haut = ht; _typlec = typ; if (_typlec != 0) { for (int i = 0; i <= 500; ++i) savph[i] = _cfiphBuffer[i]; tempo = kTempoNoise; } else if (haut > 5) tempo = kTempoF; else tempo = kTempoM; _vm->_addFix = (float)((tempo - 8)) / 256; cctable(_tbi); switch (typ) { case 1: loadNoise(); regenbruit(); break; case 2: loadMusicSound(); loadPhonemeSounds(); break; default: break; } handlePhoneme(); _vm->_soundManager.litph(_tbi, typ, tempo); if (_typlec != 0) for (int i = 0; i <= 500; ++i) { _cfiphBuffer[i] = savph[i]; _mlec = _typlec; } _vm->setPal(_vm->_numpal); }
int main() { // SFML window that will host our OpenGL magic sf::Window window(sf::VideoMode(1920, 1080), "OpenGL", sf::Style::Default, sf::ContextSettings(32)); window.setVerticalSyncEnabled(true); window.setMouseCursorVisible(false); sf::View view; sf::Mouse::setPosition(sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2), window); glewInit(); Player player; programInit(shaderMap, modelMap, textureMap, normalMap); initPresetSystem(shaderMap, modelMap, textureMap, normalMap, presetMap); Editor editor(modelMap, shaderMap, textureMap, normalMap, presetMap); GLInit(); // ---------------------- MODELS ------------------------------- Model sphereModel, unitSquareModel; generateSphere(&sphereModel, 50); sphereModel.upload(); myLoadObj("Models/unitSquare.obj", &unitSquareModel); unitSquareModel.upload(); loadNoise(); // Add terrain information to earth cv::Mat earthBumpMap = cv::imread("Textures/earthBumpMap.jpg"); earthBumpMap.convertTo(earthBumpMap, CV_32F); int height = earthBumpMap.rows; int width = earthBumpMap.cols; std::cout << "Dims: " << height << ", " << width << std::endl; std::cout << "Dims: " << *earthBumpMap.row(height-1).col(5).ptr<float>() << std::endl; // ---------------------- OBJECTS ------------------------------- // Initiation of all objects in the program // ShaderParameters = (ambientCoeff, diffuseCoeff, specularCoeff, specularExponent) cv::Vec4f standardShaderParameters(0.2f, 0.5f, 0.8f, 10); Object squareNormalMap, squareSpecularityMap; GLuint earthNormalMap, earthSpecularityMap, earthTextureDay, earthTextureNight; GLuint normalMapShader, specularityMapShader; shaderInit(&phongNoTex, "Shaders/phongNoTex.vert", "Shaders/phongNoTex.frag"); shaderInit(&normalMapShader, "Shaders/normalMap.vert", "Shaders/normalMap.frag"); shaderInit(&specularityMapShader, "Shaders/specularityMap.vert", "Shaders/specularityMap.frag"); LoadTGATextureSimple("Textures/earthTextureDay.tga", &earthTextureDay); LoadTGATextureSimple("Textures/earthTextureNight.tga", &earthTextureNight); LoadTGATextureSimple("Textures/earthNormalMap.tga", &earthNormalMap); LoadTGATextureSimple("Textures/earthSpecularityMap.tga", &earthSpecularityMap); //squareNormalMap.init(&unitSquareModel, phongNoTex, standardShaderParameters, 0, 0, 0, earthNormalMap); squareNormalMap.init(&unitSquareModel, normalMapShader, standardShaderParameters, 0, 0, 0, earthNormalMap); squareSpecularityMap.init(&unitSquareModel, specularityMapShader, standardShaderParameters, earthTextureDay, earthTextureNight, earthSpecularityMap, earthNormalMap); squareNormalMap.set(cv::Vec3f(100,0,0), cv::Vec3f(50,50,100), cv::Vec3f(0, pi/2, -pi/2), cv::Vec3f(0,0,0), 1); squareSpecularityMap.set(cv::Vec3f(100,0,0), cv::Vec3f(50,50,100), cv::Vec3f(0, pi/2, -pi/2), cv::Vec3f(0,0,0), 1); // ---------------------- SKYSPHERE ------------------------------- Object skysphere; GLuint skysphereTexture, skyboxShader; LoadTGATextureSimple("Textures/spaceBox6.tga", &skysphereTexture); shaderInit(&skyboxShader, "Shaders/skybox.vert", "Shaders/skybox.frag"); skysphere.init(&sphereModel, skyboxShader, standardShaderParameters, skysphereTexture); skysphere.set(player.position, cv::Vec3f(1,1,1), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1); int item; // SFML built-in clock sf::Clock clock; states[RUNNING] = true; states[EDITOR] = true; states[STARTUP] = true; /* bool running = true; bool runningEditor = true; bool startup = true; bool selectObject = false; bool cooldown = false; */ Object* currentObject = NULL; Object* playerObject = NULL; while (states[RUNNING]) { dt = clock.getElapsedTime().asSeconds(); if(states[EDITOR]) { window.setVisible(false); if(states[SELECTOBJECT]) { solsystem.getObjects(&allObjects); currentObject = getSelectedObject(&allObjects, &player); allObjects.clear(); } editor.edit(solsystem, states, currentObject); states[STARTUP] = false; sf::Mouse::setPosition(sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2), window); clock.restart(); window.setActive(); states[SELECTOBJECT] = false; currentObject = NULL; states[EDITOR] = false; window.setVisible(true); } else { clock.restart(); if (playerObject != NULL) { std::cout << player.position << std::endl; player.move(playerObject->position); //player.position = playerObject->position; std::cout << playerObject->position << std::endl; } handleEvents(&window, states, &item, playerObject, &player, dt); player.lookAtUpdate(dt); // Plocka ut all planeters positioner std::list<Object*> allObjects; solsystem.getObjects(&allObjects); std::vector<cv::Vec3f> positionVector; std::vector<cv::Vec3f> radiusVector; std::list<Object*>::iterator i = allObjects.begin(); for (i++ ; i != allObjects.end(); ++i) { positionVector.push_back((*i)->position); radiusVector.push_back((*i)->scale); //std::cout << "Scale: " << (*i)->scale << std::endl; } int numberOfPlanets = positionVector.size(); GLfloat* positions = makeArray(positionVector); GLfloat* radius = makeArray(radiusVector); ///////////////////////////////// SKYBOX ///////////////////////////////////////// window.setActive(); //drawSkybox(&player, &skyboxModel, skyboxShader, skyboxTexture); glDisable(GL_DEPTH_TEST); //skybox.set(player.position, cv::Vec3f(5,5,5), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1); //skybox.draw(&player); skysphere.set(player.position, cv::Vec3f(5,5,5), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1); skysphere.draw(&player, 0, dt); glEnable(GL_DEPTH_TEST); ///////////////////////////////// ALX ///////////////////////////////////////// if (states[NORMALMAP]) { squareNormalMap.draw(&player, dt, numberOfPlanets, positions, radius); } if (states[SPECULARITYMAP]) { squareSpecularityMap.draw(&player, dt, numberOfPlanets, positions, radius); } ///////////////////////////////// ALX ///////////////////////////////////////// if(!states[COOLDOWN] && item == 1) { Object* newItem = presetMap["Earth"]->clone(); newItem->set(player.position, cv::Vec3f(0.25,0.25,0.25), cv::Vec3f(0,0,0), 10*player.getLookAtDirection(), 1); solsystem.addItem(newItem); std::cout << 10*normalize(player.position - player.lookAtVector) << std::endl; states[COOLDOWN] = true; } item = 0; if(states[ENABLEGRAVITY] && playerObject == NULL) { playerObject = presetMap["Earth"]->clone(); playerObject->set(player.position, cv::Vec3f(1.25,1.25,1.25), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1); solsystem.addPlayerItem(playerObject); states[ENABLEGRAVITY] = false; } if(states[DISABLEGRAVITY] && playerObject != NULL) { solsystem.removePlayerItem(); playerObject = NULL; states[DISABLEGRAVITY] = false; } solsystem.update(physEngine, dt*0.5); solsystem.draw(&player, accTime); accTime += dt; window.display(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } cv::waitKey(0); } // release resources... glDeleteVertexArrays(1, &sphereModel.VAO); //glDeleteVertexArrays(1, &skyboxModel.VAO); //glDeleteVertexArrays(1, &unitSquareModel.VAO); //glDeleteVertexArrays(1, &groundModel.VAO); return 0; }
NoiseOof::NoiseOof( double tStep_n, // IN : Time step double tDurAdd_n, // IN : Time add for each adding of noise double tFirst_n, // IN : Time of the first bin (>0) double tLast_n, // IN : Time of the last bin (<0) double fmin_n, // IN : Minimal frequency for the range where the filter have the good shape double fmax_n, // IN : Maximal frequency for the range where the filter have the good shape double alpha_n, // IN : Power of f --> Shape : f^alpha int Nb_Ageing_n // IN : Number of events before stabilization. ) { settStep(tStep_n); settDurAdd(tDurAdd_n); settFirst(tFirst_n); settLast(tLast_n); fmin = fmin_n; fmax = fmax_n; alpha = alpha_n; Nb_Ageing = Nb_Ageing_n; /* cout << "fmin = " << fmin << endl; cout << "fmax = " << fmax << endl; cout << "alpha = " << alpha << endl; */ /*! \todo Make a function to compute a int from a double. Is there a reason to no call rint ?*/ NbData = (int)((tFirst-tLast)/tStep+100*PRECISION); vector< vector<double> > alpha_tmp(0); vector< vector<double> > beta_tmp(0); // Calcul des poles. double w0,w1,wmax,wmin; double p0,z0,dp; double p,z,pcourant,zcourant,dpcourant,den,tStep_inv; int nproc; w0 = 2*M_PI*fmin; w1 = 2*M_PI*fmax; wmax = log10(w1); wmin = log10(w0); //printf(" w0 = %f , w1 = %f , wmax = %f, wmin = %f, tStep = %f \n", w0,w1, wmax,wmin,tStep); tStep_inv = 1./tStep; nproc = (int)((wmax-wmin)*2.+log10(tStep_inv)); // Nombres de poles. alpha_tmp.resize(nproc); beta_tmp.resize(nproc); dp = (wmax-wmin)/nproc; p0 = wmin+(1+alpha/2)/2*dp; z0 = p0-alpha/2*dp; pcourant = p0; zcourant = z0; dpcourant = 0.; for(int i=0;i<nproc;i++) { p = pcourant+dpcourant; dpcourant = (wmax-wmin)/nproc; z = p-alpha/2*dp; w0 = (pow(10,p)/2)*tStep; w1 = (pow(10,z)/2)*tStep; pcourant = p; zcourant = z; den = 1+w0; alpha_tmp[i].resize(1); beta_tmp[i].resize(2); alpha_tmp[i][0]=(1-w0)/den; beta_tmp[i][0]=(1+w1)/den; beta_tmp[i][1]=-(1-w1)/den; //printf(" filtre %d : alpha0 = %f , beta0 = %f , beta1 = %f \n", i, alpha_tmp[i][0], beta_tmp[i][0], beta_tmp[i][1]); } NFilter.init(alpha_tmp, beta_tmp, Nb_Ageing); //NFilter.init(alpha_tmp, beta_tmp, 0); loadNoise(); ///cout << " - WhiteData size = " << WhiteData.size() << endl; ///cout << " - NoiseData size = " << NoiseData.size() << endl; ///for(int i=0; i<10; i++) /// cout << " WhiteData[i] = " << WhiteData[i] << " - NoiseData[i] = " << NoiseData[i] << endl; strcpy(NoiseType,"Oof"); }