Import('env')

env_modules = env.Clone()

Export('env_modules')

continue

env.Prepend(LIBS=[lib])

float t2 = t * t;

float t3 = t2 * t;

}

T bezier(T start, T control_1, T control_2, T end, float t) {

Spatial *parent_node = parent_lookup->value();

ERR_FAIL_COND_V_MSG(parent_node == NULL, state.root,

if (spatial != state.root) {

parent_node->add_child(spatial);

}

aiMaterial *ai_material = state.assimp_scene->mMaterials[ai_mesh->mMaterialIndex];

mat.instance();

int32_t mat_two_sided = 0;

if (AI_SUCCESS == ai_material->Get(AI_MATKEY_TWOSIDED, mat_two_sided)) {

if (mat_two_sided > 0) {

} else {

}

}

// Culling handling for meshes

// cull all back faces

// Now process materials

aiTextureType base_color = aiTextureType_BASE_COLOR;

// anything transparent must be culled

if (image_data.raw_image->detect_alpha() != Image::ALPHA_NONE) {

}

}

}

// anything transparent must be culled

if (image_data.raw_image->detect_alpha() != Image::ALPHA_NONE) {

}

}

aiColor4D clr_diffuse;

if (AI_SUCCESS == ai_material->Get(AI_MATKEY_COLOR_DIFFUSE, clr_diffuse)) {

if (Math::is_equal_approx(clr_diffuse.a, 1.0f) == false) {

}

mat->set_albedo(Color(clr_diffuse.r, clr_diffuse.g, clr_diffuse.b, clr_diffuse.a));

}

// Process texture normal map

if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_normal, filename, path, image_data)) {

AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);

} else {

aiString texture_path;

if (AI_SUCCESS == ai_material->Get(AI_MATKEY_FBX_NORMAL_TEXTURE, AI_PROPERTIES, texture_path)) {

if (AssimpUtils::CreateAssimpTexture(state, texture_path, filename, path, image_data)) {

}

}

}

// Process texture normal map

if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_normal_camera, filename, path, image_data)) {

AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);

}

}

// Process texture normal map

if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_emission_color, filename, path, image_data)) {

AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);

}

}

// Process texture normal map

if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_metalness, filename, path, image_data)) {

AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);

}

}

// Process texture normal map

if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_roughness, filename, path, image_data)) {

AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);

}

}

if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_emissive, filename, path, image_data)) {

AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);

} else {

// Process emission textures

aiString texture_emissive_path;

if (AI_SUCCESS ==

ai_material->Get(AI_MATKEY_FBX_MAYA_EMISSION_TEXTURE, AI_PROPERTIES, texture_emissive_path)) {

if (AssimpUtils::CreateAssimpTexture(state, texture_emissive_path, filename, path, image_data)) {

}

} else {

float pbr_emission = 0.0f;

// Process texture normal map

if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_specular, filename, path, image_data)) {

AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);

}

}

// Process texture normal map

if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_ao_map, filename, path, image_data)) {

AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);

}

}

}

/**

*/

static const Transform assimp_matrix_transform(const aiMatrix4x4 p_matrix) {

aiMatrix4x4 matrix = p_matrix;

static void set_texture_mapping_mode(aiTextureMapMode *map_mode, Ref<ImageTexture> texture) {

ERR_FAIL_COND(texture.is_null());

ERR_FAIL_COND(map_mode == NULL);

aiTextureMapMode tex_mode = map_mode[0];

if (tex_mode == aiTextureMapMode_Wrap) {

//Default

} else if (tex_mode == aiTextureMapMode_Clamp) {

} else if (tex_mode == aiTextureMapMode_Mirror) {

}

texture->set_flags(flags);

}

/**

}

return Ref<Image>();

} else {

ERR_FAIL_COND_V(texture.is_null(), Ref<Image>());

Ref<Image> image = texture->get_data();

ERR_FAIL_COND_V(image.is_null(), Ref<Image>());

if (image_state.raw_image.is_valid()) {

image_state.texture.instance();

image_state.texture->create_from_image(image_state.raw_image);

return true;

}

}

def can_build(env, platform):

def configure(env):

pass

/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

/*************************************************************************/

Object *areaGodoObject = ObjectDB::get_instance(event.event_callback_id);

if (!areaGodoObject) {

return;

}

}

void AreaBullet::main_shape_changed() {

btGhost->setCollisionShape(get_main_shape());

}

set_spOv_gravityPointAttenuation(p_value);

break;

default:

}

}

case PhysicsServer::AREA_PARAM_GRAVITY_POINT_ATTENUATION:

return spOv_gravityPointAttenuation;

default:

return Variant();

}

}

ev.event_callback_method = p_method;

/// Set if monitoring

set_godot_object_flags(get_godot_object_flags() | GOF_IS_MONITORING_AREA);

} else {

set_godot_object_flags(get_godot_object_flags() & (~GOF_IS_MONITORING_AREA));

}

bool AreaBullet::has_event_callback(Type p_callbackObjectType) {

}

void AreaBullet::on_enter_area(AreaBullet *p_area) {

ObjectID event_callback_id;

StringName event_callback_method;

};

enum OverlapState {

// <--------------- Joint creation asserts

/// Assert the body is assigned to a space

}

/// Assert the two bodies of joint are in the same space

}

void BulletPhysicsServer::shape_set_data(RID p_shape, const Variant &p_data) {

ERR_FAIL_COND(!shape);

shape->set_data(p_data);

}

}

PhysicsServer::ShapeType BulletPhysicsServer::shape_get_type(RID p_shape) const {

ERR_FAIL_COND_V(!shape, PhysicsServer::SHAPE_CUSTOM);

return shape->get_type();

}

Variant BulletPhysicsServer::shape_get_data(RID p_shape) const {

ERR_FAIL_COND_V(!shape, Variant());

return shape->get_data();

}

void BulletPhysicsServer::shape_set_margin(RID p_shape, real_t p_margin) {

ERR_FAIL_COND(!shape);

shape->set_margin(p_margin);

}

real_t BulletPhysicsServer::shape_get_margin(RID p_shape) const {

ERR_FAIL_COND_V(!shape, 0.0);

return shape->get_margin();

}

void BulletPhysicsServer::space_set_active(RID p_space, bool p_active) {

ERR_FAIL_COND(!space);

if (space_is_active(p_space) == p_active) {

}

bool BulletPhysicsServer::space_is_active(RID p_space) const {

ERR_FAIL_COND_V(!space, false);

return -1 != active_spaces.find(space);

}

void BulletPhysicsServer::space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) {

ERR_FAIL_COND(!space);

space->set_param(p_param, p_value);

}

real_t BulletPhysicsServer::space_get_param(RID p_space, SpaceParameter p_param) const {

ERR_FAIL_COND_V(!space, 0);

return space->get_param(p_param);

}

PhysicsDirectSpaceState *BulletPhysicsServer::space_get_direct_state(RID p_space) {

ERR_FAIL_COND_V(!space, NULL);

return space->get_direct_state();

}

void BulletPhysicsServer::space_set_debug_contacts(RID p_space, int p_max_contacts) {

ERR_FAIL_COND(!space);

space->set_debug_contacts(p_max_contacts);

}

Vector<Vector3> BulletPhysicsServer::space_get_contacts(RID p_space) const {

ERR_FAIL_COND_V(!space, Vector<Vector3>());

return space->get_debug_contacts();

}

int BulletPhysicsServer::space_get_contact_count(RID p_space) const {

ERR_FAIL_COND_V(!space, 0);

return space->get_debug_contact_count();

}

