Additional IDE fixes

bindings/javascript/Polycode/RenderThread.js

@@ -31,6 +31,10 @@ RenderThread.prototype.processJob = function(job) {
 	Polycode.RenderThread_processJob(this.__ptr, job)
 }
 
+RenderThread.prototype.clearFrameQueue = function() {
+	Polycode.RenderThread_clearFrameQueue(this.__ptr)
+}
+
 RenderThread.prototype.getShaderBinding = function() {
 	var retVal = new ShaderBinding()
 	retVal.__ptr = Polycode.RenderThread_getShaderBinding(this.__ptr)

bindings/lua/Polycode/RenderThread.lua

@@ -49,6 +49,10 @@ function RenderThread:processJob(job)
 	local retVal = Polycode.RenderThread_processJob(self.__ptr, job.__ptr)
 end
 
+function RenderThread:clearFrameQueue()
+	local retVal =  Polycode.RenderThread_clearFrameQueue(self.__ptr)
+end
+
 function RenderThread:getShaderBinding()
 	local retVal =  Polycode.RenderThread_getShaderBinding(self.__ptr)
 	if retVal == nil then return nil end

include/polycode/bindings/javascript/PolycodeJSWrappers.h

@@ -7698,6 +7698,12 @@ namespace Polycode {
 		return 0;
 	}
 
+	duk_ret_t Polycode_RenderThread_clearFrameQueue(duk_context *context) {
+		RenderThread *inst = (RenderThread*)duk_to_pointer(context, 0);
+		inst->clearFrameQueue();
+		return 0;
+	}
+
 	duk_ret_t Polycode_RenderThread_getShaderBinding(duk_context *context) {
 		RenderThread *inst = (RenderThread*)duk_to_pointer(context, 0);
 		PolyBase *ptrRetVal = (PolyBase*)inst->getShaderBinding();

include/polycode/bindings/lua/PolycodeLuaWrappers.h

@@ -10462,6 +10462,12 @@ static int Polycode_RendererThreadJob_set_jobType(lua_State *L) {
 		inst->processJob(job);
 		return 0;
 	}
+	static int Polycode_RenderThread_clearFrameQueue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearFrameQueue();
+		return 0;
+	}
 	static int Polycode_RenderThread_getShaderBinding(lua_State *L) {
 		luaL_checktype(L, 1, LUA_TUSERDATA);
 		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));

include/polycode/core/PolyRenderer.h

