Exemplo n.º 1
0
//--------------------------------------------------------------
void ofApp::setup(){
    // 画面基本設定
    ofSetFrameRate(60);
    ofSetBackgroundAuto(false);
    ofBackground(0);
    
//    ofNoFill();
    ofSetColor(255, 255, 0);
    
    gui.setup();
    gui.add(refresh.setup("refresh", 100, 100, 3000));
    gui.add(speed.setup("speed", 8.0, 0.0, 20.0));
    gui.add(defSize.setup("Default size", 10, 1, 20));
    gui.add(size.setup("radius size", 0.1, 0, 10));
    gui.add(forceX.setup("FORCE X", 0.01, 0, 1));
    gui.add(forceY.setup("FORCE Y", 0.01, 0, 1));
    gui.add(forceZ.setup("FORCE Z", 0.01, 0, 1));
    gui.add(forceSeedX.setup("FORCE SEED X", 0.01, 0, 1));
    gui.add(forceSeedY.setup("FORCE SEED Y", 0.01, 0, 1));
    gui.add(forceSeedZ.setup("FORCE SEED Z", 0.01, 0, 1));
    gui.add(colorStart.setup("C1", 0.1, 0, 1));
    gui.add(colorEnd.setup("C2", 0.4, 0, 1));
    gui.add(shape.setup("PARTICLE SHAPE", 0, 0, 3));
    
    gui.loadFromFile("settings.xml");

//	light.enable();
    initParticles();
}
Exemplo n.º 2
0
void keyboard(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 27:
            g_bExitESC = true;
            exit(EXIT_SUCCESS);
            break;

        case 'r':
            memset(hvfield, 0, sizeof(cData) * DS);
            cudaMemcpy(dvfield, hvfield, sizeof(cData) * DS,
                       cudaMemcpyHostToDevice);

            initParticles(particles, DIM, DIM);

            cudaGraphicsUnregisterResource(cuda_vbo_resource);

            getLastCudaError("cudaGraphicsUnregisterBuffer failed");

            glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
            glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(cData) * DS,
                            particles, GL_DYNAMIC_DRAW_ARB);
            glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

            cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, vbo, cudaGraphicsMapFlagsNone);

            getLastCudaError("cudaGraphicsGLRegisterBuffer failed");
            break;

        default:
            break;
    }
}
Exemplo n.º 3
0
int main(int argc, char *argv[])
{
    param params;
    AABB water_volume;
    AABB boundary_volume;
    fluid_particle *fluid_particles = NULL;
    boundary_particle *boundary_particles = NULL;
    initParams(&water_volume, &boundary_volume, &params);

    initParticles(&fluid_particles, &boundary_particles, &water_volume,
                  &boundary_volume, &params);

    eulerStart(fluid_particles, boundary_particles, &params);

    // Main simulation loop
    #pragma acc enter data copyin(fluid_particles[0:params.number_fluid_particles], boundary_particles[0:params.number_boundary_particles],params[0:1])
    for(int n=0; n<params.number_steps; n++) {
        updatePressures(fluid_particles, &params);

        updateAccelerations(fluid_particles, boundary_particles, &params);

        updatePositions(fluid_particles, &params);

        if (n % params.steps_per_frame == 0) {
            #pragma acc update host(fluid_particles[0:params.number_fluid_particles])
            writeFile(fluid_particles, &params);
       }
    }

    #pragma acc exit data delete(fluid_particles[0:params.number_fluid_particles],boundary_particles[0:params.number_boundary_particles],params[0:1])
    finalizeParticles(fluid_particles, boundary_particles);
    return 0;
}
Exemplo n.º 4
0
/**
 * Hier findet die komplette Initialisierung des kompletten SPIEeles statt.
 * Inklusive der Datenhaltung und des SPIEelfeldes.
 */
