void SpriteMainScene::doAutoTest()
{
isStating = false;
statCount = 0;
totalStatTime = 0.0f;
minFrameRate = -1.0f;
maxFrameRate = -1.0f;
// recreate a SubTest object
this->removeChild(_subTest->getTheParentNode());
CC_SAFE_DELETE(_subTest);
_subTest = new (std::nothrow) SubTest;
_subTest->initWithSubTest(_subtestNumber, this);
// create sprites & update the label
_quantityNodes = autoTestSpriteCounts[autoTestIndex];
for( int i = 0; i < _quantityNodes; i++)
{
auto sprite = _subTest->createSpriteWithTag(i);
doTest(sprite);
}
updateNodes();
updateTitle();
schedule(CC_SCHEDULE_SELECTOR(SpriteMainScene::beginStat), DELAY_TIME);
schedule(CC_SCHEDULE_SELECTOR(SpriteMainScene::endStat), DELAY_TIME + STAT_TIME);
}
bool RoundPageScrollView::init(const std::vector<CCNode*> &_nodes, int _radius)
{
if(!ContentLayer::init())
return false;
posY = -180;
w = 0;
v = 0;
currId = 0;
radius = Radius = _radius;
nodeScaleControll = 1.0;
distance = 300;
isOpen = false;
viewPort = CCRectMake(-winSize.width*0.5, -400, winSize.width, 700);
nodes = _nodes;
nodeNum = nodes.size();
defaultAction = true;
callBack = [](int id){};
updateNodes(nodes);
setTouchEnabled(true);
//star = PH::GetSprite("gameui/cha.png");
//star->setPosition(ccp(0,100));
//addChild(star);
update(0.0);
this->scheduleUpdate();
return true;
}
void TreeView::addChild(Widget* w)
{
ContainerWidget::addChild(w);
TreeViewNode* tvn = dynamic_cast<TreeViewNode*>(w);
// Set link to TreeView
tvn->notifyTreeViewParent(this);
int index = tvn->getIndex();
// If we're adding to the end, things are simple - don't have to update other node names, or positions.
if((index < 0) || (index >= static_cast<int>(mNodes.size())))
{
mNodes.push_back(tvn);
}
else
{
// If we've made it here, we have to insert the node into the list, and update all node indices and positions.
int counter = 0;
for(std::list<TreeViewNode*>::iterator it = mNodes.begin(); it != mNodes.end(); ++it)
{
if(counter == index)
{
mNodes.insert(it,tvn);
break;
}
++counter;
}
}
updateNodes();
}
//////////////////////////////////////////////////////////////////////////
// update
//virtual
void ScnModelComponent::postUpdate( BcF32 Tick )
{
Super::postUpdate( Tick );
UpdateFence_.increment();
updateNodes( BaseTransform_ * getParentEntity()->getWorldMatrix() );
#if DEBUG_RENDER_NODES
BcU32 NoofNodes = Model_->pHeader_->NoofNodes_;
for( BcU32 NodeIdx = 0; NodeIdx < NoofNodes; ++NodeIdx )
{
ScnModelNodeTransformData* pNodeTransformData = &pNodeTransformData_[ NodeIdx ];
ScnModelNodePropertyData* pNodePropertyData = &Model_->pNodePropertyData_[ NodeIdx ];
MaMat4d ThisMatrix = pNodeTransformData->WorldTransform_;
MaMat4d ParentMatrix = pNodePropertyData->ParentIndex_ != BcErrorCode ?
pNodeTransformData_[ pNodePropertyData->ParentIndex_ ].WorldTransform_ :
getParentEntity()->getWorldMatrix();
ScnDebugRenderComponent::pImpl()->drawMatrix(
ThisMatrix, RsColour::WHITE, 2000 );
ScnDebugRenderComponent::pImpl()->drawLine(
ParentMatrix.translation(),
ThisMatrix.translation(),
RsColour::WHITE, 1000 );
}
#endif // DEBUG_RENDER_NODES
}
void SceneGraphEditor::nodePressed(Qt::MouseButton button, int uid, int nid)
{
// for now we'll have it so only one node can be selected at a time
feather::qml::command::clear_selection();
feather::qml::command::select_node(uid);
emit nodeSelection(0,uid,nid);
updateNodes();
}
void TreeView::setNodeHeight(float nodeHeightInPixels)
{
nodeHeightInPixels = Ogre::Math::Floor(nodeHeightInPixels + 0.5);
mDesc->treeview_nodeHeight = nodeHeightInPixels;
for(std::list<TreeViewNode*>::iterator it = mNodes.begin(); it != mNodes.end(); ++it)
(*it)->setHeight(nodeHeightInPixels);
updateNodes();
}
Timeline::TimelineRenderPass::State *QmlProfilerBindingLoopsRenderPass::update(
const Timeline::TimelineAbstractRenderer *renderer,
const Timeline::TimelineRenderState *parentState, State *oldState,
int indexFrom, int indexTo, bool stateChanged, qreal spacing) const
{
Q_UNUSED(stateChanged);
Q_UNUSED(spacing);
const QmlProfilerRangeModel *model = qobject_cast<const QmlProfilerRangeModel *>(
renderer->model());
if (!model || indexFrom < 0 || indexTo > model->count())
return oldState;
BindingLoopsRenderPassState *state;
if (oldState == 0)
state = new BindingLoopsRenderPassState(model);
else
state = static_cast<BindingLoopsRenderPassState *>(oldState);
if (state->indexFrom() < state->indexTo()) {
if (indexFrom < state->indexFrom()) {
for (int i = indexFrom; i < state->indexFrom();
i += BindlingLoopsGeometry::maxEventsPerNode)
updateNodes(model, i, qMin(i + BindlingLoopsGeometry::maxEventsPerNode,
state->indexFrom()), parentState, state);
}
if (indexTo > state->indexTo()) {
for (int i = state->indexTo(); i < indexTo; i+= BindlingLoopsGeometry::maxEventsPerNode)
updateNodes(model, i, qMin(i + BindlingLoopsGeometry::maxEventsPerNode, indexTo),
parentState, state);
}
} else {
for (int i = indexFrom; i < indexTo; i+= BindlingLoopsGeometry::maxEventsPerNode)
updateNodes(model, i, qMin(i + BindlingLoopsGeometry::maxEventsPerNode, indexTo),
parentState, state);
}
state->updateIndexes(indexFrom, indexTo);
return state;
}
vector<shared_ptr<ActionNode> > ActivityExecution::getNextActions(const string& roleName)
{
vector<shared_ptr<ActionNode> > toExec;
updateNodes();
for(size_t i=0; i<_toExecuteNodes.size(); i++)
{
if(_toExecuteNodes[i]->getPartition_at(0)->getName() == roleName)
{
toExec.push_back(_toExecuteNodes[i]);
}
}
return toExec;
}
void SpriteMainScene::onDecrease(CCObject* pSender)
{
if( quantityNodes <= 0 )
return;
for( int i=0;i < kNodesIncrease;i++)
{
quantityNodes--;
m_pSubTest->removeByTag(quantityNodes);
}
updateNodes();
}
void LabelMainScene::onDecrease(Ref* sender)
{
if( _quantityNodes <= 0 )
return;
for( int i = 0;i < kNodesIncrease;i++)
{
_quantityNodes--;
_labelContainer->removeChildByTag(_quantityNodes);
}
updateNodes();
}
Map::Map(const model::Game& game, const model::World& world)
: m_tiles(world.getTilesXY())
, m_game(&game)
, m_world(&world)
, m_tileSize((int)m_game->getTrackTileSize())
, m_tileCenter((int)m_game->getTrackTileSize() / 2, (int)m_game->getTrackTileSize() / 2)
, m_worldWidthTiles(world.getWidth())
, m_worldHeightTiles(world.getHeight())
{
m_tileNodes.resize(m_worldWidthTiles * m_worldHeightTiles);
updateNodes();
}
void SpriteMainScene::onIncrease(Object* sender)
{
if( quantityNodes >= kMaxNodes)
return;
for( int i=0;i< kNodesIncrease;i++)
{
auto sprite = _subTest->createSpriteWithTag(quantityNodes);
doTest(sprite);
quantityNodes++;
}
updateNodes();
}
void SpriteMainScene::onDecrease(Ref* sender)
{
if( _quantityNodes <= 0 )
return;
for( int i=0;i < kNodesIncrease;i++)
{
_quantityNodes--;
_subTest->removeByTag(_quantityNodes);
}
updateNodes();
}
void SceneManager::updateQueues( const Frustum &frustum1, const Frustum *frustum2,
RenderingOrder::List order, bool lightQueue, bool renderableQueue )
{
// Clear without affecting capacity
if( lightQueue ) _lightQueue.resize( 0 );
if( renderableQueue ) _renderableQueue.resize( 0 );
updateNodes();
updateQueuesRec( frustum1, frustum2,
order == RenderingOrder::FrontToBack || order == RenderingOrder::BackToFront,
getRootNode(), lightQueue, renderableQueue );
// Sort
if( order == RenderingOrder::FrontToBack )
std::sort( _renderableQueue.begin(), _renderableQueue.end(), SceneNode::frontToBackOrder );
else if( order == RenderingOrder::BackToFront )
std::sort( _renderableQueue.begin(), _renderableQueue.end(), SceneNode::backToFrontOrder );
}
void RadialLayoutElement::spatialUpdate() {
BaseType::spatialUpdate();
updateNodes();
}
void LabelMainScene::onIncrease(Ref* sender)
{
if( _quantityNodes >= kMaxNodes)
return;
auto size = Director::getInstance()->getWinSize();
switch (_s_labelCurCase)
{
case kCaseLabelTTFUpdate:
for( int i=0;i< kNodesIncrease;i++)
{
auto label = Label::createWithSystemFont("LabelTTF", "Marker Felt", 30);
label->setPosition(Vec2((size.width/2 + rand() % 50), ((int)size.height/2 + rand() % 50)));
_labelContainer->addChild(label, 1, _quantityNodes);
_quantityNodes++;
}
break;
case kCaseLabelBMFontUpdate:
for( int i=0;i< kNodesIncrease;i++)
{
auto label = Label::createWithBMFont("fonts/bitmapFontTest3.fnt","LabelBMFont");
label->setPosition(Vec2((size.width/2 + rand() % 50), ((int)size.height/2 + rand() % 50)));
_labelContainer->addChild(label, 1, _quantityNodes);
_quantityNodes++;
}
break;
case kCaseLabelUpdate:
{
TTFConfig ttfConfig("fonts/arial.ttf", 60, GlyphCollection::DYNAMIC);
for( int i=0;i< kNodesIncrease;i++)
{
auto label = Label::createWithTTF(ttfConfig, "Label", TextHAlignment::LEFT);
label->setPosition(Vec2((size.width/2 + rand() % 50), ((int)size.height/2 + rand() % 50)));
_labelContainer->addChild(label, 1, _quantityNodes);
_quantityNodes++;
}
break;
}
case kCaseLabelBMFontBigLabels:
for( int i=0;i< kNodesIncrease;i++)
{
auto label = Label::createWithBMFont("fonts/bitmapFontTest3.fnt", LongSentencesExample);
label->setPosition(Vec2((size.width/2 + rand() % 50), ((int)size.height/2 + rand() % 50)));
_labelContainer->addChild(label, 1, _quantityNodes);
_quantityNodes++;
}
break;
case kCaseLabelBigLabels:
{
TTFConfig ttfConfig("fonts/arial.ttf", 60, GlyphCollection::DYNAMIC);
for( int i=0;i< kNodesIncrease;i++)
{
auto label = Label::createWithTTF(ttfConfig, LongSentencesExample, TextHAlignment::CENTER, size.width);
label->setPosition(Vec2((rand() % 50), rand()%((int)size.height/3)));
_labelContainer->addChild(label, 1, _quantityNodes);
_quantityNodes++;
}
break;
}
default:
break;
}
updateNodes();
}
//////////////////////////////////////////////////////////////////////////
// onAttach
//virtual
void ScnModelComponent::onAttach( ScnEntityWeakRef Parent )
{
Super::onAttach( Parent );
// Duplicate node data for update/rendering.
BcU32 NoofNodes = Model_->pHeader_->NoofNodes_;
pNodeTransformData_ = new ScnModelNodeTransformData[ NoofNodes ];
BcMemCopy( pNodeTransformData_, Model_->pNodeTransformData_, sizeof( ScnModelNodeTransformData ) * NoofNodes );
// Create material instances to render with.
ScnModelMeshRuntimeList& MeshRuntimes = Model_->MeshRuntimes_;
ScnMaterialComponentRef MaterialComponentRef;
PerComponentMeshDataList_.reserve( MeshRuntimes.size() );
for( BcU32 Idx = 0; Idx < MeshRuntimes.size(); ++Idx )
{
ScnModelMeshData* pMeshData = &Model_->pMeshData_[ Idx ];
ScnModelMeshRuntime* pMeshRuntime = &MeshRuntimes[ Idx ];
TPerComponentMeshData ComponentData;
if( pMeshRuntime->MaterialRef_.isValid() )
{
BcAssert( pMeshRuntime->MaterialRef_.isValid() && pMeshRuntime->MaterialRef_->isReady() );
ScnShaderPermutationFlags ShaderPermutation = pMeshData->ShaderPermutation_;
// Setup lighting.
if( isLit() )
{
ShaderPermutation |= ScnShaderPermutationFlags::LIGHTING_DIFFUSE;
}
else
{
ShaderPermutation |= ScnShaderPermutationFlags::LIGHTING_NONE;
}
// Even on failure add. List must be of same size for quick lookups.
ComponentData.MaterialComponentRef_ = Parent->attach< ScnMaterialComponent >(
BcName::INVALID, pMeshRuntime->MaterialRef_, ShaderPermutation );
}
// Create uniform buffer for object.
if( pMeshData->IsSkinned_ )
{
ComponentData.UniformBuffer_ = RsCore::pImpl() ?
RsCore::pImpl()->createBuffer(
RsBufferDesc(
RsBufferType::UNIFORM,
RsResourceCreationFlags::STREAM,
ScnShaderBoneUniformBlockData::StaticGetClass()->getSize() ) ) : nullptr;
}
else
{
ComponentData.UniformBuffer_ = RsCore::pImpl() ?
RsCore::pImpl()->createBuffer(
RsBufferDesc(
RsBufferType::UNIFORM,
RsResourceCreationFlags::STREAM,
ScnShaderObjectUniformBlockData::StaticGetClass()->getSize() ) ) : nullptr;
}
//
PerComponentMeshDataList_.push_back( ComponentData );
}
// Update nodes.
UpdateFence_.increment();
updateNodes( BaseTransform_ * getParentEntity()->getWorldMatrix() );
}
