Fixing bugs

include/anki/core/Counters.h

@@ -39,10 +39,14 @@ enum class Counter
 class CountersManager
 {
 public:
-	CountersManager(HeapAllocator<U8>& alloc, const CString& cacheDir);
+	CountersManager()
+	{}
 
 	~CountersManager();
 
+	ANKI_USE_RESULT Error create(
+		HeapAllocator<U8> alloc, const CString& cacheDir);
+
 	void increaseCounter(Counter counter, F64 val);
 	void increaseCounter(Counter counter, U64 val);
 
@@ -60,6 +64,7 @@ public:
 	void stopTimerIncreaseCounter(Counter counter);
 
 private:
+	HeapAllocator<U8> m_alloc;
 	File m_perframeFile;
 	File m_perrunFile;
 	DArray<U64> m_perframeValues;
@@ -68,7 +73,7 @@ private:
 };
 
 /// The singleton of the counters manager
-typedef SingletonInit<CountersManager> CountersManagerSingleton;
+typedef Singleton<CountersManager> CountersManagerSingleton;
 
 // Macros that encapsulate the functionaly
 
@@ -96,8 +101,6 @@ typedef SingletonInit<CountersManager> CountersManagerSingleton;
 #	define ANKI_COUNTERS_FLUSH() ((void)0)
 #endif // ANKI_ENABLE_COUNTERS
 
-namespace detail {
-
 // Forward
 class ThreadTraceManager;
 
@@ -110,16 +113,20 @@ public:
 	File m_traceFile;
 	Mutex m_fileMtx;
 
-	TraceManager(HeapAllocator<U8>& alloc, const CString& storeDir);
+	TraceManager()
+	{}
 
 	~TraceManager();
 
+	ANKI_USE_RESULT Error create(
+		HeapAllocator<U8>& alloc, const CString& storeDir);
+
 	void flushAll();
 
 	void flush(ThreadTraceManager& thread);
 };
 
-using TraceManagerSingleton = SingletonInit<TraceManager>;
+using TraceManagerSingleton = Singleton<TraceManager>;
 
 /// Trace manager per thread.
 class ThreadTraceManager
@@ -157,21 +164,19 @@ public:
 
 using ThreadTraceManagerSingleton = SingletonThreadSafe<ThreadTraceManager>;
 
-} // end namespace detail
-
 /// @name Trace macros.
 /// @{
 
 #if ANKI_ENABLE_COUNTERS
 
 #	define ANKI_TRACE_PUSH_EVENT(name_) \
-	detail::ThreadTraceManagerSingleton::get().pushEvent(name_)
+	ThreadTraceManagerSingleton::get().pushEvent(name_)
 
 #	define ANKI_TRACE_POP_EVENT() \
-	detail::ThreadTraceManagerSingleton::get().popEvent()
+	ThreadTraceManagerSingleton::get().popEvent()
 
 #	define ANKI_TRACE_FLUSH() \
-	detail::TraceManagerSingleton::get().flushAll()
+	TraceManagerSingleton::get().flushAll()
 
 #else
 

include/anki/event/LightEvent.h

@@ -17,28 +17,38 @@ class Light;
 /// @addtogroup event
 /// @{
 
-/// Helper class
-class LightEventData
-{
-public:
-	F32 m_radiusMultiplier = 0.0;
-	Vec4 m_intensityMultiplier = Vec4(0.0);
-	Vec4 m_specularIntensityMultiplier = Vec4(0.0);
-};
-
 /// An event for light animation
-class LightEvent: public Event, private LightEventData
+class LightEvent: public Event
 {
 public:
 	/// Create
 	ANKI_USE_RESULT Error create(
 		EventManager* manager, F32 startTime, F32 duration,
-		Light* light, const LightEventData& data);
+		Light* light);
 
 	/// Implements Event::update
 	ANKI_USE_RESULT Error update(F32 prevUpdateTime, F32 crntTime);
 
