Wie deklarieren Variablen in Ray-Tracing-objektorientierten Programm, wenn die meisten von ihnen eine Vektoren und Kamera Deklarationen?

Question

Ich habe einige Probleme mit meinem Ray-Tracing-Programm. Der ursprüngliche Code, den ich benutzt habe, stammt aus dem Youtube Tutorial - https://www.youtube.com/watch?v=k_aRiYSXcyo (caleb piercy Tutorial auf Ray-Tracing).

Ich habe dann den Code in der main.cpp in einen objektorientierten Code mit Visual Studio neu gemacht.

Der Punkt war die Kapselung der Funktionen und Berechnungen, um dann entweder OpenMP (in Visual Studio) oder (in Visual Studio) zu verwenden, so dass ich das gesamte Programm multi-threading.

Aber bevor ich das tue, habe ich ein Problem mit den spezifischen Deklarationen der Variablen. Die meisten von ihnen sind Vektoren-Deklarationen aus meiner Header-Datei Vect.h und Camera.h-Datei.

Hier ist der Code aus der main.cpp und genauer gesagt - nur die Deklarationen. Ich werde die Algorithmenfunktionen und Berechnungen nicht veröffentlichen, da sie funktionieren und ich habe kein Problem damit.

die Klasse, in der ich erklären einige der Variablen und Methodenfunktionen

//thread class 
class Thread 
{ 
public: 

    void UPrightRend(); 
    void UPleftRend(); 
    void DownrightRend(); 
    void DownleftRend(); 
    void define(); 
    void calcVect(int x, int y); 
    void calcColor(); 
    void saveimg(const char *filename); 
    int winningObjectIndex(vector<double> object_intersections); 
    Color getColorAt(Vect intersection_position, Vect intersecting_ray_direction, vector<Object*> scene_objects, int index_of_winning_object, vector<Source*> light_sources, double accuracy, double ambientlight); 

private: 

    //basic variables 
    int dpi = 72; 
    double sWidth = 1000; 
    double sHeight = 800; 
    int n = sWidth*sHeight; 
    RGBType *pixels = new RGBType[n]; 

    //aadepth sends out n number of pixels/rays that hit one pixels and then reflect to other pixels are return a value that is then averaged 
    static const int aadepth = 5; 
    double aspectratio = sWidth/sHeight; 
    double ambientlight = 0.2; 
    double accuracy = 0.000001; 

    int thisone, aa_index; 
    double xamnt, yamnt; 

    Vect camdir; 
    Vect camright; 
    Vect camdown; 
    Camera scene_cam; 

    vector<Source*> light_sources; 

    vector<Object*> scene_objects; 

    //start with a blank pixel 
    double tempRed[aadepth*aadepth]; 
    double tempGreen[aadepth*aadepth]; 
    double tempBlue[aadepth*aadepth]; 

}; 

und die Verzögerung der anderen Variablen.

void Thread::define() 
{ 

    //Calling Vect.h and establishing the XYZ positions 
    Vect O(0, 0, 0); 
    Vect X(3, 0, 3.5); 
    Vect Y(0, 1, 0); 
    Vect Z(0, 0, 1); 
    Vect P(5.5, 0, 3.5); 
    Vect R(0, -3, 0); 
    Vect M(7, 0, -5); 

    Vect new_sphere_location(2, 0, 0); 

    Vect campos(4, 1, -4); 

    Vect look_at(0, 0, 0); 
    Vect diff_btw(campos.getVectX() - look_at.getVectX(), campos.getVectY() - look_at.getVectY(), campos.getVectZ() - look_at.getVectZ()); 

    //camera direction and position 
    camdir = diff_btw.negative().normalize(); 
    camright = Y.crossProduct(camdir).normalize(); 
    camdown = camright.crossProduct(camdir); 
    Camera scene_cam(campos, camdir, camright, camdown); 

    //color of objects and planes 
    Color white_light(1.0, 1.0, 1.0, 0); 
    Color pretty_green(0.25, 0.25, 0.95, 0.5); 
    Color maroon(0.5, 0.25, 0.25, 0.5); 
    Color tile_floor(1, 1, 1, 2); 
    Color gray(0.5, 0.5, 0.5, 0); 
    Color black(0.0, 0.0, 0.0, 0); 

    //light color and position 
    Vect light_position(-7, 10, -10); 
    Light scene_light(light_position, white_light); 
    light_sources.push_back(dynamic_cast<Source*>(&scene_light)); 

    //scene objects 
    Sphere scene_sphere(O, 0.85, pretty_green); 
    Sphere scene_sphere2(new_sphere_location, 0.5, maroon); 
    Plane scene_plane(Y, -1, tile_floor); 
    Plane scene_plane2(P, -1, gray); 
    Plane scene_plane3(X, 1, gray); 
    Plane scene_plane4(R, -1, tile_floor); 
    Plane scene_plane5(M, -1, black); 

    scene_objects.push_back(dynamic_cast<Object*>(&scene_sphere)); 
    scene_objects.push_back(dynamic_cast<Object*>(&scene_sphere2)); 
    scene_objects.push_back(dynamic_cast<Object*>(&scene_plane)); 
    scene_objects.push_back(dynamic_cast<Object*>(&scene_plane2)); 
    scene_objects.push_back(dynamic_cast<Object*>(&scene_plane3)); 
    scene_objects.push_back(dynamic_cast<Object*>(&scene_plane4)); 
    scene_objects.push_back(dynamic_cast<Object*>(&scene_plane5)); 

} 

