Unterkategorien

• MFC

  Fragen zu den MFC (Microsoft Foundation Classes). WinForms haben mit MFC übrigens nichts zu tun.

  32670
  Themen
  172823
  Beiträge

  K

  @Finnegan sagte in Rail Road Tycoon MFC in Action: ht has Hallo Finnegan, du hast in deiner Antwort alle wesentlichen Punkte erkannt, das ist schon mal eine Hausnummer, ich versuche mal auf deine Hinweise zu Antworten: industriellen Visualisierungs-Engine Ja Die Engine mit shadern und Terraingenerations ist von mir seit 26 Jahren in der Entwicklung, sie basiert auf Glide (Heute) , und enthält die gesamte Visualisierung von Meshes mats lights und Netze Genrationen, die ist fähig alles abzubilden, und was nicht läuft ergänze ich dann entsprechend, gutes Zeichen ich muss sehr selten an der Engin arbeiten, die Anrufer der Engine haben also keine Ahnung was in dieser passiert, das ist gut weggekapselt. Chunks ein fixes LOD Das Chunksystem ist Dynamisch und passt sich der Netzgröße an, es hat 5 Stufen, und nur durch genaue Verteilung aller Chunks (in dem Fall viele hunderte) basieren immer auf einem 8ter System also chunksize zb 256 / 512 usw, auch das passiert volldynamisch. Sowie krumme Werte einspielen bekommst Du sogenannte gefürchtete Cracks im Gitter --) Hier mal der Creator der Crackfrei arbeitet. bool CGLchunk::Create(int Width, int Height, float SceneScale, bool bTexOn, bool bColOn, CGLfont* pFnt, CVertex* pVert, CVertex* pNorm, CTexvert* pTVert, CVertex* pColor, GLuint* pIdx, CGLShader* pShader) { Delete(); DWORD ti(GetTickCount()); m_ChunkSize = 256 + 2; //A128 + 4 + (LODS-2) DD to the normal 128 Chunk the extra Size of 2 (for inspect deeper into neighnbors !! m_Width = Width; m_Height = Height; m_pIdx = pIdx; m_SzeneScale = SceneScale; m_SceneSize = max(Width, Height) * SceneScale; m_pVert = pVert; m_pNorm = pNorm; m_pTVert = pTVert; m_pColor = pColor; m_pFnt = pFnt; m_pShader = pShader; m_SzeneMinZ = FLT_MAX; m_SzeneMaxZ = FLT_MIN; CVersions::DbgMsg(0, "CGLchunk::Create ChunkSize=%d SzeneSize=%d ChunksNeed=%d\n", m_ChunkSize, m_SceneSize, m_SceneSize / m_ChunkSize); for (int y = 0; y < Height; y += m_ChunkSize) { const int extraY((y + m_ChunkSize < Height) ? 1 : 0); int xChunk(m_ChunkSize + extraY); if (y + xChunk > Height) xChunk = Height - y; for (int x = 0; x < Width; x += m_ChunkSize) { const int extraX((x + m_ChunkSize < Width) ? 1 : 0); int yChunk(m_ChunkSize + extraX); if (x + yChunk > Width) yChunk = Width - x; TerrainChunk chunk; chunk.yStart = y; //if(chunk.yStart + chunk.height >= Height) || (chunk.xStart + chunk.width >= Width)) //TEST Debug check only border chunks chunk.xStart = x; chunk.height = xChunk; chunk.width = yChunk; const int indexTopLeft((y * Width) + x); const int indexBottomRight(((y + xChunk - 1) * Width) + (x + yChunk - 1)); chunk.MinX = m_pVert[indexTopLeft].x; chunk.MinY = m_pVert[indexTopLeft].y; chunk.MaxX = m_pVert[indexBottomRight].x; chunk.MaxY = m_pVert[indexBottomRight].y; chunk.MinZ = FLT_MAX; chunk.MaxZ = FLT_MIN; for (int r = 0; r < chunk.height; ++r) for (int c = 0; c < chunk.width; ++c) { const int globalIndex((chunk.yStart + r) * Width + (chunk.xStart + c)); const float z(m_pVert[globalIndex].z); if (z < chunk.MinZ) chunk.MinZ = z; if (z > chunk.MaxZ) chunk.MaxZ = z; if (z < m_SzeneMinZ)//need for frag shader texel tile m_SzeneMinZ = z; if (z > m_SzeneMaxZ)//need for frag shader texel tile m_SzeneMaxZ = z; } for (int level = 0; level < LODS; level++) //generate for each level an index grid { const int lodFactor(1 << level); chunk.startIndex[level] = (GLuint)m_GlobalIndices.size(); // Setze den Startindex im globalen Buffer for (int r = 0; r < chunk.height; r += lodFactor) for (int c = 0; c < chunk.width; c += lodFactor) { if ((chunk.yStart + r + lodFactor) >= Height || (chunk.xStart + c + lodFactor) >= Width) continue; const int topLeft = (chunk.yStart + r) * Width + (chunk.xStart + c); const int topRight = topLeft + lodFactor; const int bottomLeft = (chunk.yStart + r + lodFactor) * Width + (chunk.xStart + c); const int bottomRight = bottomLeft + lodFactor; m_GlobalIndices.push_back(topLeft); m_GlobalIndices.push_back(bottomLeft); m_GlobalIndices.push_back(topRight); m_GlobalIndices.push_back(bottomLeft); m_GlobalIndices.push_back(bottomRight); m_GlobalIndices.push_back(topRight); } chunk.indexCount[level] = (GLuint)m_GlobalIndices.size() - chunk.startIndex[level]; // Setze die Anzahl der Indices } chunk.center = CVertex(0.5f * (chunk.MinX + chunk.MaxX), 0.5f * (chunk.MinY + chunk.MaxY), 0.5f * (chunk.MinZ + chunk.MaxZ)); m_Chunks.push_back(chunk); } } CVersions::DbgMsg(true, "CGLchunk::Create InnertCalcTime=%f [s] \n", ((float)GetTickCount() - ti)/1000.0f); float ChunkLenght(m_ChunkSize * m_SzeneScale); for (int n(0); n < LODS; n++) //Generate a list with accurate distances to any chunk for camera based on each chunk Size m_LODThresholds[n] = ChunkLenght * (n + 1); //n+2 means nearby chunks full rendered //------------------------ Init Sahder Attributes and VBO's once here ------------------------------ m_Vbo.Create(pVert, pNorm, pColor, pTVert, m_GlobalIndices.data(), bTexOn, bColOn, Width * Height, m_GlobalIndices.size()); m_pShader->Enable(); if (bTexOn) { if (!Load4Textures()) return CVersions::DbgMsg(0, "CGLchunk::Create Failed load 4 Texels\n"); m_pShader->SetUniform1i("uWaterTex", 1); m_pShader->SetUniform1i("uGrassTex", 2); m_pShader->SetUniform1i("uRockTex", 3); m_pShader->SetUniform1i("uMountainTex", 4); m_pShader->SetUniform1f("uMinHeight", m_SzeneMinZ); m_pShader->SetUniform1f("uMaxHeight", m_SzeneMaxZ); float tile = 0.001f; m_pShader->SetUniform1f("uWaterTileFactor", tile); m_pShader->SetUniform1f("uGrassTileFactor", tile); m_pShader->SetUniform1f("uRockTileFactor", tile); m_pShader->SetUniform1f("uMountainTileFactor", tile); m_pShader->SetUniform1f("uFallbackStart", 5000.0f); m_pShader->SetUniform1f("uFallbackEnd", 20000.0f); m_pShader->SetUniform1i("uUseTexture", 1); } else { m_pShader->SetUniform1i("uUseTexture", 0); } m_pShader->SetAttributePointers(m_pVert, m_pNorm, m_pTVert, m_pColor, bTexOn); m_pShader->EnableAttributes(bTexOn); m_pShader->SetUniform3f("vLightPos", 0, 0, 50000.0f); m_pShader->SetUniform3f("uLightColor", 1, 1, 1); m_pShader->SetUniform3f("vViewPos", 0, 0, 0); m_pShader->Disable(); return CVersions::DbgMsg(true, "CGLchunk::Create CalcTime=%d\n", GetTickCount() - ti); } Heightmap-basierten Landschaftsrenderer Jo die Engine kann sowohl über HighMaps arbeiten, das kann ich hier optional Schalten, sogar Highmap kombiniert mit einer Passenden FarbTextur. Das Verfahren existiert parallel und ist teil meines 3DViews der Kamera Bilder in Echtzeit erzeugt, aber für das Spiel hier wird ein Netzverwendet dessen Größe ich in LuaSkript an die Engine übertrage zb 12000 Seitenlänge * 1000 dann habe ich genügend Rasterzellen die mit dem PerlinGenerator Hügelig gerechnet wird. die Höhen ergeben dann im sog. JetColorraum die Farben für nur Color Anzeige , bzw über die Shader lader ich dann wiederum 5 Texturen für jedes Z So entsteht eine Wellige Landschaft mit nur 5 kleinen Texturen 512*512 Damit wird dann das gesammte Terrain von der GRafikkarte im ShaderMode gerendert, und die Chunks handhaben die Auflösung dann automatisch im Shaderprogramm dem TexelMixer das läuft mit 1Khz Frameraten. Die Ränder der Scene im Shader haben tatsächlich kanten umbrüche, die befinden sich dann aber außerhalb der Skybox, man kann quasi entscheiden ob man Cracks in der Szene hat, oder eine Treppen form an den außenkannten die ja nicht stören da sie keiner sehen kann (Sphere SkyBox) #version 330 core /* ==================================================================== FLEXXRAIL SHADER: Fragment-Shader für Terrain (reduziert) ==================================================================== */ in vec3 FragPos; in vec3 Normal; in float vHeight; in vec3 VertexColor; in float isBillboard; in vec2 TexCoord; // neu: aus VS/GS übernommen out vec4 FragColor; uniform sampler2D uWaterTex, uGrassTex, uRockTex, uMountainTex; uniform float uWaterTileFactor, uGrassTileFactor, uRockTileFactor, uMountainTileFactor; uniform float uMinHeight, uMaxHeight; uniform bool uUseTexture; void main() { if (!uUseTexture || isBillboard > 0.5) { FragColor = vec4(VertexColor, 1.0); return; } // Höhe normieren float normH = clamp((vHeight - uMinHeight) / max(uMaxHeight - uMinHeight, 1e-6), 0.0, 1.0); // Layer-Gewichte (weich) float wWater = smoothstep(-0.03, 0.07, normH); float wGrass = smoothstep(0.18, 0.28, normH); float wRock = smoothstep(0.40, 0.50, normH); float wMount = smoothstep(0.65, 0.85, normH); // Projektive UVs: Worldspace-Planar mapping per dominanter Achse vec3 an = abs(Normal); vec2 uv = TexCoord; // fallback: aus VS if (an.x > an.y && an.x > an.z) uv = FragPos.yz; else if (an.y > an.z) uv = FragPos.xz; else uv = FragPos.xy; vec4 cWater = texture(uWaterTex, uv * uWaterTileFactor); vec4 cGrass = texture(uGrassTex, uv * uGrassTileFactor); vec4 cRock = texture(uRockTex, uv * uRockTileFactor); vec4 cMount = texture(uMountainTex, uv * uMountainTileFactor); vec4 mix1 = mix(cWater, cGrass, wWater); vec4 mix2 = mix(mix1, cRock, wGrass); vec4 mix3 = mix(mix2, cMount, wRock); FragColor = mix3; } Hah! Und das hüpfen der Lok. Das Video ist ziemlich alt, inzwischen fahren 200 Loks mit 1Khz bildrate auf den dynamisch gerenderten Tracks die mit dem VBO gestreamt werden, Basis bleiben die Kontrollpunkte die der User Erzeugt hat und Du sagst es es ist der Catmul Raum der hier massiv für 3D Splines verwendet wird. Den Link habe ich repariert, man kann die aktuelle Demo laden, und spielen lassen. Die Rotationen der Loks auf der Spline erfolgen mit unterschiedlichen Translationen, das ist hoch komplex der Spline 1:1 zu folgen , während deine Hauptkamera das betrachten muss lleicht kann man auch schauen ob die Schienen dabei die Unterseite der Lok berühren Nee das währe viel zu langsam, es folgt also den Kontrollpunkten mit entsprechenden Offsets, die spline zwischen den Kontrollpunkten wird bei der Fahrt tatsächlich ständig im Voraus berechnet, da ich auch Weichen folgen muss was die Hölle war, die Gleise speichern also das Netzwerk was mit was verbunden ist, und die Lok generiert asynchron über threads den neusten Fahrweg über das Kontrollpunkt Netzwerk. Kurve wirkt dann oft ein wenig "matschig". Ja also mit der Maus drop't der User automatisch beiom tracken diese Kontrollpunkte die einen gewissen pitch haben, der Mechanismus verhindert zb Hakenschläge oder 90° Richtungsänderungen, so entsteht durch das Kontrollpunkt System automatisch im Vorfeld das es keine Gleisbrüche durch unterschrittene Winkel gibt. Damit werden auch Bezieher Anschluss stellen erzeugt (Weichen) . automatisiert "glätten" und Koeffizienten Genau lässt der User den Tracking Kontrollmodus los, wird die Strecke sofort weich gerechnet Optimiert. "Überschwingen" Genau man muss wissen das der Catmull Algorithmus einem 5wer System unterliegt man also damit keine Strecken abbilden kann die nicht im Moduls 5 sind, macht man es kleiner wird es garstiger mit der Streuung, also das ist am ende alles Feinabgestimmt. Ein Heiden Aufwand. Aber vielleicht hast du ja ganz andere Prioritäten im Moment, Ja im Moment bin ich dabei die Codemenge zu reduzieren , unnütze Daten zu entfernen, und einen sauberen Editor herzustellen, das Projekt ist 10 RNA Stufen gesplittet RNA1 -10 Das sieht im Moment(1Jahr) etwa so aus: /* ================================================================================ SPLINE DOT SYSTEM - TRACK CONSTRUCTION & MANAGEMENT ================================================================================ STABILISIERUNGS-PHASE 1: Nur Verhalten sichern, keine Quer-Optimierungen. Aenderungen klein halten; nach jeder Aenderung Build + kurzer Interaktions-Test. AKTIONSPUNKT-ANKER (nur neben Aktionen in CPP, kurz/grepbar): // A1: Mutation (Rule #xx / RNAy) // A2: Guard/Abort (Rule #xx) // A3: Topology-Sync (RNA1/RNA2/RNA3/RNA5) INVARIANTEN (immer): EXAKTE Endpunkte (bit-identisch); Vorwaerts => neuer Host; Backtracking nur im aktiven Track; Switch nie verlaengern. ================================================================================ RNA UEBERSICHT (ACTIVE NETWORK ARCHITECTURE) ================================================================================ +------+----------------------------------+------------------+------------------+ | RNA | BESCHREIBUNG | DATEIEN | STATUS | +------+----------------------------------+------------------+------------------+ | RNA1 | Basis-Vernetzung | SplineObjFollow* | AKTIV | | | Endpunkt-zu-Endpunkt via | SplineTopology | | | | ConManager (fwd/bwd FragmentId) | | | +------+----------------------------------+------------------+------------------+ | RNA2 | Switch-Handling (Weichen) | SplineObjFollow* | AKTIV | | | Midpoint-Vernetzung via SnapIn | SplineDot | | | | TYPE_OPEN_TRK fuer Weichenstate | | | +------+----------------------------------+------------------+------------------+ | RNA3 | Signal-Handling (Dipper) | SplineDotSignal | AKTIV | | | Streckensignale, einseitig | SplineAccessory* | | | | TYPE_SIGNAL_TRK + TYPE_OPEN_TRK | | | +------+----------------------------------+------------------+------------------+ | RNA4 | Geometrie-Generierung | TrackUtil | AKTIV | | | Prellboecke, Single<->Double | SplineDot | | | | Uebergaenge, Piller | | | +------+----------------------------------+------------------+------------------+ | RNA5 | Terminal-Handling (Bahnhoefe) | SplineDotTerminal| AKTIV | | | Gauge-Signale (A+B), Face-to-Face| SplineAccessory* | | | | TYPE_TERMINAL_TRK + SIG_A/SIG_B | | | +------+----------------------------------+------------------+------------------+ | RNA6 | Verkehr & Kollisionen auf Track | GLSceneTraffic | AKTIV | | | Disaster nur gleiche phys. Spur | | TRAFFIC_DISASTER | | | Lua-Event flags=8 | | =1 (aktiv) | +------+----------------------------------+------------------+------------------+ KURZFORM: RNA1 = Gleise verbinden (ConManager, forwardFragmentId/backwardFragmentId) RNA2 = Weichen (Switch Entry/Exit, TYPE_OPEN_TRK fuer Stellung) RNA3 = Dipper-Signale (Streckensignale, TYPE_SIGNAL_TRK) RNA4 = Geometrie (Prellboecke, Single<->Double Uebergaenge) RNA5 = Terminals (Bahnhoefe mit Face-to-Face Signallogik) RNA6 = Verkehr (Spurfilter, Bremsen, Disaster bei gleicher physischer Spur) ================================================================================ SPLINE INTERAKTIONEN - REGELWERK ================================================================================ Hinweis: Spline-Fusion ist nicht aktiv. Geschlossene Loops werden als TRACK_LOOPED behandelt. Alle Punkte beschreiben den aktuellen Ist-Zustand. 1) Track-Cursor & Simulation: - Track startet an frei selektiertem Start-/Endpunkt einer offenen Spline oder frei im Raum. - Wird ein End-/Startpunkt gegriffen, genau dieser Punkt wird erster Trackeintrag; Original-Host wird temporaer entfernt. - Punkte folgen Maus live; Commit manuell (Button Up) oder automatisch bei Distanzlimit; Backtracking bis nur 1 Punkt => verwerfen. 2) Start-/Endpunkt vs. mittlerer Kontrollpunkt: - Nur Endpunkte dienen als Anknuepfung fuer Fortsetzung; Mittelpunkte koennen nicht zum Start promotiert werden. - Mittelpunkte erlauben nur Verschiebung innerhalb begrenzter Amplitude / Projektion (siehe Regel 6). - Host wird beim Fortsetzen aus Endpunkt aus Liste geloest bis Commit (Konsistenz, kein Doppel). 3) Snap-In (nur visuell): - Andocken fuehrt keine strukturelle Verschmelzung durch; Track bleibt separater Host nach Commit. - Snap darf nicht ausgeloest werden bei Rueckbau-Intent, Startpunkt, Near-Duplicate oder erreichten MAXTRKDIST. - Reihenfolge der Prioritaeten: Backtracking vor Snap vor Auto-Segment (siehe 24). 4) Optimize (Taste O): - Fuehrt Spline::Optimize mit Laengentoleranz durch, entfernt lineare Ueberfluessige und glättet Verlauf. - Setzt update=true (VBO Rebuild) sowie optDirty/curvedDirty zur spaeteren Anzeigeaktualisierung. - Kurven-Stuetzpunkte koennen nach Optimize erneut synthetisch eingefuegt werden (Regel 9 / 14). 5) Winkel-Latch (MINCURANG): - Wird MINCURANG ueberschritten setzt m_BadAngleLatch Aufnahme-Stopp (stabilisiert gegen Zickzack / Ruecksprung). - Entlatch bei Rueckkehr unter MINCURANG * 0.85, Basisrichtung aktualisiert sobald Vorwaertsprojektion > 0. - Latch interagiert mit Backtracking (Regel 25) indem Rueckbau die Winkelbasis ungueltig macht. 6) Verschieben mittlerer Kontrollpunkte: - Projektion auf Achse zwischen Nachbarn limitiert durch radiale Schutzsphaeren (RADSPHERE) und Mindest-Abstaende. - Orthogonale Amplitude wird gekapt (allowedAmplitude) adaptiv nach Segmentlaengen + ctrlAmpMul + CTRLAMPFACT. - Projektion ausserhalb Sicherheitsfenster oder unzulaessige Verkuerzung => Bewegung verworfen (keine Mutation). 7) Backtracking: - Rueckwaertsbewegung (projDist < Segmentende) entfernt letzte Punkte iterativ solange Bedingung anhalt. - Seitliche Abweichung (latSq) wird toleriert nur innerhalb Threshold (DOTPITCH_06_SQ) falls kein expliziter Rueckintent. - Nach Reduktion wird Referenzrichtung neu gesetzt, Latch zurueckgesetzt und Winkelbasis als unset markiert. 8) Track-Limit (MAXTRKDIST): - Erreicht Distanz Start->Cursor MAXTRKDIST => Auto-Commit des aktuellen Tracks (Segmentierung fuer Performance/Budget). - Neuer Track startet sofort mit letztem Endpunkt & m_RefDir (letztes Segment) fuer kontinuierliche Richtung. - Backtracking unterbricht Auto-Limit; Snap ist waehrend Limit-Trigger blockiert (Intent Vorrang). 9) Kurven-Stuetzpunkte (deaktiviert): - Historisch: Spline::IsCurved basierte Stuetzpunkteinfügung (Vor-/Nachlauf) bei Distanzfenster. - Aktuell: Optimizer löscht keine Kontrollpunkte mehr, daher keine zusätzliche Stuetzpunkteinfügung. - Cleanup entfällt. 10) Spline/VBO Update: - Bei update=true: HostSpline neu generiert (SPLINERES) & fragment VBO rekonstruiert; danach update=false. - Opt/Curved Dirty Flags veranlassen spaetere On-Demand Anzeige (Prozent & Kurvenmarkierung) ohne Rebuild. - Kein Redo solange keine Hostmutation (Punkte / Typ) oder Sichtbarkeitswechsel erfolgt. 11) Auswahl: - Keine Auswahl wenn (m_SelDot==0 && m_SelSpline==-1); Endpunkt-Fortsetzung setzt m_SelSpline temporaer -1. - Commit oder Abbruch (Backtracking bis 1 Punkt) ruft ClearSelect zwecks Zustand Reset auf. - Mittelpunktauswahl fuer Move prueft Typ-/Moduskompatibilitaet (BASE_TYPE_MISMATCH). 12) Sortierung: - Hosts werden in Folge minimaler Endpunktdistanz verkettet (Nearest-Neighbour Sequenz) mit optionalem Reverse. - Bei Nachbarnaehe < ALIGN_MAX_DIST erfolgt Ausrichtung (Translate/Rotate) ohne Merge / Dup-Elimination. - Nach Sortierung erfolgt AlignSortedSplines fuer glattere Uebergaenge (Dir Toleranz + Distanzkriterien). 13) Uebergangsverfeinerung: - m_TrackNeighbor Marker liefert anfangs m_RefDir fuer Startwinkel-Bewertung und Latch-Hysterese. - Erlaubt sanftere Anfahrtsphasen (verhindert zu fruehes Latch bei minimalem ersten Segment). - Wird beim Fortsetzen aus Host-Endpunkt gesetzt (Nachbar = zweiter Punkt). 14) Punkt-Reduktion: - ValidateTrack entfernt Near-Duplicates / sehr kurze Segmente bevor Optimize arbeitet (Qualitaet Filter). - Optimize reduziert lineare Ketten behält Kurven- u. Nachlaufbereiche; later Supportpunkte ggf. reinsert. - Ergebnis host.dots ersetzt Eingangsliste (swap) fuer minimale Kopiekosten. 15) Guard-Zonen: - Naehe zum Start (CLOSE_GUARD_SQ) oder Selbstannäherung (SELF_APPROACH_SQ) aktiviert Guard (dichtere Sampling Steps). - Guard reduziert stepSize (0.75 Faktor) in PlaceStandardPoints zum Stabilisieren frischer Kurven / enger Passagen. - Verhindert Zickzack durch zu große erste Schritte und Kreuzungen bei Ruecknaeherung. 16) Performance: - VBO Rebuild strikt an update Flag; Linien-Overlay nutzt HostSpline Cache (leichtgewichtige Vertexliste). - Angle / Optimize Prozent Lazy Evaluation (optDirty / curvedDirty) reduziert Berechnungen pro Frame. - Auto-Segmentierung (Regel 8) begrenzt Host-Laenge fuer bessere Frustum-Culling Granularitaet. 17) Persistenz: - hostlist.bin speichert: Anzahl Hosts, Punktanzahl, Punkte (CVertex Raw), update-Flag, Typ (Version >=2) + Mapping. - Version 8: Speichert forwardFragmentId und backwardFragmentId fuer Connection-Persistenz. - Laden erzeugt sofort VBO + HostSpline (update=false) und setzt Dirty Flags fuer Anzeige. 18) Stabilisierung: - Fortgesetzter Host wird nicht dupliziert sondern entfernt bis Abschluss (verhindert Inkonsistenzen / Doppelrender). - Backtracking nach Wiederaufnahme erzeugt keinen neuen Host sondern modifiziert laufenden Track. - Latch Reset & Richtungsbasis Handling nach Rueckbau verhindert Winkelsprung. 19) Weichen-Erzeugung: - Nach Commit: Distanz vom neuen Track-Ende zu Nicht-Endpunkt eines Fremd-Hosts <= DOTSEARCHRADIUS => Switch Host. - TYPE_SWITCH_TRK markiert Sondergeometrie (Ausschluss aus Optimize, Regel 20) und getrennte Verarbeitung. - rawTargetIdx Auswahl spaeter fuer Tangenten (Regel 21) im inneren Bereich (keine Randpunkte). 20) Switch & Optimize: - TYPE_SWITCH_TRK Hosts von Spline::Optimize ausgeschlossen (bewahrt kritische Abzweig-Stuetzpunkte). - Normale Single/Double Hosts werden optimiert fuer geringere Punktlast. - Switch Flags bleiben stabil bei Sortierung / Persistenz (Regel 27). 21) Switch-Zielwahl (DetermineTargetIdx): - Richtung basierend auf Anflugrichtung UND Host-Geometrie (beide Seiten pruefen). - Eindringtiefe dynamisch: 3-5 Steps je nach verfuegbarem Platz und Kruemmung. - Fallback zu anderer Richtung wenn gewaehlte Seite blockiert ist. - Minimum 3 Steps, Maximum durch maxPossible begrenzt. 22) Bezier Handles (BuildBezier): - Handle-Laenge: 0.40 * Distanz, skaliert mit Winkel, Clamp [1.5..3.5]*DOTPITCH. - Lateraler Offset seitenvalidiert (kein Durchdringen / Mindestabstand >=0.35*DOTPITCH). - Handles adaptiert bei enger Kurve um Ueberziehung / Selbstschneiden zu vermeiden. 23) Bezier Sampling: - Adaptives Parameter t Inkrement (TTSTEP Basis) bis segmentlaengenkriterium >= DOTPITCH erreicht oder Ende. - Fruehphase prueft Clearance gegen Host (keine Selbstkollision) vor Punktannahme. - Abschluss bereinigt zu dicht liegende Schlusssegmente fuer gleichmaessige Verteilung. 24) Snap-Prioritaet: - Prioritaet strikt: Backtracking > Snap > Auto-Segmentierung fuer klare Benutzerintention. - Snap wird nur evaluiert falls kein Rueckintent & Budget nicht ueberschritten & kein Near-Duplicate. - Auto-Segmentierung final nur ohne Snap/Backtracking Trigger in diesem Tick. 25) Angle-Latch & Backtracking: - Rueckbau invalidiert Winkelbasis (AngleBaseUnset) wodurch erste Vorwaertsbewegung Basis neu bestimmt. - Latch (m_BadAngleLatch) bleibt aktiv bis Winkelprojektion wieder innerhalb Hysterese (MINCURANG*0.85). - Verhindert Zickzack / sofortige Re-Latch Schleifen nach Korrekturbewegung. 26) Auto-Segment Neustart: - Nach Limit-Commit Startpunkt = altes Ende, m_RefDir = letztes Segment (kohärente Richtungskontinuitaet). - Winkelbasis neu initialisiert sobald ausreichend Vorwaertsschritt laenger als EPS erfolgt. - Verhindert Ausrichtungsspruenge im aufeinanderfolgendem Segmentfluss. 27) Switch Persistenz: - Weichen-Typ Flags dauerhaft (kein Downgrade durch Optimize / Sort / Persistenzmapping). - Keine automatische Punktverdichtung auf Switch Hosts zur Wahrung exakter Abzweig Geometrie. - Kurven-Flags bei Switch ebenfalls lazy neu generiert (curvedDirty) nach Mutationen. 28) Track-Limit Darstellung: - Kein visuelles Overlay fuer Limit (Reduktion visueller Komplexitaet / Fokus auf Cursor Feedback). - Logische Segmentierung steuert Speicher, Culling and Performance statt UI Indikatoren. - Limitpruefung vergleicht Start->Cursor Distanz (MAXTRKDIST_SQ) (Quadratvergleich ohne sqrt). 29) Connected-Index (geplant, noch inaktiv): - Spatial-Manager für verbundene Splines vorgesehen. 30) Weichen-Schalter (ToggleSwitchAt) [RNA2]: - Zur Laufzeit: Klick auf Switch-Cube toggelt TYPE_OPEN_TRK im host.type. - Suche: Iteration ueber alle Hosts mit TYPE_SWITCH_TRK. - Effekt: TYPE_OPEN_TRK bestimmt ob Lok in Switch einfahren darf. - VBO: Nach Toggle wird GenerateVbo aufgerufen (Farbe Gruen/Rot). 31) Signal-Schalter (ToggleSignalAt) [RNA3]: - Zur Laufzeit: Klick auf Signal-Box toggelt TYPE_OPEN_TRK. - Suche: Iteration ueber normale Hosts und deren m_SignalBoxes. - Effekt: Synchronisiert Flag in SnapIn (Logik) und Signal-Host (Optik). 32) Klick-Priorisierung (HandleSplines): - Nicht-Konstruktions-Modus: Mausklick prueft erst Switch, dann Signal. - Reihenfolge: if (!ToggleSwitchAt(pos)) ToggleSignalAt(pos); 33) RNA3 Signal-Editor (Modus): - Aktiv wenn g_InpMgr.GetSignalMode() != 0. - Phantom-Signal: RenderSignalCursor zeigt Vorschau. - Platzierung: Erzeugt SnapIn am Gleis UND separaten Signal-Host. 34) RNA3 Signal-Loeschung (DEL): - Taste DEL im Signal-Modus entfernt SnapIn UND Signal-Host. 35) RNA4 Prellbock (TYPE_PILLER_TRK): - Automatische Erkennung: forwardFragmentId==-1 ODER backwardFragmentId==-1. - Connection-IDs: Werden zentral in FindConnections() aufgebaut. 36) RNA4 Prellbock-Geometrie (GeneratePiller): - Position: Am Gleisende, versetzt um 3 * SLEEPER_PITCH. - Struktur: Klassischer Prellboecke mit 45-Grad Hypotenuse. 37) RNA4 Connection-Logik (FindConnections): - IDs werden nach jeder Topologieaenderung zentral aus exakten Endpunkten aufgebaut. - Switch-IDs bleiben autoritativ; normale Gegenreferenzen werden im selben Pipeline-Schritt synchronisiert. 38) RNA4 Double-to-Single Taper (Verjuengung): - Automatische Erkennung: Double-Track an Single-Track grenzt. - Uebergangszone: 20% der Spline-Laenge. 39) RNA5 Terminal-Editor (Modus): - Aktiv wenn g_InpMgr.GetTerminalMode() != 0. - Phantom-Terminal: RenderTerminalCursor zeigt Vorschau. - Platzierung: Erzeugt SnapIn mit TYPE_TERMINAL_TRK. 40) RNA5 Terminal Face-to-Face Logik (KRITISCH!): - Die Lok reagiert NUR auf das Signal das ihr ENTGEGENKOMMT. - Forward: Pruefe TYPE_TERM_SIG_A, halte bei signalBIdx. - Backward: Pruefe TYPE_TERM_SIG_B, halte bei signalAIdx. - FALSCH: if (m_Forward) red = (TYPE_TERM_SIG_B != 0); - RICHTIG: if (m_Forward) red = (TYPE_TERM_SIG_A != 0); 41) RNA5 Terminal-Signal Toggle: - Klick auf Signal A toggelt TYPE_TERM_SIG_A. - Klick auf Signal B toggelt TYPE_TERM_SIG_B. - Beide Signale unabhaengig schaltbar. 42) RNA6 Verkehr & Kollisions-Erkennung: - Aktivierung: #define TRAFFIC_DISASTER 1 in GLSceneTraffic.cpp - Pruefung: Beide Loks auf demselben Host (m_FollowFrag). - Doppelgleis-Vertrag: Jede Phantomlok besitzt m_TrackSide (-1/+1); Single-Track ist immer 0. Unterschiedliche Seiten sind zwei physische Gleise und duerfen niemals miteinander kollidieren. - Prellbock: Die Fahrtrichtung wechselt, die physische m_TrackSide nicht; der Render-Offset wird separat gespiegelt. - Beim Doppelgleis-Hostwechsel wird die Weltposition zur Seitenkontinuitaet ausgewertet, damit Weichen keinen Sprung auf das Nachbargleis erzeugen. - UI-Reset: Doppelgleis-Seiten werden pro Lok unabhaengig zufaellig gesetzt; gleiche oder unterschiedliche Seiten sind beide gueltig. - Lua-Event: OnTrain() mit flags=8 bei Kollision. ================================================================================ BEKANNTE SCHWERE BUGS (GEFIXT) - DOKUMENTATION FUER WARTUNG ================================================================================ BUG#1: PHANTOM-SPLINE BEI SWITCH-VERLAENGERUNG (Gefixt 2024) -------------------------------------------------------------------------------- SYMPTOM: - User zieht Spline aus Host heraus -> Switch[A] entsteht - User verlaengert Switch[A] und verbindet mit Host[B] (Midpoint-Snap) - RESULTAT: Zusaetzlicher "Phantom-Spline" entsteht am Switch[A]-Ausgang! - Dieser Stummel ist sichtbar aber logisch nicht verbunden URSACHE: - HandleSnapAndSwitch() ruft CommitTrack() -> erstellt Client[X] - GenTrack() macht SPLIT wenn Client > 8 Dots (absorbClient=false) - Finalize() erstellt Switch[B] UND laesst Client[X] (4-9 Dots) bestehen - Client[X] ist ein orphan Track zwischen Switch[A] und Switch[B] LOESUNG (SplineControl.cpp HandleSnapAndSwitch): 1. Wenn startedFromSwitch=true: TrackMkLst trimmen (Switch-Dots entfernen) 2. Nach GenTrack(): Pruefen ob Client ein orphan Stummel ist 3. Client-Dots an neuen Switch VORNE anhaengen (Merge) 4. Dann Client loeschen und Fragment-IDs korrigieren 5. origSwitch.forwardFragmentId -> newSwitch setzen BETROFFENE DATEIEN: - SplineControl.cpp: HandleSnapAndSwitch(), CommitTrack() - SplineSwitch.cpp: GenTrack(), Finalize() - SplineDotUtil.cpp: HandleDotMove() - SplineTopology.cpp: UpdateSwitchConnections() WARNUNG: - Bei Aenderungen an Switch-Logik IMMER testen: 1. Neuen Switch durch Herausziehen erstellen 2. Switch mit anderem Host verbinden (Midpoint-Snap) 3. Pruefen ob NUR EIN neuer Switch entsteht, KEIN Stummel! ================================================================================ LUA OnTrain EVENT FLAGS ================================================================================ +------+-------------+------------------+------------------+ | Bit | Flag | extra1 | extra2 | +------+-------------+------------------+------------------+ | 0 | Terminal | dotIdx | mode (0=enter | | | | | 1=arrived)| |------+-------------+------------------+------------------+ | 1 | Signal | dotIdx | - | +------+-------------+------------------+------------------+ | 2 | Switch | switchHostId | dotIdx | | | | (otherSplineId) | (Andockpunkt) | +------+-------------+------------------+------------------+ | 3 | Disaster | phantomIdx1 | phantomIdx2 | | | | (erste Lok) | (zweite Lok) | +------+-------------+------------------+------------------+ ================================================================================ VERSION HISTORY ================================================================================ v1.0: Basis-Regelwerk (Regeln 1-28) v1.1: RNA3 Signal-System (Regeln 31-34) v1.2: RNA4 Prellboecke/Taper (Regeln 35-38) v1.3: RNA5 Terminals (Regeln 39-41) v1.4: RNA6 Kollisionen (Regel 42) v1.5: RNA-Tabelle hinzugefuegt, Zuordnungen korrigiert v1.6: BUG#1 Phantom-Spline dokumentiert und gefixt v1.7: Endpoint Smoothing (Regel 32) hinzugefügt ================================================================================ */ nicht die Zeit habe, da allzu tief einzusteigen Du scheinst da schon recht Tief drinnen zu stecken Also danke für deine Analysen / Interesse Ich mach da stupide Weiter und es wird Jahre brauchen bis es ein 50 Player MMPGO abbildet so wie Sid Mayer es vor 30 Jahren vorlegte, unglaublich was die da auf dem Amiga oder PC integriert haben mit den Rechnern früher unglaublich.... Grüße aus Berlin, und danke für deine Hinweise Mega Antwort leider geworden sorry... Karsten
• VCL (C++ Builder)

  Rund um die VCL (Visual Component Library) und den C++Builder.

  24027
  Themen
  143578
  Beiträge

  

  Nur aus Interesse: Hat wer diese Version ( C++Builder 12 Community Edition) auf seinem Rechner installiert? Wenn ja, dann könnte die Version mit meinem Win11 nicht kompatibel sein, oder sonst was. Wenn nein, dann ist das Ding wohl fehlerhaft.
• C++/CLI mit .NET

  C++ mit .NET? Nennt sich C++/CLI, oder in der früheren Version Managed C++. Programmierung des .NET-Frameworks mit C++, oder Fragen zu den Erweiterungen von C++/CLI mit dem Visual Studio.

  5156
  Themen
  29747
  Beiträge

  _

  @znieh99 um mit Niklaus Wirth (* 15. Februar 1934 in Winterthur; † 1. Januar 2024 in Zürich) zu antworten: Wahlfreier Zugriff (Random Access) findet nicht auf Dateiebene sondern im Hauptspeicher statt. Denn: Dateien sind Sequenzen, sie werden sequentiell gelesen und sequentiell geschrieben. Das heißt: Lese den Dateiinhalt auf eine zweckmäßige Datenstruktur (Array, Liste, Map o.ä) und bearbeite diese. Anschließend schreibe diese Daten zurück in die Sequenz (Serialize). Die Frage ist also, wie man abstrakte Datentypen in Sequenzen serialisiert und umgekehrt. Und aus OOP-Sicht könnte man die Daten im RAM als Objekte auffassen die dafür ihre eigenen Methoden bescheiben. MFG
• Andere GUIs - Qt, GTK+, wxWidgets

  Alternative GUI-Libs werden immer geläufiger, diese Rubrik bietet Qt, gtkmm, GTK+, wxWidgets und Co. eine Heimat.

  4717
  Themen
  25495
  Beiträge

  

  Ich arbeite gerade an DirectX und nutze zum ersten mal die DirectXMath Funktionen. Die SIMD Unterstützung ist neu für mich. Das Flag _XM_SSE_INTRINSICS_ ist entsprechend gesetzt. Von daher wollte ich fragen ob der folgende Code so ok ist: float GetDistance2D(const DirectX::XMVECTOR& P1, const DirectX::XMVECTOR& P2) { DirectX::XMVECTOR delta = DirectX::XMVectorSubtract(P1, P2); DirectX::XMVECTOR length = DirectX::XMVector2Length(delta); return DirectX::XMVectorGetX(length); } Mein gedankliches Problem: DirectX::XMVECTOR ist ein 4D Vektor, aber ich brauche nur die 2D Distanz. Wäre also der folgende Code schneller? float GetDistance2D(const DirectX::XMVECTOR& P1, const DirectX::XMVECTOR& P2) { float P1x, P1y, P1w; float P2x, P2y, P2w; // Bestimme XY von P1 P1w = DirectX::XMVectorGetW(P1); if (P1w != 0.0f && P1w != 1.0f) { P1x = DirectX::XMVectorGetX(P1) / P1w; P1y = DirectX::XMVectorGetY(P1) / P1w; } else { P1x = DirectX::XMVectorGetX(P1); P1y = DirectX::XMVectorGetY(P1); } // Bestimme XY von P2 P2w = DirectX::XMVectorGetW(P2); if (P2w != 0.0f && P2w != 1.0f) { P2x = DirectX::XMVectorGetX(P2) / P2w; P2y = DirectX::XMVectorGetY(P2) / P2w; } else { P2x = DirectX::XMVectorGetX(P2); P2y = DirectX::XMVectorGetY(P2); } // Berechne nun den Abstand float DiffX = P1x - P2x; float DiffY = P1y - P2y; return sqrt(DiffX * DiffX + DiffY * DiffY); }