Size2F IGameClientSettings::DesignWinSize() const
{
PublishDevices device = ResultTag().Device;
switch (device.ToInt())
{
case PublishDevices::sd.IntValue:
return Size2F(480, 320);
case PublishDevices::hd.IntValue:
return Size2F(MEDUSA_SCREEN_WIDTH,MEDUSA_SCREEN_HEIGHT); //retina will *2
default:
Log::AssertFailed("Error device");
break;
}
return Size2F::Zero;
}
NormalLayer* normalLayer = new NormalLayer();
float winWidth = ResolutionAdapter::Instance().WinWidth();
float winHeight = ResolutionAdapter::Instance().WinHeight();
//back ground
FOR_EACH_UINT32(i, mChildCount)
{
Sprite* child = NodeFactory::Instance().CreateSprite(FileIdRef("Background.jpg", i));
child->SetPositionX(winWidth*i);
normalLayer->AddChild(child);
}
//foreground
mComponent = ComponentFactory::Instance().Create<ParallaxScrollComponent>();
mComponent->Initialize(Rect2F(Point2F::Zero, Size2F(winWidth*mChildCount, winHeight)), ResolutionAdapter::Instance().WinRect(), ScrollDirection::HorizontalFromLeft, true);
Sprite* mainSprite = NodeFactory::Instance().CreateSprite("test2.png");
mainSprite->DockToScreen(DockPoint::MiddleTop);
mainSprite->SetAnchorPoint(AnchorPoint::MiddleTop);
normalLayer->AddChild(mainSprite);
FOR_EACH_SIZE(i, mChildCount)
{
Sprite* child = NodeFactory::Instance().CreateSprite("test2.png");
child->SetAnchorPoint(AnchorPoint::MiddleTop);
child->SetPosition(mainSprite->Position());
child->MoveY(-child->Height()*(i + 1));
normalLayer->AddChild(child);
Point3F ratio = Point3F::One;
ratio.X = (float)(mChildCount-i) / mChildCount;
void ProgressBarNode::SetProtoData( const CoreProto::Editor::ProgressBar& val )
{
mProtoData = val;
SetName(val.id());
CCSprite* sprite=new CCSprite();
sprite->autorelease();
FileSystemOrderItem* orderItem=ResourceManager::Instance().InitSprite(sprite,val.image(),val.size());
if (orderItem==NULL)
{
Log::LogErrorFormat("ProgressBarNode:Cannot find image:%s",val.image().file().name().c_str());
return;
}
if(!initWithSprite(sprite))
{
Log::LogErrorFormat("Cannot init progress bar:%s",val.id().c_str());
return;
}
Point2F offset=orderItem->GetOffsetOrZero();
Size2F originalSize=orderItem->GetOriginalSizeOrZero();
Point2F newAnchorPoint=Point2F(val.anchor().x(),val.anchor().y());
if (offset!=Point2F::Zero)
{
CCSize contentSize=getContentSize();
newAnchorPoint= LayerEditor::CalculateAnchor(newAnchorPoint,offset,Size2F(contentSize.width,contentSize.height),Size2F(contentSize.width,contentSize.height));
}
//setFlipX(val.isfilpx());
//setFlipY(val.isfilpy());
setZOrder(val.zorder());
setVisible(val.isvisible());
setAnchorPoint(ccp(newAnchorPoint.X,newAnchorPoint.Y));
if (val.has_scale())
{
setScaleX(val.scale().x());
setScaleY(val.scale().y());
}
else
{
setScale(1.f);
}
setRotation(val.rotation());
SetRenderFlag((RenderFlag)val.renderflag());
if (val.isproportionpoint())
{
CCSize winSize= CCDirector::sharedDirector()->getWinSizeInPixels();
setPosition(ccp(val.position().x()*winSize.width,val.position().y()*winSize.height));
}
else
{
setPosition(ccp(val.position().x(),val.position().y()));
}
setPercentage(100.f);
setType((CCProgressTimerType)val.type());
CCPoint midPos = ccp(val.midpoint().x(),val.midpoint().y());
if (getType() == kCCProgressTimerTypeRadial)
{
midPos.x = Math::Clamp(midPos.x,0.001f,0.9999f);
midPos.y = Math::Clamp(midPos.y,0.001f,0.9999f);
}
setMidpoint(midPos);
setBarChangeRate(ccp(val.changerate().x(),val.changerate().y()));
setTag(val.tag());
}
NineGridSprite* ImageViewReader::CreateNineGridSprite(uint8 enable, const flatbuffers::FlatSize* nineGridSize, const flatbuffers::FlatSize* widgetSize, const flatbuffers::CapInsets* capInset, const FileIdRef& fileId)
{
bool isEnableNineGrid = enable != 0;
Size2F size = Size2F::Zero;
ThicknessF padding = ThicknessF::Zero;
if (isEnableNineGrid)
{
size = Size2F(nineGridSize->width(), nineGridSize->height());
}
else
{
size = Size2F(widgetSize->width(), widgetSize->height());
}
padding = ThicknessF(capInset->x(), size.Width - capInset->width() - capInset->x(), size.Height - capInset->height() - capInset->y(), capInset->y());
auto* sprite = NodeFactory::Instance().CreateNineGridSprite(size, fileId, padding);
sprite->EnableNineGrid(isEnableNineGrid);
return sprite;
/*
Share<IMaterial> material = nullptr;
auto* orderItem = FileSystem::Instance().FindOrderItem(fileId);
if (orderItem->Region() != nullptr)
{
TextureAtlasRegion* region = (TextureAtlasRegion*)orderItem->Region();
if (region->IsPolygon())
{
Log::AssertFailedFormat("Not support polygon region mode on {} when CreateNineGridTexture", fileId.Name);
return nullptr;
}
material = region->CreateMaterial();
}
else if (!orderItem->RegionName().IsEmpty())
{
auto regioFileId = FileId::ParseFrom(orderItem->GetFileEntry()->Path());
auto region = TextureAtlasFactory::Instance().CreateAtlasRegion(orderItem->RegionName(), regioFileId);
if (region == nullptr)
{
Log::AssertFailedFormat("Cannot find region:{} in {}", orderItem->RegionName(), regioFileId);
return nullptr;
}
if (region->IsPolygon())
{
Log::AssertFailedFormat("Not support polygon region mode on {} when CreateNineGridTexture", regioFileId.Name);
return nullptr;
}
material = region->CreateMaterial();
}
else
{
material = MaterialFactory::Instance().CreateSingleTexture(fileId);
}
Size2F size = material->FirstTexture()->Size();
ThicknessF padding = ThicknessF(capInset->x(), size.Width - capInset->width() - capInset->x(), size.Height - capInset->height() - capInset->y(), capInset->y());
Share<TextureNineGridMesh> mesh = new TextureNineGridMesh();
mesh->Initialize(Size2F(widgetSize->width(), widgetSize->height()), size,padding);
auto renderObject = RenderingObject(mesh, material);
NineGridSprite* sprite = new NineGridSprite();
sprite->EnableLayout(false); //suppress duplicate arrange after size changed
sprite->SetRenderingObject(renderObject);
sprite->SetTexturePadding(padding);
sprite->SetSize(renderObject.Mesh()->Size());
sprite->Initialize();
sprite->EnableLayout(true);
sprite->EnableNineGrid(enable != 0);
return sprite;
*/
}