So. Wenn ich die Funktion define() in der main() Funktion mit einem Objekt aufrufen, bekomme ich einen schwarzen Bildschirm als Bildausgabe. Wenn ich die Funktion define() in der Berechnungsfunktion aufrufe, stürzt das Programm sofort beim Start ab. Wenn ich den Inhalt der define() Funktion in die Klasse private: verschiebe, bekomme ich Fehler für die Deklarationen.

Alle Variablen in der define() müssen gesehen werden, aber ich weiß nicht, wie es geht.

Wie behebe ich das? Es funktioniert nicht und ich bekomme nur ein schwarzes Bild als Ergebnis oder es stürzt einfach ab.

Sorry, wenn etwas unklar ist (dies ist meine erste Frage zu stackoverflow).

Vielen Dank!

Answer 1

Ich weiß nicht genau, wo ist das Problem, das den schwarzen Bildschirm verursachen, aber ich bin nicht über den Absturz überrascht.

Sie sollten berücksichtigen, dass Variablen (und relative Werte), die in einer Methode deklariert sind, wie in define(), verloren gehen, wenn die Methode die Ausführung beendet.

So sehen Sie den folgenden Code

Sphere scene_sphere(O, 0.85, pretty_green); 
Sphere scene_sphere2(new_sphere_location, 0.5, maroon); 
Plane scene_plane(Y, -1, tile_floor); 
Plane scene_plane2(P, -1, gray); 
Plane scene_plane3(X, 1, gray); 
Plane scene_plane4(R, -1, tile_floor); 
Plane scene_plane5(M, -1, black); 

scene_objects.push_back(dynamic_cast<Object*>(&scene_sphere)); 
scene_objects.push_back(dynamic_cast<Object*>(&scene_sphere2)); 
scene_objects.push_back(dynamic_cast<Object*>(&scene_plane)); 
scene_objects.push_back(dynamic_cast<Object*>(&scene_plane2)); 
scene_objects.push_back(dynamic_cast<Object*>(&scene_plane3)); 
scene_objects.push_back(dynamic_cast<Object*>(&scene_plane4)); 
scene_objects.push_back(dynamic_cast<Object*>(&scene_plane5)); 

Sie erklären sieben lokale Variablen (scene_sphere, scene_sphere2, etc.) und neben ihr ihre Zeiger hinzufügen (ich nehme an, dass Object ist eine Basisklasse für Sphere und Plane) in ein Mitglied der Klasse (scene_objects).

Wenn define() die Ausführung beenden, beenden die sieben Variablen (scene_sphere, scene_sphere2 usw.) ihre Lebensdauer und ihr Speicher wird freigegeben. Die sieben Zeiger in scene_objects zeigen also auf den freigegebenen Stapelspeicher, der für andere Variablen wiederverwendet werden kann.

Wenn Sie (wenn Sie versuchen) einen der sieben Zeiger verwenden, ist es sehr wahrscheinlich, dass das Programm abstürzt.

gleiche Problem mit

Light scene_light(light_position, white_light); 
light_sources.push_back(dynamic_cast<Source*>(&scene_light)); 

nehme ich an Sie die dynamische Zuordnung verwendet werden soll (new) auf diese Weise

light_sources.push_back(new Light(light_position, white_light)); 

// ... 

scene_objects.push_back(new Sphere(O, 0.85, pretty_green)); 
scene_objects.push_back(new Sphere(new_sphere_location, 0.5, maroon)); 
scene_objects.push_back(new Plane(Y, -1, tile_floor)); 
scene_objects.push_back(new Plane(P, -1, gray)); 
scene_objects.push_back(new Plane(X, 1, gray)); 
scene_objects.push_back(new Plane(R, -1, tile_floor)); 
scene_objects.push_back(new Plane(M, -1, black)); 

so die spitzen Gegenstand das Ende define() überleben können.

Aber denken Sie daran, delete sie wenn angemessen, wenn Sie Leckspeicher nicht wollen.

Oder, besser, Sie können Smart Pointer (std::unique_ptr durch Beispiel) anstelle von einfachen Zeigern verwenden.

ps .: Entschuldigung für mein schlechtes Englisch