Visual Studio macht probleme

Moment ich habe gerade was festgestellt.Ich habe einfach vor dem Aufrug von _parent->ChangePane(it->second); (siehe Bild) so ein Debug Punkt gesetzt.
An dem Zeitpunkt ist this okey.
Wenn ich mir ohne den Debupg point den Fehler anzeigen lasse, ist this nicht mehr in Ordnung, also liegt es wohl an diesem Aufruf.

Nexus

Sind _parent und it gültig?

Ich sehe gerade _parent ist ungültig, obwohl es ein member ist ?

Nexus

Dann verfolge _parent weiter im Debugger. Speziell die Initialisierung, aber auch danach.

Sollte ich _parent nicht als Referenz erstellen ?

Die Initialisierung sieht nicht falsch aus:

Hier wird das _parent in den Konsturktor übergeben:

IResult IMenuSystem::Initialize()
{
	//....
	IMenuPane* _pmain = new IMenuPane(FindChild(_sMenuScene,"menu_main"),this);

und so sieht der Konstruktor aus:

IMenuPane::IMenuPane(TEntity node,IMenuSystem* parent) : _parent(parent)
{
	_camNode = node;
	_state = P_NONE;

}

Jetzt komm ich der Sache schon näher:

void IMenuPane::ButtonSignal(IMenuButton* b )
{
	if(b)
	{
	std::map<IMenuButton*,IMenuPane*>::iterator it; // Hier ist _parent noch okey
	for(it = _mButtonSignals.begin(); it != _mButtonSignals.end(); it++)
	{
		if(it->first == b )
		{
			_parent->ChangePane(it->second);  // Hier nicht mehr
			break;
		}
	}
	}

}

Wie kann das sein, dass sich _parent hier verändert ? Es wird ja nicht aufgerufen, auch wird nichts mit dem Objekt gemacht

So habe das glaub ich jetzt gelöst, einfach _parent durch it->second->_parent ersetzt.Jetzt bekomme ich wieder diesen Fehler wie auf dem Bild.

Ich weiß auch garnicht was dort der Fehler sein soll.IGameManager ist eingendlich so eine Art interface pattern, was einfach als einzigen Member einen IComponentManager hat und diesen einfach Updatet,Initialisiert,Löscht.

Dieser wird auch niergendwo übergeben.

OHHHHHHHHHHHHHH GOTT dieses Scheiß Programm.
Immer wieder dieses Problem mit _parent, diesmal is this undefiniert.....WTF
Das Programm ist schon seit 2 Monaten am Laufen und ich hatte wirklich noch nie Problemme damit, dass ohne VS 2010 laufen zu lassen, ich glaube ich lass es einfach und mach normal weiter.

Mal gucken, wenn ich morgen nichts finde dann weiß ich auch nicht....

Athar

Bob Wolfskin schrieb:

Wie kann das sein, dass sich _parent hier verändert ?

Das fragst du am besten ChangePane()...

Bob Wolfskin schrieb:

So habe das glaub ich jetzt gelöst, einfach _parent durch it->second->_parent ersetzt.

Naja, entweder es gibt eine gute Begründung, warum das vorher falsch war und nun richtig ist, oder die Änderung ist falsch.

Sinn und Zweck der ButtonSignal()-Funktion ist mir auch nicht ganz klar. Sieht auf den ersten Blick so aus, als wäre das designmäßig eher von hinten aufgezäumt. Ein Klick auf einen Menu-Button führt dazu, dass alle Menu-Panes gefragt werden, ob sie denn nicht mal das zum Button gehörige Menu-Pane aktivieren könnten, oder wie muss man das verstehen?

Es soll so funktionieren:

Auf einem Pane sind Buttons.(Ah ja es ist ein 3D Menu)
Die Panes stehen für Menüabschnitt wie Main-Menu,Options.....

Im IMenuSystem werden alle Panes und Komponenten erstellt.( Polymoph, alle Komponenten haben die klasse IComponent, jedoch können sie von den Klassen IMenuButton,IMenuSlider... sein).

Man fügt also einem Button ein singalpane hinzu, d.h wenn man auf diesen Button drückt, soll der zum diesem Pane wechseln.

Man fügt dem Button also mit SetButtonSignalPane das erwünschte Pane hinzu, was in einer map gespeichert wird ( diese map ist member von IMenuSystem).
Wird jetzt auf ein Button geklickt ruft er IMenuPane::ButtonSignal(this) auf.
Dort wird dann geguckt ob es du diesem Button ein Signal gibt ( ein IMenuPane). Wenn ja soll durch das IMenuSystem zum diesem Pane gewechselt werden.
Tada

Ah ja hier ist eine etwas ältere version davon:
http://www.youtube.com/watch?v=ALLm0MOijME

Nexus

Bob Wolfskin schrieb:

ich glaube ich lass es einfach und mach normal weiter.

Davon würde ich abraten. Wenn du einem Bug auf der Spur bist, und besonders wenn es sich um UB handeln könnte, merze ihn so schnell es geht aus! Sonst wird dir das mit Sicherheit eines Tages zum Verhängnis...

Du debuggst schon im Debug-Modus und hast alle Debug-Symbole aktiviert? Nur um offensichtliche Fehler auszuschliessen...

Athar

Bob Wolfskin schrieb:

( diese map ist member von IMenuSystem).
Wird jetzt auf ein Button geklickt ruft er IMenuPane::ButtonSignal(this) auf.

Und hier hakt es mit meinem Verständnis: die Map wird vom Menu-System verwaltet, aber ButtonSignal ist keine Methode von IMenuSystem, sondern IMenuPane. Für welches Menu-Pane rufst du denn die Methode auf und warum gerade dieses? Ist die Methode statisch? Wenn ja, was ist dann _parent? Wieso hat ButtonSignal() Zugriff auf Member von IMenuSystem?

Aufgrund der verschachtelten Panes würde ich aber nun eher erwarten, dass _parent auf das besitzende Menu-Pane zeigt (für das Hauptmenü also nullptr!), _mButtonSignals die eigenen Buttons auf die Sub-Panes mappt und dass ChangePane für die eigene Instanz aufgerufen wird (statt auf _parent), um ein neues Sub-Pane anzuzeigen.
So ist das etwas verwirrend und wenn da im irgendwo ein Fehler drinsteckt, würde es mich nicht wundern.

Bob Wolfskin schrieb:

Ah ja hier ist eine etwas ältere version davon:
http://www.youtube.com/watch?v=ALLm0MOijME

Sieht ja immerhin schon mal schick aus

Also jeder button hat als parent sein pane.ich denke das design ist soweit okey.wenn ein button gedrückt wird wendet es sich an das parentpane und ruft die buttpnsignal Funktion auf und über gibt sich selbst.jedes Pane hat ein patent menusystem.dort wendet es sich hin zum wechseln des panes.weil im menusystem wird das ganze gemacht.

Hey also ich werde gleich mal weitersuchen.
Jedoch stelle ich einfach mal den Code der 3 klassen hier rein mit der Hoffnung dass es biiitttteee jemand nachguckt.

IMenuSystem.h

#ifndef IMENUSYSTEM_H_
#define IMENUSYSTEM_H_

#include "IComponent.h"
#include "engine.h"
#include "PathDefine.h"
#include "IEngineSystem.h"
#include "IMenuPane.h"
#include "IProfileManager.h"

class IMenuButton;

class IMenuSystem : public IComponent
{
public:
	friend class IMenuButton;
	friend class IMenuPane;

	IMenuSystem();
	~IMenuSystem();

	IResult Initialize();
	IResult Terminate();
	void Update();
	inline void ButtonQuitCode() { MessageBoxA(0,"Quit",0,0); }

	IResult AddPane(IMenuPane*,TVec3,TVec3);

	bool _stateReady;
	TVec3 rot;

	//------------Effects-------------------------//
	int rand_min;
	int rand_max;
	float rand_out;
	float chromatic_strenght;
	//--------------------------------------------//

private:

	TCamera _cSceneCamera;
	TEntity _sMenuScene;
	ISmartPointer<IEngineSystem> _iEngineSystem;

	IMenuPane* _pFocusPane;
	std::vector<IMenuPane*> _vPanes;

	IResult ChangePane(IMenuPane* signal);

	void IncreaseValue(std::string name,float value);
	void DecreaseValue(std::string name,float value);

	TVec3 position;
	TVec3 rotation;

	float move,strafe,mx,my;

	//********************************************//

	void UpdateEffects();

	//********************************************//

private:        // option values for slider

	std::map<std::string,float> _optionsMap;

private:        //Camera movement from node to node

	TVec3 _currentPosition;
	TVec3 _currentRotation;

	TEntity _nextNode;

	TVec3 _posAccels;
	TVec3 _rotAccels;

	int _currentSteps;
	bool _cameraMovement;

	double _startDistance;
	double _currentFunctionValue;

	void UpdateCameraMovement();
	void UpdatePaneChanges();
	inline void SetCameraMovement(TEntity node) { 
		_currentSteps = (int)(30.0f / AppSpeed());
		_currentPosition = EntityPosition(_cSceneCamera,1);
		_currentRotation = EntityRotation(_cSceneCamera,1);
		_cameraMovement = true; 
		_nextNode = node; 
		_posAccels = (EntityPosition(node,1) - EntityPosition(_cSceneCamera,1)) / (float)_currentSteps;
		_rotAccels = (EntityRotation(node,1) - EntityRotation(_cSceneCamera,1)) / (float)_currentSteps;

		_currentFunctionValue = -90.0f;
		_startDistance = EntityDistance(IEngineSystem::Inst()->GetCamera(),_nextNode);

	}

private:

	///////////////////////////////////////////////////////////////
	// Signals
	//

	void HandleSignals();

	//
	//
	///////////////////////////////////////////////////////////////

private:

	///////////////////////////////////////////////////////////////
	// /brief
	// 
	//
	// This is a section for the Profilemanager.
	// Manager here the function of the continue and new game button
	// 
	// With the profilemanager a new profile is created and saved
	// For cthe continue button just check if a profile is allready
	// created and change the state to the game state
	//
	////////////////////////////////////////////////////////////////

	ISmartPointer<IProfileManager> _pProfileManager;

	/////////////////////////////////////
	// Create bool for signal activision
	//
	//
	/////////////////////////////////////

	bool b_signal_continue;
	bool b_signal_newgame;
};

#endif

IMenuSystem.cpp

#include "IMenuSystem.h"
#include "IConsole.h"
#include "IMenuButton.h"
#include "ISoundSystem.h"
#include "IMenuSlider.h"
#include "IMenuLabel.h"
#include "IMenuTextSlider.h"
#include "PathDefine.h"

IMenuSystem::IMenuSystem() : _stateReady(false),
	                         _iEngineSystem(IEngineSystem::Inst()),
							 _pProfileManager(new IProfileManager())

{
	rot = Vec3(0);
	move = 0.0f;
	strafe = 0.0f;
	mx = 0.0f;
	my = 0.0f;
	_cameraMovement = false;

	//////////////////////////////////////////////
	// Signals reset
	//

	b_signal_continue = false;
	b_signal_newgame = false;

	//
	//
	//////////////////////////////////////////////
}

IMenuSystem::~IMenuSystem()
{

}

IResult IMenuSystem::Initialize()
{
	IConsole::inst()->Debug("IMenuSystem Initialized!");
	IEngineSystem::Inst()->ActivateRendering(true); // enable rendering for video

	_cSceneCamera = _iEngineSystem->GetCamera();
	_sMenuScene = LoadScene("abstract::menu_sc.sbx");

	if(!_sMenuScene)
		IConsole::inst()->Debug("No Menu Scene ");

	/////////////////////////////////////////////////////////////////////////////////////

	IMenuPane* _pmain = new IMenuPane(FindChild(_sMenuScene,"menu_main"),this);
	IMenuPane* _p_options = new IMenuPane(FindChild(_sMenuScene,"menu_options"),this);
	IMenuPane* _p_options_display = new IMenuPane(FindChild(_sMenuScene,"menu_display"),this);
	IMenuPane* _p_singleplayer = new IMenuPane(FindChild(_sMenuScene,"menu_singleplayer"),this);

	_pmain->Initialize();
	_p_options->Initialize();
	_p_options_display->Initialize();
	_p_singleplayer->Initialize();

	_pFocusPane = _pmain;  // set the main menu in focus

	PositionEntity(_cSceneCamera,EntityPosition(_pmain->_camNode,1),1);
	RotateEntity(_cSceneCamera,EntityRotation(_pmain->_camNode,1),1);

	//************************************************************************//

	IMenuButton* _msingleplayer = new IMenuButton(this);
	IMenuButton* _mmultiplayer = new IMenuButton(this);
	IMenuButton* _moptions = new IMenuButton(this);
	IMenuButton* _mmods = new IMenuButton(this);
	IMenuButton* _mcredits = new IMenuButton(this);
	IMenuButton* _mquit = new IMenuButton(this);

	_msingleplayer->Initialize(LoadMesh("abstract::singleplayer.gmf"));
	_mmultiplayer->Initialize(LoadMesh("abstract::multiplayer.gmf"));
	_moptions->Initialize(LoadMesh("abstract::options.gmf"));
	_mmods->Initialize(LoadMesh("abstract::mods.gmf"));
	_mcredits->Initialize(LoadMesh("abstract::credits.gmf"));
	_mquit->Initialize(LoadMesh("abstract::quit.gmf"));

	//_mquit->SetActiveSignal(&IEngineSystem::Inst()->_quitSystems);

	_pmain->AddComp(_msingleplayer,Vec3(0,4.5,0),Vec3(0,0,0));
	_pmain->AddComp(_mmultiplayer,Vec3(-0.4,3.3,0),Vec3(0,0,0));
	_pmain->AddComp(_moptions,Vec3(0,2.1,0),Vec3(0,0,0));
	_pmain->AddComp(_mmods,Vec3(0.2,0.9,0),Vec3(0,0,0));
	_pmain->AddComp(_mcredits,Vec3(0.5,-0.3,0),Vec3(0,0,0));
	_pmain->AddComp(_mquit,Vec3(-0.1,-1.5,0),Vec3(0,0,0));

	AddPane(_pmain,Vec3(0,1,2.52),Vec3(0));   //Add to menu system

	_pmain->SetButtonSignalPane(_msingleplayer,_p_singleplayer); // Set button singla for singleplayer
	_pmain->SetButtonSignalPane(_moptions,_p_options);  // Set button signal of options

	//************************************************************************//

	IMenuButton* _button_options_graphics = new IMenuButton(this);
	IMenuButton* _button_options_display = new IMenuButton(this);
	IMenuButton* _button_options_sound = new IMenuButton(this);
	IMenuButton* _button_options_control = new IMenuButton(this);

	_button_options_display->Initialize(LoadMesh("abstract::button_display.gmf"));
	_button_options_sound->Initialize(LoadMesh("abstract::button_sound.gmf"));
	_button_options_graphics->Initialize(LoadMesh("abstract::button_graphics.gmf"));
	_button_options_control->Initialize(LoadMesh("abstract::button_control.gmf"));

	_p_options->AddComp(_button_options_display,Vec3(0.1f,1.0f,0.0f),Vec3(0.0f,0.0f,0.0f));
	_p_options->AddComp(_button_options_graphics,Vec3(0.2f,-0.2f,0.0f),Vec3(0.0f,0.0f,0.0f));
	_p_options->AddComp(_button_options_sound,Vec3(-0.2f,-1.5f,0.0f),Vec3(0.0f,0.0f,0.0f));
	_p_options->AddComp(_button_options_control,Vec3(0.0f,-2.7f,0.0f),Vec3(0.0f,0.0f,0.0f));

	AddPane(_p_options,Vec3(2.0f,1.0f,1.2f),Vec3(0.0f,-90.0f,0.0f));

	_p_options->SetButtonSignalPane(_button_options_display,_p_options_display);

	IMenuLabel* _label_options_display_resolution = new IMenuLabel(this);
	IMenuLabel* _label_options_display_fullscreen = new IMenuLabel(this);
	IMenuTextSlider* _slider_options_display = new IMenuTextSlider(this);
	IMenuSlider* _slider_options_display_fullscreen = new IMenuSlider(this,1,1.0);
	IMenuLabel* _label_options_display_vsync = new IMenuLabel(this);
	IMenuSlider* _slider_options_display_vsync = new IMenuSlider(this,1,1.0);
	IMenuLabel* _label_options_display_brightness = new IMenuLabel(this);
	IMenuSlider* _slider_options_display_brightness = new IMenuSlider(this,9,1.0);

	_label_options_display_resolution->Initialize(LoadMesh("abstract::label_resolution.gmf"));
	_slider_options_display->Initialize(NULL);
	_label_options_display_fullscreen->Initialize(LoadMesh("abstract::label_fullscreen.gmf"));
	_slider_options_display_fullscreen->Initialize(NULL);
	_slider_options_display_vsync->Initialize(NULL);
	_label_options_display_vsync->Initialize(LoadMesh("abstract::label_vsync.gmf"));
	_label_options_display_brightness->Initialize(LoadMesh("abstract::label_brightness.gmf"));
	_slider_options_display_brightness->Initialize(NULL);

	_slider_options_display->AddOption("abstract::800x600.gmf",800,600);
	_slider_options_display->AddOption("abstract::1024x768.gmf",1024,768);
	_slider_options_display->AddOption("abstract::1280x800.gmf",1280,800);
	_slider_options_display->AddOption("abstract::1280x1024.gmf",1280,1024);
	_slider_options_display->AddOption("abstract::1366x768.gmf",1366,768);
	_slider_options_display->AddOption("abstract::1440x900.gmf",1440,900);
	_slider_options_display->AddOption("abstract::1600x900.gmf",1600,900);
	_slider_options_display->AddOption("abstract::1680x1050.gmf",1680,1050);
	_slider_options_display->AddOption("abstract::1920x1080.gmf",1920,1080);
	_slider_options_display->AddOption("abstract::1920x1200.gmf",1920,1200);

	_p_options_display->AddComp(_label_options_display_resolution,Vec3(0.52f,0.7f,0),Vec3(0));
	_p_options_display->AddComp(_slider_options_display,Vec3(0.7f,0.5f,-0.1f),Vec3(0.0f,-45.0f,0.0f));
	_p_options_display->AddComp(_label_options_display_fullscreen,Vec3(0.55f,0.30,0),Vec3(0));
	_p_options_display->AddComp(_slider_options_display_fullscreen,Vec3(1.0f,0.13f,-0.2f),Vec3(0.0f,-45.0f,0.0f));
	_p_options_display->AddComp(_label_options_display_vsync,Vec3(0.55f,0.0f,0),Vec3(0));
	_p_options_display->AddComp(_slider_options_display_vsync,Vec3(1.0f,-0.11f,-0.2f),Vec3(0.0f,-45.0f,0.0f));
	_p_options_display->AddComp(_label_options_display_brightness,Vec3(0.55f,-0.35f,0),Vec3(0));
	_p_options_display->AddComp(_slider_options_display_brightness,Vec3(0.7f,-0.5f,-0.1f),Vec3(0.0f,-45.0f,0.0f));

	AddPane(_p_options_display,Vec3(2.0f,1.3f,-1.2f),Vec3(0.0f,-90.0f,0.0f));

	IMenuButton* _button_singleplayer_continue = new IMenuButton(this);
	IMenuButton* _button_singleplayer_newgame = new IMenuButton(this);

	_button_singleplayer_continue->Initialize(LoadMesh("abstract::sp_continue.gmf"));
	_button_singleplayer_newgame->Initialize(LoadMesh("abstract::sp_newgame.gmf"));

	_p_singleplayer->AddComp(_button_singleplayer_continue,Vec3(-0.4f,0.0f,0.0f),Vec3(0));
	_p_singleplayer->AddComp(_button_singleplayer_newgame,Vec3(0.0f,-1.2f,0.0f),Vec3(0));

	_button_singleplayer_continue->SetActiveSignal(&b_signal_continue);
	_button_singleplayer_newgame->SetActiveSignal(&b_signal_newgame);

	AddPane(_p_singleplayer,Vec3(0.0f,2.2f,0.5f),Vec3(-90.0f,0.0f,0.0f));

	//************************************************************************//

	/////////////////////////////////////////////////////////////////////////////////////
	_currentSteps = 70;
	IConsole::inst()->AddItem("Function",_currentSteps);

	/////////////////////////////////////////////////////////////////////////////////////

	rand_min = 0;
	rand_max = 30;
	chromatic_strenght = 1.0f;

	IConsole::inst()->AddItem("Lol",_iEngineSystem->Inst()->_fchromatic_shader);

	ISoundSystem::Inst()->Play_Menu_Background();  //Play Background sound
	ShowEntity(IEngineSystem::Inst()->GetCamera());

	return IRESULT_OK;
}

IResult IMenuSystem::Terminate()
{

	return IRESULT_OK;
}

void IMenuSystem::Update()
{
	if(MouseDown(2))
	{
	mx = MouseX() - GraphicsWidth()/2;
	my = MouseY() - GraphicsHeight()/2;
	MoveMouse(GraphicsWidth()/2,GraphicsHeight()/2);
	rot.X += my/20.0f;
	rot.Y -= mx/20.0f;
	RotateEntity(_cSceneCamera,rot);
	}

	move = (KeyDown(KEY_W)-KeyDown(KEY_S))/10.0f;
	strafe = (KeyDown(KEY_D)-KeyDown(KEY_A))/10.0f;
	MoveEntity(_cSceneCamera,Vec3(strafe,0,move));

	UpdateEffects();

	for(std::vector<IMenuPane*>::iterator it = _vPanes.begin(); it != _vPanes.end();it++)
	{
		static_cast<IMenuPane*>(*it)->Update();
	}

	UpdateCameraMovement();
	UpdatePaneChanges();

	HandleSignals();

}

void IMenuSystem::UpdateEffects()
{
	//----------Chromatic----------//
	rand_out = (float)rand() / rand_max;
	if(rand_out > 17.0)
	{
		chromatic_strenght = LE::Curve(rand_out/300.0,chromatic_strenght,10.0f);
	}
	else
	{
		chromatic_strenght = LE::Curve(0.0f,chromatic_strenght,5.0f);
	}

	_iEngineSystem->Inst()->_fchromatic_shader = chromatic_strenght;

}

IResult IMenuSystem::AddPane(IMenuPane* pane,TVec3 pos,TVec3 rot)
{
	_vPanes.push_back(pane);
	PositionEntity(pane->_piv,pos);
	RotateEntity(pane->_piv,rot);

	return IRESULT_OK;
}

IResult IMenuSystem::ChangePane(IMenuPane* signal)
{
	SetCameraMovement(signal->_camNode);
	ISoundSystem::Inst()->Play_Menu_Whoosh();
	_pFocusPane = signal;
	return IRESULT_OK;
}

void IMenuSystem::UpdateCameraMovement()
{
	if(_cameraMovement)
	{
		if(EntityDistance(IEngineSystem::Inst()->GetCamera(),_nextNode) > 0.01)
		{
           _currentPosition += _posAccels * (sin(_currentFunctionValue * 3.14159636 / 180.0)+1.2);
		   _currentRotation += _rotAccels * (sin(_currentFunctionValue * 3.14159636 / 180.0)+1.2);
		}
		else
		{
			_cameraMovement = false;
		}
		PositionEntity(_cSceneCamera,_currentPosition,1);
		RotateEntity(_cSceneCamera,_currentRotation,1);

		_currentFunctionValue = -(360 / _startDistance) * EntityDistance(IEngineSystem::Inst()->GetCamera(),_nextNode) + 270.0;

	}

}

void IMenuSystem::UpdatePaneChanges()
{
	if(KeyHit(KEY_ESCAPE))
	{
		if(_pFocusPane && _pFocusPane->_backPane.get())
		{
			ChangePane(_pFocusPane->_backPane.get());
		}

	}

}

void IMenuSystem::HandleSignals()
{
	if(b_signal_continue)
	{
		/////////////////////////////////
		// 
		// 
		//
		// Else do nothing
		/////////////////////////////////
		if(IProfileManager::CheckForExistingProfile() == IRESULT_OK)
		{
			_stateReady = true;  //change state
		}
	}

	if(b_signal_newgame)
	{
		/////////////////////////////////
		// 
		// Create a new Profile struct
		// and save it in a file
		//
		/////////////////////////////////

		IProfile _tmp_profile;  

		/////////////////////////////////
		//
		// Create Profile, standartconstructor
		// makes name and progressfilename
		// to unnamed and unnamed.prf
		//
		/////////////////////////////////

		IProfileManager::SaveProfile(_tmp_profile);
		// Save new profile with standart data

		/////////////////////////////////
		//
		// Change state to Game state

		_stateReady = true;  // !!!!!!!!!!!!!!!!!!

		//
		//
		/////////////////////////////////
	}

}

IMenuPane.h

#ifndef IMENUPANE_H_
#define IMENUPANE_H_

#pragma once

#include "GlobalDefine.h"
#include "IMenuComponent.h"
#include "engine.h"
#include "IMenuButton.h"

class IMenuPane : public IMenuComponent
{
public:

	friend class IMenuSystem;
	friend class IMenuButton;

	IMenuPane(TEntity node,IMenuSystem* parent);
	~IMenuPane();

	void Update();
	IResult Initialize();
	IResult Terminate();

	IResult AddComp(IMenuComponent*,TVec3,TVec3);
	inline IResult SetBackPane(IMenuPane* p) { _backPane.reset(p); return IRESULT_OK; }
	IMenuComponent* CheckEntity(TEntity check);

	void ButtonSignal(IMenuButton* b);
	inline void SetButtonSignalPane(IMenuButton* b,IMenuPane* p) { _mButtonSignals.insert( std::pair<IMenuButton*,IMenuPane*>(b,p)); p->_backPane.reset(this); }

	bool GetInteractState() { return _bPaneInteract; }

private:
	float pos;
	TEntity _piv;
	std::vector<IMenuComponent*> _components;
	std::vector<IMenuComponent*>::iterator _iterator;

	std::map<IMenuButton*,IMenuPane*> _mButtonSignals;

	IMenuSystem* const _parent ;
	ISmartPointer<IMenuPane> _backPane;

	bool _bPaneInteract;

	TEntity _camNode;

	TPick _raycast;
};

#endif

IMenuPane.cpp

#include "IMenuPane.h"
#include "IEngineSystem.h"
#include "IConsole.h"
#include "ISoundSystem.h"
#include "IMenuSlider.h"
#include "IMenuSystem.h"

IMenuPane::IMenuPane(TEntity node,IMenuSystem* parent) : _parent(parent)
{
	_camNode = node;
	_state = P_NONE;

}

IMenuPane::~IMenuPane()
{

}

//---------------Filter----------------//
int _stdcall Raycast_Filter(TEntity entity)
{
	return ( GetEntityType(entity) == 7 ) ? 1 : 0;
}

IResult IMenuPane::Initialize()
{
	//Create Pivote
	_piv = CreatePivot();
	pos = 0.0f;

	return IRESULT_OK;
}

IResult IMenuPane::Terminate()
{
	return IRESULT_OK;
}

void IMenuPane::Update()
{

	if(KeyHit(KEY_ENTER))
	{
		_bPaneInteract = true;
	}
	else
	{
		_bPaneInteract = false;
	}

	for(_iterator = _components.begin(); _iterator != _components.end(); _iterator++)
	{
		static_cast<IMenuComponent*>(*_iterator)->Update();

	}

	if(CameraPick(&_raycast,IEngineSystem::Inst()->GetCamera(),Vec3(MouseX(),MouseY(),200),1.0f,1))
	{
		if(!strcmp("BUTTON",GetEntityKey(_raycast.entity,"MENU")))
		{
			IMenuComponent* temp = (IMenuComponent*)GetEntityUserData(_raycast.entity);

			if(MouseHit(1))        // if moousehit click event to the button
			{
				if(temp->_state == B_SELECTED)
				temp->_state = B_PRECLICKED;	
			}
			else
			{
			if(temp->_state == B_UNSELECTED) 
				temp->_state = B_PRESELECTED;
			}
		}
		else if(!strcmp("SLIDER_L",GetEntityKey(_raycast.entity,"MENU")))
		{
			IMenuComponent* temp = (IMenuComponent*)GetEntityUserData(_raycast.entity);
			if(MouseHit(1) && temp->_state == S_SELECTED_LEFT)
			{
				temp->_state = S_PRECLICKED_LEFT;
				IConsole::inst()->Debug("Click");

			}
			else if(temp->_state == S_UNSELECTED)
			{
			    temp->_state = S_SELECTED_LEFT;
			}
		}
		else if(!strcmp("SLIDER_R",GetEntityKey(_raycast.entity,"MENU")))
		{
			IMenuComponent* temp = (IMenuComponent*)GetEntityUserData(_raycast.entity);
			if(MouseHit(1) && temp->_state == S_SELECTED_RIGHT)
			{
				temp->_state = S_PRECLICKED_RIGHT;
			}
			else if(temp->_state == S_UNSELECTED)
			{
			temp->_state = S_SELECTED_RIGHT;
			}
		}

		for(_iterator = _components.begin(); _iterator != _components.end(); _iterator++)
	    {   

		if(!strcmp("BUTTON",GetEntityKey(static_cast<IMenuComponent*>(*_iterator)->_mesh,"MENU")))
		{
			if(static_cast<IMenuComponent*>(*_iterator)->_mesh != _raycast.entity)
			{
			static_cast<IMenuComponent*>(*_iterator)->_state = B_UNSELECTED;
			}
		}
		if(!strcmp("SLIDER",GetEntityKey(static_cast<IMenuComponent*>(*_iterator)->_mesh,"MENU")))
		{
			if(static_cast<IMenuSlider*>(*_iterator)->_arrow_left != _raycast.entity && static_cast<IMenuSlider*>(*_iterator)->_arrow_right != _raycast.entity )
			{
			static_cast<IMenuSlider*>(*_iterator)->_state = S_UNSELECTED;
			}
		}
	    }

	}

}

IResult IMenuPane::AddComp(IMenuComponent* comp,TVec3 pos,TVec3 rot)
{
	_components.push_back(comp);

	PositionEntity(comp->_mesh,EntityPosition(_piv));
	RotateEntity(comp->_mesh,EntityRotation(_piv));

	EntityParent(comp->_mesh,_piv);

	MoveEntity(comp->_mesh,pos);
	RotateEntity(comp->_mesh,rot);

	comp->_parentPane = this;

	return IRESULT_OK;
}

IMenuComponent* IMenuPane::CheckEntity(TEntity check)
{
	for(_iterator = _components.begin(); _iterator != _components.end(); _iterator++)
	{
		if(static_cast<IMenuComponent*>(*_iterator)->_mesh == check)
		{
			return static_cast<IMenuComponent*>(*_iterator);
			break;
		}
	}
	return NULL;
}

void IMenuPane::ButtonSignal(IMenuButton* b )
{
	if(b)
	{
	std::map<IMenuButton*,IMenuPane*>::iterator it;
	for(it = _mButtonSignals.begin(); it != _mButtonSignals.end(); it++)
	{
		if(it->first == b )
		{
			it->second->_parent->ChangePane(it->second);
			break;
		}
	}
	}

}

IMenuButton.h

#ifndef IMENUBUTTON_H_
#define IMENUBUTTON_H_

#pragma once

#include "GlobalDefine.h"
#include "IMenuComponent.h"
#include "engine.h"

class IMenuSystem;
class IMenuPane;

class IMenuButton : public IMenuComponent
{
public:
	friend class IMenuSystem;
	friend class IMenuPane;

	IMenuButton(IMenuSystem* s);
	~IMenuButton();

	void Update();
	IResult Initialize(TEntity entity);
	IResult Terminate();

	inline void SetSignalPane(IMenuPane* p) { _signalPane.reset(p); }

	inline void SetActiveSignal(bool* b) { _activeSignal = b; }

private:
	TEntity _button;
	float y;

	ISmartPointer<IMenuSystem> _parentSystem;
	ISmartPointer<IMenuPane> _signalPane;

	bool* _activeSignal;
};

#endif

IMenuButton.cpp

#include "IMenuButton.h"
#include "IConsole.h"
#include "ISoundSystem.h"
#include "IEngineSystem.h"
#include "IMenuSystem.h"

IMenuButton::IMenuButton(IMenuSystem* s) : _parentSystem(s)
{
   _comp = BUTTON; // Set the commponent as a button
   _state = B_UNSELECTED;  // Set the button to not selected by default
   y = 0.01f;

}

IMenuButton::~IMenuButton()
{

}

IResult IMenuButton::Initialize(TEntity mesh)
{

	this->_mesh = CreateCube();
	SetEntityKey(_mesh,"MENU","BUTTON");
	SetEntityUserData(_mesh,(BYTE*)this);
	EntityType(_mesh,1); //Type 7 for raycast
	ScaleEntity(_mesh,Vec3((GetEntityAABB(mesh).X1 - GetEntityAABB(mesh).X0),(GetEntityAABB(mesh).Y1 - GetEntityAABB(mesh).Y0) + 0.02f,(GetEntityAABB(mesh).Z1 - GetEntityAABB(mesh).Z0)));
	PaintEntity(_mesh,LoadMaterial("abstract::invisible.mat"));

	this->_button = mesh;
	PositionEntity(_button,Vec3(EntityPosition(mesh).X,EntityPosition(_mesh).Y - (GetEntityAABB(_mesh).Y1 - GetEntityAABB(_mesh).Y0)/2.0f,EntityPosition(_mesh).Z));
	RotateEntity(_button,EntityRotation(mesh));
	EntityParent(_button,_mesh);

	return IRESULT_OK;
}

IResult IMenuButton::Terminate()
{
	return IRESULT_OK;
}

void IMenuButton::Update()
{
	PositionEntity(_button,Vec3(y,EntityPosition(_button).Y,EntityPosition(_button).Z));
	y = max(y,0.01f);
	y = min(y,0.14f);

	switch(_state)
	{
	case B_SELECTED:
		y += 0.007 * AppSpeed();
		PointEntity(IEngineSystem::Inst()->GetCamera(),_button,3,0.005f,0.0f);
		EntityColor(_button,Vec4(5.8f,0.55f,-0.6f,0.6f));
		break;
	case B_PRESELECTED:
		ISoundSystem::Inst()->Play_Menu_Button();
		_state = B_SELECTED;
		break;
	case B_UNSELECTED:
		EntityColor(_button,Vec4(1.0f,1.0f,1.0f,1.0f));
		y -= 0.007f * AppSpeed();
		break;

	case B_PRECLICKED:
		ISoundSystem::Inst()->Play_Menu_Confirm();
		_state = B_CLICKED;
		break;

	case B_CLICKED:
		EntityColor(_button,Vec4(5.8f,0.0f,-0.6f,0.6f));
		_parentPane->ButtonSignal(this);
		_state = B_SELECTED;

		if(_activeSignal) *_activeSignal = true;

		break;

	};

}

evtl. auch IMenuComponent.h

#ifndef IMENUCOMPONENT_H_
#define IMENUCOMPONENT_H_

#pragma once

#include "GlobalDefine.h"
#include "engine.h"

class IMenuPane;

class IMenuComponent
{
public:
	IMenuComponent() { }
	~IMenuComponent() { }

	virtual void Update() { }
	virtual IResult Initialize() { return IRESULT_OK; }
	virtual IResult Terminate() { return IRESULT_OK; }

	enum State{
		B_SELECTED = 0,
		B_PRESELECTED,
		B_UNSELECTED,
		B_PRECLICKED,
		B_CLICKED,
		S_SELECTED_LEFT,
		S_SELECTED_RIGHT,
		S_PRECLICKED_LEFT,
		S_PRECLICKED_RIGHT,
		S_CLICKED_LEFT,
		S_CLICKED_RIGHT,
		S_UNSELECTED,
		S_INCREASE,
		S_DECREASE,
		P_NONE                 //Pane does nothing
	} _state;

	enum Component{
		BUTTON = 0,
		SLIDER,
		LABEL
	} _comp;

	TEntity _mesh;
	IMenuPane* _parentPane;  // Error fix 1.0, don't use ISmartPointer for that, because the scope makes issues

};

#endif

Das wäre echt sehr lieb.
Danke

SeppJ

Bob Wolfskin schrieb:

Jedoch stelle ich einfach mal den Code der 3 klassen hier rein mit der Hoffnung dass es biiitttteee jemand nachguckt.

[...950 Zeilen Code...]

Das wäre echt sehr lieb.

Dazu kann man nur eines sagen, selbst wenn es unqualifiziert klingt: lol

dot

Schau dir mal an wofür das Call Stack Window beim Debuggen gut ist, könnte mir vorstellen dass dir das weiterhilft...

Dazu kann man nur eines sagen, selbst wenn es unqualifiziert klingt: lol

Ja man ich weiß Kann ja sein, dass jemand die Herausforderung sucht

Naja ein Versuch wars wert Werd mir gleich mal die Call Stack Window Zeugs da angucken

Heiliger Jesus endlich hab ich es rausbekommen.
Das war so ein scheiß billiger bool pointer ,der quasie als referenz dienen soll um bei einem Klick auf den Button ein eingetrageses bool zu ändern.

Dort stand einfach -> bool* _activeSignal; und bei switch-case vom Button if(_activeSignal) *_activeSignal = true; --> FAIL jetzt funktioniert alles super toll.
Ich war kurz davor wegen diesem scheiß fail pointer über 1000 Zeilen neu zu schreiben.....

Naja okey danke Leute für die Hilfe

Hör auf _ vor deine Variablen zu setzen^^.