void BulletPhysicsServer::area_set_space(RID p_area, RID p_space) {

ERR_FAIL_COND(!area);

SpaceBullet *space = NULL;

if (p_space.is_valid()) {

ERR_FAIL_COND(!space);

}

area->set_space(space);

}

RID BulletPhysicsServer::area_get_space(RID p_area) const {

return area->get_space()->get_self();

}

void BulletPhysicsServer::area_set_space_override_mode(RID p_area, AreaSpaceOverrideMode p_mode) {

ERR_FAIL_COND(!area);

area->set_spOv_mode(p_mode);

}

PhysicsServer::AreaSpaceOverrideMode BulletPhysicsServer::area_get_space_override_mode(RID p_area) const {

ERR_FAIL_COND_V(!area, PhysicsServer::AREA_SPACE_OVERRIDE_DISABLED);

return area->get_spOv_mode();

}

void BulletPhysicsServer::area_add_shape(RID p_area, RID p_shape, const Transform &p_transform, bool p_disabled) {

ERR_FAIL_COND(!area);

ERR_FAIL_COND(!shape);

area->add_shape(shape, p_transform, p_disabled);

}

void BulletPhysicsServer::area_set_shape(RID p_area, int p_shape_idx, RID p_shape) {

ERR_FAIL_COND(!area);

ERR_FAIL_COND(!shape);

area->set_shape(p_shape_idx, shape);

}

void BulletPhysicsServer::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform &p_transform) {

ERR_FAIL_COND(!area);

area->set_shape_transform(p_shape_idx, p_transform);

}

int BulletPhysicsServer::area_get_shape_count(RID p_area) const {

ERR_FAIL_COND_V(!area, 0);

return area->get_shape_count();

}

RID BulletPhysicsServer::area_get_shape(RID p_area, int p_shape_idx) const {

ERR_FAIL_COND_V(!area, RID());

return area->get_shape(p_shape_idx)->get_self();

}

Transform BulletPhysicsServer::area_get_shape_transform(RID p_area, int p_shape_idx) const {

ERR_FAIL_COND_V(!area, Transform());

return area->get_shape_transform(p_shape_idx);

}

void BulletPhysicsServer::area_remove_shape(RID p_area, int p_shape_idx) {

ERR_FAIL_COND(!area);

return area->remove_shape_full(p_shape_idx);

}

void BulletPhysicsServer::area_clear_shapes(RID p_area) {

ERR_FAIL_COND(!area);

for (int i = area->get_shape_count(); 0 < i; --i)

}

void BulletPhysicsServer::area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) {

ERR_FAIL_COND(!area);

area->set_shape_disabled(p_shape_idx, p_disabled);

if (space_owner.owns(p_area)) {

return;

}

ERR_FAIL_COND(!area);

area->set_instance_id(p_id);

}

ObjectID BulletPhysicsServer::area_get_object_instance_id(RID p_area) const {

if (space_owner.owns(p_area)) {

}

ERR_FAIL_COND_V(!area, ObjectID());

return area->get_instance_id();

}

void BulletPhysicsServer::area_set_param(RID p_area, AreaParameter p_param, const Variant &p_value) {

if (space_owner.owns(p_area)) {

if (space) {

space->set_param(p_param, p_value);

}

} else {

ERR_FAIL_COND(!area);

area->set_param(p_param, p_value);

Variant BulletPhysicsServer::area_get_param(RID p_area, AreaParameter p_param) const {

if (space_owner.owns(p_area)) {

return space->get_param(p_param);

} else {

ERR_FAIL_COND_V(!area, Variant());

return area->get_param(p_param);

}

void BulletPhysicsServer::area_set_transform(RID p_area, const Transform &p_transform) {

ERR_FAIL_COND(!area);

area->set_transform(p_transform);

}

Transform BulletPhysicsServer::area_get_transform(RID p_area) const {

ERR_FAIL_COND_V(!area, Transform());

return area->get_transform();

}

void BulletPhysicsServer::area_set_collision_mask(RID p_area, uint32_t p_mask) {

ERR_FAIL_COND(!area);

area->set_collision_mask(p_mask);

}

void BulletPhysicsServer::area_set_collision_layer(RID p_area, uint32_t p_layer) {

ERR_FAIL_COND(!area);

area->set_collision_layer(p_layer);

}

void BulletPhysicsServer::area_set_monitorable(RID p_area, bool p_monitorable) {

ERR_FAIL_COND(!area);

area->set_monitorable(p_monitorable);

}

void BulletPhysicsServer::area_set_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {

ERR_FAIL_COND(!area);

}

void BulletPhysicsServer::area_set_area_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {

ERR_FAIL_COND(!area);

}

void BulletPhysicsServer::area_set_ray_pickable(RID p_area, bool p_enable) {

ERR_FAIL_COND(!area);

area->set_ray_pickable(p_enable);

}

bool BulletPhysicsServer::area_is_ray_pickable(RID p_area) const {

ERR_FAIL_COND_V(!area, false);

return area->is_ray_pickable();

}

}

void BulletPhysicsServer::body_set_space(RID p_body, RID p_space) {

ERR_FAIL_COND(!body);

SpaceBullet *space = NULL;

if (p_space.is_valid()) {

ERR_FAIL_COND(!space);

}

}

RID BulletPhysicsServer::body_get_space(RID p_body) const {

ERR_FAIL_COND_V(!body, RID());

SpaceBullet *space = body->get_space();

}

void BulletPhysicsServer::body_set_mode(RID p_body, PhysicsServer::BodyMode p_mode) {

ERR_FAIL_COND(!body);

body->set_mode(p_mode);

}

PhysicsServer::BodyMode BulletPhysicsServer::body_get_mode(RID p_body) const {

ERR_FAIL_COND_V(!body, BODY_MODE_STATIC);

return body->get_mode();

}

void BulletPhysicsServer::body_add_shape(RID p_body, RID p_shape, const Transform &p_transform, bool p_disabled) {

ERR_FAIL_COND(!body);

ERR_FAIL_COND(!shape);

body->add_shape(shape, p_transform, p_disabled);

}

void BulletPhysicsServer::body_set_shape(RID p_body, int p_shape_idx, RID p_shape) {

ERR_FAIL_COND(!body);

ERR_FAIL_COND(!shape);

body->set_shape(p_shape_idx, shape);

}

void BulletPhysicsServer::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform &p_transform) {

ERR_FAIL_COND(!body);

body->set_shape_transform(p_shape_idx, p_transform);

}

int BulletPhysicsServer::body_get_shape_count(RID p_body) const {

ERR_FAIL_COND_V(!body, 0);

return body->get_shape_count();

}

RID BulletPhysicsServer::body_get_shape(RID p_body, int p_shape_idx) const {

ERR_FAIL_COND_V(!body, RID());

ShapeBullet *shape = body->get_shape(p_shape_idx);

}

Transform BulletPhysicsServer::body_get_shape_transform(RID p_body, int p_shape_idx) const {

ERR_FAIL_COND_V(!body, Transform());

return body->get_shape_transform(p_shape_idx);

}

void BulletPhysicsServer::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) {

ERR_FAIL_COND(!body);

body->set_shape_disabled(p_shape_idx, p_disabled);

}

void BulletPhysicsServer::body_remove_shape(RID p_body, int p_shape_idx) {

ERR_FAIL_COND(!body);

body->remove_shape_full(p_shape_idx);

}

void BulletPhysicsServer::body_clear_shapes(RID p_body) {

ERR_FAIL_COND(!body);

body->remove_all_shapes();

}

CollisionObjectBullet *body = get_collisin_object(p_body);

ERR_FAIL_COND(!body);

body->set_instance_id(p_id);

}

CollisionObjectBullet *body = get_collisin_object(p_body);

return body->get_instance_id();

}

