void ParticleEditor::DrawParticleSystem()
{	
	m_manager->SetZPosition(0.0f);
	const VideoPtr& video = m_provider->GetVideo();
	const InputPtr& input = m_provider->GetInput();
	const Vector2 v2Screen = video->GetScreenSizeF();
	const bool overMenu = (input->GetCursorPosition(video).x<(int)m_menuWidth*2);
	if (input->GetLeftClickState() == GSKS_DOWN && !overMenu)
		m_v2Pos = input->GetCursorPositionF(video);
	else
		m_v2Pos = video->GetScreenSizeF()/2;

	if (input->GetKeyState(GSK_LEFT) == GSKS_DOWN)
		m_systemAngle+=2;
	if (input->GetKeyState(GSK_RIGHT) == GSKS_DOWN)
		m_systemAngle-=2;
	if (input->GetKeyState(GSK_UP) == GSKS_DOWN)
		m_systemAngle = 0.0f;
	if (input->GetKeyState(GSK_DOWN) == GSKS_DOWN)
		m_systemAngle = 180.0f;

	m_timer.CalcLastFrame();
	m_manager->UpdateParticleSystem(m_v2Pos, Vector3(m_v2Pos, 0), m_systemAngle, static_cast<float>(m_timer.GetElapsedTime() * 1000.0));

	video->SetScissor(Rect2D((int)m_menuWidth*2, 0, video->GetScreenSize().x-(int)m_menuWidth*2, video->GetScreenSize().y));
	if ((m_boundingSphere.IsActive() || m_boundingSphere.IsMouseOver()) && m_system.boundingSphere >= 1)
	{
		m_sphereSprite->SetOrigin(Sprite::EO_CENTER);
		m_sphereSprite->DrawShaped(m_v2Pos + ETHGlobal::ToVector2(m_manager->GetStartPos()),
								  Vector2(m_system.boundingSphere, m_system.boundingSphere),
								  BSPHERE_COLOR, BSPHERE_COLOR, BSPHERE_COLOR, BSPHERE_COLOR);
	}
	const bool zBuffer = video->GetZBuffer();
	video->SetZBuffer(false);
	
	if (m_provider->GetShaderManager()->BeginParticlePass(m_system))
	{
		m_manager->DrawParticleSystem(Vector3(1,1,1),v2Screen.y,-v2Screen.y, ETHParticleManager::SAME_DEPTH_AS_OWNER, ETH_DEFAULT_ZDIRECTION, Vector2(0,0), 1.0f);
		m_provider->GetShaderManager()->EndParticlePass();
		
	}
	video->SetZBuffer(zBuffer);
	video->UnsetScissor();

	if (m_manager->Finished() || m_manager->Killed())
	{
		ShadowPrint(Vector2(200.0f, video->GetScreenSizeF().y/2), REPLAY_MESSAGE, GS_L("Verdana14_shadow.fnt"), gs2d::constant::WHITE);
		if (input->GetKeyState(GSK_SPACE) == GSKS_HIT || input->GetLeftClickState() == GSKS_HIT)
		{
			m_manager->Play(m_v2Pos, Vector3(m_v2Pos, 0), m_systemAngle);
			m_manager->Kill(false);
		}
	}

	str_type::stringstream ss;
	ss << m_system.bitmapFile;
	ss << GS_L(" | ") << GS_L("Active particles: ") << m_manager->GetNumActiveParticles() << GS_L("/") << m_manager->GetNumParticles();
	const float infoTextSize = m_menuSize * m_menuScale;
	ShadowPrint(Vector2(m_menuWidth*2+5,v2Screen.y-infoTextSize-m_menuSize), ss.str().c_str(), GS_L("Verdana14_shadow.fnt"), gs2d::constant::WHITE);
}
std::string ProjectManager::DoEditor(SpritePtr pNextAppButton)
{
	GSGUI_BUTTON file_r = PlaceFileMenu();

	if (file_r.text == _S_NEW_PROJ)
	{
		SaveAs();
	}
	if (file_r.text == _S_LOAD_PROJ)
	{
		Open();
	}

	SetFileNameToTitle(m_provider->GetVideo(), _ETH_PROJECT_MANAGER_WINDOW_TITLE);

	if (GetCurrentProject() == "")
	{
		ShadowPrint(Vector2(64,128),
			GS_L("-Start a new project or load an existing one.\n") \
			GS_L("-If you start a new project, all necessary files and paths will be copied to the target folder.\n") \
			GS_L("-Media files (sprites, sounds, normals) should be manually placed into their correct directories.\n") \
			GS_L("-Create .ENT entity files before building your scenes.\n"));
	}
	else
	{
		str_type::string currentProjectFilename = 
			utf8::c(Platform::GetFileName(GetCurrentFile(false))).wc_str();
			str_type::string sText = GS_L("Project loaded: ") + currentProjectFilename + GS_L("\n") +
			GS_L("We're ready to go. Press TAB or click the arrow to go to the Editors");
		ShadowPrint(Vector2(64,128), sText.c_str());
	}

	ProccessFileOpenRequests();
	return GetCurrentProject();
}
Exemple #3
0
bool EditorBase::DrawTab(VideoPtr video, InputPtr input, const Vector2 &v2Pos, const float width, const wstring &text, Color color)
{
	video->SetAlphaMode(Video::AM_PIXEL);
	video->SetVertexShader(ShaderPtr());
	video->SetPixelShader(ShaderPtr());
	video->SetZBuffer(false);
	video->SetZWrite(false);

	const Vector2 v2Cam = video->GetCameraPos();
	video->SetCameraPos(Vector2(0,0));
	bool mouseOver = false;
	if (mouseOver = ETHGlobal::PointInRect(input->GetCursorPositionF(video), v2Pos+Vector2(width/2, m_menuSize), Vector2(width, m_menuSize)))
	{
		if (color.a < 200)
			color.a = 200;
	}

	const Vector2 v2CurveSize = m_curve->GetBitmapSizeF();
	const float rectWidth = width-v2CurveSize.x*2;
	m_curve->FlipX();
	m_curve->Draw(v2Pos, color);

	const Vector2 v2RectPos = v2Pos+Vector2(v2CurveSize.x, 0);
	video->DrawRectangle(v2RectPos, Vector2(rectWidth, m_menuSize*2), color);

	m_curve->FlipX();
	m_curve->Draw(v2Pos+Vector2(v2CurveSize.x+rectWidth, 0), color);

	ShadowPrint(v2RectPos+Vector2(v2CurveSize.x, m_menuSize/2), text.c_str(), L"Verdana14_shadow.fnt", Color(color.a,255,255,255));
	video->SetCameraPos(v2Cam);
	return (mouseOver && input->GetKeyState(GSK_LMOUSE) == GSKS_HIT);
}
Exemple #4
0
void DrawHighScores()
{
    int i;
    int w;
    int h;
    HighScore* s;

    ClearMScreen();
    CA_CacheScreen(BACKGROUND_SCREENPIC);
    DrawMenuTitle("HIGH SCORES");

    if (playstate != ex_title) {
        DrawInstructions(IT_HIGHSCORES);
    }

    fontnumber = 2;
    SETFONTCOLOR(ENABLED_TEXT_COLOR, TERM_BACK_COLOR);

    ShadowPrint("NAME", 86, 60);
    ShadowPrint("SCORE", 175, 60);
    ShadowPrint("MISSION", 247, 53);
    ShadowPrint("RATIO", 254, 60);

    for (i = 0, s = Scores.data(); i < MaxScores; i++, s++) {
        SETFONTCOLOR(HIGHLIGHT_TEXT_COLOR - 1, TERM_BACK_COLOR);
        //
        // name
        //
        if (*s->name) {
            ShadowPrint(s->name, 45, static_cast<int16_t>(68 + (SCORE_Y_SPACING * i)));
        }

        //
        // score
        //

        std::string buffer;

        if (s->score > 9999999) {
            SETFONTCOLOR(HIGHLIGHT_TEXT_COLOR + 1, TERM_BACK_COLOR);
        }

        buffer = std::to_string(s->score);
        ::USL_MeasureString(buffer.c_str(), &w, &h);
        ::ShadowPrint(buffer.c_str(), static_cast<int16_t>(205 - w), static_cast<int16_t>(68 + (SCORE_Y_SPACING * i))); // 235

        //
        // mission ratio
        //
        buffer = std::to_string(s->ratio);
        USL_MeasureString(buffer.c_str(), &w, &h);
        ShadowPrint(buffer.c_str(), static_cast<int16_t>(272 - w), static_cast<int16_t>(68 + (SCORE_Y_SPACING * i)));
    }

    VW_UpdateScreen();
}
void ParticleEditor::ParticlePanel()
{
	std::string programPath = GetCurrentProjectPath(false);
	const VideoPtr& video = m_provider->GetVideo();
	const InputPtr& input = m_provider->GetInput();

	GSGUI_BUTTON file_r = m_fileMenu.PlaceMenu(Vector2(0,m_menuSize*2));
	if (file_r.text == LOAD_BMP)
	{
		char path[___OUTPUT_LENGTH], file[___OUTPUT_LENGTH];
		if (OpenParticleBMP(path, file))
		{
			ETHGlobal::CopyFileToProject(programPath, path, ETHDirectories::GetParticlesDirectory(), m_provider->GetFileManager());
			m_system.bitmapFile = file;
			m_provider->GetGraphicResourceManager()->ReleaseResource(m_system.bitmapFile);
			m_manager = ETHParticleManagerPtr(
				new ETHParticleManager(m_provider, m_system, m_v2Pos, Vector3(m_v2Pos, 0), m_systemAngle, 1.0f));
		}
	}

	if (file_r.text == SAVE_SYSTEM)
	{
		if (m_untitled)
			SaveAs();
		else
			Save();
	}

	if (file_r.text == SAVE_SYSTEM_AS)
	{
		SaveAs();
	}

	if (file_r.text == LOAD_BG)
	{
		char path[___OUTPUT_LENGTH], file[___OUTPUT_LENGTH];
		if (OpenParticleBMP(path, file))
		{
			m_backgroundSprite = video->CreateSprite(path);
		}	
	}

	if (file_r.text == OPEN_SYSTEM)
	{
		m_systemAngle = 0.0f;
		char path[___OUTPUT_LENGTH], file[___OUTPUT_LENGTH];
		if (OpenSystem(path, file))
		{
			m_manager = ETHParticleManagerPtr(
				new ETHParticleManager(m_provider, path, m_v2Pos, Vector3(m_v2Pos, 0), m_systemAngle));
			m_manager->SetZPosition(0.0f);
			m_manager->Kill(false);
			m_system = *m_manager->GetSystem();
			SetMenuConstants();

			SetCurrentFile(path);
			m_untitled = false;
		}
	}

	if (file_r.text == _S_GOTO_PROJ)
	{
		m_projManagerRequested = true;
	}

	if (input->GetKeyState(GSK_K) == GSKS_HIT)
		m_manager->Kill(!m_manager->Killed());
	
	if (!m_fileMenu.IsActive())
	{
		Vector2 v2ScreenDim = video->GetScreenSizeF();
		float menu = m_menuSize*m_menuScale+(m_menuSize*2);

		// places the alpha mode menu
		ShadowPrint(Vector2(v2ScreenDim.x-m_alphaModes.GetWidth(), menu), GS_L("Alpha mode:"), GS_L("Verdana14_shadow.fnt"), gs2d::constant::WHITE);
		menu += m_menuSize;
		m_alphaModes.PlaceMenu(Vector2(v2ScreenDim.x-m_alphaModes.GetWidth(), menu)); menu += m_alphaModes.GetNumButtons()*m_menuSize;

		// sets the alpha mode according to the selected item
		if (m_alphaModes.GetButtonStatus(ALPHA_MODE_PIXEL))
			m_system.alphaMode = Video::AM_PIXEL;
		if (m_alphaModes.GetButtonStatus(ALPHA_MODE_ADD))
			m_system.alphaMode = Video::AM_ADD;
		if (m_alphaModes.GetButtonStatus(ALPHA_MODE_MODULATE))
			m_system.alphaMode = Video::AM_MODULATE;

		// places the sprite cut fields to the right
		menu += m_menuSize/2;
		ShadowPrint(Vector2(v2ScreenDim.x-m_alphaModes.GetWidth(), menu), GS_L("Sprite cut:"), GS_L("Verdana14_shadow.fnt"), gs2d::constant::WHITE);
		menu += m_menuSize;
		m_system.spriteCut.x = Max(1, static_cast<int>(m_spriteCut[0].PlaceInput(Vector2(v2ScreenDim.x-m_alphaModes.GetWidth(),menu)))); menu += m_menuSize;
		m_system.spriteCut.y = Max(1, static_cast<int>(m_spriteCut[1].PlaceInput(Vector2(v2ScreenDim.x-m_alphaModes.GetWidth(),menu)))); menu += m_menuSize;

		// if there is sprite animation in the particle system, places the animation mode selector
		if (m_system.spriteCut.x > 1 || m_system.spriteCut.y > 1)
		{
			menu += m_menuSize/2;
			m_animationModes.PlaceMenu(Vector2(v2ScreenDim.x-m_animationModes.GetWidth(), menu)); menu += m_animationModes.GetNumButtons()*m_menuSize;

			if (m_animationModes.GetButtonStatus(ANIMATION_MODE_ANIMATE))
				m_system.animationMode = ETHParticleSystem::PLAY_ANIMATION;
			if (m_animationModes.GetButtonStatus(ANIMATION_MODE_PICK))
				m_system.animationMode = ETHParticleSystem::PICK_RANDOM_FRAME;
		}

		// inputs all data
		menu = m_menuSize*m_menuScale+(m_menuSize*2);
		menu += m_menuSize/2;
		ShadowPrint(Vector2(0.0f,menu), GS_L("Particles:"), GS_L("Verdana14_shadow.fnt"), gs2d::constant::WHITE);
		int nParticles = m_particles.PlaceInput(Vector2(m_menuWidth,menu)); menu += m_menuSize;

		ShadowPrint(Vector2(0.0f,menu), GS_L("Repeats:"), GS_L("Verdana14_shadow.fnt"), gs2d::constant::WHITE);
		m_system.repeat = m_repeats.PlaceInput(Vector2(m_menuWidth,menu)); menu += m_menuSize;
		menu += m_menuSize/2;

		if (nParticles != m_system.nParticles && nParticles > 0)
		{
			m_system.nParticles = nParticles;
			m_manager = ETHParticleManagerPtr(
				new ETHParticleManager(m_provider, m_system, m_v2Pos, Vector3(m_v2Pos, 0), m_systemAngle, 1.0f));
			m_manager->Kill(false);
		}

		m_system.gravityVector.x = m_gravity[0].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.gravityVector.y = m_gravity[1].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;

		m_system.directionVector.x = m_direction[0].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.directionVector.y = m_direction[1].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;

		m_system.randomizeDir.x = m_randDir[0].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.randomizeDir.y = m_randDir[1].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.boundingSphere = m_boundingSphere.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.allAtOnce = (bool)(m_allAtOnce.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize) != 0); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.startPoint.x = m_startPoint[0].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.startPoint.y = m_startPoint[1].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.randStartPoint.x = m_randStart[0].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.randStartPoint.y = m_randStart[1].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.color0.w = m_color0[0].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.color0.x = m_color0[1].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.color0.y = m_color0[2].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.color0.z = m_color0[3].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.color1.w = m_color1[0].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.color1.x = m_color1[1].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.color1.y = m_color1[2].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.color1.z = m_color1[3].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.size = m_size.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.growth = m_growth.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.randomizeSize = m_randSize.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.lifeTime = m_lifeTime.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.randomizeLifeTime = m_randLifeTime.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.angleStart = m_angleStart.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.angleDir = m_angle.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.randAngle = m_randAngle.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.randAngleStart = m_randAngleStart.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.minSize = m_minSize.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.maxSize = m_maxSize.PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_system.emissive.x = m_luminance[0].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.emissive.y = m_luminance[1].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		m_system.emissive.z = m_luminance[2].PlaceInput(Vector2(0.0f,menu), Vector2(0.0f, v2ScreenDim.y-m_menuSize), m_menuSize); menu += m_menuSize;
		menu += m_menuSize/2;

		m_manager->SetSystem(m_system);
	}
}
Exemple #6
0
void	DrawHighScores(void)
{
	char		buffer[16],*str;
	word		i,
				w,h;
	HighScore	*s;

	ClearMScreen();
	CA_CacheScreen (BACKGROUND_SCREENPIC);
	DrawMenuTitle("HIGH SCORES");

	if (playstate != ex_title)
		DrawInstructions(IT_HIGHSCORES);

	fontnumber=2;
	SETFONTCOLOR(ENABLED_TEXT_COLOR,TERM_BACK_COLOR);

	ShadowPrint("NAME",86,60);
//	ShadowPrint("MISSION",150,60);
	ShadowPrint("SCORE",175,60);
	ShadowPrint("MISSION",247,53);
	ShadowPrint("RATIO",254,60);

	for (i = 0,s = Scores;i < MaxScores;i++,s++)
	{
		SETFONTCOLOR(HIGHLIGHT_TEXT_COLOR-1,TERM_BACK_COLOR);
		//
		// name
		//
		if (*s->name)
			ShadowPrint(s->name,45,68 + (SCORE_Y_SPACING * i));

#if 0
		//
		// mission
		//

		ltoa(s->episode+1,buffer,10);
		ShadowPrint(buffer,165,68 + (SCORE_Y_SPACING * i));
#endif

		//
		// score
		//

		if (s->score > 9999999)
			SETFONTCOLOR(HIGHLIGHT_TEXT_COLOR+1,TERM_BACK_COLOR);

		ltoa(s->score,buffer,10);
		USL_MeasureString(buffer,&w,&h);
		ShadowPrint(buffer,205 - w,68 + (SCORE_Y_SPACING * i));		// 235

		//
		// mission ratio
		//
		ltoa(s->ratio,buffer,10);
		USL_MeasureString(buffer,&w,&h);
		ShadowPrint(buffer,272-w,68 + (SCORE_Y_SPACING * i));
	}

	VW_UpdateScreen ();
}