CollisionObject2D::CollisionObject2D(RID p_rid, bool p_area) {
rid = p_rid;
area = p_area;
pickable = true;
set_notify_transform(true);
total_subshapes = 0;
if (p_area) {
Physics2DServer::get_singleton()->area_attach_object_instance_id(rid, get_instance_id());
} else {
Physics2DServer::get_singleton()->body_attach_object_instance_id(rid, get_instance_id());
}
}
/* Find trip point info of a thermal zone */
static int find_tzone_tp(char *tz_name, char *d_name, struct tz_info *tzi,
int tz_id)
{
int tp_id;
unsigned long temp_ulong;
if (strstr(d_name, "trip_point") &&
strstr(d_name, "temp")) {
/* check if trip point temp is non-zero
* ignore 0/invalid trip points
*/
sysfs_get_ulong(tz_name, d_name, &temp_ulong);
if (temp_ulong < MAX_TEMP_KC) {
tzi->nr_trip_pts++;
/* found a valid trip point */
tp_id = get_instance_id(d_name, 2, 0);
syslog(LOG_DEBUG, "tzone %s trip %d temp %lu tpnode %s",
tz_name, tp_id, temp_ulong, d_name);
if (tp_id < 0 || tp_id >= MAX_NR_TRIP) {
syslog(LOG_ERR, "Failed to find TP inst %s\n",
d_name);
return -1;
}
get_trip_point_data(tz_name, tz_id, tp_id);
tzi->tp[tp_id].temp = temp_ulong;
}
}
return 0;
}
CollisionObject::CollisionObject(RID p_rid, bool p_area) {
rid = p_rid;
area = p_area;
capture_input_on_drag = false;
ray_pickable = true;
set_notify_transform(true);
total_subshapes = 0;
if (p_area) {
PhysicsServer::get_singleton()->area_attach_object_instance_id(rid, get_instance_id());
} else {
PhysicsServer::get_singleton()->body_attach_object_instance_id(rid, get_instance_id());
}
//set_transform_notify(true);
}
static WCHAR *get_compatible_ids(DEVICE_OBJECT *device)
{
struct device_extension *ext = (struct device_extension *)device->DeviceExtension;
WCHAR *iid, *did, *dst, *ptr;
DWORD len;
if (!(iid = get_instance_id(device)))
return NULL;
if (!(did = get_device_id(device)))
{
HeapFree(GetProcessHeap(), 0, iid);
return NULL;
}
len = strlenW(iid) + strlenW(did) + strlenW(ext->busid) + 4;
if ((dst = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
{
ptr = dst;
strcpyW(ptr, iid);
ptr += strlenW(iid) + 1;
strcpyW(ptr, did);
ptr += strlenW(did) + 1;
strcpyW(ptr, ext->busid);
ptr += strlenW(ext->busid) + 1;
*ptr = 0;
}
HeapFree(GetProcessHeap(), 0, iid);
HeapFree(GetProcessHeap(), 0, did);
return dst;
}
/* check cooling devices for binding info. */
static int find_tzone_cdev(struct dirent *nl, char *tz_name,
struct tz_info *tzi, int tz_id, int cid)
{
unsigned long trip_instance = 0;
char cdev_name_linked[256];
char cdev_name[256];
char cdev_trip_name[256];
int cdev_id;
if (nl->d_type == DT_LNK) {
syslog(LOG_DEBUG, "TZ%d: cdev: %s cid %d\n", tz_id, nl->d_name,
cid);
tzi->nr_cdev++;
if (tzi->nr_cdev > ptdata.nr_cooling_dev) {
syslog(LOG_ERR, "Err: Too many cdev? %d\n",
tzi->nr_cdev);
return -EINVAL;
}
/* find the link to real cooling device record binding */
snprintf(cdev_name, 256, "%s/%s", tz_name, nl->d_name);
memset(cdev_name_linked, 0, sizeof(cdev_name_linked));
if (readlink(cdev_name, cdev_name_linked,
sizeof(cdev_name_linked) - 1) != -1) {
cdev_id = get_instance_id(cdev_name_linked, 1,
sizeof("device") - 1);
syslog(LOG_DEBUG, "cdev %s linked to %s : %d\n",
cdev_name, cdev_name_linked, cdev_id);
tzi->cdev_binding |= (1 << cdev_id);
/* find the trip point in which the cdev is binded to
* in this tzone
*/
snprintf(cdev_trip_name, 256, "%s%s", nl->d_name,
"_trip_point");
sysfs_get_ulong(tz_name, cdev_trip_name,
&trip_instance);
/* validate trip point range, e.g. trip could return -1
* when passive is enabled
*/
if (trip_instance > MAX_NR_TRIP)
trip_instance = 0;
tzi->trip_binding[cdev_id] |= 1 << trip_instance;
syslog(LOG_DEBUG, "cdev %s -> trip:%lu: 0x%lx %d\n",
cdev_name, trip_instance,
tzi->trip_binding[cdev_id],
cdev_id);
}
return 0;
}
return -ENODEV;
}
SoftBody::SoftBody() :
MeshInstance(),
physics_rid(PhysicsServer::get_singleton()->soft_body_create()),
mesh_owner(false),
collision_mask(1),
collision_layer(1),
simulation_started(false),
pinned_points_cache_dirty(true) {
PhysicsServer::get_singleton()->body_attach_object_instance_id(physics_rid, get_instance_id());
}
Variant Object::_call_deferred_bind(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
if (p_argcount < 1) {
r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument = 0;
return Variant();
}
if (p_args[0]->get_type() != Variant::STRING) {
r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 0;
r_error.expected = Variant::STRING;
return Variant();
}
r_error.error = Variant::CallError::CALL_OK;
StringName method = *p_args[0];
MessageQueue::get_singleton()->push_call(get_instance_id(), method, &p_args[1], p_argcount - 1);
return Variant();
}
int probe_thermal_sysfs(void)
{
DIR *dir;
struct dirent **namelist;
int n;
dir = opendir(THERMAL_SYSFS);
if (!dir) {
fprintf(stderr, "\nNo thermal sysfs, exit\n");
return -1;
}
n = scandir(THERMAL_SYSFS, &namelist, 0, alphasort);
if (n < 0)
syslog(LOG_ERR, "scandir failed in thermal sysfs");
else {
/* detect number of thermal zones and cooling devices */
while (n--) {
int inst;
if (strstr(namelist[n]->d_name, CDEV)) {
inst = get_instance_id(namelist[n]->d_name, 1,
sizeof("device") - 1);
/* keep track of the max cooling device since
* there may be gaps.
*/
if (inst > ptdata.max_cdev_instance)
ptdata.max_cdev_instance = inst;
syslog(LOG_DEBUG, "found cdev: %s %d %d\n",
namelist[n]->d_name,
ptdata.nr_cooling_dev,
ptdata.max_cdev_instance);
ptdata.nr_cooling_dev++;
} else if (strstr(namelist[n]->d_name, TZONE)) {
inst = get_instance_id(namelist[n]->d_name, 1,
sizeof("zone") - 1);
if (inst > ptdata.max_tz_instance)
ptdata.max_tz_instance = inst;
syslog(LOG_DEBUG, "found tzone: %s %d %d\n",
namelist[n]->d_name,
ptdata.nr_tz_sensor,
ptdata.max_tz_instance);
ptdata.nr_tz_sensor++;
}
free(namelist[n]);
}
free(namelist);
}
syslog(LOG_INFO, "found %d tzone(s), %d cdev(s), target zone %d\n",
ptdata.nr_tz_sensor, ptdata.nr_cooling_dev,
target_thermal_zone);
closedir(dir);
if (!ptdata.nr_tz_sensor) {
fprintf(stderr, "\nNo thermal zones found, exit\n\n");
return -1;
}
ptdata.tzi = calloc(ptdata.max_tz_instance+1, sizeof(struct tz_info));
if (!ptdata.tzi) {
fprintf(stderr, "Err: allocate tz_info\n");
return -1;
}
/* we still show thermal zone information if there is no cdev */
if (ptdata.nr_cooling_dev) {
ptdata.cdi = calloc(ptdata.max_cdev_instance + 1,
sizeof(struct cdev_info));
if (!ptdata.cdi) {
free(ptdata.tzi);
fprintf(stderr, "Err: allocate cdev_info\n");
return -1;
}
}
/* now probe tzones */
if (scan_tzones())
return -1;
if (scan_cdevs())
return -1;
return 0;
}
void GridMap::set_cell_item(int p_x, int p_y, int p_z, int p_item, int p_rot) {
ERR_FAIL_INDEX(ABS(p_x), 1 << 20);
ERR_FAIL_INDEX(ABS(p_y), 1 << 20);
ERR_FAIL_INDEX(ABS(p_z), 1 << 20);
IndexKey key;
key.x = p_x;
key.y = p_y;
key.z = p_z;
OctantKey ok;
ok.x = p_x / octant_size;
ok.y = p_y / octant_size;
ok.z = p_z / octant_size;
if (p_item < 0) {
//erase
if (cell_map.has(key)) {
OctantKey octantkey = ok;
ERR_FAIL_COND(!octant_map.has(octantkey));
Octant &g = *octant_map[octantkey];
g.cells.erase(key);
g.dirty = true;
cell_map.erase(key);
_queue_octants_dirty();
}
return;
}
OctantKey octantkey = ok;
if (!octant_map.has(octantkey)) {
//create octant because it does not exist
Octant *g = memnew(Octant);
g->dirty = true;
g->static_body = PhysicsServer::get_singleton()->body_create(PhysicsServer::BODY_MODE_STATIC);
PhysicsServer::get_singleton()->body_attach_object_instance_id(g->static_body, get_instance_id());
SceneTree *st = SceneTree::get_singleton();
if (st && st->is_debugging_collisions_hint()) {
g->collision_debug = VisualServer::get_singleton()->mesh_create();
g->collision_debug_instance = VisualServer::get_singleton()->instance_create();
VisualServer::get_singleton()->instance_set_base(g->collision_debug_instance, g->collision_debug);
}
octant_map[octantkey] = g;
if (is_inside_world()) {
_octant_enter_world(octantkey);
_octant_transform(octantkey);
}
}
Octant &g = *octant_map[octantkey];
g.cells.insert(key);
g.dirty = true;
_queue_octants_dirty();
Cell c;
c.item = p_item;
c.rot = p_rot;
cell_map[key] = c;
}