void BulletPhysicsServer::body_set_enable_continuous_collision_detection(RID p_body, bool p_enable) {

ERR_FAIL_COND(!body);

body->set_continuous_collision_detection(p_enable);

}

bool BulletPhysicsServer::body_is_continuous_collision_detection_enabled(RID p_body) const {

ERR_FAIL_COND_V(!body, false);

return body->is_continuous_collision_detection_enabled();

}

void BulletPhysicsServer::body_set_collision_layer(RID p_body, uint32_t p_layer) {

ERR_FAIL_COND(!body);

body->set_collision_layer(p_layer);

}

uint32_t BulletPhysicsServer::body_get_collision_layer(RID p_body) const {

ERR_FAIL_COND_V(!body, 0);

return body->get_collision_layer();

}

void BulletPhysicsServer::body_set_collision_mask(RID p_body, uint32_t p_mask) {

ERR_FAIL_COND(!body);

body->set_collision_mask(p_mask);

}

uint32_t BulletPhysicsServer::body_get_collision_mask(RID p_body) const {

ERR_FAIL_COND_V(!body, 0);

return body->get_collision_mask();

}

void BulletPhysicsServer::body_set_param(RID p_body, BodyParameter p_param, float p_value) {

ERR_FAIL_COND(!body);

body->set_param(p_param, p_value);

}

float BulletPhysicsServer::body_get_param(RID p_body, BodyParameter p_param) const {

ERR_FAIL_COND_V(!body, 0);

return body->get_param(p_param);

}