+	void setRadiusMultiplier(F32 v)
+	{
+		m_radiusMultiplier = v;
+	}
+
+	void setIntensityMultiplier(const Vec4& v)
+	{
+		m_intensityMultiplier = v;
+	}
+
+	void setSpecularIntensityMultiplier(const Vec4& v)
+	{
+		m_specularIntensityMultiplier = v;
+	}
+
 private:
+	F32 m_radiusMultiplier = 0.0;
+	Vec4 m_intensityMultiplier = Vec4(0.0);
+	Vec4 m_specularIntensityMultiplier = Vec4(0.0);
+
 	F32 m_originalRadius;
 	Vec4 m_originalDiffColor;
 	Vec4 m_originalSpecColor;

include/anki/gl/GlHandleDeferredDeleter.h

@@ -34,10 +34,16 @@ public:
 			GlCommandBufferHandle commands;
 			
 			Error err = commands.create(manager);
-			ANKI_ASSERT(!err);
-			
-			commands.template _pushBackNewCommand<TDeleteCommand>(obj, alloc);
-			commands.flush();
+			if(!err)
+			{
+				commands.template _pushBackNewCommand<TDeleteCommand>(
+					obj, alloc);
+				commands.flush();
+			}
+			else
+			{
+				ANKI_LOGE("Failed to create command");
+			}
 		}
 		else
 		{

include/anki/math/Vec.h

@@ -2156,13 +2156,19 @@ public:
 	}
 
 	template<typename TAlloc>
-	StringBase<TAlloc> toString(
-		typename StringBase<TAlloc>::Allocator& alloc) const
+	StringBase<typename TAlloc::template rebind<char>::other> toString(
+		TAlloc alloc_) const
 	{
-		StringBase<TAlloc> out(alloc);
+		using Alloc = typename TAlloc::template rebind<char>::other;
+		Alloc alloc = alloc_;
+		StringBase<Alloc> out;
 		for(U i = 0; i < N; i++)
 		{
-			out += StringBase<TAlloc>::toString(m_arr[i]) + CString(" ");
+			StringBase<Alloc> tmp;
+			tmp.toString(alloc, m_arr[i]);
+			out.append(alloc, tmp);
+			out.append(alloc, " ");
+			tmp.destroy(alloc);
 		}
 		return out;
 	}

include/anki/resource/MaterialProgramCreator.h

@@ -74,6 +74,7 @@ public:
 			m_value = std::move(b.m_value);
 			m_constant = b.m_constant;
 			m_arraySize = b.m_arraySize;
+			m_instanced = b.m_instanced;
 			m_line = std::move(b.m_line);
 			m_shaderDefinedMask = b.m_shaderDefinedMask;
 			m_shaderReferencedMask = b.m_shaderReferencedMask;

include/anki/scene/ModelNode.h

@@ -75,7 +75,8 @@ private:
 	SceneDArray<ObbSpatialComponent*> m_spatials;
 
 	ANKI_USE_RESULT Error updateInstanceSpatials(
-		const SceneFrameDArray<MoveComponent*>& instanceMoves);
+		const MoveComponent* instanceMoves[], 
+		U32 instanceMovesCount);
 };
 
 /// The model scene node

include/anki/scene/SceneNode.h

