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