Added cubemap editor to IDE material editor, added LightCube shader to the default pack, fixed cubemap bindings in GLSL, changed the way cubemaps are save in the material file, added cubemap selector in the material editor

Assets/Default asset pack/default/LightCube.frag

@@ -0,0 +1,9 @@
+uniform samplerCube lightCube;
+varying vec4 vertexColor;
+varying vec3 normal;
+
+void main()
+{
+    vec4 texColor = textureCube(lightCube, normal);
+    gl_FragColor = texColor*vertexColor;
+}

Assets/Default asset pack/default/default.mat

@@ -110,6 +110,16 @@
 				</textures>
 			</fp>
 		</shader>
+		<shader type="glsl" name="LightCube" numAreaLights="0" numSpotLights="0">		
+			<vp source="DefaultShader.vert">
+				<params>			
+				</params>				
+			</vp>
+			<fp source="LightCube.frag">
+				<params>			
+				</params>
+			</fp>
+		</shader>		
 		<shader type="glsl" name="NorColSpec" numAreaLights="4" numSpotLights="2">		
 			<vp source="NormalShader.vert">
 				<params>			

Core/Contents/Include/PolyCubemap.h

@@ -31,9 +31,24 @@ namespace Polycode {
 	class _PolyExport Cubemap : public Resource {
 		public:
 			Cubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5);
+			
+			Texture *getTexture(int index);			
+			void setTexture(Texture *texture, int index);
+			
+			virtual void recreateFromTextures(){}
+			
 			virtual ~Cubemap();	
+			
+			static const int CUBEMAP_XPOS = 0;
+			static const int CUBEMAP_XNEG = 1;
+			static const int CUBEMAP_YPOS = 2;
+			static const int CUBEMAP_YNEG = 3;			
+			static const int CUBEMAP_ZPOS = 4;
+			static const int CUBEMAP_ZNEG = 5;
+																	
+		protected:
 		
-		protected:		
+			std::vector<Texture*> textures;
 		
 	};
 }

Core/Contents/Include/PolyGLCubemap.h

@@ -25,8 +25,8 @@ THE SOFTWARE.
 #include "PolyGlobals.h"
 #include "PolyCubemap.h"
 
-#ifdef _WINDOWS
-#include <windows.h>
+#ifdef _WINDOWS
+#include <windows.h>
 #endif
 
 #if defined(__APPLE__) && defined(__MACH__)
@@ -48,10 +48,13 @@ namespace Polycode {
 		OpenGLCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5);
 		virtual ~OpenGLCubemap();
 		
+		void recreateFromTextures();
+		
 		GLuint getTextureID();		
 			
 	protected:
-		
+	
+		bool glCubemapLoaded;
 		int filteringMode;
 		GLuint textureID;
 	};

Core/Contents/Include/PolyGLSLShader.h

@@ -68,10 +68,12 @@ namespace Polycode {
 			GLSLShaderBinding(GLSLShader *shader);
 			virtual ~GLSLShaderBinding();
 			
+			void clearCubemap(const String& name);
 			void addTexture(const String& name, Texture *texture);
 			void addCubemap(const String& name, Cubemap *cubemap);
 			void clearTexture(const String& name);
 			Texture *getTexture(const String& name);
+			Cubemap *getCubemap(const String& name);
 			
 			std::vector<GLSLTextureBinding> textures;
 			std::vector<GLSLCubemapBinding> cubemaps;

Core/Contents/Include/PolyMaterialManager.h

@@ -86,7 +86,8 @@ namespace Polycode {
 		
 			std::vector<Material*> loadMaterialsFromFile(String fileName);
 			std::vector<Shader*> loadShadersFromFile(String fileName);		
-			
+			std::vector<Cubemap*> loadCubemapsFromFile(String fileName);	
+						
 			void addMaterial(Material *material);
 			void addShader(Shader *shader);
 		

Core/Contents/Include/PolyShader.h

@@ -153,7 +153,9 @@ namespace Polycode {
 			virtual ~ShaderBinding();
 
 			virtual Texture *getTexture(const String& name){ return NULL;};
+			virtual Cubemap *getCubemap(const String& name){ return NULL;};			
 			virtual void clearTexture(const String& name){};
+			virtual void clearCubemap(const String& name){};
 			virtual void addTexture(const String& name, Texture *texture)  {};
 			LocalShaderParam *addParam(int type, const String& name);
 			virtual void addCubemap(const String& name, Cubemap *cubemap) {};

Core/Contents/Source/PolyCubemap.cpp

@@ -25,7 +25,26 @@
 using namespace Polycode;
 
 Cubemap::Cubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5) : Resource(Resource::RESOURCE_CUBEMAP) {
-	
+	textures.push_back(t0);
+	textures.push_back(t1);
+	textures.push_back(t2);
+	textures.push_back(t3);
+	textures.push_back(t4);
+	textures.push_back(t5);	
+}
+
+void Cubemap::setTexture(Texture *texture, int index) {
+	if(index >= 0 && index < 6) {
+		textures[index] = texture;		
+	}	
+}
+
+Texture *Cubemap::getTexture(int index) {
+	if(index >= 0 && index < 6) {
+		return textures[index];
+	} else {
+		return NULL;
+	}
 }
 
 Cubemap::~Cubemap() {

Core/Contents/Source/PolyGLCubemap.cpp

@@ -21,30 +21,61 @@
 */
 
 #include "PolyGLCubemap.h"
-#include "PolyTexture.h"
+#include "PolyTexture.h"
 
 using namespace Polycode;
 
 OpenGLCubemap::OpenGLCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5) : Cubemap(t0,t1,t2,t3,t4,t5) {
 	
+	glCubemapLoaded = false;
+
+	recreateFromTextures();
+}
+
+void OpenGLCubemap::recreateFromTextures() {
+
+	if(glCubemapLoaded) {
+		glDeleteTextures(1, &textureID);
+	}
+
 	glGenTextures(1, &textureID);
 	glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);	
 	
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+0, 0, GL_RGBA, t0->getWidth(), t0->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, t0->getTextureData());
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+1, 0, GL_RGBA, t1->getWidth(), t1->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, t1->getTextureData());
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+2, 0, GL_RGBA, t2->getWidth(), t2->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, t2->getTextureData());
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+3, 0, GL_RGBA, t3->getWidth(), t3->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, t3->getTextureData());
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+4, 0, GL_RGBA, t4->getWidth(), t4->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, t4->getTextureData());	
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+5, 0, GL_RGBA, t5->getWidth(), t5->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, t5->getTextureData());		
 	