void initGame ()
{   
    initCameraPosition();
    initSpheres();
    initQuads();
    initParticles();
}
Exemplo n.º 5
0
void init( ) {
    int x, z;
    
    glShadeModel(GL_SMOOTH);
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClearDepth(1.0);
    glEnable(GL_DEPTH_TEST);
    
    // Ground Verticies
    // Ground Colors
    for (z = 0; z < 21; z++) {
        for (x = 0; x < 21; x++) {
            ground_points[x][z][0] = x - 10.0;
            ground_points[x][z][1] = accum;
            ground_points[x][z][2] = z - 10.0;
            
            ground_colors[z][x][0] = r; // red value
            ground_colors[z][x][1] = g; // green value
            ground_colors[z][x][2] = b; // blue value
            ground_colors[z][x][3] = 0.0; // acummulation factor
        }
    }
    
    // Initialize particles
    for (loop = 0; loop < MAX_PARTICLES; loop++) {
        initParticles(loop);
    }
}
Exemplo n.º 6
0
int main(int argc, char *argv[])
{
    param params;
    AABB water_volume;
    AABB boundary_volume;
    fluid_particle *fluid_particles = NULL;
    boundary_particle *boundary_particles = NULL;
    initParams(&water_volume, &boundary_volume, &params);

    initParticles(&fluid_particles, &boundary_particles, &water_volume,
                  &boundary_volume, &params);

    eulerStart(fluid_particles, boundary_particles, &params);

    // Main simulation loop
    for(int n=0; n<params.number_steps; n++) {
        updatePressures(fluid_particles, &params);

        updateAccelerations(fluid_particles, boundary_particles, &params);

        updatePositions(fluid_particles, &params);

        if (n % params.steps_per_frame == 0) {
            writeFile(fluid_particles, &params);
        }
    }

    finalizeParticles(fluid_particles, boundary_particles);
    return 0;
}
Exemplo n.º 7
0
void GLWidget::initializeGL()
{
    qDebug() << "Initializing OpenGL";

    qglClearColor(QColor(20, 20, 20));

    initShaders();
    initParticles();
    initVBOs();

    psTexture = bindTexture(pointSpriteImage, GL_TEXTURE_2D, GL_RGBA);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    velTexture = bindTexture(paletteImage, GL_TEXTURE_2D, GL_RGBA);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
    qDebug() << "OpenGL initialized.";
    
    initializeCL();
    
}
Exemplo n.º 8
0
int main(int argc, char *argv[])
{
    param params;
    AABB water_volume;
    AABB boundary_volume;
    fluid_particle *fluid_particles = NULL;
    boundary_particle *boundary_particles = NULL;
    initParams(&water_volume, &boundary_volume, &params);

    initParticles(&fluid_particles, &boundary_particles, &water_volume,
                  &boundary_volume, &params);

    eulerStart(fluid_particles, boundary_particles, &params);

    // Main simulation loop
    // Hint: Copy fluid_particles(params.number_fluid_particles), boundary_particles(params.number_boundary_particles), and params(1)
    for(int n=0; n<params.number_steps; n++) {
        updatePressures(fluid_particles, &params);

        updateAccelerations(fluid_particles, boundary_particles, &params);

        updatePositions(fluid_particles, &params);

        if (n % params.steps_per_frame == 0) {
            // Hint: Make sure to update the host fluid_particle data
            writeFile(fluid_particles, &params);
        }
    }

    // Hint: delete any acc data allocated
    finalizeParticles(fluid_particles, boundary_particles);
    return 0;
}
Exemplo n.º 9
0
template <typename PointInT, typename StateT> bool
pcl::tracking::KLDAdaptiveParticleFilterTracker<PointInT, StateT>::initCompute ()
{
  if (!Tracker<PointInT, StateT>::initCompute ())
  {
    PCL_ERROR ("[pcl::%s::initCompute] Init failed.\n", getClassName ().c_str ());
    return (false);
  }

  if (transed_reference_vector_.empty ())
  {
    // only one time allocation
    transed_reference_vector_.resize (maximum_particle_number_);
    for (unsigned int i = 0; i < maximum_particle_number_; i++)
    {
      transed_reference_vector_[i] = PointCloudInPtr (new PointCloudIn ());
    }
  }
  
  coherence_->setTargetCloud (input_);

  if (!change_detector_)
    change_detector_ = boost::shared_ptr<pcl::octree::OctreePointCloudChangeDetector<PointInT> >(new pcl::octree::OctreePointCloudChangeDetector<PointInT> (change_detector_resolution_));
  
  if (!particles_ || particles_->points.empty ())
    initParticles (true);
  return (true);
}
Exemplo n.º 10
0
// For Rain
void drawRain() {
    float x, y, z;
    for (loop = 0; loop < MAX_PARTICLES; loop=loop+2) {
        if (par_sys[loop].alive == true) {
            x = par_sys[loop].xpos;
            y = par_sys[loop].ypos;
            z = par_sys[loop].zpos + zoom;
            
            // Draw particles
            glColor3f(0.5, 0.5, 1.0);
            glBegin(GL_LINES);
            glVertex3f(x, y, z);
            glVertex3f(x, y+0.5, z);
            glEnd();
            
            // Update values
            //Move
            // Adjust slowdown for speed!
            par_sys[loop].ypos += par_sys[loop].vel / (slowdown*1000);
            par_sys[loop].vel += par_sys[loop].gravity;
            // Decay
            par_sys[loop].life -= par_sys[loop].fade;
            
            if (par_sys[loop].ypos <= -10) {
                par_sys[loop].life = -1.0;
            }
            //Revive
            if (par_sys[loop].life < 0.0) {
                initParticles(loop);
            }
        }
    }
}
Exemplo n.º 11
0
void main(void) {
  int gd = CUSTOM, gm = CUSTOM_MODE(1024,768);
  int page = 0;
  g_mousestate curState;
  g_mousestate oldState;
  int scrolling = 0;
  
  initgraph(&gd, &gm, "");
  
  initParticles(particles);
  
  while(!anykeypressed()) {
    getmousestate(&curState);
    if((curState.buttons & MOUSE_LEFTBUTTON) == 0) {
      scrolling = 0;
    } else {
      if(scrolling == 0) {
        scrolling = 1;
        getmousestate(&oldState);
      } else {
        orgX -= -curState.x + oldState.x;
        orgY += -curState.y + oldState.y;
        oldState = curState;
      }
    }
    updateParticles(particles, particles2);
	setactivepage(1 - page);
    clearviewport();
	drawParticles(particles);
	setvisualpage(1 - page);
    page = 1 - page;
	delay(4);
  }
  closegraph();
}
/// \param effectDef XML tag containing the effect definition
ParticleEffect::ParticleEffect(TiXmlElement *effectDef)
{
    // assign defaults
    m_nTotalParticleCount = 0;
    m_bCycleParticles = true;
    m_bIsDead = false;
    m_IsDying = false;
    m_nLiveParticleCount = 0;
    m_fEmitPartial = 1.0f; // start with at least one particle
    m_vecGravity = Vector3::kZeroVector;
    m_vecPosition = Vector3::kZeroVector;
    m_txtParticleTexture = NULL;
    m_UpdateFunc.clear();
    m_InitFunc.clear();

    m_fPILife = 1.0f;
    m_fPISpeed = 100.0f;
    m_fPIDragValue = 0.0f;
    m_PIFadeIn = 0.0f;
    m_PIFadeOut = 1.0f;
    m_PIFadeMax = 1.0f;
    m_PIRotationSpeed = 0.0f;
    m_PIRotationStopTime = 0.0f;
    m_distFunc = NULL;

    // default emit rate is all at once (or at least all in the first .01 secs)
    m_nEmitRate = m_nTotalParticleCount * 100;
    m_sort = false;

    m_vertBuffer = NULL;
    m_indexBuffer = NULL;

    // get system data
    effectDef->Attribute("particleCount", &m_nTotalParticleCount);
    const char *filename = effectDef->Attribute("textureName");

    // initialize effect properties from the xml tag
    initProperties(effectDef);

    // allocate memory needed
    m_Particles = new Particle[m_nTotalParticleCount];
    m_drawOrder = new int[m_nTotalParticleCount];

    initParticles();

    // create vertex and index buffers, and initialize index buffer. We can
    // create the index buffer as static since it doesn't change values; this
    // will increase performance a little.
    m_vertBuffer = new VertexLBuffer(m_nTotalParticleCount * 4, true);
    m_indexBuffer = new IndexBuffer(m_nTotalParticleCount * 2);
    initIndexBuffer();

    // this should be replaced with the renderer version of loading a texture
    gDirectoryManager.setDirectory(eDirectoryTextures);
    D3DXIMAGE_INFO structImageInfo; //image information
    HRESULT hres=D3DXCreateTextureFromFileEx(pD3DDevice, filename,
                 0,0,1,0,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,D3DX_FILTER_NONE,
                 D3DX_DEFAULT,0,&structImageInfo,NULL, &m_txtParticleTexture);
}
Exemplo n.º 13
0
void Init()
{
	initD3D();
	initParticles();
	initVertexData();
	initRectangleVertexes();
	initEffect();
}
Exemplo n.º 14
0
Arquivo: main.cpp Projeto: puffski/SPH
void init()
{
	// General Graphics
	glClearColor(0.1, 0.1, 0.1, 1);	
	glEnable(GL_DEPTH_TEST);
	//particle  initiation
	initParticles();
}
  void PlaneSupportedCuboidEstimator::cloudCallback(
    const sensor_msgs::PointCloud2::ConstPtr& msg)
  {
    boost::mutex::scoped_lock lock(mutex_);
    NODELET_INFO("cloudCallback");
    if (!latest_polygon_msg_ || !latest_coefficients_msg_) {
      JSK_NODELET_WARN("Not yet polygon is available");
      return;
    }

    if (!tracker_) {
      NODELET_INFO("initTracker");
      // Update polygons_ vector
      polygons_.clear();
      for (size_t i = 0; i < latest_polygon_msg_->polygons.size(); i++) {
        Polygon::Ptr polygon = Polygon::fromROSMsgPtr(latest_polygon_msg_->polygons[i].polygon);
        polygons_.push_back(polygon);
      }
      // viewpoint
      tf::StampedTransform transform
        = lookupTransformWithDuration(tf_, sensor_frame_, msg->header.frame_id,
                                      ros::Time(0.0),
                                      ros::Duration(0.0));
      tf::vectorTFToEigen(transform.getOrigin(), viewpoint_);
      
      ParticleCloud::Ptr particles = initParticles();
      tracker_.reset(new pcl::tracking::ROSCollaborativeParticleFilterTracker<pcl::PointXYZ, pcl::tracking::ParticleCuboid>);
      tracker_->setCustomSampleFunc(boost::bind(&PlaneSupportedCuboidEstimator::sample, this, _1));
      tracker_->setLikelihoodFunc(boost::bind(&PlaneSupportedCuboidEstimator::likelihood, this, _1, _2));
      tracker_->setParticles(particles);
      tracker_->setParticleNum(particle_num_);
      support_plane_updated_ = false;
      // Publish histograms
      publishHistogram(particles, 0, pub_histogram_global_x_, msg->header);
      publishHistogram(particles, 1, pub_histogram_global_y_, msg->header);
      publishHistogram(particles, 2, pub_histogram_global_z_, msg->header);
      publishHistogram(particles, 3, pub_histogram_global_roll_, msg->header);
      publishHistogram(particles, 4, pub_histogram_global_pitch_, msg->header);
      publishHistogram(particles, 5, pub_histogram_global_yaw_, msg->header);
      publishHistogram(particles, 6, pub_histogram_dx_, msg->header);
      publishHistogram(particles, 7, pub_histogram_dy_, msg->header);
      publishHistogram(particles, 8, pub_histogram_dz_, msg->header);
      // Publish particles
      sensor_msgs::PointCloud2 ros_particles;
      pcl::toROSMsg(*particles, ros_particles);
      ros_particles.header = msg->header;
      pub_particles_.publish(ros_particles);
      
    }
    else {
      ParticleCloud::Ptr particles = tracker_->getParticles();
      Eigen::Vector4f center;
      pcl::compute3DCentroid(*particles, center);
      if (center.norm() > fast_cloud_threshold_) {
        estimate(msg);
      }
    }
  }
