Differential D3855 Diff 20257 source/blender/modifiers/intern/MOD_manta.c

Changeset View

Standalone View

source/blender/modifiers/intern/MOD_manta.c

This file was moved from source/blender/modifiers/intern/MOD_smoke.c.

	Show All 24 Lines

	#include "MEM_guardedalloc.h"			#include "MEM_guardedalloc.h"

	#include "BLI_utildefines.h"			#include "BLI_utildefines.h"

	#include "DNA_collection_types.h"			#include "DNA_collection_types.h"
	#include "DNA_object_types.h"			#include "DNA_object_types.h"
	#include "DNA_scene_types.h"			#include "DNA_scene_types.h"
	#include "DNA_smoke_types.h"			#include "DNA_manta_types.h"
	#include "DNA_object_force_types.h"			#include "DNA_object_force_types.h"
	#include "DNA_mesh_types.h"			#include "DNA_mesh_types.h"

	#include "BKE_cdderivedmesh.h"			#include "BKE_cdderivedmesh.h"
	#include "BKE_layer.h"			#include "BKE_layer.h"
	#include "BKE_library_query.h"			#include "BKE_library_query.h"
	#include "BKE_modifier.h"			#include "BKE_modifier.h"
	#include "BKE_smoke.h"			#include "BKE_manta.h"

	#include "DEG_depsgraph.h"			#include "DEG_depsgraph.h"
	#include "DEG_depsgraph_build.h"			#include "DEG_depsgraph_build.h"
	#include "DEG_depsgraph_physics.h"			#include "DEG_depsgraph_physics.h"
	#include "DEG_depsgraph_query.h"			#include "DEG_depsgraph_query.h"

	#include "MOD_modifiertypes.h"			#include "MOD_modifiertypes.h"

	static void initData(ModifierData *md)			static void initData(ModifierData *md)
	{			{
	SmokeModifierData smd = (SmokeModifierData )md;			FluidModifierData mmd = (FluidModifierData )md;

	smd->domain = NULL;			mmd->domain = NULL;
	smd->flow = NULL;			mmd->flow = NULL;
	smd->coll = NULL;			mmd->effector = NULL;
	smd->type = 0;			mmd->type = 0;
	smd->time = -1;			mmd->time = -1;
	}			}

	static void copyData(const ModifierData md, ModifierData target, const int flag)			static void copyData(const ModifierData md, ModifierData target, const int flag)
	{			{
	const SmokeModifierData smd = (const SmokeModifierData )md;			const FluidModifierData mmd = (const FluidModifierData )md;
	SmokeModifierData tsmd = (SmokeModifierData )target;			FluidModifierData tmmd = (FluidModifierData )target;

	smokeModifier_free(tsmd);			mantaModifier_free(tmmd);
	smokeModifier_copy(smd, tsmd, flag);			mantaModifier_copy(mmd, tmmd, flag);
	}			}

	static void freeData(ModifierData *md)			static void freeData(ModifierData *md)
	{			{
	SmokeModifierData smd = (SmokeModifierData )md;			FluidModifierData mmd = (FluidModifierData )md;

	smokeModifier_free(smd);			mantaModifier_free(mmd);
	}			}

	static void requiredDataMask(Object *UNUSED(ob),			static void requiredDataMask(Object *UNUSED(ob),
	ModifierData *md,			ModifierData *md,
	CustomData_MeshMasks *r_cddata_masks)			CustomData_MeshMasks *r_cddata_masks)
	{			{
	SmokeModifierData smd = (SmokeModifierData )md;			FluidModifierData mmd = (FluidModifierData )md;

	if (smd && (smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {			if (mmd && (mmd->type & MOD_MANTA_TYPE_FLOW) && mmd->flow) {
	if (smd->flow->source == MOD_SMOKE_FLOW_SOURCE_MESH) {			if (mmd->flow->source == FLUID_FLOW_SOURCE_MESH) {
	/* vertex groups */			/* vertex groups */
	if (smd->flow->vgroup_density) {			if (mmd->flow->vgroup_density) {
	r_cddata_masks->vmask \|= CD_MASK_MDEFORMVERT;			r_cddata_masks->vmask \|= CD_MASK_MDEFORMVERT;
	}			}
	/* uv layer */			/* uv layer */
	if (smd->flow->texture_type == MOD_SMOKE_FLOW_TEXTURE_MAP_UV) {			if (mmd->flow->texture_type == FLUID_FLOW_TEXTURE_MAP_UV) {
	r_cddata_masks->fmask \|= CD_MASK_MTFACE;			r_cddata_masks->fmask \|= CD_MASK_MTFACE;
	}			}
	}			}
	}			}
	}			}

	static Mesh applyModifier(ModifierData md, const ModifierEvalContext ctx, Mesh me)			static Mesh applyModifier(ModifierData md, const ModifierEvalContext ctx, Mesh me)
	{			{
	SmokeModifierData smd = (SmokeModifierData )md;			FluidModifierData mmd = (FluidModifierData )md;
				Mesh *result = NULL;

	if (ctx->flag & MOD_APPLY_ORCO) {			if (ctx->flag & MOD_APPLY_ORCO) {
	return me;			return me;
	}			}

	Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph);			Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph);
	return smokeModifier_do(smd, ctx->depsgraph, scene, ctx->object, me);
				result = mantaModifier_do(mmd, ctx->depsgraph, scene, ctx->object, me);
				return result ? result : me;
	}			}

	static bool dependsOnTime(ModifierData *UNUSED(md))			static bool dependsOnTime(ModifierData *UNUSED(md))
	{			{
	return true;			return true;
	}			}

	static bool is_flow_cb(Object UNUSED(ob), ModifierData md)			static bool is_flow_cb(Object UNUSED(ob), ModifierData md)
	{			{
	SmokeModifierData smd = (SmokeModifierData )md;			FluidModifierData mmd = (FluidModifierData )md;
	return (smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow;			return (mmd->type & MOD_MANTA_TYPE_FLOW) && mmd->flow;
	}			}

	static bool is_coll_cb(Object UNUSED(ob), ModifierData md)			static bool is_coll_cb(Object UNUSED(ob), ModifierData md)
	{			{
	SmokeModifierData smd = (SmokeModifierData )md;			FluidModifierData mmd = (FluidModifierData )md;
	return (smd->type & MOD_SMOKE_TYPE_COLL) && smd->coll;			return (mmd->type & MOD_MANTA_TYPE_EFFEC) && mmd->effector;
	}			}

	static void updateDepsgraph(ModifierData md, const ModifierUpdateDepsgraphContext ctx)			static void updateDepsgraph(ModifierData md, const ModifierUpdateDepsgraphContext ctx)
	{			{
	SmokeModifierData smd = (SmokeModifierData )md;			FluidModifierData mmd = (FluidModifierData )md;

	if (smd && (smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {			if (mmd && (mmd->type & MOD_MANTA_TYPE_DOMAIN) && mmd->domain) {
	DEG_add_collision_relations(ctx->node,			DEG_add_collision_relations(ctx->node,
	ctx->object,			ctx->object,
	smd->domain->fluid_group,			mmd->domain->fluid_group,
	eModifierType_Smoke,			eModifierType_Manta,
	is_flow_cb,			is_flow_cb,
	"Smoke Flow");			"Manta Flow");
	DEG_add_collision_relations(ctx->node,			DEG_add_collision_relations(ctx->node,
	ctx->object,			ctx->object,
	smd->domain->coll_group,			mmd->domain->effector_group,
	eModifierType_Smoke,			eModifierType_Manta,
	is_coll_cb,			is_coll_cb,
	"Smoke Coll");			"Manta Coll");
	DEG_add_forcefield_relations(ctx->node,			DEG_add_forcefield_relations(ctx->node,
	ctx->object,			ctx->object,
	smd->domain->effector_weights,			mmd->domain->effector_weights,
	true,			true,
	PFIELD_SMOKEFLOW,			PFIELD_SMOKEFLOW,
	"Smoke Force Field");			"Manta Force Field");

				if (mmd->domain->guiding_parent != NULL) {
				DEG_add_object_relation(
				ctx->node, mmd->domain->guiding_parent, DEG_OB_COMP_TRANSFORM, "Fluid Guiding Object");
				DEG_add_object_relation(
				ctx->node, mmd->domain->guiding_parent, DEG_OB_COMP_GEOMETRY, "Fluid Guiding Object");
				}
	}			}
	}			}

	static void foreachIDLink(ModifierData md, Object ob, IDWalkFunc walk, void *userData)			static void foreachIDLink(ModifierData md, Object ob, IDWalkFunc walk, void *userData)
	{			{
	SmokeModifierData smd = (SmokeModifierData )md;			FluidModifierData mmd = (FluidModifierData )md;

	if (smd->type == MOD_SMOKE_TYPE_DOMAIN && smd->domain) {			if (mmd->type == MOD_MANTA_TYPE_DOMAIN && mmd->domain) {
	walk(userData, ob, (ID **)&smd->domain->coll_group, IDWALK_CB_NOP);			walk(userData, ob, (ID **)&mmd->domain->effector_group, IDWALK_CB_NOP);
	walk(userData, ob, (ID **)&smd->domain->fluid_group, IDWALK_CB_NOP);			walk(userData, ob, (ID **)&mmd->domain->fluid_group, IDWALK_CB_NOP);
	walk(userData, ob, (ID **)&smd->domain->eff_group, IDWALK_CB_NOP);			walk(userData, ob, (ID **)&mmd->domain->force_group, IDWALK_CB_NOP);

				if (mmd->domain->guiding_parent) {
				walk(userData, ob, (ID **)&mmd->domain->guiding_parent, IDWALK_CB_NOP);
				}

	if (smd->domain->effector_weights) {			if (mmd->domain->effector_weights) {
	walk(userData, ob, (ID **)&smd->domain->effector_weights->group, IDWALK_CB_NOP);			walk(userData, ob, (ID **)&mmd->domain->effector_weights->group, IDWALK_CB_NOP);
	}			}
	}			}

	if (smd->type == MOD_SMOKE_TYPE_FLOW && smd->flow) {			if (mmd->type == MOD_MANTA_TYPE_FLOW && mmd->flow) {
	walk(userData, ob, (ID **)&smd->flow->noise_texture, IDWALK_CB_USER);			walk(userData, ob, (ID **)&mmd->flow->noise_texture, IDWALK_CB_USER);
	}			}
	}			}

	ModifierTypeInfo modifierType_Smoke = {			ModifierTypeInfo modifierType_Manta = {
	/* name */ "Smoke",			/* name */ "Fluid",
	/* structName */ "SmokeModifierData",			/* structName */ "FluidModifierData",
	/* structSize */ sizeof(SmokeModifierData),			/* structSize */ sizeof(FluidModifierData),
	/* type */ eModifierTypeType_Constructive,			/* type */ eModifierTypeType_Constructive,
	/* flags */ eModifierTypeFlag_AcceptsMesh \| eModifierTypeFlag_UsesPointCache \|			/* flags */ eModifierTypeFlag_AcceptsMesh \| eModifierTypeFlag_Single,
	eModifierTypeFlag_Single,

	/* copyData */ copyData,			/* copyData */ copyData,

	/* deformVerts */ NULL,			/* deformVerts */ NULL,
	/* deformMatrices */ NULL,			/* deformMatrices */ NULL,
	/* deformVertsEM */ NULL,			/* deformVertsEM */ NULL,
	/* deformMatricesEM */ NULL,			/* deformMatricesEM */ NULL,
	/* applyModifier */ applyModifier,			/* applyModifier */ applyModifier,
	Show All 13 Lines