void CreateNodesDialog::CreateNode(ResourceEditor::eNodeType nodeType)
{
SafeRelease(sceneNode);
SceneData *activeScene = SceneDataManager::Instance()->SceneGetActive();
EditorScene * editorScene = activeScene->GetScene();
scene = editorScene;
switch (nodeType)
{
case ResourceEditor::NODE_LANDSCAPE:
SetHeader(LocalizedString(ResourceEditor::CREATE_NODE_LANDSCAPE));
sceneNode = new Entity();
sceneNode->AddComponent(ScopedPtr<RenderComponent> (new RenderComponent(ScopedPtr<Landscape>(new Landscape()))));
sceneNode->SetName(ResourceEditor::LANDSCAPE_NODE_NAME);
break;
case ResourceEditor::NODE_LIGHT:
{
SetHeader(LocalizedString(ResourceEditor::CREATE_NODE_LIGHT));
//sceneNode = //EditorLightNode::CreateSceneAndEditorLight();
sceneNode = new Entity();
sceneNode->AddComponent(ScopedPtr<LightComponent> (new LightComponent(ScopedPtr<Light>(new Light))));
sceneNode->SetName(ResourceEditor::LIGHT_NODE_NAME);
break;
}
case ResourceEditor::NODE_SERVICE_NODE:
{
SetHeader(LocalizedString(ResourceEditor::CREATE_NODE_SERVICE));
sceneNode = new Entity();
KeyedArchive *customProperties = sceneNode->GetCustomProperties();
customProperties->SetBool(ResourceEditor::EDITOR_IS_LOCKED, true);
sceneNode->SetName(ResourceEditor::SERVICE_NODE_NAME);
break;
}
case ResourceEditor::NODE_CAMERA:
{
SetHeader(LocalizedString(ResourceEditor::CREATE_NODE_CAMERA));
sceneNode = new Entity();
Camera * camera = new Camera();
camera->SetUp(Vector3(0.0f, 0.0f, 1.0f));
sceneNode->AddComponent(ScopedPtr<CameraComponent> (new CameraComponent(camera)));
sceneNode->SetName(ResourceEditor::CAMERA_NODE_NAME);
SafeRelease(camera);
}break;
case ResourceEditor::NODE_IMPOSTER:
SetHeader(LocalizedString(ResourceEditor::CREATE_NODE_IMPOSTER));
sceneNode = new ImposterNode();
sceneNode->SetName(ResourceEditor::IMPOSTER_NODE_NAME);
break;
case ResourceEditor::NODE_PARTICLE_EMITTER:
{
SetHeader(LocalizedString(ResourceEditor::CREATE_NODE_PARTICLE_EMITTER));
sceneNode = new Entity();
sceneNode->SetName(ResourceEditor::PARTICLE_EMITTER_NODE_NAME);
ParticleEmitter3D* newEmitter = new ParticleEmitter3D();
RenderComponent * renderComponent = new RenderComponent();
renderComponent->SetRenderObject(newEmitter);
sceneNode->AddComponent(renderComponent);
newEmitter->Release();
renderComponent->Release();
break;
}
case ResourceEditor::NODE_USER_NODE:
{
SetHeader(LocalizedString(ResourceEditor::CREATE_NODE_USER));
sceneNode = new Entity();
sceneNode->SetName(ResourceEditor::USER_NODE_NAME);
sceneNode->AddComponent(ScopedPtr<UserComponent> (new UserComponent()));
break;
}
case ResourceEditor::NODE_SWITCH_NODE:
{
SetHeader(LocalizedString(ResourceEditor::CREATE_NODE_SWITCH));
sceneNode = new Entity();
sceneNode->SetName(ResourceEditor::SWITCH_NODE_NAME);
sceneNode->AddComponent(ScopedPtr<SwitchComponent> (new SwitchComponent()));
KeyedArchive *customProperties = sceneNode->GetCustomProperties();
customProperties->SetBool(Entity::SCENE_NODE_IS_SOLID_PROPERTY_NAME, false);
}
break;
case ResourceEditor::NODE_PARTICLE_EFFECT:
{
SetHeader(ResourceEditor::CREATE_NODE_PARTICLE_EFFECT);
sceneNode = new Entity();
sceneNode->AddComponent(ScopedPtr<ParticleEffectComponent> (new ParticleEffectComponent()));
sceneNode->SetName(ResourceEditor::PARTICLE_EFFECT_NODE_NAME);
break;
}
case ResourceEditor::NODE_SKYBOX:
{
SetHeader(L"SkyBox");
//TODO: add skybox creation code here
break;
}
default:
break;
}
propertyList = PropertyControlCreator::Instance()->CreateControlForNode(sceneNode, propertyRect, true);
SafeRetain(propertyList);
AddControl(propertyList);
SetScene(editorScene);
propertyList->ReadFrom(sceneNode);
}
void UIButton::LoadFromYamlNode(YamlNode * node, UIYamlLoader * loader)
{
UIControl::LoadFromYamlNode(node, loader);
//int32 stateArray[] = {STATE_NORMAL, STATE_PRESSED_INSIDE, STATE_PRESSED_OUTSIDE, STATE_DISABLED, STATE_SELECTED, STATE_HOVER};
//String statePostfix[] = {"Normal", "PressedInside", "PressedOutside", "Disabled", "Selected", "Hover"};
for (int k = 0; k < STATE_COUNT; ++k)
{
YamlNode * stateSpriteNode = node->Get(Format("stateSprite%s", statePostfix[k].c_str()));
if (stateSpriteNode)
{
YamlNode * spriteNode = stateSpriteNode->Get(0);
YamlNode * frameNode = stateSpriteNode->Get(1);
int32 frame = 0;
if (frameNode)frame = frameNode->AsInt();
if (spriteNode)
{
SetStateSprite(stateArray[k], spriteNode->AsString(), frame);
}
}
YamlNode * stateDrawTypeNode = node->Get(Format("stateDrawType%s", statePostfix[k].c_str()));
if (stateDrawTypeNode)
{
UIControlBackground::eDrawType type = (UIControlBackground::eDrawType)loader->GetDrawTypeFromNode(stateDrawTypeNode);
SetStateDrawType(stateArray[k],type);
YamlNode * leftRightStretchCapNode = node->Get(Format("leftRightStretchCap%s", statePostfix[k].c_str()));
YamlNode * topBottomStretchCapNode = node->Get(Format("topBottomStretchCap%s", statePostfix[k].c_str()));
if(leftRightStretchCapNode)
{
float32 leftStretchCap = leftRightStretchCapNode->AsFloat();
GetActualBackground(stateArray[k])->SetLeftRightStretchCap(leftStretchCap);
}
if(topBottomStretchCapNode)
{
float32 topStretchCap = topBottomStretchCapNode->AsFloat();
GetActualBackground(stateArray[k])->SetTopBottomStretchCap(topStretchCap);
}
}
YamlNode * stateAlignNode = node->Get(Format("stateAlign%s", statePostfix[k].c_str()));
if (stateAlignNode)
{
int32 align = loader->GetAlignFromYamlNode(stateAlignNode);
SetStateAlign(stateArray[k],align);
}
YamlNode * stateFontNode = node->Get(Format("stateFont%s", statePostfix[k].c_str()));
if (stateFontNode)
{
Font * font = loader->GetFontByName(stateFontNode->AsString());
if (font)SetStateFont(stateArray[k], font);
}
YamlNode * stateTextNode = node->Get(Format("stateText%s", statePostfix[k].c_str()));
if (stateTextNode)
{
SetStateText(stateArray[k], LocalizedString(stateTextNode->AsWString()));
}
YamlNode * stateTextColorNode = node->Get(Format("stateTextcolor%s", statePostfix[k].c_str()));
if (stateTextColorNode)
{
Vector4 c = stateTextColorNode->AsVector4();
SetStateFontColor(stateArray[k], Color(c.x, c.y, c.z, c.w));
}
YamlNode * stateShadowColorNode = node->Get(Format("stateShadowcolor%s", statePostfix[k].c_str()));
if (stateShadowColorNode)
{
Vector4 c = stateShadowColorNode->AsVector4();
SetStateShadowColor(stateArray[k], Color(c.x, c.y, c.z, c.w));
}
YamlNode * stateShadowOffsetNode = node->Get(Format("stateShadowoffset%s", statePostfix[k].c_str()));
if (stateShadowOffsetNode)
{
SetStateShadowOffset(stateArray[k], stateShadowOffsetNode->AsVector2());
}
}
for (int k = 0; k < STATE_COUNT; ++k)
{
YamlNode * colorInheritNode = node->Get("colorInherit");
UIControlBackground::eColorInheritType type = (UIControlBackground::eColorInheritType)loader->GetColorInheritTypeFromNode(colorInheritNode);
if(colorInheritNode)
{
for(int32 i = 0; i < DRAW_STATE_COUNT; ++i)
{
if(stateBacks[i])
{
stateBacks[i]->SetColorInheritType(type);
}
}
}
}
}
void SceneEditorScreenMain::InitializeBodyList()
{
AddBodyItem(LocalizedString(L"panel.level"), false);
}
WideString SceneEditorScreenMain::MenuItemText(int32 menuID, int32 itemID)
{
WideString text = L"";
switch (menuID)
{
case MENUID_OPEN:
{
if(EOMID_OPEN == itemID)
{
text = LocalizedString(L"menu.open.open");
}
else
{
int32 lastIndex = itemID - EOMID_OPENLAST_STARTINDEX;
String path = EditorSettings::Instance()->GetLastOpenedFile(lastIndex);
text = StringToWString(path);
}
break;
}
case MENUID_CREATENODE:
{
switch (itemID)
{
case ResourceEditor::NODE_LANDSCAPE:
{
text = LocalizedString(L"menu.createnode.landscape");
break;
}
case ResourceEditor::NODE_LIGHT:
{
text = LocalizedString(L"menu.createnode.light");
break;
}
case ResourceEditor::NODE_SERVICE_NODE:
{
text = LocalizedString(L"menu.createnode.servicenode");
break;
}
case ResourceEditor::NODE_BOX:
{
text = LocalizedString(L"menu.createnode.box");
break;
}
case ResourceEditor::NODE_SPHERE:
{
text = LocalizedString(L"menu.createnode.sphere");
break;
}
case ResourceEditor::NODE_CAMERA:
{
text = LocalizedString(L"menu.createnode.camera");
break;
}
case ResourceEditor::NODE_IMPOSTER:
{
text = LocalizedString(L"menu.createnode.imposter");
break;
}
case ResourceEditor::NODE_PARTICLE_EMITTER:
{
text = LocalizedString(L"menu.createnode.particleemitter");
break;
}
case ResourceEditor::NODE_USER_NODE:
{
text = LocalizedString(L"menu.createnode.usernode");
break;
}
default:
break;
}
break;
}
case MENUID_VIEWPORT:
{
switch (itemID)
{
case ResourceEditor::VIEWPORT_IPHONE:
text = LocalizedString("menu.viewport.iphone");
break;
case ResourceEditor::VIEWPORT_RETINA:
text = LocalizedString("menu.viewport.retina");
break;
case ResourceEditor::VIEWPORT_IPAD:
text = LocalizedString("menu.viewport.ipad");
break;
case ResourceEditor::VIEWPORT_DEFAULT:
text = LocalizedString("menu.viewport.default");
break;
default:
break;
}
break;
}
case MENUID_EXPORTTOGAME:
{
switch (itemID)
{
case ResourceEditor::FORMAT_PNG:
text = LocalizedString(L"menu.export.png");
break;
case ResourceEditor::FORMAT_PVR:
text = LocalizedString(L"menu.export.pvr");
break;
case ResourceEditor::FORMAT_DXT:
text = LocalizedString(L"menu.export.dxt");
break;
default:
break;
}
break;
}
default:
break;
}
return text;
}
void SceneEditorScreenMain::LoadResources()
{
new ErrorNotifier();
new HintManager();
new UNDOManager();
new PropertyControlCreator();
ControlsFactory::CustomizeScreenBack(this);
font = ControlsFactory::GetFontLight();
//init file system dialog
fileSystemDialog = new UIFileSystemDialog("~res:/Fonts/MyriadPro-Regular.otf");
fileSystemDialog->SetDelegate(this);
String path = EditorSettings::Instance()->GetDataSourcePath();
if(path.length())
fileSystemDialog->SetCurrentDir(path);
// add line after menu
Rect fullRect = GetRect();
AddLineControl(Rect(0, ControlsFactory::BUTTON_HEIGHT, fullRect.dx, LINE_HEIGHT));
CreateTopMenu();
//
settingsDialog = new SettingsDialog(fullRect, this);
UIButton *settingsButton = ControlsFactory::CreateImageButton(Rect(fullRect.dx - ControlsFactory::BUTTON_HEIGHT, 0, ControlsFactory::BUTTON_HEIGHT, ControlsFactory::BUTTON_HEIGHT), "~res:/Gfx/UI/settingsicon");
settingsButton->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnSettingsPressed));
AddControl(settingsButton);
SafeRelease(settingsButton);
menuPopup = new MenuPopupControl(GetRect(), ControlsFactory::BUTTON_HEIGHT + LINE_HEIGHT);
menuPopup->SetDelegate(this);
InitializeNodeDialogs();
textureTrianglesDialog = new TextureTrianglesDialog();
textureConverterDialog = new TextureConverterDialog(fullRect);
materialEditor = new MaterialEditor();
particlesEditor = new ParticlesEditorControl();
//add line before body
AddLineControl(Rect(0, BODY_Y_OFFSET, fullRect.dx, LINE_HEIGHT));
//Library
libraryButton = ControlsFactory::CreateButton(
Rect(fullRect.dx - ControlsFactory::BUTTON_WIDTH,
BODY_Y_OFFSET - ControlsFactory::BUTTON_HEIGHT,
ControlsFactory::BUTTON_WIDTH,
ControlsFactory::BUTTON_HEIGHT),
LocalizedString(L"panel.library"));
libraryButton->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnLibraryPressed));
AddControl(libraryButton);
int32 libraryWidth = EditorSettings::Instance()->GetRightPanelWidth();
libraryControl = new LibraryControl(
Rect(fullRect.dx - libraryWidth, BODY_Y_OFFSET + 1, libraryWidth, fullRect.dy - BODY_Y_OFFSET - 1));
libraryControl->SetDelegate(this);
libraryControl->SetPath(path);
//properties
propertiesButton = ControlsFactory::CreateButton(
Vector2(libraryButton->GetRect().x - ControlsFactory::BUTTON_WIDTH,
BODY_Y_OFFSET - ControlsFactory::BUTTON_HEIGHT),
LocalizedString(L"panel.properties"));
propertiesButton->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnPropertiesPressed));
AddControl(propertiesButton);
//scene ingo
sceneInfoButton = ControlsFactory::CreateButton(
Vector2(propertiesButton->GetRect().x - ControlsFactory::BUTTON_WIDTH,
BODY_Y_OFFSET - ControlsFactory::BUTTON_HEIGHT),
LocalizedString(L"panel.sceneinfo"));
sceneInfoButton->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnSceneInfoPressed));
AddControl(sceneInfoButton);
sceneGraphButton = ControlsFactory::CreateButton( Vector2(0, BODY_Y_OFFSET - ControlsFactory::BUTTON_HEIGHT), LocalizedString(L"panel.graph.scene"));
sceneGraphButton->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnSceneGraphPressed));
AddControl(sceneGraphButton);
dataGraphButton = ControlsFactory::CreateButton(Vector2(ControlsFactory::BUTTON_WIDTH, BODY_Y_OFFSET - ControlsFactory::BUTTON_HEIGHT), LocalizedString(L"panel.graph.data"));
dataGraphButton->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnDataGraphPressed));
AddControl(dataGraphButton);
entitiesButton = ControlsFactory::CreateButton(Vector2(ControlsFactory::BUTTON_WIDTH*2, BODY_Y_OFFSET - ControlsFactory::BUTTON_HEIGHT), LocalizedString(L"panel.graph.entities"));
entitiesButton->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnEntitiesPressed));
AddControl(entitiesButton);
InitializeBodyList();
SetupAnimation();
helpDialog = new HelpDialog();
}
void SceneEditorScreenMain::CreateTopMenu()
{
int32 x = 0;
int32 y = 0;
int32 dx = ControlsFactory::BUTTON_WIDTH;
int32 dy = ControlsFactory::BUTTON_HEIGHT;
btnOpen = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.open"), true);
ControlsFactory::CustomizeButtonExpandable(btnOpen);
x += dx;
btnSave = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.save"), true);
x += dx;
btnExport = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.export"));
ControlsFactory::CustomizeButtonExpandable(btnExport);
x += dx;
btnMaterials = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.materials"), true);
x += dx;
btnCreate = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.createnode"), true);
ControlsFactory::CustomizeButtonExpandable(btnCreate);
x += dx;
btnProject = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.openproject"));
#ifdef __DAVAENGINE_BEAST__
x += dx;
btnBeast = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.beast"), true);
#endif //#ifdef __DAVAENGINE_BEAST__
x += dx;
btnLandscapeHeightmap = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.landscape.heightmap"), true);
x += dx;
btnLandscapeColor = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.landscape.colormap"), true);
x += dx;
btnViewPortSize = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.viewport"));
ControlsFactory::CustomizeButtonExpandable(btnViewPortSize);
x += dx;
btnTextureConverter = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.textureconvertor"));
x += dx;
btnNew = ControlsFactory::CreateButton(Rect(x, y, dx, dy), LocalizedString(L"menu.new"));
AddControl(btnOpen);
AddControl(btnSave);
AddControl(btnExport);
AddControl(btnMaterials);
AddControl(btnCreate);
AddControl(btnNew);
AddControl(btnProject);
#ifdef __DAVAENGINE_BEAST__
AddControl(btnBeast);
#endif
AddControl(btnLandscapeHeightmap);
AddControl(btnLandscapeColor);
AddControl(btnViewPortSize);
AddControl(btnTextureConverter);
btnOpen->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnOpenPressed));
btnSave->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnSavePressed));
btnExport->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnExportPressed));
btnMaterials->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnMaterialsPressed));
btnCreate->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnCreatePressed));
btnNew->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnNewPressed));
btnProject->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnOpenProjectPressed));
#ifdef __DAVAENGINE_BEAST__
btnBeast->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnBeastPressed));
#endif// #ifdef __DAVAENGINE_BEAST__
btnLandscapeHeightmap->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnLandscapeHeightmapPressed));
btnLandscapeColor->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnLandscapeColorPressed));
btnViewPortSize->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnViewPortSize));
btnTextureConverter->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &SceneEditorScreenMain::OnTextureConverter));
}
void UIStaticText::LoadFromYamlNode(YamlNode * node, UIYamlLoader * loader)
{
UIControl::LoadFromYamlNode(node, loader);
YamlNode * fontNode = node->Get("font");
YamlNode * textNode = node->Get("text");
YamlNode * multilineNode = node->Get("multiline");
YamlNode * multilineBySymbolNode = node->Get("multilineBySymbol");
YamlNode * fittingNode = node->Get("fitting");
YamlNode * textColorNode = node->Get("textcolor");
YamlNode * shadowColorNode = node->Get("shadowcolor");
YamlNode * shadowOffsetNode = node->Get("shadowoffset");
if (fontNode)
{
const String & fontName = fontNode->AsString();
Font * font = loader->GetFontByName(fontName);
SetFont(font);
}
bool multiline = loader->GetBoolFromYamlNode(multilineNode, false);
bool multilineBySymbol = loader->GetBoolFromYamlNode(multilineBySymbolNode, false);
SetMultiline(multiline, multilineBySymbol);
if(fittingNode)
{
int32 fittingArray[] = {TextBlock::FITTING_DISABLED, TextBlock::FITTING_ENLARGE,
TextBlock::FITTING_REDUCE, TextBlock::FITTING_POINTS};
String fittingValues[] = {"Disabled", "Enlarge", "Reduce", "Points"};
const String & fittinOption = fittingNode->AsString();
int32 fittingType = 0;
for(int32 i = 0 ; i < 4; ++i)
{
size_t find = fittinOption.find(fittingValues[i]);
if(find != fittinOption.npos)
{
fittingType |= fittingArray[i];
}
}
SetFittingOption(fittingType);
}
if (textNode)
{
SetText(LocalizedString(textNode->AsWString()));
}
if(textColorNode)
{
Vector4 c = textColorNode->AsVector4();
SetTextColor(Color(c.x, c.y, c.z, c.w));
}
if(shadowColorNode)
{
Vector4 c = shadowColorNode->AsVector4();
SetShadowColor(Color(c.x, c.y, c.z, c.w));
}
if(shadowOffsetNode)
{
SetShadowOffset(shadowOffsetNode->AsVector2());
}
YamlNode * alignNode = node->Get("textalign");
SetTextAlign(loader->GetAlignFromYamlNode(alignNode)); // NULL is also OK here.
}
LandscapeToolsPanelHeightmap::LandscapeToolsPanelHeightmap(LandscapeToolsPanelDelegate *newDelegate, const Rect & rect)
: LandscapeToolsPanel(newDelegate, rect)
{
Rect sizeRect(rect.dx - TEXTFIELD_WIDTH,
0, TEXTFIELD_WIDTH, ControlsFactory::TOOLS_HEIGHT / 2);
sizeValue = CreateTextField(sizeRect);
AddControl(sizeValue);
Rect strengthRect(sizeRect);
strengthRect.y = sizeRect.y + sizeRect.dy;
strengthValue = CreateTextField(strengthRect);
AddControl(strengthValue);
Rect lineRect;
lineRect.x = strengthSlider->GetRect().x + strengthSlider->GetRect().dx/2;
lineRect.dx = 2;
lineRect.y = strengthSlider->GetRect().y - 2;
lineRect.dy = strengthSlider->GetRect().dy + 4;
line = ControlsFactory::CreateLine(lineRect);
AddControl(line);
showGrid = CreateCkeckbox(Rect(0, ControlsFactory::TOOLS_HEIGHT, ControlsFactory::TOOLS_HEIGHT/2, ControlsFactory::TOOLS_HEIGHT/2),
LocalizedString(L"landscapeeditor.showgrid"));
float32 x = 0;
float32 y = ControlsFactory::TOOLS_HEIGHT + ControlsFactory::TOOLS_HEIGHT/2.f;
relative = CreateCkeckbox(Rect(x, y, ControlsFactory::TOOLS_HEIGHT/2.f, ControlsFactory::TOOLS_HEIGHT/2.f),
LocalizedString(L"landscapeeditor.relative"));
x += (ControlsFactory::TOOLS_HEIGHT/2.f + OFFSET + TEXT_WIDTH);
average = CreateCkeckbox(Rect(x, y, ControlsFactory::TOOLS_HEIGHT/2.f, ControlsFactory::TOOLS_HEIGHT/2.f),
LocalizedString(L"landscapeeditor.average"));
x += (ControlsFactory::TOOLS_HEIGHT/2.f + OFFSET + TEXT_WIDTH);
absoluteDropper = CreateCkeckbox(Rect(x, y, ControlsFactory::TOOLS_HEIGHT/2.f, ControlsFactory::TOOLS_HEIGHT/2.f),
LocalizedString(L"landscapeeditor.absolutedropper"));
Rect heightRect;
heightRect.x = showGrid->GetRect().x + showGrid->GetRect().dx + TEXT_WIDTH + OFFSET;
heightRect.y = ControlsFactory::TOOLS_HEIGHT;
heightRect.dx = TEXTFIELD_WIDTH;
heightRect.dy = average->GetRect().dy;
heightValue = CreateTextField(Rect(heightRect));
heightValue->SetText(L"0");
AddControl(heightValue);
heightRect.x = heightRect.x + heightRect.dx + ControlsFactory::OFFSET/2.f;
heightRect.dx = TEXT_WIDTH;
UIStaticText *textControl = new UIStaticText(heightRect);
textControl->SetText(LocalizedString(L"landscapeeditor.height"));
textControl->SetFont(ControlsFactory::GetFontLight());
textControl->SetAlign(ALIGN_VCENTER | ALIGN_LEFT);
AddControl(textControl);
SafeRelease(textControl);
averageStrength = CreateSlider(Rect(rect.dx - SLIDER_WIDTH, heightRect.y,
SLIDER_WIDTH, ControlsFactory::TOOLS_HEIGHT / 2));
averageStrength->AddEvent(UIControl::EVENT_VALUE_CHANGED, Message(this, &LandscapeToolsPanelHeightmap::OnAverageSizeChanged));
AddControl(averageStrength);
AddSliderHeader(averageStrength, LocalizedString(L"landscapeeditor.averagestrength"));
dropperTool = new LandscapeTool(-1, LandscapeTool::TOOL_DROPPER, "~res:/LandscapeEditor/SpecialTools/dropper.png");
dropperTool->size = 1.0f;
dropperTool->height = prevHeightValue = 0.f;
Rect dropperRect = brushIcon->GetRect();
dropperRect.x = (dropperRect.x + dropperRect.dx + ControlsFactory::OFFSET);
dropperIcon = new UIControl(dropperRect);
dropperIcon->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &LandscapeToolsPanelHeightmap::OnDropperTool));
dropperIcon->GetBackground()->SetDrawType(UIControlBackground::DRAW_SCALE_PROPORTIONAL);
dropperIcon->SetSprite(dropperTool->sprite, 0);
AddControl(dropperIcon);
copypasteTool = new LandscapeTool(-1, LandscapeTool::TOOL_COPYPASTE, "~res:/LandscapeEditor/SpecialTools/copypaste.png");
Rect copypasteRect = dropperRect;
copypasteRect.x = (copypasteRect.x + copypasteRect.dx + ControlsFactory::OFFSET);
copypasteIcon = new UIControl(copypasteRect);
copypasteIcon->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &LandscapeToolsPanelHeightmap::OnCopypasteTool));
copypasteIcon->GetBackground()->SetDrawType(UIControlBackground::DRAW_SCALE_PROPORTIONAL);
copypasteIcon->SetSprite(copypasteTool->sprite, 0);
AddControl(copypasteIcon);
copypasteRect.x = (copypasteRect.x + copypasteRect.dx + ControlsFactory::OFFSET);
copypasteRect.dx = copypasteRect.dy = ControlsFactory::TOOLS_HEIGHT / 2;
copyHeightmap = CreateCkeckbox(copypasteRect, L"Height");
copypasteRect.y += copypasteRect.dy;
copyTilemask = CreateCkeckbox(copypasteRect, L"Tilemask");
sizeValue->SetText(Format(L"%.3f", LandscapeTool::SizeHeightMax()));
strengthValue->SetText(Format(L"%.3f", LandscapeTool::StrengthHeightMax()));
relative->SetChecked(true, false);
average->SetChecked(false, false);
absoluteDropper->SetChecked(false, false);
sizeSlider->SetMinMaxValue(0.f, LandscapeTool::SizeHeightMax());
sizeSlider->SetValue(LandscapeTool::DefaultSizeHeight());
strengthSlider->SetMinMaxValue(-LandscapeTool::StrengthHeightMax(), LandscapeTool::StrengthHeightMax());
strengthSlider->SetValue(LandscapeTool::DefaultStrengthHeight());
averageStrength->SetMinMaxValue(0.f, 1.f);
averageStrength->SetValue(0.5f);
copyHeightmap->SetChecked(true, false);
copyTilemask->SetChecked(true, false);
}
void CreateNodesDialog::CreateNode(ResourceEditor::eNodeType nodeType)
{
SafeRelease(sceneNode);
SceneEditorScreenMain * screen = (SceneEditorScreenMain*)UIScreenManager::Instance()->GetScreen(SCREEN_SCENE_EDITOR_MAIN);
EditorScene * editorScene = screen->FindCurrentBody()->bodyControl->GetScene();
scene = editorScene;
switch (nodeType)
{
case ResourceEditor::NODE_LANDSCAPE:
SetHeader(LocalizedString(L"createnode.landscape"));
sceneNode = new LandscapeNode();
sceneNode->SetName("Landscape");
break;
case ResourceEditor::NODE_LIGHT:
{
SetHeader(LocalizedString(L"createnode.light"));
sceneNode = EditorLightNode::CreateSceneAndEditorLight();
sceneNode->SetName("Light");
break;
}
case ResourceEditor::NODE_SERVICE_NODE:
{
SetHeader(LocalizedString(L"createnode.servicenode"));
sceneNode = new SceneNode();
KeyedArchive *customProperties = sceneNode->GetCustomProperties();
customProperties->SetBool("editor.isLocked", true);
sceneNode->SetName("Servicenode");
break;
}
case ResourceEditor::NODE_BOX:
SetHeader(LocalizedString(L"createnode.box"));
sceneNode = new CubeNode();
sceneNode->SetName("Cube");
break;
case ResourceEditor::NODE_SPHERE:
SetHeader(LocalizedString(L"createnode.sphere"));
sceneNode = new SphereNode();
sceneNode->SetName("Sphere");
break;
case ResourceEditor::NODE_CAMERA:
SetHeader(LocalizedString(L"createnode.camera"));
sceneNode = new Camera();
((Camera *)sceneNode)->SetUp(Vector3(0.0f, 0.0f, 1.0f));
sceneNode->SetName("Camera");
break;
case ResourceEditor::NODE_IMPOSTER:
SetHeader(LocalizedString(L"createnode.imposter"));
sceneNode = new ImposterNode();
sceneNode->SetName("Imposter");
break;
case ResourceEditor::NODE_PARTICLE_EMITTER:
{
SetHeader(LocalizedString(L"createnode.particleemitter"));
ParticleEmitterNode * node = new ParticleEmitterNode();
node->LoadFromYaml("~res:/Particles/sparkles.yaml");
sceneNode = node;
}
break;
case ResourceEditor::NODE_USER_NODE:
SetHeader(LocalizedString(L"createnode.usernode"));
sceneNode = new UserNode();
sceneNode->SetName("UserNode");
break;
default:
break;
}
propertyList = PropertyControlCreator::Instance()->CreateControlForNode(sceneNode, propertyRect, true);
SafeRetain(propertyList);
AddControl(propertyList);
SetScene(editorScene);
propertyList->ReadFrom(sceneNode);
}
