bool CommandDeleteT::Do()
{
wxASSERT(!m_Done);
if (m_Done) return false;
// Deselect any affected elements that are selected.
m_CommandSelect->Do();
ArrayT<MapElementT*> DeletedElems;
for (unsigned long EntNr=0; EntNr<m_DeleteEnts.Size(); EntNr++)
{
m_MapDoc.Remove(m_DeleteEnts[EntNr]);
DeletedElems.PushBack(m_DeleteEnts[EntNr]);
}
for (unsigned long PrimNr=0; PrimNr<m_DeletePrims.Size(); PrimNr++)
{
m_MapDoc.Remove(m_DeletePrims[PrimNr]);
DeletedElems.PushBack(m_DeletePrims[PrimNr]);
}
// Update all observers.
m_MapDoc.UpdateAllObservers_Deleted(DeletedElems);
m_Done=true;
return true;
}
/* echo element connectivity data */
void SCNIMFT::DefineElements(const ArrayT<StringT>& block_ID, const ArrayT<int>& mat_index)
{
const char caller[] = "SCNIMFT::DefineElements";
//TEMP
if (block_ID.Length() > 1)
ExceptionT::GeneralFail(caller, "mutliple block ID's not supported %d",
block_ID.Length());
/* access to the model database */
ModelManagerT& model = ElementSupport().ModelManager();
fElementConnectivities.Dimension(1);
// NB THIS IS SPECIALIZED TO ONLY ONE ELEMENT BLOCK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
model.ReadConnectivity(block_ID[0]);
/* set pointer to connectivity list */
fElementConnectivities[0] = model.ElementGroupPointer(block_ID[0]);
// Get nodal coordinates
int nsd = NumSD();
fNodalCoordinates.Dimension(fNodes.Length(), nsd);
fNodalCoordinates.RowCollect(fNodes, model.Coordinates());
/* set up element cards for state variable storage */
fElementCards.Dimension(fNodes.Length()); /* one card per node */
for (int i = 0; i < fElementCards.Length(); i++)
fElementCards[i].SetMaterialNumber(mat_index[0]);
fCellGeometry->DefineElements(block_ID, mat_index);
}
TEATREE_FLATTEN
static void exec(moments_type& p, const moments_type& d, const ArrayT& r)
{
p.Oxxx += d.Oxxx + r*(-3*d.Qxx + r*(3*d.Dx - r*d.M));
p.Oxxy += d.Oxxy - r.yx()*d.Qxx
+ r*(-2*d.Qxy + 2*r.yx()*d.Dx + r*(d.Dx.yx()-r.yx()*d.M));
}
int InspectorDialogT::GetBestPage(const ArrayT<MapElementT*>& Selection) const
{
if (Selection.Size()==0)
{
// Nothing is selected, so just show the scene graph.
return 0;
}
else if (Selection.Size()==1)
{
MapElementT* MapElement=Selection[0];
return (MapElement->GetType()==&MapEntityT::TypeInfo) ? 1 : 2;
}
else
{
// Multiple map elements are selected.
// If we have only map primitives, open the Primitive Properties tab
// (even though it doesn't make much sense - primitive properties can be edited for a single item only).
// One or more entities in the selection cause us to open the Entitiy Properties tab.
bool HaveEntities=false;
for (unsigned long SelNr=0; SelNr<Selection.Size(); SelNr++)
{
MapElementT* MapElement=Selection[SelNr];
if (MapElement->GetType()==&MapEntityT::TypeInfo)
{
HaveEntities=true;
break;
}
}
return HaveEntities ? 1 : 2;
}
}
/*static*/ bool StateT::IsDeltaMessageEmpty(const ArrayT<uint8_t>& DeltaMessage)
{
if (DeltaMessage[0] == 1)
{
// Check the RLE-compressed delta message.
unsigned int i = 1;
while (i < DeltaMessage.Size())
{
const unsigned int N = DeltaMessage[i];
i++;
if (N < MAX_VERBATIM)
{
for (unsigned int Stop = i+N+1; i < Stop; i++)
if (DeltaMessage[i]) return false;
}
else
{
if (DeltaMessage[i]) return false;
i++;
}
}
}
else
{
// Check the uncompressed delta message.
for (unsigned int i = 1; i < DeltaMessage.Size(); i++)
if (DeltaMessage[i])
return false;
}
return true;
}
template<class T> ArrayT< Polygon3T<T> > Polygon3T<T>::GetSplits(const Plane3T<T>& SplitPlane, const T HalfPlaneThickness) const
{
const unsigned long FRONT=0;
const unsigned long BACK =1;
ArrayT< Polygon3T<T> > Result;
Result.PushBackEmpty(2);
Result[FRONT].Plane=this->Plane;
Result[BACK ].Plane=this->Plane;
if (!Vertices.Size()) return Result;
Vector3T<T> LastVertex=Vertices[Vertices.Size()-1];
double LastDist =SplitPlane.GetDistance(LastVertex);
for (unsigned long VertexNr=0; VertexNr<Vertices.Size(); VertexNr++)
{
const Vector3T<T>& ThisVertex=Vertices[VertexNr];
const double ThisDist =SplitPlane.GetDistance(ThisVertex);
if (ThisDist>HalfPlaneThickness)
{
if (LastDist<-HalfPlaneThickness)
{
Vector3T<T> Intersection=SplitPlane.GetIntersection(LastVertex, ThisVertex, 0);
Result[BACK ].Vertices.PushBack(Intersection);
Result[FRONT].Vertices.PushBack(Intersection);
}
else if (LastDist<=HalfPlaneThickness) Result[FRONT].Vertices.PushBack(LastVertex);
Result[FRONT].Vertices.PushBack(ThisVertex);
}
else if (ThisDist<-HalfPlaneThickness)
{
if (LastDist>HalfPlaneThickness)
{
Vector3T<T> Intersection=SplitPlane.GetIntersection(LastVertex, ThisVertex, 0);
Result[FRONT].Vertices.PushBack(Intersection);
Result[BACK ].Vertices.PushBack(Intersection);
}
else if (LastDist>=-HalfPlaneThickness) Result[BACK].Vertices.PushBack(LastVertex);
Result[BACK].Vertices.PushBack(ThisVertex);
}
else
{
if (LastDist> HalfPlaneThickness) Result[FRONT].Vertices.PushBack(ThisVertex);
else if (LastDist<-HalfPlaneThickness) Result[BACK ].Vertices.PushBack(ThisVertex);
}
LastVertex=ThisVertex;
LastDist =ThisDist;
}
return Result;
}
/* return the index the next receive */
void CommunicatorT::WaitReceive(const ArrayT<MPI_Request>& requests, int& index, int& source) const
{
const char caller[] = "CommunicatorT::WaitReceive";
Log(kModerate, caller, "waiting for 1 of %d", requests.Length());
index = source = -1;
#ifdef __TAHOE_MPI__
/* grab completed receive */
MPI_Status status;
int ret = MPI_Waitany(requests.Length(), (MPI_Request*) requests.Pointer(), &index, &status);
#ifdef CHECK_MPI_RETURN
if (ret != MPI_SUCCESS) Log(kFail, caller, "MPI_Waitany failed");
#endif
#ifdef CHECK_MPI_STATUS
if (status.MPI_ERROR != MPI_SUCCESS) Log(kFail, caller, "bad status: %d", status.MPI_ERROR);
#endif
source = status.MPI_SOURCE;
#endif
Log(kModerate, caller, "received request at index %d from %d", index, source);
}
// This function determines the adjacency cell graph of the 'SuperLeaves'.
// It is filled-in and stored in the 'Neighbours' members/components of the 'SuperLeaves'.
// After this function was called, all components of all 'SuperLeaves' are completely filled-in.
void DetermineAdjacencyGraph()
{
for (unsigned long SL1Nr=0; SL1Nr<SuperLeaves.Size(); SL1Nr++)
for (unsigned long SL2Nr=0; SL2Nr<SuperLeaves.Size(); SL2Nr++)
{
if (SL1Nr==SL2Nr || !SuperLeaves[SL1Nr].BB.GetEpsilonBox(MapT::RoundEpsilon).Intersects(SuperLeaves[SL2Nr].BB)) continue;
// Jedes Portal des ersten Leafs gegen jedes Portal des zweiten Leafs
// prüfen und testen, ob sie sich schneiden (dann sind sie durchlässig).
// BEACHTE: SuperLeaves haben *alle* Portale von *allen* ihrer Leaves!
// D.h. es können sich nicht nur Portale auf ihrer konvexen Hülle befinden, sondern auch "innen drin".
// Wegen der Konvexität der SuperLeaves dürfte das aber keine Rolle spielen und folgendes müßte trotzdem korrekt funktionieren.
for (unsigned long Portal1Nr=0; Portal1Nr<SuperLeaves[SL1Nr].Portals.Size(); Portal1Nr++)
for (unsigned long Portal2Nr=0; Portal2Nr<SuperLeaves[SL2Nr].Portals.Size(); Portal2Nr++)
{
if (!SuperLeaves[SL1Nr].Portals[Portal1Nr].Overlaps(SuperLeaves[SL2Nr].Portals[Portal2Nr], false, MapT::RoundEpsilon)) continue;
// Folgender Check ist zwar redundant, aber zumindest sinnvoll.
// Da diese Funktion sowieso schnell genug ist, lasse ihn nicht weg!
if (SuperLeaves[SL1Nr].Portals[Portal1Nr].WhatSide(SuperLeaves[SL2Nr].Portals[Portal2Nr].Plane, MapT::RoundEpsilon)!=Polygon3T<double>::InMirrored) continue;
ArrayT< Polygon3T<double> > NewPortals;
SuperLeaves[SL1Nr].Portals[Portal1Nr].GetChoppedUpAlong(SuperLeaves[SL2Nr].Portals[Portal2Nr], MapT::RoundEpsilon, NewPortals);
SuperLeaves[SL1Nr].Neighbours.PushBackEmpty();
SuperLeaves[SL1Nr].Neighbours[SuperLeaves[SL1Nr].Neighbours.Size()-1].SuperLeafNr=SL2Nr;
SuperLeaves[SL1Nr].Neighbours[SuperLeaves[SL1Nr].Neighbours.Size()-1].SubPortal =NewPortals[NewPortals.Size()-1];
}
}
printf("SLs Adjacency Graph : done\n");
}
bool CommandGroupSetPropT::Do()
{
wxASSERT(!m_Done);
if (m_Done) return false;
// Set the new property
// and notify all observers that our groups inventory changed.
switch (m_Prop)
{
case PROP_NAME: m_Group->Name=m_NewName; break;
case PROP_COLOR: m_Group->Color=m_NewColor; break;
case PROP_CANSELECT: m_Group->CanSelect=m_NewFlag; break;
case PROP_SELECTASGROUP: m_Group->SelectAsGroup=m_NewFlag; break;
}
m_MapDoc.UpdateAllObservers_GroupsChanged();
// If the elements in the group have changed color, update all observers accordingly.
if (m_Prop==PROP_COLOR)
{
const ArrayT<MapElementT*> GroupElems=m_Group->GetMembers(m_MapDoc);
if (GroupElems.Size()>0)
m_MapDoc.UpdateAllObservers_Modified(GroupElems, MEMD_GENERIC /*MEMD_VISIBILITY*/);
}
m_Done=true;
return true;
}
inline void StringToArray(LPCTSTR text, ArrayT & array, LPCTSTR separator = _T(""), bool trimSpaces = true)
{
CString search = text;
int seplen = CString(separator).GetLength();
while (true)
{
int idx = search.Find(separator);
if (idx == -1)
{
if (trimSpaces)
{
search.TrimLeft();
search.TrimRight();
}
if (!search.IsEmpty())
array.Add(search);
break;
}
CString part = search.Left(idx);
search.Delete(0, idx + seplen);
if (trimSpaces)
{
part.TrimLeft();
part.TrimRight();
}
if (!part.IsEmpty())
array.Add(part);
}
}
/* change the number of active element groups */
void ElementListT::SetActiveElementGroupMask(const ArrayT<bool>& mask)
{
/* first time */
if (fAllElementGroups.Length() == 0)
{
/* cache all pointers */
fAllElementGroups.Dimension(Length());
for (int i = 0; i < fAllElementGroups.Length(); i++)
{
ElementBaseT* element = (*this)[i];
fAllElementGroups[i] = element;
}
}
/* check */
if (mask.Length() != fAllElementGroups.Length())
ExceptionT::SizeMismatch("ElementListT::SetActiveElementGroupMask",
"expecting mask length %d not %d", fAllElementGroups.Length(), mask.Length());
/* reset active element groups */
int num_active = 0;
for (int i = 0; i < mask.Length(); i++)
if (mask[i])
num_active++;
/* cast this to an ArrayT */
ArrayT<ElementBaseT*>& element_list = *this;
element_list.Dimension(num_active);
num_active = 0;
for (int i = 0; i < mask.Length(); i++)
if (mask[i])
element_list[num_active++] = fAllElementGroups[i];
}
bool EditorChoiceWindowT::HandlePGChange(wxPropertyGridEvent& Event, GuiEditor::ChildFrameT* ChildFrame)
{
if (EditorWindowT::HandlePGChange(Event, ChildFrame)) return true;
const wxPGProperty* Prop =Event.GetProperty();
const wxString PropName=Prop->GetName();
if (PropName=="Choices")
{
ArrayT<std::string> NewStrings;
wxStringTokenizer Tokenizer(Prop->GetValueAsString(), "\r\n");
while (Tokenizer.HasMoreTokens())
NewStrings.PushBack(std::string(Tokenizer.GetNextToken()));
ChildFrame->SubmitCommand(new CommandSetWinPropT< ArrayT<std::string> >(m_GuiDoc, this, PropName, m_Choice->m_Choices, NewStrings));
return true;
}
if (PropName=="DefaultChoice")
{
wxASSERT(m_Choice->GetMemberVar("selectedChoice").Member!=NULL);
ChildFrame->SubmitCommand(new CommandModifyWindowT(m_GuiDoc, m_Choice, PropName, m_Choice->GetMemberVar("selectedChoice"), Prop->GetValue().GetLong()));
return true;
}
return false;
}
bool ToolEditSurfaceT::OnLMouseDown3D(ViewWindow3DT& ViewWindow, wxMouseEvent& ME)
{
const ArrayT<ViewWindow3DT::HitInfoT> Hits=ViewWindow.GetElementsAt(ME.GetPosition());
// Having this statement here means that the user absolutely cannot entirely clear the
// surfaces selection (in 3D views, it works in 2D views), but that is just fine - why would he?
if (Hits.Size()==0) return true;
MapElementT* Object =Hits[0].Object;
unsigned long FaceIndex=Hits[0].FaceNr;
if (m_EyeDropperActive)
{
ViewWindow.GetChildFrame()->GetSurfacePropsDialog()->EyeDropperClick(Object, FaceIndex);
return true;
}
if (!ME.ControlDown())
ViewWindow.GetChildFrame()->GetSurfacePropsDialog()->ClearSelection();
ViewWindow.GetChildFrame()->GetSurfacePropsDialog()->ToggleClick(Object, ME.ShiftDown() ? EditSurfacePropsDialogT::ALL_FACES : FaceIndex);
// When something is newly selected (Control is not down), its surface properties are also picked up.
if (!ME.ControlDown())
ViewWindow.GetChildFrame()->GetSurfacePropsDialog()->EyeDropperClick(Object, FaceIndex);
return true;
}
void CommandDeleteT::Undo()
{
wxASSERT(m_Done);
if (!m_Done) return;
ArrayT<MapElementT*> InsertedElems;
for (unsigned long PrimNr=0; PrimNr<m_DeletePrims.Size(); PrimNr++)
{
m_MapDoc.Insert(m_DeletePrims[PrimNr], m_DeletePrimsParents[PrimNr]);
InsertedElems.PushBack(m_DeletePrims[PrimNr]);
}
for (unsigned long EntNr=0; EntNr<m_DeleteEnts.Size(); EntNr++)
{
m_MapDoc.Insert(m_DeleteEnts[EntNr]);
InsertedElems.PushBack(m_DeleteEnts[EntNr]);
}
// Update all observers.
m_MapDoc.UpdateAllObservers_Created(InsertedElems);
// Select the previously selected elements again.
m_CommandSelect->Undo();
m_Done=false;
}
void SubjectT::UpdateAllObservers_Modified(IntrusivePtrT<cf::GuiSys::WindowT> Window, WindowModDetailE Detail, const wxString& PropertyName)
{
ArrayT< IntrusivePtrT<cf::GuiSys::WindowT> > Windows;
Windows.PushBack(Window);
UpdateAllObservers_Modified(Windows, Detail, PropertyName);
}
void MFPenaltyContact2DT::ComputeStrikerCoordinates(const ArrayT<int>& strikers)
{
/* dimension */
fStrikerCoords_man.SetMajorDimension(strikers.Length(), false);
/* current striker coords */
if (strikers.Length() > 0) {
/* reconstruct displacement field */
if (fSCNI) {
fSCNI_tmp = strikers;
if (!fSCNI->GlobalToLocalNumbering(fSCNI_tmp))
ExceptionT::GeneralFail("MFPenaltyContact2DT::ComputeStrikerCoordinates",
"SCNI global->local failed");
fSCNI->InterpolatedFieldAtNodes(fSCNI_tmp, fStrikerCoords);
}
else {
iArrayT tmp;
tmp.Alias(strikers);
fElementGroup->NodalDOFs(tmp, fStrikerCoords);
}
/* compute current coordinates */
const dArray2DT& init_coords = ElementSupport().InitialCoordinates();
for (int i = 0; i < strikers.Length(); i++)
fStrikerCoords.AddToRowScaled(i, 1.0, init_coords(strikers[i]));
}
}
void SubjectT::UpdateAllObservers_Deleted(IntrusivePtrT<cf::GuiSys::WindowT> Window)
{
ArrayT< IntrusivePtrT<cf::GuiSys::WindowT> > Windows;
Windows.PushBack(Window);
UpdateAllObservers_Deleted(Windows);
}
CommandSelectT::CommandSelectT(GuiDocumentT* GuiDocument, const ArrayT< IntrusivePtrT<cf::GuiSys::WindowT> >& OldSelection, const ArrayT< IntrusivePtrT<cf::GuiSys::WindowT> >& NewSelection)
: CommandT(abs(int(OldSelection.Size())-int(NewSelection.Size()))>3, false), // Only show selection command in the undo/redo history if selection difference is greater 3.
m_GuiDocument(GuiDocument),
m_OldSelection(OldSelection),
m_NewSelection(NewSelection)
{
}
/* free any uncompleted requests */
void CommunicatorT::FreeRequests(ArrayT<MPI_Request>& requests) const
{
#ifdef __TAHOE_MPI__
const char caller[] = "CommunicatorT::FreeRequests";
/* free any uncompleted receive requests */
for (int i = 0; i < requests.Length(); i++)
if (requests[i] != MPI_REQUEST_NULL)
{
Log(kLow, "caller", "cancelling request %d/%d", i+1, requests.Length());
/* cancel request */
MPI_Cancel(&requests[i]);
MPI_Status status;
MPI_Wait(&requests[i], &status);
int flag;
MPI_Test_cancelled(&status, &flag);
if (flag )
Log(kLow, "caller", "cancelling request %d/%d: DONE", i+1, requests.Length());
else
Log(kLow, "caller", "cancelling request %d/%d: FAIL", i+1, requests.Length());
}
#else
#pragma unused(requests)
#endif
}
CommandSelectT* CommandSelectT::Add(GuiDocumentT* GuiDocument, IntrusivePtrT<cf::GuiSys::WindowT> Window)
{
ArrayT< IntrusivePtrT<cf::GuiSys::WindowT> > AddSelection;
AddSelection.PushBack(Window);
return CommandSelectT::Add(GuiDocument, AddSelection);
}
/* block until all sends posted with CommunicatorT::PostSend have completed */
void CommunicatorT::WaitSends(const ArrayT<MPI_Request>& requests)
{
const char caller[] = "CommunicatorT::WaitSends";
Log(kModerate, caller, "waiting for 1 of %d", requests.Length());
/* complete all sends */
for (int i = 0; i < requests.Length(); i++)
{
int index = -1;
#ifdef __TAHOE_MPI__
/* grab completed receive */
MPI_Status status;
int ret = MPI_Waitany(requests.Length(), (MPI_Request*) requests.Pointer(), &index, &status);
#ifdef CHECK_MPI_RETURN
if (ret != MPI_SUCCESS) Log(kFail, caller, "MPI_Waitany failed");
#endif
#ifdef CHECK_MPI_STATUS
if (status.MPI_ERROR != MPI_SUCCESS) {
WriteStatus(Log(), caller, status);
Log(kFail, caller, "bad status: %d", status.MPI_ERROR);
}
#endif
#endif
Log(kLow, caller, "completing send at index %d", index);
}
}
CommandSelectT* CommandSelectT::Remove(GuiDocumentT* GuiDocument, IntrusivePtrT<cf::GuiSys::WindowT> Window)
{
ArrayT< IntrusivePtrT<cf::GuiSys::WindowT> > RemoveSelection;
RemoveSelection.PushBack(Window);
return CommandSelectT::Remove(GuiDocument, RemoveSelection);
}
void CommandTransformT::Undo()
{
wxASSERT(m_Done);
if (!m_Done) return;
if (m_DoClone)
{
m_CommandSelect->Undo();
// Remove cloned objects from world again.
for (unsigned long CloneNr=0; CloneNr<m_ClonedElems.Size(); CloneNr++)
m_MapDoc.Remove(m_ClonedElems[CloneNr]);
m_MapDoc.UpdateAllObservers_Deleted(m_ClonedElems);
}
else
{
// Record the previous bounding-boxes for the observer message.
ArrayT<BoundingBox3fT> OldBounds;
for (unsigned long ElemNr=0; ElemNr<m_TransElems.Size(); ElemNr++)
{
OldBounds.PushBack(m_TransElems[ElemNr]->GetBB());
m_TransElems[ElemNr]->Assign(m_OldStates[ElemNr]);
}
m_MapDoc.UpdateAllObservers_Modified(m_TransElems, MEMD_TRANSFORM, OldBounds);
}
m_Done=false;
}
uint32_t* SingleOpenGLWindowImplT::GetFrameBuffer(unsigned int& Width_, unsigned int& Height_)
{
static ArrayT<uint32_t> FrameBuffer;
FrameBuffer.Overwrite();
FrameBuffer.PushBackEmpty(Width*Height);
// Pixel vom BackBuffer in den FrameBuffer lesen.
// Beachte: Die ersten beiden Parameter (0, 0) spezifizieren die linke UNTERE Ecke des gewünschten Bereichs!
glReadPixels(0, 0, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, &FrameBuffer[0]);
Width_ =Width;
Height_=Height;
// Wie oben schon erwähnt, steht der 'FrameBuffer' leider auf dem Kopf.
// Vertausche daher alle Zeilen (vertikale Spiegelung).
for (unsigned int y=0; y<Height_/2; y++)
{
uint32_t* UpperRow=&FrameBuffer[0]+ y *Width_;
uint32_t* LowerRow=&FrameBuffer[0]+(Height_-y-1)*Width_;
for (unsigned int x=0; x<Width_; x++)
{
const uint32_t Swap=*UpperRow;
*UpperRow=*LowerRow;
*LowerRow=Swap;
UpperRow++;
LowerRow++;
}
}
return &FrameBuffer[0];
}
/* initialize the state variable array */
void MR_RP2DT::InitStateVariables(ArrayT<double>& state)
{
int num_state = NumStateVariables();
if (state.Length() != num_state) {
#ifndef _SIERRA_TEST_
cout << "\n SurfacePotentialT::InitStateVariables: expecting state variable array\n"
<< " length " << num_state << ", found length " << state.Length() << endl;
#endif
throw ExceptionT::kSizeMismatch;
}
/* clear */
if (num_state > 0) state = 0.0;
/* Initializing internal state variables */
double enp = state[14];
double esp = state[15];
double fchi = fchi_r + (fchi_p - fchi_r)*exp(-falpha_chi*enp);
double fc = fc_r + (fc_p - fc_r)*exp(-falpha_c*esp);
double ftan_phi = tan(fphi_r) + (tan(fphi_p) - tan(fphi_r))*exp(-falpha_phi*esp);
double ftan_psi = (tan(fpsi_p))*exp(-falpha_psi*esp);
state[6] = fchi;
state[7] = fc ;
state[8] = ftan_phi;
state[9] = ftan_psi;
state[13] = 0.;
state[nTiedFlag] = kTiedNode;
}
bool EngineEntityT::Repredict(const ArrayT<PlayerCommandT>& PlayerCommands, unsigned long RemoteLastIncomingSequenceNr, unsigned long LastOutgoingSequenceNr)
{
if (!UsePrediction.GetValueBool())
return false;
if (LastOutgoingSequenceNr-RemoteLastIncomingSequenceNr>PlayerCommands.Size())
{
EnqueueString("WARNING - Prediction impossible: Last ack'ed PlayerCommand is too old (%u, %u)!\n", RemoteLastIncomingSequenceNr, LastOutgoingSequenceNr);
return false;
}
/*
* This assumes that this method is immediately called after ParseServerDeltaUpdateMessage(),
* where the state of this entity has been set to the state of the latest server frame,
* and that every in-game packet from the server contains a delta update message for our local client!
*/
// Unseren Entity über alle relevanten (d.h. noch nicht bestätigten) PlayerCommands unterrichten.
// Wenn wir auf dem selben Host laufen wie der Server (z.B. Single-Player Spiel oder lokaler Client bei non-dedicated-Server Spiel),
// werden die Netzwerk-Nachrichten in Nullzeit (im Idealfall über Memory-Buffer) versandt.
// Falls dann auch noch der Server mit full-speed läuft, sollte daher immer RemoteLastIncomingSequenceNr==LastOutgoingSequenceNr sein,
// was impliziert, daß dann keine Prediction stattfindet (da nicht notwendig!).
for (unsigned long SequenceNr=RemoteLastIncomingSequenceNr+1; SequenceNr<=LastOutgoingSequenceNr; SequenceNr++)
Entity->ProcessConfigString(&PlayerCommands[SequenceNr & (PlayerCommands.Size()-1)], "PlayerCommand");
Entity->Think(-2.0, 0);
return true;
}
static void
TraceArray(JSTracer* trc, void* data)
{
ArrayT* array = static_cast<ArrayT *>(data);
for (unsigned i = 0; i < array->Length(); ++i)
JS_CallHeapObjectTracer(trc, &array->ElementAt(i), "array-element");
}
void SubjectT::UpdateAllObservers_Modified(IntrusivePtrT<cf::GuiSys::WindowT> Window, WindowModDetailE Detail)
{
ArrayT< IntrusivePtrT<cf::GuiSys::WindowT> > Windows;
Windows.PushBack(Window);
UpdateAllObservers_Modified(Windows, Detail);
}
void InspDlgEntityPropsT::OnContextMenuItemDelete(wxCommandEvent& event)
{
// Just in case the user pressed e.g. CTRL+Q (clear selection) in the meanwhile...
if (LastRightClickedProperty==NULL) return;
// Only handle deletes on properties that are not a category.
if (LastRightClickedProperty->IsCategory()) return;
// Key is not undefined (cannot be deleted).
if (LastRightClickedProperty->GetParent()!=UnDefKeys)
{
wxMessageBox("Only undefined keys can be deleted.");
return;
}
ArrayT<CommandT*> Commands;
for (unsigned long i=0; i<SelectedEntities.Size(); i++)
Commands.PushBack(new CommandDeletePropertyT(*MapDoc, SelectedEntities[i], LastRightClickedProperty->GetName()));
CommandT* MacroCommand=new CommandMacroT(Commands, "Delete Property '"+LastRightClickedProperty->GetName()+"'");
// Note that we also receive the update notification recursively (triggered by command execution in SubmitCommand()).
// This is intentional, or else we had to manually fix the PropMan, CombinedPropInfos, etc. here, which is error-prone.
// The complete recursive update is much less work and 100% safe, because it guarantees that no new bugs are introduced here.
MapDoc->GetHistory().SubmitCommand(MacroCommand);
}
void ClipWorldT::TraceRay(const Vector3dT& Start, const Vector3dT& Ray,
unsigned long ClipMask, const ClipModelT* Ignore, TraceResultT& Result, ClipModelT** HitClipModel) const
{
// Violation of this requirement is usually, but not necessarily, an error.
// If you ever get false-positives here, just remove the test entirely.
assert(Result.Fraction==1.0 && !Result.StartSolid);
if (HitClipModel) *HitClipModel=NULL;
// Try the trace against the WorldCollMdl first.
WorldCollMdl->TraceRay(Start, Ray, ClipMask, Result);
// if (Result.Fraction<OldFrac && HitClipModel) *HitClipModel=WorldCollMdl; // FIXME: WorldCollMdl is of type CollisionModelT...
if (Result.Fraction==0.0) return;
// Now try all the entity models.
ArrayT<ClipModelT*> ClipModels;
const BoundingBox3dT OverallBB(Start, Start+Ray*Result.Fraction);
GetClipModelsFromBB(ClipModels, ClipMask, OverallBB);
for (unsigned long ModelNr=0; ModelNr<ClipModels.Size(); ModelNr++)
{
ClipModelT* ClipModel =ClipModels[ModelNr];
const double OldFraction=Result.Fraction;
if (ClipModel==Ignore) continue;
ClipModel->TraceRay(Start, Ray, ClipMask, Result);
if (Result.Fraction<OldFraction && HitClipModel) *HitClipModel=ClipModel;
if (Result.Fraction==0.0) break;
}
}