@@ -85,10 +85,11 @@ public:
 	ANKI_USE_RESULT Error iterateComponents(Func func) const
 	{
 		Error err = ErrorCode::NONE;
-		U count = m_componentsCount;
-		while(!err && count-- != 0)
+		auto it = m_components.getBegin();
+		auto end = it + m_componentsCount;
+		for(; !err && it != end; ++it)
 		{
-			err = func(*m_components[count]);
+			err = func(*(*it));
 		}
 
 		return err;
@@ -100,12 +101,14 @@ public:
 	{
 		Error err = ErrorCode::NONE;
 		SceneComponent::Type type = Component::getClassType();
-		U count = m_componentsCount;
-		while(!err && count-- != 0)
+		auto it = m_components.getBegin();
+		auto end = it + m_componentsCount;
+		for(; !err && it != end; ++it)
 		{
-			if(m_components[count]->getType() == type)
+			SceneComponent* comp = *it;
+			if(comp->getType() == type)
 			{
-				err = func(m_components[count]->downCast<Component>());
+				err = func(comp->downCast<Component>());
 			}
 		}
 

include/anki/util/Allocator.h

@@ -64,7 +64,7 @@ public:
 	template<typename Y>
 	struct rebind
 	{
-		typedef GenericPoolAllocator<Y, TPool, checkFree> other;
+		using other = GenericPoolAllocator<Y, TPool, checkFree>;
 	};
 
 	/// Default constructor

src/core/App.cpp

@@ -140,8 +140,13 @@ Error App::createInternal(const ConfigSet& config_,
 	m_timerTick = 1.0 / 60.0; // in sec. 1.0 / period
 
 #if ANKI_ENABLE_COUNTERS
-	CountersManagerSingleton::init(m_heapAlloc, m_settingsDir.toCString());
-	detail::TraceManagerSingleton::init(m_heapAlloc, m_settingsDir.toCString());
+	err = CountersManagerSingleton::get().create(
+		m_heapAlloc, m_settingsDir.toCString());
+	if(err) return err;
+
+	err = TraceManagerSingleton::get().create(
+		m_heapAlloc, m_settingsDir.toCString());
+	if(err) return err;
 #endif
 
 	//

src/core/Counters.cpp

@@ -45,7 +45,7 @@ static const Array<CounterInfo, (U)Counter::COUNT> cinfo = {{
 	{"SWAP_BUFFERS_TIME", CF_PER_RUN | CF_F64},
 	{"GL_CLIENT_WAIT_TIME", CF_PER_FRAME | CF_PER_RUN | CF_F64},
 	{"GL_SERVER_WAIT_TIME", CF_PER_FRAME | CF_PER_RUN | CF_F64},
-	{"GL_DRAWCALLS_COUNT", CF_PER_RUN | CF_U64},
+	{"GL_DRAWCALLS_COUNT", CF_PER_FRAME | CF_PER_RUN | CF_U64},
 	{"GL_VERTICES_COUNT", CF_PER_FRAME | CF_PER_RUN | CF_U64},
 	{"GL_QUEUES_SIZE", CF_PER_FRAME | CF_PER_RUN | CF_U64},
 	{"GL_CLIENT_BUFFERS_SIZE", CF_PER_FRAME | CF_PER_RUN | CF_U64}
@@ -54,35 +54,51 @@ static const Array<CounterInfo, (U)Counter::COUNT> cinfo = {{
 #define MAX_NAME "24"
 
 //==============================================================================
-CountersManager::CountersManager(
-	HeapAllocator<U8>& alloc, const CString& cacheDir)
-:	m_perframeValues(alloc),
-	m_perrunValues(alloc),
-	m_counterTimes(alloc)
+Error CountersManager::create(
+	HeapAllocator<U8> alloc, const CString& cacheDir)
 {
-	m_perframeValues.resize((U)Counter::COUNT, 0);
-	m_perrunValues.resize((U)Counter::COUNT, 0);
-	m_counterTimes.resize((U)Counter::COUNT, 0.0);
+	Error err = ErrorCode::NONE;
+
+	U count = static_cast<U>(Counter::COUNT);
+	m_alloc = alloc;
+	
+	err = m_perframeValues.create(m_alloc, count, 0);
+	if(err) return err;
+
+	err = m_perrunValues.create(m_alloc, count, 0);
+	if(err) return err;
+
+	err = m_counterTimes.create(m_alloc, count, 0.0);
+	if(err) return err;
 
 	// Open and write the headers to the files
-	m_perframeFile.open(
-		(String(cacheDir, alloc) + "/frame_counters.csv").toCString(),
-		File::OpenFlag::WRITE);
+	String tmp;
+	String::ScopeDestroyer tmpd(&tmp, alloc);
+	err = tmp.sprintf(alloc, "%s/frame_counters.csv", &cacheDir[0]);
+	if(err) return err;
+
+	err = m_perframeFile.open(tmp.toCString(), File::OpenFlag::WRITE);
+	if(err) return err;
 
-	m_perframeFile.writeText("FRAME");
+	err = m_perframeFile.writeText("FRAME");
+	if(err) return err;
 
 	for(const CounterInfo& inf : cinfo)
 	{
 		if(inf.m_flags & CF_PER_FRAME)
 		{
-			m_perframeFile.writeText(", %s", inf.m_name);
+			err = m_perframeFile.writeText(", %s", inf.m_name);
+			if(err) return err;
 		}
 	}
 
 	// Open and write the headers to the other file
-	m_perrunFile.open(
-		(String(cacheDir, alloc) + "/run_counters.csv").toCString(),
-		File::OpenFlag::WRITE);
+	tmp.destroy(alloc);
+	err = tmp.sprintf(alloc, "%s/run_counters.csv", &cacheDir[0]);
+	if(err) return err;
+
+	err = m_perrunFile.open(tmp.toCString(), File::OpenFlag::WRITE);
+	if(err) return err;
 
 	U i = 0;
 	for(const CounterInfo& inf : cinfo)
@@ -91,22 +107,30 @@ CountersManager::CountersManager(
 		{
 			if(i != 0)
 			{
-				m_perrunFile.writeText(", %" MAX_NAME "s", inf.m_name);
+				err = m_perrunFile.writeText(", %" MAX_NAME "s", inf.m_name);
 			}
 			else
 			{
-				m_perrunFile.writeText("%" MAX_NAME "s", inf.m_name);
+				err = m_perrunFile.writeText("%" MAX_NAME "s", inf.m_name);
 			}
 
+			if(err) return err;
+
 			++i;
 		}
 	}
-	m_perrunFile.writeText("\n");
+	err = m_perrunFile.writeText("\n");
+
+	return err;
 }
 
 //==============================================================================
 CountersManager::~CountersManager()
-{}
+{
+	m_perframeValues.destroy(m_alloc);
+	m_perrunValues.destroy(m_alloc);
+	m_counterTimes.destroy(m_alloc);
+}
 
 //==============================================================================
 void CountersManager::increaseCounter(Counter counter, U64 val)
@@ -170,8 +194,10 @@ void CountersManager::stopTimerIncreaseCounter(Counter counter)
 //==============================================================================
 void CountersManager::resolveFrame()
 {
+	Error err = ErrorCode::NONE;
+
 	// Write new line and frame no
-	m_perframeFile.writeText("\n%llu", getGlobTimestamp());
+	err = m_perframeFile.writeText("\n%llu", getGlobTimestamp());
 
 	U i = 0;
 	for(const CounterInfo& inf : cinfo)
@@ -180,11 +206,12 @@ void CountersManager::resolveFrame()
 		{
 			if(inf.m_flags & CF_U64)
 			{
-				m_perframeFile.writeText(", %llu", m_perframeValues[i]);
+				err = m_perframeFile.writeText(", %llu", m_perframeValues[i]);
 			}
 			else if(inf.m_flags & CF_F64)
 			{
-				m_perframeFile.writeText(", %f", *((F64*)&m_perframeValues[i]));
+				err = m_perframeFile.writeText(
+					", %f", *((F64*)&m_perframeValues[i]));
 			}
 			else
 			{
@@ -196,11 +223,15 @@ void CountersManager::resolveFrame()
 
 		i++;
 	}
+
+	(void)err;
 }
 
 //==============================================================================
 void CountersManager::flush()
 {
+	Error err = ErrorCode::NONE;
+
 	// Resolve per run counters
 	U i = 0;
 	U j = 0;
@@ -210,23 +241,24 @@ void CountersManager::flush()
 		{
 			if(j != 0)
 			{
-				m_perrunFile.writeText(", ");
+				err = m_perrunFile.writeText(", ");
 			}
 
 			if(inf.m_flags & CF_U64)
 			{
-				m_perrunFile.writeText("%" MAX_NAME "llu", m_perrunValues[i]);
+				err = m_perrunFile.writeText(
+					"%" MAX_NAME "llu", m_perrunValues[i]);
 			}
 			else if(inf.m_flags & CF_F64)
 			{
 				if(inf.m_flags & CF_FPS)
 				{
-					m_perrunFile.writeText("%" MAX_NAME "f", 
+					err = m_perrunFile.writeText("%" MAX_NAME "f", 
 						(F64)getGlobTimestamp() / *((F64*)&m_perrunValues[i]));
 				}
 				else
 				{
-					m_perrunFile.writeText("%" MAX_NAME "f", 
+					err = m_perrunFile.writeText("%" MAX_NAME "f", 
 						*((F64*)&m_perrunValues[i]));
 				}
 			}
@@ -241,52 +273,67 @@ void CountersManager::flush()
 
 		++i;
 	}
-	m_perrunFile.writeText("\n");
+	err = m_perrunFile.writeText("\n");
 
 	// Close and flush files
 	m_perframeFile.close();
 	m_perrunFile.close();
+
+	if(err)
+	{
+		ANKI_LOGE("Error in counters file");
+	}
 }
 
 //==============================================================================
 // TraceManager                                                                =
 //==============================================================================
 
-namespace detail {
-
 //==============================================================================
-TraceManager::TraceManager(HeapAllocator<U8>& alloc, const CString& storeDir)
+TraceManager::~TraceManager()
 {
-	String filename(storeDir, alloc);
-	filename += "/trace";
-	m_traceFile.open(filename.toCString(), File::OpenFlag::WRITE);
-
-	m_traceFile.writeText(
-		"thread_id, depth, event_name, start_time, stop_time\n");
+	flushAll();
 }
 
 //==============================================================================
-TraceManager::~TraceManager()
+Error TraceManager::create(HeapAllocator<U8>& alloc, const CString& storeDir)
 {
-	flushAll();
+	Error err = ErrorCode::NONE;
+	String filename;
+	err = filename.sprintf(alloc, "%s/trace", &storeDir[0]);
+	if(err) return err;
+
+	err = m_traceFile.open(filename.toCString(), File::OpenFlag::WRITE);
+
+	if(!err)
+	{
+		err = m_traceFile.writeText(
+			"thread_id, depth, event_name, start_time, stop_time\n");
+	}
+
+	filename.destroy(alloc);
+	return err;
 }
 
 //==============================================================================
 void TraceManager::flush(ThreadTraceManager& thread)
 {
 	ANKI_ASSERT(thread.m_depth == 0);
+	Error err = ErrorCode::NONE;
 
 	LockGuard<Mutex> lock(m_fileMtx);
 	for(U i = 0; i < thread.m_bufferedEventsCount; i++)
 	{
 		const ThreadTraceManager::Event& event = thread.m_bufferedEvents[i];
 
-		m_traceFile.writeText("%u, %u, %s, %f, %f\n", 
+		err = m_traceFile.writeText("%u, %u, %s, %f, %f\n", 
 			thread.m_id,
 			event.m_depth,
 			event.m_name,
 			event.m_startTime,
 			event.m_stopTime);
+
+		(void)err;
 	}
 
 	thread.m_bufferedEventsCount = 0;
@@ -340,8 +387,6 @@ void ThreadTraceManager::popEvent()
 	}
 }
 
-} // end namespace detail
-
 } // end namespace anki
 
 #endif // ANKI_ENABLE_COUNTERS

src/event/LightEvent.cpp

@@ -10,13 +10,11 @@ namespace anki {
 
 //==============================================================================
 Error LightEvent::create(EventManager* manager, F32 startTime, F32 duration,
-	Light* light, const LightEventData& data)
+	Light* light)
 {
 	Error err = Event::create(manager, startTime, duration, light);
 	if(err) return err;
 
-	*static_cast<LightEventData*>(this) = data;
-
 	switch(light->getLightType())
 	{
 	case Light::Type::POINT:

src/gl/GlProgramPipelineHandle.cpp

@@ -129,8 +129,14 @@ GlProgramHandle GlProgramPipelineHandle::getAttachedProgram(GLenum type) const
 {
 	ANKI_ASSERT(isCreated());
 	Error err = serializeOnGetter();
-	ANKI_ASSERT(!err);
-	return _get().getAttachedProgram(type);
+	if(!err)
+	{
+		return _get().getAttachedProgram(type);
+	}
+	else
+	{
+		return GlProgramHandle();
+	}
 }
 
 } // end namespace anki

src/resource/MaterialProgramCreator.cpp

@@ -398,14 +398,14 @@ Error MaterialProgramCreator::parseInputsTag(const XmlElement& programEl)
 				m_alloc, "%s %s", &inpvar.m_type[0], &inpvar.m_name[0]));
 			
 			U arrSize = 0;
-			if(inpvar.m_arraySize > 1)
+			if(inpvar.m_instanced)
 			{
-				arrSize = inpvar.m_arraySize;
+				inpvar.m_arraySize = ANKI_GL_MAX_INSTANCES;
 			}
 
-			if(inpvar.m_instanced)
+			if(inpvar.m_arraySize > 1)
 			{
-				inpvar.m_arraySize = ANKI_GL_MAX_INSTANCES;
+				arrSize = inpvar.m_arraySize;
 			}
 
 			if(arrSize)

src/scene/ModelNode.cpp

@@ -127,13 +127,14 @@ void ModelPatchNode::getRenderWorldTransform(U index, Transform& trf)
 
 //==============================================================================
 Error ModelPatchNode::updateInstanceSpatials(
-	const SceneFrameDArray<MoveComponent*>& instanceMoves)
+	const MoveComponent* instanceMoves[],
+	U32 instanceMovesCount)
 {
 	Error err = ErrorCode::NONE;
 	Bool fullUpdate = false;
 
 	const U oldSize = m_spatials.getSize();
-	const U newSize = instanceMoves.getSize();
+	const U newSize = instanceMovesCount;
 
 	if(oldSize < newSize)
 	{
@@ -142,10 +143,7 @@ Error ModelPatchNode::updateInstanceSpatials(
 		fullUpdate = true;
 		
 		err = m_spatials.resize(getSceneAllocator(), newSize);
-		if(err)
-		{
-			return err;
-		}
+		if(err)	return err;
 
 		U diff = newSize - oldSize;
 		U index = oldSize;
@@ -153,16 +151,10 @@ Error ModelPatchNode::updateInstanceSpatials(
 		{
 			ObbSpatialComponent* newSpatial = getSceneAllocator().
 				newInstance<ObbSpatialComponent>(this);
-			if(newSpatial == nullptr)
-			{
-				return ErrorCode::OUT_OF_MEMORY;
-			}
+			if(newSpatial == nullptr) return ErrorCode::OUT_OF_MEMORY;
 
 			err = addComponent(newSpatial);
-			if(err)
-			{
-				return err;
-			}
+			if(err)	return err;
 
 			m_spatials[index++] = newSpatial;
 		}
@@ -178,14 +170,16 @@ Error ModelPatchNode::updateInstanceSpatials(
 	}
 
 	U count = newSize;
+	const Obb& localBoundingShape = m_modelPatch->getBoundingShape();
 	while(count-- != 0)
 	{
 		ObbSpatialComponent& sp = *m_spatials[count];
+		ANKI_ASSERT(count < instanceMovesCount);
 		const MoveComponent& inst = *instanceMoves[count];
 
 		if(sp.getTimestamp() < inst.getTimestamp() || fullUpdate)
 		{
-			sp.m_obb = m_modelPatch->getBoundingShape().getTransformed(
+			sp.m_obb = localBoundingShape.getTransformed(
 				inst.getWorldTransform());
 
 			sp.markForUpdate();
@@ -289,7 +283,9 @@ Error ModelNode::frameUpdate(F32, F32)
 	Error err = ErrorCode::NONE;
 
 	// Gather the move components of the instances
-	SceneFrameDArray<MoveComponent*> instanceMoves;
+	SceneFrameDArray<const MoveComponent*> instanceMoves;
+	SceneFrameDArray<const MoveComponent*>::ScopeDestroyer instanceMovesd(
+		&instanceMoves, getSceneFrameAllocator());
 	U instanceMovesCount = 0;
 	Timestamp instancesTimestamp = 0;
 
@@ -329,10 +325,9 @@ Error ModelNode::frameUpdate(F32, F32)
 		{
 			m_transformsTimestamp = instancesTimestamp;
 
-			U count = 0;
-			for(const MoveComponent* instanceMove : instanceMoves)
+			for(U i = 0; i < instanceMovesCount; ++i)
 			{
-				m_transforms[count++] = instanceMove->getWorldTransform();
+				m_transforms[i] = instanceMoves[i]->getWorldTransform();
 			}
 		}
 
@@ -343,13 +338,12 @@ Error ModelNode::frameUpdate(F32, F32)
 			auto end = m_modelPatches.getEnd();
 			for(; it != end && !err; ++it)
 			{
-				err = (*it)->updateInstanceSpatials(instanceMoves);
+				err = (*it)->updateInstanceSpatials(
+					&instanceMoves[0], instanceMovesCount);
 			}
 		}
 	}
 
-	instanceMoves.destroy(getSceneFrameAllocator());
-
 	return err;
 }
 

testapp/Main.cpp

@@ -153,13 +153,12 @@ Error init()
 		point->setLensFlaresStretchMultiplier(Vec2(10.0, 1.0));
 		point->setLensFlaresAlpha(1.0);
 
-		LightEventData eventData;
-		eventData.m_radiusMultiplier = 0.2;
-		eventData.m_intensityMultiplier = Vec4(-1.2, 0.0, 0.0, 0.0);
-		eventData.m_specularIntensityMultiplier = Vec4(0.1, 0.1, 0.0, 0.0);
 		LightEvent* event;
-		err = scene.getEventManager().newEvent(event, 0.0, 0.8, point, eventData);
+		err = scene.getEventManager().newEvent(event, 0.0, 0.8, point);
 		if(err) return err;
+		event->setRadiusMultiplier(0.2);
+		event->setIntensityMultiplier(Vec4(-1.2, 0.0, 0.0, 0.0));
+		event->setSpecularIntensityMultiplier(Vec4(0.1, 0.1, 0.0, 0.0));
 		event->setReanimate(true);
 
 		MoveEventData moveData;

tests/script/LuaBinder.cpp

@@ -25,7 +25,6 @@ ANKI_TEST(Script, LuaBinder)
 	Vec2 v2(2.0, 3.0);
 	Vec3 v3(1.1, 2.2, 3.3);
 
-#if 0
 	sm.exposeVariable("v2", &v2);
 	sm.exposeVariable("v3", &v3);
 
@@ -33,5 +32,4 @@ ANKI_TEST(Script, LuaBinder)
 
 	ANKI_TEST_EXPECT_EQ(v2, Vec2(6, 12));
 	ANKI_TEST_EXPECT_EQ(v3, Vec3(1.1, 2.2, 0.1));
-#endif
 }