void BulletPhysicsServer::body_set_kinematic_safe_margin(RID p_body, real_t p_margin) {

ERR_FAIL_COND(!body);

if (body->get_kinematic_utilities()) {

}

real_t BulletPhysicsServer::body_get_kinematic_safe_margin(RID p_body) const {

ERR_FAIL_COND_V(!body, 0);

if (body->get_kinematic_utilities()) {

}

void BulletPhysicsServer::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {

ERR_FAIL_COND(!body);

body->set_state(p_state, p_variant);

}

Variant BulletPhysicsServer::body_get_state(RID p_body, BodyState p_state) const {

ERR_FAIL_COND_V(!body, Variant());

return body->get_state(p_state);

}

void BulletPhysicsServer::body_set_applied_force(RID p_body, const Vector3 &p_force) {

ERR_FAIL_COND(!body);

body->set_applied_force(p_force);

}

Vector3 BulletPhysicsServer::body_get_applied_force(RID p_body) const {

ERR_FAIL_COND_V(!body, Vector3());

return body->get_applied_force();

}

void BulletPhysicsServer::body_set_applied_torque(RID p_body, const Vector3 &p_torque) {

ERR_FAIL_COND(!body);

body->set_applied_torque(p_torque);

}

Vector3 BulletPhysicsServer::body_get_applied_torque(RID p_body) const {

ERR_FAIL_COND_V(!body, Vector3());

return body->get_applied_torque();

}

void BulletPhysicsServer::body_add_central_force(RID p_body, const Vector3 &p_force) {

ERR_FAIL_COND(!body);

body->apply_central_force(p_force);

}

void BulletPhysicsServer::body_add_force(RID p_body, const Vector3 &p_force, const Vector3 &p_pos) {

ERR_FAIL_COND(!body);

body->apply_force(p_force, p_pos);

}

void BulletPhysicsServer::body_add_torque(RID p_body, const Vector3 &p_torque) {

ERR_FAIL_COND(!body);

body->apply_torque(p_torque);

}

void BulletPhysicsServer::body_apply_central_impulse(RID p_body, const Vector3 &p_impulse) {

ERR_FAIL_COND(!body);

body->apply_central_impulse(p_impulse);

}

void BulletPhysicsServer::body_apply_impulse(RID p_body, const Vector3 &p_pos, const Vector3 &p_impulse) {

ERR_FAIL_COND(!body);

body->apply_impulse(p_pos, p_impulse);

}

void BulletPhysicsServer::body_apply_torque_impulse(RID p_body, const Vector3 &p_impulse) {

ERR_FAIL_COND(!body);

body->apply_torque_impulse(p_impulse);

}

void BulletPhysicsServer::body_set_axis_velocity(RID p_body, const Vector3 &p_axis_velocity) {

ERR_FAIL_COND(!body);

Vector3 v = body->get_linear_velocity();

}

void BulletPhysicsServer::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_lock) {

ERR_FAIL_COND(!body);

body->set_axis_lock(p_axis, p_lock);

}

bool BulletPhysicsServer::body_is_axis_locked(RID p_body, BodyAxis p_axis) const {

ERR_FAIL_COND_V(!body, 0);

return body->is_axis_locked(p_axis);

}

void BulletPhysicsServer::body_add_collision_exception(RID p_body, RID p_body_b) {

ERR_FAIL_COND(!body);

ERR_FAIL_COND(!other_body);

body->add_collision_exception(other_body);

}

void BulletPhysicsServer::body_remove_collision_exception(RID p_body, RID p_body_b) {

ERR_FAIL_COND(!body);

ERR_FAIL_COND(!other_body);

body->remove_collision_exception(other_body);

}

void BulletPhysicsServer::body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {

ERR_FAIL_COND(!body);

for (int i = 0; i < body->get_exceptions().size(); i++) {

p_exceptions->push_back(body->get_exceptions()[i]);

}

void BulletPhysicsServer::body_set_max_contacts_reported(RID p_body, int p_contacts) {

ERR_FAIL_COND(!body);

body->set_max_collisions_detection(p_contacts);

}

int BulletPhysicsServer::body_get_max_contacts_reported(RID p_body) const {

ERR_FAIL_COND_V(!body, 0);

return body->get_max_collisions_detection();

}

void BulletPhysicsServer::body_set_omit_force_integration(RID p_body, bool p_omit) {

ERR_FAIL_COND(!body);

body->set_omit_forces_integration(p_omit);

}

bool BulletPhysicsServer::body_is_omitting_force_integration(RID p_body) const {

ERR_FAIL_COND_V(!body, false);

return body->get_omit_forces_integration();

}

void BulletPhysicsServer::body_set_force_integration_callback(RID p_body, Object *p_receiver, const StringName &p_method, const Variant &p_udata) {

ERR_FAIL_COND(!body);

}

void BulletPhysicsServer::body_set_ray_pickable(RID p_body, bool p_enable) {

ERR_FAIL_COND(!body);

body->set_ray_pickable(p_enable);

}

bool BulletPhysicsServer::body_is_ray_pickable(RID p_body) const {

ERR_FAIL_COND_V(!body, false);

return body->is_ray_pickable();

}

PhysicsDirectBodyState *BulletPhysicsServer::body_get_direct_state(RID p_body) {

ERR_FAIL_COND_V(!body, NULL);

return BulletPhysicsDirectBodyState::get_singleton(body);

}

bool BulletPhysicsServer::body_test_motion(RID p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, MotionResult *r_result, bool p_exclude_raycast_shapes) {

ERR_FAIL_COND_V(!body, false);

ERR_FAIL_COND_V(!body->get_space(), false);

}

int BulletPhysicsServer::body_test_ray_separation(RID p_body, const Transform &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, SeparationResult *r_results, int p_result_max, float p_margin) {

ERR_FAIL_COND_V(!body, 0);

ERR_FAIL_COND_V(!body->get_space(), 0);

}

void BulletPhysicsServer::soft_body_update_visual_server(RID p_body, class SoftBodyVisualServerHandler *p_visual_server_handler) {

ERR_FAIL_COND(!body);

body->update_visual_server(p_visual_server_handler);

}

void BulletPhysicsServer::soft_body_set_space(RID p_body, RID p_space) {

ERR_FAIL_COND(!body);

SpaceBullet *space = NULL;

if (p_space.is_valid()) {

ERR_FAIL_COND(!space);

}

}

RID BulletPhysicsServer::soft_body_get_space(RID p_body) const {

ERR_FAIL_COND_V(!body, RID());

SpaceBullet *space = body->get_space();

}

void BulletPhysicsServer::soft_body_set_mesh(RID p_body, const REF &p_mesh) {

ERR_FAIL_COND(!body);

body->set_soft_mesh(p_mesh);

}

void BulletPhysicsServer::soft_body_set_collision_layer(RID p_body, uint32_t p_layer) {

ERR_FAIL_COND(!body);

body->set_collision_layer(p_layer);

}

uint32_t BulletPhysicsServer::soft_body_get_collision_layer(RID p_body) const {

ERR_FAIL_COND_V(!body, 0);

return body->get_collision_layer();

}

void BulletPhysicsServer::soft_body_set_collision_mask(RID p_body, uint32_t p_mask) {

ERR_FAIL_COND(!body);

body->set_collision_mask(p_mask);

}

uint32_t BulletPhysicsServer::soft_body_get_collision_mask(RID p_body) const {

ERR_FAIL_COND_V(!body, 0);

return body->get_collision_mask();

}

void BulletPhysicsServer::soft_body_add_collision_exception(RID p_body, RID p_body_b) {

ERR_FAIL_COND(!body);

if (!other_body) {

}

ERR_FAIL_COND(!other_body);

}

void BulletPhysicsServer::soft_body_remove_collision_exception(RID p_body, RID p_body_b) {

ERR_FAIL_COND(!body);

if (!other_body) {

}

ERR_FAIL_COND(!other_body);

}

void BulletPhysicsServer::soft_body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {

ERR_FAIL_COND(!body);

for (int i = 0; i < body->get_exceptions().size(); i++) {

p_exceptions->push_back(body->get_exceptions()[i]);

}

void BulletPhysicsServer::soft_body_set_transform(RID p_body, const Transform &p_transform) {

ERR_FAIL_COND(!body);

body->set_soft_transform(p_transform);

}

Vector3 BulletPhysicsServer::soft_body_get_vertex_position(RID p_body, int vertex_index) const {

Vector3 pos;

ERR_FAIL_COND_V(!body, pos);

}

void BulletPhysicsServer::soft_body_set_ray_pickable(RID p_body, bool p_enable) {

ERR_FAIL_COND(!body);

body->set_ray_pickable(p_enable);

}

bool BulletPhysicsServer::soft_body_is_ray_pickable(RID p_body) const {

ERR_FAIL_COND_V(!body, false);

return body->is_ray_pickable();

}

void BulletPhysicsServer::soft_body_set_simulation_precision(RID p_body, int p_simulation_precision) {

ERR_FAIL_COND(!body);

body->set_simulation_precision(p_simulation_precision);

}

int BulletPhysicsServer::soft_body_get_simulation_precision(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_simulation_precision();

}

void BulletPhysicsServer::soft_body_set_total_mass(RID p_body, real_t p_total_mass) {

ERR_FAIL_COND(!body);

body->set_total_mass(p_total_mass);

}

real_t BulletPhysicsServer::soft_body_get_total_mass(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_total_mass();

}

void BulletPhysicsServer::soft_body_set_linear_stiffness(RID p_body, real_t p_stiffness) {

ERR_FAIL_COND(!body);

body->set_linear_stiffness(p_stiffness);

}

real_t BulletPhysicsServer::soft_body_get_linear_stiffness(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_linear_stiffness();

}

void BulletPhysicsServer::soft_body_set_areaAngular_stiffness(RID p_body, real_t p_stiffness) {

ERR_FAIL_COND(!body);

body->set_areaAngular_stiffness(p_stiffness);

}

real_t BulletPhysicsServer::soft_body_get_areaAngular_stiffness(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_areaAngular_stiffness();

}

void BulletPhysicsServer::soft_body_set_volume_stiffness(RID p_body, real_t p_stiffness) {

ERR_FAIL_COND(!body);

body->set_volume_stiffness(p_stiffness);

}

real_t BulletPhysicsServer::soft_body_get_volume_stiffness(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_volume_stiffness();

}

void BulletPhysicsServer::soft_body_set_pressure_coefficient(RID p_body, real_t p_pressure_coefficient) {

ERR_FAIL_COND(!body);

body->set_pressure_coefficient(p_pressure_coefficient);

}

real_t BulletPhysicsServer::soft_body_get_pressure_coefficient(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_pressure_coefficient();

}

void BulletPhysicsServer::soft_body_set_pose_matching_coefficient(RID p_body, real_t p_pose_matching_coefficient) {

ERR_FAIL_COND(!body);

return body->set_pose_matching_coefficient(p_pose_matching_coefficient);

}

real_t BulletPhysicsServer::soft_body_get_pose_matching_coefficient(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_pose_matching_coefficient();

}

void BulletPhysicsServer::soft_body_set_damping_coefficient(RID p_body, real_t p_damping_coefficient) {

ERR_FAIL_COND(!body);

body->set_damping_coefficient(p_damping_coefficient);

}

real_t BulletPhysicsServer::soft_body_get_damping_coefficient(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_damping_coefficient();

}

void BulletPhysicsServer::soft_body_set_drag_coefficient(RID p_body, real_t p_drag_coefficient) {

ERR_FAIL_COND(!body);

body->set_drag_coefficient(p_drag_coefficient);

}

real_t BulletPhysicsServer::soft_body_get_drag_coefficient(RID p_body) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_drag_coefficient();

}

void BulletPhysicsServer::soft_body_move_point(RID p_body, int p_point_index, const Vector3 &p_global_position) {

ERR_FAIL_COND(!body);

body->set_node_position(p_point_index, p_global_position);

}

Vector3 BulletPhysicsServer::soft_body_get_point_global_position(RID p_body, int p_point_index) {

ERR_FAIL_COND_V(!body, Vector3(0., 0., 0.));

Vector3 pos;

body->get_node_position(p_point_index, pos);

}

Vector3 BulletPhysicsServer::soft_body_get_point_offset(RID p_body, int p_point_index) const {

ERR_FAIL_COND_V(!body, Vector3());

Vector3 res;

body->get_node_offset(p_point_index, res);

}

void BulletPhysicsServer::soft_body_remove_all_pinned_points(RID p_body) {

ERR_FAIL_COND(!body);

body->reset_all_node_mass();

}

void BulletPhysicsServer::soft_body_pin_point(RID p_body, int p_point_index, bool p_pin) {

ERR_FAIL_COND(!body);

body->set_node_mass(p_point_index, p_pin ? 0 : 1);

}

bool BulletPhysicsServer::soft_body_is_point_pinned(RID p_body, int p_point_index) {

ERR_FAIL_COND_V(!body, 0.f);

return body->get_node_mass(p_point_index);

}

PhysicsServer::JointType BulletPhysicsServer::joint_get_type(RID p_joint) const {

ERR_FAIL_COND_V(!joint, JOINT_PIN);

return joint->get_type();

}

}

void BulletPhysicsServer::joint_disable_collisions_between_bodies(RID p_joint, const bool p_disable) {

ERR_FAIL_COND(!joint);

joint->disable_collisions_between_bodies(p_disable);

}

bool BulletPhysicsServer::joint_is_disabled_collisions_between_bodies(RID p_joint) const {

ERR_FAIL_COND_V(!joint, false);

return joint->is_disabled_collisions_between_bodies();

}

RID BulletPhysicsServer::joint_create_pin(RID p_body_A, const Vector3 &p_local_A, RID p_body_B, const Vector3 &p_local_B) {

ERR_FAIL_COND_V(!body_A, RID());

JointAssertSpace(body_A, "A", RID());

RigidBodyBullet *body_B = NULL;

if (p_body_B.is_valid()) {

JointAssertSpace(body_B, "B", RID());

JointAssertSameSpace(body_A, body_B, RID());

}

}

void BulletPhysicsServer::pin_joint_set_param(RID p_joint, PinJointParam p_param, float p_value) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_PIN);

PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);

}

float BulletPhysicsServer::pin_joint_get_param(RID p_joint, PinJointParam p_param) const {

ERR_FAIL_COND_V(!joint, 0);

ERR_FAIL_COND_V(joint->get_type() != JOINT_PIN, 0);

PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);

}

void BulletPhysicsServer::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_PIN);

PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);

}

Vector3 BulletPhysicsServer::pin_joint_get_local_a(RID p_joint) const {

ERR_FAIL_COND_V(!joint, Vector3());

ERR_FAIL_COND_V(joint->get_type() != JOINT_PIN, Vector3());

PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);

}

void BulletPhysicsServer::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_PIN);

PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);

}

Vector3 BulletPhysicsServer::pin_joint_get_local_b(RID p_joint) const {

ERR_FAIL_COND_V(!joint, Vector3());

ERR_FAIL_COND_V(joint->get_type() != JOINT_PIN, Vector3());

PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);

}

RID BulletPhysicsServer::joint_create_hinge(RID p_body_A, const Transform &p_hinge_A, RID p_body_B, const Transform &p_hinge_B) {

ERR_FAIL_COND_V(!body_A, RID());

JointAssertSpace(body_A, "A", RID());

RigidBodyBullet *body_B = NULL;

if (p_body_B.is_valid()) {

JointAssertSpace(body_B, "B", RID());

JointAssertSameSpace(body_A, body_B, RID());

}

}

RID BulletPhysicsServer::joint_create_hinge_simple(RID p_body_A, const Vector3 &p_pivot_A, const Vector3 &p_axis_A, RID p_body_B, const Vector3 &p_pivot_B, const Vector3 &p_axis_B) {

ERR_FAIL_COND_V(!body_A, RID());

JointAssertSpace(body_A, "A", RID());

RigidBodyBullet *body_B = NULL;

if (p_body_B.is_valid()) {

JointAssertSpace(body_B, "B", RID());

JointAssertSameSpace(body_A, body_B, RID());

}

}

void BulletPhysicsServer::hinge_joint_set_param(RID p_joint, HingeJointParam p_param, float p_value) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_HINGE);

HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);

}

float BulletPhysicsServer::hinge_joint_get_param(RID p_joint, HingeJointParam p_param) const {

ERR_FAIL_COND_V(!joint, 0);

ERR_FAIL_COND_V(joint->get_type() != JOINT_HINGE, 0);

HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);

}

void BulletPhysicsServer::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag, bool p_value) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_HINGE);

HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);

}

bool BulletPhysicsServer::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag) const {

ERR_FAIL_COND_V(!joint, false);

ERR_FAIL_COND_V(joint->get_type() != JOINT_HINGE, false);

HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);

}

RID BulletPhysicsServer::joint_create_slider(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {

ERR_FAIL_COND_V(!body_A, RID());

JointAssertSpace(body_A, "A", RID());

RigidBodyBullet *body_B = NULL;

if (p_body_B.is_valid()) {

JointAssertSpace(body_B, "B", RID());

JointAssertSameSpace(body_A, body_B, RID());

}

}

void BulletPhysicsServer::slider_joint_set_param(RID p_joint, SliderJointParam p_param, float p_value) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_SLIDER);

SliderJointBullet *slider_joint = static_cast<SliderJointBullet *>(joint);

}

float BulletPhysicsServer::slider_joint_get_param(RID p_joint, SliderJointParam p_param) const {

ERR_FAIL_COND_V(!joint, 0);

ERR_FAIL_COND_V(joint->get_type() != JOINT_SLIDER, 0);

SliderJointBullet *slider_joint = static_cast<SliderJointBullet *>(joint);

}

RID BulletPhysicsServer::joint_create_cone_twist(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {

ERR_FAIL_COND_V(!body_A, RID());

JointAssertSpace(body_A, "A", RID());

RigidBodyBullet *body_B = NULL;

if (p_body_B.is_valid()) {

JointAssertSpace(body_B, "B", RID());

JointAssertSameSpace(body_A, body_B, RID());

}

}

void BulletPhysicsServer::cone_twist_joint_set_param(RID p_joint, ConeTwistJointParam p_param, float p_value) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_CONE_TWIST);

ConeTwistJointBullet *coneTwist_joint = static_cast<ConeTwistJointBullet *>(joint);

}

float BulletPhysicsServer::cone_twist_joint_get_param(RID p_joint, ConeTwistJointParam p_param) const {

ERR_FAIL_COND_V(!joint, 0.);

ERR_FAIL_COND_V(joint->get_type() != JOINT_CONE_TWIST, 0.);

ConeTwistJointBullet *coneTwist_joint = static_cast<ConeTwistJointBullet *>(joint);

}

RID BulletPhysicsServer::joint_create_generic_6dof(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {

ERR_FAIL_COND_V(!body_A, RID());

JointAssertSpace(body_A, "A", RID());

RigidBodyBullet *body_B = NULL;

if (p_body_B.is_valid()) {

JointAssertSpace(body_B, "B", RID());

JointAssertSameSpace(body_A, body_B, RID());

}

}

void BulletPhysicsServer::generic_6dof_joint_set_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param, float p_value) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_6DOF);

Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);

}

float BulletPhysicsServer::generic_6dof_joint_get_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param) {

ERR_FAIL_COND_V(!joint, 0);

ERR_FAIL_COND_V(joint->get_type() != JOINT_6DOF, 0);

Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);

}

void BulletPhysicsServer::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag, bool p_enable) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_6DOF);

Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);

}

bool BulletPhysicsServer::generic_6dof_joint_get_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag) {

ERR_FAIL_COND_V(!joint, false);

ERR_FAIL_COND_V(joint->get_type() != JOINT_6DOF, false);

Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);

}

void BulletPhysicsServer::generic_6dof_joint_set_precision(RID p_joint, int p_precision) {

ERR_FAIL_COND(!joint);

ERR_FAIL_COND(joint->get_type() != JOINT_6DOF);

Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);

}

int BulletPhysicsServer::generic_6dof_joint_get_precision(RID p_joint) {

ERR_FAIL_COND_V(!joint, 0);

ERR_FAIL_COND_V(joint->get_type() != JOINT_6DOF, 0);

Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);

void BulletPhysicsServer::free(RID p_rid) {

if (shape_owner.owns(p_rid)) {

// Notify the shape is configured

for (Map<ShapeOwnerBullet *, int>::Element *element = shape->get_owners().front(); element; element = element->next()) {

bulletdelete(shape);

} else if (rigid_body_owner.owns(p_rid)) {

body->set_space(NULL);

} else if (soft_body_owner.owns(p_rid)) {

body->set_space(NULL);

} else if (area_owner.owns(p_rid)) {

area->set_space(NULL);

} else if (joint_owner.owns(p_rid)) {

joint->destroy_internal_constraint();

joint_owner.free(p_rid);

bulletdelete(joint);

} else if (space_owner.owns(p_rid)) {

space->remove_all_collision_objects();

#include "area_bullet.h"

#include "core/rid.h"

#include "joint_bullet.h"

#include "rigid_body_bullet.h"

#include "servers/physics_server.h"

#include "shape_bullet.h"

#include "soft_body_bullet.h"

#include "space_bullet.h"

/**

@author AndreaCatania

*/

char active_spaces_count;

Vector<SpaceBullet *> active_spaces;

protected:

static void _bind_methods();

BulletPhysicsServer();

~BulletPhysicsServer();

return &space_owner;

}

return &shape_owner;

}

return &area_owner;

}

