DGL • Thema anzeigen - bin neu, nicht boxen

bin neu, nicht boxen

Moderator: DGL-Team

Seite 1 von 4

[ 49 Beiträge ]

Gehe zu Seite 1, 2, 3, 4 Nächste

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

cyanide

Betreff des Beitrags: bin neu, nicht boxen

Verfasst: Mo Nov 03, 2003 20:32

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

guten tag

ich habe schon etwas in dem forum rumgestöbert.

zu mir:
najo, ich bin nicht so netzaktiv und meine mathematischen kenntnisse sind auch nicht sooo die geilsten.

ich habe zuhause ne 3D engine (delphi, opengl) am start und bin grad dabei ne collision detection zu implementieren. die engine selber ist bis jetzt so optisch auf dem stand von Q2.

gfx/snd/input engine ist von der gameengine sauber getrennt.

ich kann in gewissen zeitzyklen die engine mit sourcecode online stellen. der ei oder andere wird da sicher schöne sachen für sich finden :wink:

najo... zurück zum problem. hat jemand ne idee, wie man eine abfrage ob eine traceline ein polygone schneidet sinnvoll gestalten kann ?

bisher benutze ich was selbstgedrehtes, was ich so noch nirgends gefunden habe. ich nehme die POLY-endpunkte und nehme für den ersten durchgang nur die x und z coods. von denen bekomme ich dann einen winken zu den x und z coords des tracestartpoints. und dann muss ich nur noch den winkel von tracestart und traceend wissen und kann fragen ob der winkel zwischen den beiden äussersten winkeln des polys liegt. danach das ganze nochmal mit y und ich habe eine test-scene mit 200.000 polys auf ca. 0.01% colltests geschrumpft.

funzt! ich ahbe es ausgiebig getestet. auch wenn tracestart ganz nahe vorm poly ist.

weiss jemand was besseres ?

ich würde mich freuen, von euch mal was schönes zu hören

grx_cyan

Nach oben

HomerS

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 20:35

DGL Member

Registriert: Sa Nov 02, 2002 18:06
Beiträge: 299
Wohnort: Dresden

*box*

Guck mal bei sulaco.co.za da gibts ein komplettes Beispiel für Line-Tri-Intersections.

*nochmal box*

Edit: Ach ja, wofür ist das da? Kollision? Dann würde ich's anders machen. (Kollision mit BSP abprüfen). Weil sowas doch ganz schön aufwendig ist (Line-Triangle Intersection)

_________________
"Ich würde ja gern die Welt verändern, aber Gott gibt mir den Quelltext nicht"

Nach oben

cyanide

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 20:41

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

da war ich schon... hat mal jemand die coordinaten von den dreiecken verändert ? :oops:

also bei mir geht der test ab dem moment nicht mehr

ps: ich code ne landscape engine. so kann ich ncith wirklich viel mit BSP anfangen. die tests bei BSP sid mir so auch noch nicht einläuchtend :oops:

Nach oben

HomerS

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 20:48

DGL Member

Registriert: Sa Nov 02, 2002 18:06
Beiträge: 299
Wohnort: Dresden

Versuch das mal:

Code:

 
function LineHitsTriangle(Triangle : TTriangle; LineStart, LineEnd : TAffineExtVector) : Boolean;
    const
      // Used to cover up the error in floating point
      MATCH_FACTOR : Extended = 0.9999999999;
      verticeCount = 3;
    var
      Normal : TAffineExtVector;
      Intersection : TAffineExtVector;
      originDistance : Extended;
      distance1 : Extended;
      distance2 : Extended;
      Vector1 : TAffineExtVector;
      Vector2 : TAffineExtVector;
      m_magnitude : Double;
      Point : TAffineExtVector;
      LineDir : TAffineExtVector;
      Numerator : Extended;
      Denominator : Extended;
      dist : Extended;
      Angle,tempangle : Extended;
      vA, vB : TAffineExtVector;
      i : integer;
      dotProduct : Extended;
      vectorsMagnitude : Extended;
    begin
    Normal[0] := 0;
    Normal[1] := 0;
    Normal[2] := 0;
 
    originDistance := 0;
    distance1 := 0;
    distance2 := 0;
    Point[0] := 0;
    Point[1] := 0;
    Point[2] := 0;
 
    LineDir[0] := 0;
    LineDir[1] := 0;
    LineDir[2] := 0;
 
    Numerator := 0.0;
    Denominator := 0.0;
    dist := 0.0;
    Angle := 0.0;
 
    {----------------------------------------------------------------------------}
    { First we check to see if our line intersected the plane.                   }
    { If this isn't true there is no need to go on, so return false immediately. }
    { We pass in address of vNormal and originDistance                           }
    { so we only calculate it once                                               }
    {                                                                            }
    { In order to get a vector from 2 points (a direction) we need to            }
    { subtract the second point from the first point.                            }
    {----------------------------------------------------------------------------}
 
    //vector
    Vector1[0] := Triangle.Verts[2][0] - Triangle.Verts[0][0];
    Vector1[1] := Triangle.Verts[2][1] - Triangle.Verts[0][1];
    Vector1[2] := Triangle.Verts[2][2] - Triangle.Verts[0][2];
    //vector
    Vector2[0] := Triangle.Verts[1][0] - Triangle.Verts[0][0];
    Vector2[1] := Triangle.Verts[1][1] - Triangle.Verts[0][1];
    Vector2[2] := Triangle.Verts[1][2] - Triangle.Verts[0][2];
 
    {----------------------------------------------------------------------------}
    { Once again, if we are given 2 vectors (directions of 2 sides of a polygon) }
    { then we have a plane define.                                               }
    { The cross product finds a vector that is perpendicular to that plane,      }
    { which means it's point straight out of the plane at a 90 degree angle.     }
    {----------------------------------------------------------------------------}
 
    //cross
 
    // The X value for the vector is:  (V1.y * V2.z) - (V1.z * V2.y)
    Normal[0] := ((Vector1[1] * Vector2[2]) - (Vector1[2] * Vector2[1]));
    // The Y value for the vector is:  (V1.z * V2.x) - (V1.x * V2.z)
    Normal[1] := ((Vector1[2] * Vector2[0]) - (Vector1[0] * Vector2[2]));
    // The value for the vector is:  (V1.x * V2.y) - (V1.y * V2.x)
    Normal[2] := ((Vector1[0] * Vector2[1]) - (Vector1[1] * Vector2[0]));
 
    //normalize
 
    {----------------------------------------------------------------------------}
    { This will give us the magnitude or \"Norm\" as some say, of our normal.      }
    { Here is the equation:  magnitude = sqrt(V.x^2 + V.y^2 + V.z^2)             }
    { Where V is the vector                                                      }
    {----------------------------------------------------------------------------}
 
    // Get the magnitude of our normal
    m_magnitude := sqrt((Normal[0] * Normal[0]) +
                        (Normal[1] * Normal[1]) +
                        (Normal[2] * Normal[2]));
 
    {----------------------------------------------------------------------------}
    { Now that we have the magnitude, we can divide our normal by that magnitude.}
    { That will make our normal a total length of 1.                             }
    { This makes it easier to work with too.                                     }
    {----------------------------------------------------------------------------}
 
    Normal[0] := Normal[0]/m_magnitude; // Divide the X value of our normal by it's magnitude
    Normal[1] := Normal[1]/m_magnitude; // Divide the Y value of our normal by it's magnitude
    Normal[2] := Normal[2]/m_magnitude; // Divide the Z value of our normal by it's magnitude
 
    //plane distance
 
    {----------------------------------------------------------------------------}
    { Let's find the distance our plane is from the origin.                      }
    { We can find this value from the normal to the plane (polygon)              }
    { and any point that lies on that plane (Any vertex)                         }
    {                                                                            }
    { Use the plane equation to find the distance (Ax + By + Cz + D = 0)         }
    { We want to find D. So, we come up with D = -(Ax + By + Cz)                 }
    {----------------------------------------------------------------------------}
 
    originDistance := -1 * ((Normal[0] * Triangle.Verts[0][0]) +
                            (Normal[1] * Triangle.Verts[0][1]) +
                            (Normal[2] * Triangle.Verts[0][2]));
 
    // Get the distance from point1 from the plane using:
    //Ax + By + Cz + D = (The distance from the plane)
    distance1 := ((Normal[0] * LineStart[0])  +
                  (Normal[1] * LineStart[1])  +
                  (Normal[2] * LineStart[2])) + originDistance;
 
    // Get the distance from point2 from the plane using
    //Ax + By + Cz + D = (The distance from the plane)
    distance2 := ((Normal[0] * LineEnd[0])  +
                  (Normal[1] * LineEnd[1])  +
                  (Normal[2] * LineEnd[2])) + originDistance;
 
 
    {----------------------------------------------------------------------------}
    { Now that we have 2 distances from the plane,                               }
    { if we times them together we either get a positive or negative number.     }
    { If it's a negative number, that means we collided!                         }
    { This is because the 2 points must be on either side of the plane           }
    { (IE. -1 * 1 = -1).                                                         }
    {----------------------------------------------------------------------------}
 
    // Check to see if both point's distances are both negative or both positive
    if(distance1 * distance2 >= 0) then
      begin
      // Return false if each point has the same sign.
      //-1 and 1 would mean each point is on either side of the plane.
      //-1 -2 or 3 4 wouldn't...
      result := false;
      exit;
      end;
 
    {----------------------------------------------------------------------------}
    { Now that we have our normal and distance,                                  }
    { We can use it to calculate the intersection point.                         }
    { The intersection point is the point that actually is ON the plane.         }
    { It is between the lines points.                                            }
    { We need this point test next, if we are inside the polygon.                }
    { To get the I-Point, we use normal of the plain, the points of the line,    }
    { and the originDistance.                                                    }
    {                                                                            }
    { Here comes the confusing part...                                           }
    { We need to find the 3D point that is actually on the plane.                }
    { Here are some steps to do that:                                            }
    {----------------------------------------------------------------------------}
 
    //vector
 
    {----------------------------------------------------------------------------}
    { (1)                                                                        }
    { First we need to get the vector of our line,                               }
    { Then normalize it so it's a length of 1                                    }
    {----------------------------------------------------------------------------}
    LineDir[0] := LineEnd[0] - LineStart[0];    // Get the X value of our new vector
    LineDir[1] := LineEnd[1] - LineStart[1];    // Get the Y value of our new vector
    LineDir[2] := LineEnd[2] - LineStart[2];    // Get the Z value of our new vector
 
    //normalize
 
    // Get the magnitude of our normal
    m_magnitude := sqrt((LineDir[0] * LineDir[0]) +
                        (LineDir[1] * LineDir[1]) +
                        (LineDir[2] * LineDir[2]));
 
    {----------------------------------------------------------------------------}
    { Now that we have the magnitude, we can divide our normal by that magnitude.}
    { That will make our normal a total length of 1.                             }
    { This makes it easier to work with too.                                     }
    {----------------------------------------------------------------------------}
 
    LineDir[0] := LineDir[0]/m_magnitude;// Divide the X value of our normal by it's magnitude
    LineDir[1] := LineDir[1]/m_magnitude;// Divide the Y value of our normal by it's magnitude
    LineDir[2] := LineDir[2]/m_magnitude;// Divide the Z value of our normal by it's magnitude
 
 
    {----------------------------------------------------------------------------}
    { (2)                                                                        }
    { Use the plane equation (distance = Ax + By + Cz + D)                       }
    { to find the distance from one of our points to the plane.                  }
    { Here I just chose a arbitrary point as the point to find that distance.    }
    { You notice we negate that distance.                                        }
    { We negate the distance because we want to eventually go BACKWARDS          }
    { from our point to the plane.                                               }
    { By doing this is will basically bring us back to the plane                 }
    { to find our intersection point.                                            }
    {----------------------------------------------------------------------------}
 
    // Use the plane equation with the normal and the line
    Numerator := -1 * (Normal[0] * LineStart[0] +
                       Normal[1] * LineStart[1] +
                       Normal[2] * LineStart[2] + originDistance);
 
    {----------------------------------------------------------------------------}
    { (3)                                                                        }
    { We take the dot product between our line vector and normal of the polygon  }
    { This will give us the cosine of the angle between the 2                    }
    { (since they are both normalized - length 1).                               }
    { We will then divide our Numerator by this value,                           }
    { to find the offset towards the plane from our arbitrary point.             }
    {----------------------------------------------------------------------------}
 
    // Get the dot product of the line's vector and the normal of the plane
    Denominator := ( (Normal[0] * LineDir[0]) + (Normal[1] * LineDir[1]) + (Normal[2] * LineDir[2]) );
 
    if( Denominator = 0.0) then  // Check so we don't divide by zero
      begin
      Intersection := LineStart; // Return an arbitrary point on the line
      end
    else
      begin
 
      {----------------------------------------------------------------------------}
      { We divide the (distance from the point to the plane) by (the dot product)  }
      { to get the distance (dist) that we need to move from our arbitrary point.  }
      { We need to then times this distance (dist) by our line's vector (direction)}
      { When you times a scalar (single number)                                    }
      { by a vector you move along that vector. That is what we are doing.         }
      { We are moving from our arbitrary point                                     }
      { we chose from the line BACK to the plane along the lines vector.           }
      { It seems logical to just get the numerator, which is the distance          }
      { from the point to the line,                                                }
      { and then just move back that much along the line's vector.                 }
      { Well, the distance from the plane means the SHORTEST distance.             }
      { What about in the case that the line is almost parallel with the polygon   }
      { but doesn't actually intersect it until half way down the line's length?   }
      { The distance from the plane is short, but the distance from                }
      { the actual intersection point is pretty long.                              }
      { If we divide the distance by the dot product of our line vector            }
      { and the normal of the plane, we get the correct length.  Cool huh?         }
      {----------------------------------------------------------------------------}
 
      // Divide to get the multiplying (percentage) factor
      dist := Numerator / Denominator;
 
      {----------------------------------------------------------------------------}
      { Now, like we said above, we times the dist by the vector,                  }
      { then add our arbitrary point.                                              }
      { This essentially moves the point along the vector to a certain distance.   }
      { This now gives us the intersection point.  Yay!                            }
      {----------------------------------------------------------------------------}
 
      Point[0] := (LineStart[0] + (LineDir[0] * dist));
      Point[1] := (LineStart[1] + (LineDir[1] * dist));
      Point[2] := (LineStart[2] + (LineDir[2] * dist));
 
      Intersection := Point;                                // Return the intersection point
      end;
 
    {----------------------------------------------------------------------------}
    { Now that we have the intersection point,                                   }
    { we need to test if it's inside the polygon.                                }
    { To do this, we use :                                                       }
    {   Our intersection point,                                                  }
    {   The polygon,                                                             }
    {   And the number of vertices our polygon has                               }
    {----------------------------------------------------------------------------}
 
    {----------------------------------------------------------------------------}
    { Just because we intersected the plane,                                     }
    { doesn't mean we were anywhere near the polygon.                            }
    { We need to check our intersection point                                    }
    { to make sure it is inside of the polygon.                                  }
    { This is another tough function to grasp at first,                          }
    { but let me try and explain.                                                }
    { It's a brilliant method really,                                            }
    { what it does is create triangles within the polygon                        }
    { from the intersection point.                                               }
    { It then adds up the inner angle of each of those triangles.                }
    { If the angles together add up to 360 degrees                               }
    { (or 2 * PI in radians) then we are inside!                                 }
    { If the angle is under that value, we must be outside of polygon.           }
    { To further understand why this works,                                      }
    { take a pencil and draw a perfect triangle.                                 }
    { Draw a dot in the middle of the triangle.                                  }
    { Now, from that dot, draw a line to each of the vertices.                   }
    { Now, we have 3 triangles within that triangle right?                       }
    { We know that if we add up all of the angles in a triangle we get 360 right?}
    { Well, that is kinda what we are doing, but the inverse of that.            }
    { Say your triangle is an isosceles triangle, so add up the angles           }
    { and you will get 360 degree angles.  90 + 90 + 90 is 360.                  }
    {----------------------------------------------------------------------------}
 
    // Go in a circle to each vertex and get the angle between
    for i := 0 to verticeCount-1 do
      begin
 
      // Subtract the intersection point from the current vertex
      // Get the X value of our new vector
      vA[0] := Triangle.Verts[i][0] - Intersection[0];
      // Get the Y value of our new vector
      vA[1] := Triangle.Verts[i][1] - Intersection[1];
      // Get the Z value of our new vector
      vA[2] := Triangle.Verts[i][2] - Intersection[2];
 
      // Subtract the point from the next vertex
      // Get the X value of our new vector
      vB[0] := Triangle.Verts[(i + 1) mod verticeCount][0] - Intersection[0];
      // Get the Y value of our new vector
      vB[1] := Triangle.Verts[(i + 1) mod verticeCount][1] - Intersection[1];
      // Get the Z value of our new vector
      vB[2] := Triangle.Verts[(i + 1) mod verticeCount][2] - Intersection[2];
 
      {----------------------------------------------------------------------------}
      { Remember, we said that the Dot Product of returns the cosine of the angle  }
      { between 2 vectors?                                                         }
      { Well, that is assuming they are unit vectors (normalize vectors).          }
      { So, if we don't have a unit vector,                                        }
      { then instead of just saying  arcCos(DotProduct(A, B))                      }
      { We need to divide the dot product                                          }
      { by the magnitude of the 2 vectors multiplied by each other.                }
      { Here is the equation:   arc cosine of (V . W / || V || * || W || )         }
      { the || V || means the magnitude of V.                                      }
      { This then cancels out the magnitudes dot product magnitudes.               }
      { But basically, if you have normalize vectors already,                      }
      { you can forget about the magnitude part.                                   }
      {----------------------------------------------------------------------------}
 
      // Get the dot product of the vectors
      dotProduct := ( (vA[0] * vB[0]) +
                      (vA[1] * vB[1]) +
                      (vA[2] * vB[2]) );
 
      // Get the product of both of the vectors magnitudes
      vectorsMagnitude := sqrt(
                               extended(vA[0] * vA[0]) +
                               extended(vA[1] * vA[1]) +
                               extended(vA[2] * vA[2])
                               )
                            *
                          sqrt(
                               extended(vB[0] * vB[0]) +
                               extended(vB[1] * vB[1]) +
                               extended(vB[2] * vB[2])
                               );
 
      {----------------------------------------------------------------------------}
      { Get the arc cosine of the (dotProduct / vectorsMagnitude)                  }
      { which is the angle in RADIANS.                                             }
      { IE:                                                                        }
      {   PI/2 radians = 90 degrees                                                }
      {   PI radians = 180 degrees                                                 }
      {   2*PI radians = 360 degrees                                               }
      {                                                                            }
      { To convert radians to degress use this equation:   radians * (PI / 180)    }
      { To convert degrees to radians use this equation:   degrees * (180 / PI)    }
      {----------------------------------------------------------------------------}
 
 
      tempangle := arccos( dotProduct / vectorsMagnitude );
 
      {----------------------------------------------------------------------------}
      { Here we make sure that the angle is not a -1.#IND0000000 number,           }
      { which means indefinate.                                                    }
      { acos() thinks it's funny when it returns -1.#IND0000000.                   }
      { If we don't do this check,                                                 }
      { our collision results will sometimes say we are colliding when we aren't.  }
      { I found this out the hard way after MANY hours                             }
      { and already wrong written tutorials <!-- s:) --><img src=\"{SMILIES_PATH}/icon_e_smile.gif\" alt=\":)\" title=\"Lächeln\" /><!-- s:) -->                                     }
      { Usually this value is found when the dot product and the maginitude        }
      { are the same value.                                                        }
      { We want to set tempangle = 0 when this happens.                            }
      {----------------------------------------------------------------------------}
 
      if(isnan(tempangle)) then
        begin
        tempangle := 0;
        end;
 
      // add the current tempangle to Angle in radians
      Angle := Angle + tempangle;
      end;
 
    {----------------------------------------------------------------------------}
    { Now that we have the total angles added up,                                }
    { we need to check if they add up to 360 degrees.                            }
    { Since we are using the dot product, we are working in radians,             }
    { so we check if the angles equals 2*PI.                                     }
    { You will notice that we use MATCH_FACTOR in conjunction with our 2*PI.     }
    { This is because of the inaccuracy when working with floating point numbers.}
    { It usually won't always be perfectly 2 * PI, so we need                    }
    { to use a little twiddling.                                                 }
    { I(Digiben) use .9999,                                                      }
    { but you can change this to fit your own desired accuracy.                  }
    { For the Delphi version I am using 0.9999999999 because im using extended   }
    { and not double (float in c++)                                              }
    {----------------------------------------------------------------------------}
 
    // If the angle is greater than 2 PI, (360 degrees)
    if(Angle >= (MATCH_FACTOR * (2.0 * PI)) ) then
      begin
      result := TRUE;                           // The point is inside of the polygon
      exit;                       // We collided!     Return success
      end;
 
 
    // If we get here, we must have NOT collided
 
    result := false; // There was no collision, so return false
    end;
 
 
 

Brauchst noch die Geometry dafür

Und TTriangle.Verts ist einfach ein array[0..2] of TVertex

_________________
"Ich würde ja gern die Welt verändern, aber Gott gibt mir den Quelltext nicht"

Nach oben

cyanide

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 20:51

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

aha... wenns läuft bin ich schonmal etwas glücklicher. meine derzeitige abfrage funzt via matrix. und wenn ich auch den code zeige, erschlagt ihr mich sicher mit was ganz hartem :oops:

Nach oben

HomerS

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 20:51

DGL Member

Registriert: Sa Nov 02, 2002 18:06
Beiträge: 299
Wohnort: Dresden

Im Anhang ist die Funktion mal drin.

TTRiangles.Verts ist einfach ein array[0..2] of TVector

Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

_________________
"Ich würde ja gern die Welt verändern, aber Gott gibt mir den Quelltext nicht"

Nach oben

cyanide

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 20:53

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

danke... aber copy & paste hatte ich schneller drin

erm... müssen wir immer gleichzeitig posten ? *fg*
(hab jetzt meine edits dazugerechnet)

Zuletzt geändert von cyanide am Mo Nov 03, 2003 20:54, insgesamt 1-mal geändert.

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 20:53

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

@HomerS :
Bitte poste keine so großen Quellcodes mehr,zumal obiger ja identisch mit dem von Sulaco ist,da das die Foren-DB nicht mag.

@Cyanide :
Wenn du Spieler-Landschaftskollision machen willst,dann benötigst du definitiv eine Routine die nur die in der Nähe des Spielers liegende Geometrie für einen Kollisionstest in Betracht ziehst.Dazu empfiehlt sich bei einer Landschaft übrigens ein Octree,denn man dafür sowieso bereits zum Rendern nutzen sollten.Danach reicht es wenn du den Spieler als 3 Linien darstellst (seine drei Achsen) und diese dann mit der umliegenden Geometrie auf Kollision testest.Alternativ kannst du den Spieler auch als eine Kugel beschreiben lassen und diese gegen die Polygone testen,was auch recht häufig gemacht wird.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Nach oben

cyanide

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 20:58

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

das ist falsch. ich habe teilweise tests, die von einem ende bis zum anderen ende der map reichen.

meine maps unterteile ich aber später mit einem neuen system. das stelle ich dann hier auch vor. ich will versuchen den skybackground interaktiv zu halten und da dann die weltteile reinrendern, die zu weit entfernt liegen. hierbei ist aber wichtig, dass spieler die hinter der map stehen trotzdem ganz oder durch verdeckung theoritisch daseiender wände nur halb oder garnicht gezeichnet werden. und figuren sollen ab einer gewissen reichweiter nur noch als sprites dargestellt werden. die engine rechnet beim laden einer map die sprites selber aus, indem die die figuren von allen seiten zeichnet und texturen draus macht. ab den entfernungen, wo diese dann statt der normalen figuren gezeichnet werden, merkt man das nicht mehr

Nach oben

cyanide

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 21:01

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

(sorry für evtl. schreibfehler)

ich brauche solche langen tracelines für sniper und co, welche innerhalb eines frames eine lange traceline produzieren.

wenn das alles theoretisch funktioniert, dann brauche ich kein kompliziertes LOD mehr. dann geht alles viel einfachher und schneller

Nach oben

cyanide

Betreff des Beitrags:

Verfasst: Mo Nov 03, 2003 21:08

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

hmpf... ich hätte nciht so mit der tür ins haus fallen sollen. ich hätte viel zu erklären, warum ich solche tests brauche.

- physik
- bullets
- raytracing (ja!)

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Di Nov 04, 2003 12:13

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Und trotzdem wäre ein Octree doch ne gute Alternative,selbst wenn du den nicht für dein LODding benutzt.Viele Spiele nutzen ihre BSP-Bäume auch nur zur Kollisionserkennung und nutzen fürs Rendern andere LOD-Techniken.
Denn durch nen Octree kannst du doch ganz einfach testen welche Boundingbox dein Strahl geradet durchschneidet und musst dann nur gegen die zu dieser Box gehörenden Polygone testen.

Ansonsten ist das was du da vorhast recht unklar.Erklär das mal etwas genauer.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Nach oben

cyanide

Betreff des Beitrags:

Verfasst: Di Nov 04, 2003 18:53

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

ok... ich weiss jetzt nicht genau, was unklar ist. deswegen werde ich jetzt mal etwas ausholen:

start der entwicklung war vor ca. 4 wochen. ich code aber schon sehr lange, wodurch die engine einen schon recht guten status hat.

ich muss mich aber derzeit leider mit allem beschäftigen, da ich ganz alleine an dem projekt arbeite und unbedingt alle ideen umsetzten will. dadurch sind einige schönheiten auf der strecke geblieben. angefangen hat alles mit einem tutorial von NEHE. darauf habe ich erstmal einen landscapegenerator gesetzt. sah dann alles ganz nett aus und ich war motiviert genug ne gameengine zu schreiben. aös nächstes kam dann ein MD3 modelloader und kurz danach ne (wenn auch total blöde) KI. jetzt konnte ich mich schonmal mir doofen MD3-schwertkämpfern mit toll aussehenden raketen um frags streiten.

toll :oops:

naja... dann kam ich da irgendwie in das ganze rein und habe alles erstmal getrennt. alles was irgendwie nicht so richtig mit einem spielregelwerk zusammenhängt auf die hostseite und die gameengine samt den regeln und co in dei gameengine. ähnlich wie bei Q3/Q2.

grafik:
texturen sind, wenn nicht selbst gemacht, erstmal von anderen spielen geklaut. ebenso wie die MD3 models (irgendwie ansich logisch).als beruflicher grafikdesigner mache ich aber auch vieles schon selbst (aber mir fehlt die zeit). das landscape besteht derzeit aus ca. 80.000 polygonen. ich habe eine Gef2MX und einen AMD950 MHz prozessor. ist immer recht scheisse, wenn ich mir ein schönes tutorial runtergeladen habe und nette fehlermeldungen bekomme, dass meine GraKa zu blind dafür ist :oops:

sound:
OpenAL. ich bin definitiv begeistert, was da geht. davor habe ich mit Direct Sound gebastelt und somancher weiss wie frustrierend die teilweise nicht nachvollziehbaren fehlermeldungen seien können. SDKs habe ich mir bisher nicht holen können, weil ich erst wieder seit kurzem zugang zum i-net habe. ich hoffe jetzt wird alles besser

netz:
ich habs mal kurz versucht... aber mit nur einem rechner sind die resultate nicht so doll... kann ja nicht wirklich testen, ob die coordinaten syncronisiert werden, wenn ich das spiel nur einmal laufen lassen kann........ und wenn.... ist die durchsatzrate ok? übermittelt er durchgängig daten? ich lass es erstmal :wink:

input:
naja... keine grosse aufgabe... und das mausrad bekomm ich auch noch abgefragt... (das doofe) ..... vorher brauche ich aber ne maus mit mausrad *grml*

colldet:
hehe... wer DEN code sieht wird mich erschlagen! definitiv...
ich habe ein matrixsystem benutzt, dass ganz toll alles ausrechnet. ich bekomme den genauen schnittpunkt und allesfunktiert super! einziges manko: mehr als 5000 pro sekunde sind nicht drin... :oops:

dafür sorgen 400 zeilen 'EquationSolver' code. najo, das ganze konnte ich auch etwas drosseln. mit dem winkelabfragen von möglichen testflächen habe ich einiges rausgeholt. aber die 80.000 polygone schaff ich damit trotzdem nicht wenn ich dabei an eine akzeptable framerate denken will.

noch fragen offen?

grx_cyan

ps: ich bekomme die oben vorgeschlagene abfrage definitiv nicht zum laufen. muss ich noch wirgendwas beachten? ich habe bislang noch nicht mit 'normalen' getestet... kann ich nachher ja nochmal probieren.

pps: meine rechtschreibfehler basieren zumeist darauf, dass ich schneller schreibe als ich mit den augen das geschriebene korrigieren kann. manchma lesen sich meine sätze auch etwas strane... bin zu faul mir das ganze hinterher nochmal durchzulesen. wenn ihr mich genug boxt, dann kann ich mir das mal angewöhnen ^^

Nach oben

cyanide

Betreff des Beitrags:

Verfasst: Mi Nov 05, 2003 13:06

DGL Member

Registriert: Mo Nov 03, 2003 20:23
Beiträge: 66

seid doch etwas gesprächiger :oops:

..bitte...

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Mi Nov 05, 2003 13:15

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Hab doch bereits mehrere Male erwähnt das ein Octree die beste und performanteste Lösung für das Geschwindigkeitsproblem deiner Kollisionsabfrage sein könnte.Wie gesagt testes du halt nur die Polygone die zu der Octree-Boundingbox gehören durch die dein "Strahl" verläuft.Einfacher und besser gehts nicht.

P.S. : Dein obiger Text war echt quallvoll zu lesen.Die deutsche Sprache bietet dir doch sowas wie Groß-/Kleinschreibung an.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Nach oben

Seite 1 von 4

[ 49 Beiträge ]

Gehe zu Seite 1, 2, 3, 4 Nächste

Foren-Übersicht » Programmierung » Allgemein

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.