void ParticleEffect::start()
{
    initParticles();
    m_bIsDead = false;
    m_IsDying = false;

    m_nLiveParticleCount = 0;
    m_fEmitPartial = 1.0f;
}
Exemplo n.º 17
0
ParticleGenerator::ParticleGenerator(int maxParticles, std::string vertexShader, std::string fragmentShader) {
    mMaxParticles = maxParticles;
    mParticles = new Particle[maxParticles];

    mShader.loadVertexShader(vertexShader);
    mShader.loadFragmentShader(fragmentShader);

    initParticles();
}
Exemplo n.º 18
0
void keyboard(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 27:
            g_bExitESC = true;
            exit(EXIT_SUCCESS);
            break;
        
        case 'f':
        	if (!fullscreen)
        	{
        		fullscreen = 1;
				glutFullScreenToggle();
			}
			else
			{
				fullscreen = 0;
				glutLeaveFullScreen();
			}
			break;

        case 'r':
			pthread_mutex_lock(&display_mutex);
            memset(hvfield, 0, sizeof(cData) * DS);
            cudaMemcpy(dvfield, hvfield, sizeof(cData) * DS,
                       cudaMemcpyHostToDevice);

            initParticles(particles, DIM, DIM);

#ifndef OPTIMUS
            cudaGraphicsUnregisterResource(cuda_vbo_resource);
            getLastCudaError("cudaGraphicsUnregisterBuffer failed");
#endif

#if defined(OPTIMUS) || defined(BROADCAST)
            cudaMemcpy(particles_gpu, particles, sizeof(cData) * DS, cudaMemcpyHostToDevice);
#endif

            glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
            glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(cData) * DS,
                            particles, GL_DYNAMIC_DRAW_ARB);
            glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

