~/cg/12/Shader.hxx||In constructor »EnvShader::EnvShader(Scene*, const Vec3f&, const std::string&, const std::string&, const std::string&, const std::string&, const std::string&, const std::string&)«:|
~/cg/12/Shader.hxx|26|Fehler: »Shader::Shader()« ist privat|
~/cg/12/EnvShader.cxx|19|Fehler: in diesem Zusammenhang|
||=== Build finished: 2 errors, 0 warnings ===|

Die Basisklasse wird von vielen Shadern benutzt. Dieser ist der einzige der Rumzickt. Ich verstehe einfach nicht wo ich den leeren Konstruktor der Basisklasse aufrufen soll.

Auch bei testweise eingeführten EnvShader(int i) der gar nichts macht hat er rumgemeckert. Ich bin einfach mit meinem Latein am Ende.

Basisklasse:

#ifndef SHADER_HXX
#define SHADER_HXX

#include "Vec3f.hxx"
#include "Ray.hxx"

class Scene;

#define RecursionDepth 10

class Shader
{
public:
  Shader(Scene* scene);

  virtual ~Shader();

  virtual Vec3f Shade(Ray& ray) = 0;
  virtual int getMagicNumber();
  Scene* getScene();
protected:
  Scene* m_scene;

private:
  Shader();
  Shader(const Shader& );
  Shader& operator=(const Shader& );
};
#endif

Abgeleitete Klasse:

#ifndef ENVSHADER_HXX_INCLUDED
#define ENVSHADER_HXX_INCLUDED

#include "Shader.hxx"
#include "Texture.hxx"
#include "Box.hxx"
#include <string>

class EnvShader : public Shader
{
public:
          EnvShader(Scene* scene,
	      const Vec3f& ambient_color,
	      const std::string& left,
	      const std::string& right,
	      const std::string& front,
	      const std::string& back,
	      const std::string& up,
	      const std::string& down);

  virtual ~EnvShader();

  virtual Vec3f Shade(Ray& ray);

private:
  EnvShader();
  Vec3f m_ambient_color;
  Texture* m_left;
  Texture* m_right;
  Texture* m_front;
  Texture* m_back;
  Texture* m_up;
  Texture* m_down;
  Box m_box;
  Scene* m_scene;
};
#endif // ENVSHADER_HXX_INCLUDED

C++ Code der Abgeleiteten Klasse:

#include "EnvShader.hxx"
#include "FlatShader.hxx"
#include "Primitive.hxx"
#include "Vec3f.hxx"
#include "Scene.hxx"
#include <math.h>
#include "InfinitePlane.hxx"
#include "TexturedSmoothTriangle.hxx"

EnvShader::EnvShader(Scene* scene,
	      const Vec3f& ambient_color,
	      const std::string& left,
	      const std::string& right,
	      const std::string& front,
	      const std::string& back,
	      const std::string& up,
	      const std::string& down) : m_ambient_color(ambient_color), m_scene(scene)
{
    std::cout << "ENV Shader constructor\n";
    m_left = new Texture(left);
    m_right = new Texture(right);
    m_front = new Texture(front);
    m_back = new Texture(back);
    m_up = new Texture(up);
    m_down = new Texture(down);
}

EnvShader::~EnvShader()
{
    delete(m_left);
    delete(m_right);
    delete(m_up);
    delete(m_down);
    delete(m_front);
    delete(m_back);

}

Vec3f
EnvShader::Shade(Ray& ray)
{
 return(Vec3f(0,0,0)); // make it simple
}

Wäre echt super wenn ihr mir helfen könntet.

Ruf in EnvShader den Konstruktor Shader::Shader(Scene*) auf.

// Statt
#include <math.h>
// Verwendet man eigentlich (Nun im namespace std)
#include <cmath>

Weitere Anmerkung: Du solltest in deiner Klasse entweder einen privaten Kopierkonstruktor und Zuweisungsoperator deklarieren (ohne Implementation), oder diese explizit schreiben. Ansonsten wirst du noch recht früh feststellen, wie es ist wenn die Zeiger bereits gelöscht sind...

Falls du es nachvollziehen willst:

EnvShader shader(/* deine Parameter */);
{
    EnvShader shader2 = shader;
} // <-- Hier sind die Zeiger in shader bereits gelöscht, da flache Kopie...

Dann lieber auf Kopie/Zuweisung verzichten, oder explizit schreiben. Ich würde erst einmal folgenden Code hinzufügen, dann meckert der Compiler wenn du irgendwo Kopie erzeugen willst, oder eine Zuweisung machst (Und kannst dann noch immer entscheiden ob du sie brauchst).

//... [Klasse EnvShader]
private:
    EnvShader(EnvShader const &);
    EnvShader& operator=(EnvShader const &);
//...

cu André