//************* ColorSelectorControl *************
ColorSelectorControl::ColorSelectorControl(const Rect &rect)
: ColorDetailControl(rect)
{
RenderManager::Instance()->SetRenderTarget(colorMap);
RenderManager::Instance()->SetColor(Color(0.f, 0.f, 0.f, 1.f));
RenderHelper::Instance()->FillRect(Rect(0,0, rect.dx, rect.dy));
SetInitialColors();
float32 sectionHeight = rect.dy / (float32)SECTIONS_COUNT;
DVASSERT((0 != sectionHeight) && "Wrong control size");
float32 colorDelta = 1.0f / (sectionHeight);
for(int32 dy = 0; dy < (int32)sectionHeight; ++dy)
{
for(int32 iSection = 0; iSection < SECTIONS_COUNT; ++iSection)
{
RenderManager::Instance()->SetColor(sections[iSection]);
RenderHelper::Instance()->DrawLine(Vector2(0, iSection*sectionHeight + dy),
Vector2(rect.dx, iSection*sectionHeight + dy));
}
sections[0].b += colorDelta;
sections[1].r -= colorDelta;
sections[2].g += colorDelta;
sections[3].b -= colorDelta;
sections[4].r += colorDelta;
sections[5].g -= colorDelta;
}
RenderManager::Instance()->ResetColor();
RenderManager::Instance()->RestoreRenderTarget();
SetInitialColors();
markerPoint.dx = rect.dx / 2;
}
void GameObjectManager::RealAddObject(GameObject * _object)
{
if (!_object)return;
if (_object->dead) // if object is dead we mark that it should be added on deletion from prev. manager
{
_object->nextManager = this;
return;
}else
{
DVASSERT(_object->GetManager() == 0);
}
_object->Retain();
//int objectsCount = objects.size();
List<GameObject*>::iterator currentPos = objects.begin();
//Logger::FrameworkDebug("myp: %d\n", _object->GetPriority());
int pos = 0;
for (; currentPos != objects.end(); ++currentPos)
{
GameObject * curObject = *currentPos;
if ( curObject->GetPriority() > _object->GetPriority())
{
//Logger::FrameworkDebug("op: %d\n", curObject->GetPriority());
break;
}
pos++;
}
//Logger::FrameworkDebug("added to pos: %d\n", pos);
objects.insert(currentPos, _object);
_object->SetManager(this);
RecalcObjectHierarchy(_object);
}
void Scene::SetGlobalMaterial(NMaterial *globalMaterial)
{
SafeRelease(sceneGlobalMaterial);
if(NULL != globalMaterial)
{
DVASSERT(globalMaterial->GetMaterialType() == NMaterial::MATERIALTYPE_GLOBAL);
isDefaultGlobalMaterial = false;
sceneGlobalMaterial = SafeRetain(globalMaterial);
}
else
{
isDefaultGlobalMaterial = true;
sceneGlobalMaterial = NMaterial::CreateGlobalMaterial(FastName("Scene_Global_Material"));
}
InitGlobalMaterial();
renderSystem->SetGlobalMaterial(sceneGlobalMaterial);
particleEffectSystem->SetGlobalMaterial(sceneGlobalMaterial);
ImportShadowColor(this);
}
void NMaterial::PrepareRenderState(PolygonGroup * polygonGroup, NMaterialInstance * instance)
{
// if (1)
{
// shaderArray[0]->Dump();
}
Shader * activeShader = shaderArray[instance->GetLightCount()];
DVASSERT(activeShader != 0)
instance->renderState.SetShader(activeShader);
instance->PrepareInstanceForShader(activeShader);
// Bind shader & global uniforms
RenderManager::Instance()->FlushState(&instance->renderState);
// Here bind local uniforms of material
instance->UpdateUniforms();
instance->BindUniforms();
RenderManager::Instance()->SetRenderData(polygonGroup->renderDataObject);
RenderManager::Instance()->AttachRenderData();
};
void HierarchyTreeControlNode::AddControlToParent()
{
if (!parent)
return;
DVASSERT(uiObject);
HierarchyTreeScreenNode* screenNode = dynamic_cast<HierarchyTreeScreenNode*>(parent);
if (screenNode)
{
screenNode->GetScreen()->AddControl(this->uiObject);
}
else
{
//HierarchyTreeControlNode* controlNode = GetControlNode();
HierarchyTreeControlNode* controlNode = dynamic_cast<HierarchyTreeControlNode*>(parent);
if (controlNode)
{
UIControl* control = controlNode->GetUIObject();
if (control)
control->AddControl(this->uiObject);
}
}
}
void Image::FlipVertical()
{
switch(format)
{
case FORMAT_A8:
FlipVertical((uint8 *)data, width, height);
break;
case FORMAT_A16:
case FORMAT_RGBA5551:
case FORMAT_RGBA4444:
case FORMAT_RGB565:
FlipVertical((uint16 *)data, width, height);
break;
case FORMAT_RGBA8888:
FlipVertical((uint32 *)data, width, height);
break;
default:
DVASSERT(false && "Not implemented");
break;
}
}
void DistanceSlider::SetDistance(int layer, double value)
{
if(!locked)
{
DVASSERT(0 <= layer && layer < DAVA::LodComponent::MAX_LOD_LAYERS);
stretchSize[layer] = value;
int scaleSize = GetScaleSize();
QList<int> sizes;
for(int i = 1; i < layersCount; ++i)
{
sizes.push_back((stretchSize[i] - stretchSize[i-1]) * splitter->geometry().width() / scaleSize);
}
if(layersCount)
sizes.push_back((scaleSize - stretchSize[layer]) * splitter->geometry().width() / scaleSize);
bool wasBlocked = splitter->blockSignals(true);
splitter->setSizes(sizes);
splitter->blockSignals(wasBlocked);
}
}
void TransparentWebViewTest::LoadResources()
{
webView1 = new UIWebView(Rect(5, 5, 700, 500));
webView1->SetVisible(true);
webView1->OpenURL("http://ru.wikipedia.org/");
AddControl(webView1);
FilePath srcDir("~res:/TestData/TransparentWebViewTest/");
FilePath cpyDir = FileSystem::Instance()->GetCurrentDocumentsDirectory() + "TransparentWebViewTest/";
FileSystem::Instance()->DeleteDirectory(cpyDir);
FileSystem::Instance()->CreateDirectory(cpyDir);
FilePath srcFile = srcDir + "test.html";
FilePath cpyFile = cpyDir + "test.html";
FileSystem::Instance()->CopyFile(srcFile, cpyFile);
String url = "file:///" + cpyFile.GetAbsolutePathname();
webView2 = new UIWebView(Rect(710, 5, 300, 250));
webView2->SetVisible(true);
webView2->SetBackgroundTransparency(true);
webView2->OpenURL(url);
AddControl(webView2);
Font *font = FTFont::Create("~res:/Fonts/korinna.ttf");
DVASSERT(font);
font->SetSize(20);
testButton = new UIButton(Rect(0, 510, 300, 30));
testButton->SetStateFont(0xFF, font);
testButton->SetStateText(0xFF, L"Finish Test");
testButton->SetStateFontColor(0xFF, Color::White);
testButton->SetDebugDraw(true);
testButton->AddEvent(UIControl::EVENT_TOUCH_UP_INSIDE, Message(this, &TransparentWebViewTest::ButtonPressed));
AddControl(testButton);
SafeRelease(font);
}
void PropertyGridContainerWidget::OnPropertiesGridUpdated()
{
if (PropertiesGridController::Instance()->GetActiveTreeNodesList().empty() == false)
{
// List of UI Controls is selected.
BuildPropertiesGridList();
return;
}
// Build the Properties Grid based on the active control.
const HierarchyTreeNode* activeTreeNode = PropertiesGridController::Instance()->GetActiveTreeNode();
DVASSERT(activeTreeNode);
// This code is executed when Screen/Platform are selected.
UIControl* activeControl = NULL;
const HierarchyTreeControlNode* activeTreeControlNode = dynamic_cast<const HierarchyTreeControlNode*>(activeTreeNode);
if (activeTreeControlNode)
{
activeControl = activeTreeControlNode->GetUIObject();
}
BaseMetadata* metaData = GetActiveMetadata(activeTreeNode);
BuildPropertiesGrid(activeControl, metaData, activeTreeNode->GetId());
}
LodSystem::LodMerger::LodMerger(SceneNode * _toEntity)
{
DVASSERT(_toEntity);
toEntity = _toEntity;
}
void UIControlBackground::SetColorInheritType(UIControlBackground::eColorInheritType inheritType)
{
DVASSERT(inheritType >= 0 && inheritType < COLOR_INHERIT_TYPES_COUNT);
colorInheritType = inheritType;
}
void UIControlBackground::SetFrame(int32 drawFrame)
{
DVASSERT(spr);
frame = drawFrame;
}
void HierarchyTreeWidget::OnTreeUpdated(bool needRestoreSelection)
{
EXPANDEDITEMS expandedItems;
EXPANDEDITEMS selectedItems;
//save opened node
TREEITEMS oldItems = GetAllItems();
for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) {
QTreeWidgetItem* item = iter->second;
if (item->isExpanded())
{
QVariant data = item->data(ITEM_ID);
expandedItems.insert(data.toInt());
}
}
//save selected node
for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) {
QTreeWidgetItem* item = iter->second;
if (item->isSelected())
{
QVariant data = item->data(ITEM_ID);
selectedItems.insert(data.toInt());
HierarchyTreeNode* baseNode = HierarchyTreeController::Instance()->GetTree().GetNode(data.toInt());
HierarchyTreeControlNode* selectedControl = dynamic_cast<HierarchyTreeControlNode* >(baseNode);
if(NULL != selectedControl)
{
internalSelectionChanged = true;
}
}
}
//reset tree
ui->treeWidget->clear();
const HierarchyTree& tree = HierarchyTreeController::Instance()->GetTree();
const HierarchyTreeRootNode* rootNode = tree.GetRootNode();
for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = rootNode->GetChildNodes().begin();
iter != rootNode->GetChildNodes().end();
++iter)
{
//add platform node
const HierarchyTreePlatformNode* platformNode = (const HierarchyTreePlatformNode*)(*iter);
QTreeWidgetItem* platformItem = new QTreeWidgetItem();
platformItem->setData(ITEM_ID, platformNode->GetId());
QString platformName = platformNode->GetName();
if (platformNode->IsNeedSave())
{
platformName += " *";
}
platformItem->setText(0, platformName);
platformItem->setIcon(0, QIcon(IconHelper::GetPlatformIconPath()));
ui->treeWidget->insertTopLevelItem(ui->treeWidget->topLevelItemCount(), platformItem);
for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = platformNode->GetChildNodes().begin();
iter != platformNode->GetChildNodes().end();
++iter)
{
const HierarchyTreeScreenNode* screenNode = dynamic_cast<const HierarchyTreeScreenNode*>(*iter);
DVASSERT(screenNode);
QTreeWidgetItem* screenItem = new QTreeWidgetItem();
screenItem->setData(ITEM_ID, screenNode->GetId());
// Check whether this screen was changed.
QString screenItemText = screenNode->GetName();
if (screenNode->IsNeedSave())
{
screenItemText += " *";
}
screenItem->setText(0, screenItemText);
if (dynamic_cast<const HierarchyTreeAggregatorNode*>(screenNode))
screenItem->setIcon(0, QIcon(IconHelper::GetAggregatorIconPath()));
else
screenItem->setIcon(0, QIcon(IconHelper::GetScreenIconPath()));
platformItem->insertChild(platformItem->childCount(), screenItem);
AddControlItem(screenItem, screenNode->GetChildNodes());
}
}
// Restore the selected items only after the tree is fully built.
int itemsCount = ui->treeWidget->topLevelItemCount();
for (int i = 0; i < itemsCount; i ++)
{
QTreeWidgetItem* rootItem = ui->treeWidget->topLevelItem(i);
RestoreTreeItemExpandedStateRecursive(rootItem, expandedItems);
if (needRestoreSelection)
{
RestoreTreeItemSelectedStateRecursive(rootItem, selectedItems);
}
}
internalSelectionChanged = false;
}
bool SwitchToRenerObjectConverter::MergeSwitch(Entity * entity)
{
Vector<Entity*> entitiesToRemove;
SwitchComponent * sw = GetSwitchComponent(entity);
if(sw)
{
RenderComponent * rc = GetRenderComponent(entity);
RenderObject * ro = 0;
if(!rc)
{
ro = new Mesh();
rc = new RenderComponent(ro);
ro->Release();
ro->SetAABBox(AABBox3(Vector3(0, 0, 0), Vector3(0, 0, 0)));
entity->AddComponent(rc);
}
else
{
ro = rc->GetRenderObject();
}
DVASSERT(ro);
int32 size = entity->GetChildrenCount();
for(int32 i = 0; i < size; ++i)
{
Entity * sourceEntity = entity->GetChild(i);
RenderObject * sourceRenderObject = GetRenderObject(sourceEntity);
//workaround for custom properties for crashed model
if(1 == i) // crash model
{
KeyedArchive *childProps = GetCustomPropertiesArchieve(sourceEntity);
if(childProps && childProps->IsKeyExists("CollisionType"))
{
KeyedArchive *entityProps = GetOrCreateCustomProperties(entity)->GetArchive();
entityProps->SetInt32("CollisionTypeCrashed", childProps->GetInt32("CollisionType", 0));
}
}
//end of custom properties
Vector<std::pair<Entity*, RenderObject*> > renderPairs;
if(sourceRenderObject)
{
renderPairs.push_back(std::make_pair(sourceEntity, sourceRenderObject));
}
else
{
FindRenderObjectsRecursive(sourceEntity, renderPairs);
DVASSERT(renderPairs.size() == 1);
sourceRenderObject = renderPairs[0].second;
}
if(sourceRenderObject)
{
TransformComponent * sourceTransform = GetTransformComponent(sourceEntity);
if (sourceTransform->GetLocalTransform() != Matrix4::IDENTITY)
{
PolygonGroup * pg = sourceRenderObject->GetRenderBatchCount() > 0 ? sourceRenderObject->GetRenderBatch(0)->GetPolygonGroup() : 0;
if(pg && bakedPolygonGroups.end() == bakedPolygonGroups.find(pg))
{
sourceRenderObject->BakeGeometry(sourceTransform->GetLocalTransform());
bakedPolygonGroups.insert(pg);
}
}
uint32 sourceSize = sourceRenderObject->GetRenderBatchCount();
while(sourceSize)
{
int32 lodIndex, switchIndex;
RenderBatch * sourceRenderBatch = sourceRenderObject->GetRenderBatch(0, lodIndex, switchIndex);
sourceRenderBatch->Retain();
sourceRenderObject->RemoveRenderBatch(sourceRenderBatch);
ro->AddRenderBatch(sourceRenderBatch, lodIndex, i);
sourceRenderBatch->Release();
sourceSize--;
}
}
renderPairs[0].first->RemoveComponent(Component::RENDER_COMPONENT);
LodComponent * lc = GetLodComponent(sourceEntity);
if((0 != lc) && (0 == GetLodComponent(entity)))
{
LodComponent * newLod = (LodComponent*)lc->Clone(entity);
entity->AddComponent(newLod);
}
renderPairs[0].first->RemoveComponent(Component::LOD_COMPONENT);
if(sourceEntity->GetChildrenCount() == 0)
{
entitiesToRemove.push_back(sourceEntity);
}
}
}
uint32 entitiesToRemoveCount = entitiesToRemove.size();
for(uint32 i = 0; i < entitiesToRemoveCount; ++i)
{
entitiesToRemove[i]->GetParent()->RemoveNode(entitiesToRemove[i]);
}
return false;
}
int32 PropertyCellData::GetInt()
{
DVASSERT((valueType == PROP_VALUE_INTEGER) || (valueType == PROP_VALUE_DISTANCE));
return intValue;
}
bool FileList::IsDirectory(int32 index)
{
DVASSERT((index >= 0) && (index < (int32)fileList.size()));
return fileList[index].isDirectory;
}
const FilePath & FileList::GetPathname(int32 index)
{
DVASSERT((index >= 0) && (index < (int32)fileList.size()));
return fileList[index].path;
}
void ImposterNode::UpdateState()
{
if(GetChildrenCount() > 0)
{
DVASSERT(GetChildrenCount() == 1);
AABBox3 bbox = GetChild(0)->GetWTMaximumBoundingBoxSlow();
Vector3 bboxCenter = bbox.GetCenter();
float32 distanceSquare = (scene->GetCurrentCamera()->GetPosition() - bboxCenter).SquareLength();
distanceSquare *= scene->GetCurrentCamera()->GetZoomFactor() * scene->GetCurrentCamera()->GetZoomFactor();
Vector3 newDirection = scene->GetCurrentCamera()->GetPosition()-center;
newDirection.Normalize();
float32 dotProduct = newDirection.DotProduct(direction);
switch(state)
{
case STATE_3D:
{
if(distanceSquare > TOGGLE_SQUARE_DISTANCE)
{
UpdatePriority(distanceSquare, 0);
AskForRedraw();
}
else
{
isReady = false;
}
}
break;
case STATE_QUEUED:
{
if(IsAngleOrRangeChangedEnough(distanceSquare, dotProduct))
{
UpdatePriority(distanceSquare, dotProduct);
manager->UpdateQueue(this);
}
}
break;
case STATE_IMPOSTER:
{
if(distanceSquare < TOGGLE_SQUARE_DISTANCE)
{
isReady = false;
state = STATE_3D;
manager->RemoveFromQueue(this);
break;
}
if(IsAngleOrRangeChangedEnough(distanceSquare, dotProduct))
{
UpdatePriority(distanceSquare, dotProduct);
AskForRedraw();
}
}
break;
case STATE_REDRAW_APPROVED:
{
}
break;
}
}
}
void ImposterNode::UpdateImposter()
{
Camera * camera = scene->GetCurrentCamera();
Camera * imposterCamera = new Camera();
Vector3 cameraPos = camera->GetPosition();
Entity * child = GetChild(0);
AABBox3 bbox = child->GetWTMaximumBoundingBoxSlow();
Vector3 bboxCenter = bbox.GetCenter();
imposterCamera->Setup(camera->GetFOV(), camera->GetAspect(), camera->GetZNear(), camera->GetZFar());
imposterCamera->SetTarget(bbox.GetCenter());
imposterCamera->SetPosition(cameraPos);
imposterCamera->SetUp(camera->GetUp());
imposterCamera->SetLeft(camera->GetLeft());
Rect viewport = RenderManager::Instance()->GetViewport();
const Matrix4 & mvp = imposterCamera->GetUniformProjModelMatrix();
AABBox3 screenBounds;
GetOOBBoxScreenCoords(child, mvp, screenBounds);
Vector4 pv(bboxCenter);
pv = pv*mvp;
pv.z = (pv.z/pv.w + 1.f) * 0.5f;
float32 bboxCenterZ = pv.z;
Vector2 screenSize = Vector2(screenBounds.max.x-screenBounds.min.x, screenBounds.max.y-screenBounds.min.y);
Vector3 screenBillboardVertices[4];
screenBillboardVertices[0] = Vector3(screenBounds.min.x, screenBounds.min.y, screenBounds.min.z);
screenBillboardVertices[1] = Vector3(screenBounds.max.x, screenBounds.min.y, screenBounds.min.z);
screenBillboardVertices[2] = Vector3(screenBounds.min.x, screenBounds.max.y, screenBounds.min.z);
screenBillboardVertices[3] = Vector3(screenBounds.max.x, screenBounds.max.y, screenBounds.min.z);
center = Vector3();
Matrix4 invMvp = mvp;
invMvp.Inverse();
for(int32 i = 0; i < 4; ++i)
{
//unproject
Vector4 out;
out.x = 2.f*(screenBillboardVertices[i].x-viewport.x)/viewport.dx-1.f;
out.y = 2.f*(screenBillboardVertices[i].y-viewport.y)/viewport.dy-1.f;
out.z = 2.f*screenBillboardVertices[i].z-1.f;
out.w = 1.f;
out = out*invMvp;
DVASSERT(out.w != 0.f);
out.x /= out.w;
out.y /= out.w;
out.z /= out.w;
imposterVertices[i] = Vector3(out.x, out.y, out.z);
center += imposterVertices[i];
}
center /= 4.f;
//draw
RecreateFbo(screenSize);
//Logger::Info("%f, %f", screenSize.x, screenSize.y);
if(!block)
{
return;
}
direction = camera->GetPosition()-center;
direction.Normalize();
distanceSquaredToCamera = (center-cameraPos).SquareLength();
float32 nearPlane = sqrtf(distanceSquaredToCamera);
//float32 farPlane = nearPlane + (bbox.max.z-bbox.min.z);
float32 w = (imposterVertices[1]-imposterVertices[0]).Length();
float32 h = (imposterVertices[2]-imposterVertices[0]).Length();
//TODO: calculate instead of +50
imposterCamera->Setup(-w/2.f, w/2.f, -h/2.f, h/2.f, nearPlane, nearPlane+50.f);
Rect oldViewport = RenderManager::Instance()->GetViewport();
//Texture * target = fbo->GetTexture();
RenderManager::Instance()->AppendState(RenderState::STATE_SCISSOR_TEST);
RenderManager::Instance()->State()->SetScissorRect(Rect(block->offset.x, block->offset.y, block->size.dx, block->size.dy));
RenderManager::Instance()->FlushState();
//TODO: use one "clear" function instead of two
//if(block->size.x == 512.f)
//{
// RenderManager::Instance()->ClearWithColor(0.f, .8f, 0.f, 1.f);
//}
//else if(block->size.x == 256.f)
//{
// RenderManager::Instance()->ClearWithColor(0.f, .3f, 0.f, 1.f);
//}
//else if(block->size.x == 128.f)
//{
// RenderManager::Instance()->ClearWithColor(.3f, .3f, 0.f, 1.f);
//}
//else
//{
// RenderManager::Instance()->ClearWithColor(.3f, 0.f, 0.f, 1.f);
//}
RenderManager::Instance()->ClearWithColor(.0f, .0f, 0.f, .0f);
RenderManager::Instance()->ClearDepthBuffer();
RenderManager::Instance()->RemoveState(RenderState::STATE_SCISSOR_TEST);
RenderManager::Instance()->SetViewport(Rect(block->offset.x, block->offset.y, block->size.dx, block->size.dy), true);
imposterCamera->SetTarget(center);
imposterCamera->Set();
//TODO: remove this call
HierarchicalRemoveCull(child);
RenderManager::Instance()->FlushState();
child->Draw();
RenderManager::Instance()->SetViewport(oldViewport, true);
isReady = true;
state = STATE_IMPOSTER;
//unproject
screenBillboardVertices[0] = Vector3(screenBounds.min.x, screenBounds.min.y, bboxCenterZ);
screenBillboardVertices[1] = Vector3(screenBounds.max.x, screenBounds.min.y, bboxCenterZ);
screenBillboardVertices[2] = Vector3(screenBounds.min.x, screenBounds.max.y, bboxCenterZ);
screenBillboardVertices[3] = Vector3(screenBounds.max.x, screenBounds.max.y, bboxCenterZ);
for(int32 i = 0; i < 4; ++i)
{
//unproject
Vector4 out;
out.x = 2.f*(screenBillboardVertices[i].x-viewport.x)/viewport.dx-1.f;
out.y = 2.f*(screenBillboardVertices[i].y-viewport.y)/viewport.dy-1.f;
out.z = 2.f*screenBillboardVertices[i].z-1.f;
out.w = 1.f;
out = out*invMvp;
DVASSERT(out.w != 0.f);
out.x /= out.w;
out.y /= out.w;
out.z /= out.w;
imposterVertices[i] = Vector3(out.x, out.y, out.z);
}
SafeRelease(imposterCamera);
ClearGeometry();
CreateGeometry();
}
float32 PropertyCellData::GetFloat()
{
DVASSERT((valueType == PROP_VALUE_FLOAT) || (valueType == PROP_VALUE_DISTANCE));
return floatValue;
}
void PropertyCellData::SetFloat(float32 newFloat)
{
DVASSERT((valueType == PROP_VALUE_FLOAT) || (valueType == PROP_VALUE_DISTANCE));
floatValue = newFloat;
}
Texture *RenderManager::GetTexture(uint32 textureLevel)
{
DVASSERT(textureLevel < RenderState::MAX_TEXTURE_LEVELS);
return currentState.currentTexture[textureLevel];
}
void LightPropertyControl::ReadFrom(Entity * sceneNode)
{
NodesPropertyControl::ReadFrom(sceneNode);
Light *light = GetLight(sceneNode);
DVASSERT(light);
propertyList->AddSection("property.lightnode.light", GetHeaderState("property.lightnode.light", true));
propertyList->AddComboProperty("property.lightnode.type", types);
propertyList->SetComboPropertyIndex("property.lightnode.type", light->GetType());
propertyList->AddColorProperty("property.lightnode.ambient.color");
propertyList->SetColorPropertyValue("property.lightnode.ambient.color", light->GetAmbientColor());
propertyList->AddColorProperty("property.lightnode.diffuse.color");
propertyList->SetColorPropertyValue("property.lightnode.diffuse.color", light->GetDiffuseColor());
propertyList->AddColorProperty("property.lightnode.specular.color");
propertyList->SetColorPropertyValue("property.lightnode.specular.color", light->GetSpecularColor());
propertyList->AddFloatProperty("property.lightnode.intensity");
propertyList->SetFloatPropertyValue("property.lightnode.intensity", light->GetIntensity());
//propertyList->AddFloatProperty("property.lightnode.material.shininess", light->GetShininess())
propertyList->AddSection("property.lightnode.staticlight", GetHeaderState("property.lightnode.staticlight", true));
propertyList->AddBoolProperty("property.staticlight.enable");
propertyList->SetBoolPropertyValue("property.staticlight.enable", sceneNode->GetCustomProperties()->GetBool("editor.staticlight.enable", true));
propertyList->AddBoolProperty("Cast shadows");
propertyList->SetBoolPropertyValue("Cast shadows", sceneNode->GetCustomProperties()->GetBool("editor.staticlight.castshadows", true));
propertyList->AddFloatProperty("Intensity");
propertyList->SetFloatPropertyValue("Intensity", sceneNode->GetCustomProperties()->GetFloat("editor.intensity", 1.f));
propertyList->AddFloatProperty("Falloff cutoff");
propertyList->SetFloatPropertyValue("Falloff cutoff", sceneNode->GetCustomProperties()->GetFloat("editor.staticlight.falloffcutoff", 1000.f));
propertyList->AddFloatProperty("Falloff exponent");
propertyList->SetFloatPropertyValue("Falloff exponent", sceneNode->GetCustomProperties()->GetFloat("editor.staticlight.falloffexponent", 1.f));
if(Light::TYPE_DIRECTIONAL == light->GetType())
{
propertyList->AddFloatProperty("Shadow angle");
propertyList->SetFloatPropertyValue("Shadow angle", sceneNode->GetCustomProperties()->GetFloat("editor.staticlight.shadowangle", 0.f));
propertyList->AddIntProperty("Shadow samples");
propertyList->SetIntPropertyValue("Shadow samples", sceneNode->GetCustomProperties()->GetInt32("editor.staticlight.shadowsamples", 1));
}
else if(Light::TYPE_POINT == light->GetType())
{
propertyList->AddFloatProperty("Shadow radius");
propertyList->SetFloatPropertyValue("Shadow radius", sceneNode->GetCustomProperties()->GetFloat("editor.staticlight.shadowradius", 0.f));
}
propertyList->AddSection("property.lightnode.dynamiclight", GetHeaderState("property.lightnode.dynamiclight", true));
propertyList->AddBoolProperty("property.dynamiclight.enable");
propertyList->SetBoolPropertyValue("property.dynamiclight.enable", sceneNode->GetCustomProperties()->GetBool("editor.dynamiclight.enable", true));
}
void PropertyCellData::SetInt(int32 newInt)
{
DVASSERT((valueType == PROP_VALUE_INTEGER) || (valueType == PROP_VALUE_DISTANCE));
intValue = newInt;
}
const String & FileList::GetFilename(int32 index)
{
DVASSERT((index >= 0) && (index < (int32)fileList.size()));
return fileList[index].name;
}
void LandscapeEditorColor::StoreOriginalTexture()
{
DVASSERT(originalImage == NULL);
originalImage = StoreState();
}
FileList::FileList(const FilePath & filepath)
{
DVASSERT(filepath.IsDirectoryPathname());
path = filepath;
// Windows version
#if defined(__DAVAENGINE_WIN32__)
//char tmp[_MAX_PATH];
//_getcwd(tmp, _MAX_PATH);
//Path = tmp;
FilePath prevDir = FileSystem::Instance()->GetCurrentWorkingDirectory();
BOOL res = SetCurrentDirectoryA(path.GetAbsolutePathname().c_str());
if (res)
{
struct _finddata_t c_file;
intptr_t hFile;
FileEntry entry;
if( (hFile = _findfirst( "*", &c_file )) != -1L )
{
do
{
//TODO: need to check for Win32
entry.path = filepath + c_file.name;
entry.name = c_file.name;
entry.size = c_file.size;
entry.isDirectory = (_A_SUBDIR & c_file.attrib) != 0;
if(entry.isDirectory)
{
entry.path.MakeDirectoryPathname();
}
fileList.push_back(entry);
//Logger::FrameworkDebug("filelist: %s %s", filepath.c_str(), entry.name.c_str());
}
while( _findnext( hFile, &c_file ) == 0 );
_findclose( hFile );
}
}
FileSystem::Instance()->SetCurrentWorkingDirectory(prevDir);
//TODO add drives
//entry.Name = "E:\\";
//entry.isDirectory = true;
//Files.push_back(entry);
#elif defined(__DAVAENGINE_MACOS__) || defined(__DAVAENGINE_IPHONE__) || defined (__DAVAENGINE_ANDROID__)
struct dirent **namelist;
FileEntry entry;
#if defined (__DAVAENGINE_ANDROID__)
int32 n = scandir(path.GetAbsolutePathname().c_str(), &namelist, 0, alphasortAndroid);
#else //#if defined (__DAVAENGINE_ANDROID__)
int32 n = scandir(path.GetAbsolutePathname().c_str(), &namelist, 0, alphasort);
#endif //#if defined (__DAVAENGINE_ANDROID__)
if (n >= 0)
{
while(n--)
{
entry.path = path + namelist[n]->d_name;
entry.name = namelist[n]->d_name;
entry.size = 0;
entry.isDirectory = namelist[n]->d_type == DT_DIR;
if(entry.isDirectory)
{
entry.path.MakeDirectoryPathname();
}
fileList.push_back(entry);
free(namelist[n]);
}
free(namelist);
}
#endif //PLATFORMS
directoryCount = 0;
fileCount = 0;
for (int fi = 0; fi < GetCount(); ++fi)
{
if (IsDirectory(fi))
{
if (!IsNavigationDirectory(fi))
directoryCount++;
}else
fileCount++;
}
}
// UIListDelegate implementation
int32 EditorListDelegate::ElementsCount(UIList *forList)
{
UpdateCellSize(forList);
DVASSERT(cellsCount > 0);
return cellsCount;
}
void PngImageExt::Write(const FilePath & filename)
{
DVASSERT(internalData);
ImageLoader::Save(internalData, filename);
}
QWidget* ActionItemEditDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option,
const QModelIndex &index) const
{
QWidget* editor = NULL;
switch(index.column())
{
case COLUMN_ACTION_TYPE:
{
QComboBox* combo = new QComboBox(parent);
combo->setFrame(false);
for(int i = 1; i < ACTION_NAME_COUNT - 1; ++i) //do not add sound aciton
{
combo->addItem(ACTION_TYPE_NAME[i]);
}
editor = combo;
break;
}
case COLUMN_ENTITY_NAME:
{
DAVA::Entity* parentEntity = targetComponent->GetEntity();
DAVA::Vector<DAVA::Entity*> allChildren;
parentEntity->GetChildNodes(allChildren);
DAVA::Vector<DAVA::String> childrenNames;
childrenNames.push_back(parentEntity->GetName());
for(int i = 0; i < allChildren.size(); ++i)
{
childrenNames.push_back(allChildren[i]->GetName());
}
std::sort(childrenNames.begin(), childrenNames.end());
childrenNames.erase(std::unique(childrenNames.begin(), childrenNames.end()), childrenNames.end());
QComboBox* combo = new QComboBox(parent);
combo->setFrame(false);
for(int i = 0; i < childrenNames.size(); ++i)
{
combo->addItem(childrenNames[i].c_str());
}
editor = combo;
break;
}
case COLUMN_DELAY:
{
QDoubleSpinBox* spinBox = new QDoubleSpinBox(parent);
spinBox->setMinimum(0.0f);
spinBox->setMaximum(3600.f);
spinBox->setSingleStep(0.01f);
editor = spinBox;
break;
}
case COLUMN_SWITCH_INDEX:
{
QSpinBox* spinBox = new QSpinBox(parent);
spinBox->setMinimum(-1);
spinBox->setMaximum(128);
spinBox->setSingleStep(1);
editor = spinBox;
break;
}
case COLUMN_STOPAFTERNREPEATS_INDEX:
{
QSpinBox* spinBox = new QSpinBox(parent);
spinBox->setMinimum(-1);
spinBox->setMaximum(100000);
spinBox->setSingleStep(1);
editor = spinBox;
break;
}
case COLUMN_STOPWHENEMPTY_INDEX:
{
QComboBox* combo = new QComboBox(parent);
combo->setFrame(false);
combo->addItem("Yes");
combo->addItem("No");
editor = combo;
break;
}
}
DVASSERT(editor);
return editor;
}
