void CScreenLevelList::CreateInterface()
{
CWindow* pw;
CEdit* pe;
CLabel* pl;
CButton* pb;
CCheck* pc;
CList* pli;
Math::Point pos, ddim;
int res;
std::string name;
if ( m_category == LevelCategory::FreeGame )
{
m_accessChap = m_main->GetPlayerProfile()->GetChapPassed(LevelCategory::Missions);
}
pos.x = 0.10f;
pos.y = 0.10f;
ddim.x = 0.80f;
ddim.y = 0.80f;
pw = m_interface->CreateWindows(pos, ddim, 12, EVENT_WINDOW5);
pw->SetClosable(true);
if ( m_category == LevelCategory::Exercises ) res = RT_TITLE_TRAINER;
if ( m_category == LevelCategory::Challenges ) res = RT_TITLE_DEFI;
if ( m_category == LevelCategory::Missions ) res = RT_TITLE_MISSION;
if ( m_category == LevelCategory::FreeGame ) res = RT_TITLE_FREE;
if ( m_category == LevelCategory::CodeBattles ) res = RT_TITLE_CODE_BATTLES;
if ( m_category == LevelCategory::CustomLevels ) res = RT_TITLE_USER;
GetResource(RES_TEXT, res, name);
pw->SetName(name);
pos.x = 0.10f;
pos.y = 0.40f;
ddim.x = 0.50f;
ddim.y = 0.50f;
pw->CreateGroup(pos, ddim, 5, EVENT_INTERFACE_GLINTl); // orange corner
pos.x = 0.40f;
pos.y = 0.10f;
ddim.x = 0.50f;
ddim.y = 0.50f;
pw->CreateGroup(pos, ddim, 4, EVENT_INTERFACE_GLINTr); // blue corner
// Displays a list of chapters:
pos.x = ox+sx*3;
pos.y = oy+sy*10.5f;
ddim.x = dim.x*7.5f;
ddim.y = dim.y*0.6f;
res = RT_PLAY_CHAP_CHAPTERS;
if ( m_category == LevelCategory::Missions ) res = RT_PLAY_CHAP_PLANETS;
if ( m_category == LevelCategory::FreeGame ) res = RT_PLAY_CHAP_PLANETS;
if ( m_category == LevelCategory::CustomLevels ) res = RT_PLAY_CHAP_USERLVL;
GetResource(RES_TEXT, res, name);
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL11, name);
pl->SetTextAlign(Gfx::TEXT_ALIGN_LEFT);
pos.y = oy+sy*6.7f;
ddim.y = dim.y*4.5f;
ddim.x = dim.x*6.5f;
pli = pw->CreateList(pos, ddim, 0, EVENT_INTERFACE_CHAP);
pli->SetState(STATE_SHADOW);
m_chap[m_category] = m_main->GetPlayerProfile()->GetSelectedChap(m_category)-1;
UpdateSceneChap(m_chap[m_category]);
if ( m_category != LevelCategory::FreeGame &&
m_category != LevelCategory::CodeBattles &&
m_category != LevelCategory::CustomLevels ) // Don't show completion marks in free game, code battles and userlevels
{
pli->SetState(STATE_EXTEND);
}
// Displays a list of missions:
pos.x = ox+sx*9.5f;
pos.y = oy+sy*10.5f;
ddim.x = dim.x*7.5f;
ddim.y = dim.y*0.6f;
res = RT_PLAY_LIST_LEVELS;
if ( m_category == LevelCategory::Exercises ) res = RT_PLAY_LIST_EXERCISES;
if ( m_category == LevelCategory::Challenges ) res = RT_PLAY_LIST_CHALLENGES;
if ( m_category == LevelCategory::Missions ) res = RT_PLAY_LIST_MISSIONS;
if ( m_category == LevelCategory::FreeGame ) res = RT_PLAY_LIST_FREEGAME;
GetResource(RES_TEXT, res, name);
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL12, name);
pl->SetTextAlign(Gfx::TEXT_ALIGN_LEFT);
pos.y = oy+sy*6.7f;
ddim.y = dim.y*4.5f;
ddim.x = dim.x*6.5f;
pli = pw->CreateList(pos, ddim, 0, EVENT_INTERFACE_LIST);
pli->SetState(STATE_SHADOW);
m_sel[m_category] = m_main->GetPlayerProfile()->GetSelectedRank(m_category)-1;
UpdateSceneList(m_chap[m_category], m_sel[m_category]);
if ( m_category != LevelCategory::FreeGame &&
m_category != LevelCategory::CodeBattles &&
m_category != LevelCategory::CustomLevels ) // Don't show completion marks in free game, code battles and userlevels
{
pli->SetState(STATE_EXTEND);
}
pos = pli->GetPos();
ddim = pli->GetDim();
// Displays the summary:
pos.x = ox+sx*3;
pos.y = oy+sy*5.4f;
ddim.x = dim.x*6.5f;
ddim.y = dim.y*0.6f;
GetResource(RES_TEXT, RT_PLAY_RESUME, name);
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL13, name);
pl->SetTextAlign(Gfx::TEXT_ALIGN_LEFT);
pos.x = ox+sx*3;
pos.y = oy+sy*3.6f;
ddim.x = dim.x*13.4f;
ddim.y = dim.y*1.9f;
pe = pw->CreateEdit(pos, ddim, 0, EVENT_INTERFACE_RESUME);
pe->SetState(STATE_SHADOW);
pe->SetMaxChar(500);
pe->SetEditCap(false); // just to see
pe->SetHighlightCap(false);
// Button displays the "soluce":
if ( m_category != LevelCategory::Exercises &&
m_category != LevelCategory::FreeGame )
{
pos.x = ox+sx*9.5f;
pos.y = oy+sy*5.8f;
ddim.x = dim.x*6.5f;
ddim.y = dim.y*0.5f;
pc = pw->CreateCheck(pos, ddim, -1, EVENT_INTERFACE_SOLUCE);
pc->SetState(STATE_SHADOW);
pc->ClearState(STATE_CHECK);
}
m_sceneSoluce = false;
UpdateSceneResume(m_chap[m_category]+1, m_sel[m_category]+1);
if ( m_category == LevelCategory::Missions ||
m_category == LevelCategory::FreeGame ||
m_category == LevelCategory::CustomLevels )
{
pos.x = ox+sx*9.5f;
pos.y = oy+sy*2;
ddim.x = dim.x*3.7f;
ddim.y = dim.y*1;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_PLAY);
pb->SetState(STATE_SHADOW);
if ( m_maxList == 0 )
{
pb->ClearState(STATE_ENABLE);
}
pos.x += dim.x*4.0f;
ddim.x = dim.x*2.5f;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_READ);
pb->SetState(STATE_SHADOW);
if ( !m_main->GetPlayerProfile()->HasAnySavedScene() ) // no file to read?
{
pb->ClearState(STATE_ENABLE);
}
}
else
{
pos.x = ox+sx*9.5f;
pos.y = oy+sy*2;
ddim.x = dim.x*6.5f;
ddim.y = dim.y*1;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_PLAY);
pb->SetState(STATE_SHADOW);
if ( m_maxList == 0 )
{
pb->ClearState(STATE_ENABLE);
}
}
pos.x = ox+sx*3;
ddim.x = dim.x*4;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_BACK);
pb->SetState(STATE_SHADOW);
SetBackground("textures/interface/interface.png");
CreateVersionDisplay();
if (m_category == LevelCategory::CustomLevels)
{
if(m_customLevelList.size() == 0)
{
m_main->ChangePhase(PHASE_MAIN_MENU);
std::string title, text;
GetResource(RES_TEXT, RT_DIALOG_NOUSRLVL_TITLE, title);
GetResource(RES_TEXT, RT_DIALOG_NOUSRLVL_TEXT, text);
m_dialog->StartInformation(title, title, text);
}
}
}
void CRegisterTabs::InitRegisterEdit(CWindow& tab, CEditNumber32& edit, WORD ctrlId)
{
edit.Attach(tab.GetDlgItem(ctrlId));
edit.SetDisplayType(CEditNumber32::DisplayHex);
}
/**
* This is the basic window procedure, which or handles some basic commands, such as
* identifying which command handler should be called or delegates the message to one
* of the message handlers
*/
LRESULT CWindow::basicWindowProcedure (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
//LOG_MSG("Got:", msg);
if(finishing)
{
return DefWindowProc(hwnd, msg, wparam, lparam);
}
// first step: Find if we have a registered message handler for the given message
if(windowInstances.find(hwnd) != windowInstances.end())
{
if(msg == WM_NOTIFY)
{
LRESULT lr = handleNotifyMessages(hwnd, msg, wparam, lparam);
if(lr != NOT_HANDLED_MESSAGE)
{
return lr;
};
}
// lets search for something that will handle this message
CWindow* win = windowInstances[hwnd];
if(win)
{
LRESULT res = win->handleMessage(msg, win, wparam, lparam);
if(res != NOT_HANDLED_MESSAGE)
{
return res;
}
}
}
// second: see if we have a registered command handler, and handle if this is a command
switch(msg)
{
case WM_COMMAND:
{
DWORD id = LOWORD(wparam);
if(windowInstances.find(hwnd) != windowInstances.end())
{
// check if we have a registered handler for this (with the ON_COMMAND)
if(windowInstances[hwnd]->hasIDRegd(id))
{
// no, we don't have a registered handler... let's try to handle it
if(windowInstances[hwnd]->handleExtensionCommand(id))
{
return 0;
}
}
// yes, we have a registered handler
windowInstances[hwnd]->handleCommand(LOWORD(wparam), windowInstances[hwnd]);
return 0;
}
break;
}
// third: If we need to draw some items... draw them
case WM_DRAWITEM:
if(windowInstances.find(hwnd) != windowInstances.end())
{
// LOG_X("Got WM_DRAWITEM for:", ((LPDRAWITEMSTRUCT) lparam)->hwndItem);
// find the callbacked control or something similar...
CWindow* theWindow = windowInstances[hwnd];
for(size_t i=0; i<theWindow->controls.size(); i++)
{
if(dynamic_cast<CTabControl*>(theWindow->controls[i])!=NULL)
{
dynamic_cast<CTabControl*>(theWindow->controls[i])->handleOwnerDraws((LPDRAWITEMSTRUCT)lparam);
}
else
if(theWindow->controls[i]->getHandle() == ((LPDRAWITEMSTRUCT) lparam)->hwndItem && theWindow->controls[i]->isVisible())
{
// LOG_X("Will be drawn:",theWindow->controls[i]->getHandle());
dynamic_cast<COwnerDrawControl*>(theWindow->controls[i])->draw((LPDRAWITEMSTRUCT) lparam);
}
}
return TRUE;
}
break;
}
// finally: nothing was found that could handle that message, let the DefWindowProc do it
//LOG_MSG("Message will be handled by DefWindowProc:", msg);
return DefWindowProc(hwnd, msg, wparam, lparam);
}
void CScreenQuit::CreateInterface()
{
CWindow* pw;
CEdit* pe;
CLabel* pl;
CButton* pb;
Math::Point pos, ddim;
std::string name;
pos.x = 0.0f;
pos.y = 0.0f;
ddim.x = 0.0f;
ddim.y = 0.0f;
pw = m_interface->CreateWindows(pos, ddim, -1, EVENT_WINDOW5);
pos.x = 80.0f/640.0f;
pos.y = 190.0f/480.0f;
ddim.x = 490.0f/640.0f;
ddim.y = 160.0f/480.0f;
pe = pw->CreateEdit(pos, ddim, 0, EVENT_EDIT1);
pe->SetGenericMode(true);
pe->SetEditCap(false);
pe->SetHighlightCap(false);
pe->SetFontType(Gfx::FONT_STUDIO);
pe->SetFontSize(Gfx::FONT_SIZE_SMALL);
pe->ReadText(std::string("help/") + m_app->GetLanguageChar() + std::string("/authors.txt"));
pos.x = 40.0f/640.0f;
pos.y = 83.0f/480.0f;
ddim.x = 246.0f/640.0f;
ddim.y = 16.0f/480.0f;
GetResource(RES_TEXT, RT_GENERIC_DEV1, name);
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL1, name);
pl->SetFontType(Gfx::FONT_STUDIO);
pl->SetFontSize(Gfx::FONT_SIZE_SMALL);
pos.y = 13.0f/480.0f;
GetResource(RES_TEXT, RT_GENERIC_DEV2, name);
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL2, name);
pl->SetFontType(Gfx::FONT_STUDIO);
pl->SetFontSize(Gfx::FONT_SIZE_SMALL);
pos.x = 355.0f/640.0f;
pos.y = 83.0f/480.0f;
ddim.x = 246.0f/640.0f;
ddim.y = 16.0f/480.0f;
GetResource(RES_TEXT, RT_GENERIC_EDIT1, name);
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL3, name);
pl->SetFontType(Gfx::FONT_STUDIO);
pl->SetFontSize(Gfx::FONT_SIZE_SMALL);
pos.y = 13.0f/480.0f;
GetResource(RES_TEXT, RT_GENERIC_EDIT2, name);
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL4, name);
pl->SetFontType(Gfx::FONT_STUDIO);
pl->SetFontSize(Gfx::FONT_SIZE_SMALL);
pos.x = 306.0f/640.0f;
pos.y = 17.0f/480.0f;
ddim.x = 30.0f/640.0f;
ddim.y = 30.0f/480.0f;
pb = pw->CreateButton(pos, ddim, 49, EVENT_INTERFACE_ABORT);
pb->SetState(STATE_SHADOW);
SetBackground("textures/interface/generico.png");
}
int main()
{
////////////////////
// ionEngine Init //
////////////////////
Log::AddDefaultOutputs();
SingletonPointer<CGraphicsAPI> GraphicsAPI;
SingletonPointer<CWindowManager> WindowManager;
SingletonPointer<CTimeManager> TimeManager;
SingletonPointer<CSceneManager> SceneManager;
SingletonPointer<CAssetManager> AssetManager;
SingletonPointer<CGUIManager> GUIManager;
GraphicsAPI->Init(new Graphics::COpenGLImplementation());
WindowManager->Init(GraphicsAPI);
TimeManager->Init(WindowManager);
SceneManager->Init(GraphicsAPI);
AssetManager->Init(GraphicsAPI);
//CWindow * Window = WindowManager->CreateWindow(vec2i(1600, 900), "DemoApplication", EWindowType::Windowed);
CWindow * Window = WindowManager->CreateWindowOnMonitor(2, "SSAO");
GUIManager->Init(Window);
Window->AddListener(GUIManager);
AssetManager->AddAssetPath("Assets/");
AssetManager->SetShaderPath("Shaders/");
AssetManager->SetTexturePath("Images/");
SharedPointer<IGraphicsContext> Context = GraphicsAPI->GetWindowContext(Window);
SharedPointer<IRenderTarget> BackBuffer = Context->GetBackBuffer();
BackBuffer->SetClearColor(color3f(0.3f));
SharedPointer<IFrameBuffer> SceneFrameBuffer = Context->CreateFrameBuffer();
SharedPointer<ITexture2D> SceneColor = GraphicsAPI->CreateTexture2D(Window->GetSize(), ITexture::EMipMaps::False, ITexture::EFormatComponents::RGB, ITexture::EInternalFormatType::Fix8);
SceneColor->SetMinFilter(ITexture::EFilter::Nearest);
SceneColor->SetMagFilter(ITexture::EFilter::Nearest);
SceneColor->SetWrapMode(ITexture::EWrapMode::Clamp);
SharedPointer<ITexture2D> SceneNormal = GraphicsAPI->CreateTexture2D(Window->GetSize(), ITexture::EMipMaps::False, ITexture::EFormatComponents::RGB, ITexture::EInternalFormatType::Fix8);
SceneNormal->SetMinFilter(ITexture::EFilter::Nearest);
SceneNormal->SetMagFilter(ITexture::EFilter::Nearest);
SceneNormal->SetWrapMode(ITexture::EWrapMode::Clamp);
SharedPointer<ITexture2D> SceneDepth = GraphicsAPI->CreateTexture2D(Window->GetSize(), ITexture::EMipMaps::False, ITexture::EFormatComponents::R, ITexture::EInternalFormatType::Depth);
SceneFrameBuffer->AttachColorTexture(SceneColor, 0);
SceneFrameBuffer->AttachColorTexture(SceneNormal, 1);
SceneFrameBuffer->AttachDepthTexture(SceneDepth);
if (! SceneFrameBuffer->CheckCorrectness())
{
Log::Error("Frame buffer not valid!");
}
SharedPointer<IFrameBuffer> PingFrameBuffer = Context->CreateFrameBuffer();
SharedPointer<ITexture2D> PingColor = GraphicsAPI->CreateTexture2D(Window->GetSize(), ITexture::EMipMaps::False, ITexture::EFormatComponents::RGB, ITexture::EInternalFormatType::Fix8);
PingColor->SetMinFilter(ITexture::EFilter::Nearest);
PingColor->SetMagFilter(ITexture::EFilter::Nearest);
PingColor->SetWrapMode(ITexture::EWrapMode::Clamp);
PingFrameBuffer->AttachColorTexture(PingColor, 0);
if (! PingFrameBuffer->CheckCorrectness())
{
Log::Error("Frame buffer not valid!");
}
SharedPointer<IFrameBuffer> PongFrameBuffer = Context->CreateFrameBuffer();
SharedPointer<ITexture2D> PongColor = GraphicsAPI->CreateTexture2D(Window->GetSize(), ITexture::EMipMaps::False, ITexture::EFormatComponents::RGB, ITexture::EInternalFormatType::Fix8);
PongColor->SetMinFilter(ITexture::EFilter::Nearest);
PongColor->SetMagFilter(ITexture::EFilter::Nearest);
PongColor->SetWrapMode(ITexture::EWrapMode::Clamp);
PongFrameBuffer->AttachColorTexture(PongColor, 0);
if (! PongFrameBuffer->CheckCorrectness())
{
Log::Error("Frame buffer not valid!");
}
/////////////////
// Load Assets //
/////////////////
CSimpleMesh * SphereMesh = CGeometryCreator::CreateSphere();
CSimpleMesh * PlaneMesh = CGeometryCreator::CreatePlane(vec2f(100.f));
SharedPointer<IShader> GeometryShader = AssetManager->LoadShader("Geometry");
SharedPointer<IShader> SSAOShader = AssetManager->LoadShader("SSAO");
SharedPointer<IShader> BlurHShader = AssetManager->LoadShader("BlurH");
SharedPointer<IShader> BlurVShader = AssetManager->LoadShader("BlurV");
std::uniform_real_distribution<float> randomFloats(0.0, 1.0); // generates random floats between 0.0 and 1.0
std::default_random_engine generator;
// Sample kernel
int const numSamples = 64;
std::vector<vec3f> ssaoKernel;
for (uint i = 0; i < numSamples; ++i)
{
float const VerticalBias = 0.1f;
bool random = true;
int const sampleRegionWidth = (int) sqrt((float) numSamples);
float const a = random ? randomFloats(generator) : (float) (i / sampleRegionWidth) / (float) (sampleRegionWidth - 1);
float const b = random ? randomFloats(generator) : (float) (i % sampleRegionWidth) / (float) (sampleRegionWidth - 1);
float const c = random ? randomFloats(generator) : (float) (i % 3) / 2.f;
vec3f sample = vec3f(a * 2 - 1, b * 2 - 1, c * (1.f - VerticalBias) + VerticalBias);
sample.Normalize();
sample *= randomFloats(generator);
float scale = float(i) / numSamples;
// Scale samples s.t. they're more aligned to center of kernel
scale = lerp(0.1f, 1.0f, scale * scale);
sample *= scale;
ssaoKernel.push_back(sample);
}
// Noise texture
std::vector<float> NoiseData;
uint const NoiseTexSize = 4;
for (uint i = 0; i < NoiseTexSize * NoiseTexSize; i++)
{
NoiseData.push_back(randomFloats(generator) * 2 - 1);
NoiseData.push_back(randomFloats(generator) * 2 - 1);
NoiseData.push_back(0.0);
}
SharedPointer<ITexture2D> SSAONoise = GraphicsAPI->CreateTexture2D(vec2i(NoiseTexSize), ITexture::EMipMaps::False, ITexture::EFormatComponents::RGB, ITexture::EInternalFormatType::Float16);
SSAONoise->Upload(NoiseData.data(), vec2i(NoiseTexSize), ITexture::EFormatComponents::RGB, EScalarType::Float);
SSAONoise->SetMinFilter(ITexture::EFilter::Nearest);
SSAONoise->SetMagFilter(ITexture::EFilter::Nearest);
////////////////////
// ionScene Setup //
////////////////////
CRenderPass * RenderPass = new CRenderPass(Context);
RenderPass->SetRenderTarget(SceneFrameBuffer);
SceneManager->AddRenderPass(RenderPass);
CRenderPass * SSAOPass = new CRenderPass(Context);
SSAOPass->SetRenderTarget(PingFrameBuffer);
SceneManager->AddRenderPass(SSAOPass);
int const BlurPasses = 2;
CRenderPass * BlurHPasses[BlurPasses] = { nullptr };
CRenderPass * BlurVPasses[BlurPasses] = { nullptr };
for (int i = 0; i < BlurPasses; ++ i)
{
BlurHPasses[i] = new CRenderPass(Context);
BlurHPasses[i]->SetRenderTarget(PongFrameBuffer);
SceneManager->AddRenderPass(BlurHPasses[i]);
BlurVPasses[i] = new CRenderPass(Context);
BlurVPasses[i]->SetRenderTarget(i + 1 == BlurPasses ? BackBuffer : PingFrameBuffer);
SceneManager->AddRenderPass(BlurVPasses[i]);
}
CPerspectiveCamera * Camera = new CPerspectiveCamera(Window->GetAspectRatio());
Camera->SetPosition(vec3f(-1.7f, 2.8f, 3.4f));
Camera->SetFocalLength(0.4f);
Camera->SetNearPlane(0.1f);
Camera->SetFarPlane(50.f);
RenderPass->SetActiveCamera(Camera);
SSAOPass->SetActiveCamera(Camera);
CCameraController * Controller = new CCameraController(Camera);
Controller->SetTheta(-0.08f);
Controller->SetPhi(-0.26f);
Window->AddListener(Controller);
TimeManager->MakeUpdateTick(0.02)->AddListener(Controller);
/////////////////
// Add Objects //
/////////////////
CSimpleMeshSceneObject * Sphere1 = new CSimpleMeshSceneObject();
Sphere1->SetMesh(SphereMesh);
Sphere1->SetShader(GeometryShader);
Sphere1->SetPosition(vec3f(0, 0, 0));
Sphere1->SetScale(2.f);
Sphere1->GetMaterial().Diffuse *= color3f(1.0, 0.8f, 0.8f);
RenderPass->AddSceneObject(Sphere1);
CSimpleMeshSceneObject * Sphere2 = new CSimpleMeshSceneObject();
Sphere2->SetMesh(SphereMesh);
Sphere2->SetShader(GeometryShader);
Sphere2->SetPosition(vec3f(4, 0, 0));
Sphere2->SetScale(3.f);
Sphere2->GetMaterial().Diffuse *= color3f(0.8f, 1, 0.8f);
RenderPass->AddSceneObject(Sphere2);
CSimpleMeshSceneObject * Sphere3 = new CSimpleMeshSceneObject();
Sphere3->SetMesh(SphereMesh);
Sphere3->SetShader(GeometryShader);
Sphere3->SetPosition(vec3f(12, 0, 0));
Sphere3->SetScale(4.f);
Sphere3->GetMaterial().Diffuse *= color3f(0.8f, 0.9f, 1);
RenderPass->AddSceneObject(Sphere3);
CSimpleMeshSceneObject * Sphere4 = new CSimpleMeshSceneObject();
Sphere4->SetMesh(SphereMesh);
Sphere4->SetShader(GeometryShader);
Sphere4->SetPosition(vec3f(3, 0, 6));
Sphere4->GetMaterial().Diffuse *= color3f(0.9f, 1, 1);
RenderPass->AddSceneObject(Sphere4);
CSimpleMeshSceneObject * PlaneObject = new CSimpleMeshSceneObject();
PlaneObject->SetMesh(PlaneMesh);
PlaneObject->SetShader(GeometryShader);
RenderPass->AddSceneObject(PlaneObject);
CSimpleMesh * DragonMesh = AssetManager->LoadMeshMerged("dragon10k.obj");
CSimpleMeshSceneObject * DragonObject = new CSimpleMeshSceneObject();
DragonObject->SetMesh(DragonMesh);
DragonObject->SetShader(GeometryShader);
DragonObject->SetPosition(vec3f(6.f, 1.1f, 4.f));
DragonObject->SetScale(4.f);
RenderPass->AddSceneObject(DragonObject);
CSimpleMesh * StairMesh = AssetManager->LoadMeshMerged("SM_StairCase_02.obj");
CSimpleMeshSceneObject * StairObject = new CSimpleMeshSceneObject();
StairObject->SetMesh(StairMesh);
StairObject->SetShader(GeometryShader);
StairObject->SetPosition(vec3f(12.f, 0.f, 5.f));
StairObject->SetScale(1.f);
StairObject->SetRotation(vec3f(0.f, DegToRad(90.f), 0.f));
RenderPass->AddSceneObject(StairObject);
float SSAORadius = 1.0f;
CSimpleMeshSceneObject * PostProcessObject = new CSimpleMeshSceneObject();
PostProcessObject->SetMesh(CGeometryCreator::CreateScreenTriangle());
PostProcessObject->SetShader(SSAOShader);
PostProcessObject->SetTexture("tSceneNormals", SceneNormal);
PostProcessObject->SetTexture("tSceneDepth", SceneDepth);
PostProcessObject->SetTexture("texNoise", SSAONoise);
PostProcessObject->SetUniform("samples[0]", CUniform<vector<vec3f>>(ssaoKernel));
PostProcessObject->SetUniform("radius", std::make_shared<CUniformReference<float>>(&SSAORadius));
SSAOPass->AddSceneObject(PostProcessObject);
CUniform<bool> uDoBlur = true;
CUniform<bool> uUnconstrained = false;
CUniform<float> uNormalThreshold = 0.5f;
for (int i = 0; i < BlurPasses; ++ i)
{
CSimpleMeshSceneObject * BlurHObject = new CSimpleMeshSceneObject();
BlurHObject->SetMesh(CGeometryCreator::CreateScreenTriangle());
BlurHObject->SetShader(BlurHShader);
BlurHObject->SetTexture("uTexture", PingColor);
BlurHObject->SetTexture("tSceneNormals", SceneNormal);
BlurHObject->SetUniform("uDoBlur", uDoBlur);
BlurHObject->SetUniform("uUnconstrained", uUnconstrained);
BlurHObject->SetUniform("uNormalThreshold", uNormalThreshold);
BlurHPasses[i]->AddSceneObject(BlurHObject);
CSimpleMeshSceneObject * BlurVObject = new CSimpleMeshSceneObject();
BlurVObject->SetMesh(CGeometryCreator::CreateScreenTriangle());
BlurVObject->SetShader(BlurVShader);
BlurVObject->SetTexture("uTexture", PongColor);
BlurVObject->SetTexture("tSceneNormals", SceneNormal);
BlurVObject->SetUniform("uDoBlur", uDoBlur);
BlurVObject->SetUniform("uUnconstrained", uUnconstrained);
BlurVObject->SetUniform("uNormalThreshold", uNormalThreshold);
BlurVPasses[i]->AddSceneObject(BlurVObject);
}
CPointLight * Light1 = new CPointLight();
Light1->SetPosition(vec3f(0, 6, 0));
RenderPass->AddLight(Light1);
///////////////
// Main Loop //
///////////////
TimeManager->Init(WindowManager);
while (WindowManager->Run())
{
TimeManager->Update();
GUIManager->NewFrame();
ImGui::SetNextWindowPos(ImVec2(10, 10), ImGuiSetCond_Once);
if (ImGui::Begin("Settings"))
{
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
ImGui::Text("Camera position: %.3f %.3f %.3f", Camera->GetPosition().X, Camera->GetPosition().Y, Camera->GetPosition().Z);
ImGui::Text("Camera rotation: %.3f %.3f", Controller->GetTheta(), Controller->GetPhi());
ImGui::Separator();
ImGui::SliderFloat("SSAO Radius", &SSAORadius, 0.1f, 20.f);
ImGui::Checkbox("Do Blur", &uDoBlur.Get());
ImGui::SameLine();
ImGui::Checkbox("Unconstrained", &uUnconstrained.Get());
ImGui::SliderFloat("Normal Threshold", &uNormalThreshold.Get(), -1.f, 1.f);
ImGui::End();
}
SceneFrameBuffer->ClearColorAndDepth();
BackBuffer->ClearColorAndDepth();
SceneManager->DrawAll();
GUIManager->Draw();
Window->SwapBuffers();
}
return 0;
}
void CMainDialog::StartDialog(Math::Point dim, bool fireParticles)
{
CWindow* pw;
Math::Point pos, ddim;
m_main->StartSuspend();
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW0));
if ( pw != nullptr ) pw->ClearState(STATE_ENABLE);
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW1));
if ( pw != nullptr ) pw->ClearState(STATE_ENABLE);
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW2));
if ( pw != nullptr ) pw->ClearState(STATE_ENABLE);
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW3));
if ( pw != nullptr ) pw->ClearState(STATE_ENABLE);
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW4));
if ( pw != nullptr ) pw->ClearState(STATE_ENABLE);
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW5));
if ( pw != nullptr ) pw->ClearState(STATE_ENABLE);
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW6));
if ( pw != nullptr ) pw->ClearState(STATE_VISIBLE);
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW7));
if ( pw != nullptr ) pw->ClearState(STATE_ENABLE);
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW8));
if ( pw != nullptr ) pw->ClearState(STATE_ENABLE);
m_dialogFireParticles = fireParticles;
pos.x = (1.0f-dim.x)/2.0f;
pos.y = (1.0f-dim.y)/2.0f;
pw = m_interface->CreateWindows(pos, dim, m_dialogFireParticles ? 12 : 8, EVENT_WINDOW9);
pw->SetState(STATE_SHADOW);
std::string name;
GetResource(RES_TEXT, RT_TITLE_APPNAME, name);
pw->SetName(name);
m_dialogPos = pos;
m_dialogDim = dim;
m_dialogTime = 0.0f;
m_dialogParti = 999.0f;
m_sound->Play(SOUND_TZOING);
m_dialogOpen = true;
}
// **************************************************************************
//
// CMainWindow::TranslateAccelerator
//
// Required to forward messages to the PIEWebBrowser control (and any other
// ActiveX controls that may be added to the main window's design).
//
// **************************************************************************
BOOL CMainWindow::TranslateAccelerator(MSG* pMsg)
{
#if defined( OS_WINCE) && !defined( OS_PLATFORM_MOTCE )
if (pMsg->message == WM_CONTEXTMENU){
/*
CMenuHandle menu;
menu.LoadMenu(IDR_MAIN_MENU);
menu = menu.GetSubMenu(0);
return menu.TrackPopupMenu( TPM_CENTERALIGN | TPM_VERTICAL, LOWORD(pMsg->lParam), HIWORD(pMsg->lParam), m_hWnd);
*/
return TRUE;
}
if (m_bFullScreen && pMsg->message == WM_KEYUP &&
(pMsg->wParam == VK_F1 || pMsg->wParam == VK_F2))
SetFullScreen(false);
#endif
// Accelerators are only keyboard or mouse messages
UINT uMsg = pMsg->message;
if (!(WM_KEYFIRST <= uMsg && uMsg <= WM_KEYLAST) &&
!(WM_MOUSEFIRST <= uMsg && uMsg <= WM_MOUSELAST))
{
#ifdef OS_WINCE
if ( uMsg == WM_HOTKEY )
{
int idHotKey = (int) pMsg->wParam;
int fuModifiers = (UINT) LOWORD(pMsg->lParam);
int uVirtKey = (UINT) HIWORD(pMsg->lParam);
if ( uVirtKey == VK_ESCAPE ){
if ( fuModifiers&MOD_KEYUP )
RHODESAPP().navigateBack();
//PostMessageW(WM_COMMAND,MAKEWPARAM(IDM_BACK,1),NULL);
return TRUE;
}
}
#endif //OS_WINCE
return FALSE;
}
if (NULL == m_hWnd)
{
return FALSE;
}
// Find a direct child of this window from the window that has focus.
// This will be AtlAxWin window for the hosted control.
CWindow control = ::GetFocus();
if (IsChild(control) && m_hWnd != control.GetParent())
{
do
{
control = control.GetParent();
} while (m_hWnd != control.GetParent());
}
// Give the control (via the AtlAxWin) a chance to translate this message
if (control.m_hWnd && control.SendMessage(WM_FORWARDMSG, 0, (LPARAM)pMsg))
{
return TRUE;
}
// If the main window used accelerators, we could have called the global
// ::TranslateAccelerator() function here, instead of simply returning FALSE.
return FALSE;
}
static int Run(LPTSTR /*lpstrCmdLine*/ = NULL, int nCmdShow = SW_SHOWDEFAULT)
{
checkCommonControls();
CMessageLoop theLoop;
_Module.AddMessageLoop(&theLoop);
CEdit dummy;
CWindow splash;
CRect rc;
rc.bottom = GetSystemMetrics(SM_CYFULLSCREEN);
rc.top = (rc.bottom / 2) - 80;
rc.right = GetSystemMetrics(SM_CXFULLSCREEN);
rc.left = rc.right / 2 - 85;
dummy.Create(NULL, rc, _T(APPNAME) _T(" ") _T(VERSIONSTRING), WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
ES_CENTER | ES_READONLY, WS_EX_STATICEDGE);
splash.Create(_T("Static"), GetDesktopWindow(), splash.rcDefault, NULL, WS_POPUP | WS_VISIBLE | SS_USERITEM | WS_EX_TOOLWINDOW);
splash.SetFont((HFONT)GetStockObject(DEFAULT_GUI_FONT));
HDC dc = splash.GetDC();
rc.right = rc.left + 350;
rc.bottom = rc.top + 120;
splash.ReleaseDC(dc);
splash.HideCaret();
splash.SetWindowPos(NULL, &rc, SWP_SHOWWINDOW);
splash.SetWindowLongPtr(GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(&splashCallback));
splash.CenterWindow();
sTitle = _T(VERSIONSTRING) _T(" ") _T(CONFIGURATION_TYPE);
splash.SetFocus();
splash.RedrawWindow();
WinUtil::preInit();
startup(callBack, (void*)splash.m_hWnd);
if(BOOLSETTING(PASSWD_PROTECT)) {
PassDlg dlg;
dlg.description = TSTRING(PASSWORD_DESC);
dlg.title = TSTRING(PASSWORD_TITLE);
dlg.ok = TSTRING(UNLOCK);
if(dlg.DoModal(/*m_hWnd*/) == IDOK){
tstring tmp = dlg.line;
if (tmp != Text::toT(Util::base64_decode(SETTING(PASSWORD)))) {
ExitProcess(1);
}
}
}
splash.DestroyWindow();
dummy.DestroyWindow();
if(ResourceManager::getInstance()->isRTL()) {
SetProcessDefaultLayout(LAYOUT_RTL);
}
MainFrame wndMain;
rc = wndMain.rcDefault;
if( (SETTING(MAIN_WINDOW_POS_X) != CW_USEDEFAULT) &&
(SETTING(MAIN_WINDOW_POS_Y) != CW_USEDEFAULT) &&
(SETTING(MAIN_WINDOW_SIZE_X) != CW_USEDEFAULT) &&
(SETTING(MAIN_WINDOW_SIZE_Y) != CW_USEDEFAULT) ) {
rc.left = SETTING(MAIN_WINDOW_POS_X);
rc.top = SETTING(MAIN_WINDOW_POS_Y);
rc.right = rc.left + SETTING(MAIN_WINDOW_SIZE_X);
rc.bottom = rc.top + SETTING(MAIN_WINDOW_SIZE_Y);
// Now, let's ensure we have sane values here...
if( (rc.left < 0 ) || (rc.top < 0) || (rc.right - rc.left < 10) || ((rc.bottom - rc.top) < 10) ) {
rc = wndMain.rcDefault;
}
}
int rtl = ResourceManager::getInstance()->isRTL() ? WS_EX_RTLREADING : 0;
if(wndMain.CreateEx(NULL, rc, 0, rtl | WS_EX_APPWINDOW | WS_EX_WINDOWEDGE) == NULL) {
ATLTRACE(_T("Main window creation failed!\n"));
return 0;
}
if(BOOLSETTING(MINIMIZE_ON_STARTUP)) {
wndMain.ShowWindow(SW_SHOWMINIMIZED);
} else {
wndMain.ShowWindow(((nCmdShow == SW_SHOWDEFAULT) || (nCmdShow == SW_SHOWNORMAL)) ? SETTING(MAIN_WINDOW_STATE) : nCmdShow);
}
int nRet = theLoop.Run();
_Module.RemoveMessageLoop();
dummy.Create(NULL, rc, _T(APPNAME) _T(" ") _T(VERSIONSTRING), WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
ES_CENTER | ES_READONLY, WS_EX_STATICEDGE);
splash.Create(_T("Static"), GetDesktopWindow(), splash.rcDefault, NULL, WS_POPUP | WS_VISIBLE | SS_USERITEM | WS_EX_TOOLWINDOW);
splash.SetFont((HFONT)GetStockObject(DEFAULT_GUI_FONT));
dc = splash.GetDC();
rc.right = rc.left + 350;
rc.bottom = rc.top + 120;
splash.ReleaseDC(dc);
splash.HideCaret();
splash.SetWindowPos(NULL, &rc, SWP_SHOWWINDOW);
splash.SetWindowLongPtr(GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(&splashCallback));
splash.CenterWindow();
sTitle = TSTRING(PROCESSING);
splash.SetFocus();
splash.RedrawWindow();
shutdown(callBack, (void*)splash.m_hWnd);
splash.DestroyWindow();
dummy.DestroyWindow();
return nRet;
}
void CControlPage::PopulateList() {
// Populate the controls in the dialogue box based on the relevent parameters
// in m_pDasher
SB_slider = GetDlgItem(m_hwnd, IDC_SPEEDSLIDER);
SendMessage(SB_slider, TBM_SETPAGESIZE, 0L, 20); // PgUp and PgDown change bitrate by reasonable amount
SendMessage(SB_slider, TBM_SETTICFREQ, 100, 0L);
SendMessage(SB_slider, TBM_SETRANGE, FALSE, (LPARAM)MAKELONG(10, 800));
speedbox = GetDlgItem(m_hwnd, IDC_SPEEDVAL);
SendMessage(SB_slider, TBM_SETPOS, TRUE, (LPARAM)m_pAppSettings->GetLongParameter(LP_MAX_BITRATE));
_sntprintf(m_tcBuffer, 100, TEXT("%0.2f"), m_pAppSettings->GetLongParameter(LP_MAX_BITRATE) / 100.0);
SendMessage(speedbox, WM_SETTEXT, 0, (LPARAM)m_tcBuffer);
m_hMousePosStyle = GetDlgItem(m_hwnd, IDC_MOUSEPOS_STYLE);
SendMessage(m_hMousePosStyle, CB_ADDSTRING, 0, (LPARAM)L"Centre circle");
SendMessage(m_hMousePosStyle, CB_ADDSTRING, 0, (LPARAM)L"Two box");
if (m_pAppSettings->GetBoolParameter(BP_MOUSEPOS_MODE)) {
SendMessage(m_hMousePosStyle, CB_SETCURSEL, 1, 0);
}
else {
SendMessage(m_hMousePosStyle, CB_SETCURSEL, 0, 0);
}
if (m_pAppSettings->GetBoolParameter(BP_MOUSEPOS_MODE) || m_pAppSettings->GetBoolParameter(BP_CIRCLE_START)) {
SendMessage(GetDlgItem(m_hwnd, IDC_MOUSEPOS), BM_SETCHECK, BST_CHECKED, 0);
}
else {
SendMessage(GetDlgItem(m_hwnd, IDC_MOUSEPOS), BM_SETCHECK, BST_UNCHECKED, 0);
}
// all the button checkboxes
for (int ii = 0; ii < sizeof(menutable) / sizeof(menuentry); ii++)
{
if (m_pAppSettings->GetBoolParameter(menutable[ii].paramNum))
{
SendMessage(GetDlgItem(m_hwnd, menutable[ii].idcNum), BM_SETCHECK, BST_CHECKED, 0);
}
else
{
SendMessage(GetDlgItem(m_hwnd, menutable[ii].idcNum), BM_SETCHECK, BST_UNCHECKED, 0);
}
}
// List entries:
for (int i(0); i < sizeof(listtable) / sizeof(menuentry); ++i) {
std::vector<std::string> vValues;
m_pAppSettings->GetPermittedValues(listtable[i].paramNum, vValues);
CWindow lbox = GetDlgItem(m_hwnd, listtable[i].idcNum);
auto currentParameterValue = m_pAppSettings->GetStringParameter(listtable[i].paramNum);
for (auto value : vValues) {
wstring Item;
WinUTF8::UTF8string_to_wstring(value, Item);
int iIdx = lbox.SendMessage(LB_ADDSTRING, 0, (LPARAM)Item.c_str());
if (value == currentParameterValue)
lbox.SendMessage(LB_SETCURSEL, iIdx, 0);
}
}
EnablePrefferencesForSelectedModule(IDC_CONTROL_LIST, IDC_BUTTON_PREFS);
EnablePrefferencesForSelectedModule(IDC_INPUT_LIST, IDC_BUTTON_PREFS2);
}
void CScreenApperance::CreateInterface()
{
CWindow* pw;
CLabel* pl;
CButton* pb;
CColor* pco;
CSlider* psl;
Math::Point pos, ddim;
std::string name;
pos.x = 0.10f;
pos.y = 0.10f;
ddim.x = 0.80f;
ddim.y = 0.80f;
pw = m_interface->CreateWindows(pos, ddim, 12, EVENT_WINDOW5);
GetResource(RES_TEXT, RT_TITLE_PERSO, name);
pw->SetName(name);
pos.x = 0.10f;
pos.y = 0.40f;
ddim.x = 0.50f;
ddim.y = 0.50f;
pw->CreateGroup(pos, ddim, 5, EVENT_INTERFACE_GLINTl); // orange corner
pos.x = 0.40f;
pos.y = 0.10f;
ddim.x = 0.50f;
ddim.y = 0.50f;
pw->CreateGroup(pos, ddim, 4, EVENT_INTERFACE_GLINTr); // blue corner
pos.x = 95.0f/640.0f;
pos.y = 108.0f/480.0f;
ddim.x = 220.0f/640.0f;
ddim.y = 274.0f/480.0f;
pw->CreateGroup(pos, ddim, 17, EVENT_NULL); // frame
pos.x = 100.0f/640.0f;
pos.y = 364.0f/480.0f;
ddim.x = 210.0f/640.0f;
ddim.y = 14.0f/480.0f;
pw->CreateGroup(pos, ddim, 3, EVENT_NULL); // transparent -> gray
pos.x = 120.0f/640.0f;
pos.y = 364.0f/480.0f;
ddim.x = 80.0f/640.0f;
ddim.y = 28.0f/480.0f;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_PHEAD);
pb->SetState(STATE_SHADOW);
pb->SetState(STATE_CARD);
pos.x = 210.0f/640.0f;
pos.y = 364.0f/480.0f;
ddim.x = 80.0f/640.0f;
ddim.y = 28.0f/480.0f;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_PBODY);
pb->SetState(STATE_SHADOW);
pb->SetState(STATE_CARD);
pos.x = 100.0f/640.0f;
pos.y = 354.0f/480.0f;
ddim.x = 210.0f/640.0f;
ddim.y = 10.0f/480.0f;
pw->CreateGroup(pos, ddim, 1, EVENT_INTERFACE_GLINTb); // orange bar
pos.x = 100.0f/640.0f;
pos.y = 154.0f/480.0f;
ddim.x = 210.0f/640.0f;
ddim.y = 200.0f/480.0f;
pw->CreateGroup(pos, ddim, 2, EVENT_INTERFACE_GLINTu); // orange -> transparent
// Face
pos.x = 340.0f/640.0f;
pos.y = 356.0f/480.0f;
ddim.x = 200.0f/640.0f;
ddim.y = 16.0f/480.0f;
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL11, "");
pl->SetTextAlign(Gfx::TEXT_ALIGN_LEFT);
pos.x = 340.0f/640.0f;
pos.y = 312.0f/480.0f;
ddim.x = 44.0f/640.0f;
ddim.y = 44.0f/480.0f;
pb = pw->CreateButton(pos, ddim, 43, EVENT_INTERFACE_PFACE1);
pb->SetState(STATE_SHADOW);
pos.x += 50.0f/640.0f;
pb = pw->CreateButton(pos, ddim, 46, EVENT_INTERFACE_PFACE4);
pb->SetState(STATE_SHADOW);
pos.x += 50.0f/640.0f;
pb = pw->CreateButton(pos, ddim, 45, EVENT_INTERFACE_PFACE3);
pb->SetState(STATE_SHADOW);
pos.x += 50.0f/640.0f;
pb = pw->CreateButton(pos, ddim, 44, EVENT_INTERFACE_PFACE2);
pb->SetState(STATE_SHADOW);
// Glasses
pos.x = 340.0f/640.0f;
pos.y = 270.0f/480.0f;
ddim.x = 200.0f/640.0f;
ddim.y = 16.0f/480.0f;
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL12, "");
pl->SetTextAlign(Gfx::TEXT_ALIGN_LEFT);
pos.x = 340.0f/640.0f;
pos.y = 240.0f/480.0f;
ddim.x = 30.0f/640.0f;
ddim.y = 30.0f/480.0f;
for ( int i=0 ; i<6 ; i++ )
{
int ti[6] = {11, 179, 180, 181, 182, 183};
pb = pw->CreateButton(pos, ddim, ti[i], static_cast<EventType>(EVENT_INTERFACE_PGLASS0+i));
pb->SetState(STATE_SHADOW);
pos.x += (30.0f+2.8f)/640.0f;
}
// Color A
pos.x = 340.0f/640.0f;
pos.y = 300.0f/480.0f;
ddim.x = 200.0f/640.0f;
ddim.y = 16.0f/480.0f;
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL14, "");
pl->SetTextAlign(Gfx::TEXT_ALIGN_LEFT);
pos.y = 282.0f/480.0f;
ddim.x = 18.0f/640.0f;
ddim.y = 18.0f/480.0f;
for ( int j=0 ; j<3 ; j++ )
{
pos.x = 340.0f/640.0f;
for ( int i=0 ; i<3 ; i++ )
{
pco = pw->CreateColor(pos, ddim, -1, static_cast<EventType>(EVENT_INTERFACE_PC0a+j*3+i));
pco->SetState(STATE_SHADOW);
pos.x += 20.0f/640.0f;
}
pos.y -= 20.0f/480.0f;
}
pos.x = 420.0f/640.0f;
pos.y = 282.0f/480.0f;
ddim.x = 100.0f/640.0f;
ddim.y = 18.0f/480.0f;
for ( int i=0 ; i<3 ; i++ )
{
psl = pw->CreateSlider(pos, ddim, 0, static_cast<EventType>(EVENT_INTERFACE_PCRa+i));
psl->SetState(STATE_SHADOW);
psl->SetLimit(0.0f, 255.0f);
psl->SetArrowStep(16.0f);
pos.y -= 20.0f/480.0f;
}
// Color B
pos.x = 340.0f/640.0f;
pos.y = 192.0f/480.0f;
ddim.x = 200.0f/640.0f;
ddim.y = 16.0f/480.0f;
pl = pw->CreateLabel(pos, ddim, 0, EVENT_LABEL13, "");
pl->SetTextAlign(Gfx::TEXT_ALIGN_LEFT);
pos.y = 174.0f/480.0f;
ddim.x = 18.0f/640.0f;
ddim.y = 18.0f/480.0f;
for ( int j=0 ; j<3 ; j++ )
{
pos.x = 340.0f/640.0f;
for ( int i=0 ; i<3 ; i++ )
{
pco = pw->CreateColor(pos, ddim, -1, static_cast<EventType>(EVENT_INTERFACE_PC0b+j*3+i));
pco->SetState(STATE_SHADOW);
pos.x += 20.0f/640.0f;
}
pos.y -= 20.0f/480.0f;
}
pos.x = 420.0f/640.0f;
pos.y = 174.0f/480.0f;
ddim.x = 100.0f/640.0f;
ddim.y = 18.0f/480.0f;
for ( int i=0 ; i<3 ; i++ )
{
psl = pw->CreateSlider(pos, ddim, 0, static_cast<EventType>(EVENT_INTERFACE_PCRb+i));
psl->SetState(STATE_SHADOW);
psl->SetLimit(0.0f, 255.0f);
psl->SetArrowStep(16.0f);
pos.y -= 20.0f/480.0f;
}
// Rotation
pos.x = 100.0f/640.0f;
pos.y = 113.0f/480.0f;
ddim.x = 20.0f/640.0f;
ddim.y = 20.0f/480.0f;
pb = pw->CreateButton(pos, ddim, 55, EVENT_INTERFACE_PLROT); // <
pb->SetState(STATE_SHADOW);
pb->SetRepeat(true);
pos.x = 290.0f/640.0f;
pos.y = 113.0f/480.0f;
ddim.x = 20.0f/640.0f;
ddim.y = 20.0f/480.0f;
pb = pw->CreateButton(pos, ddim, 48, EVENT_INTERFACE_PRROT); // >
pb->SetState(STATE_SHADOW);
pb->SetRepeat(true);
pos.x = 100.0f/640.0f;
pos.y = 70.0f/480.0f;
ddim.x = 100.0f/640.0f;
ddim.y = 32.0f/480.0f;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_POK);
pb->SetState(STATE_SHADOW);
pos.x = 210.0f/640.0f;
pos.y = 70.0f/480.0f;
ddim.x =100.0f/640.0f;
ddim.y = 32.0f/480.0f;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_PCANCEL);
pb->SetState(STATE_SHADOW);
pos.x = 340.0f/640.0f;
pos.y = 70.0f/480.0f;
ddim.x =194.0f/640.0f;
ddim.y = 32.0f/480.0f;
pb = pw->CreateButton(pos, ddim, -1, EVENT_INTERFACE_PDEF);
pb->SetState(STATE_SHADOW);
m_apperanceTab = 0;
m_apperanceAngle = -0.6f;
m_main->GetPlayerProfile()->LoadApperance();
UpdatePerso();
m_main->ScenePerso();
CameraPerso();
}
void CDisplayInfo::AdjustDisplayInfo(Math::Point wpos, Math::Point wdim)
{
CWindow* pw;
CEdit* edit;
CButton* button;
CSlider* slider;
CGroup* group;
Math::Point pos, dim;
wpos.x = 50.0f / 640.0f;
wpos.y = 30.0f / 480.0f;
wdim.x = 540.0f / 640.0f;
wdim.y = 420.0f / 480.0f;
pw = static_cast<Ui::CWindow*>(m_interface->SearchControl(EVENT_WINDOW4));
if ( pw != nullptr )
{
pw->SetPos(wpos);
pw->SetDim(wdim);
wdim = pw->GetDim();
}
pos.x = (50.0f + 10.0f) / 640.0f;
pos.y = (30.0f + 10.0f + 24.0f + 10.0f + 324.0f - 48.0f) / 480.0f;
dim.x = 48.0f / 640.0f;
dim.y = 48.0f / 480.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_SATCOM_HUSTON));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.y -= (48.0f + 4.0f) / 480.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_SATCOM_SAT));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
//? pos.y -= (48.0f+4.0f)/480.0f;
//? button = (CButton*)pw->SearchControl(EVENT_SATCOM_OBJECT);
//? if ( button != 0 )
//? {
//? button->SetPos(pos);
//? button->SetDim(dim);
//? }
pos.y -= (48.0f + 4.0f) / 480.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_SATCOM_LOADING));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.y -= (48.0f + 4.0f) / 480.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_SATCOM_PROG));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.y -= (48.0f + 4.0f) / 480.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_SATCOM_SOLUCE));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x = (50.0f + 10.0f + 5.0f) / 640.0f;
pos.y = (30.0f + 10.0f + 4.0f) / 480.0f;
dim.x = (48.0f - 10.0f) / 640.0f;
dim.y = 24.0f / 480.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_OBJECT_INFOOK));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x = (50.0f + 10.0f + 48.0f + 10.0f) / 640.0f;
pos.y = (30.0f + 10.0f) / 480.0f;
dim.x = 462.0f / 640.0f;
dim.y = 358.0f / 480.0f;
edit = static_cast<Ui::CEdit*>(pw->SearchControl(EVENT_EDIT1));
if ( edit != nullptr )
{
edit->SetPos(pos);
edit->SetDim(dim);
}
pos.x = (50.0f + 10.0f + 48.0f + 10.0f) / 640.0f;
pos.y = (30.0f + 10.0f + 358.0f + 10.0f) / 480.0f;
dim.x = 32.0f / 640.0f;
dim.y = 32.0f / 480.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_HYPER_PREV));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x += 35.0f / 640.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_HYPER_NEXT));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x += 35.0f / 640.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_HYPER_HOME));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x += 50.0f / 640.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_HYPER_SIZE1));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x += 35.0f / 640.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_HYPER_SIZE2));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x += 35.0f / 640.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_HYPER_SIZE3));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x += 35.0f / 640.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_HYPER_SIZE4));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x += 35.0f / 640.0f;
dim.x = 18.0f / 640.0f;
slider = static_cast<Ui::CSlider*>(pw->SearchControl(EVENT_STUDIO_SIZE));
if ( slider != nullptr )
{
slider->SetPos(pos);
slider->SetDim(dim);
}
pos.x += 50.0f / 640.0f;
dim.x = 32.0f / 640.0f;
button = static_cast<Ui::CButton*>(pw->SearchControl(EVENT_HYPER_COPY));
if ( button != nullptr )
{
button->SetPos(pos);
button->SetDim(dim);
}
pos.x = (50.0f + 10.0f) / 640.0f;
pos.y = (30.0f + 10.0f + 24.0f + 10.0f + 324.0f + 6.0f) / 480.0f;
dim.x = 48.0f / 640.0f;
dim.y = 40.0f / 480.0f;
group = static_cast<Ui::CGroup*>(pw->SearchControl(EVENT_LABEL2)); // symbol SatCom
if ( group != nullptr )
{
group->SetPos(pos);
group->SetDim(dim);
}
pos.x = (50.0f + 10.0f + 14.0f) / 640.0f;
pos.y = (30.0f + 10.0f + 6.0f) / 480.0f;
dim.x = 20.0f / 640.0f;
dim.y = 20.0f / 480.0f;
group = static_cast<Ui::CGroup*>(pw->SearchControl(EVENT_LABEL3)); // symbol stand-by
if ( group != nullptr )
{
group->SetPos(pos);
group->SetDim(dim);
}
}
void CScreenApperance::UpdatePerso()
{
CWindow* pw;
CLabel* pl;
CButton* pb;
CColor* pc;
CSlider* ps;
Gfx::Color color;
std::string name;
int i;
PlayerApperance& apperance = m_main->GetPlayerProfile()->GetApperance();
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW5));
if ( pw == nullptr ) return;
pb = static_cast<CButton*>(pw->SearchControl(EVENT_INTERFACE_PHEAD));
if ( pb != nullptr )
{
pb->SetState(STATE_CHECK, m_apperanceTab==0);
}
pb = static_cast<CButton*>(pw->SearchControl(EVENT_INTERFACE_PBODY));
if ( pb != nullptr )
{
pb->SetState(STATE_CHECK, m_apperanceTab==1);
}
pl = static_cast<CLabel*>(pw->SearchControl(EVENT_LABEL11));
if ( pl != nullptr )
{
if ( m_apperanceTab == 0 )
{
pl->SetState(STATE_VISIBLE);
GetResource(RES_TEXT, RT_PERSO_FACE, name);
pl->SetName(name);
}
else
{
pl->ClearState(STATE_VISIBLE);
}
}
pl = static_cast<CLabel*>(pw->SearchControl(EVENT_LABEL12));
if ( pl != nullptr )
{
if ( m_apperanceTab == 0 )
{
pl->SetState(STATE_VISIBLE);
GetResource(RES_TEXT, RT_PERSO_GLASSES, name);
pl->SetName(name);
}
else
{
pl->ClearState(STATE_VISIBLE);
}
}
pl = static_cast<CLabel*>(pw->SearchControl(EVENT_LABEL13));
if ( pl != nullptr )
{
if ( m_apperanceTab == 0 ) GetResource(RES_TEXT, RT_PERSO_HAIR, name);
else GetResource(RES_TEXT, RT_PERSO_BAND, name);
pl->SetName(name);
}
pl = static_cast<CLabel*>(pw->SearchControl(EVENT_LABEL14));
if ( pl != nullptr )
{
if ( m_apperanceTab == 0 )
{
pl->ClearState(STATE_VISIBLE);
}
else
{
pl->SetState(STATE_VISIBLE);
GetResource(RES_TEXT, RT_PERSO_COMBI, name);
pl->SetName(name);
}
}
for ( i=0 ; i<4 ; i++ )
{
pb = static_cast<CButton*>(pw->SearchControl(static_cast<EventType>(EVENT_INTERFACE_PFACE1+i)));
if ( pb == nullptr ) break;
pb->SetState(STATE_VISIBLE, m_apperanceTab==0);
pb->SetState(STATE_CHECK, i==apperance.face);
}
for ( i=0 ; i<10 ; i++ )
{
pb = static_cast<CButton*>(pw->SearchControl(static_cast<EventType>(EVENT_INTERFACE_PGLASS0+i)));
if ( pb == nullptr ) break;
pb->SetState(STATE_VISIBLE, m_apperanceTab==0);
pb->SetState(STATE_CHECK, i==apperance.glasses);
}
for ( i=0 ; i<3*3 ; i++ )
{
pc = static_cast<CColor*>(pw->SearchControl(static_cast<EventType>(EVENT_INTERFACE_PC0a+i)));
if ( pc == nullptr ) break;
if ( m_apperanceTab == 0 )
{
pc->ClearState(STATE_VISIBLE);
}
else
{
pc->SetState(STATE_VISIBLE);
color.r = PERSO_COLOR[3*10*1+3*i+0]/255.0f;
color.g = PERSO_COLOR[3*10*1+3*i+1]/255.0f;
color.b = PERSO_COLOR[3*10*1+3*i+2]/255.0f;
color.a = 0.0f;
pc->SetColor(color);
pc->SetState(STATE_CHECK, EqColor(color, apperance.colorCombi));
}
pc = static_cast<CColor*>(pw->SearchControl(static_cast<EventType>(EVENT_INTERFACE_PC0b+i)));
if ( pc == nullptr ) break;
color.r = PERSO_COLOR[3*10*2*m_apperanceTab+3*i+0]/255.0f;
color.g = PERSO_COLOR[3*10*2*m_apperanceTab+3*i+1]/255.0f;
color.b = PERSO_COLOR[3*10*2*m_apperanceTab+3*i+2]/255.0f;
color.a = 0.0f;
pc->SetColor(color);
pc->SetState(STATE_CHECK, EqColor(color, m_apperanceTab?apperance.colorBand:apperance.colorHair));
}
for ( i=0 ; i<3 ; i++ )
{
ps = static_cast<CSlider*>(pw->SearchControl(static_cast<EventType>(EVENT_INTERFACE_PCRa+i)));
if ( ps == nullptr ) break;
ps->SetState(STATE_VISIBLE, m_apperanceTab==1);
}
if ( m_apperanceTab == 1 )
{
color = apperance.colorCombi;
ps = static_cast<CSlider*>(pw->SearchControl(EVENT_INTERFACE_PCRa));
if ( ps != nullptr ) ps->SetVisibleValue(color.r*255.0f);
ps = static_cast<CSlider*>(pw->SearchControl(EVENT_INTERFACE_PCGa));
if ( ps != nullptr ) ps->SetVisibleValue(color.g*255.0f);
ps = static_cast<CSlider*>(pw->SearchControl(EVENT_INTERFACE_PCBa));
if ( ps != nullptr ) ps->SetVisibleValue(color.b*255.0f);
}
if ( m_apperanceTab == 0 ) color = apperance.colorHair;
else color = apperance.colorBand;
ps = static_cast<CSlider*>(pw->SearchControl(EVENT_INTERFACE_PCRb));
if ( ps != nullptr ) ps->SetVisibleValue(color.r*255.0f);
ps = static_cast<CSlider*>(pw->SearchControl(EVENT_INTERFACE_PCGb));
if ( ps != nullptr ) ps->SetVisibleValue(color.g*255.0f);
ps = static_cast<CSlider*>(pw->SearchControl(EVENT_INTERFACE_PCBb));
if ( ps != nullptr ) ps->SetVisibleValue(color.b*255.0f);
}
/**
* FUNCTION SetEditWindowValue
*
* @brief Sets the edit window text
*
* @author DAVID.LIBBY
* @date 6/1/2015 9:50:21 AM
*
* @param CurWindow
* @param NewValue
*/
void AutoCamera::SetEditWindowValue(CWindow &CurWindow,int NewValue)
{
CurWindow.SetWindowTextW(CA2W(intToString(NewValue).c_str()).m_szBuffer);
}
void AsGroupsDlg::updateSelectedGroup(bool forceClean /*= false*/) {
tstring name;
bool enableButtons = false;
if (ctrlGroups.GetSelectedIndex() != -1) {
if (forceClean == false) {
name = getText(0);
}
enableButtons = true;
}
{
CWindow wnd;
wnd.Attach(GetDlgItem(IDC_REMOVE));
wnd.EnableWindow(enableButtons);
wnd.Detach();
wnd.Attach(GetDlgItem(IDC_UPDATE));
wnd.EnableWindow(enableButtons);
wnd.Detach();
wnd.Attach(GetDlgItem(IDC_MOVE_DOWN));
wnd.EnableWindow(enableButtons);
wnd.Detach();
wnd.Attach(GetDlgItem(IDC_MOVE_UP));
wnd.EnableWindow(enableButtons);
wnd.Detach();
}
{
CEdit wnd;
wnd.Attach(GetDlgItem(IDC_NAME));
wnd.SetWindowText(name.c_str());
wnd.Detach();
}
}
// FUNCTION: InitInstance(HANDLE, int)
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
CWindow wnd;
g_hInstance = hInstance;
ReloadLangSmart();
// LoadString(hInstance, IDS_CLASS, windowClass, MAX_LOADSTRING);
// LoadString(hInstance, IDS_APP_TITLE, title, MAX_LOADSTRING);
UString title = LangString(IDS_APP_TITLE, 0x03000000);
/*
//If it is already running, then focus on the window
hWnd = FindWindow(windowClass, title);
if (hWnd)
{
SetForegroundWindow ((HWND) (((DWORD)hWnd) | 0x01));
return 0;
}
*/
WNDCLASSW wc;
// wc.style = CS_HREDRAW | CS_VREDRAW;
wc.style = 0;
wc.lpfnWndProc = (WNDPROC) WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON));
// wc.hCursor = LoadCursor (NULL, IDC_ARROW);
wc.hCursor = ::LoadCursor(0, IDC_SIZEWE);
// wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
wc.lpszMenuName =
#ifdef UNDER_CE
0
#else
MAKEINTRESOURCEW(IDM_MENU)
#endif
;
wc.lpszClassName = kWindowClass;
MyRegisterClass(&wc);
// RECT rect;
// GetClientRect(hWnd, &rect);
DWORD style = WS_OVERLAPPEDWINDOW;
// DWORD style = 0;
RECT rect;
bool maximized = false;
int x , y, xSize, ySize;
x = y = xSize = ySize = CW_USEDEFAULT;
bool windowPosIsRead = ReadWindowSize(rect, maximized);
if (windowPosIsRead)
{
// x = rect.left;
// y = rect.top;
xSize = rect.right - rect.left;
ySize = rect.bottom - rect.top;
}
UInt32 numPanels, currentPanel;
g_PanelsInfoDefined = ReadPanelsInfo(numPanels, currentPanel, g_SplitterPos);
if (g_PanelsInfoDefined)
{
if (numPanels < 1 || numPanels > 2)
numPanels = kNumDefaultPanels;
if (currentPanel >= 2)
currentPanel = 0;
}
else
{
numPanels = kNumDefaultPanels;
currentPanel = 0;
}
g_App.NumPanels = numPanels;
g_App.LastFocusedPanel = currentPanel;
if (!wnd.Create(kWindowClass, title, style,
x, y, xSize, ySize, NULL, NULL, hInstance, NULL))
return FALSE;
if (nCmdShow == SW_SHOWNORMAL ||
nCmdShow == SW_SHOW
#ifndef UNDER_CE
|| nCmdShow == SW_SHOWDEFAULT
#endif
)
{
if (maximized)
nCmdShow = SW_SHOWMAXIMIZED;
else
nCmdShow = SW_SHOWNORMAL;
}
if (nCmdShow == SW_SHOWMAXIMIZED)
g_Maximized = true;
#ifndef UNDER_CE
WINDOWPLACEMENT placement;
placement.length = sizeof(placement);
if (wnd.GetPlacement(&placement))
{
if (windowPosIsRead)
placement.rcNormalPosition = rect;
placement.showCmd = nCmdShow;
wnd.SetPlacement(&placement);
}
else
#endif
wnd.Show(nCmdShow);
return TRUE;
}
void* CSysWindow::GetNativeDisplayHandle(const WindowHandle& handle)
{
CWindow* window = (CWindow*)handle;
return window->GetHDC();
}
void CMainDialog::StartPauseMenu()
{
CWindow* pw;
CButton* pb;
Math::Point pos, dim;
std::string name;
StartDialog(Math::Point(0.3f, 0.8f), true);
m_dialogType = DialogType::PauseMenu;
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW9));
if ( pw == nullptr ) return;
pos.x = 0.35f;
pos.y = 0.60f;
dim.x = 0.30f;
dim.y = 0.30f;
pw->CreateGroup(pos, dim, 5, EVENT_INTERFACE_GLINTl); // orange corner
pos.x = 0.35f;
pos.y = 0.10f;
dim.x = 0.30f;
dim.y = 0.30f;
pw->CreateGroup(pos, dim, 4, EVENT_INTERFACE_GLINTr); // blue corner
pos.x = 0.40f;
dim.x = 0.20f;
dim.y = 32.0f/480.0f;
pos.y = 0.74f;
pb = pw->CreateButton(pos, dim, -1, EVENT_DIALOG_CANCEL);
pb->SetState(STATE_SHADOW);
GetResource(RES_TEXT, RT_DIALOG_CONTINUE, name);
pb->SetName(name);
if ( (m_main->GetLevelCategory() == LevelCategory::Missions || // missions ?
m_main->GetLevelCategory() == LevelCategory::FreeGame || // free games?
m_main->GetLevelCategory() == LevelCategory::CustomLevels ) && // user ?
m_main->GetMissionType() != MISSION_CODE_BATTLE )
{
pos.y = 0.62f;
pb = pw->CreateButton(pos, dim, -1, EVENT_INTERFACE_WRITE);
pb->SetState(STATE_SHADOW);
if ( m_main->IOIsBusy() ) // current task?
{
pb->ClearState(STATE_ENABLE);
}
pos.y = 0.53f;
pb = pw->CreateButton(pos, dim, -1, EVENT_INTERFACE_READ);
pb->SetState(STATE_SHADOW);
if ( !m_main->GetPlayerProfile()->HasAnySavedScene() ) // no file to read?
{
pb->ClearState(STATE_ENABLE);
}
pb->SetState(STATE_WARNING);
}
pos.y = 0.39f;
pb = pw->CreateButton(pos, dim, -1, EVENT_INTERFACE_SETUP);
pb->SetState(STATE_SHADOW);
pos.y = 0.25f;
pb = pw->CreateButton(pos, dim, -1, EVENT_INTERFACE_AGAIN);
pb->SetState(STATE_SHADOW);
pb->SetState(STATE_WARNING);
pos.y = 0.16f;
pb = pw->CreateButton(pos, dim, -1, EVENT_DIALOG_OK);
pb->SetState(STATE_SHADOW);
pb->SetState(STATE_WARNING);
GetResource(RES_TEXT, RT_DIALOG_ABORT, name);
pb->SetName(name);
}
STDMETHODIMP CCommandHandler::Execute(
UINT nCmdID,
UI_EXECUTIONVERB verb,
__in_opt const PROPERTYKEY* key,
__in_opt const PROPVARIANT* ppropvarValue,
__in_opt IUISimplePropertySet* pCommandExecutionProperties )
{
UNREFERENCED_PARAMETER( pCommandExecutionProperties );
UNREFERENCED_PARAMETER( ppropvarValue );
UNREFERENCED_PARAMETER( key );
UNREFERENCED_PARAMETER( verb );
UNREFERENCED_PARAMETER( nCmdID );
switch ( nCmdID ) {
case cmdNewMap:
::CreateDialog( GetModuleHandle( 0 ), MAKEINTRESOURCE( IDD_DIALOG1 ), MainMapRedactorWindow.GetHandle(), CWindow::dialogProc );
break;
case cmdLoadMap:
MainMapRedactorWindow.LoadFile();
break;
case cmdSaveMap:
MainMapRedactorWindow.SaveFile();
break;
case cmdRoad:
MainMapRedactorWindow.SetBrush( MainMapRedactorWindow.GetBrush() == BRoad ? BNone : BRoad );
break;
case cmdTree:
MainMapRedactorWindow.SetBrush( MainMapRedactorWindow.GetBrush() == BTree ? BNone : BTree );
break;
case cmdWall:
MainMapRedactorWindow.SetBrush( MainMapRedactorWindow.GetBrush() == BWall ? BNone : BWall );
break;
case cmdStart:
MainMapRedactorWindow.SetBrush( MainMapRedactorWindow.GetBrush() == BStart ? BNone : BStart );
break;
case cmdFinish:
MainMapRedactorWindow.SetBrush(MainMapRedactorWindow.GetBrush() == BFinish ? BNone : BFinish);
break;
default:
break;
}
return S_OK;
}
void CMainDialog::FrameDialog(float rTime)
{
CWindow* pw;
Math::Vector pos, speed;
Math::Point dim, dpos, ddim;
float zoom;
int i;
dpos = m_dialogPos;
ddim = m_dialogDim;
m_dialogTime += rTime;
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW9));
if ( pw != nullptr )
{
if ( m_dialogTime < 1.0f )
{
if ( m_dialogTime < 0.50f )
{
zoom = Math::Bounce(m_dialogTime/0.50f);
}
else
{
zoom = 1.0f;
}
dpos.x += ddim.x/2.0f;
dpos.y += ddim.y/2.0f;
ddim.x *= zoom;
//? ddim.y *= zoom;
dpos.x -= ddim.x/2.0f;
dpos.y -= ddim.y/2.0f;
}
pw->SetPos(dpos);
pw->SetDim(ddim);
}
if ( !m_settings->GetInterfaceGlint() ) return;
m_dialogParti += rTime;
if ( m_dialogParti < m_engine->ParticleAdapt(0.05f) ) return;
m_dialogParti = 0.0f;
if ( !m_dialogFireParticles ) return;
dpos = m_dialogPos;
ddim = m_dialogDim;
pos.z = 0.0f;
speed = Math::Vector(0.0f, 0.0f, 0.0f);
for ( i=0 ; i<2 ; i++ )
{
// Bottom.
pos.x = dpos.x + ddim.x*Math::Rand();
pos.y = dpos.y;
pos.x += (Math::Rand()-0.5f)*(6.0f/640.0f);
pos.y += Math::Rand()*(16.0f/480.0f)-(10.0f/480.0f);
dim.x = 0.01f+Math::Rand()*0.01f;
dim.y = dim.x/0.75f;
m_particle->CreateParticle(pos, speed, dim,
static_cast<Gfx::ParticleType>(Gfx::PARTILENS1+rand()%3),
1.0f, 0.0f, 0.0f, Gfx::SH_INTERFACE);
// Top.
pos.x = dpos.x + ddim.x*Math::Rand();
pos.y = dpos.y + ddim.y;
pos.x += (Math::Rand()-0.5f)*(6.0f/640.0f);
pos.y -= Math::Rand()*(16.0f/480.0f)-(10.0f/480.0f);
dim.x = 0.01f+Math::Rand()*0.01f;
dim.y = dim.x/0.75f;
m_particle->CreateParticle(pos, speed, dim,
static_cast<Gfx::ParticleType>(Gfx::PARTILENS1+rand()%3),
1.0f, 0.0f, 0.0f, Gfx::SH_INTERFACE);
// Left.
pos.y = dpos.y + ddim.y*Math::Rand();
pos.x = dpos.x;
pos.x += Math::Rand()*(16.0f/640.0f)-(10.0f/640.0f);
pos.y += (Math::Rand()-0.5f)*(6.0f/480.0f);
dim.x = 0.01f+Math::Rand()*0.01f;
dim.y = dim.x/0.75f;
m_particle->CreateParticle(pos, speed, dim,
static_cast<Gfx::ParticleType>(Gfx::PARTILENS1+rand()%3),
1.0f, 0.0f, 0.0f, Gfx::SH_INTERFACE);
// Right.
pos.y = dpos.y + ddim.y*Math::Rand();
pos.x = dpos.x + ddim.x;
pos.x -= Math::Rand()*(16.0f/640.0f)-(10.0f/640.0f);
pos.y += (Math::Rand()-0.5f)*(6.0f/480.0f);
dim.x = 0.01f+Math::Rand()*0.01f;
dim.y = dim.x/0.75f;
m_particle->CreateParticle(pos, speed, dim,
static_cast<Gfx::ParticleType>(Gfx::PARTILENS1+rand()%3),
1.0f, 0.0f, 0.0f, Gfx::SH_INTERFACE);
}
}
/****************************************************************************\
| Function: CNumberedWindow::HandlePointerEvent
| Purpose: Handles pointer events for CNumberedWindow.
| Input: aPointerEvent The pointer event
| Output: None
\****************************************************************************/
void CNumberedWindow::HandlePointerEvent(TPointerEvent& aPointerEvent)
{
switch (aPointerEvent.iType)
{
case TPointerEvent::EDrag:
{
// Move the window position as the pointer is dragged.
TPoint point = aPointerEvent.iParentPosition;
TPoint distToMove = point - iOldPos;
TPoint position = Window().Position();
Window().SetPosition(position + distToMove);
iOldPos = point;
break;
}
case TPointerEvent::EButton1Down:
{
// Move window to front
Window().SetOrdinalPosition(0);
// Request drag events
Window().PointerFilter(EPointerFilterDrag, 0);
// Initialize starting point for dragging
iOldPos = aPointerEvent.iParentPosition;
break;
}
case TPointerEvent::EButton1Up:
{
// Cancel the request for drag events.
Window().PointerFilter(EPointerFilterDrag, EPointerFilterDrag);
break;
}
case TPointerEvent::EButton3Down:
{
// Cascade windows in top left corner.
// Window at the front should be cascaded last.
// The window at the front (ordinal position 0) is given by Child(), and
// each window behind it is given by NextSibling(). We need to go down
// the sibling list till we get to the last sibling, and move this to
// the top left corner. Then go back up the list and move each previous
// sibling on top of the last, displaced by an offset (of TPoint(10,10)).
TPoint point(0, 0);
TUint32 nextSib, prevSib;
CWindow* childWindow;
TInt numChildren = 0;
TUint32 child = Window().Child();
if (child)
{
childWindow = (CWindow*) child;
numChildren++;
nextSib = childWindow->Window().NextSibling();
while (nextSib)
{
numChildren++;
childWindow = (CWindow*) nextSib;
nextSib = childWindow->Window().NextSibling();
}
for (TInt i = numChildren; i > 0; i--)
{
childWindow->Window().SetPosition(point);
prevSib = childWindow->Window().PrevSibling();
if (prevSib)
{
childWindow = (CWindow*) prevSib;
point += TPoint(10, 10);
}
}
}
break;
}
default:
break;
}
}
// PROGRAM START
int main(int argc, char *argv[])
{
srand((unsigned int)(time(0)));
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
RMASK = 0xff000000;
GMASK = 0x00ff0000;
BMASK = 0x0000ff00;
AMASK = 0x000000ff;
#else
RMASK = 0x000000ff;
GMASK = 0x0000ff00;
BMASK = 0x00ff0000;
AMASK = 0xff000000;
#endif
// Load in the target image and create the two additional surfaces
Target = IMG_Load("TestImage.png");
if (Target->w > IMAGE_MAX_W) return -1;
if (Target->h > IMAGE_MAX_H) return -2;
Best = SDL_CreateRGBSurface(SDL_SWSURFACE, Target->w, Target->h, 32, RMASK, GMASK, BMASK, AMASK);
Evolve = SDL_CreateRGBSurface(SDL_SWSURFACE, Target->w, Target->h, 32, RMASK, GMASK, BMASK, AMASK);
// If the surfaces are wider or taller than the maximum render area, decide how to scale it to fit
RenderScale = 1.0;
if ((Target->w > RENDER_MAX_W) || (Target->h > RENDER_MAX_H))
RenderScale = ((Target->w > Target->h) ? (double)(Target->w) / (double)(RENDER_MAX_W) : (double)(Target->h) / (double)(RENDER_MAX_H));
// Find the pixel byte size (to avoid dividing over and over later (probably 4)
TargetPixelSize = Target->pitch / Target->w;
EvolvePixelSize = Evolve->pitch / Evolve->w;
// Create bit shifting elements for later based on the system endian-ness and whether the image is 24-bit or 32-bit
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
TargetBitMask_R = 0xff << (8 * (TargetPixelSize - 1));
TargetPixelShift_R = 8 * (TargetPixelSize - 1);
TargetBitMask_G = 0xff << (8 * (TargetPixelSize - 2));
TargetPixelShift_G = 8 * (TargetPixelSize - 2);
TargetBitMask_B = 0xff << (8 * (TargetPixelSize - 3));
TargetPixelShift_B = 8 * (TargetPixelSize - 3);
EvolveBitMask_R = 0xff << (8 * (EvolvePixelSize - 1));
EvolvePixelShift_R = 8 * (EvolvePixelSize - 1);
EvolveBitMask_G = 0xff << (8 * (EvolvePixelSize - 2));
EvolvePixelShift_G = 8 * (EvolvePixelSize - 2);
EvolveBitMask_B = 0xff << (8 * (EvolvePixelSize - 3));
EvolvePixelShift_B = 8 * (EvolvePixelSize - 3);
#else
TargetBitMask_R = 0xff << (8 * (TargetPixelSize - 3));
TargetPixelShift_R = 8 * (TargetPixelSize - 3);
TargetBitMask_G = 0xff << (8 * (TargetPixelSize - 2));
TargetPixelShift_G = 8 * (TargetPixelSize - 2);
TargetBitMask_B = 0xff << (8 * (TargetPixelSize - 1));
TargetPixelShift_B = 8 * (TargetPixelSize - 1);
EvolveBitMask_R = 0xff << (8 * (EvolvePixelSize - 3));
EvolvePixelShift_R = 8 * (EvolvePixelSize - 3);
EvolveBitMask_G = 0xff << (8 * (EvolvePixelSize - 2));
EvolvePixelShift_G = 8 * (EvolvePixelSize - 2);
EvolveBitMask_B = 0xff << (8 * (EvolvePixelSize - 1));
EvolvePixelShift_B = 8 * (EvolvePixelSize - 1);
#endif
// Load in the parts of the render rects that don't change
SourceRect.x = SourceRect.y = 0;
DestinationRect.w = SourceRect.w = Target->w;
DestinationRect.h = SourceRect.h = Target->h;
// Create the window
if(!Window.DefineWindow(SCREEN_W, SCREEN_H, 32, false, "Triangle Image Evolution")) return -1;
OpeningTick = SDL_GetTicks();
TotalTime = 0.0;
// Define all ListPolygon instances to a RANDOM state
for (unsigned int i = 0; i < POLYGON_COUNT; i++) RandPolygon(&PolygonList[i]);
// Calculate the starting fitness
TempFitness = 0.0;
Fitness = CalculateFitness();
// Set the mutation information to NULL
Attempts = 0;
Mutations = 0;
GoodMutations = 0;
RenderSwitch = true;
// Define the mutation type
MutationType = Mutate1;
while (true)
{
// Poll for input
if(SDL_PollEvent(&event) > 0)
{
if(event.type & (SDL_KEYUP | SDL_KEYDOWN))
{
nKeyArray = SDL_GetKeyState(&nKeys);
if (nKeyArray[SDLK_ESCAPE]) break;
if (nKeyArray[SDLK_RETURN]) RenderSwitch = !RenderSwitch;
if (nKeyArray[SDLK_1]) ExportBinary();
if (nKeyArray[SDLK_2]) ImportBinary();
if (nKeyArray[SDLK_3]) MutationType = Mutate1;
if (nKeyArray[SDLK_4]) MutationType = Mutate2;
}
}
// Go through a mutation sequence
MutationType(PolygonList);
if (RenderSwitch) RenderScreen(RenderScale);
}
SDL_FreeSurface(Target);
SDL_FreeSurface(Best);
SDL_FreeSurface(Evolve);
Window.Undefine();
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
return 0;
}
BOOL CSkinScrollWnd::Initialize ( CONST HWND hWnd, CONST SCROLLBAR_SKIN_INFO& ResSet )
{
if ( FALSE == ::IsWindow ( hWnd ) )
{
return FALSE;
}
if ( FALSE == SetSkinInfo ( ResSet ) )
{
return FALSE;
}
m_imgCorner.Load(ResSet.pImageCorner, ImageFormatPNG);
m_brBackground.Attach(ResSet.hBrBackground);
CWindow ParentWnd = ::GetParent ( hWnd );
CRect rcFrm, rcWnd;
::GetWindowRect ( hWnd, &rcFrm );
ParentWnd.ScreenToClient ( &rcFrm );
rcWnd = rcFrm;
rcWnd.OffsetRect ( -rcWnd.left, -rcWnd.top );
DWORD dwStyle = ::GetWindowLong ( hWnd, GWL_STYLE );
DWORD dwFrmStyle = WS_CHILD | SS_NOTIFY ;
DWORD dwFrmStyleEx = 0;
if ( dwStyle & WS_VISIBLE )
{
dwFrmStyle |= WS_VISIBLE;
}
if ( dwStyle & WS_BORDER )
{
dwStyle &= ~WS_BORDER;
::SetWindowLong ( hWnd, GWL_STYLE, dwStyle );
int nBorder = ::GetSystemMetrics ( SM_CXBORDER );
rcWnd.right -= nBorder * 2;
rcWnd.bottom -= nBorder * 2;
dwFrmStyle |= WS_BORDER;
}
DWORD dwExStyle = ::GetWindowLong ( hWnd, GWL_EXSTYLE );
if ( dwExStyle & WS_EX_CLIENTEDGE )
{
dwExStyle &= ~WS_EX_CLIENTEDGE;
::SetWindowLong ( hWnd, GWL_EXSTYLE, dwExStyle );
int nCXEDGE = ::GetSystemMetrics ( SM_CXEDGE );
rcWnd.right -= nCXEDGE * 2;
rcWnd.bottom -= nCXEDGE * 2;
dwFrmStyleEx |= WS_EX_CLIENTEDGE;
}
this->Create ( ParentWnd.m_hWnd, rcFrm, _T ( "" ), dwFrmStyle, dwFrmStyleEx );
m_MidWnd.Create ( m_hWnd, NULL, _T ( "" ), WS_CHILD | WS_VISIBLE /*| WS_CLIPCHILDREN | WS_CLIPSIBLINGS */ );
m_sbHorizontal.Create( m_hWnd, NULL, NULL, WS_CHILD | SBS_HORZ );
m_sbVertical.Create ( m_hWnd, NULL, NULL, WS_CHILD | SBS_VERT );
::SetParent ( hWnd, m_MidWnd.m_hWnd );
::SetWindowLong ( hWnd, GWL_USERDATA, ( LONG ) this );
m_fnOldWinProc = ( WNDPROC ) ::SetWindowLong ( hWnd, GWL_WNDPROC, ( LONG ) WindowProc );
m_hTargetWnd = hWnd;
::SetWindowPos ( hWnd, NULL, rcWnd.left, rcWnd.top, rcWnd.right, rcWnd.bottom,
SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE );
::SetTimer ( m_hWnd, TIMER_UPDATE, 100, NULL );
return TRUE;
}
//The following example attaches an HWND to the CWindow object and //calls CWindow::GetWindowThreadID() to retrieve the id of the thread //that created the window CWindow myWindow; myWindow.Attach(hWnd); DWORD dwID = myWindow.GetWindowThreadID();
LRESULT CWindow::WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
CWindow * window;
static int x = 0, y = 0;
static int x1 = 0, y1 = 0;
switch (uMsg)
{
case WM_CREATE:
// OnCreate(); 不在这时候调用OnCreate了。
break;
case WM_CLOSE:
OnClose();
if(m_IsModal)
{
m_Modaling = false;
}
break;
case WM_DESTROY:
OnDestroy();
break;
case WM_ERASEBKGND:
return OnEraseBackGround(wParam, lParam);
break;
case WM_PAINT:
BeginPaint(hWnd, &ps);
OnPaint(ps.hdc);
EndPaint(hWnd, &ps);
break;
case WM_TIMER:
OnTimer(wParam);
break;
case WM_SIZE:
OnSize(LOWORD(lParam), HIWORD(lParam));
break;
case WM_COMMAND:
window = FindWindowByHWND((HWND) lParam);
if (window != NULL)
window->OnCommand(wParam, lParam);
break;
case WM_LBUTTONDOWN:
x = GET_X_LPARAM(lParam);
y = GET_Y_LPARAM(lParam);
OnMouseDown(0, x, y, wParam);
break;
case WM_LBUTTONUP:
x1 = GET_X_LPARAM(lParam);
y1 = GET_Y_LPARAM(lParam);
if(abs(x - x1) <= 5 && abs(y - y1) <= 5)
{
OnClick(0, x, y, wParam);
}
OnMouseUp(0, x1, y1, wParam);
x = 0; y = 0; x1 = 0; y1 = 0;
break;
case WM_RBUTTONDOWN:
OnMouseDown(1, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), wParam);
break;
case WM_MBUTTONDOWN:
OnMouseDown(2, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), wParam);
break;
case WM_MOUSEMOVE:
OnMouseMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), wParam);
break;
case WM_LBUTTONDBLCLK:
OnDoubleClick(0, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), wParam);
break;
case WM_RBUTTONDBLCLK:
OnDoubleClick(1, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), wParam);
break;
case WM_MBUTTONDBLCLK:
OnDoubleClick(2, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), wParam);
break;
case WM_GETMINMAXINFO:
OnGetMinMaxInfo((MINMAXINFO *) lParam);
break;
case WM_KEYDOWN:
OnKeyDown(wParam, lParam);
break;
case WM_CHAR:
OnChar(wParam, lParam);
break;
default:
break;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
void CRegisterTabs::RegisterChanged(HWND hDlg, TAB_ID srcTabId, WPARAM wParam)
{
if (g_Reg == NULL || !isStepping())
{
return;
}
WORD ctrlId = LOWORD(wParam);
CWindow editCtrl = ::GetDlgItem(hDlg, ctrlId);
char text[20];
editCtrl.GetWindowText(text, 20);
if (srcTabId == TabGPR)
{
uint64_t value = CEditReg64::ParseValue(text);
if (ctrlId == IDC_HI_EDIT)
{
g_Reg->m_HI.UDW = value;
}
else if (ctrlId == IDC_LO_EDIT)
{
g_Reg->m_LO.UDW = value;
}
else
{
int nReg = GetCtrlRegNum(ctrlId, GPREditIds);
g_Reg->m_GPR[nReg].UDW = value;
}
return;
}
uint32_t value = strtoul(text, NULL, 16);
sprintf(text, "%08X", value);
editCtrl.SetWindowText(text); // reformat text
if (srcTabId == TabFPR)
{
if (ctrlId == IDC_FCSR_EDIT)
{
g_Reg->m_FPCR[31] = value;
return;
}
int nReg = GetCtrlRegNum(ctrlId, FPREditIds);
*(uint32_t*)g_Reg->m_FPR_S[nReg] = value;
return;
}
switch (ctrlId)
{
case IDC_COP0_0_EDIT: g_Reg->INDEX_REGISTER = value; break;
case IDC_COP0_1_EDIT: g_Reg->RANDOM_REGISTER = value; break;
case IDC_COP0_2_EDIT: g_Reg->ENTRYLO0_REGISTER = value; break;
case IDC_COP0_3_EDIT: g_Reg->ENTRYLO1_REGISTER = value; break;
case IDC_COP0_4_EDIT: g_Reg->CONTEXT_REGISTER = value; break;
case IDC_COP0_5_EDIT: g_Reg->PAGE_MASK_REGISTER = value; break;
case IDC_COP0_6_EDIT: g_Reg->WIRED_REGISTER = value; break;
case IDC_COP0_7_EDIT: g_Reg->BAD_VADDR_REGISTER = value; break;
case IDC_COP0_8_EDIT: g_Reg->COUNT_REGISTER = value; break;
case IDC_COP0_9_EDIT: g_Reg->ENTRYHI_REGISTER = value; break;
case IDC_COP0_10_EDIT: g_Reg->COMPARE_REGISTER = value; break;
case IDC_COP0_11_EDIT: g_Reg->STATUS_REGISTER = value; break;
case IDC_COP0_12_EDIT: g_Reg->CAUSE_REGISTER = value; break;
case IDC_COP0_13_EDIT: g_Reg->EPC_REGISTER = value; break;
case IDC_COP0_14_EDIT: g_Reg->CONFIG_REGISTER = value; break;
case IDC_COP0_15_EDIT: g_Reg->TAGLO_REGISTER = value; break;
case IDC_COP0_16_EDIT: g_Reg->TAGHI_REGISTER = value; break;
case IDC_COP0_17_EDIT: g_Reg->ERROREPC_REGISTER = value; break;
case IDC_COP0_18_EDIT: g_Reg->FAKE_CAUSE_REGISTER = value; break;
case IDC_RDRAM00_EDIT: g_Reg->RDRAM_CONFIG_REG = value; break; // or device_type
case IDC_RDRAM04_EDIT: g_Reg->RDRAM_DEVICE_ID_REG = value; break;
case IDC_RDRAM08_EDIT: g_Reg->RDRAM_DELAY_REG = value; break;
case IDC_RDRAM0C_EDIT: g_Reg->RDRAM_MODE_REG = value; break;
case IDC_RDRAM10_EDIT: g_Reg->RDRAM_REF_INTERVAL_REG = value; break;
case IDC_RDRAM14_EDIT: g_Reg->RDRAM_REF_ROW_REG = value; break;
case IDC_RDRAM18_EDIT: g_Reg->RDRAM_RAS_INTERVAL_REG = value; break;
case IDC_RDRAM1C_EDIT: g_Reg->RDRAM_MIN_INTERVAL_REG = value; break;
case IDC_RDRAM20_EDIT: g_Reg->RDRAM_ADDR_SELECT_REG = value; break;
case IDC_RDRAM24_EDIT: g_Reg->RDRAM_DEVICE_MANUF_REG = value; break;
case IDC_SP00_EDIT: g_Reg->SP_MEM_ADDR_REG = value; break;
case IDC_SP04_EDIT: g_Reg->SP_DRAM_ADDR_REG = value; break;
case IDC_SP08_EDIT: g_Reg->SP_RD_LEN_REG = value; break;
case IDC_SP0C_EDIT: g_Reg->SP_WR_LEN_REG = value; break;
case IDC_SP10_EDIT: g_Reg->SP_STATUS_REG = value; break;
case IDC_SP14_EDIT: g_Reg->SP_DMA_FULL_REG = value; break;
case IDC_SP18_EDIT: g_Reg->SP_DMA_BUSY_REG = value; break;
case IDC_SP1C_EDIT: g_Reg->SP_SEMAPHORE_REG = value; break;
case IDC_SP_PC_EDIT: g_Reg->SP_PC_REG = value; break;
case IDC_DPC00_EDIT: g_Reg->DPC_START_REG = value; break;
case IDC_DPC04_EDIT: g_Reg->DPC_END_REG = value; break;
case IDC_DPC08_EDIT: g_Reg->DPC_CURRENT_REG = value; break;
case IDC_DPC0C_EDIT: g_Reg->DPC_STATUS_REG = value; break;
case IDC_DPC10_EDIT: g_Reg->DPC_CLOCK_REG = value; break;
case IDC_DPC14_EDIT: g_Reg->DPC_BUFBUSY_REG = value; break;
case IDC_DPC18_EDIT: g_Reg->DPC_PIPEBUSY_REG = value; break;
case IDC_DPC1C_EDIT: g_Reg->DPC_TMEM_REG = value; break;
case IDC_MI00_EDIT: g_Reg->MI_INIT_MODE_REG = value; break; // or MI_MODE ?
case IDC_MI04_EDIT: g_Reg->MI_VERSION_REG = value; break; // or MI_NOOP ?
case IDC_MI08_EDIT: g_Reg->MI_INTR_REG = value; break; // or MI_INTR ?
case IDC_MI0C_EDIT: g_Reg->MI_INTR_MASK_REG = value; break; // or MI_INTR_MASK ?
case IDC_VI00_EDIT: g_Reg->VI_STATUS_REG = value; break;
case IDC_VI04_EDIT: g_Reg->VI_ORIGIN_REG = value; break;
case IDC_VI08_EDIT: g_Reg->VI_WIDTH_REG = value; break;
case IDC_VI0C_EDIT: g_Reg->VI_INTR_REG = value; break;
case IDC_VI10_EDIT: g_Reg->VI_CURRENT_REG = value; break;
case IDC_VI14_EDIT: g_Reg->VI_BURST_REG = value; break;
case IDC_VI18_EDIT: g_Reg->VI_V_SYNC_REG = value; break;
case IDC_VI1C_EDIT: g_Reg->VI_H_SYNC_REG = value; break;
case IDC_VI20_EDIT: g_Reg->VI_LEAP_REG = value; break;
case IDC_VI24_EDIT: g_Reg->VI_H_START_REG = value; break;
case IDC_VI28_EDIT: g_Reg->VI_V_START_REG = value; break;
case IDC_VI2C_EDIT: g_Reg->VI_V_BURST_REG = value; break;
case IDC_VI30_EDIT: g_Reg->VI_X_SCALE_REG = value; break;
case IDC_VI34_EDIT: g_Reg->VI_Y_SCALE_REG = value; break;
case IDC_AI00_EDIT: g_Reg->AI_DRAM_ADDR_REG = value; break;
case IDC_AI04_EDIT: g_Reg->AI_LEN_REG = value; break;
case IDC_AI08_EDIT: g_Reg->AI_CONTROL_REG = value; break;
case IDC_AI0C_EDIT: g_Reg->AI_STATUS_REG = value; break;
case IDC_AI10_EDIT: g_Reg->AI_DACRATE_REG = value; break;
case IDC_AI14_EDIT: g_Reg->AI_BITRATE_REG = value; break;
case IDC_PI00_EDIT: g_Reg->PI_DRAM_ADDR_REG = value; break;
case IDC_PI04_EDIT: g_Reg->PI_CART_ADDR_REG = value; break;
case IDC_PI08_EDIT: g_Reg->PI_RD_LEN_REG = value; break;
case IDC_PI0C_EDIT: g_Reg->PI_WR_LEN_REG = value; break;
case IDC_PI10_EDIT: g_Reg->PI_STATUS_REG = value; break;
case IDC_PI14_EDIT: g_Reg->PI_BSD_DOM1_LAT_REG = value; break;
case IDC_PI18_EDIT: g_Reg->PI_BSD_DOM1_PWD_REG = value; break;
case IDC_PI1C_EDIT: g_Reg->PI_BSD_DOM1_PGS_REG = value; break;
case IDC_PI20_EDIT: g_Reg->PI_BSD_DOM1_RLS_REG = value; break;
case IDC_PI24_EDIT: g_Reg->PI_BSD_DOM2_LAT_REG = value; break;
case IDC_PI28_EDIT: g_Reg->PI_BSD_DOM2_PWD_REG = value; break;
case IDC_PI2C_EDIT: g_Reg->PI_BSD_DOM2_PGS_REG = value; break;
case IDC_PI30_EDIT: g_Reg->PI_BSD_DOM2_RLS_REG = value; break;
case IDC_RI00_EDIT: g_Reg->RI_MODE_REG = value; break;
case IDC_RI04_EDIT: g_Reg->RI_CONFIG_REG = value; break;
case IDC_RI08_EDIT: g_Reg->RI_CURRENT_LOAD_REG = value; break;
case IDC_RI0C_EDIT: g_Reg->RI_SELECT_REG = value; break;
case IDC_RI10_EDIT: g_Reg->RI_REFRESH_REG = value; break;
case IDC_RI14_EDIT: g_Reg->RI_LATENCY_REG = value; break;
case IDC_RI18_EDIT: g_Reg->RI_RERROR_REG = value; break;
case IDC_RI1C_EDIT: g_Reg->RI_WERROR_REG = value; break;
case IDC_SI00_EDIT: g_Reg->SI_DRAM_ADDR_REG = value; break;
case IDC_SI04_EDIT: g_Reg->SI_PIF_ADDR_RD64B_REG = value; break;
case IDC_SI08_EDIT: g_Reg->SI_PIF_ADDR_WR64B_REG = value; break;
case IDC_SI0C_EDIT: g_Reg->SI_STATUS_REG = value; break;
case IDC_DD00_EDIT: g_Reg->ASIC_DATA = value; break;
case IDC_DD04_EDIT: g_Reg->ASIC_MISC_REG = value; break;
case IDC_DD08_EDIT: g_Reg->ASIC_STATUS = value; break;
case IDC_DD0C_EDIT: g_Reg->ASIC_CUR_TK = value; break;
case IDC_DD10_EDIT: g_Reg->ASIC_BM_STATUS = value; break;
case IDC_DD14_EDIT: g_Reg->ASIC_ERR_SECTOR = value; break;
case IDC_DD18_EDIT: g_Reg->ASIC_SEQ_STATUS = value; break;
case IDC_DD1C_EDIT: g_Reg->ASIC_CUR_SECTOR = value; break;
case IDC_DD20_EDIT: g_Reg->ASIC_HARD_RESET = value; break;
case IDC_DD24_EDIT: g_Reg->ASIC_C1_S0 = value; break;
case IDC_DD28_EDIT: g_Reg->ASIC_HOST_SECBYTE = value; break;
case IDC_DD2C_EDIT: g_Reg->ASIC_C1_S2 = value; break;
case IDC_DD30_EDIT: g_Reg->ASIC_SEC_BYTE = value; break;
case IDC_DD34_EDIT: g_Reg->ASIC_C1_S4 = value; break;
case IDC_DD38_EDIT: g_Reg->ASIC_C1_S6 = value; break;
case IDC_DD3C_EDIT: g_Reg->ASIC_CUR_ADDR = value; break;
case IDC_DD40_EDIT: g_Reg->ASIC_ID_REG = value; break;
case IDC_DD44_EDIT: g_Reg->ASIC_TEST_REG = value; break;
case IDC_DD48_EDIT: g_Reg->ASIC_TEST_PIN_SEL = value; break;
}
}
bool CStudio::EventProcess(const Event &event)
{
CWindow* pw;
CEdit* edit;
CSlider* slider;
if ( m_dialog != SD_NULL ) // dialogue exists?
{
return EventDialog(event);
}
if ( event.type == EVENT_FRAME )
{
EventFrame(event);
}
pw = static_cast< CWindow* >(m_interface->SearchControl(EVENT_WINDOW3));
if ( pw == nullptr ) return false;
edit = static_cast<CEdit*>(pw->SearchControl(EVENT_STUDIO_EDIT));
if ( edit == nullptr ) return false;
if ( event.type == pw->GetEventTypeClose() )
{
m_event->AddEvent(Event(EVENT_STUDIO_OK));
}
if ( event.type == EVENT_STUDIO_EDIT ) // text modifief?
{
ColorizeScript(edit);
}
if ( event.type == EVENT_STUDIO_LIST ) // list clicked?
{
m_main->StartDisplayInfo(m_helpFilename, -1);
}
if ( event.type == EVENT_STUDIO_NEW ) // new?
{
m_script->New(edit, "");
}
if ( event.type == EVENT_STUDIO_OPEN ) // open?
{
StartDialog(SD_OPEN);
}
if ( event.type == EVENT_STUDIO_SAVE ) // save?
{
StartDialog(SD_SAVE);
}
if ( event.type == EVENT_STUDIO_UNDO ) // undo?
{
edit->Undo();
}
if ( event.type == EVENT_STUDIO_CUT ) // cut?
{
edit->Cut();
}
if ( event.type == EVENT_STUDIO_COPY ) // copy?
{
edit->Copy();
}
if ( event.type == EVENT_STUDIO_PASTE ) // paste?
{
edit->Paste();
}
if ( event.type == EVENT_STUDIO_SIZE ) // size?
{
slider = static_cast< CSlider* >(pw->SearchControl(EVENT_STUDIO_SIZE));
if ( slider == nullptr ) return false;
m_settings->SetFontSize(9.0f+slider->GetVisibleValue()*15.0f);
ViewEditScript();
}
if ( event.type == EVENT_STUDIO_TOOL && // instructions?
m_dialog == SD_NULL )
{
m_main->StartDisplayInfo(SATCOM_HUSTON, false);
}
if ( event.type == EVENT_STUDIO_HELP && // help?
m_dialog == SD_NULL )
{
m_main->StartDisplayInfo(SATCOM_PROG, false);
}
if ( event.type == EVENT_STUDIO_COMPILE ) // compile?
{
if ( m_script->GetScript(edit) ) // compile
{
std::string res;
GetResource(RES_TEXT, RT_STUDIO_COMPOK, res);
SetInfoText(res, false);
}
else
{
std::string error;
m_script->GetError(error);
SetInfoText(error, false);
}
}
if ( event.type == EVENT_STUDIO_RUN ) // run/stop?
{
if ( m_script->IsRunning() )
{
m_event->AddEvent(Event(EVENT_OBJECT_PROGSTOP));
}
else
{
if ( m_script->GetScript(edit) ) // compile
{
SetInfoText("", false);
m_event->AddEvent(Event(EVENT_OBJECT_PROGSTART));
}
else
{
std::string error;
m_script->GetError(error);
SetInfoText(error, false);
}
}
}
if ( event.type == EVENT_STUDIO_REALTIME ) // real time?
{
m_bRealTime = !m_bRealTime;
m_script->SetStepMode(!m_bRealTime);
UpdateFlux();
UpdateButtons();
}
if ( event.type == EVENT_STUDIO_STEP ) // step?
{
m_script->Step();
}
if ( event.type == EVENT_WINDOW3 ) // window is moved?
{
m_editActualPos = m_editFinalPos = pw->GetPos();
m_editActualDim = m_editFinalDim = pw->GetDim();
m_settings->SetWindowPos(m_editActualPos);
m_settings->SetWindowDim(m_editActualDim);
AdjustEditScript();
}
if ( event.type == pw->GetEventTypeReduce() )
{
if ( m_bEditMinimized )
{
m_editFinalPos = m_settings->GetWindowPos();
m_editFinalDim = m_settings->GetWindowDim();
m_bEditMinimized = false;
m_bEditMaximized = false;
}
else
{
m_editFinalPos.x = 0.00f;
m_editFinalPos.y = -0.44f;
m_editFinalDim.x = 1.00f;
m_editFinalDim.y = 0.50f;
m_bEditMinimized = true;
m_bEditMaximized = false;
}
m_main->SetEditFull(m_bEditMaximized);
pw = static_cast< CWindow* >(m_interface->SearchControl(EVENT_WINDOW3));
if ( pw != nullptr )
{
pw->SetMaximized(m_bEditMaximized);
pw->SetMinimized(m_bEditMinimized);
}
}
if ( event.type == pw->GetEventTypeFull() )
{
if ( m_bEditMaximized )
{
m_editFinalPos = m_settings->GetWindowPos();
m_editFinalDim = m_settings->GetWindowDim();
m_bEditMinimized = false;
m_bEditMaximized = false;
}
else
{
m_editFinalPos.x = 0.00f;
m_editFinalPos.y = 0.00f;
m_editFinalDim.x = 1.00f;
m_editFinalDim.y = 1.00f;
m_bEditMinimized = false;
m_bEditMaximized = true;
}
m_main->SetEditFull(m_bEditMaximized);
pw = static_cast< CWindow* >(m_interface->SearchControl(EVENT_WINDOW3));
if ( pw != nullptr )
{
pw->SetMaximized(m_bEditMaximized);
pw->SetMinimized(m_bEditMinimized);
}
}
return true;
}
void CRegisterTabs::InitRegisterEdit64(CWindow& tab, CEditReg64& edit, WORD ctrlId)
{
edit.Attach(tab.GetDlgItem(ctrlId));
}
int main()
{
////////////////////
// ionEngine Init //
////////////////////
Log::AddDefaultOutputs();
SingletonPointer<CGraphicsAPI> GraphicsAPI;
SingletonPointer<CWindowManager> WindowManager;
SingletonPointer<CTimeManager> TimeManager;
SingletonPointer<CSceneManager> SceneManager;
SingletonPointer<CAssetManager> AssetManager;
GraphicsAPI->Init(new Graphics::COpenGLImplementation());
WindowManager->Init(GraphicsAPI);
TimeManager->Init(WindowManager);
SceneManager->Init(GraphicsAPI);
AssetManager->Init(GraphicsAPI);
CWindow * Window = WindowManager->CreateWindow(vec2i(1600, 900), "DemoApplication", EWindowType::Windowed);
AssetManager->SetAssetPath("Assets/");
AssetManager->SetShaderPath("Shaders/");
AssetManager->SetTexturePath("Images/");
SharedPointer<IGraphicsContext> Context = GraphicsAPI->GetWindowContext(Window);
SharedPointer<IRenderTarget> RenderTarget = Context->GetBackBuffer();
RenderTarget->SetClearColor(color3f(0.3f));
/////////////////
// Load Assets //
/////////////////
CSimpleMesh * SphereMesh = CGeometryCreator::CreateSphere();
CSimpleMesh * SkySphereMesh = CGeometryCreator::CreateSkySphere();
CSimpleMesh * PlaneMesh = CGeometryCreator::CreatePlane(vec2f(100.f));
SharedPointer<IShaderProgram> DiffuseShader = AssetManager->LoadShader("Diffuse");
SharedPointer<IShaderProgram> SimpleShader = AssetManager->LoadShader("Simple");
SharedPointer<IShaderProgram> SpecularShader = AssetManager->LoadShader("Specular");
SharedPointer<IShaderProgram> SkySphereShader = AssetManager->LoadShader("SkySphere");
SharedPointer<ITexture2D> SkyMap = AssetManager->LoadTexture("SkyMap.jpg");
SkyMap->SetMagFilter(ITexture::EFilter::Nearest);
////////////////////
// ionScene Setup //
////////////////////
CRenderPass * RenderPass = new CRenderPass(Context);
RenderPass->SetRenderTarget(RenderTarget);
SceneManager->AddRenderPass(RenderPass);
CPerspectiveCamera * Camera = new CPerspectiveCamera(Window->GetAspectRatio());
Camera->SetPosition(vec3f(0, 3, -5));
Camera->SetFocalLength(0.4f);
RenderPass->SetActiveCamera(Camera);
CCameraController * Controller = new CCameraController(Camera);
Controller->SetTheta(15.f * Constants32::Pi / 48.f);
Controller->SetPhi(-Constants32::Pi / 16.f);
Window->AddListener(Controller);
TimeManager->MakeUpdateTick(0.02)->AddListener(Controller);
/////////////////
// Add Objects //
/////////////////
CSimpleMeshSceneObject * LightSphere1 = new CSimpleMeshSceneObject();
LightSphere1->SetMesh(SphereMesh);
LightSphere1->SetShader(SimpleShader);
LightSphere1->SetPosition(vec3f(0, 1, 0));
RenderPass->AddSceneObject(LightSphere1);
CSimpleMeshSceneObject * LightSphere2 = new CSimpleMeshSceneObject();
LightSphere2->SetMesh(SphereMesh);
LightSphere2->SetShader(SimpleShader);
LightSphere2->SetPosition(vec3f(4, 2, 0));
RenderPass->AddSceneObject(LightSphere2);
CSimpleMeshSceneObject * LightSphere3 = new CSimpleMeshSceneObject();
LightSphere3->SetMesh(SphereMesh);
LightSphere3->SetShader(SimpleShader);
LightSphere3->SetPosition(vec3f(12, 3, 0));
RenderPass->AddSceneObject(LightSphere3);
CSimpleMeshSceneObject * SpecularSphere = new CSimpleMeshSceneObject();
SpecularSphere->SetMesh(SphereMesh);
SpecularSphere->SetShader(SpecularShader);
SpecularSphere->SetPosition(vec3f(3, 3, 6));
SpecularSphere->GetMaterial().Ambient = vec3f(0.05f);
RenderPass->AddSceneObject(SpecularSphere);
CSimpleMeshSceneObject * PlaneObject = new CSimpleMeshSceneObject();
PlaneObject->SetMesh(PlaneMesh);
PlaneObject->SetShader(DiffuseShader);
PlaneObject->GetMaterial().Ambient = vec3f(0.05f);
RenderPass->AddSceneObject(PlaneObject);
CSimpleMeshSceneObject * SkySphereObject = new CSimpleMeshSceneObject();
SkySphereObject->SetMesh(SkySphereMesh);
SkySphereObject->SetShader(SkySphereShader);
SkySphereObject->SetTexture("uTexture", SkyMap);
RenderPass->AddSceneObject(SkySphereObject);
CPointLight * Light1 = new CPointLight();
Light1->SetPosition(vec3f(0, 1, 0));
Light1->SetColor(Colors::Red);
RenderPass->AddLight(Light1);
CPointLight * Light2 = new CPointLight();
Light2->SetPosition(vec3f(4, 2, 0));
Light2->SetColor(Colors::Green);
RenderPass->AddLight(Light2);
CPointLight * Light3 = new CPointLight();
Light3->SetPosition(vec3f(12, 3, 0));
Light3->SetColor(Colors::Blue);
RenderPass->AddLight(Light3);
///////////////
// Main Loop //
///////////////
TimeManager->Init(WindowManager);
while (WindowManager->Run())
{
TimeManager->Update();
float const MinimumBrightness = 0.2f;
float const MaximumBrightness = 1.f - MinimumBrightness;
float const Brightness = (Sin<float>((float) TimeManager->GetRunTime()) / 2.f + 0.5f) * MaximumBrightness + MinimumBrightness;
float const Radius = Brightness * 10.f;
Light1->SetRadius(Radius);
Light2->SetRadius(Radius);
Light3->SetRadius(Radius);
float const Bright = 1;
float const Dim = 0.5f;
LightSphere1->GetMaterial().Diffuse = color3f(Bright, Dim, Dim) * Brightness;
LightSphere2->GetMaterial().Diffuse = color3f(Dim, Bright, Dim) * Brightness;
LightSphere3->GetMaterial().Diffuse = color3f(Dim, Dim, Bright) * Brightness;
LightSphere1->SetScale(Brightness);
LightSphere2->SetScale(Brightness);
LightSphere3->SetScale(Brightness);
SkySphereObject->SetPosition(Camera->GetPosition());
RenderTarget->ClearColorAndDepth();
SceneManager->DrawAll();
Window->SwapBuffers();
}
return 0;
}
/**
* Handles the Notify Messages
*/
LRESULT CWindow::handleNotifyMessages(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
UINT code = ((LPNMHDR) lparam)->code;
switch(code)
{
case TCN_SELCHANGE:
{
HWND hwndFrom = ((LPNMHDR)lparam)->hwndFrom;
CTabControl* tabCtrl = getControlForHandle<CTabControl>(hwndFrom);
if(tabCtrl)
{
return tabCtrl->selChanged();
}
break;
}
case TCN_SELCHANGING:
{
HWND hwndFrom = ((LPNMHDR)lparam)->hwndFrom;
CTabControl* tabCtrl = getControlForHandle<CTabControl>(hwndFrom);
if(tabCtrl)
{
return tabCtrl->selChanging();
}
break;
}
case TVN_ENDLABELEDIT:
{
HWND hwndFrom = ((LPNMHDR)lparam)->hwndFrom;
CTreeControl* tree = getControlForHandle<CTreeControl>(hwndFrom);
if(tree)
{
return tree->endLabelEdit((LPNMTREEVIEW)lparam);
}
break;
}
case TVN_BEGINLABELEDIT:
{
HWND hwndFrom = ((LPNMHDR)lparam)->hwndFrom;
CTreeControl* tree = getControlForHandle<CTreeControl>(hwndFrom);
if(tree)
{
return tree->startLabelEdit((LPNMTREEVIEW)lparam);
}
break;
}
case TTN_GETDISPINFO:
{
LPTOOLTIPTEXT lpttt;
lpttt = (LPTOOLTIPTEXT) lparam;
HWND hwndFrom = lpttt->hdr.hwndFrom; // the tooltips handle
HWND ttparent = GetParent(hwndFrom); // the "main" window
CWindow* ctrl = getControlForHandle<CWindow>(ttparent);
CToolBar* tb = ctrl->getToolbar();
if(tb)
{
int idButton = lpttt->hdr.idFrom;
lpttt->lpszText = (LPWSTR)tb->getTooltip(idButton);
lpttt->uFlags |= TTF_DI_SETITEM;
return 0;
}
}
}
return NOT_HANDLED_MESSAGE;
}
void CScreenLevelList::UpdateSceneList(int chap, int &sel)
{
CWindow* pw;
CList* pl;
std::string fileName;
char line[500] = {0};
int j;
bool bPassed;
pw = static_cast<CWindow*>(m_interface->SearchControl(EVENT_WINDOW5));
if ( pw == nullptr ) return;
pl = static_cast<CList*>(pw->SearchControl(EVENT_INTERFACE_LIST));
if ( pl == nullptr ) return;
pl->Flush();
bool readAll = true;
for ( j=0 ; j<MAXSCENE ; j++ )
{
CLevelParser levelParser(m_category, chap+1, j+1);
if (!levelParser.Exists())
{
readAll = true;
break;
}
else
{
if (!readAll)
break;
}
try
{
levelParser.Load();
sprintf(line, "%d: %s", j+1, levelParser.Get("Title")->GetParam("text")->AsString().c_str());
}
catch (CLevelParserException& e)
{
sprintf(line, "%s", (std::string("[ERROR]: ")+e.what()).c_str());
}
bPassed = m_main->GetPlayerProfile()->GetLevelPassed(m_category, chap+1, j+1);
pl->SetItemName(j, line);
pl->SetCheck(j, bPassed);
pl->SetEnable(j, true);
if ( m_category == LevelCategory::Missions && !m_main->GetShowAll() && !bPassed )
{
readAll = false;
}
}
if (readAll)
{
m_maxList = j;
}
else
{
m_maxList = j+1; // this is not the last!
}
if ( sel > j-1 ) sel = j-1;
pl->SetSelect(sel);
pl->ShowSelect(false); // shows the selected columns
}