@@ -139,6 +139,8 @@ namespace Polycode {
 			void enqueueJob(int jobType, void *data, void *data2=NULL);
 			void processJob(const RendererThreadJob &job);
 		
+			void clearFrameQueue();
+		
 			ShaderBinding *getShaderBinding();
 		
 			void processDrawBufferLights(GPUDrawBuffer *buffer);

include/polycode/modules/ui/PolyUIComboBox.h

@@ -30,6 +30,7 @@
 #include "polycode/modules/ui/PolyUIMenu.h"
 #include "polycode/modules/ui/PolyUIElement.h"
 #include "polycode/core/PolyFont.h"
+#include <memory>
 
 namespace Polycode {
 
@@ -39,6 +40,7 @@ namespace Polycode {
 			virtual ~UIComboBoxItem();
 			
 			void *data;
+			std::shared_ptr<void> sharedData;
 			String label;
 	};
 
@@ -53,7 +55,8 @@ namespace Polycode {
 			
 			int addComboItem(String itemName);			
 			int addComboItem(String itemName, void *data);
-						
+			int addComboItemWithSharedData(String itemName, std::shared_ptr<void> data);
+		
 			int getSelectedIndex();
 			UIComboBoxItem *getSelectedItem();
 			void setSelectedIndex(unsigned int newIndex, bool suppressChangeEvent = false);

src/bindings/javascript/PolycodeJS.cpp

@@ -1103,6 +1103,7 @@ int jsopen_Polycode(duk_context *ctx) {
 			{"RenderThread_enqueueFrame", Polycode_RenderThread_enqueueFrame, 2},
 			{"RenderThread_enqueueJob", Polycode_RenderThread_enqueueJob, 4},
 			{"RenderThread_processJob", Polycode_RenderThread_processJob, 2},
+			{"RenderThread_clearFrameQueue", Polycode_RenderThread_clearFrameQueue, 1},
 			{"RenderThread_getShaderBinding", Polycode_RenderThread_getShaderBinding, 1},
 			{"RenderThread_processDrawBufferLights", Polycode_RenderThread_processDrawBufferLights, 2},
 			{"RenderThread_processDrawBuffer", Polycode_RenderThread_processDrawBuffer, 2},

src/bindings/lua/PolycodeLua.cpp

@@ -1162,6 +1162,7 @@ int luaopen_Polycode(lua_State *L) {
 		{"RenderThread_enqueueFrame", Polycode_RenderThread_enqueueFrame},
 		{"RenderThread_enqueueJob", Polycode_RenderThread_enqueueJob},
 		{"RenderThread_processJob", Polycode_RenderThread_processJob},
+		{"RenderThread_clearFrameQueue", Polycode_RenderThread_clearFrameQueue},
 		{"RenderThread_getShaderBinding", Polycode_RenderThread_getShaderBinding},
 		{"RenderThread_processDrawBufferLights", Polycode_RenderThread_processDrawBufferLights},
 		{"RenderThread_processDrawBuffer", Polycode_RenderThread_processDrawBuffer},

src/core/PolyCore.cpp

@@ -196,6 +196,7 @@ namespace Polycode {
 		this->xRes = xRes;
 		this->yRes = yRes;
 		coreResized = true;
+		renderer->getRenderThread()->clearFrameQueue();
 		Render();
 	}
 	

src/core/PolyRenderer.cpp

@@ -199,6 +199,14 @@ void RenderThread::processDrawBufferLights(GPUDrawBuffer *buffer) {
 	}
 }
 
+void RenderThread::clearFrameQueue() {
+	jobQueueMutex->lock();
+	while(frameQueue.size()) {
+		frameQueue.pop();
+	}
+	jobQueueMutex->unlock();
+}
+
 void RenderThread::processDrawBuffer(GPUDrawBuffer *buffer) {
 	
 	++currentDebugFrameInfo.buffersProcessed;

src/ide/PolycodeMaterialEditor.cpp

@@ -423,10 +423,9 @@ void ShaderEditorPane::handleEvent(Event *event) {
 		}		
 		
 		if(event->getDispatcher() == vertexProgramProp) {
-			ShaderProgram* vpProgram = (ShaderProgram*)vertexProgramProp->comboEntry->getSelectedItem()->data;
+			std::shared_ptr<ShaderProgram> vpProgram = std::static_pointer_cast<ShaderProgram>(vertexProgramProp->comboEntry->getSelectedItem()->sharedData);
 			if(vpProgram) {
-				// SMARTPTR_TODO
-				//currentShader->vertexProgram = vpProgram;
+				currentShader->vertexProgram = vpProgram;
 				dispatchEvent(new Event(), Event::CHANGE_EVENT);
 			} else {
 				globalFrame->assetBrowser->addEventListener(this, UIEvent::OK_EVENT);
@@ -438,10 +437,9 @@ void ShaderEditorPane::handleEvent(Event *event) {
 		}		
 
 		if(event->getDispatcher() == fragmentProgramProp) {
-			ShaderProgram* fpProgram = (ShaderProgram*)fragmentProgramProp->comboEntry->getSelectedItem()->data;
+			std::shared_ptr<ShaderProgram> fpProgram = std::static_pointer_cast<ShaderProgram>(fragmentProgramProp->comboEntry->getSelectedItem()->sharedData);
 			if(fpProgram) {
-				// SMARTPTR_TODO
-				//currentShader->fragmentProgram = fpProgram;
+				currentShader->fragmentProgram = fpProgram;
 				dispatchEvent(new Event(), Event::CHANGE_EVENT);
 			} else {
 				globalFrame->assetBrowser->addEventListener(this, UIEvent::OK_EVENT);
@@ -487,25 +485,24 @@ void ShaderEditorPane::reloadPrograms() {
 	vertexProgramProp->comboEntry->addComboItem("Custom...", NULL);
 	fragmentProgramProp->comboEntry->addComboItem("Custom...", NULL);	
 		
-	std::vector<std::shared_ptr<Resource> > programs = CoreServices::getInstance()->getResourceManager()->getResources(Resource::RESOURCE_PROGRAM);
+	std::vector<std::shared_ptr<Resource> > programResources = CoreServices::getInstance()->getResourceManager()->getResources(Resource::RESOURCE_PROGRAM);
 	
-	// RENDERER_TODO
-	/*
-	for(int i=0; i < programs.size(); i++) {
-		ShaderProgram* program = (ShaderProgram*) programs[i];
+
+	for(auto resource:programResources) {
+		std::shared_ptr<ShaderProgram> program = std::static_pointer_cast<ShaderProgram>(resource);
 		if(program->type == ShaderProgram::TYPE_VERT) {
-			vertexProgramProp->comboEntry->addComboItem(program->getResourceName(), (void*)program);
-			if(program == currentShader->vp) {
+			vertexProgramProp->comboEntry->addComboItemWithSharedData(program->getResourceName(), program);
+			if(program == currentShader->vertexProgram) {
 				vertexProgramProp->comboEntry->setSelectedIndex(vertexProgramProp->comboEntry->getNumItems()-1);
 			}
 		} else if(program->type == ShaderProgram::TYPE_FRAG) {
-			fragmentProgramProp->comboEntry->addComboItem(program->getResourceName(), (void*)program);		
-			if(program == currentShader->fp) {
+			fragmentProgramProp->comboEntry->addComboItemWithSharedData(program->getResourceName(), program);
+			if(program == currentShader->fragmentProgram) {
 				fragmentProgramProp->comboEntry->setSelectedIndex(fragmentProgramProp->comboEntry->getNumItems()-1);
-			}			
+			}
 		}
-	}	
-	 */
+	}
+
 }
 
 void ShaderEditorPane::setShader(std::shared_ptr<Shader> shader) {
@@ -516,23 +513,20 @@ void ShaderEditorPane::setShader(std::shared_ptr<Shader> shader) {
 	reloadPrograms();
 		
 	nameProp->set(shader->getName());
-	
-	// RENDERER_TODO
-	/*
 	for(int i=0; i < vertexProgramProp->comboEntry->getNumItems(); i++) {
-		ShaderProgram* program = (ShaderProgram*) vertexProgramProp->comboEntry->getItemAtIndex(i)->data;
-		if(program == shader->vp) {
+		std::shared_ptr<ShaderProgram> program = std::static_pointer_cast<ShaderProgram>(vertexProgramProp->comboEntry->getItemAtIndex(i)->sharedData);
+		if(program == shader->vertexProgram) {
 			vertexProgramProp->comboEntry->setSelectedIndex(i);
 		}
 	}
 
 	for(int i=0; i < fragmentProgramProp->comboEntry->getNumItems(); i++) {
-		ShaderProgram* program = (ShaderProgram*) fragmentProgramProp->comboEntry->getItemAtIndex(i)->data;
-		if(program == shader->fp) {
+		std::shared_ptr<ShaderProgram> program = std::static_pointer_cast<ShaderProgram>(fragmentProgramProp->comboEntry->getItemAtIndex(i)->sharedData);
+		if(program == shader->fragmentProgram) {
 			fragmentProgramProp->comboEntry->setSelectedIndex(i);
 		}
 	}
-	*/
+	
 	screenShaderProp->set(shader->screenShader);
 	
 	pointLightsProp->set(shader->numPointLights);
@@ -905,15 +899,16 @@ MaterialEditorPane::MaterialEditorPane() : UIElement() {
 
 void MaterialEditorPane::reloadShaders() {
 	shaderProp->comboEntry->clearItems();
-	// SMARTPTR_TODO
-	/*
-	MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager();
-	for(int i=0; i < materialManager->getNumShaders(); i++) {
-		if(!materialManager->getShaderByIndex(i)->screenShader) {
-			shaderProp->comboEntry->addComboItem(materialManager->getShaderByIndex(i)->getName(), (void*)materialManager->getShaderByIndex(i));
+	
+	ResourcePool *globalPool = Services()->getResourceManager()->getGlobalPool();
+	std::vector<std::shared_ptr<Resource> > shaderResources = globalPool->getResources(Resource::RESOURCE_SHADER);
+	
+	for(auto resource:shaderResources) {
+		std::shared_ptr<Shader> shader = std::static_pointer_cast<Shader>(resource);
+		if(!shader->screenShader) {
+			shaderProp->comboEntry->addComboItemWithSharedData(shader->getName(), shader);
 		}
 	}
-	 */
 }
 
 void MaterialEditorPane::Resize(Number width, Number height) {
@@ -945,8 +940,7 @@ void MaterialEditorPane::handleEvent(Event *event) {
 		}
 	} else if(event->getDispatcher() == shaderProp) {
 		
-		// SHAREDPTR_TODO:
-		std::shared_ptr<Shader> selectedShader; // = std::static_pointer_cast<Shader>(shaderProp->comboEntry->getSelectedItem()->data);
+		std::shared_ptr<Shader> selectedShader = std::static_pointer_cast<Shader>(shaderProp->comboEntry->getSelectedItem()->sharedData);
 		if(selectedShader) {			
 			if(currentMaterial->getShader(0) != selectedShader) {
 				currentMaterial->clearShaders();
@@ -1000,8 +994,7 @@ void MaterialEditorPane::setMaterial(std::shared_ptr<Material> material) {
 	
 	if(currentMaterial->getShader(0)) { 
 	for(int i=0; i < shaderProp->comboEntry->getNumItems(); i++) {
-		// SHAREDPTR_TODO:
-		std::shared_ptr<Shader> shader;// = (Shader*)shaderProp->comboEntry->getItemAtIndex(i)->data;
+		std::shared_ptr<Shader> shader = std::static_pointer_cast<Shader>(shaderProp->comboEntry->getItemAtIndex(i)->sharedData);
 		if(shader) {
 			if(currentMaterial->getShader(0)->getName() == shader->getName()) {
 				shaderProp->set(i);
@@ -1374,38 +1367,6 @@ void PolycodeMaterialEditor::saveMaterials(ObjectEntry *materialsEntry, std::vec
 					}
 				}
 				
-				// RENDERER_TODO
-				/*
-				for(int j=0; j < shader->expectedTextures.size(); j++) {
-					Texture *texture = shaderBinding->getTexture(shader->expectedTextures[j]);
-					
-					bool inRenderBinding = false;
-					
-					for(int b=0; b < shaderBinding->getNumRenderTargetBindings(); b++) {
-						RenderTargetBinding *_binding = shaderBinding->getRenderTargetBinding(b);
-						if(_binding->name == shader->expectedTextures[j]) {
-							inRenderBinding = true;
-						}
-					}
-					
-					if(texture && !inRenderBinding) {
-						String texturePath = texture->getResourcePath();
-						texturePath = texturePath.replace(parentProject->getRootFolder()+"/", "");				
-						ObjectEntry *textureEntry = texturesEntry->addChild("texture", texturePath);
-						textureEntry->addChild("name", shader->expectedTextures[j]);
-					}
-				}
-				
-				for(int j=0; j < shader->expectedCubemaps.size(); j++) {
-					Cubemap *cubemap = shaderBinding->getCubemap(shader->expectedCubemaps[j]);
-					if(cubemap) {
-						String cubemapName = cubemap->getResourceName();
-						ObjectEntry *cubemapEntry = texturesEntry->addChild("cubemap", cubemapName);
-						cubemapEntry->addChild("name", shader->expectedCubemaps[j]);
-					}
-				}
-				*/
-				
 				if(shader->expectedParams.size() > 0 || shader->expectedParams.size() > 0) {
 					ObjectEntry *paramsEntry = shaderEntry->addChild("params");
 					
@@ -1520,17 +1481,22 @@ void PolycodeMaterialEditor::handleEvent(Event *event) {
 
 	if(event->getDispatcher() == materialBrowser->newShaderButton && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {
 		
-			// SHAREDPTR_TODO:
-		std::shared_ptr<Shader> newShader;// = std::make_shared<Shader>("Untitled", "default/Unlit.vert", "default/Unlit.frag", false);
-			newShader->setName("Untitled");
-			resourcePool->addResource(newShader);
-			if(newShader) {
-				materialBrowser->addShader(newShader)->setSelected();
-				shaders.push_back(newShader);
-				setHasChanges(true);	
-			} else {
-				printf("Error creating shader!\n");
-			}
+		ResourcePool *globalPool = Services()->getResourceManager()->getGlobalPool();
+		std::shared_ptr<ShaderProgram> vertexProgram = std::static_pointer_cast<ShaderProgram>(globalPool->getResourceByPath("default/Unlit.vert"));
+		std::shared_ptr<ShaderProgram> fragmentProgram = std::static_pointer_cast<ShaderProgram>(globalPool->getResourceByPath("default/Unlit.frag"));
+		
+		
+		std::shared_ptr<Shader> newShader = std::make_shared<Shader>(vertexProgram, fragmentProgram);
+		newShader->setName("Untitled");
+		
+		resourcePool->addResource(newShader);
+		if(newShader) {
+			materialBrowser->addShader(newShader)->setSelected();
+			shaders.push_back(newShader);
+			setHasChanges(true);
+		} else {
+			printf("Error creating shader!\n");
+		}
 	}	
 
 	if(event->getDispatcher() == materialBrowser->newCubemapButton && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {

src/modules/ui/PolyUIComboBox.cpp

@@ -136,6 +136,13 @@ int UIComboBox::addComboItem(String itemName, void *data) {
 	return items.size()-1;
 }
 
+
+int UIComboBox::addComboItemWithSharedData(String itemName, std::shared_ptr<void> data) {
+	int index = addComboItem(itemName, NULL);
+	items[index]->sharedData = data;
+	return index;
+}
+
 int UIComboBox::addComboItem(String itemName) {
 	return addComboItem(itemName, NULL);
 }