//-----------------------------------------------------------------------------
// Purpose: Think while actively tracking a target.
//-----------------------------------------------------------------------------
void CNPC_CombineCamera::ActiveThink()
{
// Allow descended classes a chance to do something before the think function
if (PreThink(CAMERA_ACTIVE))
return;
// No active target, look for suspicious characters.
CBaseEntity *pTarget = MaintainEnemy();
if ( !pTarget )
{
// Nobody suspicious. Go back to being idle.
m_hEnemyTarget = NULL;
EmitSound("NPC_CombineCamera.BecomeIdle");
SetAngry(false);
SetThink(&CNPC_CombineCamera::SearchThink);
SetNextThink( gpGlobals->curtime );
return;
}
// Examine the target until it reaches our inner radius
if ( pTarget != m_hEnemyTarget )
{
Vector vecDelta = pTarget->GetAbsOrigin() - GetAbsOrigin();
float flDist = vecDelta.Length();
if ( (flDist < m_nInnerRadius) && FInViewCone(pTarget) )
{
m_OnFoundEnemy.Set(pTarget, pTarget, this);
// If it's a citizen, it's ok. If it's the player, it's not ok.
if ( pTarget->IsPlayer() )
{
SetEyeState(CAMERA_EYE_FOUND_TARGET);
if (HasSpawnFlags(SF_COMBINE_CAMERA_BECOMEANGRY))
{
SetAngry(true);
}
else
{
EmitSound("NPC_CombineCamera.Active");
}
m_OnFoundPlayer.Set(pTarget, pTarget, this);
m_hEnemyTarget = pTarget;
}
else
{
SetEyeState(CAMERA_EYE_HAPPY);
m_flEyeHappyTime = gpGlobals->curtime + 2.0;
// Now forget about this target forever
AddEntityRelationship( pTarget, D_NU, 99 );
}
}
else
{
// If we get angry automatically, we get un-angry automatically
if ( HasSpawnFlags(SF_COMBINE_CAMERA_BECOMEANGRY) && m_bAngry )
{
SetAngry(false);
}
m_hEnemyTarget = NULL;
// We don't quite see this guy, but we sense him.
SetEyeState(CAMERA_EYE_SEEKING_TARGET);
}
}
// Update our think time
SetNextThink( gpGlobals->curtime + 0.1f );
TrackTarget(pTarget);
MaintainEye();
}
void LocaleWin::initializeLocalizerData()
{
if (m_didInitializeNumberData)
return;
Vector<String, DecimalSymbolsSize> symbols;
enum DigitSubstitution {
DigitSubstitutionContext = 0,
DigitSubstitution0to9 = 1,
DigitSubstitutionNative = 2,
};
DWORD digitSubstitution = DigitSubstitution0to9;
getLocaleInfo(LOCALE_IDIGITSUBSTITUTION, digitSubstitution);
if (digitSubstitution == DigitSubstitution0to9) {
symbols.append("0");
symbols.append("1");
symbols.append("2");
symbols.append("3");
symbols.append("4");
symbols.append("5");
symbols.append("6");
symbols.append("7");
symbols.append("8");
symbols.append("9");
} else {
String digits = getLocaleInfoString(LOCALE_SNATIVEDIGITS);
ASSERT(digits.length() >= 10);
for (unsigned i = 0; i < 10; ++i)
symbols.append(digits.substring(i, 1));
}
ASSERT(symbols.size() == DecimalSeparatorIndex);
symbols.append(getLocaleInfoString(LOCALE_SDECIMAL));
ASSERT(symbols.size() == GroupSeparatorIndex);
symbols.append(getLocaleInfoString(LOCALE_STHOUSAND));
ASSERT(symbols.size() == DecimalSymbolsSize);
String negativeSign = getLocaleInfoString(LOCALE_SNEGATIVESIGN);
enum NegativeFormat {
NegativeFormatParenthesis = 0,
NegativeFormatSignPrefix = 1,
NegativeFormatSignSpacePrefix = 2,
NegativeFormatSignSuffix = 3,
NegativeFormatSpaceSignSuffix = 4,
};
DWORD negativeFormat = NegativeFormatSignPrefix;
getLocaleInfo(LOCALE_INEGNUMBER, negativeFormat);
String negativePrefix = emptyString();
String negativeSuffix = emptyString();
switch (negativeFormat) {
case NegativeFormatParenthesis:
negativePrefix = "(";
negativeSuffix = ")";
break;
case NegativeFormatSignSpacePrefix:
negativePrefix = negativeSign + " ";
break;
case NegativeFormatSignSuffix:
negativeSuffix = negativeSign;
break;
case NegativeFormatSpaceSignSuffix:
negativeSuffix = " " + negativeSign;
break;
case NegativeFormatSignPrefix: // Fall through.
default:
negativePrefix = negativeSign;
break;
}
m_didInitializeNumberData = true;
setLocalizerData(symbols, emptyString(), emptyString(), negativePrefix, negativeSuffix);
}
static bool writeUInt16(Vector<char>& vector, uint16_t value)
{
uint16_t bigEndianValue = htons(value);
return vector.tryAppend(reinterpret_cast<char*>(&bigEndianValue), sizeof(bigEndianValue));
}
void SMILTimeContainer::sortByPriority(Vector<SVGSMILElement*>& smilElements, SMILTime elapsed)
{
if (m_documentOrderIndexesDirty)
updateDocumentOrderIndexes();
std::sort(smilElements.begin(), smilElements.end(), PriorityCompare(elapsed));
}
// See http://msdn.microsoft.com/en-us/library/dd317787(v=vs.85).aspx
static Vector<DateFormatToken> parseDateFormat(const String format)
{
Vector<DateFormatToken> tokens;
StringBuilder literalBuffer;
bool inQuote = false;
bool lastQuoteCanBeLiteral = false;
for (unsigned i = 0; i < format.length(); ++i) {
UChar ch = format[i];
if (inQuote) {
if (ch == '\'') {
inQuote = false;
ASSERT(i);
if (lastQuoteCanBeLiteral && format[i - 1] == '\'') {
literalBuffer.append('\'');
lastQuoteCanBeLiteral = false;
} else
lastQuoteCanBeLiteral = true;
} else
literalBuffer.append(ch);
continue;
}
if (ch == '\'') {
inQuote = true;
if (lastQuoteCanBeLiteral && i > 0 && format[i - 1] == '\'') {
literalBuffer.append(ch);
lastQuoteCanBeLiteral = false;
} else
lastQuoteCanBeLiteral = true;
} else if (isYearSymbol(ch)) {
commitLiteralToken(literalBuffer, tokens);
unsigned count = countContinuousLetters(format, i);
i += count - 1;
if (count == 1)
tokens.append(DateFormatToken(DateFormatToken::Year1));
else if (count == 2)
tokens.append(DateFormatToken(DateFormatToken::Year2));
else
tokens.append(DateFormatToken(DateFormatToken::Year4));
} else if (isMonthSymbol(ch)) {
commitLiteralToken(literalBuffer, tokens);
unsigned count = countContinuousLetters(format, i);
i += count - 1;
if (count == 1)
tokens.append(DateFormatToken(DateFormatToken::Month1));
else if (count == 2)
tokens.append(DateFormatToken(DateFormatToken::Month2));
else if (count == 3)
tokens.append(DateFormatToken(DateFormatToken::Month3));
else
tokens.append(DateFormatToken(DateFormatToken::Month4));
} else if (isDaySymbol(ch)) {
commitLiteralToken(literalBuffer, tokens);
unsigned count = countContinuousLetters(format, i);
i += count - 1;
if (count == 1)
tokens.append(DateFormatToken(DateFormatToken::Day1));
else
tokens.append(DateFormatToken(DateFormatToken::Day2));
} else if (isEraSymbol(ch)) {
// Just ignore era.
// HTML5 date supports only A.D.
} else
literalBuffer.append(ch);
}
commitLiteralToken(literalBuffer, tokens);
return tokens;
}
int main(int argc, char *argv[]){
Network yarp;
//Port<Bottle> armPlan;
//Port<Bottle> armPred;
Port armPlan;
Port armPred;
armPlan.open("/randArm/plan");
armPred.open("/randArm/pred");
bool fwCvOn = 0;
fwCvOn = Network::connect("/randArm/plan","/fwdConv:i");
fwCvOn *= Network::connect("/fwdConv:o","/randArm/pred");
if (!fwCvOn){
printf("Please run command:\n ./fwdConv --input /fwdConv:i --output /fwdConv:o");
return 1;
}
const gsl_rng_type *T;
gsl_rng *r;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
Property params;
params.fromCommand(argc,argv);
if (!params.check("robot")){
fprintf(stderr, "Please specify robot name");
fprintf(stderr, "e.g. --robot icub");
return -1;
}
std::string robotName = params.find("robot").asString().c_str();
std::string remotePorts = "/";
remotePorts += robotName;
remotePorts += "/";
if (params.check("side")){
remotePorts += params.find("side").asString().c_str();
}
else{
remotePorts += "left";
}
remotePorts += "_arm";
std::string localPorts = "/randArm/cmd";
Property options;
options.put("device", "remote_controlboard");
options.put("local", localPorts.c_str());
options.put("remote", remotePorts.c_str());
PolyDriver robotDevice(options);
if (!robotDevice.isValid()){
printf("Device not available. Here are known devices: \n");
printf("%s", Drivers::factory().toString().c_str());
Network::fini();
return 1;
}
IPositionControl *pos;
IEncoders *enc;
bool ok;
ok = robotDevice.view(pos);
ok = ok && robotDevice.view(enc);
if (!ok){
printf("Problems acquiring interfaces\n");
return 0;
}
int nj = 0;
pos->getAxes(&nj);
Vector encoders;
Vector command;
Vector commandCart;
Vector tmp;
encoders.resize(nj);
tmp.resize(nj);
command.resize(nj);
commandCart.resize(nj);
for (int i = 0; i < nj; i++) {
tmp[i] = 25.0;
}
pos->setRefAccelerations(tmp.data());
for (int i = 0; i < nj; i++) {
tmp[i] = 5.0;
pos->setRefSpeed(i, tmp[i]);
}
command = 0;
//set the arm joints to "middle" values
command[0] = -45;
command[1] = 45;
command[2] = 0;
command[3] = 45;
pos->positionMove(command.data());
bool done = false;
while (!done){
pos->checkMotionDone(&done);
Time::delay(0.1);
}
while (true){
tmp = command;
command[0] += 15*(2*gsl_rng_uniform(r)-1);
command[1] += 15*(2*gsl_rng_uniform(r)-1);
command[2] += 15*(2*gsl_rng_uniform(r)-1);
command[3] += 15*(2*gsl_rng_uniform(r)-1);
printf("%.1lf %.1lf %.1lf %.1lf\n", command[0], command[1], command[2], command[3]);
//above 0 doesn't seem to be safe for joint 0
if (command[0] > 0 || command[0] < -90){
command[0] = tmp[0];
}
if (command[1] > 160 || command[1] < -0){
command[1] = tmp[1];
}
if (command[2] > 100 || command[2] < -35){
command[2] = tmp[2];
}
if (command[3] > 100 || command[3] < 10){
command[3] = tmp[3];
}
//use fwd kin to find end effector position
Bottle plan, pred;
for (int i = 0; i < nj; i++){
plan.add(command[i]);
}
armPlan.write(plan);
armPred.read(pred);
for (int i = 0; i < 3; i++){
commandCart[i] = pred.get(i).asDouble();
}
double rad = sqrt(commandCart[0]*commandCart[0]+commandCart[1]*commandCart[1]);
// safety radius back to 30 cm
if (rad > 0.3){
pos->positionMove(command.data());
done = false;
while(!done){
pos->checkMotionDone(&done);
Time::delay(0.1);
}
}
else{
printf("Self collision detected!\n");
}
}
robotDevice.close();
gsl_rng_free(r);
return 0;
}
void TextureMapperLayer::setChildren(const Vector<TextureMapperLayer*>& newChildren)
{
removeAllChildren();
for (size_t i = 0; i < newChildren.size(); ++i)
addChild(newChildren[i]);
}
TEST_F(AnimationInterpolationEffectTest, MultipleInterpolations)
{
InterpolationEffect interpolationEffect;
interpolationEffect.addInterpolation(SampleInterpolation::create(InterpolableNumber::create(10), InterpolableNumber::create(15)),
RefPtr<TimingFunction>(), 1, 2, 1, 3);
interpolationEffect.addInterpolation(SampleInterpolation::create(InterpolableNumber::create(0), InterpolableNumber::create(1)),
LinearTimingFunction::shared(), 0, 1, 0, 1);
interpolationEffect.addInterpolation(SampleInterpolation::create(InterpolableNumber::create(1), InterpolableNumber::create(6)),
CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease), 0.5, 1.5, 0.5, 1.5);
Vector<RefPtr<Interpolation>> activeInterpolations;
interpolationEffect.getActiveInterpolations(-0.5, duration, activeInterpolations);
EXPECT_EQ(0ul, activeInterpolations.size());
interpolationEffect.getActiveInterpolations(0, duration, activeInterpolations);
EXPECT_EQ(1ul, activeInterpolations.size());
EXPECT_FLOAT_EQ(0, getInterpolableNumber(activeInterpolations.at(0)));
interpolationEffect.getActiveInterpolations(0.5, duration, activeInterpolations);
EXPECT_EQ(2ul, activeInterpolations.size());
EXPECT_FLOAT_EQ(0.5f, getInterpolableNumber(activeInterpolations.at(0)));
EXPECT_FLOAT_EQ(1, getInterpolableNumber(activeInterpolations.at(1)));
interpolationEffect.getActiveInterpolations(1, duration, activeInterpolations);
EXPECT_EQ(2ul, activeInterpolations.size());
EXPECT_FLOAT_EQ(10, getInterpolableNumber(activeInterpolations.at(0)));
EXPECT_FLOAT_EQ(5.0282884f, getInterpolableNumber(activeInterpolations.at(1)));
interpolationEffect.getActiveInterpolations(1, duration * 1000, activeInterpolations);
EXPECT_EQ(2ul, activeInterpolations.size());
EXPECT_FLOAT_EQ(10, getInterpolableNumber(activeInterpolations.at(0)));
EXPECT_FLOAT_EQ(5.0120168f, getInterpolableNumber(activeInterpolations.at(1)));
interpolationEffect.getActiveInterpolations(1.5, duration, activeInterpolations);
EXPECT_EQ(1ul, activeInterpolations.size());
EXPECT_FLOAT_EQ(12.5f, getInterpolableNumber(activeInterpolations.at(0)));
interpolationEffect.getActiveInterpolations(2, duration, activeInterpolations);
EXPECT_EQ(1ul, activeInterpolations.size());
EXPECT_FLOAT_EQ(15, getInterpolableNumber(activeInterpolations.at(0)));
}
/// Construct q Quaternion from the @p real and @p imag parts
Quaternion(T real, const Vector<T, 3>& imag)
: _a(real)
, _x(imag.x())
, _y(imag.y())
, _z(imag.z())
{ }
void main ()
{
try
{
Vector<float> v;
v.Add(10);
v.Add(3.4);
v.Add(6.2);
v.Add(9.3);
v.Add(1.8);
v.Add(6.7);
v.Add(1.6);
v.Add(3.5);
v.Add(4);
v.Add(8.3); //10
v.Add(7.1);
v.Add(8.4);
v.Add(5.3);
v.Add(2.6);
v.Add(3.8);
v.Add(6.7);
v.Add(2.5);
v.Add(8.4);
v.Add(2.7);
v.Add(9.5); // 20
v.Add(3.9);
cout << "Should print 10...3.9: " << endl;
cout << v << endl;
v.Add(5);
v.Add(2.9);
cout << "Should print 10...2.9: " << endl;
cout << v << endl;
v.Remove(0);
cout << "Should remove 10, so should print 3.4...3.9: " << endl;
cout << v << endl;
// Copy constructor test
CopyTest(v);
Vector<float> aVector;
aVector = v;
cout << "Should print 3.4...3.9: " << endl;
cout << aVector << endl;
}
catch (string error)
{
cout << error << endl;
}
system("pause");
}
bool CollisionPolygon2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) {
if (!node)
return false;
Ref<InputEventMouseButton> mb = p_event;
if (mb.is_valid()) {
Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
Vector2 gpoint = mb->get_position();
Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
cpoint = canvas_item_editor->snap_point(cpoint);
cpoint = node->get_global_transform().affine_inverse().xform(cpoint);
Vector<Vector2> poly = node->get_polygon();
//first check if a point is to be added (segment split)
real_t grab_threshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8);
switch (mode) {
case MODE_CREATE: {
if (mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) {
if (!wip_active) {
wip.clear();
wip.push_back(cpoint);
wip_active = true;
edited_point_pos = cpoint;
canvas_item_editor->get_viewport_control()->update();
edited_point = 1;
return true;
} else {
if (wip.size() > 1 && xform.xform(wip[0]).distance_to(gpoint) < grab_threshold) {
//wip closed
_wip_close();
return true;
} else {
wip.push_back(cpoint);
edited_point = wip.size();
canvas_item_editor->get_viewport_control()->update();
return true;
//add wip point
}
}
} else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && wip_active) {
_wip_close();
}
} break;
case MODE_EDIT: {
if (mb->get_button_index() == BUTTON_LEFT) {
if (mb->is_pressed()) {
if (mb->get_control()) {
if (poly.size() < 3) {
undo_redo->create_action(TTR("Edit Poly"));
undo_redo->add_undo_method(node, "set_polygon", poly);
poly.push_back(cpoint);
undo_redo->add_do_method(node, "set_polygon", poly);
undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
undo_redo->commit_action();
return true;
}
//search edges
int closest_idx = -1;
Vector2 closest_pos;
real_t closest_dist = 1e10;
for (int i = 0; i < poly.size(); i++) {
Vector2 points[2] = { xform.xform(poly[i]),
xform.xform(poly[(i + 1) % poly.size()]) };
Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points);
if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2)
continue; //not valid to reuse point
real_t d = cp.distance_to(gpoint);
if (d < closest_dist && d < grab_threshold) {
closest_dist = d;
closest_pos = cp;
closest_idx = i;
}
}
if (closest_idx >= 0) {
pre_move_edit = poly;
poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos));
edited_point = closest_idx + 1;
edited_point_pos = xform.affine_inverse().xform(closest_pos);
node->set_polygon(poly);
canvas_item_editor->get_viewport_control()->update();
return true;
}
} else {
//look for points to move
int closest_idx = -1;
Vector2 closest_pos;
real_t closest_dist = 1e10;
for (int i = 0; i < poly.size(); i++) {
Vector2 cp = xform.xform(poly[i]);
real_t d = cp.distance_to(gpoint);
if (d < closest_dist && d < grab_threshold) {
closest_dist = d;
closest_pos = cp;
closest_idx = i;
}
}
if (closest_idx >= 0) {
pre_move_edit = poly;
edited_point = closest_idx;
edited_point_pos = xform.affine_inverse().xform(closest_pos);
canvas_item_editor->get_viewport_control()->update();
return true;
}
}
} else {
if (edited_point != -1) {
//apply
ERR_FAIL_INDEX_V(edited_point, poly.size(), false);
poly[edited_point] = edited_point_pos;
undo_redo->create_action(TTR("Edit Poly"));
undo_redo->add_do_method(node, "set_polygon", poly);
undo_redo->add_undo_method(node, "set_polygon", pre_move_edit);
undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
undo_redo->commit_action();
edited_point = -1;
return true;
}
}
} else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && edited_point == -1) {
int closest_idx = -1;
Vector2 closest_pos;
real_t closest_dist = 1e10;
for (int i = 0; i < poly.size(); i++) {
Vector2 cp = xform.xform(poly[i]);
real_t d = cp.distance_to(gpoint);
if (d < closest_dist && d < grab_threshold) {
closest_dist = d;
closest_pos = cp;
closest_idx = i;
}
}
if (closest_idx >= 0) {
undo_redo->create_action(TTR("Edit Poly (Remove Point)"));
undo_redo->add_undo_method(node, "set_polygon", poly);
poly.remove(closest_idx);
undo_redo->add_do_method(node, "set_polygon", poly);
undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update");
undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update");
undo_redo->commit_action();
return true;
}
}
} break;
}
}
Ref<InputEventMouseMotion> mm = p_event;
if (mm.is_valid()) {
if (edited_point != -1 && (wip_active || mm->get_button_mask() & BUTTON_MASK_LEFT)) {
Vector2 gpoint = mm->get_position();
Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
cpoint = canvas_item_editor->snap_point(cpoint);
edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint);
canvas_item_editor->get_viewport_control()->update();
}
}
return false;
}
Vector normalize(const Vector &v)
{
float l = v.length();
return v / l;
}
void C_Hairball::ClientThink()
{
// Do some AI-type stuff.. move the entity around.
//C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
//m_vecAngles = SetAbsAngles( pPlayer->GetAbsAngles() ); // copy player angles.
Assert( !GetMoveParent() );
// Sophisticated AI.
m_flCurSpinTime += gpGlobals->frametime;
if ( m_flCurSpinTime < m_flSpinDuration )
{
float div = m_flCurSpinTime / m_flSpinDuration;
QAngle angles = GetLocalAngles();
angles.x += m_flSpinRateX * SmoothCurve( div );
angles.y += m_flSpinRateY * SmoothCurve( div );
SetLocalAngles( angles );
}
else
{
// Flip between stopped and starting.
if ( fabs( m_flSpinRateX ) > 0.01f )
{
m_flSpinRateX = m_flSpinRateY = 0;
m_flSpinDuration = RandomFloat( 1, 2 );
}
else
{
static float flXSpeed = 3;
static float flYSpeed = flXSpeed * 0.1f;
m_flSpinRateX = RandomFloat( -M_PI*flXSpeed, M_PI*flXSpeed );
m_flSpinRateY = RandomFloat( -M_PI*flYSpeed, M_PI*flYSpeed );
m_flSpinDuration = RandomFloat( 1, 4 );
}
m_flCurSpinTime = 0;
}
if ( m_flSitStillTime > 0 )
{
m_flSitStillTime -= gpGlobals->frametime;
if ( m_flSitStillTime <= 0 )
{
// Shoot out some random lines and find the longest one.
m_vMoveDir.Init( 1, 0, 0 );
float flLongestFraction = 0;
for ( int i=0; i < 15; i++ )
{
Vector vDir( RandomFloat( -1, 1 ), RandomFloat( -1, 1 ), RandomFloat( -1, 1 ) );
VectorNormalize( vDir );
trace_t trace;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vDir * 10000, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &trace );
if ( trace.fraction != 1.0 )
{
if ( trace.fraction > flLongestFraction )
{
flLongestFraction = trace.fraction;
m_vMoveDir = vDir;
}
}
}
m_vMoveDir *= 650; // set speed.
m_flSitStillTime = -1; // Move in this direction..
}
}
else
{
// Move in the specified direction.
Vector vEnd = GetAbsOrigin() + m_vMoveDir * gpGlobals->frametime;
trace_t trace;
UTIL_TraceLine( GetAbsOrigin(), vEnd, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &trace );
if ( trace.fraction < 1 )
{
// Ok, stop moving.
m_flSitStillTime = RandomFloat( 1, 3 );
}
else
{
SetLocalOrigin( GetLocalOrigin() + m_vMoveDir * gpGlobals->frametime );
}
}
// Transform the base hair positions so we can lock them down.
VMatrix mTransform;
mTransform.SetupMatrixOrgAngles( GetLocalOrigin(), GetLocalAngles() );
for ( int i=0; i < m_HairPositions.Count(); i++ )
{
Vector3DMultiplyPosition( mTransform, m_HairPositions[i], m_TransformedHairPositions[i] );
}
if ( m_bFirstThink )
{
m_bFirstThink = false;
for ( int i=0; i < m_HairPositions.Count(); i++ )
{
for ( int j=0; j < m_nNodesPerHair; j++ )
{
m_Nodes[i*m_nNodesPerHair+j].Init( m_TransformedHairPositions[i] );
}
}
}
// Simulate the physics and apply constraints.
m_Physics.Simulate( m_Nodes.Base(), m_Nodes.Count(), &m_Delegate, gpGlobals->frametime, 0.98 );
}
int main()
{
// Time measurement.
TimePeriod cpu_time;
cpu_time.tick();
// Create coarse mesh, set Dirichlet BC, enumerate basis functions.
Space* space = new Space(A, B, NELEM, DIR_BC_LEFT, DIR_BC_RIGHT, P_INIT, NEQ, NEQ);
// Enumerate basis functions, info for user.
int ndof = Space::get_num_dofs(space);
info("ndof: %d", ndof);
// Initialize the weak formulation.
WeakForm wf;
wf.add_matrix_form(jacobian);
wf.add_vector_form(residual);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem *dp_coarse = new DiscreteProblem(&wf, space, is_linear);
// Newton's loop on coarse mesh.
// Fill vector coeff_vec using dof and coeffs arrays in elements.
double *coeff_vec_coarse = new double[Space::get_num_dofs(space)];
get_coeff_vector(space, coeff_vec_coarse);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix_coarse = create_matrix(matrix_solver);
Vector* rhs_coarse = create_vector(matrix_solver);
Solver* solver_coarse = create_linear_solver(matrix_solver, matrix_coarse, rhs_coarse);
int it = 1;
while (1)
{
// Obtain the number of degrees of freedom.
int ndof_coarse = Space::get_num_dofs(space);
// Assemble the Jacobian matrix and residual vector.
dp_coarse->assemble(coeff_vec_coarse, matrix_coarse, rhs_coarse);
// Calculate the l2-norm of residual vector.
double res_l2_norm = get_l2_norm(rhs_coarse);
// Info for user.
info("---- Newton iter %d, ndof %d, res. l2 norm %g", it, Space::get_num_dofs(space), res_l2_norm);
// If l2 norm of the residual vector is within tolerance, then quit.
// NOTE: at least one full iteration forced
// here because sometimes the initial
// residual on fine mesh is too small.
if(res_l2_norm < NEWTON_TOL_COARSE && it > 1) break;
// Multiply the residual vector with -1 since the matrix
// equation reads J(Y^n) \deltaY^{n+1} = -F(Y^n).
for(int i=0; i<ndof_coarse; i++) rhs_coarse->set(i, -rhs_coarse->get(i));
// Solve the linear system.
if(!solver_coarse->solve())
error ("Matrix solver failed.\n");
// Add \deltaY^{n+1} to Y^n.
for (int i = 0; i < ndof_coarse; i++) coeff_vec_coarse[i] += solver_coarse->get_solution()[i];
// If the maximum number of iteration has been reached, then quit.
if (it >= NEWTON_MAX_ITER) error ("Newton method did not converge.");
// Copy coefficients from vector y to elements.
set_coeff_vector(coeff_vec_coarse, space);
it++;
}
// Cleanup.
delete matrix_coarse;
delete rhs_coarse;
delete solver_coarse;
delete [] coeff_vec_coarse;
delete dp_coarse;
// DOF and CPU convergence graphs.
SimpleGraph graph_dof_est, graph_cpu_est;
SimpleGraph graph_dof_exact, graph_cpu_exact;
// Adaptivity loop:
int as = 1;
bool done = false;
do
{
info("---- Adaptivity step %d:", as);
// Construct globally refined reference mesh and setup reference space.
Space* ref_space = construct_refined_space(space);
// Initialize the FE problem.
bool is_linear = false;
DiscreteProblem* dp = new DiscreteProblem(&wf, ref_space, is_linear);
// Set up the solver, matrix, and rhs according to the solver selection.
SparseMatrix* matrix = create_matrix(matrix_solver);
Vector* rhs = create_vector(matrix_solver);
Solver* solver = create_linear_solver(matrix_solver, matrix, rhs);
// Newton's loop on the fine mesh.
info("Solving on fine mesh:");
// Fill vector coeff_vec using dof and coeffs arrays in elements.
double *coeff_vec = new double[Space::get_num_dofs(ref_space)];
get_coeff_vector(ref_space, coeff_vec);
int it = 1;
while (1)
{
// Obtain the number of degrees of freedom.
int ndof = Space::get_num_dofs(ref_space);
// Assemble the Jacobian matrix and residual vector.
dp->assemble(coeff_vec, matrix, rhs);
// Calculate the l2-norm of residual vector.
double res_l2_norm = get_l2_norm(rhs);
// Info for user.
info("---- Newton iter %d, ndof %d, res. l2 norm %g", it, Space::get_num_dofs(ref_space), res_l2_norm);
// If l2 norm of the residual vector is within tolerance, then quit.
// NOTE: at least one full iteration forced
// here because sometimes the initial
// residual on fine mesh is too small.
if(res_l2_norm < NEWTON_TOL_REF && it > 1) break;
// Multiply the residual vector with -1 since the matrix
// equation reads J(Y^n) \deltaY^{n+1} = -F(Y^n).
for(int i=0; i<ndof; i++) rhs->set(i, -rhs->get(i));
// Solve the linear system.
if(!solver->solve())
error ("Matrix solver failed.\n");
// Add \deltaY^{n+1} to Y^n.
for (int i = 0; i < ndof; i++) coeff_vec[i] += solver->get_solution()[i];
// If the maximum number of iteration has been reached, then quit.
if (it >= NEWTON_MAX_ITER) error ("Newton method did not converge.");
// Copy coefficients from vector y to elements.
set_coeff_vector(coeff_vec, ref_space);
it++;
}
// Starting with second adaptivity step, obtain new coarse
// mesh solution via projecting the fine mesh solution.
if(as > 1)
{
info("Projecting the fine mesh solution onto the coarse mesh.");
// Project the fine mesh solution (defined on space_ref) onto the coarse mesh (defined on space).
OGProjection::project_global(space, ref_space, matrix_solver);
}
// Calculate element errors and total error estimate.
info("Calculating error estimate.");
double err_est_array[MAX_ELEM_NUM];
double err_est_rel = calc_err_est(NORM, space, ref_space, err_est_array) * 100;
// Report results.
info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%",
Space::get_num_dofs(space), Space::get_num_dofs(ref_space), err_est_rel);
// Time measurement.
cpu_time.tick();
// If exact solution available, also calculate exact error.
if (EXACT_SOL_PROVIDED)
{
// Calculate element errors wrt. exact solution.
double err_exact_rel = calc_err_exact(NORM, space, exact_sol, NEQ, A, B) * 100;
// Info for user.
info("Relative error (exact) = %g %%", err_exact_rel);
// Add entry to DOF and CPU convergence graphs.
graph_dof_exact.add_values(Space::get_num_dofs(space), err_exact_rel);
graph_cpu_exact.add_values(cpu_time.accumulated(), err_exact_rel);
}
// Add entry to DOF and CPU convergence graphs.
graph_dof_est.add_values(Space::get_num_dofs(space), err_est_rel);
graph_cpu_est.add_values(cpu_time.accumulated(), err_est_rel);
// Decide whether the relative error is sufficiently small.
if(err_est_rel < TOL_ERR_REL) break;
// Returns updated coarse and fine meshes, with the last
// coarse and fine mesh solutions on them, respectively.
// The coefficient vectors and numbers of degrees of freedom
// on both meshes are also updated.
adapt(NORM, ADAPT_TYPE, THRESHOLD, err_est_array,
space, ref_space);
as++;
// Plot meshes, results, and errors.
adapt_plotting(space, ref_space, NORM, EXACT_SOL_PROVIDED, exact_sol);
// Cleanup.
delete solver;
delete matrix;
delete rhs;
delete ref_space;
delete dp;
delete [] coeff_vec;
}
while (done == false);
info("Total running time: %g s", cpu_time.accumulated());
// Save convergence graphs.
graph_dof_est.save("conv_dof_est.dat");
graph_cpu_est.save("conv_cpu_est.dat");
graph_dof_exact.save("conv_dof_exact.dat");
graph_cpu_exact.save("conv_cpu_exact.dat");
// Test variable.
int success_test = 1;
info("N_dof = %d.", Space::get_num_dofs(space));
if (Space::get_num_dofs(space) > 40) success_test = 0;
if (success_test)
{
info("Success!");
return ERROR_SUCCESS;
}
else
{
info("Failure!");
return ERROR_FAILURE;
}
}
void DlgSqlExport::Run(Sql& cursor, String command, String tablename)
{
Title(Nvl(tablename, t_("SQL query")) + t_(" export"));
object_name <<= tablename;
if(!cursor.Execute(command)) {
Exclamation(NFormat(t_("Error executing [* \1%s\1]: \1%s"), command, cursor.GetLastError()));
return;
}
for(int i = 0; i < cursor.GetColumns(); i++) {
const SqlColumnInfo& sci = cursor.GetColumnInfo(i);
String type;
switch(sci.type) {
case BOOL_V:
case INT_V: type = t_("integer"); break;
case DOUBLE_V: type = t_("real number"); break;
case STRING_V:
case WSTRING_V: type = t_("string"); break;
case DATE_V: type = t_("date"); break;
case TIME_V: type = t_("date/time"); break;
case /*ORA_BLOB_V*/-1: type = t_("BLOB"); break;
case /*ORA_CLOB_V*/-2: type = t_("CLOB"); break;
default: type = FormatInt(sci.type); break;
}
columns.Add(sci.name, sci.type, sci.width, 1);
}
static String cfg;
LoadFromString(*this, cfg);
SyncUI();
while(TopWindow::Run() == IDOK)
try {
String out_table = ~object_name;
String delim;
switch((int)~delimiters) {
case DELIM_TAB: delim = "\t"; break;
case DELIM_SEMICOLON: delim = ";"; break;
}
Vector<int> out;
String colstr;
String title;
for(int i = 0; i < columns.GetCount(); i++)
if(columns.Get(i, 3)) {
out.Add(i);
String cname = cursor.GetColumnInfo(i).name;
colstr << (i ? ", " : "") << cname;
if(i) title << delim;
title << cname;
}
if(out.IsEmpty()) {
throw Exc(t_("No columns selected!"));
continue;
}
String rowbegin, rowend;
int fmt = ~format;
FileSel fsel;
String ext;
switch(fmt) {
case FMT_TEXT: {
rowend = "";
ext = ".txt";
fsel.Type(t_("Text files (*.txt)"), "*.txt");
break;
}
case FMT_SQL: {
if(identity_insert)
rowbegin << "set identity_insert " << out_table << " on ";
rowbegin << "insert into " << out_table << "(" << colstr << ") values (";
rowend = ");";
ext = ".sql";
fsel.Type(t_("SQL scripts (*.sql)"), "*.sql");
break;
}
}
fsel.AllFilesType().DefaultExt(ext.Mid(1));
if(!IsNull(recent_file))
fsel <<= ForceExt(recent_file, ext);
if(!fsel.ExecuteSaveAs(t_("Save export as")))
continue;
recent_file = ~fsel;
FileOut fo;
if(!fo.Open(recent_file)) {
Exclamation(NFormat(t_("Error creating file [* \1%s\1]."), recent_file));
continue;
}
if(fmt == FMT_TEXT)
fo.PutLine(title);
Progress progress(t_("Exporting row %d"));
while(cursor.Fetch()) {
String script = rowbegin;
for(int i = 0; i < out.GetCount(); i++) {
Value v = cursor[out[i]];
switch(fmt) {
case FMT_TEXT: {
if(i)
script.Cat(delim);
if(IsString(v) && quote) {
String s = v;
script << '\"';
for(const char *p = s, *e = s.End(); p < e; p++)
if(*p == '\"')
script.Cat("\"\"");
else
script.Cat(*p);
script << '\"';
}
else
script << StdFormat(v);
break;
}
case FMT_SQL: {
if(i) script.Cat(", ");
script << SqlCompile(cursor.GetDialect(), SqlFormat(v));
break;
}
}
}
script << rowend;
fo.PutLine(script);
/*
if(autocommit && --left <= 0) {
fo.PutLine("commit;");
left = autocommit;
}
*/
if(progress.StepCanceled()) {
Exclamation(t_("Export aborted!"));
return;
}
}
fo.Close();
if(fo.IsError())
throw Exc(NFormat(t_("Error writing file %s."), recent_file));
break;
}
catch(Exc e) {
ShowExc(e);
}
cfg = StoreAsString(*this);
}
void Light::SetDirection(Vector v){
m_direction = v.d3dvector();
}
double RootMeanSquaredError::calculate_performance(const Vector<double>& parameters) const
{
// Control sentence (if debug)
#ifdef __OPENNN_DEBUG__
check();
#endif
#ifdef __OPENNN_DEBUG__
std::ostringstream buffer;
const size_t size = parameters.size();
const size_t parameters_number = neural_network_pointer->count_parameters_number();
if(size != parameters_number)
{
buffer << "OpenNN Exception: RootMeanSquaredError class.\n"
<< "double calculate_performance(const Vector<double>&) const method.\n"
<< "Size (" << size << ") must be equal to number of parameters (" << parameters_number << ").\n";
throw std::logic_error(buffer.str());
}
#endif
// Neural network stuff
const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
const size_t inputs_number = multilayer_perceptron_pointer->get_inputs_number();
const size_t outputs_number = multilayer_perceptron_pointer->get_outputs_number();
// Data set stuff
const Instances& instances = data_set_pointer->get_instances();
const size_t training_instances_number = instances.count_training_instances_number();
const Vector<size_t> training_indices = instances.arrange_training_indices();
size_t training_index;
const Variables& variables = data_set_pointer->get_variables();
const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();
const Vector<size_t> targets_indices = variables.arrange_targets_indices();
// Root mean squared error
Vector<double> inputs(inputs_number);
Vector<double> outputs(outputs_number);
Vector<double> targets(outputs_number);
double sum_squared_error = 0.0;
int i = 0;
#pragma omp parallel for private(i, training_index, inputs, outputs, targets) reduction(+:sum_squared_error)
for(i = 0; i < (int)training_instances_number; i++)
{
training_index = training_indices[i];
// Input vector
inputs = data_set_pointer->get_instance(training_index, inputs_indices);
// Output vector
outputs = multilayer_perceptron_pointer->calculate_outputs(inputs, parameters);
// Target vector
targets = data_set_pointer->get_instance(training_index, targets_indices);
// Sum squaresd error
sum_squared_error += outputs.calculate_sum_squared_error(targets);
}
return(sqrt(sum_squared_error/(double)training_instances_number));
}
Vector::Vector(const Vector& v) : s{v.s}, max{v.max}, elementen{new double[v.s]} {
for(int i=0; i<v.s; i++){
elementen[i]=v.get(i);
}
}
void TextureMapperLayer::sortByZOrder(Vector<TextureMapperLayer* >& array)
{
qsort(array.data(), array.size(), sizeof(TextureMapperLayer*), compareGraphicsLayersZValue);
}
/**
* Compute the intersection between the line segment and the capped cylinder.
*
* Site from is ALWAYS fluid
* Site to is ALWAYS solid
*
* Therefore we expect exactly one intersection. Due to floating point errors,
* we can't guarantee this. So, we search for intersections with some
* tolerance (macro TOL) and pick the closest to fluid site (as given by the
* parametic line coordinate t. We use a priority_queue to keep the hits in
* order.
*/
Hit ComputeIntersection(CylinderData* cyl, std::vector<Iolet*>& iolets,
Site& from, Site& to) {
HitList hitList = HitList();
/*
* The equation of the line segment is:
* x(t) = a + t (b - a) t E (0, 1)
*/
Vector& n = cyl->Axis;
double& r = cyl->Radius;
Vector& c = cyl->Centre;
double& h = cyl->Length;
{
/*
* The equation determining intersection with an INFINITE cylinder of
* radius r is:
* [(b-a)^2 - ((b-a).n)^2] t^2 + [2 a.(b - a) - 2 (a.n)((b-a).n)] t + [a^2 - (a.n)^2 - r^2] = 0
* So first compute the coefficients and then the discriminant of the eqn
*/
Vector a = from.Position - c;
Vector b = to.Position - c;
Vector b_a = b - a;
double b_aDOTn = Vector::Dot(b_a, n);
double aDOTn = Vector::Dot(a, n);
double A = (b_a.GetMagnitudeSquared() - b_aDOTn * b_aDOTn);
double B = 2. * (Vector::Dot(a, b_a) - aDOTn * b_aDOTn);
double C = a.GetMagnitudeSquared() - aDOTn * aDOTn - r * r;
double discriminant = B * B - 4 * A * C;
if (discriminant < 0.) {
// No real solutions.
} else if (discriminant == 0) {
// Exactly one solution, i.e. line segment just brushes the cylinder.
// This means the line must be outside the cylinder everywhere else,
// so we will count this as no intersection.
} else {
// Two real solutions. So we have two intersections between the
// infinite line and infinite cylinder.
// If t outside (0,1), then the intersection isn't on the line segment
// we care about.
std::vector<double> ts(2);
ts[0] = (-B + std::sqrt(discriminant)) / (2 * A);
ts[1] = (-B - std::sqrt(discriminant)) / (2 * A);
for (std::vector<double>::iterator tIt = ts.begin(); tIt
!= ts.end(); ++tIt) {
double t = *tIt;
if (t > 0. && t < 1. + TOL) {
// Hit in part of line we care about.
// Now check if it's on the finite cylinder. This requires that
// x.n E (-h/2, h/2)
double xDOTn = aDOTn + t * b_aDOTn;
if (xDOTn >= -0.5 * h - TOL && xDOTn <= 0.5 * h + TOL) {
// Real cylinder hit!
Hit hit;
hit.t = t;
hit.pt = from.Position + b_a * t;
hit.cellId = -1;
hitList.push(hit);
}
}
}
}
}
/*
* Now we want to look for intersections with the capping planes.
*/
Vector& a = from.Position;
Vector& b = to.Position;
Vector b_a = b - a;
for (std::vector<Iolet*>::iterator iIt = iolets.begin(); iIt
!= iolets.end(); ++iIt) {
Iolet* iolet = *iIt;
/*
* Plane equation is x.p = q.p (p = plane normal, q = point on plane)
* Line is x = a + t(b-a)
*/
Vector& q = iolet->Centre;
Vector& p = iolet->Normal;
double t = Vector::Dot(q - a, p) / Vector::Dot(b_a, p);
if (t > 0. && t < 1. + TOL) {
// Intersection within the line segment. Now check within cap.
Vector x = a + b_a * t;
Vector x_c = x - c;
double x_cDOTn = Vector::Dot(x_c, n);
Vector radial = x_c - n * x_cDOTn;
if (radial.GetMagnitudeSquared() < (r + TOL) * (r + TOL)) {
// Within the cap
Hit hit;
hit.t = t;
hit.pt = x;
hit.cellId = iIt - iolets.begin();
hitList.push(hit);
}
}
}
// We know there SHOULD be exactly one intersection. Take the closest.
if (hitList.size() == 0)
throw InconsistentFluidnessError(from, to, hitList.size());
// Ensure that the hit lies on the link
Hit ans = hitList.top();
if (ans.t > 1.) {
ans.t = 1.;
ans.pt = b;
}
return ans;
}
bool Connection::sendOutgoingMessage(MessageID messageID, PassOwnPtr<MessageEncoder> encoder)
{
Vector<Attachment> attachments = encoder->releaseAttachments();
size_t numberOfPortDescriptors = 0;
size_t numberOfOOLMemoryDescriptors = 0;
for (size_t i = 0; i < attachments.size(); ++i) {
Attachment::Type type = attachments[i].type();
if (type == Attachment::MachPortType)
numberOfPortDescriptors++;
else if (type == Attachment::MachOOLMemoryType)
numberOfOOLMemoryDescriptors++;
}
size_t messageSize = machMessageSize(encoder->bufferSize(), numberOfPortDescriptors, numberOfOOLMemoryDescriptors);
char buffer[inlineMessageMaxSize];
bool messageBodyIsOOL = false;
if (messageSize > sizeof(buffer)) {
messageBodyIsOOL = true;
attachments.append(Attachment(encoder->buffer(), encoder->bufferSize(), MACH_MSG_VIRTUAL_COPY, false));
numberOfOOLMemoryDescriptors++;
messageSize = machMessageSize(0, numberOfPortDescriptors, numberOfOOLMemoryDescriptors);
}
bool isComplex = (numberOfPortDescriptors + numberOfOOLMemoryDescriptors > 0);
mach_msg_header_t* header = reinterpret_cast<mach_msg_header_t*>(&buffer);
header->msgh_bits = isComplex ? MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND | MACH_MSGH_BITS_COMPLEX, 0) : MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
header->msgh_size = messageSize;
header->msgh_remote_port = m_sendPort;
header->msgh_local_port = MACH_PORT_NULL;
header->msgh_id = messageID.toInt();
if (messageBodyIsOOL)
header->msgh_id |= MessageBodyIsOOL;
uint8_t* messageData;
if (isComplex) {
mach_msg_body_t* body = reinterpret_cast<mach_msg_body_t*>(header + 1);
body->msgh_descriptor_count = numberOfPortDescriptors + numberOfOOLMemoryDescriptors;
uint8_t* descriptorData = reinterpret_cast<uint8_t*>(body + 1);
for (size_t i = 0; i < attachments.size(); ++i) {
Attachment attachment = attachments[i];
mach_msg_descriptor_t* descriptor = reinterpret_cast<mach_msg_descriptor_t*>(descriptorData);
switch (attachment.type()) {
case Attachment::MachPortType:
descriptor->port.name = attachment.port();
descriptor->port.disposition = attachment.disposition();
descriptor->port.type = MACH_MSG_PORT_DESCRIPTOR;
descriptorData += sizeof(mach_msg_port_descriptor_t);
break;
case Attachment::MachOOLMemoryType:
descriptor->out_of_line.address = attachment.address();
descriptor->out_of_line.size = attachment.size();
descriptor->out_of_line.copy = attachment.copyOptions();
descriptor->out_of_line.deallocate = attachment.deallocate();
descriptor->out_of_line.type = MACH_MSG_OOL_DESCRIPTOR;
descriptorData += sizeof(mach_msg_ool_descriptor_t);
break;
default:
ASSERT_NOT_REACHED();
}
}
messageData = descriptorData;
} else
messageData = (uint8_t*)(header + 1);
// Copy the data if it is not being sent out-of-line.
if (!messageBodyIsOOL)
memcpy(messageData, encoder->buffer(), encoder->bufferSize());
ASSERT(m_sendPort);
// Send the message.
kern_return_t kr = mach_msg(header, MACH_SEND_MSG, messageSize, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if (kr != KERN_SUCCESS) {
// FIXME: What should we do here?
}
return true;
}
//------------------------------------------------------------------------------
// Purpose : Update the direction and position of my spotlight
// Input :
// Output :
//------------------------------------------------------------------------------
void CPointSpotlight::SpotlightUpdate(void)
{
// ---------------------------------------------------
// If I don't have a spotlight attempt to create one
// ---------------------------------------------------
if ( !m_hSpotlight )
{
if ( m_bSpotlightOn )
{
// Make the spotlight
SpotlightCreate();
}
else
{
return;
}
}
else if ( !m_bSpotlightOn )
{
SpotlightDestroy();
return;
}
if ( !m_hSpotlightTarget )
{
DevWarning( "**Attempting to update point_spotlight but target ent is NULL\n" );
SpotlightDestroy();
SpotlightCreate();
if ( !m_hSpotlightTarget )
return;
}
m_vSpotlightCurrentPos = SpotlightCurrentPos();
// Update spotlight target velocity
Vector vTargetDir;
VectorSubtract( m_vSpotlightCurrentPos, m_hSpotlightTarget->GetAbsOrigin(), vTargetDir );
float vTargetDist = vTargetDir.Length();
// If we haven't moved at all, don't recompute
if ( vTargetDist < 1 )
{
m_hSpotlightTarget->SetAbsVelocity( vec3_origin );
return;
}
Vector vecNewVelocity = vTargetDir;
VectorNormalize(vecNewVelocity);
vecNewVelocity *= (10 * vTargetDist);
// If a large move is requested, just jump to final spot as we probably hit a discontinuity
if (vecNewVelocity.Length() > 200)
{
VectorNormalize(vecNewVelocity);
vecNewVelocity *= 200;
VectorNormalize(vTargetDir);
m_hSpotlightTarget->SetAbsOrigin( m_vSpotlightCurrentPos );
}
m_hSpotlightTarget->SetAbsVelocity( vecNewVelocity );
m_hSpotlightTarget->m_vSpotlightOrg = GetAbsOrigin();
// Avoid sudden change in where beam fades out when cross disconinuities
VectorSubtract( m_hSpotlightTarget->GetAbsOrigin(), m_hSpotlightTarget->m_vSpotlightOrg, m_hSpotlightTarget->m_vSpotlightDir );
float flBeamLength = VectorNormalize( m_hSpotlightTarget->m_vSpotlightDir );
m_flSpotlightCurLength = (0.60*m_flSpotlightCurLength) + (0.4*flBeamLength);
ComputeRenderInfo();
//NDebugOverlay::Cross3D(GetAbsOrigin(),Vector(-5,-5,-5),Vector(5,5,5),0,255,0,true,0.1);
//NDebugOverlay::Cross3D(m_vSpotlightCurrentPos,Vector(-5,-5,-5),Vector(5,5,5),0,255,0,true,0.1);
//NDebugOverlay::Cross3D(m_vSpotlightTargetPos,Vector(-5,-5,-5),Vector(5,5,5),255,0,0,true,0.1);
}
static void writeLayers(TextStream& ts, const RenderLayer* rootLayer, RenderLayer* l,
const LayoutRect& paintRect, int indent, RenderAsTextBehavior behavior)
{
// FIXME: Apply overflow to the root layer to not break every test. Complete hack. Sigh.
LayoutRect paintDirtyRect(paintRect);
if (rootLayer == l) {
paintDirtyRect.setWidth(max<LayoutUnit>(paintDirtyRect.width(), rootLayer->renderBox()->layoutOverflowRect().maxX()));
paintDirtyRect.setHeight(max<LayoutUnit>(paintDirtyRect.height(), rootLayer->renderBox()->layoutOverflowRect().maxY()));
l->setSize(l->size().expandedTo(pixelSnappedIntSize(l->renderBox()->maxLayoutOverflow(), LayoutPoint(0, 0))));
}
// Calculate the clip rects we should use.
LayoutRect layerBounds;
ClipRect damageRect, clipRectToApply, outlineRect;
l->calculateRects(rootLayer, 0, TemporaryClipRects, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect);
// Ensure our lists are up-to-date.
l->updateLayerListsIfNeeded();
bool shouldPaint = (behavior & RenderAsTextShowAllLayers) ? true : l->intersectsDamageRect(layerBounds, damageRect.rect(), rootLayer);
Vector<RenderLayer*>* negList = l->negZOrderList();
bool paintsBackgroundSeparately = negList && negList->size() > 0;
if (shouldPaint && paintsBackgroundSeparately)
write(ts, *l, layerBounds, damageRect.rect(), clipRectToApply.rect(), outlineRect.rect(), LayerPaintPhaseBackground, indent, behavior);
if (negList) {
int currIndent = indent;
if (behavior & RenderAsTextShowLayerNesting) {
writeIndent(ts, indent);
ts << " negative z-order list(" << negList->size() << ")\n";
++currIndent;
}
for (unsigned i = 0; i != negList->size(); ++i)
writeLayers(ts, rootLayer, negList->at(i), paintDirtyRect, currIndent, behavior);
}
if (shouldPaint)
write(ts, *l, layerBounds, damageRect.rect(), clipRectToApply.rect(), outlineRect.rect(), paintsBackgroundSeparately ? LayerPaintPhaseForeground : LayerPaintPhaseAll, indent, behavior);
if (Vector<RenderLayer*>* normalFlowList = l->normalFlowList()) {
int currIndent = indent;
if (behavior & RenderAsTextShowLayerNesting) {
writeIndent(ts, indent);
ts << " normal flow list(" << normalFlowList->size() << ")\n";
++currIndent;
}
for (unsigned i = 0; i != normalFlowList->size(); ++i)
writeLayers(ts, rootLayer, normalFlowList->at(i), paintDirtyRect, currIndent, behavior);
}
if (Vector<RenderLayer*>* posList = l->posZOrderList()) {
int currIndent = indent;
if (behavior & RenderAsTextShowLayerNesting) {
writeIndent(ts, indent);
ts << " positive z-order list(" << posList->size() << ")\n";
++currIndent;
}
for (unsigned i = 0; i != posList->size(); ++i)
writeLayers(ts, rootLayer, posList->at(i), paintDirtyRect, currIndent, behavior);
}
// Altough the RenderFlowThread requires a layer, it is not collected by its parent,
// so we have to treat it as a special case.
if (l->renderer()->isRenderView()) {
RenderView* renderView = toRenderView(l->renderer());
writeRenderNamedFlowThreads(ts, renderView, rootLayer, paintDirtyRect, indent, behavior);
}
}
int main(int argc, char** argv)
{
Color color;
float zpf = 0.5; //primitive is double, causes problems
float zpt = 0.25;
float zps = 0.75;
Camera cam = Camera();
raytracer = Raytracer(cam.eye, 16, Color(0,0,0), Color(0.1,0.1,0.1));
UL = Vector(-1, 1, 1);
UR = Vector( 1, 1, 1);
LR = Vector( 1, -1, 1);
LL = Vector(-1, -1, 1);
Image screen = Image(width, height);
//Triangle triangle(Vector(-9,-5,10),Vector(-3,-5,13),Vector(-6,5,10), Color(1,0.5,0.25));
//raytracer.registerShape(triangle);
//Sphere sphere = Sphere(Vector(0, 0, 10), 3, Color(0.5,0.5,0.5));
//raytracer.registerShape(sphere);
//Sphere sphere2 = Sphere(Vector(3, 0, 6), 1, Color(0.25,0.5,1));
//raytracer.registerShape(sphere2);
Triangle triangle = Triangle (Vector (-5, -5, 10), Vector(5, -5, 10), Vector(0, 5, 10));
raytracer.registerShape(triangle);
Light light = Light(0,0,0,1,0,1);
raytracer.registerLight(light);
for(float k = 0; k < height; k++) {
for(float i = 0; i < width; i++) {
float u = (i + zpf) / width;
float v = (k + zpf) / height;
Vector dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
Ray ray = Ray(cam.eye, dir);
PoI poi = PoI();
bool gotHit = intersect_search(ray, triangles, 1, &poi);
//PoI intersect = PoI(Vector(0,0,0), Vector(0,0,0));
//bool gotHit = triangle.hit(ray, &intersect);
//gotHit = gotHit || sphere.hit(ray, &intersect);
Color color1 = raytracer.trace(ray, 1);
u = (i + 2*zpt) / width;
v = (k + zpt) / height;
dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
ray = Ray(cam.eye, dir);
Color color2 = raytracer.trace(ray, 1);
u = (i + 3*zpt) / width;
v = (k + zpt) / height;
dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
ray = Ray(cam.eye, dir);
Color color3 = raytracer.trace(ray, 1);
u = (i + zpt) / width;
v = (k + 2*zpt) / height;
dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
ray = Ray(cam.eye, dir);
Color color4 = raytracer.trace(ray, 1);
u = (i + zpt) / width;
v = (k + 3*zpt) / height;
dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
ray = Ray(cam.eye, dir);
Color color5 = raytracer.trace(ray, 1);
u = (i + 2*zpt) / width;
v = (k + 2*zpt) / height;
dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
ray = Ray(cam.eye, dir);
Color color6 = raytracer.trace(ray, 1);
u = (i + 2*zpt) / width;
v = (k + 3*zpt) / height;
dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
ray = Ray(cam.eye, dir);
Color color7 = raytracer.trace(ray, 1);
u = (i + 3*zpt) / width;
v = (k + 2*zpt) / height;
dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
ray = Ray(cam.eye, dir);
Color color8 = raytracer.trace(ray, 1);
u = (i + 3*zpt) / width;
v = (k + 3*zpt) / height;
dir = ((UR.Vsca(v)).Vadd(UL.Vsca(1-v)).Vsca(u)).Vadd((LR.Vsca(v)).Vadd(LL.Vsca(1-v)).Vsca(1-u)).Vsub(cam.eye).Vnor();
ray = Ray(cam.eye, dir);
Color color9 = raytracer.trace(ray, 1);
/*if (gotHit)
{
color = poi.getColor();
//Ray shadow_ray. origin = poi.coliision, dir -> to light <<<<<<<<---- thingies for shadows
//bool isShadowed = intersect_search(shadow_ray, tra...)
//if(isShadowed)
// color = 0;
//else
//color = poi.shade(light);
}
else
{
color = Color(0, 0, 0);
}*/
//color = VtoC((CtoV(color1).Vadd(CtoV(color2)).Vadd(CtoV(color3)).Vadd(CtoV(color4)).Vadd(CtoV(color5)).Vadd(CtoV(color6)).Vadd(CtoV(color7)).Vadd(CtoV(color8)).Vadd(CtoV(color9))).Vdiv(9));
if(!screen.setPixel(k, i, color1)) {
printf("There was a problem!\n");
}
}
}
screen.flush();
return 0;
}
double LocaleWin::parseDate(const Vector<DateFormatToken>& tokens, int baseYear, const String& input)
{
ensureShortMonthLabels();
ensureMonthLabels();
const double NaN = numeric_limits<double>::quiet_NaN();
unsigned inputIndex = 0;
int day = -1, month = -1, year = -1;
for (unsigned i = 0; i < tokens.size(); ++i) {
switch (tokens[i].type) {
case DateFormatToken::Literal: {
String data = tokens[i].data;
unsigned literalLength = data.length();
if (input.substring(inputIndex, literalLength) == data)
inputIndex += literalLength;
// Go ahead even if the input doesn't have this string.
break;
}
case DateFormatToken::Day1:
case DateFormatToken::Day2:
day = parseNumber(input, inputIndex);
if (day < 1 || day > 31)
return NaN;
break;
case DateFormatToken::Month1:
case DateFormatToken::Month2:
case DateFormatToken::Month3:
case DateFormatToken::Month4:
month = parseNumberOrMonth(input, inputIndex);
if (month < 0 || month > 11)
return NaN;
break;
case DateFormatToken::Year1: {
unsigned oldIndex = inputIndex;
year = parseNumber(input, inputIndex);
if (year <= 0)
return NaN;
if (inputIndex - oldIndex == 1) {
int shortYear = baseYear % 10;
int decade = baseYear - shortYear;
if (shortYear >= 5)
year += shortYear - 4 <= year ? decade : decade + 10;
else
year += shortYear + 5 >= year ? decade : decade - 10;
}
break;
}
case DateFormatToken::Year2: {
unsigned oldIndex = inputIndex;
year = parseNumber(input, inputIndex);
if (year <= 0)
return NaN;
if (inputIndex - oldIndex == 2) {
int shortYear = baseYear % 100;
int century = baseYear - shortYear;
if (shortYear >= 50)
year += shortYear - 49 <= year ? century : century + 100;
else
year += shortYear + 50 >= year ? century : century - 100;
}
break;
}
case DateFormatToken::Year4:
year = parseNumber(input, inputIndex);
if (year <= 0)
return NaN;
break;
}
}
if (year <= 0 || month < 0 || day <= 0)
return NaN;
return dateToDaysFrom1970(year, month, day) * msPerDay;
}
int main(int argc, char *argv[]) {
Network yarp;
Property params;
Robot * robot;
PositionImpedanceThd* controllerLeftArm;
PositionImpedanceThd* controllerRightArm;
JointImpedance *jointImpedance;
//Vector jointImpedance;
int joint,nJoints;
// Create context
params.fromCommand(argc, argv);
if (!params.check("robot")) {
fprintf(stderr, "Please specify the name of the robot\n");
fprintf(stderr, " --robot name (e.g. icub, icubSim)\n");
return -1;
}
//Initialize the Robot
robot = new Robot(0);
robot->init(params.find("robot").asString().c_str());
// Stiffness vector
nJoints = robot->get_dof(LEFT_ARM);
jointImpedanceVec.resize(nJoints);
// Default stiffness
for (joint = 0; joint < nJoints; ++joint) {
jointImpedanceVec[joint] = 0;
}
//Controller threads
controllerLeftArm = new PositionImpedanceThd(
robot->get_driver(LEFT_ARM), (double) REFSPEED, (double) REFACC, jointImpedanceVec,
(double) PCONTROLLER);
controllerRightArm = new PositionImpedanceThd(
robot->get_driver(RIGHT_ARM), (double) REFSPEED, (double) REFACC, jointImpedanceVec,
(double) PCONTROLLER);
jointImpedance = new JointImpedance(robot->get_driver(LEFT_ARM), robot->get_driver(RIGHT_ARM), PUPDATE, REST);
// Starting the controllers threads
if (!controllerLeftArm->start()) {
delete controllerLeftArm;
delete controllerRightArm;
delete jointImpedance;
return -1;
}
if (!controllerRightArm->start()) {
delete controllerLeftArm;
delete controllerRightArm;
delete jointImpedance;
return -1;
}
sleep(1);
//SetPoints Vector
bool doneLeft, doneRight;
jointsLeft.resize(nJoints);
jointsRight.resize(nJoints);
/*
* Phase 1 - Initial position
*
* Stiff movement to the initial arm position.
*/
printf("\n+++ Phase 1.\n");
firstPhase();
controllerLeftArm->enableImpedance(jointImpedanceVec);
controllerLeftArm->setJoints(jointsLeft);
controllerRightArm->setJoints(jointsRight);
sleep(3);
printf("+++ Finished phase 1.\n");
/*
* Phase 2 - Two handed grasping
*
* Compliant movement to grasp an object between the arms.
*/
printf("\n+++ Phase 2.\n");
secondPhase();
controllerLeftArm->enableImpedance(jointImpedanceVec);
controllerLeftArm->setJoints(jointsLeft);
controllerRightArm->setJoints(jointsRight);
sleep(3);
printf("+++ Finished phase 2.\n");
int go;
cout << "Press any key for the variable impedance control phase..." << endl;
cin >> go;
/*
* Phase 3 - Two-Handed Object Tracking
*
* Following the object
*/
printf("\n+++ Phase 3.\n");
if (!jointImpedance->start()){
delete controllerLeftArm;
delete controllerRightArm;
delete jointImpedance;
return -1;
}
while(getchar() != 'a'){}
jointImpedance->stop();
/*
* Tear down
*
* Releasing the object, deconstructing
*/
// Back to initial arm position
printf("\n+++ Phase 4.\n");
fourthPhase();
controllerLeftArm->setJoints(jointsLeft);
controllerRightArm->setJoints(jointsRight);
sleep(3);
printf("+++ Finished phase 4.\n");
printf("\n+++ Released the object, Demo finished.\n");
controllerLeftArm->stop();
controllerRightArm->stop();
delete robot;
delete controllerLeftArm;
delete controllerRightArm;
delete jointImpedance;
return 0;
}
bool convertWOFFToSfnt(SharedBuffer* woff, Vector<char>& sfnt)
{
ASSERT_ARG(sfnt, sfnt.isEmpty());
size_t offset = 0;
// Read the WOFF header.
uint32_t signature;
if (!readUInt32(woff, offset, signature) || signature != woffSignature) {
ASSERT_NOT_REACHED();
return false;
}
uint32_t flavor;
if (!readUInt32(woff, offset, flavor))
return false;
uint32_t length;
if (!readUInt32(woff, offset, length) || length != woff->size())
return false;
uint16_t numTables;
if (!readUInt16(woff, offset, numTables))
return false;
if (!numTables || numTables > 0x0fff)
return false;
uint16_t reserved;
if (!readUInt16(woff, offset, reserved) || reserved)
return false;
uint32_t totalSfntSize;
if (!readUInt32(woff, offset, totalSfntSize))
return false;
if (woff->size() - offset < sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t))
return false;
offset += sizeof(uint16_t); // majorVersion
offset += sizeof(uint16_t); // minorVersion
offset += sizeof(uint32_t); // metaOffset
offset += sizeof(uint32_t); // metaLength
offset += sizeof(uint32_t); // metaOrigLength
offset += sizeof(uint32_t); // privOffset
offset += sizeof(uint32_t); // privLength
// Check if the WOFF can supply as many tables as it claims it has.
if (woff->size() - offset < numTables * 5 * sizeof(uint32_t))
return false;
// Write the sfnt offset subtable.
uint16_t entrySelector = 0;
uint16_t searchRange = 1;
while (searchRange < numTables >> 1) {
entrySelector++;
searchRange <<= 1;
}
searchRange <<= 4;
uint16_t rangeShift = (numTables << 4) - searchRange;
if (!writeUInt32(sfnt, flavor)
|| !writeUInt16(sfnt, numTables)
|| !writeUInt16(sfnt, searchRange)
|| !writeUInt16(sfnt, entrySelector)
|| !writeUInt16(sfnt, rangeShift))
return false;
if (sfnt.size() > totalSfntSize)
return false;
if (totalSfntSize - sfnt.size() < numTables * 4 * sizeof(uint32_t))
return false;
size_t sfntTableDirectoryCursor = sfnt.size();
sfnt.grow(sfnt.size() + numTables * 4 * sizeof(uint32_t));
// Process tables.
for (uint16_t i = 0; i < numTables; ++i) {
// Read a WOFF table directory entry.
uint32_t tableTag;
if (!readUInt32(woff, offset, tableTag))
return false;
uint32_t tableOffset;
if (!readUInt32(woff, offset, tableOffset))
return false;
uint32_t tableCompLength;
if (!readUInt32(woff, offset, tableCompLength))
return false;
if (tableOffset > woff->size() || tableCompLength > woff->size() - tableOffset)
return false;
uint32_t tableOrigLength;
if (!readUInt32(woff, offset, tableOrigLength) || tableCompLength > tableOrigLength)
return false;
if (tableOrigLength > totalSfntSize || sfnt.size() > totalSfntSize - tableOrigLength)
return false;
uint32_t tableOrigChecksum;
if (!readUInt32(woff, offset, tableOrigChecksum))
return false;
// Write an sfnt table directory entry.
uint32_t* sfntTableDirectoryPtr = reinterpret_cast<uint32_t*>(sfnt.data() + sfntTableDirectoryCursor);
*sfntTableDirectoryPtr++ = htonl(tableTag);
*sfntTableDirectoryPtr++ = htonl(tableOrigChecksum);
*sfntTableDirectoryPtr++ = htonl(sfnt.size());
*sfntTableDirectoryPtr++ = htonl(tableOrigLength);
sfntTableDirectoryCursor += 4 * sizeof(uint32_t);
if (tableCompLength == tableOrigLength) {
// The table is not compressed.
if (!sfnt.tryAppend(woff->data() + tableOffset, tableCompLength))
return false;
} else {
uLongf destLen = tableOrigLength;
if (!sfnt.tryReserveCapacity(sfnt.size() + tableOrigLength))
return false;
Bytef* dest = reinterpret_cast<Bytef*>(sfnt.end());
sfnt.grow(sfnt.size() + tableOrigLength);
if (uncompress(dest, &destLen, reinterpret_cast<const Bytef*>(woff->data() + tableOffset), tableCompLength) != Z_OK)
return false;
if (destLen != tableOrigLength)
return false;
}
// Pad to a multiple of 4 bytes.
while (sfnt.size() % 4)
sfnt.append(0);
}
return sfnt.size() == totalSfntSize;
}
int TclModelBuilder_addRJWatsonEqsBearing(ClientData clientData,
Tcl_Interp *interp, int argc, TCL_Char **argv, Domain *theTclDomain,
TclModelBuilder *theTclBuilder, int eleArgStart)
{
// ensure the destructor has not been called
if (theTclBuilder == 0) {
opserr << "WARNING builder has been destroyed - RJWatsonEqsBearing\n";
return TCL_ERROR;
}
Element *theElement = 0;
int ndm = theTclBuilder->getNDM();
int ndf = theTclBuilder->getNDF();
int tag;
if (ndm == 2) {
// check plane frame problem has 3 dof per node
if (ndf != 3) {
opserr << "WARNING invalid ndf: " << ndf;
opserr << ", for plane problem need 3 - RJWatsonEqsBearing\n";
return TCL_ERROR;
}
// check the number of arguments is correct
if ((argc-eleArgStart) < 13) {
opserr << "WARNING insufficient arguments\n";
printCommand(argc, argv);
opserr << "Want: RJWatsonEqsBearing eleTag iNode jNode frnMdlTag kInit k2 k3 mu -P matTag -Mz matTag <-orient x1 x2 x3 y1 y2 y3> <-shearDist sDratio> <-doRayleigh> <-mass m> <-iter maxIter tol>\n";
return TCL_ERROR;
}
// get the id and end nodes
int iNode, jNode, frnMdlTag, matTag, argi, i, j;
int recvMat = 0;
double kInit, k2;
double k3 = 0.0;
double mu = 2.0;
double shearDistI = 1.0;
int doRayleigh = 0;
double mass = 0.0;
int maxIter = 25;
double tol = 1E-12;
double kFactUplift = 1E-6;
if (Tcl_GetInt(interp, argv[1+eleArgStart], &tag) != TCL_OK) {
opserr << "WARNING invalid RJWatsonEqsBearing eleTag\n";
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[2+eleArgStart], &iNode) != TCL_OK) {
opserr << "WARNING invalid iNode\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[3+eleArgStart], &jNode) != TCL_OK) {
opserr << "WARNING invalid jNode\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[4+eleArgStart], &frnMdlTag) != TCL_OK) {
opserr << "WARNING invalid frnMdlTag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
FrictionModel *theFrnMdl = OPS_getFrictionModel(frnMdlTag);
if (theFrnMdl == 0) {
opserr << "WARNING friction model not found\n";
opserr << "frictionModel: " << frnMdlTag << endln;
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[5+eleArgStart], &kInit) != TCL_OK) {
opserr << "WARNING invalid kInit\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[6+eleArgStart], &k2) != TCL_OK) {
opserr << "WARNING invalid k2\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[7+eleArgStart], &k3) != TCL_OK) {
opserr << "WARNING invalid k3\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[8+eleArgStart], &mu) != TCL_OK) {
opserr << "WARNING invalid mu\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
UniaxialMaterial *theMaterials[2];
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-P") == 0) {
theMaterials[0] = 0;
if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
opserr << "WARNING invalid matTag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
theMaterials[0] = OPS_getUniaxialMaterial(matTag);
if (theMaterials[0] == 0) {
opserr << "WARNING material model not found\n";
opserr << "uniaxialMaterial: " << matTag << endln;
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
recvMat++;
}
}
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-Mz") == 0) {
if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
opserr << "WARNING invalid matTag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
theMaterials[1] = OPS_getUniaxialMaterial(matTag);
if (theMaterials[1] == 0) {
opserr << "WARNING material model not found\n";
opserr << "uniaxialMaterial: " << matTag << endln;
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
recvMat++;
}
}
if (recvMat != 2) {
opserr << "WARNING wrong number of materials\n";
opserr << "got " << recvMat << " materials, but want 2 materials\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
// check for optional arguments
Vector x = 0;
Vector y = 0;
for (i = 9+eleArgStart; i < argc; i++) {
if (strcmp(argv[i],"-orient") == 0) {
j = i+1;
int numOrient = 0;
while (j < argc &&
strcmp(argv[j],"-shearDist") != 0 &&
strcmp(argv[j],"-doRayleigh") != 0 &&
strcmp(argv[j],"-mass") != 0 &&
strcmp(argv[j],"-iter") != 0 &&
strcmp(argv[j],"-kFactUplift") != 0) {
numOrient++;
j++;
}
if (numOrient == 6) {
argi = i+1;
x.resize(3);
y.resize(3);
double value;
// read the x values
for (j=0; j<3; j++) {
if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
opserr << "WARNING invalid -orient value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
} else {
argi++;
x(j) = value;
}
}
// read the y values
for (j=0; j<3; j++) {
if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
opserr << "WARNING invalid -orient value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
} else {
argi++;
y(j) = value;
}
}
}
else {
opserr << "WARNING insufficient arguments after -orient flag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
for (int i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-shearDist") == 0) {
if (Tcl_GetDouble(interp, argv[i+1], &shearDistI) != TCL_OK) {
opserr << "WARNING invalid -shearDist value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
for (int i = 9+eleArgStart; i < argc; i++) {
if (strcmp(argv[i], "-doRayleigh") == 0)
doRayleigh = 1;
}
for (int i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-mass") == 0) {
if (Tcl_GetDouble(interp, argv[i+1], &mass) != TCL_OK) {
opserr << "WARNING invalid -mass value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
for (int i = 9+eleArgStart; i < argc; i++) {
if (i+2 < argc && strcmp(argv[i], "-iter") == 0) {
if (Tcl_GetInt(interp, argv[i+1], &maxIter) != TCL_OK) {
opserr << "WARNING invalid maxIter\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[i+2], &tol) != TCL_OK) {
opserr << "WARNING invalid tol\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
for (int i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-kFactUplift") == 0) {
if (Tcl_GetDouble(interp, argv[i+1], &kFactUplift) != TCL_OK) {
opserr << "WARNING invalid kFactUplift\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
// now create the RJWatsonEqsBearing
theElement = new RJWatsonEQS2d(tag, iNode, jNode, *theFrnMdl, kInit, k2,
theMaterials, y, x, k3, mu, shearDistI, doRayleigh, mass,
maxIter, tol, kFactUplift);
if (theElement == 0) {
opserr << "WARNING ran out of memory creating element\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
// then add the RJWatsonEqsBearing to the domain
if (theTclDomain->addElement(theElement) == false) {
opserr << "WARNING could not add element to the domain\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
delete theElement;
return TCL_ERROR;
}
}
else if (ndm == 3) {
// check space frame problem has 6 dof per node
if (ndf != 6) {
opserr << "WARNING invalid ndf: " << ndf;
opserr << ", for space problem need 6 - RJWatsonEqsBearing \n";
return TCL_ERROR;
}
// check the number of arguments is correct
if ((argc-eleArgStart) < 17) {
opserr << "WARNING insufficient arguments\n";
printCommand(argc, argv);
opserr << "Want: RJWatsonEqsBearing eleTag iNode jNode frnMdlTag kInit k2 k3 mu -P matTag -T matTag -My matTag -Mz matTag <-orient <x1 x2 x3> y1 y2 y3> <-shearDist sDratio> <-doRayleigh> <-mass m> <-iter maxIter tol>\n";
return TCL_ERROR;
}
// get the id and end nodes
int iNode, jNode, frnMdlTag, matTag, argi, i, j;
int recvMat = 0;
double kInit, k2;
double k3 = 0.0;
double mu = 2.0;
double shearDistI = 1.0;
int doRayleigh = 0;
double mass = 0.0;
int maxIter = 25;
double tol = 1E-12;
double kFactUplift = 1E-6;
if (Tcl_GetInt(interp, argv[1+eleArgStart], &tag) != TCL_OK) {
opserr << "WARNING invalid RJWatsonEqsBearing eleTag\n";
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[2+eleArgStart], &iNode) != TCL_OK) {
opserr << "WARNING invalid iNode\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[3+eleArgStart], &jNode) != TCL_OK) {
opserr << "WARNING invalid jNode\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetInt(interp, argv[4+eleArgStart], &frnMdlTag) != TCL_OK) {
opserr << "WARNING invalid frnMdlTag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
FrictionModel *theFrnMdl = OPS_getFrictionModel(frnMdlTag);
if (theFrnMdl == 0) {
opserr << "WARNING friction model not found\n";
opserr << "frictionModel: " << frnMdlTag << endln;
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[5+eleArgStart], &kInit) != TCL_OK) {
opserr << "WARNING invalid kInit\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[6+eleArgStart], &k2) != TCL_OK) {
opserr << "WARNING invalid k2\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[7+eleArgStart], &k3) != TCL_OK) {
opserr << "WARNING invalid k3\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[8+eleArgStart], &mu) != TCL_OK) {
opserr << "WARNING invalid mu\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
UniaxialMaterial *theMaterials[4];
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-P") == 0) {
if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
opserr << "WARNING invalid axial matTag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
theMaterials[0] = OPS_getUniaxialMaterial(matTag);
if (theMaterials[0] == 0) {
opserr << "WARNING material model not found\n";
opserr << "uniaxialMaterial: " << matTag << endln;
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
recvMat++;
}
}
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-T") == 0) {
if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
opserr << "WARNING invalid torsional matTag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
theMaterials[1] = OPS_getUniaxialMaterial(matTag);
if (theMaterials[1] == 0) {
opserr << "WARNING material model not found\n";
opserr << "uniaxialMaterial: " << matTag << endln;
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
recvMat++;
}
}
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-My") == 0) {
if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
opserr << "WARNING invalid moment y matTag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
theMaterials[2] = OPS_getUniaxialMaterial(matTag);
if (theMaterials[2] == 0) {
opserr << "WARNING material model not found\n";
opserr << "uniaxialMaterial: " << matTag << endln;
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
recvMat++;
}
}
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-Mz") == 0) {
if (Tcl_GetInt(interp, argv[i+1], &matTag) != TCL_OK) {
opserr << "WARNING invalid moment z matTag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
theMaterials[3] = OPS_getUniaxialMaterial(matTag);
if (theMaterials[3] == 0) {
opserr << "WARNING material model not found\n";
opserr << "uniaxialMaterial: " << matTag << endln;
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
recvMat++;
}
}
if (recvMat != 4) {
opserr << "WARNING wrong number of materials\n";
opserr << "got " << recvMat << " materials, but want 4 materials\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
// check for optional arguments
Vector x(0);
Vector y(3); y(0) = 0.0; y(1) = 1.0; y(2) = 0.0;
for (i = 9+eleArgStart; i < argc; i++) {
if (strcmp(argv[i],"-orient") == 0) {
j = i+1;
int numOrient = 0;
while (j < argc &&
strcmp(argv[j],"-shearDist") != 0 &&
strcmp(argv[j],"-doRayleigh") != 0 &&
strcmp(argv[j],"-mass") != 0 &&
strcmp(argv[j],"-iter") != 0 &&
strcmp(argv[j],"-kFactUplift") != 0) {
numOrient++;
j++;
}
if (numOrient == 3) {
argi = i+1;
double value;
// read the y values
for (j=0; j<3; j++) {
if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
opserr << "WARNING invalid -orient value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
} else {
argi++;
y(j) = value;
}
}
}
else if (numOrient == 6) {
argi = i+1;
x.resize(3);
double value;
// read the x values
for (j=0; j<3; j++) {
if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
opserr << "WARNING invalid -orient value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
} else {
argi++;
x(j) = value;
}
}
// read the y values
for (j=0; j<3; j++) {
if (Tcl_GetDouble(interp, argv[argi], &value) != TCL_OK) {
opserr << "WARNING invalid -orient value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
} else {
argi++;
y(j) = value;
}
}
}
else {
opserr << "WARNING insufficient arguments after -orient flag\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-shearDist") == 0) {
if (Tcl_GetDouble(interp, argv[i+1], &shearDistI) != TCL_OK) {
opserr << "WARNING invalid -shearDist value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-doRayleigh") == 0)
doRayleigh = 1;
}
for (i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-mass") == 0) {
if (Tcl_GetDouble(interp, argv[i+1], &mass) != TCL_OK) {
opserr << "WARNING invalid -mass value\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
for (int i = 9+eleArgStart; i < argc; i++) {
if (i+2 < argc && strcmp(argv[i], "-iter") == 0) {
if (Tcl_GetInt(interp, argv[i+1], &maxIter) != TCL_OK) {
opserr << "WARNING invalid maxIter\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
if (Tcl_GetDouble(interp, argv[i+2], &tol) != TCL_OK) {
opserr << "WARNING invalid tol\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
for (int i = 9+eleArgStart; i < argc; i++) {
if (i+1 < argc && strcmp(argv[i], "-kFactUplift") == 0) {
if (Tcl_GetDouble(interp, argv[i+1], &kFactUplift) != TCL_OK) {
opserr << "WARNING invalid kFactUplift\n";
opserr << "singleFPBearing element: " << tag << endln;
return TCL_ERROR;
}
}
}
// now create the RJWatsonEqsBearing
theElement = new RJWatsonEQS3d(tag, iNode, jNode, *theFrnMdl, kInit, k2,
theMaterials, y, x, k3, mu, shearDistI, doRayleigh, mass,
maxIter, tol, kFactUplift);
if (theElement == 0) {
opserr << "WARNING ran out of memory creating element\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
return TCL_ERROR;
}
// then add the RJWatsonEqsBearing to the domain
if (theTclDomain->addElement(theElement) == false) {
opserr << "WARNING could not add element to the domain\n";
opserr << "RJWatsonEqsBearing element: " << tag << endln;
delete theElement;
return TCL_ERROR;
}
}
else {
opserr << "WARNING RJWatsonEqsBearing command only works when ndm is 2 or 3, ndm: ";
opserr << ndm << endln;
return TCL_ERROR;
}
// if get here we have sucessfully created the RJWatsonEqsBearing and added it to the domain
return TCL_OK;
}
JSBool js_StartPerf()
{
const char *outfile = "mozperf.data";
if (perfPid != 0) {
UnsafeError("js_StartPerf: called while perf was already running!\n");
return false;
}
// Bail if MOZ_PROFILE_WITH_PERF is empty or undefined.
if (!getenv("MOZ_PROFILE_WITH_PERF") ||
!strlen(getenv("MOZ_PROFILE_WITH_PERF"))) {
return true;
}
/*
* Delete mozperf.data the first time through -- we're going to append to it
* later on, so we want it to be clean when we start out.
*/
if (!perfInitialized) {
perfInitialized = true;
unlink(outfile);
char cwd[4096];
printf("Writing perf profiling data to %s/%s\n",
getcwd(cwd, sizeof(cwd)), outfile);
}
pid_t mainPid = getpid();
pid_t childPid = fork();
if (childPid == 0) {
/* perf record --append --pid $mainPID --output=$outfile $MOZ_PROFILE_PERF_FLAGS */
char mainPidStr[16];
snprintf(mainPidStr, sizeof(mainPidStr), "%d", mainPid);
const char *defaultArgs[] = {"perf", "record", "--append",
"--pid", mainPidStr, "--output", outfile};
Vector<const char*, 0, SystemAllocPolicy> args;
args.append(defaultArgs, ArrayLength(defaultArgs));
const char *flags = getenv("MOZ_PROFILE_PERF_FLAGS");
if (!flags) {
flags = "--call-graph";
}
// Split |flags| on spaces. (Don't bother to free it -- we're going to
// exec anyway.)
char *toksave;
char *tok = strtok_r(strdup(flags), " ", &toksave);
while (tok) {
args.append(tok);
tok = strtok_r(NULL, " ", &toksave);
}
args.append((char*) NULL);
execvp("perf", const_cast<char**>(args.begin()));
/* Reached only if execlp fails. */
fprintf(stderr, "Unable to start perf.\n");
exit(1);
}
else if (childPid > 0) {
perfPid = childPid;
/* Give perf a chance to warm up. */
usleep(500 * 1000);
return true;
}
else {
UnsafeError("js_StartPerf: fork() failed\n");
return false;
}
}
Matrix& Matrix::SetLookAtFrom(const Vector& vecAt, const Vector& vecFrom, const Vector& vecUp)
{
Vector vecZAxis = (vecFrom - vecAt).Normalize();
if (vecZAxis == vecUp) {
SetIdentity();
m_m[0][3] = vecFrom.X();
m_m[1][3] = vecFrom.Y();
m_m[2][3] = vecFrom.Z();
} else {
Vector vecXAxis = CrossProduct(vecUp, vecZAxis).Normalize();
Vector vecYAxis = CrossProduct(vecZAxis, vecXAxis);
m_m[0][0] = vecXAxis.X();
m_m[0][1] = vecYAxis.X();
m_m[0][2] = vecZAxis.X();
m_m[0][3] = vecFrom.X();
m_m[1][0] = vecXAxis.Y();
m_m[1][1] = vecYAxis.Y();
m_m[1][2] = vecZAxis.Y();
m_m[1][3] = vecFrom.Y();
m_m[2][0] = vecXAxis.Z();
m_m[2][1] = vecYAxis.Z();
m_m[2][2] = vecZAxis.Z();
m_m[2][3] = vecFrom.Z();
m_m[3][0] = 0;
m_m[3][1] = 0;
m_m[3][2] = 0;
m_m[3][3] = 1;
m_type = TransformRotate | TransformTranslate;
}
return *this;
}