void mesh_filter::StereoCameraModel::Parameters::setFilterParameters (GLRenderer& renderer) const { glUniform1f (glGetUniformLocation (renderer.getProgramID (), "near"), near_clipping_plane_distance_); glUniform1f (glGetUniformLocation (renderer.getProgramID (), "far"), far_clipping_plane_distance_); renderer.setClippingRange (near_clipping_plane_distance_, far_clipping_plane_distance_); renderer.setBufferSize (width_, height_); renderer.setCameraParameters (fx_, fy_, cx_, cy_); }
void mesh_filter::StereoCameraModel::Parameters::setRenderParameters (GLRenderer& renderer) const { renderer.setClippingRange (near_clipping_plane_distance_, far_clipping_plane_distance_); renderer.setBufferSize (width_, height_); renderer.setCameraParameters (fx_, fy_, cx_, cy_); //GLuint padding_coefficients_id = glGetUniformLocation (renderer.getProgramID (), "padding_coefficients"); // // set device dependent padding coefficients // glUniform3f (padding_coefficients_id, padding_coefficients_1_ * padding_scale_, // padding_coefficients_2_ * padding_scale_, // padding_coefficients_3_ * padding_scale_ + padding_offset_ ); }
//----------------------------------------------------------------------------- void RenderingContext::Draw(Shader& shader, GLRenderer& gl_renderer) { __GL_CALL(glUseProgram(shader.GetProgram())) shader.SetUniforms(*this); gl_renderer.Draw(shader, *this); }
void GL_LoadStaticScene() { for(unsigned int wo=0;wo<staticObjectCount;wo++) { GL_AddModelToLists(&staticObjectPool[wo], true); } renderer.staticsRebuild(); }
void GL_AddLight(residx_t shader, sceneobj_t *obj, bool bStatic) { worldLight_t *l = &worldlights[lightCount++]; memset(l, 0, sizeof(worldLight_t)); M_CopyVec3(obj->color, l->color); //M_CopyVec3(obj->pos, l.origin); l->falloff = obj->scale; renderer.addLight(l, obj, shader, bStatic); }
void shader_fireball( GLWindow& window, GLRenderer& renderer ) { auto camera = PerspectiveCamera::create( 40, (float)renderer.width() / renderer.height(), 1, 3000 ); camera->position().z = 4; auto scene = Scene::create(); float time = 1; auto material = ShaderMaterial::create( vertexShader, fragmentShader, Uniforms().add("time", Uniform( THREE::f, time )) .add("scale", Uniform( THREE::f, 1.5f )) ); // Geometries auto mesh = Mesh::create( SphereGeometry::create( 0.75f, 64, 32 ), material ); scene->add( mesh ); renderer.setClearColor( Color(0x050505), 0 ); ///////////////////////////////////////////////////////////////////////// window.animate( [&]( float dt ) -> bool { time += dt; material->uniforms[ "time" ].value = time; mesh->rotation().x += 0.1f * dt; mesh->rotation().y += 0.5f * dt; renderer.render( *scene, *camera ); return true; } ); }
MStatus RadiosityRenderer::doIt(const MArgList &args) { this->args = args; windowWidth = 640; windowHeight = 480; SDL_Window *window = SDL_CreateWindow( "Radiosity Renderer Viewport", 0, 0, 640, 480, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE ); SDL_GLContext glcontext = SDL_GL_CreateContext(window); glClearColor(0,0,0,1); glClear(GL_COLOR_BUFFER_BIT); M3dView curView = M3dView::active3dView(); MDagPath camDagPath; curView.getCamera( camDagPath ); IterateThroughDag(); //Pass DAG to renderer, let renderer render scene... SDL_GL_MakeCurrent(window, glcontext); GLRenderer renderer = GLRenderer(640,480); renderer.RenderToScreen(); SDL_GL_SwapWindow(window); //Write pixels to render window... prepareRenderView(); SDL_GL_MakeCurrent(window, glcontext); renderBufferToRenderView(); sleep(1); SDL_GL_DeleteContext(glcontext); SDL_DestroyWindow(window); SDL_Quit(); return MS::kSuccess; }
void GL_InitScene() { Cvar_Register(&gfx_doubleSided); Cvar_Register(&gfx_separate_specular_color); Cvar_Register(&gfx_ambient_and_diffuse); Cvar_Register(&gfx_render); Cvar_Register(&gfx_maxlightsperpass); Cvar_Register(&gfx_multipassLighting); Cvar_Register(&gfx_nicerFog); Cvar_Register(&gfx_octreeDepth); Cvar_Register(&gfx_sortAll); Cvar_Register(&gfx_depthNormalPass); Cvar_Register(&gfx_debugoctree); Cvar_Register(&gfx_useBuckets); Cvar_Register(&gfx_niceEffects); Cvar_Register(&gfx_debugCamera); GL_InitTerrain(); GL_InitModel(); GL_InitWater(); GL_InitClouds(); GL_InitWeather(); if (gl_ext_texenv_combine.integer) //we'll be using 2x modulation { Cvar_Set("vid_overbrightNormalize", "0.5"); } GL_InitShadow(); GL_InitPostProcessing(); screen_target = new GLRenderTarget(); glScreen = screen_target; if(gfx_postProcEnabled.integer) zPass = new DepthPass(); glGetIntegerv(GL_MAX_LIGHTS, &glMaxLights); renderer.reset(); }
void GLRenderer::drawCallback(void) { GLRenderer* r = GLRenderer::getInstance(); r->draw(); }
// Main function int main(int argc, char *argv[]) { #if defined(DEBUG) | defined(_DEBUG) _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); #endif return 0; // random seed randomSeed = static_cast<unsigned int>(time(NULL)); // Sets the update step System::setClampStep(true,0.1f); // clamp the step to 100 ms System::useAdaptiveStep(0.001f,0.01f); // use an adaptive step from 1ms to 10ms (1000fps to 100fps) SDL_Event event; // inits SDL SDL_Init(SDL_INIT_VIDEO); //SDL_WM_SetCaption("SPARK Basic Demo",NULL); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1); // double buffering // vsync //+SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL,0); //+SDL_SetVideoMode(0,0,32, SDL_OPENGL | SDL_FULLSCREEN); SDL_ShowCursor(0); //+SDL_Surface screen = *SDL_GetVideoSurface(); screenWidth = 640; screenHeight = 480; SDL_Window* window = SDL_CreateWindow("OpenGL Window", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screenWidth, screenHeight, SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN); renderFirstFrame(); // inits openGL screenRatio = (float)screenWidth / (float)screenHeight; glClearColor(0.0f,0.0f,0.0f,1.0f); glViewport(0,0,screenWidth,screenHeight); // Loads texture font FTGLTextureFont font = FTGLTextureFont("res/font.ttf"); if(font.Error()) return 1; font.FaceSize(24); fontPtr = &font; // Loads particle texture GLuint textureParticle; if (!loadTexture(textureParticle,"res/point.bmp",GL_ALPHA,/*GL_CLAMP*/GL_CLAMP_TO_EDGE,false)) return 1; // Inits Particle Engine Vector3D gravity(0.0f,-0.8f,0.0f); // Renderers GLPointRenderer* basicRenderer = GLPointRenderer::create(); GLRenderer* particleRenderer = NULL; // We use pointSprites only if it is available and if the GL extension point parameter is available if ((GLPointRenderer::loadGLExtPointSprite())&&(GLPointRenderer::loadGLExtPointParameter())) { GLPointRenderer* pointRenderer = GLPointRenderer::create(); pointRenderer->setType(POINT_SPRITE); pointRenderer->setTexture(textureParticle); pointRenderer->setTextureBlending(GL_MODULATE); pointRenderer->enableWorldSize(true); GLPointRenderer::setPixelPerUnit(45.0f * PI / 180.f,screenHeight); pointRenderer->setSize(0.05f); particleRenderer = pointRenderer; } else // we use quads { GLQuadRenderer* quadRenderer = GLQuadRenderer::create(); quadRenderer->setTexturingMode(TEXTURE_2D); quadRenderer->setTexture(textureParticle); quadRenderer->setTextureBlending(GL_MODULATE); quadRenderer->setScale(0.05f,0.05f); particleRenderer = quadRenderer; } particleRenderer->setBlending(BLENDING_ADD); particleRenderer->enableRenderingHint(DEPTH_WRITE,false); // Model Model* particleModel = Model::create(FLAG_RED | FLAG_GREEN | FLAG_BLUE | FLAG_ALPHA); particleModel->setParam(PARAM_ALPHA,0.8f); // constant alpha particleModel->setLifeTime(8.0f,8.0f); // Emitter SphericEmitter* particleEmitter = SphericEmitter::create(Vector3D(0.0f,1.0f,0.0f),0.1f * PI,0.1f * PI); particleEmitter->setZone(Point::create(Vector3D(0.0f,0.015f,0.0f))); particleEmitter->setFlow(250); particleEmitter->setForce(1.5f,1.5f); // Obstacle Plane* groundPlane = Plane::create(); Obstacle* obstacle = Obstacle::create(groundPlane,INTERSECT_ZONE,0.6f,1.0f); // Group particleGroup = Group::create(particleModel,2100); particleGroup->addEmitter(particleEmitter); particleGroup->addModifier(obstacle); particleGroup->setRenderer(particleRenderer); particleGroup->setGravity(gravity); particleSystem = System::create(); particleSystem->addGroup(particleGroup); bool exit = false; bool paused = false; // renderValue : // 0 : normal // 1 : basic render // 2 : no render unsigned int renderValue = 0; float step = 0.0f; cout << "\nSPARK FACTORY AFTER INIT :" << endl; SPKFactory::getInstance().traceAll(); SDL_Delay(3000); while (SDL_PollEvent(&event)){} std::deque<unsigned int> frameFPS; frameFPS.push_back(SDL_GetTicks()); while(!exit) { while (SDL_PollEvent(&event)) { // if esc is pressed, exit if ((event.type == SDL_KEYDOWN)&&(event.key.keysym.sym == SDLK_ESCAPE)) exit = true; // if del is pressed, reinit the system if ((event.type == SDL_KEYDOWN)&&(event.key.keysym.sym == SDLK_DELETE)) particleSystem->empty(); // if F1 is pressed, we display or not the text if ((event.type == SDL_KEYDOWN)&&(event.key.keysym.sym == SDLK_F1)) { --drawText; if (drawText < 0) drawText = 2; } // if F2 is pressed, we display or not the bounding boxes if ((event.type == SDL_KEYDOWN)&&(event.key.keysym.sym == SDLK_F2)) { particleGroup->enableAABBComputing(!particleGroup->isAABBComputingEnabled()); if (paused) particleSystem->computeAABB(); } // if F4 is pressed, the renderers are changed if ((event.type == SDL_KEYDOWN)&&(event.key.keysym.sym == SDLK_F4)) { renderValue = (renderValue + 1) % 3; switch (renderValue) { case 0 : particleGroup->setRenderer(particleRenderer); break; case 1 : particleGroup->setRenderer(basicRenderer); break; case 2 : particleGroup->setRenderer(NULL); break; } } // if pause is pressed, the system is paused if ((event.type == SDL_KEYDOWN)&&(event.key.keysym.sym == SDLK_PAUSE)) paused = !paused; // Moves the camera with the mouse if (event.type == SDL_MOUSEMOTION) { angleY += event.motion.xrel * 0.05f; angleX += event.motion.yrel * 0.05f; angleX = min(179.0f,max(1.0f,angleX)); // we cannot look under the ground } // Zoom in and out if (event.type == SDL_MOUSEBUTTONDOWN) { //if (event.button.button == SDL_BUTTON_WHEELDOWN) // camPosZ = min(10.0f,camPosZ + 0.5f); //if (event.button.button == SDL_BUTTON_WHEELUP) // camPosZ = max(0.5f,camPosZ - 0.5f); } } if (!paused) { // Changes the color of the model over time step += deltaTime * 0.0005f; particleModel->setParam(PARAM_RED,0.6f + 0.4f * sin(step)); particleModel->setParam(PARAM_GREEN,0.6f + 0.4f * sin(step + PI * 2.0f / 3.0f)); particleModel->setParam(PARAM_BLUE,0.6f + 0.4f * sin(step + PI * 4.0f / 3.0f)); // Updates particle system particleSystem->update(deltaTime * 0.001f); // 1 defined as a second } // Renders scene render(); // Computes delta time int time = SDL_GetTicks(); deltaTime = time - frameFPS.back(); frameFPS.push_back(time); while((frameFPS.back() - frameFPS.front() > 1000)&&(frameFPS.size() > 2)) frameFPS.pop_front(); // Updates info strings strNbParticles = STR_NB_PARTICLES + int2Str(particleSystem->getNbParticles()); int fps = static_cast<int>(((frameFPS.size() - 1) * 1000.0f) / (frameFPS.back() - frameFPS.front())); if (drawText == 2) strFps = STR_FPS + int2Str(fps); else strFps = int2Str(fps); } cout << "\nSPARK FACTORY BEFORE DESTRUCTION :" << endl; SPKFactory::getInstance().traceAll(); SPKFactory::getInstance().destroyAll(); cout << "\nSPARK FACTORY AFTER DESTRUCTION :" << endl; SPKFactory::getInstance().traceAll(); SPKFactory::destroyInstance(); SDL_Quit(); cout << endl; system("pause"); // Waits for the user to close the console return 0; }
void GL_RenderScene(camera_t *camera, vec3_t userpos, unsigned int sceneRenderFlags) { if (!world.cl_loaded || !gfx_render.integer) { //GL_2dMode(); return; } static float lasttime=0; camera_t sunCam; Pass basePass; worldLight_t rimLight; float lerp; float ambBoost = (vid_realbright.integer && gfx_GLSLQuality.integer<=1) ? vid_realbrightMult.value : 1.0f; basePass.setViewer(camera); scene_cam = camera; sunLight.origin[0] = -wr_sun_x.value; sunLight.origin[1] = -wr_sun_y.value; sunLight.origin[2] = -wr_sun_z.value; memset(&rimLight, 0, sizeof(worldLight_t)); M_MultVec3(sunLight.origin, -1, rimLight.origin); rimLight.type = LIGHT_DIRECTIONAL; //// SHADOW MAP RENDER //// //shadow pass, render to texture if(gfx_shadow.integer && gfx_shadowQuality.integer >= 1 && gfx_GLSLQuality.integer>1) { vec3_t wmin, wmax, sunLook; World_GetBounds(wmin, wmax); //SET_VEC3(sunLook, (wmax[0]-wmin[0])*.5f, (wmax[1]-wmin[1])*.5f, 0 * .5f); M_MultVec3(camera->viewaxis[AXIS_FORWARD], camera->farclip*0.05, sunLook); M_AddVec2(sunLook, camera->origin, sunLook); Cam_DefaultCamera(&sunCam, gfx_shadowSize.integer, gfx_shadowSize.integer, 2, 8192); if(wr_sun_z.value < 0) { SET_VEC3(sunCam.origin, -wr_sun_x.value, -wr_sun_y.value, -wr_sun_z.value); } else { SET_VEC3(sunCam.origin, wr_sun_x.value, wr_sun_y.value, wr_sun_z.value); } M_Normalize(sunCam.origin); M_MultVec3(sunCam.origin, wmax[0], sunCam.origin); sunCam.origin[0]+=sunLook[0]; sunCam.origin[1]+=sunLook[1]; M_SubVec3(sunLook, sunCam.origin, sunCam.viewaxis[AXIS_FORWARD]); M_GetAxisFromForwardVec(sunCam.viewaxis[AXIS_FORWARD], sunCam.viewaxis); sunCam.fovy = 50; sunCam.time = camera->time; sunCam.fog_far=100000; sunCam.fog_near=99999; sunCam.flags |= CAM_NO_SKY; //CSM setup if(gfx_shadowQuality.integer >= 2) { shadowSplit=0; for(int i=0;i<gfx_shadowQuality.integer;i++) { cascadedPass[i].setViewer(&sunCam); renderer.addPass(&cascadedPass[i]); } } else { shadowPass.setViewer(&sunCam); renderer.addPass(&shadowPass); } } else if( gfx_GLSLQuality.integer > 1 ) { renderer.addPass(&shadowPass); } if(gfx_postProcEnabled.integer && gfx_GLSLQuality.integer>1 && (gfx_depthNormalPass.integer || gfx_postSSAO.integer)) { zPass->setViewer(camera); renderer.addPass(zPass); } basePass.setDepthFunc(GL_LEQUAL); basePass.setDepthMask(true); basePass.clearDepth(true); if(gfx_GLSLQuality.integer>1 && gfx_postProcessing.integer) basePass.setTarget(screenPostTarget); else basePass.setTarget(glScreen); renderer.addPass(&basePass); //// BUILD RENDER LIST //// // sun/moon if(wr_sun_z.value < 0) { lerp = CLAMP(fabs(-1 - cos(wr_sun_phi.value)), 0, 1); //Console_Printf("phi %f lerp %f\n", wr_sun_phi.value, lerp); //setup sun light color and ambient sunLight.ambient[0] = obj_ambient_r.value*ambBoost; sunLight.ambient[1] = obj_ambient_g.value*ambBoost; sunLight.ambient[2] = obj_ambient_b.value*ambBoost; sunLight.color[0] = obj_light0_r.value*.9; sunLight.color[1] = obj_light0_g.value*.9; sunLight.color[2] = obj_light0_b.value*.98; rimLight.ambient[0] = 0; rimLight.ambient[1] = 0; rimLight.ambient[2] = 0; rimLight.color[0] = lerp*obj_light1_r.value*.9; rimLight.color[1] = lerp*obj_light1_g.value*.9; rimLight.color[2] = lerp*obj_light1_b.value*.98; } else { if(wr_sun_phi.value < 5.23f && wr_sun_phi.value > 1.0472f) lerp = CLAMP(fabs(1-cos(3*(M_PI-wr_sun_phi.value))), 0, 1); else lerp = 0; //Console_Printf("phi %f lerp %f cos %f\n", wr_sun_phi.value, lerp, cos(3*(M_PI-wr_sun_phi.value))); //the lights need to flip M_MultVec3(sunLight.origin, -1, sunLight.origin); M_MultVec3(rimLight.origin, -1, rimLight.origin); //setup moon light color and ambient sunLight.ambient[0] = obj_ambient_r.value*ambBoost; sunLight.ambient[1] = obj_ambient_g.value*ambBoost; sunLight.ambient[2] = obj_ambient_b.value*ambBoost; sunLight.color[0] = obj_light1_r.value*.9; sunLight.color[1] = obj_light1_g.value*.9; sunLight.color[2] = obj_light1_b.value*.98; rimLight.ambient[0] = 0; rimLight.ambient[1] = 0; rimLight.ambient[2] = 0; rimLight.color[0] = lerp*obj_light0_r.value*.9; rimLight.color[1] = lerp*obj_light0_g.value*.9; rimLight.color[2] = lerp*obj_light0_b.value*.98; } renderer.addLight(&sunLight, NULL, 0); renderer.addLight(&rimLight, NULL, 0); // The deal here is rather than changing the code in scene.cpp to support the // new renderer, we just "import" all the scene data //// SCENE DATA //// lightCount = 0; //objects scenelist_t *list; for (list = scenelist; list; list = list->next) { //if(list->cull) // continue; switch (list->obj.objtype) { case OBJTYPE_MODEL: GL_AddModelToLists(&list->obj); break; case OBJTYPE_LIGHT: GL_AddLight(0, &list->obj); break; default: break; } } //polys scenefacelist_t *flist; for (flist = scenefacelist; flist; flist = flist->next) { renderer.addPoly(flist, NULL, flist->shader); } //decals for (flist = scenefacelist_decals; flist; flist = flist->next) { renderer.addPoly(flist, NULL, flist->shader); } //lights scenelightlist_t *llist; for (llist = scenelightlist; llist; llist = llist->next) { worldLight_t *l = &worldlights[lightCount++]; M_CopyVec3(llist->light.color, l->color); M_CopyVec3(llist->light.pos, l->origin); renderer.addLight(l, NULL, 0); } //// END SCENE DATA //// //// ENVIRO //// if(!(camera->flags & CAM_NO_WORLD)) { //terrain if (!(scene_cam->flags & CAM_NO_TERRAIN)) renderer.addCustomListItem(&terrainItem, false); //sprites for (std::list<scenelist_t*>::iterator itr = spritelist.begin(); itr != spritelist.end(); itr++) { scenelist_t *sprite = *itr; renderer.addSprite(sprite, &sprite->obj, sprite->obj.shader); } //clouds (at the back) if(gfx_sky.integer) { renderer.addCustomListItem(&cloudsItem, false); } if(gfx_water.integer) { waterItem.set(NULL,NULL,0); renderer.addCustomListItem(&waterItem, false); } //sky if (gfx_sky.integer) { if(Cvar_GetInteger("tl_suntod") <= 1440) sky.setTimeofDay(Cvar_GetValue("tl_suntod")/1440.0f); else sky.setTimeofDay((Cvar_GetValue("tod_sunminute"))/1440.0f); //renderer.addListItem(&clouds, false); renderer.addCustomListItem(&sky, false); } //// FX LAYER //// //polys for (flist = scenefxfacelist; flist; flist = flist->next) { renderer.addPolyFX(flist, NULL, flist->shader); } //decals for (flist = scenefxfacelist_decals; flist; flist = flist->next) { renderer.addPolyFX(flist, NULL, flist->shader); } //sprites for (std::list<scenelist_t*>::iterator itr = spritefxlist.begin(); itr != spritefxlist.end(); itr++) { scenelist_t *sprite = *itr; renderer.addSpriteFX(sprite, &sprite->obj, sprite->obj.shader); } } //// RENDER //// renderer.render(camera->time-lasttime); lasttime = camera->time; }
void GL_ClearStaticScene() { renderer.clearStatics(); }
void particles_sprites( GLWindow& window, GLRenderer& renderer ) { auto camera = PerspectiveCamera::create( 75, ( float )renderer.width() / renderer.height(), 1.f, 2000 ); camera->position().z = 1000; auto scene = Scene::create(); scene->fog = FogExp2::create( 0x000000, .0008f ); auto geometry = Geometry::create(); auto sprite1 = ImageUtils::loadTexture( threeDataPath("textures/sprites/snowflake1.png") ); auto sprite2 = ImageUtils::loadTexture( threeDataPath("textures/sprites/snowflake2.png") ); auto sprite3 = ImageUtils::loadTexture( threeDataPath("textures/sprites/snowflake3.png") ); auto sprite4 = ImageUtils::loadTexture( threeDataPath("textures/sprites/snowflake4.png") ); auto sprite5 = ImageUtils::loadTexture( threeDataPath("textures/sprites/snowflake5.png") ); const auto particleCount = 10000; geometry->vertices.reserve( particleCount ); std::generate_n( std::back_inserter( geometry->vertices ), particleCount, [] { return Vector3( Math::random(-1000.f, 1000.f), Math::random(-1000.f, 1000.f), Math::random(-1000.f, 1000.f) ); } ); std::vector<Material::Ptr> materials; auto addParticleSystem = [&]( const Vector3& color, const Texture::Ptr& sprite, float size ) { auto material = ParticleSystemMaterial::create( Material::Parameters().add( "size", size ) .add( "map", sprite ) .add( "blending", THREE::AdditiveBlending ) .add( "depthTest", false ) .add( "transparent", true ) ); materials.push_back( material ); material->color.setHSL( color[0], color[1], color[2] ); auto particles = ParticleSystem::create( geometry, material ); particles->rotation() = Euler( Math::random() * 6, Math::random() * 6, Math::random() * 6 ); scene->add( particles ); }; typedef std::tuple<Vector3, Texture::Ptr, float> ColorSpriteSize; std::array<ColorSpriteSize, 5> params = { ColorSpriteSize( Vector3( 1.f, 0.2f, 0.5f), sprite2, 20.f ), ColorSpriteSize( Vector3(0.95f, 0.1f, 0.5f), sprite3, 13.f ), ColorSpriteSize( Vector3(0.90f, 0.05f, 0.5f), sprite1, 10.f ), ColorSpriteSize( Vector3(0.85f, 0.f, 0.5f), sprite5, 8.f ), ColorSpriteSize( Vector3(0.80f, 0.f, 0.5f), sprite4, 5.f ) }; for ( const auto& param : params ) { addParticleSystem( std::get<0>(param), std::get<1>(param), std::get<2>(param) ); } ///////////////////////////////////////////////////////////////////////// auto mouseX = 0.f, mouseY = 0.f; window.addEventListener( SDL_MOUSEMOTION, [&]( const SDL_Event& event ) { mouseX = 2.f * ( ( float )event.motion.x / renderer.width() - 0.5f ); mouseY = 2.f * ( ( float )event.motion.y / renderer.height() - 0.5f ); } ); window.addEventListener( SDL_WINDOWEVENT, [&]( const SDL_Event& event ) { if (event.window.event != SDL_WINDOWEVENT_RESIZED) return; camera->aspect = ( float )event.window.data1 / event.window.data2; camera->updateProjectionMatrix(); renderer.setSize( event.window.data1, event.window.data2 ); } ); ///////////////////////////////////////////////////////////////////////// auto time = 0.f; window.animate( [&]( float dt ) -> bool { time += dt * .05f; camera->position().x += ( -1000.f * mouseX - camera->position().x ) * 3 * dt; camera->position().y += ( 1000.f * mouseY - camera->position().y ) * 3 * dt; camera->lookAt( scene->position() ); for ( size_t i = 0; i < scene->children.size(); ++i ) { auto& object = *scene->children[ i ]; if ( object.type() == THREE::ParticleSystem ) { object.rotation().y = time * ( i < 4 ? i + 1 : - ( (int)i + 1 ) ); } } for ( size_t i = 0; i < materials.size(); ++i ) { auto& color = std::get<0>(params[ i ]); const auto h = Math::fmod( 360.f * ( color[0] + time ), 360.f ) / 360.f; materials[ i ]->color.setHSL( h, color[ 1 ], color[ 2 ] ); } renderer.render( *scene, *camera ); return true; } ); }
void GL_AddSprite(residx_t shader, scenelist_t *sp, sceneobj_t *obj, bool bStatic) { renderer.addSprite(sp, obj, shader, bStatic); }
void geometries( GLWindow& window, GLRenderer& renderer ) { auto camera = PerspectiveCamera::create( 45, ( float )renderer.width() / renderer.height(), 10, 20000 ); camera->position().y = 700; auto scene = Scene::create(); scene->add( AmbientLight::create( 0x404040 ) ); auto light = DirectionalLight::create( 0xffffff ); light->position().set( 0, 1, 0 ); scene->add( light ); auto map = ImageUtils::loadTexture( threeDataPath( "textures/UV_Grid_Sm.jpg" ) ); map->wrapS = map->wrapT = THREE::RepeatWrapping; map->anisotropy = 16; auto material = MeshLambertMaterial::create( Material::Parameters() .add( "ambient", Color( 0xbbbbbb ) ) .add( "map", map ) .add( "side", THREE::DoubleSide ) ); // auto sphere = Mesh::create( SphereGeometry::create( 75, 20, 10 ), material ); sphere->position().set( -400, 0, 200 ); scene->add( sphere ); auto ico = Mesh::create( IcosahedronGeometry::create( 75, 1 ), material ); ico->position().set( -200, 0, 200 ); scene->add( ico ); auto octa = Mesh::create( OctahedronGeometry::create( 75, 2 ), material ); octa->position().set( 0, 0, 200 ); scene->add( octa ); auto tetra = Mesh::create( TetrahedronGeometry::create( 75, 0 ), material ); tetra->position().set( 200, 0, 200 ); scene->add( tetra ); // auto plane = Mesh::create( PlaneGeometry::create( 100, 100, 4, 4 ), material ); plane->position().set( -400, 0, 0 ); scene->add( plane ); auto cube = Mesh::create( BoxGeometry::create( 100, 100, 100, 4, 4, 4 ), material ); cube->position().set( -200, 0, 0 ); scene->add( cube ); auto circle = Mesh::create( CircleGeometry::create( 50, 20, 0, Math::PI() * 2 ), material ); circle->position().set( 0, 0, 0 ); scene->add( circle ); auto ring = Mesh::create( RingGeometry::create( 10, 50, 20, 5, 0, Math::PI() * 2 ), material ); ring->position().set( 200, 0, 0 ); scene->add( ring ); auto cylinder = Mesh::create( CylinderGeometry::create( 25, 75, 100, 40, 5 ), material ); cylinder->position().set( 400, 0, 0 ); scene->add( cylinder ); // std::vector<Vector3> points; for ( auto i = 0; i < 50; i ++ ) { points.push_back( Vector3( Math::sin( (float)i * 0.2 ) * Math::sin( (float)i * 0.1 ) * 15 + 50, 0, ( (float)i - 5 ) * 2 ) ); } auto lathe = Mesh::create( LatheGeometry::create( points, 20 ), material ); lathe->position().set( -400, 0, -200 ); scene->add( lathe ); auto torus = Mesh::create( TorusGeometry::create( 50, 20, 20, 20 ), material ); torus->position().set( -200, 0, -200 ); scene->add( torus ); auto torusKnot = Mesh::create( TorusKnotGeometry::create( 50, 10, 50, 20 ), material ); torusKnot->position().set( 0, 0, -200 ); scene->add( torusKnot ); auto axis = AxisHelper::create( 50 ); axis->position().set( 200, 0, -200 ); scene->add( axis ); auto arrow = ArrowHelper::create( Vector3( 0, 1, 0 ), Vector3( 0, 0, 0 ) ); arrow->setLength(50); arrow->position().set( 400, 0, -200 ); scene->add( arrow ); ///////////////////////////////////////////////////////////////////////// window.addEventListener( SDL_WINDOWEVENT, [&]( const SDL_Event& event ) { if (event.window.event != SDL_WINDOWEVENT_RESIZED) return; camera->aspect = ( float )event.window.data1 / event.window.data2; camera->updateProjectionMatrix(); renderer.setSize( event.window.data1, event.window.data2 ); } ); ///////////////////////////////////////////////////////////////////////// auto time = 0.f; int benchmarkFrames = 100000; window.animate( [&]( float dt ) -> bool { time += dt; camera->position().x = Math::cos( time * 0.2 ) * 800; camera->position().z = Math::sin( time * 0.2 ) * 800; camera->lookAt( scene->position() ); for ( size_t i = 0; i < scene->children.size(); i ++ ) { auto& object = scene->children[ i ]; object->rotation().x = time * 1; object->rotation().y = time * 0.25; } renderer.render( *scene, *camera ); return --benchmarkFrames > 0; } ); }
void GL_AddMesh(residx_t shader, mesh_t *mesh, sceneobj_t *obj, int meshNum, bool bStatic) { renderer.addMesh(mesh, obj, shader, meshNum, bStatic); }
void trails( GLWindow& window, GLRenderer& renderer ) { renderer.sortObjects = false; renderer.autoClearColor = false; // Camera auto camera = PerspectiveCamera::create( 60, (float)renderer.width() / renderer.height(), 1, 10000 ); camera->position().set( 100000, 0, 3200 ); // Scene auto scene = Scene::create(); // Geometries std::array<Color, 4> colors = { Color(0x000000), Color(0xff0080), Color(0x8000ff), Color(0xffffff) }; auto geometry = Geometry::create(); for ( int i = 0; i < 2000; i ++ ) { Vertex vertex; vertex.x = Math::random(-2000.f, 2000.f); vertex.y = Math::random(-2000.f, 2000.f); vertex.z = Math::random(-2000.f, 2000.f); geometry->vertices.push_back( vertex ); geometry->colors.push_back( colors[ (int)Math::floor( Math::random() * colors.size() ) ] ); } // Materials auto material = ParticleSystemMaterial::create( Material::Parameters().add("color", Color(0xcccccc)) .add("size", 1.0f) .add("vertexColors", THREE::VertexColors) .add("depthTest", false) .add("opacity", 0.5f) .add("sizeAttenuation", false) ); auto mesh = ParticleSystem::create( geometry, material ); scene->add( mesh ); auto mouseX = 0.f, mouseY = 0.f; window.addEventListener(SDL_MOUSEMOTION, [&]( const SDL_Event& event ) { mouseX = 2.f * ((float)event.motion.x / renderer.width() - 0.5f); mouseY = 2.f * ((float)event.motion.y / renderer.height() - 0.5f); }); // Rendering window.animate ( [&]( float dt ) -> bool { camera->position().x += ( 1000.f * mouseX - camera->position().x ) * 5 * dt; camera->position().y += ( 1000.f * mouseY - camera->position().y ) * 5 * dt; camera->lookAt( scene->position() ); renderer.render( *scene, *camera ); return true; } ); }
int main(int argc, char** argv) { using namespace Prox::Simulation; std::string SEED_ARG("--seed="); std::string DISPLAY_ARG("--display="); // Simulation params std::string DURATION_ARG("--duration="); std::string ITERATIONS_ARG("--iterations="); std::string REALTIME_ARG("--realtime="); std::string TIMESTEP_ARG("--timestep="); // in milliseconds // Object params std::string NOBJECTS_ARG("--nobjects="); std::string STATIC_OBJECTS_ARG("--static-objects="); std::string MOVING_FRAC_ARG("--moving-frac="); std::string CSV_ARG("--csv="); std::string CSV_MOTION_ARG("--csvmotion="); // Handler params std::string HANDLER_ARG("--handler="); std::string BRANCH_ARG("--branch="); // Querier params std::string NQUERIES_ARG("--nqueries="); std::string STATIC_QUERIES_ARG("--static-queries="); unsigned int seed = 0; bool display = false; int duration = 0; // seconds int iterations = 0; // iterations before termination bool realtime = true; // realtime or simulated time steps int timestep = 50; int nobjects = 10000; float moving_frac = 1.0f; std::string csvfile = ""; std::string csvmotionfile = ""; std::string handler_type = "rtree"; int branching = 16; int nqueries = 50; bool static_queries = false; for(int argi = 0; argi < argc; argi++) { std::string arg(argv[argi]); if (arg.find(SEED_ARG) != std::string::npos) { std::string seed_arg = arg.substr(SEED_ARG.size()); seed = boost::lexical_cast<int>(seed_arg); } else if (arg.find(DISPLAY_ARG) != std::string::npos) { std::string display_arg = arg.substr(DISPLAY_ARG.size()); display = convert_bool(display_arg); } else if (arg.find(DURATION_ARG) != std::string::npos) { std::string duration_arg = arg.substr(DURATION_ARG.size()); duration = boost::lexical_cast<int>(duration_arg); } else if (arg.find(ITERATIONS_ARG) != std::string::npos) { std::string iterations_arg = arg.substr(ITERATIONS_ARG.size()); iterations = boost::lexical_cast<int>(iterations_arg); } else if (arg.find(REALTIME_ARG) != std::string::npos) { std::string realtime_arg = arg.substr(REALTIME_ARG.size()); realtime = convert_bool(realtime_arg); } else if (arg.find(TIMESTEP_ARG) != std::string::npos) { std::string timestep_arg = arg.substr(TIMESTEP_ARG.size()); timestep = boost::lexical_cast<int>(timestep_arg); } else if (arg.find(NOBJECTS_ARG) != std::string::npos) { std::string nobjects_arg = arg.substr(NOBJECTS_ARG.size()); nobjects = boost::lexical_cast<int>(nobjects_arg); } else if (arg.find(STATIC_OBJECTS_ARG) != std::string::npos) { std::string static_arg = arg.substr(STATIC_OBJECTS_ARG.size()); bool static_objects = convert_bool(static_arg); if (static_objects) moving_frac = 0.0f; } else if (arg.find(MOVING_FRAC_ARG) != std::string::npos) { std::string moving_arg = arg.substr(MOVING_FRAC_ARG.size()); moving_frac = boost::lexical_cast<float>(moving_arg); } else if (arg.find(CSV_ARG) != std::string::npos) { csvfile = arg.substr(CSV_ARG.size()); } else if (arg.find(SEED_ARG) != std::string::npos) { std::string seed_arg = arg.substr(SEED_ARG.size()); seed = boost::lexical_cast<int>(seed_arg); } else if (arg.find(HANDLER_ARG) != std::string::npos) { handler_type = arg.substr(HANDLER_ARG.size()); } else if (arg.find(BRANCH_ARG) != std::string::npos) { std::string branch_arg = arg.substr(BRANCH_ARG.size()); branching = boost::lexical_cast<int>(branch_arg); } else if (arg.find(NQUERIES_ARG) != std::string::npos) { std::string nqueries_arg = arg.substr(NQUERIES_ARG.size()); nqueries = boost::lexical_cast<int>(nqueries_arg); } else if (arg.find(STATIC_QUERIES_ARG) != std::string::npos) { std::string static_arg = arg.substr(STATIC_QUERIES_ARG.size()); static_queries = convert_bool(static_arg); } } srand(seed); #ifndef LIBPROX_RTREE_DATA # error "You must define LIBPROX_RTREE_DATA to either LIBPROX_RTREE_DATA_BOUNDS or LIBPROX_RTREE_DATA_MAXSIZE" #endif #if LIBPROX_RTREE_DATA == LIBPROX_RTREE_DATA_BOUNDS typedef Prox::BoundingSphereData<Prox::DefaultSimulationTraits> NodeData; #elif LIBPROX_RTREE_DATA == LIBPROX_RTREE_DATA_MAXSIZE typedef Prox::MaxSphereData<Prox::DefaultSimulationTraits> NodeData; #elif LIBPROX_RTREE_DATA == LIBPROX_RTREE_DATA_SIMILARMAXSIZE typedef Prox::SimilarMaxSphereData<Prox::DefaultSimulationTraits> NodeData; #else # error "Invalid setting for LIBPROX_RTREE_DATA" #endif ManualQueryHandler* handler = NULL; if (handler_type == "rtree") { handler = new Prox::RTreeManualQueryHandler<Prox::DefaultSimulationTraits, NodeData>(branching); } Simulator* simulator = new Simulator(handler, duration, Duration::milliseconds((unsigned int)timestep), iterations, realtime); GLRenderer* renderer = new GLRenderer(simulator, handler, display); BoundingBox3 random_region( Vector3(-100.f, -100.f, -100.f), Vector3(100.f, 100.f, 100.f) ); int nobjects_moving = nobjects * moving_frac; int nobjects_static = nobjects - nobjects_moving; // There are various combinations of sources of objects we might need to get // to the target number with the right mix. When we need random objects and // we've loaded some from another source, we need to make sure we get the // region to generate them over correct. bool got_static = false; bool got_moving = false; // First, get objects from csv files. if (!csvfile.empty()) { simulator->createStaticCSVObjects(csvfile, nobjects_static); got_static = true; } // note: this should be second so that if (!csvmotionfile.empty()) { assert(!csvfile.empty()); // FIXME we'd like to support this, need to // figure out bounding box issues for // generating starting positions simulator->createMotionCSVObjects(csvmotionfile, nobjects_moving); got_moving = true; } // Next, take care of leftovers with random objects. Note that we use the // existing bounds if some other objects were already loaded. if (!got_static && !got_moving) simulator->createRandomObjects(random_region, nobjects, moving_frac); else if (!got_static && got_moving) simulator->createRandomObjects(simulator->region(), nobjects_static, 0.0); else if (got_static && !got_moving) simulator->createRandomObjects(simulator->region(), nobjects_moving, 1.0); // else we don't need any random objects // Sometimes we're not perfect, but let's aim for 99% of the target objects. assert(simulator->allObjectsSize() >= .99f * nobjects); simulator->initialize(/*churn_rate*/0); if (!csvmotionfile.empty() && !static_queries) simulator->createCSVQueries(nqueries, csvmotionfile); else simulator->createRandomQueries(nqueries, static_queries); simulator->run(); renderer->run(); simulator->shutdown(); delete renderer; delete simulator; return 0; }
void shader( GLWindow& window, GLRenderer& renderer ) { auto camera = PerspectiveCamera::create( 60, ( float )renderer.width() / renderer.height(), 1, 10000 ); camera->position().z = 300; auto scene = Scene::create(); auto texture = ImageUtils::loadTexture( threeDataPath( "textures/sprites/spark1.png" ) ); Uniforms uniforms; uniforms[ "color" ] = Uniform( THREE::c, Color( 0xffffff ) ); uniforms[ "texture" ] = Uniform( THREE::t, texture.get() ); Attributes attributes; attributes[ "size" ] = Attribute( THREE::f ); attributes[ "customColor" ] = Attribute( THREE::c ); auto shaderMaterial = ShaderMaterial::create( vertexShader, fragmentShader, uniforms, attributes, Material::Parameters().add( "blending", THREE::AdditiveBlending ) .add( "depthTest", false ) .add( "transparent", true ) ); // Geometries const auto radius = 200.f; const auto pointCount = 100000; auto geometry = Geometry::create(); auto& vertices = geometry->vertices; vertices.reserve( pointCount ); std::generate_n( std::back_inserter(vertices), pointCount, [=]() -> Vector3 { return Vector3( Math::random(-1.f, 1.f), Math::random(-1.f, 1.f), Math::random(-1.f, 1.f) ).multiplyScalar( radius ); } ); auto sphere = ParticleSystem::create( geometry, shaderMaterial ); sphere->geometry->dynamic = true; sphere->sortParticles = false; std::vector<float> values_size( pointCount ); std::vector<Color> values_color( pointCount ); for ( int v = 0; v < pointCount; v++ ) { values_size[ v ] = 10; values_color[ v ].set( 0xffaa00 ); if ( vertices[ v ].x < 0 ) values_color[ v ].setHSL( 0.5f + 0.1f * ( (float)v / pointCount ), 0.7f, 0.5f ); else values_color[ v ].setHSL( 0.0f + 0.1f * ( (float)v / pointCount), 0.9f, 0.5f ); } auto& size = shaderMaterial->attributes[ "size" ]; auto& color = shaderMaterial->attributes[ "customColor" ]; size.value = values_size; color.value = values_color; scene->add( sphere ); ///////////////////////////////////////////////////////////////////////// window.addEventListener( SDL_WINDOWEVENT, [&]( const SDL_Event& event ) { if (event.window.event != SDL_WINDOWEVENT_RESIZED) return; camera->aspect = ( float )event.window.data1 / event.window.data2; camera->updateProjectionMatrix(); renderer.setSize( event.window.data1, event.window.data2 ); } ); ///////////////////////////////////////////////////////////////////////// auto time = 0.f; window.animate( [&]( float dt ) -> bool { time += dt; sphere->rotation().z = time * 0.03f; auto& sizes = size.value.cast<std::vector<float>>(); for( size_t i = 0; i < sizes.size(); i++ ) { sizes[ i ] = 10.f + 9.f * Math::sin( 0.1f * i + time * 3.f ); } size.needsUpdate = true; renderer.render( *scene, *camera ); return true; } ); }
void particles_billboards( GLWindow& window, GLRenderer& renderer ) { auto camera = PerspectiveCamera::create( 55, ( float )renderer.width() / renderer.height(), 2.f, 2000 ); camera->position().z = 1000; auto scene = Scene::create(); scene->fog = FogExp2::create( 0x000000, .001f ); auto geometry = Geometry::create(); const auto particleCount = 10000; geometry->vertices.reserve( particleCount ); std::generate_n( std::back_inserter( geometry->vertices ), particleCount, [] { return Vector3( Math::random(-1000.f, 1000.f), Math::random(-1000.f, 1000.f), Math::random(-1000.f, 1000.f) ); } ); auto sprite = ImageUtils::loadTexture( threeDataPath("textures/sprites/disc.png") ); auto material = ParticleSystemMaterial::create( Material::Parameters().add( "size", 35.f ) .add( "map", sprite ) .add( "sizeAttenuation", false ) .add( "transparent", true) ); material->color.setHSL( 1.f, 0.3f, 0.7f ); auto particles = ParticleSystem::create( geometry, material ); particles->sortParticles = true; scene->add( particles ); ///////////////////////////////////////////////////////////////////////// auto mouseX = 0.f, mouseY = 0.f; window.addEventListener( SDL_MOUSEMOTION, [&]( const SDL_Event& event ) { mouseX = 2.f * ( ( float )event.motion.x / renderer.width() - 0.5f ); mouseY = 2.f * ( ( float )event.motion.y / renderer.height() - 0.5f ); } ); window.addEventListener( SDL_WINDOWEVENT, [&]( const SDL_Event& event ) { if (event.window.event != SDL_WINDOWEVENT_RESIZED) return; camera->aspect = ( float )event.window.data1 / event.window.data2; camera->updateProjectionMatrix(); renderer.setSize( event.window.data1, event.window.data2 ); } ); ///////////////////////////////////////////////////////////////////////// auto time = 0.f; window.animate( [&]( float dt ) -> bool { time += dt * .05f; camera->position().x += ( -1000.f * mouseX - camera->position().x ) * 3 * dt; camera->position().y += ( 1000.f * mouseY - camera->position().y ) * 3 * dt; camera->lookAt( scene->position() ); const auto h = Math::fmod( 360.f * ( 1.f + time ), 360.f ) / 360.f; material->color.setHSL( h, 0.5f, 0.5f ); renderer.render( *scene, *camera ); return true; } ); }