return &rigid_body_owner;

}

return &soft_body_owner;

}

return &joint_owner;

}

virtual void body_clear_shapes(RID p_body);

// Used for Rigid and Soft Bodies

virtual void body_set_enable_continuous_collision_detection(RID p_body, bool p_enable);

virtual bool body_is_continuous_collision_detection_enabled(RID p_body) const;

CollisionObjectBullet::CollisionObjectBullet(Type p_type) :

RIDBullet(),

type(p_type),

collisionLayer(0),

collisionMask(0),

collisionsEnabled(true),

case PhysicsServer::CONE_TWIST_JOINT_RELAXATION:

coneConstraint->setLimit(coneConstraint->getSwingSpan1(), coneConstraint->getSwingSpan2(), coneConstraint->getTwistSpan(), coneConstraint->getLimitSoftness(), coneConstraint->getBiasFactor(), p_value);

break;

break;

}

}

return coneConstraint->getLimitSoftness();

case PhysicsServer::CONE_TWIST_JOINT_RELAXATION:

return coneConstraint->getRelaxationFactor();

return 0;

}

}

case PhysicsServer::G6DOF_JOINT_ANGULAR_SPRING_EQUILIBRIUM_POINT:

sixDOFConstraint->getRotationalLimitMotor(p_axis)->m_equilibriumPoint = p_value;

break;

default:

WARN_DEPRECATED_MSG("The parameter " + itos(p_param) + " is deprecated.");

break;

return sixDOFConstraint->getRotationalLimitMotor(p_axis)->m_springDamping;

case PhysicsServer::G6DOF_JOINT_ANGULAR_SPRING_EQUILIBRIUM_POINT:

return sixDOFConstraint->getRotationalLimitMotor(p_axis)->m_equilibriumPoint;

default:

WARN_DEPRECATED_MSG("The parameter " + itos(p_param) + " is deprecated.");

return 0;

sixDOFConstraint->setLimit(p_axis + 3, 0, -1); // Free

}

break;

case PhysicsServer::G6DOF_JOINT_FLAG_ENABLE_MOTOR:

sixDOFConstraint->getRotationalLimitMotor(p_axis)->m_enableMotor = flags[p_axis][p_flag];

break;

case PhysicsServer::G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR:

sixDOFConstraint->getTranslationalLimitMotor()->m_enableMotor[p_axis] = flags[p_axis][p_flag];

break;

break;

}

}

result.shape = convexResult.m_localShapeInfo->m_triangleIndex; // "m_triangleIndex" Is a odd name but contains the compound shape ID

result.rid = gObj->get_self();

result.collider_id = gObj->get_instance_id();

++count;

return 1; // not used by bullet

}

result.collider_id = colObj->get_instance_id();

result.rid = colObj->get_self();

++m_count;

}

void HingeJointBullet::set_param(PhysicsServer::HingeJointParam p_param, real_t p_value) {

switch (p_param) {

case PhysicsServer::HINGE_JOINT_LIMIT_UPPER:

hingeConstraint->setLimit(hingeConstraint->getLowerLimit(), p_value, hingeConstraint->getLimitSoftness(), hingeConstraint->getLimitBiasFactor(), hingeConstraint->getLimitRelaxationFactor());

break;

case PhysicsServer::HINGE_JOINT_MOTOR_MAX_IMPULSE:

hingeConstraint->setMaxMotorImpulse(p_value);

break;

break;

}

}

real_t HingeJointBullet::get_param(PhysicsServer::HingeJointParam p_param) const {

switch (p_param) {

case PhysicsServer::HINGE_JOINT_BIAS:

return 0;

case PhysicsServer::HINGE_JOINT_LIMIT_UPPER:

return hingeConstraint->getUpperLimit();

case PhysicsServer::HINGE_JOINT_LIMIT_LOWER:

return hingeConstraint->getMotorTargetVelocity();

case PhysicsServer::HINGE_JOINT_MOTOR_MAX_IMPULSE:

return hingeConstraint->getMaxMotorImpulse();

return 0;

}

}

void HingeJointBullet::set_flag(PhysicsServer::HingeJointFlag p_flag, bool p_value) {

return p2pConstraint->m_setting.m_damping;

case PhysicsServer::PIN_JOINT_IMPULSE_CLAMP:

return p2pConstraint->m_setting.m_impulseClamp;

}

}

void PinJointBullet::setPivotInA(const Vector3 &p_pos) {

class BulletPhysicsServer;

RID self;

BulletPhysicsServer *physicsServer;

}

void RigidBodyBullet::main_shape_changed() {

btBody->setCollisionShape(get_main_shape());

set_continuous_collision_detection(is_continuous_collision_detection_enabled()); // Reset

}

Object *obj = ObjectDB::get_instance(force_integration_callback->id);

if (!obj) {

// Remove integration callback

} else {

const Variant *vp[2] = { &variantBodyDirect, &force_integration_callback->udata };

force_integration_callback = NULL;

}

force_integration_callback = memnew(ForceIntegrationCallback);

force_integration_callback->id = p_id;

force_integration_callback->method = p_method;

scratch_space_override_modificator();

break;

default:

}

}

case PhysicsServer::BODY_PARAM_GRAVITY_SCALE:

return gravity_scale;

default:

return 0;

}

}

case PhysicsServer::BODY_STATE_CAN_SLEEP:

return can_sleep;

default:

return Variant();

}

}

void SoftBodyBullet::set_node_position(int p_node_index, const btVector3 &p_global_position) {

if (bt_soft_body) {

bt_soft_body->m_nodes[p_node_index].m_x = p_global_position;

}

}

r_result.shape = btResult.m_shapeId;

r_result.rid = gObj->get_self();

r_result.collider_id = gObj->get_instance_id();

} else {

}

return true;

} else {

if (p_result_max <= 0)

return 0;

btCollisionShape *btShape = shape->create_bt_shape(p_xform.basis.get_scale_abs(), p_margin);

if (!btShape->isConvex()) {

bulletdelete(btShape);

return 0;

}

btConvexShape *btConvex = static_cast<btConvexShape *>(btShape);

}

bool BulletPhysicsDirectSpaceState::cast_motion(const RID &p_shape, const Transform &p_xform, const Vector3 &p_motion, float p_margin, float &r_closest_safe, float &r_closest_unsafe, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas, ShapeRestInfo *r_info) {

btCollisionShape *btShape = shape->create_bt_shape(p_xform.basis.get_scale(), p_margin);

if (!btShape->isConvex()) {

bulletdelete(btShape);

return false;

}

btConvexShape *bt_convex_shape = static_cast<btConvexShape *>(btShape);

if (p_result_max <= 0)

return 0;

btCollisionShape *btShape = shape->create_bt_shape(p_shape_xform.basis.get_scale_abs(), p_margin);

if (!btShape->isConvex()) {

bulletdelete(btShape);

return 0;

}

btConvexShape *btConvex = static_cast<btConvexShape *>(btShape);

bool BulletPhysicsDirectSpaceState::rest_info(RID p_shape, const Transform &p_shape_xform, float p_margin, ShapeRestInfo *r_info, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {

btCollisionShape *btShape = shape->create_bt_shape(p_shape_xform.basis.get_scale_abs(), p_margin);

if (!btShape->isConvex()) {

bulletdelete(btShape);

return 0;

}

btConvexShape *btConvex = static_cast<btConvexShape *>(btShape);

case PhysicsServer::AREA_PARAM_GRAVITY_POINT_ATTENUATION:

break;

default:

break;

}

}

case PhysicsServer::AREA_PARAM_GRAVITY_POINT_ATTENUATION:

return 0;

default:

return Variant();

}

}