+	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);	
 	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	
+	Texture *tex;
+	
+	tex = getTexture(Cubemap::CUBEMAP_XPOS);
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+
+	tex = getTexture(Cubemap::CUBEMAP_XNEG);	
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+
+	tex = getTexture(Cubemap::CUBEMAP_YPOS);
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+
+	tex = getTexture(Cubemap::CUBEMAP_YNEG);
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+
+	tex = getTexture(Cubemap::CUBEMAP_ZPOS);
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+
+	tex = getTexture(Cubemap::CUBEMAP_ZNEG);
+	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+	
+		
+	glCubemapLoaded = true;
 }
 
 OpenGLCubemap::~OpenGLCubemap() {
-
+	if(glCubemapLoaded) {
+		glDeleteTextures(1, &textureID);
+	}
 }
 
 GLuint OpenGLCubemap::getTextureID() {

Core/Contents/Source/PolyGLRenderer.cpp

@@ -773,7 +773,7 @@ void OpenGLRenderer::clearShader() {
 	glDisable(GL_FOG);
 	
 	for(int i=0; i < 4; i++)  {
-		glActiveTexture(GL_TEXTURE0+i);
+		glActiveTexture(GL_TEXTURE0+i);		
 		glDisable(GL_TEXTURE_2D);
 	}
 		

Core/Contents/Source/PolyGLSLShader.cpp

@@ -68,6 +68,15 @@ GLSLShaderBinding::~GLSLShaderBinding() {
 	
 }
 
+Cubemap *GLSLShaderBinding::getCubemap(const String& name) {
+	for(int i=0; i < cubemaps.size(); i++) {
+		if(cubemaps[i].name == name) {			
+			return cubemaps[i].cubemap;
+		}
+	}
+	return NULL;
+}
+
 Texture *GLSLShaderBinding::getTexture(const String& name) {
 	for(int i=0; i < textures.size(); i++) {
 		if(textures[i].name == name) {			
@@ -91,6 +100,15 @@ void GLSLShaderBinding::addCubemap(const String& name, Cubemap *cubemap) {
 	cubemaps.push_back(binding);
 }
 
+void GLSLShaderBinding::clearCubemap(const String& name) {
+	for(int i=0; i < cubemaps.size(); i++) {
+		if(cubemaps[i].name == name) {
+			cubemaps.erase(cubemaps.begin()+i);
+			return;
+		}
+	}
+}
+
 void GLSLShaderBinding::clearTexture(const String& name) {
 	for(int i=0; i < textures.size(); i++) {
 		if(textures[i].name == name) {

Core/Contents/Source/PolyGLSLShaderModule.cpp

@@ -420,9 +420,9 @@ bool GLSLShaderModule::applyShaderMaterial(Renderer *renderer, Material *materia
 		int texture_location = glGetUniformLocation(glslShader->shader_id, cgBinding->cubemaps[i].name.c_str());
 		glUniform1i(texture_location, textureIndex);
 		
-		glActiveTexture(GL_TEXTURE0 + textureIndex);	
-			
-		glBindTexture(GL_TEXTURE_CUBE_MAP, ((OpenGLCubemap*)cgBinding->cubemaps[i].cubemap)->getTextureID());	
+		glActiveTexture(GL_TEXTURE0 + textureIndex);				
+		glBindTexture(GL_TEXTURE_CUBE_MAP, ((OpenGLCubemap*)cgBinding->cubemaps[i].cubemap)->getTextureID());
+		printf("BINDING %d\n", ((OpenGLCubemap*)cgBinding->cubemaps[i].cubemap)->getTextureID());
 		textureIndex++;
 	}	
 	
@@ -435,6 +435,15 @@ bool GLSLShaderModule::applyShaderMaterial(Renderer *renderer, Material *materia
 		textureIndex++;
 	}		
 
+	for(int i=0; i < cgBinding->cubemaps.size(); i++) {
+		int texture_location = glGetUniformLocation(glslShader->shader_id, cgBinding->cubemaps[i].name.c_str());
+		glUniform1i(texture_location, textureIndex);
+		
+		glActiveTexture(GL_TEXTURE0 + textureIndex);				
+		glBindTexture(GL_TEXTURE_CUBE_MAP, ((OpenGLCubemap*)cgBinding->cubemaps[i].cubemap)->getTextureID());
+		textureIndex++;
+	}	
+
 		 
 	return true;
 }

Core/Contents/Source/PolyGLTexture.cpp

@@ -62,8 +62,9 @@ void OpenGLTexture::recreateFromImageData() {
 	
 	Number anisotropy = CoreServices::getInstance()->getRenderer()->getAnisotropyAmount();
 	
-	if(glTextureLoaded)
+	if(glTextureLoaded) {
 		glDeleteTextures(1, &textureID);
+	}
 	
 	glGenTextures(1, &textureID);
 	glBindTexture(GL_TEXTURE_2D, textureID);

Core/Contents/Source/PolyMaterialManager.cpp

@@ -271,21 +271,20 @@ Cubemap *MaterialManager::cubemapFromXMLNode(TiXmlNode *node) {
 	Cubemap *newCubemap = NULL;
 	
 	String name = nodeElement->Attribute("name");
-	String mapString = nodeElement->GetText();
-	
-	vector<String> maps = mapString.split(",");	
-	if(maps.size() != 6) {
-		Logger::log("Error: A cubemap must contain 6 images \n");
-		return NULL;
-	}
-	
+	String xPos = nodeElement->Attribute("xPos");
+	String xNeg = nodeElement->Attribute("xNeg");
+	String yPos = nodeElement->Attribute("yPos");
+	String yNeg = nodeElement->Attribute("yNeg");
+	String zPos = nodeElement->Attribute("zPos");				
+	String zNeg = nodeElement->Attribute("zNeg");
+		
 	newCubemap = CoreServices::getInstance()->getRenderer()->createCubemap(
-							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[0]),
-							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[1]),
-							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[2]),
-							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[3]),
-							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[4]),
-							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, maps[5])
+		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(xPos),
+		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(xNeg),
+		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(yPos),
+		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(yNeg),
+		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(zPos),
+		CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(zNeg)
 	);
 	newCubemap->setResourceName(name);
 	return newCubemap;
@@ -323,6 +322,30 @@ std::vector<Shader*> MaterialManager::loadShadersFromFile(String fileName) {
 	return retVector;
 }
 
+std::vector<Cubemap*> MaterialManager::loadCubemapsFromFile(String fileName) {
+	std::vector<Cubemap*> retVector;
+	
+	TiXmlDocument doc(fileName.c_str());
+	doc.LoadFile();
+	
+	if(doc.Error()) {
+		Logger::log("XML Error: %s\n", doc.ErrorDesc());
+	} else {
+		TiXmlElement *mElem = doc.RootElement()->FirstChildElement("cubemaps");
+		if(mElem) {
+			TiXmlNode* pChild;					
+			for (pChild = mElem->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) {
+				Cubemap *newCubemap = cubemapFromXMLNode(pChild);
+				if (newCubemap) {
+					retVector.push_back(newCubemap);
+				}
+			}
+		}
+	}
+	
+	return retVector;
+}
+
 std::vector<Material*> MaterialManager::loadMaterialsFromFile(String fileName) {
 	std::vector<Material*> retVector;
 	

Core/Contents/Source/PolyResourceManager.cpp

@@ -146,24 +146,12 @@ void ResourceManager::parseCubemaps(const String& dirPath, bool recursive) {
 	for(int i=0; i < resourceDir.size(); i++) {	
 		if(resourceDir[i].type == OSFileEntry::TYPE_FILE) {
 			if(resourceDir[i].extension == "mat") {
-				Logger::log("Adding cubemaps from %s\n", resourceDir[i].nameWithoutExtension.c_str());
-				TiXmlDocument doc(resourceDir[i].fullPath.c_str());
-				doc.LoadFile();
-				if(doc.Error()) {
-					Logger::log("XML Error: %s\n", doc.ErrorDesc());
-				} else {
-					TiXmlElement *mElem = doc.RootElement()->FirstChildElement("cubemaps");
-					
-					if(mElem) {
-						TiXmlNode* pChild;					
-						for (pChild = mElem->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) {
-							Cubemap *newMat = CoreServices::getInstance()->getMaterialManager()->cubemapFromXMLNode(pChild);
-							//						newMat->setResourceName(newMat->getName());
-							if(newMat)
-								addResource(newMat);
-						}
-					}
-				}
+			
+				MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager();			
+				std::vector<Cubemap*> cubemaps = materialManager->loadCubemapsFromFile(resourceDir[i].fullPath);			
+				for(int c=0; c < cubemaps.size(); c++) {
+					addResource(cubemaps[c]);
+				}			
 			}
 		} else {
 			if(recursive)

IDE/Contents/Include/PolycodeMaterialEditor.h

@@ -38,10 +38,38 @@ public:
 	}
 	Material *material;
 	Shader *shader;
+	Cubemap *cubemap;
 	String name;
 };
 
 
+class MaterialPreviewBox : public UIElement {
+	public:
+		MaterialPreviewBox();
+		~MaterialPreviewBox();
+		void setMaterial(Material *material);		
+		void showPrimitive(unsigned int index);
+		void clearMaterial();
+		
+		void handleEvent(Event *event);
+		
+		Scene *previewScene;
+		SceneLight *mainLight;
+		SceneLight *secondLight;		
+		SceneRenderTexture *renderTexture;
+		ScreenShape *previewShape;
+		
+		std::vector<UIImageButton*> shapeSwitches;
+		std::vector<ScenePrimitive*> shapePrimitives;
+		ScreenImage *shapeSelector;
+		
+		ScreenEntity *previewBase;		
+		ScenePrimitive *previewPrimitive;	
+		Material *currentMaterial;			
+		
+};
+
+
 class MaterialBrowser : public UIElement {
 	public:
 		MaterialBrowser();
@@ -49,16 +77,18 @@ class MaterialBrowser : public UIElement {
 		
 		void Resize(Number width, Number height);
 		
-		UITree * addMaterial(Material *material);
-		UITree * addShader(Shader *shader);
-				
+		UITree *addMaterial(Material *material);
+		UITree *addShader(Shader *shader);
+		UITree *addCubemap(Cubemap *cubemap);
+						
 		void handleEvent(Event *event);
 		
 		MaterialBrowserData *selectedData;
 
-		UIImageButton *newShaderButton;				
+		UIImageButton *newShaderButton;	
 		UIImageButton *newMaterialButton;
-		
+		UIImageButton *newCubemapButton;
+				
 		UITree *selectedNode;
 														
 	protected:
@@ -66,11 +96,38 @@ class MaterialBrowser : public UIElement {
 		ScreenShape *headerBg;
 		UITree *shadersNode;
 		UITree *materialsNode;
-		UITree *cubemapsNode;			
-	
+		UITree *cubemapsNode;
+		UITree *postEffectsNode;
+			
 		UITreeContainer *treeContainer;	
 };
 
+class CubemapEditorPane : public UIElement {
+	public:
+		CubemapEditorPane();
+		~CubemapEditorPane();
+		void Resize(Number width, Number height);
+		void setCubemap(Cubemap *cubemap);
+		void handleEvent(Event *event);
+		Cubemap *currentCubemap;		
+		
+	protected:
+	
+		PropList *propList;
+		ScreenShape *headerBg;
+		
+		TextureProp *yPosTexture;
+		TextureProp *yNegTexture;
+		TextureProp *xPosTexture;
+		TextureProp *xNegTexture;
+		TextureProp *zPosTexture;
+		TextureProp *zNegTexture;
+		
+		StringProp *nameProp;
+		
+		MaterialPreviewBox *cubemapPreview;
+};
+
 class ShaderEditorPane : public UIElement {
 	public:
 		ShaderEditorPane();
@@ -111,32 +168,20 @@ class MaterialEditorPane : public UIElement {
 		MaterialEditorPane();
 		~MaterialEditorPane();
 		
-		void setMaterial(Material *material);		
+		void setMaterial(Material *material);
 		void handleEvent(Event *event);
 		
 		void reloadShaders();
 		void Resize(Number width, Number height);	
-		void showPrimitive(unsigned int index);
 		
 		Material *currentMaterial;			
 	protected:
 	
+		MaterialPreviewBox *materialPreview;
 		bool changingMaterial;
 	
 		ScreenShape *headerBg;			
-		ScenePrimitive *previewPrimitive;
 		
-		Scene *previewScene;
-		SceneLight *mainLight;
-		SceneLight *secondLight;		
-		SceneRenderTexture *renderTexture;
-		ScreenShape *previewShape;
-		
-		std::vector<UIImageButton*> shapeSwitches;
-		std::vector<ScenePrimitive*> shapePrimitives;
-		ScreenImage *shapeSelector;
-		
-		ScreenEntity *previewBase;		
 		PropList *propList;
 		
 		StringProp *nameProp;
@@ -156,7 +201,8 @@ class MaterialMainWindow : public UIElement {
 	
 	MaterialEditorPane *materialPane;
 	ShaderEditorPane *shaderPane;	
-	
+	CubemapEditorPane *cubemapPane;	
+		
 	UIColorPicker *colorPicker;
 };
 
@@ -183,7 +229,8 @@ class PolycodeMaterialEditor : public PolycodeEditor {
 		MaterialMainWindow *mainWindow;
 		std::vector<Material*> materials;
 		std::vector<Shader*> shaders;
-				
+		std::vector<Cubemap*> cubemaps;
+						
 		UITree *selectedMaterialNode;
 };
 

IDE/Contents/Include/PolycodeProps.h

@@ -350,7 +350,6 @@ class ShaderOptionsSheet : public PropSheet {
 		
 };
 
-
 class ShaderTexturesSheet : public PropSheet {
 	public:
 		ShaderTexturesSheet();
@@ -368,6 +367,7 @@ class ShaderTexturesSheet : public PropSheet {
 		ShaderBinding *binding;
 						
 		std::vector<TextureProp*> textureProps;
+		std::vector<ComboProp*> cubemapProps;		
 };
 
 class EntitySheet : public PropSheet {

IDE/Contents/Source/PolycodeMaterialEditor.cpp

@@ -22,11 +22,143 @@
  
 #include "PolycodeMaterialEditor.h"
 #include "PolycodeFrame.h"
+#include "PolyCubemap.h"
 
 extern UIColorPicker *globalColorPicker;
 extern UIGlobalMenu *globalMenu;
 extern PolycodeFrame *globalFrame;
 
+CubemapEditorPane::CubemapEditorPane() : UIElement() {
+	currentCubemap = NULL;
+
+	headerBg = new ScreenShape(ScreenShape::SHAPE_RECT,10,10);
+	addChild(headerBg);
+	headerBg->setPositionMode(ScreenEntity::POSITION_TOPLEFT);
+	headerBg->color.setColorHexFromString(CoreServices::getInstance()->getConfig()->getStringValue("Polycode", "uiHeaderBgColor"));	
+	
+	propList = new PropList("CUBEMAP EDITOR");
+	addChild(propList);
+	propList->setPosition(0, 0);
+
+	PropSheet *baseProps1 = new PropSheet("CUBEMAP OPTIONS", "");
+	propList->addPropSheet(baseProps1);
+
+	nameProp = new StringProp("Name");
+	baseProps1->addProp(nameProp);
+	
+	baseProps1->propHeight = 70;
+	
+	PropSheet *baseProps = new PropSheet("CUBEMAP TEXTURES", "");
+	propList->addPropSheet(baseProps);
+
+	xPosTexture = new TextureProp("X+");
+	baseProps->addProp(xPosTexture);
+	xNegTexture = new TextureProp("X-");
+	baseProps->addProp(xNegTexture);	
+	yPosTexture = new TextureProp("Y+");
+	baseProps->addProp(yPosTexture);		
+	yNegTexture = new TextureProp("Y-");
+	baseProps->addProp(yNegTexture);
+	zPosTexture = new TextureProp("Z+");
+	baseProps->addProp(zPosTexture);
+	zNegTexture = new TextureProp("Z-");
+	baseProps->addProp(zNegTexture);
+
+	nameProp->addEventListener(this, Event::CHANGE_EVENT);	
+	yPosTexture->addEventListener(this, Event::CHANGE_EVENT);
+	yNegTexture->addEventListener(this, Event::CHANGE_EVENT);
+	xPosTexture->addEventListener(this, Event::CHANGE_EVENT);
+	xNegTexture->addEventListener(this, Event::CHANGE_EVENT);
+	zPosTexture->addEventListener(this, Event::CHANGE_EVENT);
+	zNegTexture->addEventListener(this, Event::CHANGE_EVENT);						
+	
+	baseProps->propHeight = 220;
+	propList->updateProps();
+	
+	cubemapPreview = new MaterialPreviewBox();
+	addChild(cubemapPreview);
+	cubemapPreview->setPosition(400, 0);
+	
+	Material *previewMaterial = CoreServices::getInstance()->getMaterialManager()->createMaterial("CubemapPreview", "LightCube");
+	cubemapPreview->setMaterial(previewMaterial);
+	enabled = false;
+	
+}
+
+void CubemapEditorPane::setCubemap(Cubemap *cubemap) {
+	enabled = true;
+	currentCubemap = cubemap;
+	
+	nameProp->set(cubemap->getResourceName());
+	
+	cubemapPreview->previewPrimitive->getLocalShaderOptions()->clearCubemap("lightCube");
+	cubemapPreview->previewPrimitive->getLocalShaderOptions()->addCubemap("lightCube", cubemap);	
+	
+	yPosTexture->set(cubemap->getTexture(Cubemap::CUBEMAP_YPOS));
+	yNegTexture->set(cubemap->getTexture(Cubemap::CUBEMAP_YNEG));
+	xPosTexture->set(cubemap->getTexture(Cubemap::CUBEMAP_XPOS));
+	xNegTexture->set(cubemap->getTexture(Cubemap::CUBEMAP_XNEG));
+	zPosTexture->set(cubemap->getTexture(Cubemap::CUBEMAP_ZPOS));
+	zNegTexture->set(cubemap->getTexture(Cubemap::CUBEMAP_ZNEG));				
+	
+}
+
+void CubemapEditorPane::handleEvent(Event *event) {
+
+	if(event->getDispatcher() == nameProp) {
+		currentCubemap->setResourceName(nameProp->get());
+		dispatchEvent(new Event(), Event::CHANGE_EVENT);					
+	}
+
+	if(event->getDispatcher() == yPosTexture) {
+		currentCubemap->setTexture(yPosTexture->get(), Cubemap::CUBEMAP_YPOS);
+		currentCubemap->recreateFromTextures();
+		dispatchEvent(new Event(), Event::CHANGE_EVENT);			
+	}	
+	
+	if(event->getDispatcher() == yNegTexture) {
+		currentCubemap->setTexture(yNegTexture->get(), Cubemap::CUBEMAP_YNEG);
+		currentCubemap->recreateFromTextures();
+		dispatchEvent(new Event(), Event::CHANGE_EVENT);			
+	}	
+
+	if(event->getDispatcher() == xPosTexture) {
+		currentCubemap->setTexture(xPosTexture->get(), Cubemap::CUBEMAP_XPOS);
+		currentCubemap->recreateFromTextures();
+		dispatchEvent(new Event(), Event::CHANGE_EVENT);			
+	}	
+
+	if(event->getDispatcher() == xNegTexture) {
+		currentCubemap->setTexture(xNegTexture->get(), Cubemap::CUBEMAP_XNEG);
+		currentCubemap->recreateFromTextures();
+		dispatchEvent(new Event(), Event::CHANGE_EVENT);			
+	}	
+
+	if(event->getDispatcher() == zPosTexture) {
+		currentCubemap->setTexture(zPosTexture->get(), Cubemap::CUBEMAP_ZPOS);
+		currentCubemap->recreateFromTextures();
+		dispatchEvent(new Event(), Event::CHANGE_EVENT);			
+	}	
+
+	if(event->getDispatcher() == zNegTexture) {
+		currentCubemap->setTexture(zNegTexture->get(), Cubemap::CUBEMAP_ZNEG);
+		currentCubemap->recreateFromTextures();
+		dispatchEvent(new Event(), Event::CHANGE_EVENT);			
+	}	
+	
+}
+
+CubemapEditorPane::~CubemapEditorPane() {
+
+}
+
+void CubemapEditorPane::Resize(Number width, Number height) {
+	headerBg->setShapeSize(width, 30);	
+	propList->Resize(370, height);
+	propList->updateProps();
+}
+
+
 ShaderEditorPane::ShaderEditorPane() : UIElement() {	
 
 	changingShader = false;
@@ -230,55 +362,8 @@ void ShaderEditorPane::Resize(Number width, Number height) {
 	propList->updateProps();
 }
 
-
-MaterialEditorPane::MaterialEditorPane() : UIElement() {	
-
-	changingMaterial = false;
-	
-	headerBg = new ScreenShape(ScreenShape::SHAPE_RECT,10,10);
-	addChild(headerBg);
-	headerBg->setPositionMode(ScreenEntity::POSITION_TOPLEFT);
-	headerBg->color.setColorHexFromString(CoreServices::getInstance()->getConfig()->getStringValue("Polycode", "uiHeaderBgColor"));	
-	
-	propList = new PropList("MATERIAL EDITOR");
-	addChild(propList);
-	propList->setPosition(0, 0);
-
-	PropSheet *baseProps = new PropSheet("MATERIAL SETTINGS", "");
-	propList->addPropSheet(baseProps);
-	
-	nameProp = new StringProp("Name");
-	baseProps->addProp(nameProp);	
-	nameProp->addEventListener(this, Event::CHANGE_EVENT);
-		
-	shaderProp = new ComboProp("Shader");
-	baseProps->addProp(shaderProp);
-	shaderProp->addEventListener(this, Event::CHANGE_EVENT);
-	
-	blendModeProp = new ComboProp("Blend mode");
-	baseProps->addProp(blendModeProp);
-	blendModeProp->addEventListener(this, Event::CHANGE_EVENT);
-		
-	blendModeProp->comboEntry->addComboItem("Normal");
-	blendModeProp->comboEntry->addComboItem("Lighten");
-	blendModeProp->comboEntry->addComboItem("Color");
-	blendModeProp->comboEntry->addComboItem("Premultiplied");
-	blendModeProp->comboEntry->addComboItem("Multiply");	
-	
-	baseProps->propHeight = 130;	
-	
-	shaderTextureSheet = new ShaderTexturesSheet();
-	propList->addPropSheet(shaderTextureSheet);			
-	shaderTextureSheet->addEventListener(this, Event::CHANGE_EVENT);
-		
-	shaderOptionsSheet = new ShaderOptionsSheet("SHADER OPTIONS", "shader_options");
-	propList->addPropSheet(shaderOptionsSheet);
-	shaderOptionsSheet->addEventListener(this, Event::CHANGE_EVENT);
-		
-	propList->updateProps();
-						
-	// TODO: Move the preview widget to its own class
-	
+MaterialPreviewBox::MaterialPreviewBox() : UIElement() {
+	currentMaterial = NULL;
 	previewScene = new Scene(true);	
 	
 	renderTexture = new SceneRenderTexture(previewScene, previewScene->getDefaultCamera(), 512, 512);
@@ -335,7 +420,7 @@ MaterialEditorPane::MaterialEditorPane() : UIElement() {
 	
 	previewBase = new ScreenEntity();
 	previewBase->processInputEvents = true;
-	previewBase->setPosition(400, 0);
+	previewBase->setPosition(0, 0);
 	addChild(previewBase);
 	
 	previewShape = new ScreenShape(ScreenShape::SHAPE_RECT, 256, 256);
@@ -347,11 +432,6 @@ MaterialEditorPane::MaterialEditorPane() : UIElement() {
 	previewShape->setStrokeWidth(1.0);
 	previewBase->addChild(previewShape);
 	
-	Config *conf = CoreServices::getInstance()->getConfig();	
-	String fontName = conf->getStringValue("Polycode", "uiDefaultFontName");
-	int fontSize = conf->getNumericValue("Polycode", "uiDefaultFontSize");	
-	Number padding = conf->getNumericValue("Polycode", "uiWindowSkinPadding");	
-	
 	shapeSelector = new ScreenImage("Images/small_selector.png");
 	previewBase->addChild(shapeSelector);
 	shapeSelector->color.a = 0.4;
@@ -366,9 +446,102 @@ MaterialEditorPane::MaterialEditorPane() : UIElement() {
 		shapeSwitches[i]->setPosition(105 + (25 * i), 300);
 		shapeSwitches[i]->addEventListener(this, UIEvent::CLICK_EVENT);
 	}
+
+	showPrimitive(0);
+}
+
+void MaterialPreviewBox::clearMaterial() {
+	previewPrimitive->clearMaterial();
+}
+
+MaterialPreviewBox::~MaterialPreviewBox() {
+
+}
+
+void MaterialPreviewBox::setMaterial(Material *material) {
+	currentMaterial = material;
+	previewPrimitive->setMaterial(material);	
+	
+}
+
+void MaterialPreviewBox::showPrimitive(unsigned int index) {
+	for(int i=0; i < shapePrimitives.size(); i++) {
+		shapePrimitives[i]->visible = false;	
+	}
+	shapePrimitives[index]->visible = true;	
+	shapeSelector->setPosition(105 - 2 + (25 * index), 298);
+	if(currentMaterial) {
+		shapePrimitives[index]->setMaterial(currentMaterial);
+	}
+	previewPrimitive = shapePrimitives[index];
+
+}
+
+void MaterialPreviewBox::handleEvent(Event *event) {
+	for(int i=0; i < shapeSwitches.size(); i++) {
+		if(event->getDispatcher() == shapeSwitches[i]) {
+			if(event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {
+				showPrimitive(i);
+			}
+		}
+	}
+}
+
+MaterialEditorPane::MaterialEditorPane() : UIElement() {	
+
+	changingMaterial = false;
+	
+	headerBg = new ScreenShape(ScreenShape::SHAPE_RECT,10,10);
+	addChild(headerBg);
+	headerBg->setPositionMode(ScreenEntity::POSITION_TOPLEFT);
+	headerBg->color.setColorHexFromString(CoreServices::getInstance()->getConfig()->getStringValue("Polycode", "uiHeaderBgColor"));	
+	
+	propList = new PropList("MATERIAL EDITOR");
+	addChild(propList);
+	propList->setPosition(0, 0);
+
+	PropSheet *baseProps = new PropSheet("MATERIAL SETTINGS", "");
+	propList->addPropSheet(baseProps);
+	
+	nameProp = new StringProp("Name");
+	baseProps->addProp(nameProp);	
+	nameProp->addEventListener(this, Event::CHANGE_EVENT);
+		
+	shaderProp = new ComboProp("Shader");
+	baseProps->addProp(shaderProp);
+	shaderProp->addEventListener(this, Event::CHANGE_EVENT);
+	
+	blendModeProp = new ComboProp("Blend mode");
+	baseProps->addProp(blendModeProp);
+	blendModeProp->addEventListener(this, Event::CHANGE_EVENT);
+		
+	blendModeProp->comboEntry->addComboItem("Normal");
+	blendModeProp->comboEntry->addComboItem("Lighten");
+	blendModeProp->comboEntry->addComboItem("Color");
+	blendModeProp->comboEntry->addComboItem("Premultiplied");
+	blendModeProp->comboEntry->addComboItem("Multiply");	
+	
+	baseProps->propHeight = 130;	
+	
+	shaderTextureSheet = new ShaderTexturesSheet();
+	propList->addPropSheet(shaderTextureSheet);			
+	shaderTextureSheet->addEventListener(this, Event::CHANGE_EVENT);
+		
+	shaderOptionsSheet = new ShaderOptionsSheet("SHADER OPTIONS", "shader_options");
+	propList->addPropSheet(shaderOptionsSheet);
+	shaderOptionsSheet->addEventListener(this, Event::CHANGE_EVENT);
+		
+	propList->updateProps();
+							
+	
+	materialPreview = new MaterialPreviewBox();
+	addChild(materialPreview);
+	materialPreview->setPosition(400, 0);
+	
+	Config *conf = CoreServices::getInstance()->getConfig();	
+	String fontName = conf->getStringValue("Polycode", "uiDefaultFontName");	
 				
 	currentMaterial = NULL;	
-	showPrimitive(0);
 	
 	reloadShaders();
 	
@@ -393,18 +566,6 @@ void MaterialEditorPane::Resize(Number width, Number height) {
 	propList->updateProps();
 }
 
-void MaterialEditorPane::showPrimitive(unsigned int index) {
-	for(int i=0; i < shapePrimitives.size(); i++) {
-		shapePrimitives[i]->visible = false;	
-	}
-	shapePrimitives[index]->visible = true;	
-	shapeSelector->setPosition(105 - 2 + (25 * index), 298);
-	if(currentMaterial) {
-		shapePrimitives[index]->setMaterial(currentMaterial);
-	}
-	previewPrimitive = shapePrimitives[index];
-}
-
 void MaterialEditorPane::handleEvent(Event *event) {
 
 	if(event->getDispatcher() == currentMaterial) {
@@ -432,11 +593,11 @@ void MaterialEditorPane::handleEvent(Event *event) {
 		if(selectedShader) {			
 			if(currentMaterial->getShader(0) != selectedShader) {
 				currentMaterial->clearShaders();
-				previewPrimitive->clearMaterial();
+				materialPreview->clearMaterial();
 				
 				ShaderBinding *newShaderBinding = selectedShader->createBinding();				
 				currentMaterial->addShader(selectedShader, newShaderBinding);
-				previewPrimitive->setMaterial(currentMaterial);					
+				materialPreview->setMaterial(currentMaterial);					
 			}
 			
 			shaderTextureSheet->setShader(selectedShader, currentMaterial);
@@ -447,14 +608,6 @@ void MaterialEditorPane::handleEvent(Event *event) {
 			dispatchEvent(new Event(), Event::CHANGE_EVENT);
 		}		
 	}
-	
-	for(int i=0; i < shapeSwitches.size(); i++) {
-		if(event->getDispatcher() == shapeSwitches[i]) {
-			if(event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {
-				showPrimitive(i);
-			}
-		}
-	}
 }
 
 void MaterialEditorPane::setMaterial(Material *material) {
@@ -465,7 +618,7 @@ void MaterialEditorPane::setMaterial(Material *material) {
 	}
 	
 	currentMaterial = material;
-	previewPrimitive->setMaterial(material);		
+	materialPreview->setMaterial(material);		
 	
 	material->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);
 	
@@ -507,9 +660,11 @@ MaterialMainWindow::MaterialMainWindow() : UIElement() {
 
 	materialPane = new MaterialEditorPane();
 	shaderPane = new ShaderEditorPane();
+	cubemapPane = new CubemapEditorPane();
 		
 	addChild(materialPane);
 	addChild(shaderPane);	
+	addChild(cubemapPane);
 	enableScissor = true;
 }
 	
@@ -518,6 +673,7 @@ void MaterialMainWindow::Resize(Number width, Number height) {
 	scissorBox.setRect(pos.x,pos.y,width, height);
 	materialPane->Resize(width, height);
 	shaderPane->Resize(width, height);
+	cubemapPane->Resize(width, height);	
 }
 
 MaterialBrowser::MaterialBrowser() : UIElement() {
@@ -528,8 +684,8 @@ MaterialBrowser::MaterialBrowser() : UIElement() {
 		
 	shadersNode = treeContainer->getRootNode()->addTreeChild("Images/shader_icon.png", "Shaders", NULL);
 	materialsNode = treeContainer->getRootNode()->addTreeChild("Images/material_icon.png", "Materials", NULL);
-	cubemapsNode = treeContainer->getRootNode()->addTreeChild("folder.png", "Cubemaps", NULL);
-	cubemapsNode = treeContainer->getRootNode()->addTreeChild("folder.png", "Post Effects", NULL);
+	cubemapsNode = treeContainer->getRootNode()->addTreeChild("Images/cubemap_icon.png", "Cubemaps", NULL);
+	postEffectsNode = treeContainer->getRootNode()->addTreeChild("folder.png", "Post Effects", NULL);
 				
 	addChild(treeContainer);		
 	selectedData = NULL;
@@ -545,7 +701,11 @@ MaterialBrowser::MaterialBrowser() : UIElement() {
 	
 	newMaterialButton = new UIImageButton("Images/new_material.png");
 	addChild(newMaterialButton);
-	newMaterialButton->setPosition(28,4);
+	newMaterialButton->setPosition(32,4);
+
+	newCubemapButton = new UIImageButton("Images/new_cubemap.png");
+	addChild(newCubemapButton);
+	newCubemapButton->setPosition(59,4);
 	
 	selectedNode = NULL;
 
@@ -579,6 +739,11 @@ UITree *MaterialBrowser::addShader(Shader *shader) {
 	return shadersNode->addTreeChild("shader_icon.png", shader->getName(), (void*)data);
 }
 
+UITree *MaterialBrowser::addCubemap(Cubemap *cubemap) {
+	MaterialBrowserData *data = new MaterialBrowserData();
+	data->cubemap = cubemap;
+	return cubemapsNode->addTreeChild("cubemap_icon.png", cubemap->getResourceName(), (void*)data);	
+}
 
 MaterialBrowser::~MaterialBrowser() {
 
@@ -615,6 +780,13 @@ bool PolycodeMaterialEditor::openFile(OSFileEntry filePath) {
 		materialBrowser->addShader(shaders[i]);
 		CoreServices::getInstance()->getMaterialManager()->addShader(shaders[i]);
 	}	
+
+	cubemaps = CoreServices::getInstance()->getMaterialManager()->loadCubemapsFromFile(filePath.fullPath);
+	for(int i=0; i < cubemaps.size(); i++) {
+		materialBrowser->addCubemap(cubemaps[i]);
+		CoreServices::getInstance()->getResourceManager()->addResource(cubemaps[i]);
+	}	
+
 	
 	materials = CoreServices::getInstance()->getMaterialManager()->loadMaterialsFromFile(filePath.fullPath);	
 	for(int i=0; i < materials.size(); i++) {
@@ -626,12 +798,14 @@ bool PolycodeMaterialEditor::openFile(OSFileEntry filePath) {
 	
 	mainWindow->materialPane->addEventListener(this, Event::CHANGE_EVENT);
 	mainWindow->shaderPane->addEventListener(this, Event::CHANGE_EVENT);
-	
+	mainWindow->cubemapPane->addEventListener(this, Event::CHANGE_EVENT);
+		
 	mainWindow->shaderPane->parentProject = parentProject;
 	
 	materialBrowser->newMaterialButton->addEventListener(this, UIEvent::CLICK_EVENT);
 	materialBrowser->newShaderButton->addEventListener(this, UIEvent::CLICK_EVENT);
-		
+	materialBrowser->newCubemapButton->addEventListener(this, UIEvent::CLICK_EVENT);
+			
 	mainWindow->materialPane->addEventListener(this, Event::CHANGE_EVENT);
 	
 	PolycodeEditor::openFile(filePath);
@@ -672,6 +846,20 @@ void PolycodeMaterialEditor::saveFile() {
 
 	Object fileData;
 	fileData.root.name = "polycode_material_library";
+
+	ObjectEntry *cubemapsEntry = fileData.root.addChild("cubemaps");
+	
+	for(int i=0; i < cubemaps.size(); i++) {
+		ObjectEntry *cubemapEntry = cubemapsEntry->addChild("cubemap");
+		cubemapEntry->addChild("name", cubemaps[i]->getResourceName());
+		
+		cubemapEntry->addChild("xPos", cubemaps[i]->getTexture(Cubemap::CUBEMAP_XPOS)->getResourcePath());
+		cubemapEntry->addChild("xNeg", cubemaps[i]->getTexture(Cubemap::CUBEMAP_XNEG)->getResourcePath());
+		cubemapEntry->addChild("yPos", cubemaps[i]->getTexture(Cubemap::CUBEMAP_YPOS)->getResourcePath());
+		cubemapEntry->addChild("yNeg", cubemaps[i]->getTexture(Cubemap::CUBEMAP_YNEG)->getResourcePath());
+		cubemapEntry->addChild("zPos", cubemaps[i]->getTexture(Cubemap::CUBEMAP_ZPOS)->getResourcePath());
+		cubemapEntry->addChild("zNeg", cubemaps[i]->getTexture(Cubemap::CUBEMAP_ZNEG)->getResourcePath());										
+	}
 	
 	ObjectEntry *materialsEntry = fileData.root.addChild("materials");
 	
@@ -736,6 +924,13 @@ void PolycodeMaterialEditor::handleEvent(Event *event) {
 		setHasChanges(true);
 	}
 
+	if(event->getDispatcher() == mainWindow->cubemapPane && event->getEventType() == "" && event->getEventCode() == Event::CHANGE_EVENT) {
+		if(selectedMaterialNode && mainWindow->cubemapPane->currentCubemap) {
+			selectedMaterialNode->setLabelText(mainWindow->cubemapPane->currentCubemap->getResourceName());
+		}
+		setHasChanges(true);
+	}
+
 		
 	if(event->getDispatcher() == materialBrowser->newMaterialButton && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {
 		Material *newMaterial = CoreServices::getInstance()->getMaterialManager()->createMaterial("Untitled", "DefaultShader");
@@ -755,6 +950,21 @@ void PolycodeMaterialEditor::handleEvent(Event *event) {
 				printf("Error creating shader!\n");
 			}
 	}	
+
+	if(event->getDispatcher() == materialBrowser->newCubemapButton && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {	
+		Cubemap *cubemap = CoreServices::getInstance()->getRenderer()->createCubemap(
+							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, "default.png"),
+							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, "default.png"),
+							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, "default.png"),
+							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, "default.png"),
+							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, "default.png"),
+							 (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, "default.png"));
+		cubemap->setResourceName("Cubemap"+String::IntToString(cubemaps.size()));
+		cubemaps.push_back(cubemap);
+		materialBrowser->addCubemap(cubemap);
+		setHasChanges(true);
+		CoreServices::getInstance()->getResourceManager()->addResource(cubemap);
+	}	
 		
 
 	if(event->getDispatcher() == materialBrowser) {
@@ -762,14 +972,19 @@ void PolycodeMaterialEditor::handleEvent(Event *event) {
 			if(materialBrowser->selectedData)  {
 				mainWindow->materialPane->enabled = false;
 				mainWindow->shaderPane->enabled = false;
-								
+				mainWindow->cubemapPane->enabled = false;
+												
 				if(materialBrowser->selectedData->material) {
 					selectedMaterialNode = materialBrowser->selectedNode;				
 					mainWindow->materialPane->setMaterial(materialBrowser->selectedData->material);					
 				} else if(materialBrowser->selectedData->shader) {
 					selectedMaterialNode = materialBrowser->selectedNode;				
 					mainWindow->shaderPane->setShader(materialBrowser->selectedData->shader);
+				} else if(materialBrowser->selectedData->cubemap) {
+					selectedMaterialNode = materialBrowser->selectedNode;				
+					mainWindow->cubemapPane->setCubemap(materialBrowser->selectedData->cubemap);
 				}
+
 			}			
 		}
 	}

IDE/Contents/Source/PolycodeProps.cpp

@@ -22,6 +22,7 @@
  
 #include "PolycodeProps.h"
 #include "PolycodeFrame.h"
+#include "PolyCubemap.h"
 
 extern UIColorPicker *globalColorPicker;
 extern PolycodeFrame *globalFrame;
@@ -1450,6 +1451,16 @@ void ShaderTexturesSheet::handleEvent(Event *event) {
 				dispatchEvent(new Event(), Event::CHANGE_EVENT);
 			}
 		}	
+		
+		for(int i=0; i < cubemapProps.size(); i++) {
+			if(event->getDispatcher() == cubemapProps[i]) {
+				binding->clearCubemap(cubemapProps[i]->label->getText());
+				Cubemap *cubemap = (Cubemap*)cubemapProps[i]->comboEntry->getSelectedItem()->data;
+				binding->addCubemap(cubemapProps[i]->label->getText(), cubemap);
+				dispatchEvent(new Event(), Event::CHANGE_EVENT);
+			}
+		}	
+		
 	}
 	PropSheet::handleEvent(event);
 }
@@ -1464,7 +1475,9 @@ void ShaderTexturesSheet::clearShader() {
 		props[i]->removeAllHandlersForListener(this);
 		delete props[i];
 	}
+	
 	props.clear();
+	cubemapProps.clear();
 	textureProps.clear();
 	
 	propHeight = 30;
@@ -1479,6 +1492,30 @@ void ShaderTexturesSheet::setShader(Shader *shader, Material *material) {
 		return;
 		
 	binding = material->getShaderBinding(0);	
+
+	for(int i=0; i < shader->expectedCubemaps.size(); i++) {
+		ComboProp *comboProp = new ComboProp(shader->expectedCubemaps[i]);
+		
+		std::vector<Resource*> cubemaps = CoreServices::getInstance()->getResourceManager()->getResources(Resource::RESOURCE_CUBEMAP);
+		
+		for(int j=0; j < cubemaps.size(); j++) {
+			comboProp->comboEntry->addComboItem(cubemaps[j]->getResourceName(), (void*) cubemaps[j]);
+			if(material) {
+				if(material->getShaderBinding(0)) {
+					Cubemap *currentCubemap = material->getShaderBinding(0)->getCubemap(shader->expectedCubemaps[i]);
+					if(currentCubemap) {
+						if(currentCubemap->getResourceName() == cubemaps[j]->getResourceName()) {
+							comboProp->set(j);
+						}
+					}
+				}
+			}
+		}
+				
+		addProp(comboProp);
+		cubemapProps.push_back(comboProp);
+		propHeight += 45;
+	}
 	
 	for(int i=0; i < shader->expectedTextures.size(); i++) {
 		TextureProp *textureProp = new TextureProp(shader->expectedTextures[i]);