void enemy::clean_plane(int i){
for(int j = 0; j < 4; j++){
if(_enemy[i].position[j].Y < 24){
SetPos(_enemy[i].position[j]);
printf(" ");
}
}
new_plane(a, b, i);
}
void load_scene5_objects(t_scene *scene)
{
add_object(scene, new_object(CONE, new_cone(new_vector(0, 1, -0.5),
new_vector(8, 4, -5), 30), new_color(LIGHT_BLUE), 100));
add_object(scene, new_object(CYLINDER, new_cylinder(new_vector(0, 1, -0.3),
new_vector(-10, 0, -5), 2), new_color(PASTEL_BLUE), 100));
add_object(scene, new_object(SPHERE, new_sphere(-1, 3, 2, 2),
new_color(BLUE), 100));
add_object(scene, new_object(PLANE, new_plane(0, -1, 0, 0),
new_color(DARK_GREY), 100));
}
void enemy::move_plane(){
clean_plane();
for(int i = 0; i < 10; i++){
if(_enemy[i].position[3].Y+1 > 24){
new_plane(a, b, i);
}
else{
for(int j = 0; j < 4; j++)
_enemy[i].position[j].Y++;
}
int pos = random(a, b).X%4;
switch(pos){
case 0://Ïò×óÒƶ¯
{
if(_enemy[i].position[0].X-1 < 1){
new_plane(a, b, i);
}
else{
for(int j = 0; j < 4; j++)
_enemy[i].position[j].X--;
}
break;
}
case 1:
{
if(_enemy[i].position[2].X+1 > 49){
new_plane(a, b, i);
}
else{
for(int j = 0; j < 4; j++)
_enemy[i].position[j].X++;
}
break;
}
default:enemy_bullet[i].initial_enemy_bullet(_enemy[i].position[3]);break;
}
enemy_bullet[i].move_enemy_bullet();
enemy_bullet[i].draw_enemy_bullet();
}
draw_plane();
}
int handle_input(t_env* env, char* line)
{
char** input;
int nb_args;
input = id_strwordtab(line, " \t", &nb_args);
if (input == NULL)
return (-1);
if (id_strcmp(input[0], "c") == 0)
return (fill_camera(env, input, nb_args));
else if (id_strcmp(input[0], "S") == 0)
return (new_sphere(env, input, nb_args));
else if (id_strcmp(input[0], "P") == 0)
return (new_plane(env, input, nb_args));
else if (id_strcmp(input[0], "C") == 0)
return (new_cylinder(env, input, nb_args));
else if (id_strcmp(input[0], "Li") == 0)
return (new_light(env, input, nb_args));
id_wordtabfree(input);
return (0);
}
void Polyhedron<Real>::addConvexPointToPolyhedron(
const std::vector<plane<Real >> &planes,
const std::vector<vector3<Real >> &vertices,
const std::vector<PolyhedronEdge> &edges,
const vector3<Real> &spot,
std::vector<plane<Real >> &new_planes,
std::vector<vector3<Real >> &new_vertices,
std::vector<PolyhedronEdge> &new_edges)
{
//TODO wyprofilować i zoptymalizować
/*
założenia:
1) żaden wierzchołek się nie powtarza
2) żadna płaszczyzna się nie powtarza
*/
vector3<Real> averagePoint(vector3<Real>::zero);
Real scale = ((Real) 1.0) / vertices.size();
for (uint i = 0; i < vertices.size(); ++i)
averagePoint += vertices[i] * scale;
new_vertices.reserve(vertices.size() + 1);
new_vertices.clear();
new_vertices.push_back(spot);
int num_spot = 0; // new_vertices.size() -1;
new_edges.clear();
new_planes.clear();
std::vector<bool> isPlaneUseful(planes.size());
std::vector<int> oldNewVertexMapping(vertices.size());
std::vector<int> oldNewPlaneMapping(planes.size());
/*
klucz - indeks starego wierzchołka (!= spot) nowej krawędzi
wartość - druga ściana która wspóldzieli nową krawędź lub pusta gdy nieznana
*/
std::map<int, int> oldEdgesToNewWalls;
for (uint i = 0; i < oldNewVertexMapping.size(); ++i)
oldNewVertexMapping[i] = -1; //unused
for (uint i = 0; i < oldNewPlaneMapping.size(); ++i)
oldNewPlaneMapping[i] = -1; //unused
for (uint i = 0; i < planes.size(); ++i)
{
bool planeUseful = (planes[i].distance(spot) >= -std::max(error, std::fabs(error * planes[i].d)));
isPlaneUseful[i] = planeUseful;
if (planeUseful)
{
new_planes.push_back(planes[i]);
oldNewPlaneMapping[i] = new_planes.size() - 1;
}
}
for (uint i = 0; i < edges.size(); ++i)
{
char usefulness = 0;
if (isPlaneUseful[edges[i].num_p1])
usefulness++;
if (isPlaneUseful[edges[i].num_p2])
usefulness++;
if (usefulness == 0)
continue;
/*
wierczhołkom mogły pozmieniać się numery, następne 10 linijek to
załatwia
*/
int new_num_v1 = oldNewVertexMapping[edges[i].num_v1];
if (new_num_v1 == -1)
{
new_vertices.push_back(vertices[edges[i].num_v1]);
new_num_v1 = new_vertices.size() - 1;
oldNewVertexMapping[edges[i].num_v1] = new_num_v1;
}
int new_num_v2 = oldNewVertexMapping[edges[i].num_v2];
if (new_num_v2 == -1)
{
new_vertices.push_back(vertices[edges[i].num_v2]);
new_num_v2 = new_vertices.size() - 1;
oldNewVertexMapping[edges[i].num_v2] = new_num_v2;
}
/*
płaszczyznom też mogły się zmienić numery, ale tu test na -1
(wyrzucenie złej płaszczyzny) zanużymy w podprzypadku.
*/
int new_num_p1 = oldNewPlaneMapping[edges[i].num_p1];
int new_num_p2 = oldNewPlaneMapping[edges[i].num_p2];
if (usefulness == 2) // obie płaszczyzny istnieją, super.
{
//PolyhedronEdge(uint _num_v1, uint _num_v2, uint _num_p1, uint _num_p2)
new_edges.push_back(PolyhedronEdge(new_num_v1, new_num_v2, new_num_p1, new_num_p2));
}
else
{ // jedna istnieje, druga nie.
if (new_num_p1 == -1) // dla ułatwienia, zawsze druga nieistnieje
{
new_num_p1 = new_num_p2;
new_num_p2 = -1;
}
// tworzę nową ścianę
plane<Real> new_plane(new_vertices[new_num_v1], new_vertices[new_num_v2], spot);
/*
plane<Real> new_plane2(plane<Real>::stablePlaneFromPoints(new_vertices[new_num_v1], new_vertices[new_num_v2], spot));
NEWLOG("p1:[%f\t][%f\t][%f\t][%f\t]\np2:[%f\t][%f\t][%f\t][%f\t]",
new_plane.normal.x, new_plane.normal.y, new_plane.normal.z, new_plane.d,
new_plane2.normal.x, new_plane2.normal.y, new_plane2.normal.z, new_plane2.d);
*/
if (new_plane.distance(averagePoint) < -std::max(error, std::fabs(error * new_plane.d)))
new_plane.flip();
new_planes.push_back(new_plane);
new_num_p2 = new_planes.size() - 1;
//dodaję STARĄ krawędź
new_edges.push_back(PolyhedronEdge(new_num_v1, new_num_v2, new_num_p1, new_num_p2));
/*
próbuję dodać od 0 do 2 NOWYCH KRAWĘDZI
TUTAJ new_num_p1 jest już BEZUŻYTECZNE, (wskazuje starą ścianę, już załatwioną)
new_num_p2 wskazuje nowoutworzoną ścianę
new_num_v1 i new_num_v2 wskazują stare wierzchołki
poniższy kod działa tak:
dla każdego ze starych wierzchołków (new_num_v1, new_num_v2)
mam krawędź (stary_wierzchołek, spot) którą identyfikuję
za pomocą indeksu starego wierzchołka (wallKey)
sprawdzam w mapie: jeśli druga ściana przyległa do tej krawędzi
już istnieje, to mogę dodać krawędź do zbioru nowych
(bo wreszcie znam wszystkie arg. konstruktora)
jeśli jeszcze nie istenieje, to zostawiam informacje o tej ścianie
i czekam, aż krawędź zostanie dodana przy okazji dodawania ściany
przyległej.
*/
std::map<int, int>::iterator secondWall;
// najpierw sprawdzamy ścianę przyległą z new_num_v1
int wallKey = new_num_v1;
secondWall = oldEdgesToNewWalls.find(wallKey);
if (secondWall == oldEdgesToNewWalls.end()) // nie znamy drugiej ściany dla tej krawędzi.
{
oldEdgesToNewWalls[wallKey] = new_num_p2; // to ją dodajemy i kiedyś do tego wrócimy
//NEWLOG("pkt %d czeka", wallKey);
}
else // wiemy z którą ścianą ta krawędź będzie współdzielona
{
//NEWLOG("pkt %d się doczekał", secondWall->first);
new_edges.push_back(PolyhedronEdge(new_num_v1, num_spot, new_num_p2, secondWall->second));
}
// teraz sprawdzamy ścianę przyległa z new_num_v2
wallKey = new_num_v2;
secondWall = oldEdgesToNewWalls.find(wallKey);
if (secondWall == oldEdgesToNewWalls.end()) // nie znamy drugiej ściany dla tej krawędzi.
{
oldEdgesToNewWalls[wallKey] = new_num_p2; // to ją dodajemy i kiedyś do tego wrócimy
//NEWLOG("pkt %d czeka", wallKey);
}
else // wiemy z którą ścianą ta krawędź będzie współdzielona
{
//NEWLOG("pkt %d się doczekał", secondWall->first);
new_edges.push_back(PolyhedronEdge(new_num_v2, num_spot, new_num_p2, secondWall->second));
}
}
}
}