case PhysicsServer::SPACE_PARAM_BODY_ANGULAR_VELOCITY_DAMP_RATIO:

case PhysicsServer::SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS:

default:

break;

}

}

case PhysicsServer::SPACE_PARAM_BODY_ANGULAR_VELOCITY_DAMP_RATIO:

case PhysicsServer::SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS:

default:

return 0.f;

}

}

static ImmediateGeometry *motionVec(NULL);

static ImmediateGeometry *normalLine(NULL);

#endif

bool SpaceBullet::test_body_motion(RigidBodyBullet *p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, PhysicsServer::MotionResult *r_result, bool p_exclude_raycast_shapes) {

motionVec->set_as_toplevel(true);

normalLine->set_as_toplevel(true);

red_mat->set_line_width(20.0);

red_mat->set_albedo(Color(1, 0, 0, 1));

motionVec->set_material_override(red_mat);

blue_mat->set_line_width(20.0);

blue_mat->set_albedo(Color(0, 0, 1, 1));

normalLine->set_material_override(blue_mat);

}

ClassDB::bind_method(D_METHOD("get_material"), &CSGMesh::get_material);

ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh", PROPERTY_HINT_RESOURCE_TYPE, "Mesh"), "set_mesh", "get_mesh");

}

void CSGMesh::set_mesh(const Ref<Mesh> &p_mesh) {

ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");

ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");

ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_faces");

}

void CSGSphere::set_radius(const float p_radius) {

ADD_PROPERTY(PropertyInfo(Variant::REAL, "width", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_width", "get_width");

ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_height", "get_height");

ADD_PROPERTY(PropertyInfo(Variant::REAL, "depth", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_depth", "get_depth");

}

void CSGBox::set_width(const float p_width) {

ADD_PROPERTY(PropertyInfo(Variant::INT, "sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_sides", "get_sides");

ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cone"), "set_cone", "is_cone");

ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_faces");

}

void CSGCylinder::set_radius(const float p_radius) {

ADD_PROPERTY(PropertyInfo(Variant::INT, "sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_sides", "get_sides");

ADD_PROPERTY(PropertyInfo(Variant::INT, "ring_sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_ring_sides", "get_ring_sides");

ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_faces");

}

void CSGTorus::set_inner_radius(const float p_inner_radius) {

ADD_PROPERTY(PropertyInfo(Variant::BOOL, "path_continuous_u"), "set_path_continuous_u", "is_path_continuous_u");

ADD_PROPERTY(PropertyInfo(Variant::BOOL, "path_joined"), "set_path_joined", "is_path_joined");

ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_faces");

BIND_ENUM_CONSTANT(MODE_DEPTH);

BIND_ENUM_CONSTANT(MODE_SPIN);

}

}

if (p_image->get_format() >= Image::FORMAT_BPTC_RGBA)

return; //do not compress, already compressed

flags |= cvtt::Flags::BC7_RespectPunchThrough;

flags |= cvtt::Flags::Uniform;

}

#include "core/image.h"

void image_decompress_cvtt(Image *p_image);

#endif // IMAGE_COMPRESS_CVTT_H

bool ResourceFormatDDS::handles_type(const String &p_type) const {

}

String ResourceFormatDDS::get_resource_type(const String &p_path) const {

#include "core/os/os.h"

#include "core/print_string.h"

switch (format) {

return Image::FORMAT_ETC2_R11;

return Image::FORMAT_ETC2_RG11;

return Image::FORMAT_ETC2_RGB8;

return Image::FORMAT_ETC2_RGBA8;

// TODO: would be nice if we could use FORMAT_ETC2_RGB8A1 for FORMAT_RGBA5551

}

}

Image::Format img_format = p_img->get_format();

if (img_format >= Image::FORMAT_DXT1) {

return; //do not compress, already compressed

return;

}

if (force_etc1_format) {

// If VRAM compression is using ETC, but image has alpha, convert to RGBA4444 or LA8

// This saves space while maintaining the alpha channel

p_img->convert(Image::FORMAT_RGBA4444);

return;

p_img->convert(Image::FORMAT_LA8);

return;

}

}

uint32_t imgw = p_img->get_width(), imgh = p_img->get_height();

Ref<Image> img = p_img->duplicate();

}

static void _compress_etc1(Image *p_img, float p_lossy_quality) {

}

}

void _register_etc_compress_func() {

bool ResourceFormatPKM::handles_type(const String &p_type) const {

}

String ResourceFormatPKM::get_resource_type(const String &p_path) const {

# Godot source files

env_freetype.add_source_files(env.modules_sources, "*.cpp")

void GDAPI godot_arvr_blit(godot_int p_eye, godot_rid *p_render_target, godot_rect2 *p_rect) {

// blits out our texture as is, handy for preview display of one of the eyes that is already rendered with lens distortion on an external HMD

ARVRInterface::Eyes eye = (ARVRInterface::Eyes)p_eye;

RID *render_target = (RID *)p_render_target;

Rect2 screen_rect = *(Rect2 *)p_rect;

if (eye == ARVRInterface::EYE_LEFT) {

screen_rect.size.x /= 2.0;

screen_rect.position.x += screen_rect.size.x;

}

VSG::rasterizer->blit_render_target_to_screen(*render_target, screen_rect, 0);

}

godot_int GDAPI godot_arvr_get_texid(godot_rid *p_render_target) {

// In order to send off our textures to display on our hardware we need the opengl texture ID instead of the render target RID

// This is a handy function to expose that.

RID *render_target = (RID *)p_render_target;

RID eye_texture = VSG::storage->render_target_get_texture(*render_target);

return texid;

}

if (err || !library_init) {

OS::get_singleton()->close_dynamic_library(native_handle);

native_handle = NULL;

return false;

}

return self->to_argb32();

}

godot_color GDAPI godot_color_inverted(const godot_color *p_self) {

godot_color dest;

const Color *self = (const Color *)p_self;

_err_print_error("gdnative_init", library->get_current_library_path().utf8().ptr(), 0, message.utf8().ptr());

}

godot_object GDAPI *godot_instance_from_id(godot_int p_instance_id) {

}

void *godot_get_class_tag(const godot_string_name *p_class) {

keys.write[i] = (*keys_proxy)[i];

}

}

godot_int GDAPI godot_string_findn(const godot_string *p_self, godot_string p_what) {

ref = REF(reference);

}

if (!ref.is_null()) {

} else {

#if defined(DEBUG_METHODS_ENABLED)

if (reference) {

]

},

{

"name": "godot_quat_new_with_basis",

"return_type": "void",

"arguments": [

]

},

{

"name": "godot_color_inverted",

"return_type": "godot_color",

"arguments": [

"name": "godot_arvr_blit",

"return_type": "void",

"arguments": [

["godot_rid *", "p_render_target"],

["godot_rect2 *", "p_screen_rect"]

]

godot_int GDAPI godot_color_to_argb32(const godot_color *p_self);

godot_color GDAPI godot_color_inverted(const godot_color *p_self);

godot_color GDAPI godot_color_contrasted(const godot_color *p_self);

/////// int

/////// real

void GDAPI godot_print_warning(const char *p_description, const char *p_function, const char *p_file, int p_line);

void GDAPI godot_print(const godot_string *p_message);

//tags used for safe dynamic casting

void GDAPI *godot_get_class_tag(const godot_string_name *p_class);

GODOT_METHOD_RPC_MODE_REMOTE,

GODOT_METHOD_RPC_MODE_MASTER,

GODOT_METHOD_RPC_MODE_PUPPET,

GODOT_METHOD_RPC_MODE_REMOTESYNC,

GODOT_METHOD_RPC_MODE_MASTERSYNC,

GODOT_METHOD_RPC_MODE_PUPPETSYNC,

} godot_method_rpc_mode;

// --- Instance ---

typedef struct {

godot_pluginscript_instance_data *(*init)(godot_pluginscript_script_data *p_data, godot_object *p_owner);

void (*finish)(godot_pluginscript_instance_data *p_data);

godot_variant (*call_method)(godot_pluginscript_instance_data *p_data,

const godot_string_name *p_method, const godot_variant **p_args,

godot_error (*complete_code)(godot_pluginscript_language_data *p_data, const godot_string *p_code, const godot_string *p_path, godot_object *p_owner, godot_array *r_options, godot_bool *r_force, godot_string *r_call_hint);

void (*auto_indent_code)(godot_pluginscript_language_data *p_data, godot_string *p_code, int p_from_line, int p_to_line);

godot_string (*debug_get_error)(godot_pluginscript_language_data *p_data);

int (*debug_get_stack_level_count)(godot_pluginscript_language_data *p_data);

int (*debug_get_stack_level_line)(godot_pluginscript_language_data *p_data, int p_level);

#include "core/project_settings.h"

#include "core/variant.h"

#include "gdnative/gdnative.h"

#include "nativescript.h"

if (classes->has(p_base)) {

desc.base_data = &(*classes)[p_base];

desc.base_native_type = desc.base_data->base_native_type;

} else {

desc.base_data = NULL;

desc.base_native_type = p_base;

desc.destroy_func = p_destroy_func;

desc.is_tool = true;

desc.base = p_base;

if (classes->has(p_base)) {

desc.base_data = &(*classes)[p_base];

desc.base_native_type = desc.base_data->base_native_type;

} else {

desc.base_data = NULL;

desc.base_native_type = p_base;

NativeScriptDesc::Method method;

method.method = p_method;

method.rpc_mode = p_attr.rpc_type;

method.info = MethodInfo(p_function_name);

E->get().methods.insert(p_function_name, method);

property.default_value = *(Variant *)&p_attr->default_value;

property.getter = p_get_func;

property.rset_mode = p_attr->rset_type;

property.setter = p_set_func;

property.info = PropertyInfo((Variant::Type)p_attr->type,

p_path,

#include "nativescript.h"

#include "gdnative/gdnative.h"

#include "core/core_string_names.h"

}

}

String NativeScript::get_class_documentation() const {

NativeScriptDesc *script_data = get_script_desc();

#ifdef DEBUG_ENABLED

if (p_notification == MainLoop::NOTIFICATION_CRASH) {

if (current_method_call != StringName("")) {

current_method_call = "";

}

}

return script;

}

}

}

ScriptLanguage *NativeScriptInstance::get_language() {

godot_instance_method method;

MethodInfo info;

int rpc_mode;

String documentation;

};

struct Property {

PropertyInfo info;

Variant default_value;

int rset_mode;

String documentation;

};

String documentation;

};

Map<StringName, Method> methods;

OrderedHashMap<StringName, Property> properties;

Map<StringName, Signal> signals_; // QtCreator doesn't like the name signals

StringName base;

bool is_tool;

inline NativeScriptDesc() :

methods(),

properties(),

signals_(),

base(),

virtual void get_script_method_list(List<MethodInfo> *p_list) const;

virtual void get_script_property_list(List<PropertyInfo> *p_list) const;

String get_class_documentation() const;

String get_method_documentation(const StringName &p_method) const;

String get_signal_documentation(const StringName &p_signal_name) const;

virtual void notification(int p_notification);

String to_string(bool *r_valid);

virtual Ref<Script> get_script() const;

virtual MultiplayerAPI::RPCMode get_rpc_mode(const StringName &p_method) const;

virtual MultiplayerAPI::RPCMode get_rset_mode(const StringName &p_variable) const;

virtual ScriptLanguage *get_language();

virtual void call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount);

#include "pluginscript_script.h"

bool PluginScriptInstance::set(const StringName &p_name, const Variant &p_value) {

}

bool PluginScriptInstance::get(const StringName &p_name, Variant &r_ret) const {

}

Ref<Script> PluginScriptInstance::get_script() const {

_desc->notification(_data, p_notification);

}

MultiplayerAPI::RPCMode PluginScriptInstance::get_rpc_mode(const StringName &p_method) const {

return _script->get_rpc_mode(p_method);

}

MultiplayerAPI::RPCMode PluginScriptInstance::get_rset_mode(const StringName &p_variable) const {

return _script->get_rset_mode(p_variable);

}

void set_path(const String &p_path);

virtual MultiplayerAPI::RPCMode get_rpc_mode(const StringName &p_method) const;

virtual MultiplayerAPI::RPCMode get_rset_mode(const StringName &p_variable) const;

virtual void refcount_incremented();

}

void PluginScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {

}

/* LOADER FUNCTIONS */

#include "pluginscript_instance.h"

#include "pluginscript_script.h"

#ifdef DEBUG_ENABLED

#define __ASSERT_SCRIPT_REASON "Cannot retrieve PluginScript class for this script, is your code correct?"

#define ASSERT_SCRIPT_VALID() \

_member_lines[*key] = (*members)[*key];

}

