bool LLNotificationsListener::Forwarder::matchType(const LLSD& filter, const std::string& type) const
{
// Decide whether this notification matches filter:
// undefined: forward all notifications
if (filter.isUndefined())
{
return true;
}
// array of string: forward any notification matching any named type
if (filter.isArray())
{
for (LLSD::array_const_iterator ti(filter.beginArray()), tend(filter.endArray());
ti != tend; ++ti)
{
if (ti->asString() == type)
{
return true;
}
}
// Didn't match any entry in the array
return false;
}
// string: forward only the specific named type
return (filter.asString() == type);
}
//
// PPTokenTBuf::underflow
//
void PPTokenTBuf::underflow()
{
if(tptr() != tend()) return;
switch((buf[0] = src.get()).tok)
{
case Core::TOK_Identi:
if(IsKeyWrd(buf[0].str))
buf[0].tok = Core::TOK_KeyWrd;
break;
case Core::TOK_Number:
if(IsNumInt(buf[0].str)) buf[0].tok = Core::TOK_NumInt;
else if(IsNumFix(buf[0].str)) buf[0].tok = Core::TOK_NumFix;
else if(IsNumFlt(buf[0].str)) buf[0].tok = Core::TOK_NumFlt;
else
{
std::cerr << "ERROR: " << buf[0].pos << ": not valid number: '"
<< buf[0].str << "'\n";
throw EXIT_FAILURE;
}
break;
default:
break;
}
sett(buf, buf, buf + 1);
}
unsigned long WINAPI threadrun(void * var)
{
unsigned i;
thrdmem_t *t = (thrdmem_t *)var;
int tnum = t->threadnum;
int k = tnum;
int k1;
int counterA = tnum;
Lock(k);
#ifdef _WIN32
Sleep(100);
#else
sleep(1);
#endif
tstart(&t->_tstart);
for(i = 0; i < maxcount; i++) {
k1 = k + 1;
if(k1 >= ncrits)
k1 = 0;
Lock(k1);
Unlock(k);
if(showme) {
if(showme > 1) {
printf("T%d\n",tnum); fflush(stdout);
}
else if (showme > 2) {
printf("T%d: i=%d %d\n", tnum,i,counterA); fflush(stdout);
}
}
counterA += nthreads;
k = k1;
t->tcounter++;
}
Unlock(k);
tend(&t->_tend);
if(showme > 0) {
// Don't let my printf's interfere with the timing of other threads.
SLEEP(2+(nthreads/40));
double tim = tval(&t->_tstart, &t->_tend);
printf("%lu %s/thread Context switches in %7.3f sec ",
maxcount, facility, tim);
printf("%7.3f usec/cswitch",
(tim*1e6)/(maxcount*nthreads));
printf("\n");
fflush(stdout);
}
#ifdef _WIN32
ExitThread(0);
#endif
return 0;
}
static LLSD getTabInfo(LLPanel* tab)
{
LLSD panels;
for (LLPanel::tree_iterator_t ti(tab->beginTreeDFS()), tend(tab->endTreeDFS());
ti != tend; ++ti)
{
// *ti is actually an LLView*, which had better not be NULL
LLView* view(*ti);
if (! view)
{
LL_ERRS("LLSideTrayListener") << "LLSideTrayTab '" << tab->getName()
<< "' has a NULL child LLView*" << LL_ENDL;
}
// The logic we use to decide what "panel" names to return is heavily
// based on LLSideTray::showPanel(): the function that actually
// implements the "SideTray.ShowPanel" operation. showPanel(), in
// turn, depends on LLSideTray::openChildPanel(): when
// openChildPanel() returns non-NULL, showPanel() stops searching
// attached and detached LLSideTrayTab tabs.
// For each LLSideTrayTab, openChildPanel() first calls
// findChildView(panel_name, true). In other words, panel_name need
// not be a direct LLSideTrayTab child, it's sought recursively.
// That's why we use (begin|end)TreeDFS() in this loop.
// But this tree_iterator_t loop will actually traverse every widget
// in every panel. Returning all those names will not help our caller:
// passing most such names to openChildPanel() would not do what we
// want. Even though the code suggests that passing ANY valid
// side-panel widget name to openChildPanel() will open the tab
// containing that widget, results could get confusing since followup
// (onOpen()) logic wouldn't be invoked, and showPanel() wouldn't stop
// searching because openChildPanel() would return NULL.
// We must filter these LLView items, using logic that (sigh!) mirrors
// openChildPanel()'s own.
// openChildPanel() returns a non-NULL LLPanel* when either:
// - the LLView is a direct child of an LLSideTrayPanelContainer
// - the LLView is itself an LLPanel.
// But as LLSideTrayPanelContainer can directly contain LLView items
// that are NOT themselves LLPanels (e.g. "sidebar_me" contains an
// LLButton called "Jump Right Arrow"), we'd better focus only on
// LLSideTrayPanelContainer children that are themselves LLPanel
// items. Which means that the second test completely subsumes the
// first.
LLPanel* panel(dynamic_cast<LLPanel*>(view));
if (panel)
{
// Maybe it's overkill to construct an LLSD::Map for each panel, but
// the possibility remains that we might want to deliver more info
// about each panel than just its name.
panels.append(LLSDMap("name", panel->getName()));
}
}
return LLSDMap("panels", panels);
}
int
main(int argc, const char *argv[])
{
args(argc, argv);
input();
tsetup();
tmain();
tend();
yank();
return 0;
}
bool PathFinding::generatePathSimple(VectorPath& path, const Vector& start, const Vector& end, unsigned int step /* = 0 */, unsigned int obs /* = 0 */)
{
if(obs == OT_EMPTY)
obs = OT_BLOCKING;
SearchGridRaw grid((ObsType)obs);
JPS::PathVector p;
TileVector tstart(start);
TileVector tend(end);
if(!JPS::findPath(p, grid, tstart.x, tstart.y, tend.x, tend.y, step))
return false;
generateVectorPath(p, path, 0, 0);
molestPath(path);
return true;
}
static int do_step_cloth(Object *ob, ClothModifierData *clmd, DerivedMesh *result, int framenr)
{
ClothVertex *verts = NULL;
Cloth *cloth;
ListBase *effectors = NULL;
MVert *mvert;
unsigned int i = 0;
int ret = 0;
/* simulate 1 frame forward */
cloth = clmd->clothObject;
verts = cloth->verts;
mvert = result->getVertArray(result);
/* force any pinned verts to their constrained location. */
for(i = 0; i < clmd->clothObject->numverts; i++, verts++) {
/* save the previous position. */
copy_v3_v3(verts->xold, verts->xconst);
copy_v3_v3(verts->txold, verts->x);
/* Get the current position. */
copy_v3_v3(verts->xconst, mvert[i].co);
mul_m4_v3(ob->obmat, verts->xconst);
}
effectors = pdInitEffectors(clmd->scene, ob, NULL, clmd->sim_parms->effector_weights);
tstart();
/* call the solver. */
if(solvers [clmd->sim_parms->solver_type].solver)
ret = solvers[clmd->sim_parms->solver_type].solver(ob, framenr, clmd, effectors);
tend();
pdEndEffectors(&effectors);
// printf ( "%f\n", ( float ) tval() );
return ret;
}
void unit_vehicle::update(int dt, world &w)
{
if (hp <= 0)
return;
if (m_first_update)
{
m_first_update = false;
if (!m_follow.expired())
{
auto f = m_follow.lock();
vec3 diff = get_pos() - f->get_pos();
if (diff.length() < m_params.formation_radius)
m_formation_offset = f->get_rot().rotate_inv(diff);
else
m_formation_offset.set(0, 0, -15.0f);
}
m_ground = (get_pos().y - w.get_height(get_pos().x, get_pos().z)) < 5.0f;
if (m_ground)
{
//ToDo: gear anim
}
else
{
if (m_params.speed_min > 0.01f)
m_vel = get_rot().rotate(vec3::forward() * m_params.speed_cruise);
m_dpos = vec3();
}
return;
}
float kdt = dt * 0.001f;
vec3 target_dir;
bool has_target = false;
if (m_target.expired())
{
if (m_ai > ai_default && m_target_search != search_none)
{
const bool air = m_ai == ai_air_to_air || m_ai == ai_air_multirole,
ground = m_ai == ai_air_to_ground || m_ai == ai_air_multirole;
float min_dist = 10000.0f;
for (int i = 0; i < w.get_planes_count() + w.get_units_count(); ++i)
{
object_ptr t;
if (i < w.get_planes_count())
{
auto p = w.get_plane(i);
if (is_ally(p, w))
continue;
t = p;
}
else
{
if (m_target_search == search_player)
continue;
auto u = w.get_unit(i - w.get_planes_count());
if (is_ally(u))
continue;
t = u;
}
if (!t->is_targetable(air, ground))
continue;
const float dist = (t->get_pos() - get_pos()).length();
if(dist >= min_dist)
continue;
m_target = t;
min_dist = dist;
}
}
}
else
{
if (m_target.lock()->hp <= 0)
m_target.reset();
}
bool not_path_not_follow = false;
if (!m_path.empty())
{
has_target = true;
target_dir = m_path.front() - get_pos();
if (target_dir.length() < m_vel.length() * kdt * m_params.target_radius)
{
if (m_path_loop)
m_path.push_back(m_path.front());
m_path.pop_front();
if (m_path.empty())
has_target = false;
else
target_dir = m_path.front() - get_pos();
}
}
else if (!m_follow.expired())
{
has_target = true;
auto f = m_follow.lock();
target_dir = f->get_pos() + f->get_rot().rotate(m_formation_offset) - (get_pos() + get_vel() * kdt);
//+ f->get_vel() * kdt //player's plane is already updated, ToDo
}
else
not_path_not_follow = true;
if (!m_target.expired())
{
auto t = m_target.lock();
const auto dir = t->get_pos() + t->get_rot().rotate(vec3(0, 0, -20.0)) - (get_pos() + get_vel() * kdt);
if (not_path_not_follow)
{
target_dir = dir;
has_target = true;
}
for (auto &wp: m_weapons)
{
if (wp.cooldown > 0)
{
wp.cooldown -= dt;
continue;
}
if (dir.length() > wp.params.lockon_range)
continue;
wp.cooldown = wp.params.reload_time;
auto m = w.add_missile(wp.params.id.c_str(), wp.mdl);
if (!m)
continue;
m->phys->pos = get_pos();
m->phys->rot = get_rot();
m->phys->vel = get_vel();
m->phys->target_dir = dir;
m->target = m_target;
}
}
if (has_target)
{
const float eps=1.0e-6f;
const float target_dist = target_dir.length();
const vec3 v=target_dir / target_dist;
const float xz_sqdist=v.x*v.x+v.z*v.z;
const auto rot = get_rot();
const auto pyr = rot.get_euler();
const nya_math::angle_rad new_yaw=(xz_sqdist>eps*eps)? (atan2(v.x,v.z)) : pyr.y;
nya_math::angle_rad new_pitch=(fabsf(v.y)>eps)? (-atan2(v.y,sqrtf(xz_sqdist))) : 0.0f;
nya_math::angle_rad new_roll;
if (!m_follow.expired())
new_roll = m_follow.lock()->get_rot().get_euler().z;
vec3 pos = get_pos() + m_vel * kdt;
const float h = w.get_height(pos.x, pos.z);
if ((new_pitch > 0.0f && pos.y <= h + m_params.height_min) || (new_pitch < 0.0f && pos.y >= h + m_params.height_max))
new_pitch = 0.0f;
const auto ideal_rot = quat(new_pitch, new_yaw, new_roll);
const float angle_diff = rot.rotate(vec3::forward()).angle(target_dir).get_deg();
if (fabsf(angle_diff) > 0.001f)
{
const float turn_k = nya_math::clamp((180.0f / angle_diff) * m_params.turn_speed * kdt, 0.0, 1.0);
m_render->mdl.set_rot(quat::slerp(rot, ideal_rot, turn_k));
}
float speed = m_vel.length();
float want_speed = target_dist / kdt;
if (!m_follow.expired())
{
const float target_speed = m_follow.lock()->get_vel().length();
float decel_time = (speed - target_speed) / m_params.decel;
if (target_dist / (speed + m_params.accel * kdt) < decel_time)
want_speed = target_speed;
}
want_speed = nya_math::clamp(want_speed, m_params.speed_min, std::min(m_params.speed_max, m_speed_limit));
speed = tend(speed, want_speed, m_params.accel * kdt, m_params.decel * kdt);
m_vel = get_rot().rotate(vec3(0.0, 0.0, speed));
}
else if (m_params.speed_min < 0.01f)
{
float speed = m_vel.length();
if (speed > 0.0f)
{
speed = tend(speed, 0.0f, m_params.accel * kdt, m_params.decel * kdt);
m_vel = get_rot().rotate(vec3(0.0, 0.0, speed));
}
}
vec3 pos = get_pos() + m_vel * kdt;
const float h = w.get_height(pos.x, pos.z);
pos.y = nya_math::clamp(pos.y, h + m_params.height_min, h + m_params.height_max); //ToDo
set_pos(pos);
}
void draw_volume(ARegion *ar, GPUTexture *tex, float *min, float *max, int res[3], float dx, GPUTexture *tex_shadow)
{
RegionView3D *rv3d= ar->regiondata;
float viewnormal[3];
int i, j, n, good_index;
float d /*, d0 */ /* UNUSED */, dd, ds;
float *points = NULL;
int numpoints = 0;
float cor[3] = {1.,1.,1.};
int gl_depth = 0, gl_blend = 0;
/* draw slices of smoke is adapted from c++ code authored by: Johannes Schmid and Ingemar Rask, 2006, [email protected] */
float cv[][3] = {
{1.0f, 1.0f, 1.0f}, {-1.0f, 1.0f, 1.0f}, {-1.0f, -1.0f, 1.0f}, {1.0f, -1.0f, 1.0f},
{1.0f, 1.0f, -1.0f}, {-1.0f, 1.0f, -1.0f}, {-1.0f, -1.0f, -1.0f}, {1.0f, -1.0f, -1.0f}
};
// edges have the form edges[n][0][xyz] + t*edges[n][1][xyz]
float edges[12][2][3] = {
{{1.0f, 1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{-1.0f, 1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{-1.0f, -1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{1.0f, -1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{1.0f, -1.0f, 1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, -1.0f, 1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, -1.0f, -1.0f}, {0.0f, 2.0f, 0.0f}},
{{1.0f, -1.0f, -1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, 1.0f, 1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, -1.0f, 1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, -1.0f, -1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, 1.0f, -1.0f}, {2.0f, 0.0f, 0.0f}}
};
/* Fragment program to calculate the view3d of smoke */
/* using 2 textures, density and shadow */
const char *text = "!!ARBfp1.0\n"
"PARAM dx = program.local[0];\n"
"PARAM darkness = program.local[1];\n"
"PARAM f = {1.442695041, 1.442695041, 1.442695041, 0.01};\n"
"TEMP temp, shadow, value;\n"
"TEX temp, fragment.texcoord[0], texture[0], 3D;\n"
"TEX shadow, fragment.texcoord[0], texture[1], 3D;\n"
"MUL value, temp, darkness;\n"
"MUL value, value, dx;\n"
"MUL value, value, f;\n"
"EX2 temp, -value.r;\n"
"SUB temp.a, 1.0, temp.r;\n"
"MUL temp.r, temp.r, shadow.r;\n"
"MUL temp.g, temp.g, shadow.r;\n"
"MUL temp.b, temp.b, shadow.r;\n"
"MOV result.color, temp;\n"
"END\n";
GLuint prog;
float size[3];
if(!tex) {
printf("Could not allocate 3D texture for 3D View smoke drawing.\n");
return;
}
tstart();
sub_v3_v3v3(size, max, min);
// maxx, maxy, maxz
cv[0][0] = max[0];
cv[0][1] = max[1];
cv[0][2] = max[2];
// minx, maxy, maxz
cv[1][0] = min[0];
cv[1][1] = max[1];
cv[1][2] = max[2];
// minx, miny, maxz
cv[2][0] = min[0];
cv[2][1] = min[1];
cv[2][2] = max[2];
// maxx, miny, maxz
cv[3][0] = max[0];
cv[3][1] = min[1];
cv[3][2] = max[2];
// maxx, maxy, minz
cv[4][0] = max[0];
cv[4][1] = max[1];
cv[4][2] = min[2];
// minx, maxy, minz
cv[5][0] = min[0];
cv[5][1] = max[1];
cv[5][2] = min[2];
// minx, miny, minz
cv[6][0] = min[0];
cv[6][1] = min[1];
cv[6][2] = min[2];
// maxx, miny, minz
cv[7][0] = max[0];
cv[7][1] = min[1];
cv[7][2] = min[2];
copy_v3_v3(edges[0][0], cv[4]); // maxx, maxy, minz
copy_v3_v3(edges[1][0], cv[5]); // minx, maxy, minz
copy_v3_v3(edges[2][0], cv[6]); // minx, miny, minz
copy_v3_v3(edges[3][0], cv[7]); // maxx, miny, minz
copy_v3_v3(edges[4][0], cv[3]); // maxx, miny, maxz
copy_v3_v3(edges[5][0], cv[2]); // minx, miny, maxz
copy_v3_v3(edges[6][0], cv[6]); // minx, miny, minz
copy_v3_v3(edges[7][0], cv[7]); // maxx, miny, minz
copy_v3_v3(edges[8][0], cv[1]); // minx, maxy, maxz
copy_v3_v3(edges[9][0], cv[2]); // minx, miny, maxz
copy_v3_v3(edges[10][0], cv[6]); // minx, miny, minz
copy_v3_v3(edges[11][0], cv[5]); // minx, maxy, minz
// printf("size x: %f, y: %f, z: %f\n", size[0], size[1], size[2]);
// printf("min[2]: %f, max[2]: %f\n", min[2], max[2]);
edges[0][1][2] = size[2];
edges[1][1][2] = size[2];
edges[2][1][2] = size[2];
edges[3][1][2] = size[2];
edges[4][1][1] = size[1];
edges[5][1][1] = size[1];
edges[6][1][1] = size[1];
edges[7][1][1] = size[1];
edges[8][1][0] = size[0];
edges[9][1][0] = size[0];
edges[10][1][0] = size[0];
edges[11][1][0] = size[0];
glGetBooleanv(GL_BLEND, (GLboolean *)&gl_blend);
glGetBooleanv(GL_DEPTH_TEST, (GLboolean *)&gl_depth);
glLoadMatrixf(rv3d->viewmat);
// glMultMatrixf(ob->obmat);
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
/*
printf("Viewinv:\n");
printf("%f, %f, %f\n", rv3d->viewinv[0][0], rv3d->viewinv[0][1], rv3d->viewinv[0][2]);
printf("%f, %f, %f\n", rv3d->viewinv[1][0], rv3d->viewinv[1][1], rv3d->viewinv[1][2]);
printf("%f, %f, %f\n", rv3d->viewinv[2][0], rv3d->viewinv[2][1], rv3d->viewinv[2][2]);
*/
// get view vector
copy_v3_v3(viewnormal, rv3d->viewinv[2]);
normalize_v3(viewnormal);
// find cube vertex that is closest to the viewer
for (i=0; i<8; i++) {
float x,y,z;
x = cv[i][0] - viewnormal[0];
y = cv[i][1] - viewnormal[1];
z = cv[i][2] - viewnormal[2];
if ((x>=min[0])&&(x<=max[0])
&&(y>=min[1])&&(y<=max[1])
&&(z>=min[2])&&(z<=max[2])) {
break;
}
}
if(i >= 8) {
/* fallback, avoid using buffer over-run */
i= 0;
}
// printf("i: %d\n", i);
// printf("point %f, %f, %f\n", cv[i][0], cv[i][1], cv[i][2]);
if (GL_TRUE == glewIsSupported("GL_ARB_fragment_program"))
{
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glGenProgramsARB(1, &prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(text), text);
// cell spacing
glProgramLocalParameter4fARB (GL_FRAGMENT_PROGRAM_ARB, 0, dx, dx, dx, 1.0);
// custom parameter for smoke style (higher = thicker)
glProgramLocalParameter4fARB (GL_FRAGMENT_PROGRAM_ARB, 1, 7.0, 7.0, 7.0, 1.0);
}
else
printf("Your gfx card does not support 3D View smoke drawing.\n");
GPU_texture_bind(tex, 0);
if(tex_shadow)
GPU_texture_bind(tex_shadow, 1);
else
printf("No volume shadow\n");
if (!GPU_non_power_of_two_support()) {
cor[0] = (float)res[0]/(float)larger_pow2(res[0]);
cor[1] = (float)res[1]/(float)larger_pow2(res[1]);
cor[2] = (float)res[2]/(float)larger_pow2(res[2]);
}
// our slices are defined by the plane equation a*x + b*y +c*z + d = 0
// (a,b,c), the plane normal, are given by viewdir
// d is the parameter along the view direction. the first d is given by
// inserting previously found vertex into the plane equation
/* d0 = (viewnormal[0]*cv[i][0] + viewnormal[1]*cv[i][1] + viewnormal[2]*cv[i][2]); */ /* UNUSED */
ds = (ABS(viewnormal[0])*size[0] + ABS(viewnormal[1])*size[1] + ABS(viewnormal[2])*size[2]);
dd = 0.05; // ds/512.0f;
n = 0;
good_index = i;
// printf("d0: %f, dd: %f, ds: %f\n\n", d0, dd, ds);
points = MEM_callocN(sizeof(float)*12*3, "smoke_points_preview");
while(1) {
float p0[3];
float tmp_point[3], tmp_point2[3];
if(dd*(float)n > ds)
break;
copy_v3_v3(tmp_point, viewnormal);
mul_v3_fl(tmp_point, -dd*((ds/dd)-(float)n));
add_v3_v3v3(tmp_point2, cv[good_index], tmp_point);
d = dot_v3v3(tmp_point2, viewnormal);
// printf("my d: %f\n", d);
// intersect_edges returns the intersection points of all cube edges with
// the given plane that lie within the cube
numpoints = intersect_edges(points, viewnormal[0], viewnormal[1], viewnormal[2], -d, edges);
// printf("points: %d\n", numpoints);
if (numpoints > 2) {
copy_v3_v3(p0, points);
// sort points to get a convex polygon
for(i = 1; i < numpoints - 1; i++)
{
for(j = i + 1; j < numpoints; j++)
{
if(!convex(p0, viewnormal, &points[j * 3], &points[i * 3]))
{
float tmp2[3];
copy_v3_v3(tmp2, &points[j * 3]);
copy_v3_v3(&points[j * 3], &points[i * 3]);
copy_v3_v3(&points[i * 3], tmp2);
}
}
}
// printf("numpoints: %d\n", numpoints);
glBegin(GL_POLYGON);
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < numpoints; i++) {
glTexCoord3d((points[i * 3 + 0] - min[0] )*cor[0]/size[0], (points[i * 3 + 1] - min[1])*cor[1]/size[1], (points[i * 3 + 2] - min[2])*cor[2]/size[2]);
glVertex3f(points[i * 3 + 0], points[i * 3 + 1], points[i * 3 + 2]);
}
glEnd();
}
n++;
}
tend();
// printf ( "Draw Time: %f\n",( float ) tval() );
if(tex_shadow)
GPU_texture_unbind(tex_shadow);
GPU_texture_unbind(tex);
if(GLEW_ARB_fragment_program)
{
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDeleteProgramsARB(1, &prog);
}
MEM_freeN(points);
if(!gl_blend)
glDisable(GL_BLEND);
if(gl_depth)
{
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
}
}
unsigned long WINAPI threadrun(void * var)
{
unsigned i;
char *p = (char *)var;
if(equal(p,"A")) { // Adult
#ifdef _WIN32
HANDLE pipeA, pipeB;
#else
struct sembuf sop;
int pipeA, pipeB;
int i;
#endif
#ifdef _WIN32
pipeA = CreateNamedPipe(pipeAdult,
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_BYTE,
2,
128,
128,
INFINITE,
NULL);
if(pipeA == INVALID_HANDLE_VALUE) {
printf("CreateNamedPipe <%s> failed ERROR=%d\n", pipeAdult,Errno);
ExitThread(1);
}
pipeB = pipeA;
//
// ConnectNamedPipe()
//
if(!ConnectNamedPipe(pipeA, NULL)) {
printf("ConnectNamePipe ERROR: err=%d\n",Errno);
ExitThread(1);
}
#else
pipeA = pipeAfds[1];
pipeB = pipeBfds[0];
#endif
tstart();
//
// ADULT: Writes the first byte.
//
for(i = 0; i < maxcount; i++) {
counter++;
if(!Put(pipeA))
break;
if(!Get(pipeB))
break;
}
tend();
double t = tval();
printf("%d pipe/thread Context switches in %7.3f sec ",
maxcount, t);
printf("%7.3f usec/cswitch",
(t*1e6)/maxcount);
printf("\n");
#ifdef _WIN32
ExitThread(0);
#else
sop.sem_num = 0;
sop.sem_op = -1;
sop.sem_flg = 0;
if(semop(sema, &sop, 1) == -1) {
printf("semop failed (waiting for threads): err=%d\n", Errno);
return 1;
}
#endif
}
else {
#ifdef _WIN32
HANDLE pipeA, pipeB, pipeC;
#else
struct sembuf sop;
int pipeA, pipeB;
int i;
#endif
#ifdef _WIN32
//
//
// Here we call OpenNamedPipe or CreateFile
//
Sleep(1);
pipeC = CreateFile(pipeAdult,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if(pipeC == INVALID_HANDLE_VALUE) {
printf("CreateFile for pipe failed: err=%d\n",
Errno);
ExitThread(1);
}
pipeA = pipeB = pipeC;
#else
pipeA = pipeAfds[0];
pipeB = pipeBfds[1];
#endif
//
// CHILD:
// The ALREADY_EXISTS detector will wait for the
// thing to be incremented. The other guy will start
// this off.
//
// Release pipeC and waitfor pipeA
//
tstart2();
for(i = 0; i < maxcount; i++) {
if(!Get(pipeA))
break;
if(!Put(pipeB))
break;
}
tend2();
double t = tval2();
printf("%d pipe/thread Context switches in %7.3f sec ",
maxcount, t);
printf("%7.3f usec/cswitch",
(t*1e6)/maxcount);
printf("\n");
#ifdef _WIN32
ExitThread(0);
#else
sop.sem_num = 0;
sop.sem_op = -1;
sop.sem_flg = 0;
if(semop(sema, &sop, 1) == -1) {
printf("semop failed (waiting for threads): err=%d\n", Errno);
return 1;
}
#endif
}
return 0;
}
void plane::update(int dt)
{
float kdt = dt * 0.001f;
vel *= meps_to_kmph;
//simulation
const float d2r = 3.1416 / 180.0f;
float speed = vel.length();
const float speed_arg = params.rotgraph.speed.get(speed);
const vec3 rspeed = params.rotgraph.speedRot.get(speed_arg);
const float eps = 0.001f;
if (fabsf(controls.rot.z) > eps)
rot_speed.z = tend(rot_speed.z, controls.rot.z * rspeed.z, params.rot.addRotR.z * fabsf(controls.rot.z) * kdt * 100.0);
else
rot_speed.z = tend(rot_speed.z, 0.0f, params.rot.addRotR.z * kdt * 40.0);
if (fabsf(controls.rot.y) > eps)
rot_speed.y = tend(rot_speed.y, -controls.rot.y * rspeed.y, params.rot.addRotR.y * fabsf(controls.rot.y) * kdt * 50.0);
else
rot_speed.y = tend(rot_speed.y, 0.0f, params.rot.addRotR.y * kdt * 10.0);
if (fabsf(controls.rot.x) > eps)
rot_speed.x = tend(rot_speed.x, controls.rot.x * rspeed.x, params.rot.addRotR.x * fabsf(controls.rot.x) * kdt * 100.0);
else
rot_speed.x = tend(rot_speed.x, 0.0f, params.rot.addRotR.x * kdt * 40.0);
//get axis
vec3 forward = rot.rotate(vec3::forward());
vec3 up = rot.rotate(vec3::up());
vec3 right = rot.rotate(vec3::right());
//rotation
float high_g_turn = 1.0f + controls.brake * 0.5;
rot = rot * quat(vec3::forward(), rot_speed.z * kdt * d2r * 0.7);
rot = rot * quat(vec3::up(), rot_speed.y * kdt * d2r * 0.12);
rot = rot * quat(vec3::right(), rot_speed.x * kdt * d2r * (0.13 + 0.05 * (1.0f - fabsf(up.y)))
* high_g_turn * (rot_speed.x < 0 ? 1.0f : 1.0f * params.rot.pitchUpDownR));
//nose goes down while upside-down
const vec3 rot_grav = params.rotgraph.rotGravR.get(speed_arg);
rot = rot * quat(vec3::right(), -(1.0 - up.y) * kdt * d2r * rot_grav.x * 0.5f);
rot = rot * quat(vec3::up(), -right.y * kdt * d2r * rot_grav.y * 0.5f);
//nose goes down during stall
if (speed < params.move.speed.speedStall)
{
float stallRotSpeed = params.rot.rotStallR * kdt * d2r * 10.0f;
rot = rot * quat(vec3::right(), up.y * stallRotSpeed);
rot = rot * quat(vec3::up(), -right.y * stallRotSpeed);
}
//adjust throttle to fit cruising speed
float throttle = controls.throttle;
float brake = controls.brake;
if (brake < 0.01f && throttle < 0.01f)
{
if (speed < params.move.speed.speedCruising)
throttle = nya_math::min((params.move.speed.speedCruising - speed) * 0.1f, 0.5f);
else if (speed > params.move.speed.speedCruising)
brake = nya_math::min((speed - params.move.speed.speedCruising) * 0.1f, 0.1f);
}
//afterburner
if (controls.throttle > 0.3f)
{
thrust_time += kdt;
if (thrust_time >= params.move.accel.thrustMinWait)
{
thrust_time = params.move.accel.thrustMinWait;
throttle *= params.move.accel.powerAfterBurnerR;
}
}
else if (thrust_time > 0.0f)
{
thrust_time -= kdt;
if (thrust_time < 0.0f)
thrust_time = 0.0f;
}
//apply acceleration
vel = vec3::lerp(vel, forward * speed, nya_math::min(5.0f * kdt, 1.0f));
const float brake_eff = nya_math::min(1.01f + forward.dot(vec3::up()), 1.0f);
vel += forward * (params.move.accel.acceleR * throttle * kdt * 50.0f - params.move.accel.deceleR * brake * brake_eff * kdt * speed * 0.04f);
speed = vel.length();
const float grav = 9.8f * meps_to_kmph * kdt;
vel.y -= grav;
vel += up * grav;
if (speed < params.move.speed.speedMin)
vel = vel * (params.move.speed.speedMin / speed);
if (speed > params.move.speed.speedMax)
vel = vel * (params.move.speed.speedMax / speed);
//apply speed
vel *= kmph_to_meps;
pos += vel * kdt;
}
void smokeModifier_do(SmokeModifierData *smd, Scene *scene, Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc)
{
if((smd->type & MOD_SMOKE_TYPE_FLOW))
{
if(scene->r.cfra >= smd->time)
smokeModifier_init(smd, ob, scene, dm);
if(scene->r.cfra > smd->time)
{
// XXX TODO
smd->time = scene->r.cfra;
// rigid movement support
/*
Mat4CpyMat4(smd->flow->mat_old, smd->flow->mat);
Mat4CpyMat4(smd->flow->mat, ob->obmat);
*/
}
else if(scene->r.cfra < smd->time)
{
smd->time = scene->r.cfra;
smokeModifier_reset(smd);
}
}
else if(smd->type & MOD_SMOKE_TYPE_COLL)
{
if(scene->r.cfra >= smd->time)
smokeModifier_init(smd, ob, scene, dm);
if(scene->r.cfra > smd->time)
{
// XXX TODO
smd->time = scene->r.cfra;
if(smd->coll->dm)
smd->coll->dm->release(smd->coll->dm);
smd->coll->dm = CDDM_copy(dm);
// rigid movement support
Mat4CpyMat4(smd->coll->mat_old, smd->coll->mat);
Mat4CpyMat4(smd->coll->mat, ob->obmat);
}
else if(scene->r.cfra < smd->time)
{
smd->time = scene->r.cfra;
smokeModifier_reset(smd);
}
}
else if(smd->type & MOD_SMOKE_TYPE_DOMAIN)
{
SmokeDomainSettings *sds = smd->domain;
float light[3];
PointCache *cache = NULL;
PTCacheID pid;
PointCache *cache_wt = NULL;
PTCacheID pid_wt;
int startframe, endframe, framenr;
float timescale;
int cache_result = 0, cache_result_wt = 0;
framenr = scene->r.cfra;
// printf("time: %d\n", scene->r.cfra);
if(framenr == smd->time)
return;
cache = sds->point_cache[0];
BKE_ptcache_id_from_smoke(&pid, ob, smd);
BKE_ptcache_id_time(&pid, scene, framenr, &startframe, &endframe, ×cale);
cache_wt = sds->point_cache[1];
BKE_ptcache_id_from_smoke_turbulence(&pid_wt, ob, smd);
if(!smd->domain->fluid)
{
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
BKE_ptcache_id_reset(scene, &pid_wt, PTCACHE_RESET_OUTDATED);
}
if(framenr < startframe)
return;
if(framenr > endframe)
return;
if(!smd->domain->fluid && (framenr != startframe))
return;
// printf("startframe: %d, framenr: %d\n", startframe, framenr);
if(!smokeModifier_init(smd, ob, scene, dm))
{
printf("bad smokeModifier_init\n");
return;
}
/* try to read from cache */
cache_result = BKE_ptcache_read_cache(&pid, (float)framenr, scene->r.frs_sec);
// printf("cache_result: %d\n", cache_result);
if(cache_result == PTCACHE_READ_EXACT)
{
cache->flag |= PTCACHE_SIMULATION_VALID;
cache->simframe= framenr;
if(sds->wt)
{
cache_result_wt = BKE_ptcache_read_cache(&pid_wt, (float)framenr, scene->r.frs_sec);
if(cache_result_wt == PTCACHE_READ_EXACT)
{
cache_wt->flag |= PTCACHE_SIMULATION_VALID;
cache_wt->simframe= framenr;
}
}
return;
}
tstart();
smoke_calc_domain(scene, ob, smd);
// set new time
smd->time = scene->r.cfra;
/* do simulation */
// low res
cache->flag |= PTCACHE_SIMULATION_VALID;
cache->simframe= framenr;
// simulate the actual smoke (c++ code in intern/smoke)
// DG: interesting commenting this line + deactivating loading of noise files
if(framenr!=startframe)
{
if(sds->flags & MOD_SMOKE_DISSOLVE)
smoke_dissolve(sds->fluid, sds->diss_speed, sds->flags & MOD_SMOKE_DISSOLVE_LOG);
smoke_step(sds->fluid, smd->time);
}
// create shadows before writing cache so we get nice shadows for sstartframe, too
if(get_lamp(scene, light))
smoke_calc_transparency(sds->shadow, smoke_get_density(sds->fluid), sds->p0, sds->p1, sds->res, sds->dx, light, calc_voxel_transp, -7.0*sds->dx);
BKE_ptcache_write_cache(&pid, framenr);
if(sds->wt)
{
if(framenr!=startframe)
{
if(sds->flags & MOD_SMOKE_DISSOLVE)
smoke_dissolve_wavelet(sds->wt, sds->diss_speed, sds->flags & MOD_SMOKE_DISSOLVE_LOG);
smoke_turbulence_step(sds->wt, sds->fluid);
}
cache_wt->flag |= PTCACHE_SIMULATION_VALID;
cache_wt->simframe= framenr;
BKE_ptcache_write_cache(&pid_wt, framenr);
}
tend();
printf ( "Frame: %d, Time: %f\n", (int)smd->time, ( float ) tval() );
}
}
int
main(int argc, char *argv[])
{
const struct field *field;
char *pat;
int c, i, rflags = REG_EXTENDED;
#ifdef __OpenBSD__
if (pledge("stdio rpath proc exec tty", NULL) == -1)
err(1, "pledge");
#endif
setlocale(LC_CTYPE, "");
pat = strtopat(" ");
while ((c = getopt(argc, argv, "ilvxd:g:")) != -1)
switch (c) {
case 'd':
free(pat);
pat = strtopat(optarg);
break;
case 'g':
free(pat);
pat = optarg;
rflags |= REG_NEWLINE;
break;
case 'i':
rflags |= REG_ICASE;
break;
case 'l':
free(pat);
pat = strtopat("");
break;
case 'v':
puts("yank " VERSION);
exit(0);
case 'x':
tty.ca = 1;
break;
default:
usage();
}
argc -= optind;
argv += optind;
if (regcomp(®, pat, rflags) != 0)
errx(1, "invalid regular expression");
/* Ensure space for yank command and null terminator. */
if ((yankargv = calloc(argc + 3, sizeof(char *))) == NULL)
err(1, NULL);
if (argc)
{
for (i = 0; i < argc; i++)
yankargv[i] = argv[i];
}
else
{
yankargv[0] = YANKCMD;
yankargv[1] = YANKCMD2;
}
input();
tsetup();
field = tmain();
tend();
if (field == NULL)
return 1;
yank(in.v + field->so, field->eo - field->so + 1);
return 0;
}