#ifndef OPTIMUS
            cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, vbo, cudaGraphicsMapFlagsNone);
            getLastCudaError("cudaGraphicsGLRegisterBuffer failed");
#endif
			pthread_mutex_unlock(&display_mutex);
            break;

        default:
            break;
    }
}
Exemplo n.º 19
0
ParticleSystem::ParticleSystem () :
    slowdown (1.0f),
    tex (0),
    active (false),
    x (0),
    y (0),
    darken (0.0f),
    blendMode (0)
{
    initParticles (0);
}
Exemplo n.º 20
0
void menu::init_Escena() {
	ofLogNotice("- - - - - - - init escena() - - - - - - - ");
	bshowdebug=false;
	ofPoint centro = ofPoint(W_WIDTH/2.0, W_HEIGHT/2.0);

	isKeyPressed = false;
	isMousePressed = false;
	
	// Crear las particulas
	initParticles();
	
	bDraw4Forces = true;
	fRed = false;

	swFuerzaDensidad = false;
    ofEnableAlphaBlending();
	// fbos:
	// limpiarlas
	fbo1.begin();	ofClear(255,255,255,0);	fbo1.end();
	fbo2.begin();	ofClear(255,255,255,0);	fbo2.end();
	fbo3.begin();	ofClear(255,255,255,0);	fbo3.end();
	fbo4.begin();	ofClear(255,255,255,0);	fbo4.end();	
	
	bDrawFbos = false;
	
	// rangos angulares de los sectores
//	delete[] rangosAngDeg;
	rangosAngDeg [0] = 0;
	rangosAngDeg [1] = 90;
	rangosAngDeg [2] = 180;
	rangosAngDeg [3] = 270;
	ofDisableAlphaBlending();
	
	// addListeners
	// Aqui no hacemos nada (por ahora) con las colisiones y otros eventos
//    box2d.enableEvents();
//	ofAddListener(box2d.contactStartEvents, this, &menu::contactStart);
//	ofAddListener(box2d.contactEndEvents, this, &menu::contactEnd);
	
	// Listeners para detectar que se esta tocando en una zona u otra
 /*   ofAddListener(button1.buttonEvent ,this, &menu::onButtonPressed);
    ofAddListener(button2.buttonEvent ,this, &menu::onButtonPressed);
    ofAddListener(button3.buttonEvent ,this, &menu::onButtonPressed);
    ofAddListener(button4.buttonEvent ,this, &menu::onButtonPressed);*/
		
	ofLogNotice("menu - init_escena - fin");
   
	currentButton=-1;
    for(int i=0; i<buttons.size();i++){
        buttons[i].touchUpAll();
    }
    hands.objectsCol.clear();
}
Exemplo n.º 21
0
int main( int argc, char* args[] )
{
    Particles emitter;

    //Start up SDL and create window
    if ( init(&gWindow, &renderer) )
    {
        printf( "Failed to initialize!\n" );
    }
    else
    {

        if (load_texture(&smokeTexture,  renderer) == 1) {
            printf("Failed to load texture\n");
        }
        else
        {


            initParticles( &emitter, 170, 315 );

            printf("in main %f\n", emitter.m_speed);
            emitter.m_lastRender = getMilliCount();

            //Main loop flag

#ifdef EMSCRIPTEN
            emscripten_set_main_loop_arg((em_arg_callback_func)loop, (void*)&emitter, 0, 1);
#else
            while (!quit) {
                SDL_Delay(15);
                loop(&emitter);
            }
#endif

        }
    }

    //Free resources and close SDL
    SDL_DestroyTexture(smokeTexture);
    smokeTexture = NULL;

    SDL_DestroyRenderer(renderer);
    renderer = NULL;

    SDL_DestroyWindow(gWindow);
    gWindow = NULL;

    IMG_Quit();
    SDL_Quit();

    return 0;
}
Exemplo n.º 22
0
particleSystem::particleSystem(int number){
	xstart = 0.f;
	ystart = 0.f;
	zstart = 0.f;
	xend = 4.0f;
	yend = 6.0f;
	zend = 4.0f;

	initParticles(number);
	initSphere();
	gridcells.resize(4,6,4, particles);
}
int main(int argc, char *argv[]){
    struct timespec bgn,nd;

    npart = atoi(argv[1]); /*command line input expected which provides the number of particles */
    nstep = atoi(argv[2]); /*command line input expected which provides the number of particles */


    /*initialize the position of particles in space and also their velocity and acceleration vector values*/
    initParticles(npart);
    clock_gettime(CLOCK_REALTIME, &bgn);
    /*begin the simulation with the initialization done previously and using simulation parameters defined in the global constants*/
    begin_simulation();

    clock_gettime(CLOCK_REALTIME, &nd);
    printf("%f\n", timediff(bgn,nd));
}
Exemplo n.º 24
0
void GLFluids::reset()
{
    memset(hvfield, 0, sizeof(float2) * DS);
    cudaMemcpy(dvfield, hvfield, sizeof(float2) * DS,
               cudaMemcpyHostToDevice);

    initParticles(particles, DIM, DIM);

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float2) * DS,
                 particles, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, vbo, cudaGraphicsMapFlagsNone);

}
Exemplo n.º 25
0
GLFluids::GLFluids(QWidget *parent)
    : QGLWidget(parent),
      QGLFunctions()
{
    vbo = 0;

    wWidth = qMax(512, DIM);
    wHeight = qMax(512, DIM);

    hvfield = (float2 *)malloc(sizeof(float2) * DS);
    memset(hvfield, 0, sizeof(float2) * DS);

    // Allocate and initialize device data
    cudaMallocPitch((void **)&dvfield, &tPitch, sizeof(float2)*DIM, DIM);

    cudaMemcpy(dvfield, hvfield, sizeof(float2) * DS,
               cudaMemcpyHostToDevice);
    // Temporary complex velocity field data
    cudaMalloc((void **)&vxfield, sizeof(float2) * PDS);
    cudaMalloc((void **)&vyfield, sizeof(float2) * PDS);

    setup_texture(DIM, DIM);
    bind_texture();

    // Create particle array
    particles = (float2 *)malloc(sizeof(float2) * DS);
    memset(particles, 0, sizeof(float2) * DS);
    initParticles(particles, DIM, DIM);

    // Create CUFFT transform plan configuration
    cufftPlan2d(&planr2c, DIM, DIM, CUFFT_R2C);
    cufftPlan2d(&planc2r, DIM, DIM, CUFFT_C2R);

    // TODO: update kernels to use the new unpadded memory layout for perf
    // rather than the old FFTW-compatible layout
    cufftSetCompatibilityMode(planr2c, CUFFT_COMPATIBILITY_FFTW_PADDING);
    cufftSetCompatibilityMode(planc2r, CUFFT_COMPATIBILITY_FFTW_PADDING);

    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, [&](){
        simulateFluids();
        updateGL();
    });
    timer->start(0);
}
Exemplo n.º 26
0
task main()
{
  initParticles();
  if (PATH_FOLLOWING)
  {
    DISPLAY_SCALE  = DISPLAY_SCALE_PATH_FOLLOW;
    yoff = 10*DISPLAY_SCALE; xoff = 5*DISPLAY_SCALE;
    runPathTest();
  }
  else
  {
    DISPLAY_SCALE  = DISPLAY_SCALE_SQUARE;
    yoff = 5*DISPLAY_SCALE; xoff = 25*DISPLAY_SCALE;
    drawSquare();
  }

  wait1Msec(10000);
}
Exemplo n.º 27
0
void XBScene1::setup(XBBaseGUI *_gui)
{
    XBBaseScene::setup(_gui);

    wavesMask.allocate(ofGetWidth(), ofGetHeight(), GL_RGB);
    wavesMask.begin();
    ofSetBackgroundAuto(false);
    ofBackground(0, 0, 0);
    wavesMask.end();

    initWindows();
    initParticles();
    initWaves();
    initStones();
    initLines();

    blur.setup(getMainFBO().getWidth(), getMainFBO().getHeight(), 0);
    XBScene1GUI *myGUI = (XBScene1GUI *) gui;
    myGUI->flashDirector.getParameter().cast<bool>().addListener(this, &XBScene1::flashDirector);
}
Exemplo n.º 28
0
//--------------------------------------------------------------
void ofApp::update(){
	ofSetWindowTitle(ofToString(ofGetFrameRate()));
    t = ofGetElapsedTimef();
    
    frameCount++;
    
    if(frameCount > refresh) {
        initParticles();
    }
    
    for (int i = 0; i < CIRCLE_NUM; i++) {
        particle[i].resetForce();
//        particle[i].addForce( ofVec3f(ofSignedNoise(t, i * forceSeedX) * forceX, ofSignedNoise(t, i * forceSeedY) * forceY, ofSignedNoise(t, i * forceSeedZ) * forceZ));
        particle[i].addForce( ofVec3f(ofSignedNoise(t, i * forceSeedX) * forceX, ofSignedNoise(t, i * forceSeedY) * forceY, ofNoise(t, i * forceSeedZ) * forceZ));
        particle[i].updateForce();
        particle[i].updateSize(ofNoise(t * 0.2, 0.01 * i) * size);
        particle[i].updatePos();
        particle[i].updateColor(colorStart, colorEnd);
    }
}
Exemplo n.º 29
0
// For Snow
void drawSnow() {
    float x, y, z;
    for (loop = 0; loop < MAX_PARTICLES; loop=loop+2) {
        if (par_sys[loop].alive == true) {
            x = par_sys[loop].xpos;
            y = par_sys[loop].ypos;
            z = par_sys[loop].zpos + zoom;
            
            // Draw particles
            glColor3f(1.0, 1.0, 1.0);
            glPushMatrix();
            glTranslatef(x, y, z);
            glutSolidSphere(0.2, 16, 16);
            glPopMatrix();
            
            // Update values
            //Move
            par_sys[loop].ypos += par_sys[loop].vel / (slowdown*1000);
            par_sys[loop].vel += par_sys[loop].gravity;
            // Decay
            par_sys[loop].life -= par_sys[loop].fade;
            
            if (par_sys[loop].ypos <= -10) {
                int zi = z - zoom + 10;
                int xi = x + 10;
                ground_colors[zi][xi][0] = 1.0;
                ground_colors[zi][xi][2] = 1.0;
                ground_colors[zi][xi][3] += 1.0;
                if (ground_colors[zi][xi][3] > 1.0) {
                    ground_points[xi][zi][1] += 0.1;
                }
                par_sys[loop].life = -1.0;
            }
            
            //Revive
            if (par_sys[loop].life < 0.0) {
                initParticles(loop);
            }
        }
    }
}
Exemplo n.º 30
0
void imageProcessing(IplImage* img)
{
	// Create temporary images
	CvSize sz = cvGetSize(img);
	IplImage* hsv_image = cvCreateImage(sz,8,3);
	IplImage* hsv_mask = cvCreateImage(sz,8,1);

	// HSV Conversion and Thresholding
	cvCvtColor(img,hsv_image,CV_BGR2HSV);
	cvInRangeS(hsv_image,hsv_min,hsv_max, hsv_mask);

	// Init
	if((height != sz.height) | (width != sz.width))
	{
		height = sz.height;
		width = sz.width;

		initParticles();
	}

	// Filter
	particleFilter(hsv_mask);

	// Compute variance
	std::pair<double,double> V = particlesVariance();
	//ROS_INFO("Variances:  Vx = %f, Vy = %f",V.first,V.second);
	if((V.first < Var_min) & (V.second < Var_min))
	{
		robotDetected = true;
	}

	// Draw particles
	showParticles(hsv_mask);

	// Show result
	//cvNamedWindow("Search",1); cvShowImage("Search",hsv_mask);

	cvWaitKey(10);
}