void EmuScreen::update(InputState &input) {
if (!booted_)
bootGame(gamePath_);
UIScreen::update(input);
// Simply forcibily update to the current screen size every frame. Doesn't cost much.
PSP_CoreParameter().outputWidth = dp_xres;
PSP_CoreParameter().outputHeight = dp_yres;
PSP_CoreParameter().pixelWidth = pixel_xres;
PSP_CoreParameter().pixelHeight = pixel_yres;
UpdateUIState(UISTATE_INGAME);
if (errorMessage_.size()) {
I18NCategory *g = GetI18NCategory("Error");
std::string errLoadingFile = g->T("Error loading file");
errLoadingFile.append(" ");
errLoadingFile.append(g->T(errorMessage_.c_str()));
screenManager()->push(new PromptScreen(
errLoadingFile, "OK", ""));
errorMessage_ = "";
return;
}
if (invalid_)
return;
float leftstick_x = 0.0f;
float leftstick_y = 0.0f;
float rightstick_x = 0.0f;
float rightstick_y = 0.0f;
// Virtual keys.
__CtrlSetRapidFire(virtKeys[VIRTKEY_RAPID_FIRE - VIRTKEY_FIRST]);
// Apply tilt to left stick
// TODO: Make into an axis
#ifdef USING_GLES2
if (g_Config.bAccelerometerToAnalogHoriz) {
// TODO: Deadzone, etc.
leftstick_x += clamp1(curve1(input.acc.y) * 2.0f) * g_Config.iTiltSensitivity / 100;
__CtrlSetAnalogX(clamp1(leftstick_x), CTRL_STICK_LEFT);
}
#endif
// Make sure fpsLimit starts at 0
if (PSP_CoreParameter().fpsLimit != 0 && PSP_CoreParameter().fpsLimit != 1) {
PSP_CoreParameter().fpsLimit = 0;
}
// This is here to support the iOS on screen back button.
if (pauseTrigger_) {
pauseTrigger_ = false;
screenManager()->push(new GamePauseScreen(gamePath_));
}
}
void EmuScreen::update(InputState &input) {
if (!booted_)
bootGame(gamePath_);
UIScreen::update(input);
// Simply forcibily update to the current screen size every frame. Doesn't cost much.
PSP_CoreParameter().outputWidth = dp_xres;
PSP_CoreParameter().outputHeight = dp_yres;
PSP_CoreParameter().pixelWidth = pixel_xres;
PSP_CoreParameter().pixelHeight = pixel_yres;
globalUIState = UISTATE_INGAME;
if (errorMessage_.size()) {
screenManager()->push(new PromptScreen(
"Error loading file: " + errorMessage_, "OK", ""));
errorMessage_ = "";
return;
}
if (invalid_)
return;
float leftstick_x = 0.0f;
float leftstick_y = 0.0f;
float rightstick_x = 0.0f;
float rightstick_y = 0.0f;
// Virtual keys.
__CtrlSetRapidFire(virtKeys[VIRTKEY_RAPID_FIRE - VIRTKEY_FIRST]);
// Apply tilt to left stick
if (g_Config.bAccelerometerToAnalogHoriz) {
// TODO: Deadzone, etc.
leftstick_x += clamp1(curve1(input.acc.y) * 2.0f);
__CtrlSetAnalogX(clamp1(leftstick_x), CTRL_STICK_LEFT);
}
// Make sure fpsLimit starts at 0
if (PSP_CoreParameter().fpsLimit != 0 && PSP_CoreParameter().fpsLimit != 1) {
PSP_CoreParameter().fpsLimit = 0;
}
// This is here to support the iOS on screen back button.
if (pauseTrigger_) {
pauseTrigger_ = false;
if (g_Config.bNewUI) {
screenManager()->push(new GamePauseScreen(gamePath_));
} else {
screenManager()->push(new PauseScreen());
}
}
}
void EmuScreen::update(InputState &input) {
globalUIState = UISTATE_INGAME;
if (errorMessage_.size()) {
screenManager()->push(new ErrorScreen(
"Error loading file",
errorMessage_));
errorMessage_ = "";
return;
}
if (invalid_)
return;
float leftstick_x = 0.0f;
float leftstick_y = 0.0f;
float rightstick_x = 0.0f;
float rightstick_y = 0.0f;
// Virtual keys.
__CtrlSetRapidFire(virtKeys[VIRTKEY_RAPID_FIRE - VIRTKEY_FIRST]);
// First translate touches into native pad input.
// Do this no matter the value of g_Config.bShowTouchControls, some people
// like to use invisible controls...
// Don't force on platforms that likely don't have a touchscreen, like Win32, OSX, and Linux...
// TODO: What are good ifdefs for OSX and Linux, without breaking other mobile platforms?
#ifdef _WIN32
if(g_Config.bShowTouchControls) {
#endif
// TODO: Make new better touch buttons so we don't have to do this crap.
// Copy over the mouse data from the real inputstate.
fakeInputState.mouse_valid = input.mouse_valid;
fakeInputState.pad_last_buttons = fakeInputState.pad_buttons;
fakeInputState.pad_buttons = input.pad_buttons;
memcpy(fakeInputState.pointer_down, input.pointer_down, sizeof(input.pointer_down));
memcpy(fakeInputState.pointer_x, input.pointer_x, sizeof(input.pointer_x));
memcpy(fakeInputState.pointer_y, input.pointer_y, sizeof(input.pointer_y));
fakeInputState.pad_lstick_x = 0.0f;
fakeInputState.pad_lstick_y = 0.0f;
fakeInputState.pad_rstick_x = 0.0f;
fakeInputState.pad_rstick_y = 0.0f;
UpdateGamepad(fakeInputState);
UpdateInputState(&fakeInputState);
for (size_t i = 0; i < ARRAY_SIZE(legacy_touch_mapping); i++) {
if (fakeInputState.pad_buttons_down & legacy_touch_mapping[i].from)
__CtrlButtonDown(legacy_touch_mapping[i].to);
if (fakeInputState.pad_buttons_up & legacy_touch_mapping[i].from)
__CtrlButtonUp(legacy_touch_mapping[i].to);
}
leftstick_x += fakeInputState.pad_lstick_x;
leftstick_y += fakeInputState.pad_lstick_y;
rightstick_x += fakeInputState.pad_rstick_x;
rightstick_y += fakeInputState.pad_rstick_y;
if (g_Config.bShowAnalogStick) {
__CtrlSetAnalogX(clamp1(leftstick_x), CTRL_STICK_LEFT);
__CtrlSetAnalogY(clamp1(leftstick_y), CTRL_STICK_LEFT);
}
__CtrlSetAnalogX(clamp1(rightstick_x), CTRL_STICK_RIGHT);
__CtrlSetAnalogY(clamp1(rightstick_y), CTRL_STICK_RIGHT);
// Also send the special buttons to input, since that's where they're handled.
input.pad_buttons_down |= fakeInputState.pad_buttons_down & (PAD_BUTTON_MENU | PAD_BUTTON_BACK | PAD_BUTTON_RIGHT_THUMB | PAD_BUTTON_LEFT_THUMB);
input.pad_buttons_up |= fakeInputState.pad_buttons_up & (PAD_BUTTON_MENU | PAD_BUTTON_BACK | PAD_BUTTON_RIGHT_THUMB | PAD_BUTTON_LEFT_THUMB);
input.pad_buttons = fakeInputState.pad_buttons;
#ifdef _WIN32
}
#endif
// Still checking input.pad_buttons here to support the onscreen throttle button.
PSP_CoreParameter().unthrottle = virtKeys[VIRTKEY_UNTHROTTLE - VIRTKEY_FIRST] ||
(input.pad_buttons & PAD_BUTTON_UNTHROTTLE) != 0;
// Apply tilt to left stick
if (g_Config.bAccelerometerToAnalogHoriz) {
// TODO: Deadzone, etc.
leftstick_x += clamp1(curve1(input.acc.y) * 2.0f);
__CtrlSetAnalogX(clamp1(leftstick_x), CTRL_STICK_LEFT);
}
// Make sure fpsLimit starts at 0
if (PSP_CoreParameter().fpsLimit != 0 && PSP_CoreParameter().fpsLimit != 1) {
PSP_CoreParameter().fpsLimit = 0;
}
// This is still here to support the iOS on screen back button.
if (input.pad_buttons_down & (PAD_BUTTON_BACK)) {
screenManager()->push(new PauseScreen());
}
}
void EmuScreen::update(InputState &input) {
globalUIState = UISTATE_INGAME;
if (errorMessage_.size()) {
screenManager()->push(new ErrorScreen(
"Error loading file",
errorMessage_));
errorMessage_ = "";
return;
}
if (invalid_)
return;
// First translate touches into native pad input.
// Do this no matter the value of g_Config.bShowTouchControls, some people
// like to use invisible controls...
// Don't force on platforms that likely don't have a touchscreen, like Win32, OSX, and Linux...
// TODO: What are good ifdefs for OSX and Linux, without breaking other mobile platforms?
#ifdef _WIN32
if(g_Config.bShowTouchControls) {
#endif
UpdateGamepad(input);
UpdateInputState(&input);
#ifdef _WIN32
}
#endif
// Then translate pad input into PSP pad input. Also, add in tilt.
static const int mapping[12][2] = {
{PAD_BUTTON_A, CTRL_CROSS},
{PAD_BUTTON_B, CTRL_CIRCLE},
{PAD_BUTTON_X, CTRL_SQUARE},
{PAD_BUTTON_Y, CTRL_TRIANGLE},
{PAD_BUTTON_UP, CTRL_UP},
{PAD_BUTTON_DOWN, CTRL_DOWN},
{PAD_BUTTON_LEFT, CTRL_LEFT},
{PAD_BUTTON_RIGHT, CTRL_RIGHT},
{PAD_BUTTON_LBUMPER, CTRL_LTRIGGER},
{PAD_BUTTON_RBUMPER, CTRL_RTRIGGER},
{PAD_BUTTON_START, CTRL_START},
{PAD_BUTTON_SELECT, CTRL_SELECT},
};
for (int i = 0; i < 12; i++) {
if (input.pad_buttons_down & mapping[i][0]) {
__CtrlButtonDown(mapping[i][1]);
}
if (input.pad_buttons_up & mapping[i][0]) {
__CtrlButtonUp(mapping[i][1]);
}
}
float stick_x = input.pad_lstick_x;
float stick_y = input.pad_lstick_y;
float rightstick_x = input.pad_rstick_x;
float rightstick_y = input.pad_rstick_y;
I18NCategory *s = GetI18NCategory("Screen");
// Apply tilt to left stick
if (g_Config.bAccelerometerToAnalogHoriz) {
// TODO: Deadzone, etc.
stick_x += clamp1(curve1(input.acc.y) * 2.0f);
stick_x = clamp1(stick_x);
}
__CtrlSetAnalog(stick_x, stick_y, 0);
__CtrlSetAnalog(rightstick_x, rightstick_x, 1);
if (PSP_CoreParameter().fpsLimit != 2) {
// Don't really need to show these, it's pretty obvious what unthrottle does,
// in contrast to the three state toggle
/*
if (input.pad_buttons_down & PAD_BUTTON_UNTHROTTLE) {
osm.Show(s->T("unlimited", "Speed: unlimited!"), 1.0, 0x50E0FF);
}
if (input.pad_buttons_up & PAD_BUTTON_UNTHROTTLE) {
osm.Show(s->T("standard", "Speed: standard"), 1.0);
}*/
}
if (input.pad_buttons & PAD_BUTTON_UNTHROTTLE) {
PSP_CoreParameter().unthrottle = true;
} else {
PSP_CoreParameter().unthrottle = false;
}
// Make sure fpsLimit starts at 0
if (PSP_CoreParameter().fpsLimit != 0 && PSP_CoreParameter().fpsLimit != 1 && PSP_CoreParameter().fpsLimit != 2) {
PSP_CoreParameter().fpsLimit = 0;
}
//Toggle between 3 different states of fpsLimit
if (input.pad_buttons_down & PAD_BUTTON_LEFT_THUMB) {
if (PSP_CoreParameter().fpsLimit == 0) {
PSP_CoreParameter().fpsLimit = 1;
osm.Show(s->T("fixed", "Speed: fixed"), 1.0);
}
else if (PSP_CoreParameter().fpsLimit == 1) {
PSP_CoreParameter().fpsLimit = 2;
osm.Show(s->T("unlimited", "Speed: unlimited!"), 1.0, 0x50E0FF);
}
else if (PSP_CoreParameter().fpsLimit == 2) {
PSP_CoreParameter().fpsLimit = 0;
osm.Show(s->T("standard", "Speed: standard"), 1.0);
}
}
if (input.pad_buttons_down & (PAD_BUTTON_MENU | PAD_BUTTON_BACK | PAD_BUTTON_RIGHT_THUMB)) {
if (g_Config.bBufferedRendering)
fbo_unbind();
screenManager()->push(new PauseScreen());
}
}
void EmuScreen::update(InputState &input) {
globalUIState = UISTATE_INGAME;
if (errorMessage_.size()) {
screenManager()->push(new ErrorScreen(
"Error loading file",
errorMessage_));
errorMessage_ = "";
return;
}
if (invalid_)
return;
// First translate touches into native pad input.
if (g_Config.bShowTouchControls)
UpdateGamepad(input);
UpdateInputState(&input);
// Then translate pad input into PSP pad input. Also, add in tilt.
static const int mapping[12][2] = {
{PAD_BUTTON_A, CTRL_CROSS},
{PAD_BUTTON_B, CTRL_CIRCLE},
{PAD_BUTTON_X, CTRL_SQUARE},
{PAD_BUTTON_Y, CTRL_TRIANGLE},
{PAD_BUTTON_UP, CTRL_UP},
{PAD_BUTTON_DOWN, CTRL_DOWN},
{PAD_BUTTON_LEFT, CTRL_LEFT},
{PAD_BUTTON_RIGHT, CTRL_RIGHT},
{PAD_BUTTON_LBUMPER, CTRL_LTRIGGER},
{PAD_BUTTON_RBUMPER, CTRL_RTRIGGER},
{PAD_BUTTON_START, CTRL_START},
{PAD_BUTTON_SELECT, CTRL_SELECT},
};
for (int i = 0; i < 12; i++) {
if (input.pad_buttons_down & mapping[i][0]) {
__CtrlButtonDown(mapping[i][1]);
}
if (input.pad_buttons_up & mapping[i][0]) {
__CtrlButtonUp(mapping[i][1]);
}
}
float stick_x = input.pad_lstick_x;
float stick_y = input.pad_lstick_y;
// Apply tilt
if (g_Config.bAccelerometerToAnalogHoriz) {
// TODO: Deadzone, etc.
stick_x += clamp1(curve1(input.acc.y) * 2.0f);
stick_x = clamp1(stick_x);
}
__CtrlSetAnalog(stick_x, stick_y);
if (input.pad_buttons & PAD_BUTTON_LEFT_THUMB) {
PSP_CoreParameter().unthrottle = true;
} else {
PSP_CoreParameter().unthrottle = false;
}
if (input.pad_buttons_down & (PAD_BUTTON_MENU | PAD_BUTTON_BACK | PAD_BUTTON_RIGHT_THUMB)) {
if (g_Config.bBufferedRendering)
fbo_unbind();
screenManager()->push(new PauseScreen());
}
}
void EmuScreen::update(InputState &input) {
globalUIState = UISTATE_INGAME;
if (errorMessage_.size()) {
screenManager()->push(new ErrorScreen(
"Error loading file",
errorMessage_));
errorMessage_ = "";
return;
}
if (invalid_)
return;
// First translate touches into native pad input.
// Do this no matter the value of g_Config.bShowTouchControls, some people
// like to use invisible controls...
UpdateGamepad(input);
UpdateInputState(&input);
// Then translate pad input into PSP pad input. Also, add in tilt.
static const int mapping[12][2] = {
{PAD_BUTTON_A, CTRL_CROSS},
{PAD_BUTTON_B, CTRL_CIRCLE},
{PAD_BUTTON_X, CTRL_SQUARE},
{PAD_BUTTON_Y, CTRL_TRIANGLE},
{PAD_BUTTON_UP, CTRL_UP},
{PAD_BUTTON_DOWN, CTRL_DOWN},
{PAD_BUTTON_LEFT, CTRL_LEFT},
{PAD_BUTTON_RIGHT, CTRL_RIGHT},
{PAD_BUTTON_LBUMPER, CTRL_LTRIGGER},
{PAD_BUTTON_RBUMPER, CTRL_RTRIGGER},
{PAD_BUTTON_START, CTRL_START},
{PAD_BUTTON_SELECT, CTRL_SELECT},
};
for (int i = 0; i < 12; i++) {
if (input.pad_buttons_down & mapping[i][0]) {
__CtrlButtonDown(mapping[i][1]);
}
if (input.pad_buttons_up & mapping[i][0]) {
__CtrlButtonUp(mapping[i][1]);
}
}
float stick_x = input.pad_lstick_x;
float stick_y = input.pad_lstick_y;
float rightstick_x = input.pad_rstick_x;
float rightstick_y = input.pad_rstick_y;
// Apply tilt to left stick
if (g_Config.bAccelerometerToAnalogHoriz) {
// TODO: Deadzone, etc.
stick_x += clamp1(curve1(input.acc.y) * 2.0f);
stick_x = clamp1(stick_x);
}
__CtrlSetAnalog(stick_x, stick_y, 0);
__CtrlSetAnalog(rightstick_x, rightstick_x, 1);
if (input.pad_buttons & PAD_BUTTON_UNTHROTTLE) {
PSP_CoreParameter().unthrottle = true;
} else {
PSP_CoreParameter().unthrottle = false;
}
// Make sure fpsLimit starts at 0
if (PSP_CoreParameter().fpsLimit != 0 && PSP_CoreParameter().fpsLimit != 1 && PSP_CoreParameter().fpsLimit != 2) {
PSP_CoreParameter().fpsLimit = 0;
}
//Toggle between 3 different states of fpsLimit
if (input.pad_buttons_down & PAD_BUTTON_LEFT_THUMB) {
if (PSP_CoreParameter().fpsLimit == 0){
PSP_CoreParameter().fpsLimit = 1;
}
else if (PSP_CoreParameter().fpsLimit == 1){
PSP_CoreParameter().fpsLimit = 2;
}
else if (PSP_CoreParameter().fpsLimit == 2){
PSP_CoreParameter().fpsLimit = 0;
}
}
if (input.pad_buttons_down & (PAD_BUTTON_MENU | PAD_BUTTON_BACK | PAD_BUTTON_RIGHT_THUMB)) {
if (g_Config.bBufferedRendering)
fbo_unbind();
screenManager()->push(new PauseScreen());
}
}
CRhinoCommand::result CGenPianoVis::RunCommand( const CRhinoCommandContext& context )
{
Cscript1PlugIn& plugin = script1PlugIn();
if( !plugin.IsDlgVisible() )
{
return CRhinoCommand::nothing;
}
/*GET THE LAYER NAME*/
CRhinoGetString gs;
gs.SetCommandPrompt( L"NAME OF LAYER WHICH CONTAINS VISIONAL PLANE : " );
gs.GetString();
if( gs.CommandResult() != CRhinoCommand::success )
{
return gs.CommandResult();
}
/*VALIDATE THE STRING*/
ON_wString layer_name = gs.String();
layer_name.TrimLeftAndRight();
if( layer_name.IsEmpty() )
{
return CRhinoCommand::cancel;
}
/*GET A REFERENCE TO THE LAYER TABLE*/
CRhinoLayerTable& layer_table = context.m_doc.m_layer_table;
/*FIND THE LAYER*/
int layer_index = layer_table.FindLayer(layer_name );
if( layer_index < 0 )
{
RhinoApp().Print( L"LAYER \"%s\" DOES NOT EXIST.\n", layer_name );
}
else
{
ON_Layer currentLayer;
int numLayers = layer_table.LayerCount();
layer_table.SetCurrentLayerIndex(layer_index);
for(int i = 0; i < numLayers; i++)
{
if(i != layer_index)
{
currentLayer = layer_table[i];
currentLayer.SetVisible(false);
layer_table.ModifyLayer(currentLayer, i);
}
}
context.m_doc.Redraw();
const CRhinoLayer& layer = context.m_doc.m_layer_table[layer_index];
ON_SimpleArray<CRhinoObject*> obj_list;
int object_count = context.m_doc.LookupObject( layer, obj_list );
if( object_count > 0 )
{
/********************************************************************/
//CRhinoObject* obj = obj_list[0];
//if( obj && obj->IsSelectable() )
//{
// obj->Select(true);
// obj->Highlight(true);
// m_doc.Redraw();
//}
/********************************************************************/
//aniello gegin
// Disable redrawing
//CRhinoView::EnableDrawing( FALSE ); meglio tenerlo disabilitato altrimenti la schermata non si aggiorna.
// Get the next runtime object serial number before scripting
unsigned int first_sn = CRhinoObject::NextRuntimeObjectSerialNumber();
//aniello end
/////////////////////
CRhinoGetObject gc;
gc.SetCommandPrompt( L"SELECT LINE TO EXTEND" );
gc.SetGeometryFilter( CRhinoGetObject::curve_object );
gc.GetObjects( 1, 1 );
if(gc.CommandResult() == CRhinoCommand::success )
{
const CRhinoObjRef& objref = gc.Object(0);
const ON_Curve* pC = ON_Curve::Cast( objref.Geometry() );
ON_Curve* crv0 = pC->DuplicateCurve();
bool rc0 = RhinoExtendCurve(crv0, CRhinoExtend::Line, 1, 5);
bool rc1 = RhinoExtendCurve(crv0, CRhinoExtend::Line, 0, 15);
context.m_doc.ReplaceObject(objref, *crv0 );
context.m_doc.Redraw();
///// begin prova memorizzazione id o name linea pv
////ON_UUID uuid1 = gc->Attributes().m_uuid;
//// ON_UUID uuid1 = objref.ObjectUuid();
// //ON_UuidToString( uuid1, cvrPrima );
// const CRhinoObject* obj5 = objref.Object();
// ON_UUID uuid1 = obj5->Attributes().m_uuid;
// pvcurva = uuid1;
// ON_3dmObjectAttributes obj_attribs = obj5->Attributes();
// CRhinoGetString gs;
//gs.SetCommandPrompt( L"New object name" );
//gs.SetDefaultString( obj_attribs.m_name );
//gs.AcceptNothing( TRUE );
//gs.GetString();
//if( gs.CommandResult() != CRhinoCommand::success )
// return gs.CommandResult();
//// Get the string entered by the user
//ON_wString obj_name = gs.String();
//obj_name.TrimLeftAndRight();
//// Is name the same?
//if( obj_name.Compare(obj_attribs.m_name) == 0 )
// return CRhinoCommand::nothing;
// //ON_wString obj_name = (L"stringanome");
// obj_attribs.m_name = obj_name;
// context.m_doc.ModifyObjectAttributes( objref, obj_attribs );
///// end prova memorizzazione id o name linea pv
ON_3dPoint p0 = crv0->PointAtStart();
ON_3dPoint p1 = crv0->PointAtEnd();
CRhinoGetNumber gn;
//double default_value = 30;
gn.SetCommandPrompt( L"ENTER ANTERIOR ANGLE FOR EXTENSION in grad: " );
gn.SetCommandPromptDefault(L"30");
gn.SetDefaultNumber(30);
//gn.AcceptNothing(true);
gn.GetNumber();
double alphaAngle = gn.Number();
gn.SetCommandPrompt( L"ENTER ANTERIOR LENGTH FOR EXTENSION in mm: " );
gn.SetCommandPromptDefault(L"80");
gn.SetDefaultNumber(80);
gn.GetNumber();
double antLen = gn.Number();
gn.SetCommandPrompt( L"ENTER ANTERIOR FILLET RADIUS in mm: " );
gn.SetCommandPromptDefault(L"6");
gn.SetDefaultNumber(6);
gn.GetNumber();
double antRad = gn.Number();
gn.SetCommandPrompt( L"ENTER POSTERIOR ANGLE FOR EXTENSION default <ALPHA + 10°= 40°> : " );
gn.SetCommandPromptDefault(L"40");
gn.SetDefaultNumber(40);
gn.GetNumber();
double betaAngle = gn.Number();
gn.SetCommandPrompt( L"ENTER POSTERIOR LENGTH FOR EXTENSION in mm: " );
gn.SetCommandPromptDefault(L"80");
gn.SetDefaultNumber(80);
gn.GetNumber();
double posLen = gn.Number();
gn.SetCommandPrompt( L"ENTER POSTERIOR FILLET RADIUS in mm: " );
gn.SetCommandPromptDefault(L"13");
gn.SetDefaultNumber(13);
gn.GetNumber();
double posRad = gn.Number();
ON_3dPoint pointStart;
ON_3dPoint pointEnd;
//// Fillet radius
//double radius = 1.0;
// Do the fillet calculation
double t0 = 0.0, t1 = 0.0;
ON_Plane plane;
plane.plane_equation.y = 1.0;
pointStart = crv0->PointAtStart();
pointEnd = crv0->PointAtEnd();
ON_3dPoint point0((pointStart.x - posLen*cos(betaAngle*acos(-1.0)/180.0)), 0.0, (pointStart.z + posLen*sin(betaAngle*acos(-1.0)/180.0)));
ON_3dPoint point1((pointEnd.x + antLen*cos(alphaAngle*acos(-1.0)/180.0)), 0.0, (pointEnd.z - antLen*sin(alphaAngle*acos(-1.0)/180.0)));
/**********************************/
/*CREATE THE LINE CURVES TO FILLET*/
/**********************************/
ON_LineCurve curve0( pointStart, point0 ); //LINEA A SINISTRA IN FRONT VIEW
ON_LineCurve curve1( point1, pointEnd ); //LINEA A DESTRA IN FRONT VIEW
/***************************************************/
/*FILLET AT THE END/START POINTS OF THE LINE CURVES*/
/***************************************************/
double curve0_t = crv0->Domain().Max();
double curve1_t = curve1.Domain().Min();
ON_3dPoint PuntoAltezzaTacco = curve1.m_line.to;
AltezzaTacco = PuntoAltezzaTacco;
if( RhinoGetFilletPoints(curve1, *crv0, antRad, curve1_t, curve0_t, t1, t0, plane) )
{
/*******************************/
/*TRIM BACK THE TWO LINE CURVES*/
/*******************************/
ON_Interval domain1( curve1.Domain().Min(), t1 );
curve1.Trim( domain1 );
ON_Interval domain0( crv0->Domain().Min(), t0 );
crv0->Trim( domain0 );
/**************************/
/*COMPUTE THE FILLET CURVE*/
/**************************/
ON_3dVector radial0 = curve1.PointAt(t1) - plane.Origin();
radial0.Unitize();
ON_3dVector radial1 = crv0->PointAt(t0) - plane.Origin();
radial1.Unitize();
double angle = acos( radial0 * radial1 );
ON_Plane fillet_plane( plane.Origin(), radial0, radial1 );
ON_Arc fillet( fillet_plane, plane.Origin(), antRad, angle );
/******************/
/*ADD THE GEOMETRY*/
/******************/
context.m_doc.AddCurveObject( curve1 );
context.m_doc.ReplaceObject(objref, *crv0 );
context.m_doc.AddCurveObject( fillet );
context.m_doc.Redraw();
}
t0 = 0.0, t1 = 0.0;
/*FILLET AT THE START POINTS OF THE LINE CURVES*/
curve0_t = crv0->Domain().Min();
curve1_t = curve0.Domain().Min();
if( RhinoGetFilletPoints(curve0, *crv0, posRad, curve1_t, curve0_t, t1, t0, plane) )
{
// Trim back the two line curves
ON_Interval domain0( t1, curve0.Domain().Max() );
curve0.Trim( domain0 );
ON_Interval domain1( t0, crv0->Domain().Max() );
crv0->Trim( domain1 );
/*COMPUTE THE FILLET CURVE*/
ON_3dVector radial0 = curve0.PointAt(t1) - plane.Origin();
radial0.Unitize();
ON_3dVector radial1 = crv0->PointAt(t0) - plane.Origin();
radial1.Unitize();
double angle = acos( radial0 * radial1 );
ON_Plane fillet_plane( plane.Origin(), radial0, radial1 );
ON_Arc fillet( fillet_plane, plane.Origin(), posRad, angle );
/*ADD THE GEOMETRY*/
context.m_doc.AddCurveObject( curve0 );
context.m_doc.ReplaceObject(objref, *crv0 );
context.m_doc.AddCurveObject( fillet );
context.m_doc.Redraw();
}
/******************/
/*CLEAN UP OR LEAK*/
/******************/
delete crv0;
crv0 = 0;
// code temp
// aniello begin
// Get the next runtime object serial number after scripting
unsigned int next_sn = CRhinoObject::NextRuntimeObjectSerialNumber();
// Enable redrawing
//CRhinoView::EnableDrawing( TRUE );
// if the two are the same, then nothing happened
/* if( first_sn == next_sn )
//return CRhinoCommand::nothing;
return;
*/ //commento questo per far compilare :-)
// The the pointers of all of the objects that were added during scripting
ON_SimpleArray<const CRhinoObject*> objects;
for( unsigned int sn = first_sn; sn < next_sn; sn++ )
{
const CRhinoObject* obj = context.m_doc.LookupObjectByRuntimeSerialNumber( sn );
if( obj && !obj->IsDeleted() )
objects.Append( obj );
}
/*
// Sort and cull the list, as there may be duplicates
if( objects.Count() > 1 )
{
objects.HeapSort( CompareObjectPtr );
const CRhinoObject* last_obj = objects[objects.Count()-1];
for( int i = objects.Count()-2; i >= 0; i-- )
{
const CRhinoObject* prev_obj = objects[i];
if( last_obj == prev_obj )
objects.Remove(i);
else
last_obj = prev_obj;
}
}
*/
// Do something with the list...
for( int i = 0; i < objects.Count(); i++ )
{
const CRhinoObject* obj = objects[i];
if( obj->IsSelectable(true) )
obj->Select( true );
}
//aniello end
//end code temp
/*********************/
/*JOIN LINES TOGETHER*/
/*********************/
ON_SimpleArray<const ON_Curve*> lines;
ON_SimpleArray<CRhinoObject*> objectsLine;
ON_SimpleArray<ON_Curve*> output;
double tolerance = context.m_doc.AbsoluteTolerance();
int LinesCount = context.m_doc.LookupObject( layer, objectsLine);
if( LinesCount > 0 )
{
for(int i = 0; i < LinesCount; i++)
{
const CRhinoCurveObject* curve_obj = CRhinoCurveObject::Cast( objectsLine[i] );
if( curve_obj )
{
lines.Append(curve_obj->Curve());
}
}
}
if( RhinoMergeCurves(lines, output, tolerance) )
{
for(int i = 0; i < output.Count(); i++ )
{
CRhinoCurveObject* crv = new CRhinoCurveObject;
crv->SetCurve( output[i] );
if( context.m_doc.AddObject(crv) )
{
crv->Select();
}
else
{
delete crv;
}
}
}
/************************/
/*DELETE CHILDREN CURVES*/
/************************/
for(int i = 0; i < LinesCount; i++ )
{
context.m_doc.DeleteObject(objectsLine[i]);
}
context.m_doc.Redraw();
/*************************/
/*END JOIN LINES TOGETHER*/
/*************************/
}
}/*CHIUSURA IF( OBJECT_COUNT > 0 )*/
}/*CHIUSURA ELSE*/
return CRhinoCommand::success;
}