return mImpl->GetContextNotifier();
}
-// @todo Rename to ResetGlContext
void Core::ContextCreated()
{
mImpl->ContextCreated();
}
-// @todo Replace with StopRendering that prevents RenderManager from rendering
-// until we get ResetGLContext again, change ContextCreated to reset gpu buffer cache,
-// gl texture id's
void Core::ContextDestroyed()
{
mImpl->ContextDestroyed();
#define __DALI_INTEGRATION_PLATFORM_ABSTRACTION_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali/integration-api/resource-cache.h>
-#include <dali/integration-api/bitmap.h> ///@todo Remove this include (a bunch of stuff needs to include it though)
+#include <dali/integration-api/bitmap.h>
#include <dali/public-api/images/image-operations.h>
#include <dali/public-api/common/dali-vector.h>
// End marker
*mNextSlot = 0;
- // @todo Remove cast & change all messages to use WordType instead
return reinterpret_cast<unsigned int*>(slot);
}
/**
* Use a linear search to find the interval containing progress
- * TODO: Use binary search instead
*/
template <class V>
bool KeyFrameChannel<V>::FindInterval(
* The base template class for each key frame specialization. It stores a vector of
* ProgressValue pairs in mPVs, and uses the existing interface for KeyFrameChannel
* to point at this vector.
- * TODO: Incorporate KeyFrameChannel into this base template
*/
template<typename V>
class KeyFrameBaseSpec : public KeyFrameSpec
*/
void AddKeyFrame(float t, V v, AlphaFunction alpha)
{
- // TODO:: Support alpha
mPVs.push_back(PV(t, v));
}
{
Property::Index index = Property::INVALID_INDEX;
- //@todo MESH_REWORK - Are we assuming that the index into the array is the
- // same as the enumerated property? if enumIndex in the table was no longer
- // debug only, wouldn't need to make this assumption.
-
// Look for name in default properties
for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
}
}
- // @todo MESH_REWORK Store mappings for unstaged objects?
-
if( propertyPtr != NULL )
{
const SceneGraph::PropertyOwner* sceneObject = GetPropertyOwner();
}
else
{
- // @todo MESH_REWORK FIXME Need to store something that can be sent to the scene
- // object when staged.
DALI_ASSERT_ALWAYS(0 && "MESH_REWORK - Need to store property whilst off-stage" );
}
}
const std::string& fragmentShader,
Dali::Shader::ShaderHints hints )
{
- //TODO: MESH_REWORK
ShaderPtr shader( new Shader() );
shader->Initialize( vertexShader, fragmentShader, hints );
return shader;
// Undefined
RenderInstruction& operator=(const RenderInstruction& rhs);
-public: // Data, TODO hide these
+public: // Data
Render::RenderTracker* mRenderTracker; ///< Pointer to an optional tracker object (not owned)
void RenderManager::ContextDestroyed()
{
- // @todo Set an atomic value to prevent render manager rendering again until
- // ContextCreated has been called.
-
mImpl->context.GlContextDestroyed();
mImpl->programController.GlContextDestroyed();
* the current render. It essentially provides double buffering of the
* provider accessor through the message system. It does not take ownership
* of any objects.
- *
- * @todo - Add set of bools to state what changed (For improving performance)
*/
class RenderDataProvider
{
}
}
-// @todo MESH_REWORK Benchmark and test
-// The uniform map can never grow beyond the limits of GL - so really, the
-// map size is likely to be small; if retaining an unsorted map proves to be
-// slow, then it should be changed to perform an insertion sort.
void UniformMap::Add( UniformPropertyMapping* newMap )
{
UniformPropertyMapping::Hash nameHash = CalculateHash( newMap->uniformName );
*/
bool CompareItems( const RendererWithSortAttributes& lhs, const RendererWithSortAttributes& rhs )
{
- // @todo MESH_REWORK Consider replacing all these sortAttributes with a single long int that
- // encapsulates the same data (e.g. the middle-order bits of the ptrs)
if( lhs.renderItem->GetDepthIndex() == rhs.renderItem->GetDepthIndex() )
{
if( lhs.shader == rhs.shader )
const Dali::Internal::SceneGraph::UniformPropertyMapping* map = (*iter);
localMap.PushBack( map );
}
- //@todo MESH_REWORK Use memcpy to copy ptrs from one array to the other
}
}
ShaderEffect ShaderEffect::New( const std::string& vertexShader, const std::string& fragmentShader, GeometryHints hints)
{
- // @todo MESH_REWORK - Assert only image geometry type is passed.
Internal::ShaderEffectPtr internal = Internal::ShaderEffect::New( hints );
internal->SetPrograms( vertexShader, fragmentShader );
const std::string& fragmentShader,
GeometryHints hints)
{
- // @todo MESH_REWORK - Assert only image geometry type is passed.
Internal::ShaderEffectPtr internal = Internal::ShaderEffect::New( hints );
internal->SetPrograms( vertexShaderPrefix, fragmentShaderPrefix, vertexShader, fragmentShader );