d8223ffa75
That year should bring the long-awaited OpenGL ES 3.0 compatible renderer
with state-of-the-art rendering techniques tuned to work as low as middle
end handheld devices - without compromising with the possibilities given
for higher end desktop games of course. Great times ahead for the Godot
community and the gamers that will play our games!
(cherry picked from commit c7bc44d5ad)
412 lines
13 KiB
C++
412 lines
13 KiB
C++
/*************************************************************************/
|
|
/* particle_system_sw.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
#include "particle_system_sw.h"
|
|
#include "sort.h"
|
|
|
|
|
|
ParticleSystemSW::ParticleSystemSW() {
|
|
|
|
amount=8;
|
|
emitting=true;
|
|
|
|
for (int i=0;i<VS::PARTICLE_VAR_MAX;i++) {
|
|
particle_randomness[i]=0.0;
|
|
}
|
|
|
|
particle_vars[VS::PARTICLE_LIFETIME]=2.0;//
|
|
particle_vars[VS::PARTICLE_SPREAD]=0.2;//
|
|
particle_vars[VS::PARTICLE_GRAVITY]=9.8;//
|
|
particle_vars[VS::PARTICLE_LINEAR_VELOCITY]=0.2;//
|
|
particle_vars[VS::PARTICLE_ANGULAR_VELOCITY]=0.0;//
|
|
particle_vars[VS::PARTICLE_LINEAR_ACCELERATION]=0.0;//
|
|
particle_vars[VS::PARTICLE_RADIAL_ACCELERATION]=0.0;//
|
|
particle_vars[VS::PARTICLE_TANGENTIAL_ACCELERATION]=1.0;//
|
|
particle_vars[VS::PARTICLE_DAMPING]=0.0;//
|
|
particle_vars[VS::PARTICLE_INITIAL_SIZE]=1.0;
|
|
particle_vars[VS::PARTICLE_FINAL_SIZE]=0.8;
|
|
particle_vars[VS::PARTICLE_HEIGHT]=1;
|
|
particle_vars[VS::PARTICLE_HEIGHT_SPEED_SCALE]=1;
|
|
|
|
height_from_velocity=false;
|
|
local_coordinates=false;
|
|
|
|
particle_vars[VS::PARTICLE_INITIAL_ANGLE]=0.0;//
|
|
|
|
gravity_normal=Vector3(0,-1.0,0);
|
|
//emission_half_extents=Vector3(0.1,0.1,0.1);
|
|
emission_half_extents=Vector3(1,1,1);
|
|
color_phase_count=0;
|
|
color_phases[0].pos=0.0;
|
|
color_phases[0].color=Color(1.0,0.0,0.0);
|
|
visibility_aabb=AABB(Vector3(-64,-64,-64),Vector3(128,128,128));
|
|
|
|
attractor_count=0;
|
|
|
|
}
|
|
|
|
|
|
ParticleSystemSW::~ParticleSystemSW()
|
|
{
|
|
}
|
|
|
|
|
|
#define DEFAULT_SEED 1234567
|
|
|
|
_FORCE_INLINE_ static float _rand_from_seed(uint32_t *seed) {
|
|
|
|
uint32_t k;
|
|
uint32_t s = (*seed);
|
|
if (s == 0)
|
|
s = 0x12345987;
|
|
k = s / 127773;
|
|
s = 16807 * (s - k * 127773) - 2836 * k;
|
|
if (s < 0)
|
|
s += 2147483647;
|
|
(*seed) = s;
|
|
|
|
float v=((float)((*seed) & 0xFFFFF))/(float)0xFFFFF;
|
|
v=v*2.0-1.0;
|
|
return v;
|
|
}
|
|
|
|
_FORCE_INLINE_ static uint32_t _irand_from_seed(uint32_t *seed) {
|
|
|
|
uint32_t k;
|
|
uint32_t s = (*seed);
|
|
if (s == 0)
|
|
s = 0x12345987;
|
|
k = s / 127773;
|
|
s = 16807 * (s - k * 127773) - 2836 * k;
|
|
if (s < 0)
|
|
s += 2147483647;
|
|
(*seed) = s;
|
|
|
|
return s;
|
|
}
|
|
|
|
void ParticleSystemProcessSW::process(const ParticleSystemSW *p_system,const Transform& p_transform,float p_time) {
|
|
|
|
valid=false;
|
|
if (p_system->amount<=0) {
|
|
ERR_EXPLAIN("Invalid amount of particles: "+itos(p_system->amount));
|
|
ERR_FAIL_COND(p_system->amount<=0);
|
|
}
|
|
if (p_system->attractor_count<0 || p_system->attractor_count>VS::MAX_PARTICLE_ATTRACTORS) {
|
|
ERR_EXPLAIN("Invalid amount of particle attractors.");
|
|
ERR_FAIL_COND(p_system->attractor_count<0 || p_system->attractor_count>VS::MAX_PARTICLE_ATTRACTORS);
|
|
}
|
|
float lifetime = p_system->particle_vars[VS::PARTICLE_LIFETIME];
|
|
if (lifetime<CMP_EPSILON) {
|
|
ERR_EXPLAIN("Particle system lifetime too small.");
|
|
ERR_FAIL_COND(lifetime<CMP_EPSILON);
|
|
}
|
|
valid=true;
|
|
int particle_count=MIN(p_system->amount,ParticleSystemSW::MAX_PARTICLES);;
|
|
|
|
|
|
int emission_point_count = p_system->emission_points.size();
|
|
DVector<Vector3>::Read r;
|
|
if (emission_point_count)
|
|
r=p_system->emission_points.read();
|
|
|
|
if (particle_count!=particle_data.size()) {
|
|
|
|
//clear the whole system if particle amount changed
|
|
particle_data.clear();
|
|
particle_data.resize(p_system->amount);
|
|
particle_system_time=0;
|
|
}
|
|
|
|
float next_time = particle_system_time+p_time;
|
|
|
|
if (next_time > lifetime)
|
|
next_time=Math::fmod(next_time,lifetime);
|
|
|
|
|
|
ParticleData *pdata=&particle_data[0];
|
|
Vector3 attractor_positions[VS::MAX_PARTICLE_ATTRACTORS];
|
|
|
|
for(int i=0;i<p_system->attractor_count;i++) {
|
|
|
|
attractor_positions[i]=p_transform.xform(p_system->attractors[i].pos);
|
|
}
|
|
|
|
|
|
for(int i=0;i<particle_count;i++) {
|
|
|
|
ParticleData &p=pdata[i];
|
|
|
|
float restart_time = (i * lifetime / p_system->amount);
|
|
|
|
bool restart=false;
|
|
|
|
if ( next_time < particle_system_time ) {
|
|
|
|
if (restart_time > particle_system_time || restart_time < next_time )
|
|
restart=true;
|
|
|
|
} else if (restart_time > particle_system_time && restart_time < next_time ) {
|
|
restart=true;
|
|
}
|
|
|
|
if (restart) {
|
|
|
|
|
|
if (p_system->emitting) {
|
|
if (emission_point_count==0) { //use AABB
|
|
if (p_system->local_coordinates)
|
|
p.pos = p_system->emission_half_extents * Vector3( _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed) );
|
|
else
|
|
p.pos = p_transform.xform( p_system->emission_half_extents * Vector3( _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed), _rand_from_seed(&rand_seed) ) );
|
|
} else {
|
|
//use preset positions
|
|
if (p_system->local_coordinates)
|
|
p.pos = r[_irand_from_seed(&rand_seed)%emission_point_count];
|
|
else
|
|
p.pos = p_transform.xform( r[_irand_from_seed(&rand_seed)%emission_point_count] );
|
|
}
|
|
|
|
|
|
float angle1 = _rand_from_seed(&rand_seed)*p_system->particle_vars[VS::PARTICLE_SPREAD]*Math_PI;
|
|
float angle2 = _rand_from_seed(&rand_seed)*20.0*Math_PI; // make it more random like
|
|
|
|
Vector3 rot_xz=Vector3( Math::sin(angle1), 0.0, Math::cos(angle1) );
|
|
Vector3 rot = Vector3( Math::cos(angle2)*rot_xz.x,Math::sin(angle2)*rot_xz.x, rot_xz.z);
|
|
|
|
p.vel=(rot*p_system->particle_vars[VS::PARTICLE_LINEAR_VELOCITY]+rot*p_system->particle_randomness[VS::PARTICLE_LINEAR_VELOCITY]*_rand_from_seed(&rand_seed));
|
|
if (!p_system->local_coordinates)
|
|
p.vel=p_transform.basis.xform( p.vel );
|
|
|
|
p.vel+=p_system->emission_base_velocity;
|
|
|
|
p.rot=p_system->particle_vars[VS::PARTICLE_INITIAL_ANGLE]+p_system->particle_randomness[VS::PARTICLE_INITIAL_ANGLE]*_rand_from_seed(&rand_seed);
|
|
p.active=true;
|
|
for(int r=0;r<PARTICLE_RANDOM_NUMBERS;r++)
|
|
p.random[r]=_rand_from_seed(&rand_seed);
|
|
|
|
} else {
|
|
|
|
p.pos=Vector3();
|
|
p.rot=0;
|
|
p.vel=Vector3();
|
|
p.active=false;
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!p.active)
|
|
continue;
|
|
|
|
Vector3 force;
|
|
//apply gravity
|
|
force=p_system->gravity_normal * (p_system->particle_vars[VS::PARTICLE_GRAVITY]+(p_system->particle_randomness[VS::PARTICLE_GRAVITY]*p.random[0]));
|
|
//apply linear acceleration
|
|
force+=p.vel.normalized() * (p_system->particle_vars[VS::PARTICLE_LINEAR_ACCELERATION]+p_system->particle_randomness[VS::PARTICLE_LINEAR_ACCELERATION]*p.random[1]);
|
|
//apply radial acceleration
|
|
Vector3 org;
|
|
if (!p_system->local_coordinates)
|
|
org=p_transform.origin;
|
|
force+=(p.pos-org).normalized() * (p_system->particle_vars[VS::PARTICLE_RADIAL_ACCELERATION]+p_system->particle_randomness[VS::PARTICLE_RADIAL_ACCELERATION]*p.random[2]);
|
|
//apply tangential acceleration
|
|
force+=(p.pos-org).cross(p_system->gravity_normal).normalized() * (p_system->particle_vars[VS::PARTICLE_TANGENTIAL_ACCELERATION]+p_system->particle_randomness[VS::PARTICLE_TANGENTIAL_ACCELERATION]*p.random[3]);
|
|
//apply attractor forces
|
|
for(int a=0;a<p_system->attractor_count;a++) {
|
|
|
|
force+=(p.pos-attractor_positions[a]).normalized() * p_system->attractors[a].force;
|
|
}
|
|
|
|
|
|
p.vel+=force * p_time;
|
|
if (p_system->particle_vars[VS::PARTICLE_DAMPING]) {
|
|
|
|
float v = p.vel.length();
|
|
float damp = p_system->particle_vars[VS::PARTICLE_DAMPING] + p_system->particle_vars[VS::PARTICLE_DAMPING] * p_system->particle_randomness[VS::PARTICLE_DAMPING];
|
|
v -= damp * p_time;
|
|
if (v<0) {
|
|
p.vel=Vector3();
|
|
} else {
|
|
p.vel=p.vel.normalized() * v;
|
|
}
|
|
|
|
}
|
|
p.rot+=(p_system->particle_vars[VS::PARTICLE_ANGULAR_VELOCITY]+p_system->particle_randomness[VS::PARTICLE_ANGULAR_VELOCITY]*p.random[4]) *p_time;
|
|
p.pos+=p.vel * p_time;
|
|
}
|
|
}
|
|
|
|
particle_system_time=Math::fmod( particle_system_time+p_time, lifetime );
|
|
|
|
|
|
}
|
|
|
|
ParticleSystemProcessSW::ParticleSystemProcessSW() {
|
|
|
|
particle_system_time=0;
|
|
rand_seed=1234567;
|
|
valid=false;
|
|
}
|
|
|
|
|
|
struct _ParticleSorterSW {
|
|
|
|
|
|
_FORCE_INLINE_ bool operator()(const ParticleSystemDrawInfoSW::ParticleDrawInfo *p_a,const ParticleSystemDrawInfoSW::ParticleDrawInfo *p_b) const {
|
|
|
|
return p_a->d > p_b->d; // draw from further away to closest
|
|
}
|
|
};
|
|
|
|
void ParticleSystemDrawInfoSW::prepare(const ParticleSystemSW *p_system,const ParticleSystemProcessSW *p_process,const Transform& p_system_transform,const Transform& p_camera_transform) {
|
|
|
|
ERR_FAIL_COND(p_process->particle_data.size() != p_system->amount);
|
|
ERR_FAIL_COND(p_system->amount<=0 || p_system->amount>=ParticleSystemSW::MAX_PARTICLES);
|
|
|
|
const ParticleSystemProcessSW::ParticleData *pdata=&p_process->particle_data[0];
|
|
float time_pos=p_process->particle_system_time/p_system->particle_vars[VS::PARTICLE_LIFETIME];
|
|
|
|
ParticleSystemSW::ColorPhase cphase[VS::MAX_PARTICLE_COLOR_PHASES];
|
|
|
|
float last=-1;
|
|
int col_count=0;
|
|
|
|
for(int i=0;i<p_system->color_phase_count;i++) {
|
|
|
|
if (p_system->color_phases[i].pos<=last)
|
|
break;
|
|
cphase[i]=p_system->color_phases[i];
|
|
col_count++;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Vector3 camera_z_axis = p_camera_transform.basis.get_axis(2);
|
|
|
|
for(int i=0;i<p_system->amount;i++) {
|
|
|
|
ParticleDrawInfo &pdi=draw_info[i];
|
|
pdi.data=&pdata[i];
|
|
pdi.transform.origin=pdi.data->pos;
|
|
if (p_system->local_coordinates)
|
|
pdi.transform.origin=p_system_transform.xform(pdi.transform.origin);
|
|
|
|
pdi.d=-camera_z_axis.dot(pdi.transform.origin);
|
|
|
|
// adjust particle size, color and rotation
|
|
|
|
float time = ((float)i / p_system->amount);
|
|
if (time<time_pos)
|
|
time=time_pos-time;
|
|
else
|
|
time=(1.0-time)+time_pos;
|
|
|
|
Vector3 up=p_camera_transform.basis.get_axis(1); // up determines the rotation
|
|
float up_scale=1.0;
|
|
|
|
if (p_system->height_from_velocity) {
|
|
|
|
Vector3 veld = pdi.data->vel;
|
|
Vector3 cam_z = camera_z_axis.normalized();
|
|
float vc = Math::abs(veld.normalized().dot(cam_z));
|
|
|
|
if (vc<(1.0-CMP_EPSILON)) {
|
|
up = Plane(cam_z,0).project(veld).normalized();
|
|
float h = p_system->particle_vars[VS::PARTICLE_HEIGHT]+p_system->particle_randomness[VS::PARTICLE_HEIGHT]*pdi.data->random[7];
|
|
float velh = veld.length();
|
|
h+=velh*(p_system->particle_vars[VS::PARTICLE_HEIGHT_SPEED_SCALE]+p_system->particle_randomness[VS::PARTICLE_HEIGHT_SPEED_SCALE]*pdi.data->random[7]);
|
|
|
|
|
|
up_scale=Math::lerp(1.0,h,(1.0-vc));
|
|
}
|
|
|
|
} else if (pdi.data->rot) {
|
|
|
|
up.rotate(camera_z_axis,pdi.data->rot);
|
|
}
|
|
|
|
{
|
|
// matrix
|
|
Vector3 v_z = (p_camera_transform.origin-pdi.transform.origin).normalized();
|
|
// Vector3 v_z = (p_camera_transform.origin-pdi.data->pos).normalized();
|
|
Vector3 v_y = up;
|
|
Vector3 v_x = v_y.cross(v_z);
|
|
v_y = v_z.cross(v_x);
|
|
v_x.normalize();
|
|
v_y.normalize();
|
|
|
|
|
|
float initial_scale, final_scale;
|
|
initial_scale = p_system->particle_vars[VS::PARTICLE_INITIAL_SIZE]+p_system->particle_randomness[VS::PARTICLE_INITIAL_SIZE]*pdi.data->random[5];
|
|
final_scale = p_system->particle_vars[VS::PARTICLE_FINAL_SIZE]+p_system->particle_randomness[VS::PARTICLE_FINAL_SIZE]*pdi.data->random[6];
|
|
float scale = initial_scale + time * (final_scale - initial_scale);
|
|
|
|
pdi.transform.basis.set_axis(0,v_x * scale);
|
|
pdi.transform.basis.set_axis(1,v_y * scale * up_scale);
|
|
pdi.transform.basis.set_axis(2,v_z * scale);
|
|
}
|
|
|
|
|
|
|
|
int cpos=0;
|
|
|
|
while(cpos<col_count) {
|
|
|
|
if (cphase[cpos].pos > time)
|
|
break;
|
|
cpos++;
|
|
}
|
|
|
|
cpos--;
|
|
|
|
|
|
if (cpos==-1)
|
|
pdi.color=Color(1,1,1,1);
|
|
else {
|
|
if (cpos==col_count-1)
|
|
pdi.color=cphase[cpos].color;
|
|
else {
|
|
float diff = (cphase[cpos+1].pos-cphase[cpos].pos);
|
|
if (diff>0)
|
|
pdi.color=cphase[cpos].color.linear_interpolate(cphase[cpos+1].color, (time - cphase[cpos].pos) / diff );
|
|
else
|
|
pdi.color=cphase[cpos+1].color;
|
|
}
|
|
}
|
|
|
|
|
|
draw_info_order[i]=&pdi;
|
|
|
|
}
|
|
|
|
|
|
SortArray<ParticleDrawInfo*,_ParticleSorterSW> particle_sort;
|
|
particle_sort.sort(&draw_info_order[0],p_system->amount);
|
|
|
|
}
|