Array *methods = (Array *)&manifest.methods;

for (int i = 0; i < methods->size(); ++i) {

Dictionary v = (*methods)[i];

MethodInfo mi = MethodInfo::from_dict(v);

_methods_info[mi.name] = mi;

// rpc_mode is passed as an optional field and is not part of MethodInfo

Variant var = v["rpc_mode"];

}

}

Array *signals = (Array *)&manifest.signals;

for (int i = 0; i < signals->size(); ++i) {

Variant v = (*signals)[i];

_properties_default_values[pi.name] = v["default_value"];

// rset_mode is passed as an optional field and is not part of PropertyInfo

Variant var = v["rset_mode"];

}

}

#ifdef TOOLS_ENABLED

/*for (Set<PlaceHolderScriptInstance*>::Element *E=placeholders.front();E;E=E->next()) {

return -1;

}

ASSERT_SCRIPT_VALID_V(MultiplayerAPI::RPC_MODE_DISABLED);

return MultiplayerAPI::RPC_MODE_DISABLED;

}

}

ASSERT_SCRIPT_VALID_V(MultiplayerAPI::RPC_MODE_DISABLED);

return MultiplayerAPI::RPC_MODE_DISABLED;

}

PluginScript::PluginScript() :

Map<StringName, PropertyInfo> _properties_info;

Map<StringName, MethodInfo> _signals_info;

Map<StringName, MethodInfo> _methods_info;

Set<Object *> _instances;

//exported members

virtual int get_member_line(const StringName &p_member) const;

PluginScript();

void init(PluginScriptLanguage *language);

proc_ptr);

if (err != OK) {

} else {

singleton_gdnatives.push_back(singleton);

((void (*)())proc_ptr)();

pcm_write_idx = -1;

samples_decoded = 0;

}

return file_opened;

Ref<Image> img = memnew(Image(texture_size.width, texture_size.height, 0, Image::FORMAT_RGBA8, *pba));

}

// ctor and dtor

paused = p_paused;

}

return texture;

}

//virtual int mix(int16_t* p_buffer,int p_frames)=0;

virtual void update(float p_delta);

virtual void set_mix_callback(AudioMixCallback p_callback, void *p_userdata);