archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
9306037ed3d14a7afce607738f83c8b9968d478d
blender-archive/source/blender/simulation/intern/particle_function.hh

93 lines
3.0 KiB
C++
Raw Normal View History

Refactor: move ParticleFunction to separate file
2020-07-17 14:23:57 +02:00
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __SIM_PARTICLE_FUNCTION_HH__
#define __SIM_PARTICLE_FUNCTION_HH__
#include "FN_attributes_ref.hh"
#include "FN_multi_function.hh"
#include "BLI_resource_collector.hh"
Particles: Emit particles over time This adds a basic internal emitter for every particle simulation. The emitter cannot be controlled by the user yet. That will come next.
2020-07-19 13:58:49 +02:00
#include "simulation_solver.hh"
Refactor: move ParticleFunction to separate file
2020-07-17 14:23:57 +02:00
namespace blender::sim {
class ParticleFunctionInput {
public:
virtual ~ParticleFunctionInput() = default;
virtual void add_input(fn::AttributesRef attributes,
fn::MFParamsBuilder &params,
ResourceCollector &resources) const = 0;
};
class ParticleFunction {
private:
const fn::MultiFunction *global_fn_;
const fn::MultiFunction *per_particle_fn_;
Array<const ParticleFunctionInput *> global_inputs_;
Array<const ParticleFunctionInput *> per_particle_inputs_;
Array<bool> output_is_global_;
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
Vector<int> global_output_indices_;
Vector<int> per_particle_output_indices_;
Refactor: move ParticleFunction to separate file
2020-07-17 14:23:57 +02:00
Vector<fn::MFDataType> output_types_;
Vector<StringRefNull> output_names_;
friend class ParticleFunctionEvaluator;
public:
ParticleFunction(const fn::MultiFunction *global_fn,
const fn::MultiFunction *per_particle_fn,
Span<const ParticleFunctionInput *> global_inputs,
Span<const ParticleFunctionInput *> per_particle_inputs,
Span<bool> output_is_global);
};
class ParticleFunctionEvaluator {
private:
ResourceCollector resources_;
const ParticleFunction &particle_fn_;
Particles: initial object socket and emitter node support Object sockets work now, but only the new Object Transforms and the Particle Mesh Emitter node use it. The emitter does not actually use the mesh surface yet. Instead, new particles are just emitted around the origin of the object. Internally, handles to object data blocks are passed around in the network, instead of raw object pointers. Using handles has a couple of benefits: * The caller of the function has control over which handles can be resolved and therefore limit access to specific data. The set of data blocks that is accessed by a node tree should be known statically. This is necessary for a proper integration with the dependency graph. * When the pointer to an object changes (e.g. after restarting Blender), all handles are still valid. * When an object is deleted, the handle is invalidated without causing crashes. * The handle is just an integer that can be stored per particle and can be cached easily. The mapping between handles and their corresponding data blocks is stored in the Simulation data block.
2020-07-21 17:20:05 +02:00
const SimulationSolveContext &solve_context_;
Particles: Emit particles over time This adds a basic internal emitter for every particle simulation. The emitter cannot be controlled by the user yet. That will come next.
2020-07-19 13:58:49 +02:00
const ParticleChunkContext &particle_chunk_context_;
Refactor: move ParticleFunction to separate file
2020-07-17 14:23:57 +02:00
IndexMask mask_;
fn::MFContextBuilder global_context_;
fn::MFContextBuilder per_particle_context_;
Vector<void *> outputs_;
bool is_computed_ = false;
public:
ParticleFunctionEvaluator(const ParticleFunction &particle_fn,
Particles: initial object socket and emitter node support Object sockets work now, but only the new Object Transforms and the Particle Mesh Emitter node use it. The emitter does not actually use the mesh surface yet. Instead, new particles are just emitted around the origin of the object. Internally, handles to object data blocks are passed around in the network, instead of raw object pointers. Using handles has a couple of benefits: * The caller of the function has control over which handles can be resolved and therefore limit access to specific data. The set of data blocks that is accessed by a node tree should be known statically. This is necessary for a proper integration with the dependency graph. * When the pointer to an object changes (e.g. after restarting Blender), all handles are still valid. * When an object is deleted, the handle is invalidated without causing crashes. * The handle is just an integer that can be stored per particle and can be cached easily. The mapping between handles and their corresponding data blocks is stored in the Simulation data block.
2020-07-21 17:20:05 +02:00
const SimulationSolveContext &solve_context,
Particles: Emit particles over time This adds a basic internal emitter for every particle simulation. The emitter cannot be controlled by the user yet. That will come next.
2020-07-19 13:58:49 +02:00
const ParticleChunkContext &particle_chunk_context);
Refactor: move ParticleFunction to separate file
2020-07-17 14:23:57 +02:00
~ParticleFunctionEvaluator();
void compute();
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
fn::GVSpan get(int output_index, StringRef expected_name) const;
Refactor: move ParticleFunction to separate file
2020-07-17 14:23:57 +02:00
Refactor: Update integer type usage This updates the usage of integer types in code I wrote according to our new style guides. Major changes: * Use signed instead of unsigned integers in many places. * C++ containers in blenlib use `int64_t` for size and indices now (instead of `uint`). * Hash values for C++ containers are 64 bit wide now (instead of 32 bit). I do hope that I broke no builds, but it is quite likely that some compiler reports slightly different errors. Please let me know when there are any errors. If the fix is small, feel free to commit it yourself. I compiled successfully on linux with gcc and on windows.
2020-07-20 12:16:20 +02:00
template<typename T> fn::VSpan<T> get(int output_index, StringRef expected_name) const
Refactor: move ParticleFunction to separate file
2020-07-17 14:23:57 +02:00
{
return this->get(output_index, expected_name).typed<T>();
}
private:
void compute_globals();
void compute_per_particle();
};
} // namespace blender::sim
#endif /* __SIM_PARTICLE_FUNCTION_HH__ */
Copy Permalink