diff --git a/Blocks3D.vcproj b/Blocks3D.vcproj
index 19a83f7..24c36f3 100644
--- a/Blocks3D.vcproj
+++ b/Blocks3D.vcproj
@@ -349,55 +349,271 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -554,50 +770,54 @@
+
+
diff --git a/src/include/Application.h b/src/include/Application.h
index b9529f9..78092cc 100644
--- a/src/include/Application.h
+++ b/src/include/Application.h
@@ -1,8 +1,8 @@
#pragma once
#include
#include "PropertyWindow.h"
-#include "DataModel/TextButtonInstance.h"
-#include "DataModel/ImageButtonInstance.h"
+#include "DataModelV2/TextButtonInstance.h"
+#include "DataModelV2/ImageButtonInstance.h"
#include "CameraController.h"
#include "IEBrowser.h"
#include "Mouse.h"
diff --git a/src/include/CameraController.h b/src/include/CameraController.h
index 162adb7..55db426 100644
--- a/src/include/CameraController.h
+++ b/src/include/CameraController.h
@@ -1,7 +1,7 @@
#pragma once
#include
-#include "DataModel/Instance.h"
+#include "DataModelV2/Instance.h"
#include "Globals.h"
#include
diff --git a/src/include/DataModelV2/BaseButtonInstance.h b/src/include/DataModelV2/BaseButtonInstance.h
new file mode 100644
index 0000000..cd24eb8
--- /dev/null
+++ b/src/include/DataModelV2/BaseButtonInstance.h
@@ -0,0 +1,26 @@
+#pragma once
+#include "Instance.h"
+#include "Listener/ButtonListener.h"
+
+class ButtonListener;
+class Instance;
+
+class BaseButtonInstance : public Instance
+{
+public:
+ BaseButtonInstance(void);
+ virtual ~BaseButtonInstance(void);
+ virtual void render(RenderDevice* rd);
+ virtual void drawObj(RenderDevice* rd, Vector2 mousePos, bool mouseDown);
+ virtual bool mouseInButton(float, float, RenderDevice* rd);
+ virtual void onMouseClick();
+ void setButtonListener(ButtonListener*);
+ bool floatBottom;
+ bool floatRight;
+ bool floatCenter;
+ volatile bool disabled;
+ bool selected;
+protected:
+ bool mouseInArea(float, float, float, float, float, float);
+ class ButtonListener* listener;
+};
diff --git a/src/include/DataModelV2/DataModelInstance.h b/src/include/DataModelV2/DataModelInstance.h
new file mode 100644
index 0000000..fb0d19a
--- /dev/null
+++ b/src/include/DataModelV2/DataModelInstance.h
@@ -0,0 +1,57 @@
+#pragma once
+#include "WorkspaceInstance.h"
+#include "LevelInstance.h"
+#include "PartInstance.h"
+#include "rapidxml/rapidxml.hpp"
+#include "GuiRootInstance.h"
+
+class GuiRootInstance;
+
+class DataModelInstance :
+ public Instance
+{
+public:
+ DataModelInstance(void);
+ ~DataModelInstance(void);
+ void setMessage(std::string);
+ void setMessageBrickCount();
+ void clearMessage();
+ bool debugGetOpen();
+ bool getOpen();
+ bool load(const char* filename,bool clearObjects);
+ bool readXMLFileStream(std::ifstream* file);
+ void drawMessage(RenderDevice*);
+ WorkspaceInstance* getWorkspace();
+ LevelInstance * getLevel();
+ std::string message;
+ std::string _loadedFileName;
+ bool showMessage;
+ G3D::GFontRef font;
+ GuiRootInstance* getGuiRoot();
+ //float mousex;
+ //float mousey;
+ //Vector2 getMousePos();
+ //void setMousePos(int x,int y);
+ //void setMousePos(Vector2 pos);
+ //bool mouseButton1Down;
+ PartInstance* makePart();
+ void clearLevel();
+ void toggleRun();
+ bool isRunning();
+#if _DEBUG
+ void modXMLLevel(float modY);
+#endif
+private:
+ bool isBrickCount;
+ bool scanXMLObject(rapidxml::xml_node<>* node);
+ rapidxml::xml_node<>* getNode(rapidxml::xml_node<> * node,const char* name );
+ float getFloatValue(rapidxml::xml_node<> * node,const char* name);
+ bool _successfulLoad;
+ std::string _errMsg;
+ bool _legacyLoad;
+ float _modY;
+ WorkspaceInstance* workspace;
+ LevelInstance * level;
+ GuiRootInstance* guiRoot;
+ bool running;
+};
diff --git a/src/include/DataModelV2/GroupInstance.h b/src/include/DataModelV2/GroupInstance.h
new file mode 100644
index 0000000..08baed3
--- /dev/null
+++ b/src/include/DataModelV2/GroupInstance.h
@@ -0,0 +1,16 @@
+#pragma once
+#include "PartInstance.h"
+
+class GroupInstance :
+ public PVInstance
+{
+public:
+ GroupInstance(void);
+ ~GroupInstance(void);
+ GroupInstance(const GroupInstance &oinst);
+ virtual std::vector getProperties();
+ virtual void PropUpdate(LPPROPGRIDITEM &pItem);
+ std::vector unGroup();
+ PartInstance * primaryPart;
+ void render(RenderDevice * r);
+};
diff --git a/src/include/DataModelV2/GuiRootInstance.h b/src/include/DataModelV2/GuiRootInstance.h
new file mode 100644
index 0000000..5f916d0
--- /dev/null
+++ b/src/include/DataModelV2/GuiRootInstance.h
@@ -0,0 +1,24 @@
+#pragma once
+#include "Instance.h"
+
+class ImageButtonInstance;
+
+class TextButtonInstance;
+
+class GuiRootInstance : public Instance
+{
+public:
+ GuiRootInstance();
+ GuiRootInstance::~GuiRootInstance();
+ TextButtonInstance* makeTextButton();
+ void drawButtons(RenderDevice* rd);
+ ImageButtonInstance* makeImageButton(G3D::TextureRef newImage, G3D::TextureRef overImage, G3D::TextureRef downImage, G3D::TextureRef disableImage);
+ void renderGUI(G3D::RenderDevice* rd, double fps);
+ void setDebugMessage(std::string msg, G3D::RealTime msgTime);
+ void update();
+ bool mouseInGUI(G3D::RenderDevice* renderDevice,int x,int y);
+ void onMouseLeftUp(G3D::RenderDevice* renderDevice, int x,int y);
+private:
+ std::string _message;
+ G3D::RealTime _messageTime;
+};
\ No newline at end of file
diff --git a/src/include/DataModelV2/ImageButtonInstance.h b/src/include/DataModelV2/ImageButtonInstance.h
new file mode 100644
index 0000000..9b1dfd8
--- /dev/null
+++ b/src/include/DataModelV2/ImageButtonInstance.h
@@ -0,0 +1,27 @@
+#pragma once
+#include "BaseButtonInstance.h"
+
+class BaseButtonInstance;
+
+class ImageButtonInstance : public BaseButtonInstance
+{
+public:
+ //ImageButtonInstance(G3D::TextureRef);
+ //ImageButtonInstance(G3D::TextureRef,G3D::TextureRef);
+ //ImageButtonInstance(G3D::TextureRef,G3D::TextureRef,G3D::TextureRef);
+ ImageButtonInstance(G3D::TextureRef,G3D::TextureRef,G3D::TextureRef,G3D::TextureRef);
+ ~ImageButtonInstance(void);
+ void drawObj(RenderDevice*, Vector2, bool);
+ Vector2 size;
+ Vector2 position;
+
+ G3D::TextureRef image;
+ int openGLID;
+ G3D::TextureRef image_ovr;
+ int openGLID_ovr;
+ G3D::TextureRef image_dn;
+ int openGLID_dn;
+ G3D::TextureRef image_ds;
+ int openGLID_ds;
+ bool mouseInButton(float, float, RenderDevice*);
+};
diff --git a/src/include/DataModelV2/Instance.h b/src/include/DataModelV2/Instance.h
index 0cd1f61..7e25dce 100644
--- a/src/include/DataModelV2/Instance.h
+++ b/src/include/DataModelV2/Instance.h
@@ -1,18 +1,37 @@
#pragma once
#include
+#include "propertyGrid.h"
+#include "map"
class Instance
{
public:
- static Instance* Instance::Create(std::string classname)
- {
-
- }
+ bool canDelete;
Instance(void);
- Instance(const Instance &);
- ~Instance(void);
- std::vector* getChildren();
+ Instance(const Instance&);
+ virtual ~Instance(void);
+ std::string name;
+ virtual void render(RenderDevice*);
+ virtual void update();
+ std::vector children; // All children.
+ std::string getClassName();
+ Instance* findFirstChild(std::string);
+ std::vector getChildren();
+ std::vector getAllChildren();
+ virtual void setParent(Instance*);
+ void setName(std::string newName);
+ void addChild(Instance*);
+ void removeChild(Instance*);
+ void clearChildren();
+ Instance* getParent();
+ virtual Instance* clone() const { return new Instance(*this); }
+ virtual std::vector getProperties();
+ virtual void PropUpdate(LPPROPGRIDITEM &pItem);
+ int listicon;
protected:
- std::vector children;
- Instance * parent;
-}
\ No newline at end of file
+ std::string className;
+ Instance* parent; // Another pointer.
+ PROPGRIDITEM createPGI(LPSTR catalog, LPSTR propName, LPSTR propDesc, LPARAM curVal, INT type, TCHAR choices[] = NULL);
+private:
+ static const std::map g_logLevelsDescriptions;
+};
diff --git a/src/include/DataModelV2/LevelInstance.h b/src/include/DataModelV2/LevelInstance.h
new file mode 100644
index 0000000..f29ca78
--- /dev/null
+++ b/src/include/DataModelV2/LevelInstance.h
@@ -0,0 +1,16 @@
+#pragma once
+#include "instance.h"
+
+class LevelInstance :
+ public Instance
+{
+public:
+ LevelInstance(void);
+ ~LevelInstance(void);
+ float timer;
+ int score;
+ virtual std::vector getProperties();
+ std::string winMessage;
+ std::string loseMessage;
+ virtual void PropUpdate(LPPROPGRIDITEM &pItem);
+};
diff --git a/src/include/DataModelV2/PVInstance.h b/src/include/DataModelV2/PVInstance.h
new file mode 100644
index 0000000..c22436f
--- /dev/null
+++ b/src/include/DataModelV2/PVInstance.h
@@ -0,0 +1,34 @@
+#pragma once
+#include "instance.h"
+#include "enum.h"
+
+class PVInstance :
+ public Instance
+{
+public:
+ PVInstance(void);
+ ~PVInstance(void);
+ PVInstance(const PVInstance &oinst);
+ virtual void postRender(RenderDevice* rd);
+ virtual std::vector getProperties();
+ virtual void PropUpdate(LPPROPGRIDITEM &pItem);
+ bool nameShown;
+ bool controllerFlagShown;
+ Enum::Controller::Value controller;
+protected:
+ static G3D::Color3 getControllerColor(int controller)
+ {
+ switch(controller)
+ {
+ case Enum::Controller::KeyboardLeft:
+ return Color3::red();
+ case Enum::Controller::KeyboardRight:
+ return Color3::blue();
+ case Enum::Controller::Chase:
+ return Color3::black();
+ case Enum::Controller::Flee:
+ return Color3::yellow();
+ }
+ return Color3::gray();
+ }
+};
diff --git a/src/include/DataModelV2/PartInstance.h b/src/include/DataModelV2/PartInstance.h
new file mode 100644
index 0000000..6df56b7
--- /dev/null
+++ b/src/include/DataModelV2/PartInstance.h
@@ -0,0 +1,85 @@
+#pragma once
+#include "PVInstance.h"
+#include "Enum.h"
+#define _USE_MATH_DEFINES
+#include
+
+#define NEW_BOX_RENDER
+
+class PartInstance : public PVInstance
+{
+public:
+
+ PartInstance(void);
+ PartInstance(const PartInstance &oinst);
+ Instance* clone() const { return new PartInstance(*this); }
+ virtual void PartInstance::postRender(RenderDevice* rd);
+ ~PartInstance(void);
+ virtual void render(RenderDevice*);
+ Enum::SurfaceType::Value top;
+ Enum::SurfaceType::Value front;
+ Enum::SurfaceType::Value right;
+ Enum::SurfaceType::Value back;
+ Enum::SurfaceType::Value left;
+ Enum::SurfaceType::Value bottom;
+ Enum::Shape::Value shape;
+ CoordinateFrame cFrame;
+ Color3 color;
+ Vector3 getPosition();
+ Vector3 getVelocity();
+ Vector3 getRotVelocity();
+ void setParent(Instance* parent);
+ void setPosition(Vector3);
+ void setVelocity(Vector3);
+ bool collides(PartInstance * part);
+ void setRotVelocity(Vector3);
+ CoordinateFrame getCFrame();
+ void setCFrame(CoordinateFrame);
+ Box getBox();
+ Sphere getSphere();
+ Box getScaledBox();
+ CoordinateFrame getCFrameRenderBased();
+ Vector3 getSize();
+ void setSize(Vector3);
+ void setShape(Enum::Shape::Value shape);
+ bool canCollide;
+ bool anchored;
+ bool collides(Box);
+ virtual std::vector getProperties();
+ virtual void PropUpdate(LPPROPGRIDITEM &pItem);
+ #ifdef NEW_BOX_RENDER
+ void addVertex(Vector3 vertexPos,Color3 color);
+ void addNormals(Vector3 normal);
+ void addSingularNormal(Vector3 normal);
+ void addTriangle(Vector3 vertexPos,Vector3 vertexPos2, Vector3 vertexPos3);
+ void addQuad(Vector3 v1,Vector3 v2, Vector3 v3, Vector3 v4);
+ void genSmoothNormals(int);
+ void addSmoothTriangle(Vector3 vertexPos,Vector3 vertexPos2, Vector3 vertexPos3);
+ void makeSmoothFace(int vertex1, int vertex2, int vertex3);
+ void addPlus(Vector3 v1);
+ void addPlus2(Vector3 v1);
+ void debugPrintVertexIDs(RenderDevice* rd, GFontRef font, Matrix3 camRot);
+ void makeFace(int vertex1, int vertex2, int vertex3);
+ void fromArrays(float verts[], float norms[], float ind[], unsigned int countVN, unsigned int countInd);
+ bool isUniqueVertex(Vector3 pos);
+ #endif
+private:
+ Vector3 position;
+ Vector3 size;
+ Vector3 velocity;
+ Vector3 rotVelocity;
+ float _bevelSize;
+ int _parseVert;
+ int _debugTimer;
+ std::vector _debugUniqueVertices;
+ #ifdef NEW_BOX_RENDER
+ std::vector _vertices;
+ std::vector _normals;
+ #else
+ GLfloat _vertices[96];
+ #endif
+ std::vector _indices;
+ bool changed;
+ Box itemBox;
+ GLuint glList;
+};
diff --git a/src/include/DataModelV2/TextButtonInstance.h b/src/include/DataModelV2/TextButtonInstance.h
new file mode 100644
index 0000000..cc53f7f
--- /dev/null
+++ b/src/include/DataModelV2/TextButtonInstance.h
@@ -0,0 +1,35 @@
+#pragma once
+#include "BaseButtonInstance.h"
+class TextButtonInstance : public BaseButtonInstance
+{
+public:
+ TextButtonInstance(void);
+ ~TextButtonInstance(void);
+ void setAllColorsSame();
+ Vector2 boxBegin;
+ Vector2 boxEnd;
+ Vector2 fontLocationRelativeTo;
+ Color4 textColor;
+ Color4 textOutlineColor;
+ Color4 boxColor;
+ Color4 boxOutlineColor;
+ Color4 textColorOvr;
+ Color4 textOutlineColorOvr;
+ Color4 boxColorOvr;
+ Color4 boxOutlineColorOvr;
+ Color4 textColorDn;
+ Color4 textOutlineColorDn;
+ Color4 boxColorDn;
+ Color4 boxOutlineColorDn;
+ Color4 textColorDis;
+ Color4 textOutlineColorDis;
+ Color4 boxColorDis;
+ Color4 boxOutlineColorDis;
+ bool centeredWithinBox;
+ std::string title;
+ G3D::GFontRef font;
+ bool visible;
+ int textSize;
+ void drawObj(RenderDevice*, Vector2, bool);
+ bool mouseInButton(float, float, RenderDevice*);
+};
\ No newline at end of file
diff --git a/src/include/DataModelV2/ToggleImageButtonInstance.h b/src/include/DataModelV2/ToggleImageButtonInstance.h
new file mode 100644
index 0000000..0e6f685
--- /dev/null
+++ b/src/include/DataModelV2/ToggleImageButtonInstance.h
@@ -0,0 +1,29 @@
+#pragma once
+#include "imagebuttoninstance.h"
+
+
+class ToggleImageButtonInstance : public ImageButtonInstance
+{
+public:
+ //ImageButtonInstance(G3D::TextureRef);
+ //ImageButtonInstance(G3D::TextureRef,G3D::TextureRef);
+ //ImageButtonInstance(G3D::TextureRef,G3D::TextureRef,G3D::TextureRef);
+ ToggleImageButtonInstance(G3D::TextureRef newImage,G3D::TextureRef overImage = NULL,
+ G3D::TextureRef downImage = NULL,
+ G3D::TextureRef disableImage = NULL,
+ G3D::TextureRef newImage2 = NULL,
+ G3D::TextureRef overImage2 = NULL,
+ G3D::TextureRef downImage2 = NULL,
+ G3D::TextureRef disableImage2 = NULL);
+ ~ToggleImageButtonInstance(void);
+ void drawObj(RenderDevice*, Vector2, bool);
+ bool checked;
+ G3D::TextureRef image2;
+ int openGLID2;
+ G3D::TextureRef image_ovr2;
+ int openGLID2_ovr;
+ G3D::TextureRef image_dn2;
+ int openGLID2_dn;
+ G3D::TextureRef image_ds2;
+ int openGLID2_ds;
+};
diff --git a/src/include/DataModelV2/WorkspaceInstance.h b/src/include/DataModelV2/WorkspaceInstance.h
new file mode 100644
index 0000000..c854d6d
--- /dev/null
+++ b/src/include/DataModelV2/WorkspaceInstance.h
@@ -0,0 +1,12 @@
+#pragma once
+#include "GroupInstance.h"
+#include "PartInstance.h"
+
+class WorkspaceInstance :
+ public GroupInstance
+{
+public:
+ WorkspaceInstance(void);
+ ~WorkspaceInstance(void);
+ std::vector partObjects;
+};
diff --git a/src/include/Globals.h b/src/include/Globals.h
index d8280c5..3e86d95 100644
--- a/src/include/Globals.h
+++ b/src/include/Globals.h
@@ -1,5 +1,5 @@
#pragma once
-#include "DataModel/DataModelInstance.h"
+#include "DataModelV2/DataModelInstance.h"
class Application;
diff --git a/src/include/Listener/ButtonListener.h b/src/include/Listener/ButtonListener.h
index 4ac7aa2..f94453a 100644
--- a/src/include/Listener/ButtonListener.h
+++ b/src/include/Listener/ButtonListener.h
@@ -1,6 +1,6 @@
#pragma once
//#include "Application.h"
-#include "DataModel/BaseButtonInstance.h"
+#include "DataModelV2/BaseButtonInstance.h"
class BaseButtonInstance;
diff --git a/src/include/Mouse.h b/src/include/Mouse.h
index 7ff08cf..70a348b 100644
--- a/src/include/Mouse.h
+++ b/src/include/Mouse.h
@@ -1,7 +1,7 @@
#pragma once
-#include "DataModel/PartInstance.h"
+#include "DataModelV2/PartInstance.h"
#pragma once
-#include "DataModel/WorkspaceInstance.h"
+#include "DataModelV2/WorkspaceInstance.h"
struct MousePoint{
Vector3 position;
diff --git a/src/include/PropertyWindow.h b/src/include/PropertyWindow.h
index 53c5862..a4285aa 100644
--- a/src/include/PropertyWindow.h
+++ b/src/include/PropertyWindow.h
@@ -1,5 +1,5 @@
#pragma once
-#include "DataModel/Instance.h"
+#include "DataModelV2/Instance.h"
class PropertyWindow {
public:
diff --git a/src/source/Application.cpp b/src/source/Application.cpp
index 7c598fd..09a6b3d 100644
--- a/src/source/Application.cpp
+++ b/src/source/Application.cpp
@@ -2,12 +2,12 @@
#include
#include
#include "resource.h"
-#include "DataModel/Instance.h"
-#include "DataModel/PartInstance.h"
-#include "DataModel/TextButtonInstance.h"
-#include "DataModel/ImageButtonInstance.h"
-#include "DataModel/DataModelInstance.h"
-#include "DataModel/GuiRootInstance.h"
+#include "DataModelV2/Instance.h"
+#include "DataModelV2/PartInstance.h"
+#include "DataModelV2/TextButtonInstance.h"
+#include "DataModelV2/ImageButtonInstance.h"
+#include "DataModelV2/DataModelInstance.h"
+#include "DataModelV2/GuiRootInstance.h"
#include "CameraController.h"
#include "AudioPlayer.h"
#include "Globals.h"
diff --git a/src/source/CameraController.cpp b/src/source/CameraController.cpp
index d8a4fdb..dc47011 100644
--- a/src/source/CameraController.cpp
+++ b/src/source/CameraController.cpp
@@ -1,7 +1,7 @@
#include "CameraController.h"
#include "win32Defines.h"
#include
-#include "DataModel/PartInstance.h"
+#include "DataModelV2/PartInstance.h"
#include "Application.h"
#include "AudioPlayer.h"
diff --git a/src/source/DataModelV2/BaseButtonInstance.cpp b/src/source/DataModelV2/BaseButtonInstance.cpp
new file mode 100644
index 0000000..e8e00e9
--- /dev/null
+++ b/src/source/DataModelV2/BaseButtonInstance.cpp
@@ -0,0 +1,62 @@
+#include "DataModelV2/BaseButtonInstance.h"
+#include "Globals.h"
+#include "Application.h"
+
+
+ButtonListener* listener = NULL;
+
+BaseButtonInstance::BaseButtonInstance(void)
+{
+ Instance::Instance();
+ listener = NULL;
+}
+
+void BaseButtonInstance::render(RenderDevice* rd)
+{
+ DataModelInstance* dataModel = g_dataModel;
+ Vector2 pos = Vector2(g_usableApp->mouse.x,g_usableApp->mouse.y);
+ drawObj(rd, pos, g_usableApp->mouse.isMouseDown());
+ Instance::render(rd);
+}
+
+BaseButtonInstance::~BaseButtonInstance(void)
+{
+ if(listener != NULL && listener->doDelete)
+ {
+ delete listener;
+ listener = NULL;
+ }
+}
+
+void BaseButtonInstance::setButtonListener(ButtonListener* buttonListener)
+{
+ listener = buttonListener;
+}
+
+void BaseButtonInstance::drawObj(RenderDevice* rd, Vector2 mousePos, bool mouseDown){}
+
+bool BaseButtonInstance::mouseInButton(float mousex, float mousey, RenderDevice* rd){return false;}
+
+void BaseButtonInstance::onMouseClick()
+{
+ if(listener != NULL)
+ {
+ listener->onButton1MouseClick(this);
+
+ }
+}
+
+
+bool BaseButtonInstance::mouseInArea(float point1x, float point1y, float point2x, float point2y, float mousex, float mousey)
+{
+
+
+ if(mousex >= point1x && mousey >= point1y)
+ {
+ if(mousex < point2x && mousey < point2y)
+ {
+ return true;
+ }
+ }
+ return false;
+}
\ No newline at end of file
diff --git a/src/source/DataModelV2/DataModelInstance.cpp b/src/source/DataModelV2/DataModelInstance.cpp
new file mode 100644
index 0000000..8316b85
--- /dev/null
+++ b/src/source/DataModelV2/DataModelInstance.cpp
@@ -0,0 +1,613 @@
+#include
+#include "DataModelV2/GuiRootInstance.h"
+#include "DataModelV2/DataModelInstance.h"
+#include
+#include
+#include
+#include
+#include "ErrorFunctions.h"
+
+using namespace std;
+using namespace rapidxml;
+
+
+DataModelInstance::DataModelInstance(void)
+{
+ Instance::Instance();
+ workspace = new WorkspaceInstance();
+ guiRoot = new GuiRootInstance();
+ level = new LevelInstance();
+ //children.push_back(workspace);
+ //children.push_back(level);
+ className = "dataModel";
+ //mousex = 0;
+ //mousey = 0;
+ //mouseButton1Down = false;
+ showMessage = false;
+ canDelete = false;
+ _modY=0;
+ workspace->setParent(this);
+ level->setParent(this);
+ _loadedFileName="..//skooter.rbxm";
+ listicon = 5;
+ running = false;
+
+}
+
+void DataModelInstance::toggleRun()
+{
+ running = !running;
+}
+bool DataModelInstance::isRunning()
+{
+ return running;
+}
+
+DataModelInstance::~DataModelInstance(void)
+{
+}
+
+#ifdef _DEBUG
+void DataModelInstance::modXMLLevel(float modY)
+{
+ _modY += modY;
+ clearLevel();
+ debugGetOpen();
+
+}
+#endif
+
+void DataModelInstance::clearLevel()
+{
+ workspace->clearChildren();
+}
+PartInstance* DataModelInstance::makePart()
+{
+ PartInstance* part = new PartInstance();
+ return part;
+}
+
+rapidxml::xml_node<>* DataModelInstance::getNode(xml_node<> * node,const char* name)
+{
+ xml_node<> * tempNode = node->first_node(name);
+ if (!tempNode)
+ {
+ _errMsg = "Expected <";
+ _errMsg += name;
+ _errMsg+="> tag.";
+ _successfulLoad=false;
+ return 0;
+ }
+ return tempNode;
+}
+float DataModelInstance::getFloatValue(xml_node<> * node,const char* name)
+{
+ xml_node<> * tempNode = node->first_node(name);
+ if (!tempNode)
+ {
+ _errMsg = "Expected <";
+ _errMsg += name;
+ _errMsg+="> tag.";
+ _successfulLoad=false;
+ return 0;
+ }
+ float newFloat;
+ stringstream converter;
+ converter << tempNode->value();
+ converter >> newFloat;
+ return newFloat;
+}
+
+
+Color3 bcToRGB(short bc)
+{
+ switch(bc)
+ {
+ case 1: return Color3(0.94901967048645F,0.95294123888016F,0.95294123888016F);
+ case 2: return Color3(0.63137257099152F,0.64705884456635F,0.63529413938522F);
+ case 3: return Color3(0.9764706492424F,0.91372555494308F,0.60000002384186F);
+ case 5: return Color3(0.84313732385635F,0.77254909276962F,0.60392159223557F);
+ case 6: return Color3(0.7607843875885F,0.85490202903748F,0.72156864404678F);
+ case 9: return Color3(0.90980398654938F,0.7294117808342F,0.78431379795074F);
+ case 11: return Color3(0.50196081399918F,0.73333334922791F,0.85882359743118F);
+ case 12: return Color3(0.79607850313187F,0.51764708757401F,0.258823543787F);
+ case 18: return Color3(0.80000007152557F,0.55686277151108F,0.41176474094391F);
+ case 21: return Color3(0.76862752437592F,0.15686275064945F,0.10980392992496F);
+ case 22: return Color3(0.76862752437592F,0.43921571969986F,0.62745100259781F);
+ case 23: return Color3(0.050980396568775F,0.41176474094391F,0.6745098233223F);
+ case 24: return Color3(0.96078437566757F,0.80392163991928F,0.18823531270027F);
+ case 25: return Color3(0.38431376218796F,0.27843138575554F,0.19607844948769F);
+ case 26: return Color3(0.10588236153126F,0.16470588743687F,0.20784315466881F);
+ case 27: return Color3(0.42745101451874F,0.43137258291245F,0.42352944612503F);
+ case 28: return Color3(0.15686275064945F,0.49803924560547F,0.27843138575554F);
+ case 29: return Color3(0.63137257099152F,0.76862752437592F,0.54901963472366F);
+ case 36: return Color3(0.95294123888016F,0.8117647767067F,0.60784316062927F);
+ case 37: return Color3(0.29411765933037F,0.59215688705444F,0.29411765933037F);
+ case 38: return Color3(0.62745100259781F,0.37254902720451F,0.20784315466881F);
+ case 39: return Color3(0.75686281919479F,0.79215693473816F,0.8705883026123F);
+ case 40: return Color3(0.92549026012421F,0.92549026012421F,0.92549026012421F);
+ case 41: return Color3(0.80392163991928F,0.32941177487373F,0.29411765933037F);
+ case 42: return Color3(0.75686281919479F,0.87450987100601F,0.94117653369904F);
+ case 43: return Color3(0.48235297203064F,0.71372550725937F,0.90980398654938F);
+ case 44: return Color3(0.96862751245499F,0.94509810209274F,0.55294120311737F);
+ case 45: return Color3(0.70588237047195F,0.82352948188782F,0.89411771297455F);
+ case 47: return Color3(0.85098046064377F,0.52156865596771F,0.42352944612503F);
+ case 48: return Color3(0.51764708757401F,0.71372550725937F,0.55294120311737F);
+ case 49: return Color3(0.97254908084869F,0.94509810209274F,0.51764708757401F);
+ case 50: return Color3(0.92549026012421F,0.90980398654938F,0.8705883026123F);
+ case 100: return Color3(0.93333339691162F,0.76862752437592F,0.71372550725937F);
+ case 101: return Color3(0.85490202903748F,0.52549022436142F,0.47843140363693F);
+ case 102: return Color3(0.43137258291245F,0.60000002384186F,0.79215693473816F);
+ case 103: return Color3(0.78039222955704F,0.75686281919479F,0.71764707565308F);
+ case 104: return Color3(0.41960787773132F,0.19607844948769F,0.48627454042435F);
+ case 105: return Color3(0.88627457618713F,0.60784316062927F,0.25098040699959F);
+ case 106: return Color3(0.85490202903748F,0.52156865596771F,0.2549019753933F);
+ case 107: return Color3(0,0.56078433990479F,0.61176472902298F);
+ case 108: return Color3(0.4078431725502F,0.36078432202339F,0.26274511218071F);
+ case 110: return Color3(0.26274511218071F,0.32941177487373F,0.57647061347961F);
+ case 111: return Color3(0.74901962280273F,0.71764707565308F,0.69411766529083F);
+ case 112: return Color3(0.4078431725502F,0.45490199327469F,0.6745098233223F);
+ case 113: return Color3(0.89411771297455F,0.678431391716F,0.78431379795074F);
+ case 115: return Color3(0.78039222955704F,0.82352948188782F,0.23529413342476F);
+ case 116: return Color3(0.33333334326744F,0.64705884456635F,0.68627452850342F);
+ case 118: return Color3(0.71764707565308F,0.84313732385635F,0.83529418706894F);
+ case 119: return Color3(0.64313727617264F,0.74117648601532F,0.27843138575554F);
+ case 120: return Color3(0.85098046064377F,0.89411771297455F,0.65490198135376F);
+ case 121: return Color3(0.90588241815567F,0.6745098233223F,0.34509804844856F);
+ case 123: return Color3(0.82745105028152F,0.43529415130615F,0.29803922772408F);
+ case 124: return Color3(0.57254904508591F,0.22352942824364F,0.47058826684952F);
+ case 125: return Color3(0.91764712333679F,0.72156864404678F,0.57254904508591F);
+ case 126: return Color3(0.64705884456635F,0.64705884456635F,0.79607850313187F);
+ case 127: return Color3(0.86274516582489F,0.73725491762161F,0.50588238239288F);
+ case 128: return Color3(0.68235296010971F,0.47843140363693F,0.34901961684227F);
+ case 131: return Color3(0.61176472902298F,0.63921570777893F,0.65882354974747F);
+ case 133: return Color3(0.83529418706894F,0.45098042488098F,0.23921570181847F);
+ case 134: return Color3(0.84705889225006F,0.8666667342186F,0.33725491166115F);
+ case 135: return Color3(0.45490199327469F,0.52549022436142F,0.61568629741669F);
+ case 136: return Color3(0.52941179275513F,0.48627454042435F,0.56470590829849F);
+ case 137: return Color3(0.87843143939972F,0.59607845544815F,0.39215689897537F);
+ case 138: return Color3(0.58431375026703F,0.54117649793625F,0.45098042488098F);
+ case 140: return Color3(0.12549020349979F,0.22745099663734F,0.33725491166115F);
+ case 141: return Color3(0.15294118225574F,0.27450981736183F,0.17647059261799F);
+ case 143: return Color3(0.8117647767067F,0.88627457618713F,0.96862751245499F);
+ case 145: return Color3(0.47450983524323F,0.53333336114883F,0.63137257099152F);
+ case 146: return Color3(0.58431375026703F,0.55686277151108F,0.63921570777893F);
+ case 147: return Color3(0.57647061347961F,0.52941179275513F,0.40392160415649F);
+ case 148: return Color3(0.34117648005486F,0.34509804844856F,0.34117648005486F);
+ case 149: return Color3(0.086274512112141F,0.11372549831867F,0.19607844948769F);
+ case 150: return Color3(0.67058825492859F,0.678431391716F,0.6745098233223F);
+ case 151: return Color3(0.47058826684952F,0.56470590829849F,0.50980395078659F);
+ case 153: return Color3(0.58431375026703F,0.47450983524323F,0.46666669845581F);
+ case 154: return Color3(0.48235297203064F,0.1803921610117F,0.1843137294054F);
+ case 157: return Color3(1,0.96470594406128F,0.48235297203064F);
+ case 158: return Color3(0.88235300779343F,0.64313727617264F,0.7607843875885F);
+ case 168: return Color3(0.4588235616684F,0.42352944612503F,0.38431376218796F);
+ case 176: return Color3(0.59215688705444F,0.41176474094391F,0.35686275362968F);
+ case 178: return Color3(0.70588237047195F,0.51764708757401F,0.33333334326744F);
+ case 179: return Color3(0.53725492954254F,0.52941179275513F,0.53333336114883F);
+ case 180: return Color3(0.84313732385635F,0.66274511814117F,0.29411765933037F);
+ case 190: return Color3(0.9764706492424F,0.83921575546265F,0.1803921610117F);
+ case 191: return Color3(0.90980398654938F,0.67058825492859F,0.17647059261799F);
+ case 192: return Color3(0.41176474094391F,0.25098040699959F,0.15686275064945F);
+ case 193: return Color3(0.8117647767067F,0.37647062540054F,0.14117647707462F);
+ case 195: return Color3(0.27450981736183F,0.40392160415649F,0.64313727617264F);
+ case 196: return Color3(0.13725490868092F,0.27843138575554F,0.54509806632996F);
+ case 198: return Color3(0.55686277151108F,0.258823543787F,0.52156865596771F);
+ case 199: return Color3(0.38823533058167F,0.37254902720451F,0.38431376218796F);
+ case 200: return Color3(0.50980395078659F,0.54117649793625F,0.3647058904171F);
+ case 208: return Color3(0.89803928136826F,0.89411771297455F,0.87450987100601F);
+ case 209: return Color3(0.69019609689713F,0.55686277151108F,0.26666668057442F);
+ case 210: return Color3(0.43921571969986F,0.58431375026703F,0.47058826684952F);
+ case 211: return Color3(0.47450983524323F,0.70980393886566F,0.70980393886566F);
+ case 212: return Color3(0.6235294342041F,0.76470595598221F,0.91372555494308F);
+ case 213: return Color3(0.42352944612503F,0.50588238239288F,0.71764707565308F);
+ case 216: return Color3(0.56078433990479F,0.29803922772408F,0.16470588743687F);
+ case 217: return Color3(0.48627454042435F,0.36078432202339F,0.27450981736183F);
+ case 218: return Color3(0.58823531866074F,0.43921571969986F,0.6235294342041F);
+ case 219: return Color3(0.41960787773132F,0.38431376218796F,0.60784316062927F);
+ case 220: return Color3(0.65490198135376F,0.66274511814117F,0.80784320831299F);
+ case 221: return Color3(0.80392163991928F,0.38431376218796F,0.59607845544815F);
+ case 222: return Color3(0.89411771297455F,0.678431391716F,0.78431379795074F);
+ case 223: return Color3(0.86274516582489F,0.56470590829849F,0.58431375026703F);
+ case 224: return Color3(0.94117653369904F,0.83529418706894F,0.62745100259781F);
+ case 225: return Color3(0.9215686917305F,0.72156864404678F,0.49803924560547F);
+ case 226: return Color3(0.99215692281723F,0.91764712333679F,0.55294120311737F);
+ case 232: return Color3(0.49019610881805F,0.73333334922791F,0.8666667342186F);
+ case 268: return Color3(0.2039215862751F,0.16862745583057F,0.4588235616684F);
+ case 1001: return Color3(0.97254908084869F,0.97254908084869F,0.97254908084869F);
+ case 1002: return Color3(0.80392163991928F,0.80392163991928F,0.80392163991928F);
+ case 1003: return Color3(0.066666670143604F,0.066666670143604F,0.066666670143604F);
+ case 1004: return Color3(1,0,0);
+ case 1005: return Color3(1,0.68627452850342F,0);
+ case 1006: return Color3(0.70588237047195F,0.50196081399918F,1);
+ case 1007: return Color3(0.63921570777893F,0.29411765933037F,0.29411765933037F);
+ case 1008: return Color3(0.75686281919479F,0.74509805440903F,0.258823543787F);
+ case 1009: return Color3(1,1,0);
+ case 1010: return Color3(0,0,1);
+ case 1011: return Color3(0,0.12549020349979F,0.37647062540054F);
+ case 1012: return Color3(0.1294117718935F,0.32941177487373F,0.72549021244049F);
+ case 1013: return Color3(0.015686275437474F,0.68627452850342F,0.92549026012421F);
+ case 1014: return Color3(0.66666668653488F,0.33333334326744F,0);
+ case 1015: return Color3(0.66666668653488F,0,0.66666668653488F);
+ case 1016: return Color3(1,0.40000003576279F,0.80000007152557F);
+ case 1017: return Color3(1,0.68627452850342F,0);
+ case 1018: return Color3(0.070588238537312F,0.93333339691162F,0.83137261867523F);
+ case 1019: return Color3(0,1,1);
+ case 1020: return Color3(0,1,0);
+ case 1021: return Color3(0.22745099663734F,0.49019610881805F,0.082352943718433F);
+ case 1022: return Color3(0.49803924560547F,0.55686277151108F,0.39215689897537F);
+ case 1023: return Color3(0.54901963472366F,0.35686275362968F,0.6235294342041F);
+ case 1024: return Color3(0.68627452850342F,0.8666667342186F,1);
+ case 1025: return Color3(1,0.78823536634445F,0.78823536634445F);
+ case 1026: return Color3(0.69411766529083F,0.65490198135376F,1);
+ case 1027: return Color3(0.6235294342041F,0.95294123888016F,0.91372555494308F);
+ case 1028: return Color3(0.80000007152557F,1,0.80000007152557F);
+ case 1029: return Color3(1,1,0.80000007152557F);
+ case 1030: return Color3(1,0.80000007152557F,0.60000002384186F);
+ case 1031: return Color3(0.38431376218796F,0.14509804546833F,0.81960791349411F);
+ case 1032: return Color3(1,0,0.74901962280273F);
+ default: return Color3::gray();
+ }
+}
+
+
+
+bool DataModelInstance::scanXMLObject(xml_node<> * scanNode)
+{
+ xml_node<> * watchFirstNode = scanNode->first_node();
+
+ for (xml_node<> *node = scanNode->first_node();node; node = node->next_sibling())
+ {
+
+ if (strncmp(node->name(),"Item",4)==0)
+ {
+ xml_attribute<> *classAttr = node->first_attribute("class");
+ std::string className = classAttr->value();
+ if (className=="Part") {
+ xml_node<> *propNode = node->first_node();
+ xml_node<> *cFrameNode=0;
+ xml_node<> *sizeNode=0;
+ xml_node<> *shapeNode=0;
+ xml_node<> *colorNode=0;
+ xml_node<> *brickColorNode=0;
+ xml_node<> *nameNode=0;
+
+ for (xml_node<> *partPropNode = propNode->first_node();partPropNode; partPropNode = partPropNode->next_sibling())
+ {
+ for (xml_attribute<> *attr = partPropNode->first_attribute();attr; attr = attr->next_attribute())
+ {
+ std::string xmlName = attr->name();
+ std::string xmlValue = attr->value();
+
+ if (xmlValue=="CFrame" | xmlValue=="CoordinateFrame")
+ {
+ cFrameNode = partPropNode;
+ }
+ if (xmlValue=="Name")
+ {
+ nameNode = partPropNode;
+ }
+ if (xmlValue=="shape")
+ {
+ shapeNode = partPropNode;
+ _legacyLoad=false;
+ }
+ if (xmlValue=="Color")
+ {
+ colorNode=partPropNode;
+ }
+ if (xmlValue=="BrickColor")
+ {
+ brickColorNode=partPropNode;
+ }
+ if (xmlValue=="size")
+ {
+ sizeNode = partPropNode;
+ _legacyLoad=false;
+ }
+ if (xmlValue=="Part")
+ {
+ for (xml_node<> *featureNode = partPropNode->first_node();featureNode; featureNode = featureNode->next_sibling())
+ {
+ for (xml_attribute<> *attr = featureNode->first_attribute();attr; attr = attr->next_attribute())
+ {
+ std::string xmlName = attr->name();
+ std::string xmlValue = attr->value();
+ if (xmlValue=="shape")
+ {
+ shapeNode = featureNode;
+ _legacyLoad=true;
+ }
+ if (xmlValue=="size")
+ {
+ sizeNode=featureNode;
+ _legacyLoad=true;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (!cFrameNode) {
+ _errMsg="CFrame is missing in Part";
+ return false;
+ }
+ if (!sizeNode) {
+ _errMsg="Size is missing in Part";
+ return false;
+ }
+
+ float R=1;
+ float G=1;
+ float B=1;
+
+ if (colorNode)
+ {
+ R = getFloatValue(colorNode,"R");
+ G = getFloatValue(colorNode,"G");
+ B = getFloatValue(colorNode,"B");
+ }
+
+ Enum::Shape::Value partshape = Enum::Shape::Block;
+ std::string pshape = shapeNode->value();
+ if (shapeNode)
+ {
+ if(pshape == "0" || pshape == "Ball"){
+ partshape = Enum::Shape::Ball;
+ }
+ if(pshape == "1" || pshape == "Block"){
+ partshape = Enum::Shape::Block;
+ }
+ if(pshape == "2" || pshape == "Cylinder"){
+ partshape = Enum::Shape::Cylinder;
+ }
+ }
+
+ std::string newName = nameNode->value();
+ float X = getFloatValue(cFrameNode,"X");
+ float Y = getFloatValue(cFrameNode,"Y");
+ float Z = getFloatValue(cFrameNode,"Z");
+ float R00 = getFloatValue(cFrameNode,"R00");
+ float R01 = getFloatValue(cFrameNode,"R01");
+ float R02 = getFloatValue(cFrameNode,"R02");
+ float R10 = getFloatValue(cFrameNode,"R10");
+ float R11 = getFloatValue(cFrameNode,"R11");
+ float R12 = getFloatValue(cFrameNode,"R12");
+ float R20 = getFloatValue(cFrameNode,"R20");
+ float R21 = getFloatValue(cFrameNode,"R21");
+ float R22 = getFloatValue(cFrameNode,"R22");
+
+ float sizeX = getFloatValue(sizeNode,"X");
+ float sizeY = getFloatValue(sizeNode,"Y");
+ float sizeZ = getFloatValue(sizeNode,"Z");
+ //sizeX=1;
+ //sizeY=1;
+ //sizeZ=1;
+ if (_successfulLoad) {
+ PartInstance* test = makePart();
+ test->setParent(getWorkspace());
+ test->color = Color3(R,G,B);
+ test->shape = partshape;
+ if(brickColorNode)
+ {
+ test->color = bcToRGB(atoi(brickColorNode->value()));
+ }
+ test->setSize(Vector3(sizeX,sizeY+_modY,sizeZ));
+ test->setName(newName);
+ CoordinateFrame cf;
+
+ if (_legacyLoad)
+ {
+
+ cf = CoordinateFrame(Vector3(-X,Y,Z))*CoordinateFrame(Vector3(-sizeX/2,(sizeY+_modY)/2,sizeZ/2)*Matrix3(R00,R01,R02,R10,R11,R12,R20,R21,R22));
+ cf.rotation = Matrix3(R00,R01,R02,R10,R11,R12,R20,R21,R22);
+ }
+ else
+ {
+ cf.translation = Vector3(X,Y,Z);
+ cf.rotation = Matrix3(R00,R01,R02,R10,R11,R12,R20,R21,R22);
+ }
+
+ test->setCFrame(cf);
+ }
+ else
+ {
+ return false;
+ }
+
+ }
+ }
+ /*
+ for (xml_attribute<> *attr = node->first_attribute();attr; attr = attr->next_attribute())
+ {
+ std::string xmlName = attr->name();
+ std::string xmlValue = attr->value();
+ }
+ */
+ scanXMLObject(node);
+ }
+
+ return true;
+}
+
+bool DataModelInstance::load(const char* filename, bool clearObjects)
+{
+ ifstream levelFile(filename,ios::binary);
+ if (levelFile)
+ {
+ if (clearObjects)
+ clearLevel();
+ readXMLFileStream(&levelFile);
+ std::string sfilename = std::string(filename);
+ std::size_t begin = sfilename.rfind('\\') + 1;
+ std::size_t end = sfilename.find(".rbx");
+ std::string hname = sfilename.substr(begin);
+ std::string tname = hname.substr(0, hname.length() - 5);
+ name = tname;
+ return true;
+ }
+ else
+ {
+ std::stringstream msg;
+ msg << "Failed to load file:" << std::endl << filename << std::endl << strerror(errno);
+ MessageBoxStr(msg.str());
+ return false;
+ }
+}
+
+bool DataModelInstance::readXMLFileStream(std::ifstream* file)
+{
+ file->seekg(0,file->end);
+ int length = file->tellg();
+ if (length<0)
+ {
+ MessageBoxStr("File is empty");
+ file->close();
+ return false;
+ }
+ file->seekg(0,file->beg);
+ char * buffer = new char[length+1];
+ buffer[length]=0;
+
+ file->read(buffer,length);
+ file->close();
+
+ if (!file)
+ {
+ stringstream msg;
+ msg << "Something went wrong." << endl << strerror(errno);
+ MessageBoxStr(msg.str());
+ return false;
+ }
+ _successfulLoad = true;
+ xml_document<> doc;
+ doc.parse<0>(buffer);
+ xml_node<> *mainNode = doc.first_node();
+ _legacyLoad=false;
+ //std::string xmlName = mainNode->name();
+ //node = node->first_node();
+ //xmlName = node->name();
+ scanXMLObject(mainNode);
+ delete[] buffer;
+ return true;
+}
+
+bool DataModelInstance::debugGetOpen()
+{
+ ifstream levelFile(_loadedFileName.c_str(),ios::binary);
+ if (levelFile)
+ readXMLFileStream(&levelFile);
+ else
+ getOpen();
+ return true;
+}
+
+bool DataModelInstance::getOpen()
+{
+ _modY=0;
+ OPENFILENAME of;
+ ZeroMemory( &of , sizeof( of));
+ of.lStructSize = sizeof(OPENFILENAME);
+ of.lpstrFilter = "Roblox Files\0*.rbxm;*.rbxl\0\0";
+ char szFile[512];
+ of.lpstrFile = szFile ;
+ of.lpstrFile[0]='\0';
+ of.nMaxFile=500;
+ of.lpstrTitle="Hello";
+ of.Flags = OFN_FILEMUSTEXIST;
+ ShowCursor(TRUE);
+ BOOL file = GetOpenFileName(&of);
+ if (file)
+ {
+ _loadedFileName = of.lpstrFile;
+ load(of.lpstrFile,true);
+ }
+ return true;
+}
+void DataModelInstance::setMessage(std::string msg)
+{
+ message = msg;
+ isBrickCount = false;
+ showMessage = true;
+}
+
+void DataModelInstance::clearMessage()
+{
+ showMessage = false;
+ isBrickCount = false;
+ message = "";
+}
+
+void DataModelInstance::setMessageBrickCount()
+{
+ isBrickCount = true;
+ showMessage = true;
+}
+
+void DataModelInstance::drawMessage(RenderDevice* rd)
+{
+ if(isBrickCount)
+ {
+ int brickCount = 0;
+ int instCount = 0;
+ std::vector inst = getAllChildren();
+ for(size_t i = 0; i < inst.size(); i++)
+ {
+ if(PartInstance* moveTo = dynamic_cast(inst.at(i)))
+ {
+ brickCount++;
+ }
+ else
+ {
+ instCount++;
+ }
+ }
+ char brkc[12];
+ sprintf_s(brkc, "%d", brickCount);
+ char instc[12];
+ sprintf_s(instc, "%d", instCount);
+ message = "Bricks: ";
+ message += brkc;
+ message += " Snaps: ";
+ message += instc;
+ }
+ if(showMessage && !font.isNull())
+ {
+ int x = rd->getWidth()/2;
+ int y = rd->getHeight()/2;
+ int width = rd->getWidth()/2 + 100;
+ int height = width / 3;
+ Draw::box(Box(Vector3(x-(width/2), y-(height/2), 0), Vector3(x+(width/2), y+(height/2), 0)), rd, Color4::fromARGB(0x55B2B2B2), Color3::fromARGB(0xB2B2B2));
+ font->draw2D(rd, message, Vector2(x,y), height/8, Color3::white(), Color4::clear(), GFont::XALIGN_CENTER, GFont::YALIGN_CENTER);
+ }
+}
+
+WorkspaceInstance* DataModelInstance::getWorkspace()
+{
+ return workspace;
+}
+/*Vector2 DataModelInstance::getMousePos()
+{
+ return Vector2(mousex,mousey);
+}
+void DataModelInstance::setMousePos(int x,int y)
+{
+ mousex=x;
+ mousey=y;
+}
+void DataModelInstance::setMousePos(Vector2 pos)
+{
+ mousex=pos.x;
+ mousey=pos.y;
+}*/
+GuiRootInstance* DataModelInstance::getGuiRoot()
+{
+ return guiRoot;
+}
+
+
+LevelInstance* DataModelInstance::getLevel()
+{
+ return level;
+}
\ No newline at end of file
diff --git a/src/source/DataModelV2/GroupInstance.cpp b/src/source/DataModelV2/GroupInstance.cpp
new file mode 100644
index 0000000..737e46a
--- /dev/null
+++ b/src/source/DataModelV2/GroupInstance.cpp
@@ -0,0 +1,77 @@
+#include "DataModelV2/GroupInstance.h"
+
+GroupInstance::GroupInstance(void)
+{
+ PVInstance::PVInstance();
+ name = "Model";
+ className = "GroupInstance";
+ listicon = 12;
+ primaryPart = NULL;
+}
+
+GroupInstance::GroupInstance(const GroupInstance &oinst)
+{
+ PVInstance::PVInstance(oinst);
+ name = "Model";
+ className = "GroupInstance";
+ listicon = 12;
+ primaryPart = NULL;
+}
+
+GroupInstance::~GroupInstance(void)
+{
+}
+
+std::vector GroupInstance::getProperties()
+{
+ std::vector properties = PVInstance::getProperties();
+ return properties;
+}
+void GroupInstance::PropUpdate(LPPROPGRIDITEM &pItem)
+{
+ PVInstance::PropUpdate(pItem);
+}
+
+std::vector GroupInstance::unGroup()
+{
+ std::vector child;
+ while(children.size() > 0)
+ {
+ child.push_back(children[0]);
+ children[0]->setParent(parent);
+ }
+ return child;
+}
+
+void GroupInstance::render(RenderDevice * rd)
+{
+ Instance::render(rd);
+ if(primaryPart != NULL && controllerFlagShown && getControllerColor(controller) != Color3::gray())
+ {
+ rd->disableLighting();
+ Vector3 vec = Vector3(0,0,0);
+ Vector3 up = Vector3(0,8,0);
+ rd->setColor(getControllerColor(controller));
+ rd->setObjectToWorldMatrix(primaryPart->cFrame);
+ rd->beforePrimitive();
+
+ glBegin(GL_LINES);
+ glVertex3f(vec.x, vec.y, vec.z);
+ glVertex3f(up.x, up.y, up.z);
+ glEnd();
+
+ glBegin( GL_TRIANGLES );
+ glVertex3f(up.x, up.y-2, up.z);
+ glVertex3f(up.x, up.y-1, up.z-2);
+ glVertex3f(up.x, up.y, up.z);
+
+ glVertex3f(up.x, up.y, up.z);
+ glVertex3f(up.x, up.y-1, up.z-2);
+ glVertex3f(up.x, up.y-2, up.z);
+
+ glEnd();
+ rd->afterPrimitive();
+ rd->setColor(Color3::white());
+ rd->enableLighting();
+ }
+}
\ No newline at end of file
diff --git a/src/source/DataModelV2/GuiRootInstance.cpp b/src/source/DataModelV2/GuiRootInstance.cpp
new file mode 100644
index 0000000..d6e9d8d
--- /dev/null
+++ b/src/source/DataModelV2/GuiRootInstance.cpp
@@ -0,0 +1,538 @@
+#include
+#include
+#include "G3DAll.h"
+#include "DataModelV2/BaseButtonInstance.h"
+#include "DataModelV2/TextButtonInstance.h"
+#include "DataModelV2/ImageButtonInstance.h"
+#include "DataModelV2/ToggleImageButtonInstance.h"
+#include "DataModelV2/GuiRootInstance.h"
+#include "DataModelV2/ImageButtonInstance.h"
+#include "Globals.h"
+#include "StringFunctions.h"
+
+#include "Listener/GUDButtonListener.h"
+#include "Listener/ModeSelectionListener.h"
+#include "Listener/MenuButtonListener.h"
+#include "Listener/RotateButtonListener.h"
+#include "Listener/CameraButtonListener.h"
+#include "Listener/DeleteListener.h"
+#include "Listener/ToolbarListener.h"
+
+
+ImageButtonInstance* GuiRootInstance::makeImageButton(G3D::TextureRef newImage = NULL, G3D::TextureRef overImage = NULL, G3D::TextureRef downImage = NULL, G3D::TextureRef disableImage = NULL)
+{
+ ImageButtonInstance* part = new ImageButtonInstance(newImage,overImage, downImage, disableImage);
+// instances.push_back(part);
+// instances_2D.push_back(part);
+ return part;
+}
+
+TextButtonInstance* GuiRootInstance::makeTextButton()
+{
+ TextButtonInstance* part = new TextButtonInstance();
+ return part;
+}
+ToolbarListener * toolbar;
+GuiRootInstance::GuiRootInstance() : _message(""), _messageTime(0)
+{
+ toolbar = new ToolbarListener();
+ toolbar->doDelete = false;
+ g_fntdominant = GFont::fromFile(GetFileInPath("/content/font/dominant.fnt"));
+ g_fntlighttrek = GFont::fromFile(GetFileInPath("/content/font/lighttrek.fnt"));
+
+ //Bottom Left
+ TextButtonInstance* button = makeTextButton();
+ button->boxBegin = Vector2(0, -24);
+ button->boxEnd = Vector2(80, 0);
+ button->floatBottom = true;
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3(0,255,255);
+ button->textOutlineColor = Color4::clear();
+ button->title = "Hopper";
+ button->fontLocationRelativeTo = Vector2(10, 3);
+ button->setAllColorsSame();
+ button->boxOutlineColorOvr = Color3(0,255,255);
+ button->boxColorDn = Color4(button->boxColor.r,button->boxColor.g,button->boxColor.b, 0.2F);
+ button->setButtonListener(toolbar);
+ toolbar->addButtonRef(button);
+
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(0, -48);
+ button->boxEnd = Vector2(80, -24);
+ button->floatBottom = true;
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3(0,255,255);
+ button->textOutlineColor = Color4::clear();
+ button->title = "Controller";
+ button->fontLocationRelativeTo = Vector2(10, 3);
+ button->setAllColorsSame();
+ button->boxOutlineColorOvr = Color3(0,255,255);
+ button->boxColorDn = Color4(button->boxColor.r,button->boxColor.g,button->boxColor.b, 0.2F);
+ button->setButtonListener(toolbar);
+ toolbar->addButtonRef(button);
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(0, -72);
+ button->boxEnd = Vector2(80, -48);
+ button->floatBottom = true;
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3(0,255,255);
+ button->textOutlineColor = Color4::clear();
+ button->title = "Color";
+ button->fontLocationRelativeTo = Vector2(10, 3);
+ button->setAllColorsSame();
+ button->boxOutlineColorOvr = Color3(0,255,255);
+ button->boxColorDn = Color4(button->boxColor.r,button->boxColor.g,button->boxColor.b, 0.2F);
+ button->setButtonListener(toolbar);
+ toolbar->addButtonRef(button);
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(0, -96);
+ button->boxEnd = Vector2(80, -72);
+ button->floatBottom = true;
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3(0,255,255);
+ button->textOutlineColor = Color4::clear();
+ button->title = "Surface";
+ button->fontLocationRelativeTo = Vector2(10, 3);
+ button->setAllColorsSame();
+ button->boxOutlineColorOvr = Color3(0,255,255);
+ button->boxColorDn = Color4(button->boxColor.r,button->boxColor.g,button->boxColor.b, 0.2F);
+ button->setButtonListener(toolbar);
+ toolbar->addButtonRef(button);
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(0, -120);
+ button->boxEnd = Vector2(80, -96);
+ button->floatBottom = true;
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3(0,255,255);
+ button->title = "Model";
+ button->selected = true;
+ button->fontLocationRelativeTo = Vector2(10, 3);
+ button->setAllColorsSame();
+ button->boxOutlineColorOvr = Color3(0,255,255);
+ button->boxColorDn = Color4(button->boxColor.r,button->boxColor.g,button->boxColor.b, 0.2F);
+ button->setButtonListener(toolbar);
+ toolbar->addButtonRef(button);
+
+ //Top bar
+ button = makeTextButton();
+ button->boxBegin = Vector2(0, 0);
+ button->boxEnd = Vector2(125, 25);
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3::white();
+ button->boxColor = Color4::clear();
+ button->textOutlineColor = Color4(0.5F,0.5F,0.5F,0.5F);
+ button->title = "File";
+ button->textSize = 16;
+ button->fontLocationRelativeTo = Vector2(10, 0);
+ button->setAllColorsSame();
+ button->boxColorOvr = Color4(0.6F,0.6F,0.6F,0.4F);
+ button->name = "file";
+ button->setButtonListener(new MenuButtonListener());
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(125, 0);
+ button->boxEnd = Vector2(250, 25);
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3::white();
+ button->boxColor = Color4::clear();
+ button->textOutlineColor = Color4(0.5F,0.5F,0.5F,0.5F);
+ button->title = "Edit";
+ button->textSize = 16;
+ button->fontLocationRelativeTo = Vector2(10, 0);
+ button->setAllColorsSame();
+ button->boxColorOvr = Color4(0.6F,0.6F,0.6F,0.4F);
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(250, 0);
+ button->boxEnd = Vector2(375, 25);
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3::white();
+ button->boxColor = Color4::clear();
+ button->textOutlineColor = Color4(0.5F,0.5F,0.5F,0.5F);
+ button->title = "View";
+ button->textSize = 16;
+ button->fontLocationRelativeTo = Vector2(10, 0);
+ button->setAllColorsSame();
+ button->boxColorOvr = Color4(0.6F,0.6F,0.6F,0.4F);
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(375, 0);
+ button->boxEnd = Vector2(500, 25);
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3::white();
+ button->boxColor = Color4::clear();
+ button->textOutlineColor = Color4(0.5F,0.5F,0.5F,0.5F);
+ button->title = "Insert";
+ button->textSize = 16;
+ button->fontLocationRelativeTo = Vector2(10, 0);
+ button->setAllColorsSame();
+ button->boxColorOvr = Color4(0.6F,0.6F,0.6F,0.4F);
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(500, 0);
+ button->boxEnd = Vector2(625, 25);
+ button->setParent(this);
+ button->font = g_fntlighttrek;
+ button->textColor = Color3::white();
+ button->boxColor = Color4::clear();
+ button->textOutlineColor = Color4(0.5F,0.5F,0.5F,0.5F);
+ button->title = "Format";
+ button->textSize = 16;
+ button->fontLocationRelativeTo = Vector2(10, 0);
+ button->setAllColorsSame();
+ button->boxColorOvr = Color4(0.6F,0.6F,0.6F,0.4F);
+
+
+ //Menu
+ button = makeTextButton();
+ button->boxBegin = Vector2(0,215);
+ button->boxEnd = Vector2(80,235);
+ button->textOutlineColor = Color4(0.5F,0.5F,0.5F,0.5F);
+ button->textColor = Color3::white();
+ button->boxColor = Color4::clear();
+ button->textSize = 12;
+ button->title = "Group";
+ button->name = "Group";
+ button->setAllColorsSame();
+ button->textColorDis = Color3(0.8F,0.8F,0.8F);
+ button->font = g_fntlighttrek;
+ button->fontLocationRelativeTo = Vector2(10, 0);
+ button->setParent(this);
+ button->setButtonListener(new GUDButtonListener());
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(0,240);
+ button->boxEnd = Vector2(80,260);
+ button->textOutlineColor = Color4(0.5F,0.5F,0.5F,0.5F);
+ button->textColor = Color3::white();
+ button->boxColor = Color4::clear();
+ button->textSize = 12;
+ button->title = "UnGroup";
+ button->name = "UnGroup";
+ button->setAllColorsSame();
+ button->textColorDis = Color3(0.8F,0.8F,0.8F);
+ button->font = g_fntlighttrek;
+ button->fontLocationRelativeTo = Vector2(10, 0);
+ button->setParent(this);
+ button->setButtonListener(new GUDButtonListener());
+
+ button = makeTextButton();
+ button->boxBegin = Vector2(0,265);
+ button->boxEnd = Vector2(80,285);
+ button->textOutlineColor = Color4(0.5F,0.5F,0.5F,0.5F);
+ button->textColor = Color3::white();
+ button->boxColor = Color4::clear();
+ button->textSize = 12;
+ button->title = "Duplicate";
+ button->setAllColorsSame();
+ button->textColorDis = Color3(0.8F,0.8F,0.8F);
+ button->font = g_fntlighttrek;
+ button->fontLocationRelativeTo = Vector2(10, 0);
+ button->setParent(this);
+ button->name = "Duplicate";
+ button->setButtonListener(new GUDButtonListener());
+
+ ImageButtonInstance* instance = new ToggleImageButtonInstance(
+ Texture::fromFile(GetFileInPath("/content/images/Run.png")),
+ Texture::fromFile(GetFileInPath("/content/images/Run_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/Run_dn.png")),
+ NULL,
+ Texture::fromFile(GetFileInPath("/content/images/Stop.png")),
+ Texture::fromFile(GetFileInPath("/content/images/Stop_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/Stop_dn.png"))
+ );
+ instance->setButtonListener(new MenuButtonListener());
+ instance->name = "go";
+ instance->size = Vector2(65,65);
+ instance->position = Vector2(6.5, 25);
+ instance->setParent(this);
+
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/ArrowTool.png")),
+ Texture::fromFile(GetFileInPath("/content/images/ArrowTool_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/ArrowTool_dn.png")),
+ Texture::fromFile(GetFileInPath("/content/images/ArrowTool_ds.png")));
+ instance->size = Vector2(50,50);
+ instance->position = Vector2(15, 90);
+ instance->setParent(this);
+ instance->name = "Cursor";
+ instance->setButtonListener(new ModeSelectionListener());
+
+ instance = makeImageButton(Texture::fromFile(GetFileInPath("/content/images/ScaleTool.png")),Texture::fromFile(GetFileInPath("/content/images/ScaleTool_ovr.png")),Texture::fromFile(GetFileInPath("/content/images/ScaleTool_dn.png")),Texture::fromFile(GetFileInPath("/content/images/ScaleTool_ds.png")));
+ instance->size = Vector2(40,40);
+ instance->position = Vector2(0, 140);
+ instance->setParent(this);
+ instance->name = "Resize";
+ instance->setButtonListener(new ModeSelectionListener());
+
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/MoveTool.png")),
+ Texture::fromFile(GetFileInPath("/content/images/MoveTool_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/MoveTool_dn.png")),
+ Texture::fromFile(GetFileInPath("/content/images/MoveTool_ds.png")));
+ instance->size = Vector2(40,40);
+ instance->position = Vector2(40, 140);
+ instance->setParent(this);
+ instance->name = "Arrows";
+ instance->setButtonListener(new ModeSelectionListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/SelectionRotate.png")),
+ Texture::fromFile(GetFileInPath("/content/images/SelectionRotate_ovr.png")),
+ NULL,
+ Texture::fromFile(GetFileInPath("/content/images/SelectionRotate_ds.png")));
+ instance->size = Vector2(30,30);
+ instance->position = Vector2(10, 175);
+ instance->setParent(this);
+ instance->name = "Rotate";
+ instance->setButtonListener(new RotateButtonListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/SelectionTilt.png")),
+ Texture::fromFile(GetFileInPath("/content/images/SelectionTilt_ovr.png")),
+ NULL,
+ Texture::fromFile(GetFileInPath("/content/images/SelectionTilt_ds.png")));
+ instance->size = Vector2(30,30);
+ instance->position = Vector2(40, 175);
+ instance->setParent(this);
+ instance->name = "Tilt";
+ instance->setButtonListener(new RotateButtonListener());
+
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/Delete.png")),
+ Texture::fromFile(GetFileInPath("/content/images/Delete_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/Delete_dn.png")),
+ Texture::fromFile(GetFileInPath("/content/images/Delete_ds.png")));
+ instance->size = Vector2(40,46);
+ instance->position = Vector2(20, 284);
+ instance->setParent(this);
+ instance->name = "Delete";
+ instance->setButtonListener(new DeleteListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/CameraZoomIn.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraZoomIn_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraZoomIn_dn.png")));
+ instance->size = Vector2(34,25);
+ instance->floatBottom = true;
+ instance->floatRight = true;
+ instance->position = Vector2(-77, -90);
+ instance->setParent(this);
+ instance->name = "ZoomIn";
+ instance->setButtonListener(new CameraButtonListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/CameraZoomOut.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraZoomOut_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraZoomOut_dn.png")));
+ instance->size = Vector2(34,26);
+ instance->floatBottom = true;
+ instance->floatRight = true;
+ instance->position = Vector2(-77, -31);
+ instance->setParent(this);
+ instance->name = "ZoomOut";
+ instance->setButtonListener(new CameraButtonListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/CameraPanLeft.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraPanLeft_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraPanLeft_dn.png")));
+ instance->size = Vector2(34,34);
+ instance->floatBottom = true;
+ instance->floatRight = true;
+ instance->position = Vector2(-110, -50);
+ instance->setParent(this);
+ instance->name = "PanLeft";
+ instance->setButtonListener(new CameraButtonListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/CameraPanRight.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraPanRight_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraPanRight_dn.png")));
+ instance->size = Vector2(34,34);
+ instance->floatBottom = true;
+ instance->floatRight = true;
+ instance->position = Vector2(-45, -50);
+ instance->setParent(this);
+ instance->name = "PanRight";
+ instance->setButtonListener(new CameraButtonListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/CameraCenter.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraCenter_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraCenter_dn.png")));
+ instance->size = Vector2(34,20);
+ instance->floatBottom = true;
+ instance->floatRight = true;
+ instance->position = Vector2(-77, -60);
+ instance->setParent(this);
+ instance->name = "CenterCam";
+ instance->setButtonListener(new CameraButtonListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/CameraTiltUp.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraTiltUp_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraTiltUp_dn.png")));
+ instance->size = Vector2(24,24);
+ instance->floatBottom = true;
+ instance->floatRight = true;
+ instance->position = Vector2(-105, -75);
+ instance->setParent(this);
+ instance->name = "TiltUp";
+ instance->setButtonListener(new CameraButtonListener());
+
+ instance = makeImageButton(
+ Texture::fromFile(GetFileInPath("/content/images/CameraTiltDown.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraTiltDown_ovr.png")),
+ Texture::fromFile(GetFileInPath("/content/images/CameraTiltDown_dn.png")));
+ instance->size = Vector2(24,24);
+ instance->floatBottom = true;
+ instance->floatRight = true;
+ instance->position = Vector2(-40, -75);
+ instance->setParent(this);
+ instance->name = "TiltDown";
+ instance->setButtonListener(new CameraButtonListener());
+}
+
+
+void GuiRootInstance::drawButtons(RenderDevice* rd)
+{
+ rd->pushState();
+ rd->beforePrimitive();
+ //this->render(rd);
+ rd->afterPrimitive();
+ rd->popState();
+}
+
+void GuiRootInstance::setDebugMessage(std::string msg, G3D::RealTime msgTime)
+{
+ _messageTime = msgTime;
+ _message = msg;
+}
+
+//void GuiRootInstance::render(G3D::RenderDevice* renderDevice) {}
+
+void GuiRootInstance::renderGUI(G3D::RenderDevice* rd, double fps)
+{
+ //TODO--Move these to their own instance
+
+ std::stringstream stream;
+ stream << std::fixed << std::setprecision(1) << g_dataModel->getLevel()->timer;
+ g_fntdominant->draw2D(rd, "Timer: " + stream.str(), Vector2(rd->getWidth() - 120, 25), 20, Color3::fromARGB(0x81C518), Color3::black());
+ g_fntdominant->draw2D(rd, "Score: " + Convert(g_dataModel->getLevel()->score), Vector2(rd->getWidth() - 120, 50), 20, Color3::fromARGB(0x81C518), Color3::black());
+ //FPS
+#ifdef _DEBUG
+ stream.str("");
+ stream.clear();
+ stream << std::fixed << std::setprecision(3) << fps;
+ g_fntdominant->draw2D(rd, "FPS: " + stream.str(), Vector2(120, 25), 10, Color3::fromARGB(0xFFFF00), Color3::black());
+#endif
+ //GUI Boxes
+ Draw::box(G3D::Box(Vector3(0,25,0),Vector3(80,355,0)),rd,Color4(0.6F,0.6F,0.6F,0.4F), Color4(0,0,0,0));
+ Draw::box(G3D::Box(Vector3(rd->getWidth() - 120,rd->getHeight() - 117,0),Vector3(rd->getWidth(),rd->getHeight(),0)),rd,Color4(0.6F,0.6F,0.6F,0.4F), Color4(0,0,0,0));
+
+ //Camera menu title
+ g_fntlighttrek->draw2D(rd, "CameraMenu", Vector2(rd->getWidth()-(g_fntlighttrek->get2DStringBounds("CameraMenu", 14).x+1),rd->getHeight() - 120), 14, Color3::white(), Color4(0.5F,0.5F,0.5F,0.5F));
+
+ //Tools menu
+ Draw::box(G3D::Box(Vector3(5, 210,0),Vector3(75, 210,0)),rd,Color4(0.6F,0.6F,0.6F,0.4F), Color4(0.6F,0.6F,0.6F,0.4F));
+ g_fntlighttrek->draw2D(rd,"MENU", Vector2(10,332), 14, Color3::white(), Color4(0.5F,0.5F,0.5F,0.5F));
+
+
+ //drawButtons(rd);
+ if(System::time() - 3 < _messageTime)
+ {
+ g_fntdominant->draw2D(rd, _message, Vector2((rd->getWidth()/2)-(g_fntdominant->get2DStringBounds(_message, 20).x/2),(rd->getHeight()/2)-(g_fntdominant->get2DStringBounds(_message, 20).y/2)), 20, Color3::yellow(), Color3::black());
+ }
+
+ g_dataModel->drawMessage(rd);
+ render(rd);
+}
+
+bool GuiRootInstance::mouseInGUI(G3D::RenderDevice* renderDevice,int x,int y)
+{
+ std::vector instances_2D = g_dataModel->getGuiRoot()->getAllChildren();
+ for(size_t i = 0; i < instances_2D.size(); i++)
+ {
+ if(BaseButtonInstance* button = dynamic_cast(instances_2D.at(i)))
+ {
+ if(button->mouseInButton(x,y, renderDevice))
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+void GuiRootInstance::update()
+{
+ Instance * obj6 = this->findFirstChild("Delete");
+ Instance * obj = this->findFirstChild("Duplicate");
+ Instance * obj2 = this->findFirstChild("Group");
+ Instance * obj3 = this->findFirstChild("UnGroup");
+ Instance * obj4 = this->findFirstChild("Rotate");
+ Instance * obj5 = this->findFirstChild("Tilt");
+ if(obj != NULL && obj2 != NULL && obj3 != NULL && obj4 !=NULL && obj5 != NULL && obj6 != NULL)
+ {
+ BaseButtonInstance* button = (BaseButtonInstance*)obj;
+ BaseButtonInstance* button2 = (BaseButtonInstance*)obj2;
+ BaseButtonInstance* button3 = (BaseButtonInstance*)obj3;
+ BaseButtonInstance* button4 = (BaseButtonInstance*)obj4;
+ BaseButtonInstance* button5 = (BaseButtonInstance*)obj5;
+ BaseButtonInstance* button6 = (BaseButtonInstance*)obj6;
+ button->disabled = true;
+ button2->disabled = true;
+ button3->disabled = true;
+ button4->disabled = true;
+ button5->disabled = true;
+ button6->disabled = true;
+ for(size_t i = 0; i < g_selectedInstances.size(); i++)
+ if(g_selectedInstances.at(i)->canDelete)
+ {
+ button->disabled = false;
+ button2->disabled = false;
+ button3->disabled = false;
+ button4->disabled = false;
+ button5->disabled = false;
+ button6->disabled = false;
+ break;
+ }
+ }
+}
+
+GuiRootInstance::~GuiRootInstance()
+{
+ delete toolbar;
+}
+
+void GuiRootInstance::onMouseLeftUp(G3D::RenderDevice* renderDevice, int x,int y)
+{
+ std::vector instances_2D = this->getAllChildren();
+ for(size_t i = 0; i < instances_2D.size(); i++)
+ {
+ if(BaseButtonInstance* button = dynamic_cast(instances_2D[i]))
+ {
+ if(button->mouseInButton(x, y, renderDevice))
+ {
+ button->onMouseClick();
+ }
+ }
+ }
+}
diff --git a/src/source/DataModelV2/ImageButtonInstance.cpp b/src/source/DataModelV2/ImageButtonInstance.cpp
new file mode 100644
index 0000000..bcf8218
--- /dev/null
+++ b/src/source/DataModelV2/ImageButtonInstance.cpp
@@ -0,0 +1,133 @@
+#include "DataModelV2/ImageButtonInstance.h"
+
+ImageButtonInstance::ImageButtonInstance(G3D::TextureRef newImage, G3D::TextureRef overImage = NULL, G3D::TextureRef downImage = NULL, G3D::TextureRef disableImage = NULL)
+{
+ BaseButtonInstance::BaseButtonInstance();
+ image = newImage;
+ openGLID = image->getOpenGLID();
+ image_ovr = overImage;
+ if(!image_ovr.isNull())
+ openGLID_ovr = image_ovr->getOpenGLID();
+ image_dn = downImage;
+ if(!image_dn.isNull())
+ openGLID_dn = image_dn->getOpenGLID();
+ image_ds = disableImage;
+ if(!image_ds.isNull())
+ openGLID_ds = image_ds->getOpenGLID();
+ Vector2 size = Vector2(0,0);
+ Vector2 position = Vector2(0,0);
+ floatCenter = false;
+ floatBottom = false;
+ floatRight = false;
+ disabled = false;
+ className = "ImageButton";
+}
+
+ImageButtonInstance::~ImageButtonInstance(void)
+{
+ //Delete everything on destruction
+ image.~ReferenceCountedPointer();
+ delete image.getPointer();
+ image_ovr.~ReferenceCountedPointer();
+ delete image_ovr.getPointer();
+ image_ds.~ReferenceCountedPointer();
+ delete image_ds.getPointer();
+ image_dn.~ReferenceCountedPointer();
+ delete image_dn.getPointer();
+ image = NULL;
+ image_ovr = NULL;
+ image_ds = NULL;
+ image_dn = NULL;
+ delete listener;
+ listener = NULL;
+ selected = false;
+}
+
+bool ImageButtonInstance::mouseInButton(float mousex, float mousey, RenderDevice* rd)
+{
+ Vector2 positionRelative = position;
+ if(floatRight && floatBottom)
+ {
+ positionRelative = Vector2(rd->getWidth() + position.x, rd->getHeight() + position.y);
+ }
+ else if(floatBottom)
+ {
+ positionRelative = Vector2(position.x, rd->getHeight() + position.y);
+ }
+ else if(floatRight)
+ {
+ positionRelative = Vector2(rd->getWidth() + position.x, position.y);
+ }
+ if(mousex >= positionRelative.x && mousey >= positionRelative.y)
+ {
+ if(mousex < positionRelative.x + size.x && mousey < positionRelative.y + size.y)
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+void ImageButtonInstance::drawObj(RenderDevice* rd, Vector2 mousePos, bool mouseDown)
+{
+ bool drawDisabledBox = false;
+ Vector2 positionRelative = position;
+ if(floatRight && floatBottom)
+ {
+ positionRelative = Vector2(rd->getWidth() + position.x, rd->getHeight() + position.y);
+ }
+ else if(floatBottom)
+ {
+ positionRelative = Vector2(position.x, rd->getHeight() + position.y);
+ }
+ else if(floatRight)
+ {
+ positionRelative = Vector2(rd->getWidth() + position.x, position.y);
+ }
+ int renderimage = openGLID;
+ if(selected == true && !image_dn.isNull() && !disabled)
+ {
+ renderimage = openGLID_dn;
+ }
+ else if(disabled)
+ {
+ if(!image_ds.isNull())
+ renderimage = openGLID_ds;
+ else
+ drawDisabledBox = true;
+ }
+ else if(mouseInArea(positionRelative.x, positionRelative.y, positionRelative.x + size.x, positionRelative.y + size.y, mousePos.x, mousePos.y))
+ {
+ if(mouseDown && !image_dn.isNull())
+ {
+ renderimage = openGLID_dn;
+ }
+ else if(!image_ovr.isNull())
+ {
+ renderimage = openGLID_ovr;
+ }
+ }
+
+
+
+ glEnable( GL_TEXTURE_2D );
+ glEnable(GL_BLEND);// you enable blending function
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glBindTexture( GL_TEXTURE_2D, renderimage);
+ glBegin( GL_QUADS );
+ glTexCoord2d(0.0,0.0);
+ glVertex2f( positionRelative.x, positionRelative.y );
+ glTexCoord2d( 1.0,0.0 );
+ glVertex2f( positionRelative.x + size.x, positionRelative.y );
+ glTexCoord2d( 1.0,1.0 );
+ glVertex2f( positionRelative.x + size.x, positionRelative.y + size.y );
+ glTexCoord2d( 0.0,1.0 );
+ glVertex2f( positionRelative.x, positionRelative.y + size.y );
+ glEnd();
+ glDisable( GL_TEXTURE_2D );
+
+ if(drawDisabledBox)
+ {
+ Draw::box(Box(Vector3(positionRelative.x, positionRelative.y, 0), Vector3(positionRelative.x+size.x, positionRelative.y+size.y, 0)), rd, Color4(0.7F,0.7F,0.7F,0.3F), Color4::clear());
+ }
+}
\ No newline at end of file
diff --git a/src/source/DataModelV2/Instance.cpp b/src/source/DataModelV2/Instance.cpp
index e69de29..ab5dbdc 100644
--- a/src/source/DataModelV2/Instance.cpp
+++ b/src/source/DataModelV2/Instance.cpp
@@ -0,0 +1,169 @@
+#define WINVER 0x0400
+#include
+#include "DataModelV2/Instance.h"
+
+
+
+Instance::Instance(void)
+{
+ parent = NULL;
+ name = "Default Game Instance";
+ className = "BaseInstance";
+ listicon = 1;
+ canDelete = true;
+}
+
+Instance::Instance(const Instance &oinst)
+{
+
+ name = oinst.name;
+ className = oinst.className;
+ canDelete = oinst.canDelete;
+ listicon = oinst.listicon;
+ //setParent(oinst.parent);
+}
+
+
+
+void Instance::render(RenderDevice* rd)
+{
+ for(size_t i = 0; i < children.size(); i++)
+ {
+ children[i]->render(rd);
+ }
+}
+
+void Instance::update()
+{
+}
+
+PROPGRIDITEM Instance::createPGI(LPSTR catalog, LPSTR propName, LPSTR propDesc, LPARAM curVal, INT type, TCHAR choices[])
+{
+ PROPGRIDITEM pItem;
+ PropGrid_ItemInit(pItem);
+ pItem.lpszCatalog=catalog;
+ pItem.lpszPropName=propName;
+ pItem.lpszPropDesc=propDesc;
+ pItem.lpCurValue=curVal;
+ pItem.iItemType=type;
+ if(choices != NULL)
+ pItem.lpszzCmbItems = choices;
+ return pItem;
+}
+
+void Instance::PropUpdate(LPPROPGRIDITEM &item)
+{
+ if(strcmp(item->lpszPropName, "Name") == 0)
+ {
+ name = (LPSTR)item->lpCurValue;
+ }
+}
+
+std::vector Instance::getProperties()
+{
+ std::vector properties;
+
+
+ properties.push_back(createPGI(
+ "Properties",
+ "Name",
+ "The name of this instance",
+ (LPARAM)name.c_str(),
+ PIT_EDIT
+ ));
+ return properties;
+}
+
+
+
+Instance::~Instance(void)
+{
+ for(size_t i = 0; i < children.size(); i++)
+ {
+ delete children.at(i);
+ }
+}
+
+void Instance::setName(std::string newName)
+{
+ name = newName;
+}
+
+std::string Instance::getClassName()
+{
+ return className;
+}
+
+std::vector Instance::getChildren()
+{
+ return children;
+}
+
+std::vector Instance::getAllChildren()
+{
+ if(!children.empty())
+ {
+ std::vector totalchildren = children;
+ for(size_t i = 0; i < children.size(); i++)
+ {
+ std::vector subchildren = children.at(i)->getAllChildren();
+ if(!subchildren.empty())
+ totalchildren.insert(totalchildren.end(), subchildren.begin(), subchildren.end());
+ }
+ return totalchildren;
+ }
+ return children;
+}
+
+void Instance::setParent(Instance* newParent)
+{
+ if(parent != NULL)
+ {
+ parent->removeChild(this);
+ }
+ parent = newParent;
+ if(newParent != NULL)
+ {
+ newParent->addChild(this);
+ }
+}
+
+Instance* Instance::getParent()
+{
+ return parent;
+}
+
+void Instance::addChild(Instance* newChild)
+{
+ children.push_back(newChild);
+}
+
+void Instance::clearChildren()
+{
+ children.clear();
+}
+void Instance::removeChild(Instance* oldChild)
+{
+ for(size_t i = 0; i < children.size(); i++)
+ {
+ if(children.at(i) == oldChild)
+ {
+ children.erase(children.begin() + i);
+ }
+ }
+}
+
+Instance* Instance::findFirstChild(std::string name)
+{
+ for(size_t i = 0; i < children.size(); i++)
+ {
+ if(children.at(i)->name.compare(name) == 0)
+ {
+ return children.at(i);
+ }
+ }
+ return NULL;
+}
+
+
+
diff --git a/src/source/DataModelV2/LevelInstance.cpp b/src/source/DataModelV2/LevelInstance.cpp
new file mode 100644
index 0000000..7757916
--- /dev/null
+++ b/src/source/DataModelV2/LevelInstance.cpp
@@ -0,0 +1,73 @@
+#include "DataModelV2/LevelInstance.h"
+
+LevelInstance::LevelInstance(void)
+{
+ Instance::Instance();
+ name = "Level";
+ winMessage = "You Won!";
+ loseMessage = "You Lost. Try Again";
+ timer = 60.0F;
+ score = 0;
+ canDelete = false;
+}
+
+LevelInstance::~LevelInstance(void)
+{
+}
+
+
+char timerTxt[12];
+char scoreTxt[12];
+std::vector LevelInstance::getProperties()
+{
+ std::vector properties = Instance::getProperties();
+
+
+
+ properties.push_back(createPGI("Messages",
+ "WinMessage",
+ "The message that shows when the player wins.",
+ (LPARAM)winMessage.c_str(),
+ PIT_EDIT));
+ properties.push_back(createPGI("Messages",
+ "LoseMessage",
+ "The message that shows when the player loses.",
+ (LPARAM)loseMessage.c_str(),
+ PIT_EDIT));
+
+
+ sprintf_s(timerTxt, "%g", timer);
+ sprintf_s(scoreTxt, "%d", score);
+ properties.push_back(createPGI("Gameplay",
+ "InitialTimerValue",
+ "The ammount of time in seconds the player has to complete this level.\r\n\r\nPut 0 if time is limitless.",
+ (LPARAM)timerTxt,
+ PIT_EDIT));
+ properties.push_back(createPGI("Gameplay",
+ "InitialScoreValue",
+ "The ammount of points the player starts with.",
+ (LPARAM)scoreTxt,
+ PIT_EDIT));
+ return properties;
+}
+void LevelInstance::PropUpdate(LPPROPGRIDITEM &pItem)
+{
+ if(strcmp(pItem->lpszPropName, "InitialTimerValue") == 0)
+ {
+ timer = atoi((LPSTR)pItem->lpCurValue);
+ }
+ if(strcmp(pItem->lpszPropName, "InitialScoreValue") == 0)
+ {
+ score = atof((LPSTR)pItem->lpCurValue);
+ }
+ if(strcmp(pItem->lpszPropName, "LoseMessage") == 0)
+ {
+ loseMessage = (LPSTR)pItem->lpCurValue;
+ }
+ if(strcmp(pItem->lpszPropName, "WinMessage") == 0)
+ {
+ winMessage = (LPSTR)pItem->lpCurValue;
+ }
+ else
+ Instance::PropUpdate(pItem);
+}
\ No newline at end of file
diff --git a/src/source/DataModelV2/PVInstance.cpp b/src/source/DataModelV2/PVInstance.cpp
new file mode 100644
index 0000000..2688022
--- /dev/null
+++ b/src/source/DataModelV2/PVInstance.cpp
@@ -0,0 +1,108 @@
+#include "DataModelV2/PVInstance.h"
+
+PVInstance::PVInstance(void)
+{
+ Instance::Instance();
+ nameShown = false;
+ controllerFlagShown = true;
+ className = "PVInstance";
+ listicon = 0;
+ controller = (Enum::Controller::Value)0;
+}
+
+PVInstance::PVInstance(const PVInstance &oinst)
+{
+ Instance::Instance(oinst);
+}
+
+PVInstance::~PVInstance(void)
+{
+}
+
+void PVInstance::postRender(RenderDevice* rd)
+{
+}
+
+static TCHAR* enumStr(int controller)
+{
+ switch(controller)
+ {
+ case Enum::Controller::None:
+ return "None";
+ case Enum::Controller::KeyboardLeft:
+ return "KeyboardLeft";
+ case Enum::Controller::KeyboardRight:
+ return "KeyboardRight";
+ case Enum::Controller::Joypad1:
+ return "Joypad1";
+ case Enum::Controller::Joypad2:
+ return "Joypad2";
+ case Enum::Controller::Chase:
+ return "Joypad1";
+ case Enum::Controller::Flee:
+ return "Joypad2";
+ }
+ return "None";
+}
+
+static Enum::Controller::Value strEnum(TCHAR * tval)
+{
+ if(strcmp(tval, "KeyboardLeft") == 0)
+ return Enum::Controller::KeyboardLeft;
+ if(strcmp(tval, "KeyboardRight") == 0)
+ return Enum::Controller::KeyboardRight;
+ if(strcmp(tval, "Joypad1") == 0)
+ return Enum::Controller::Joypad1;
+ if(strcmp(tval, "Joypad2") == 0)
+ return Enum::Controller::Joypad2;
+ if(strcmp(tval, "Chase") == 0)
+ return Enum::Controller::Chase;
+ if(strcmp(tval, "Flee") == 0)
+ return Enum::Controller::Flee;
+ return Enum::Controller::None;
+}
+
+
+
+std::vector PVInstance::getProperties()
+{
+ std::vector properties = Instance::getProperties();
+ properties.push_back(createPGI(
+ "Item",
+ "NameShown",
+ "This chooses whether the item name is shown",
+ nameShown,
+ PIT_CHECK));
+ properties.push_back(createPGI(
+ "Item",
+ "ControllerFlagShown",
+ "This chooses whether the item's ControllerFlag is shown",
+ controllerFlagShown,
+ PIT_CHECK));
+ properties.push_back(createPGI(
+ "Behaviour",
+ "Controller",
+ "This chooses what type of controller is used",
+ (LPARAM)enumStr(controller),
+ PIT_COMBO,
+ TEXT("None\0KeyboardRight\0KeyboardLeft\0Joypad1\0Joypad2\0Chase\0Flee")
+ ));
+
+ return properties;
+}
+void PVInstance::PropUpdate(LPPROPGRIDITEM &pItem)
+{
+ if(strcmp(pItem->lpszPropName, "NameShown") == 0)
+ {
+ nameShown = pItem->lpCurValue == TRUE;
+ }
+ if(strcmp(pItem->lpszPropName, "ControllerFlagShown") == 0)
+ {
+ controllerFlagShown = pItem->lpCurValue == TRUE;
+ }
+ if(strcmp(pItem->lpszPropName, "Controller") == 0)
+ {
+ controller = strEnum((TCHAR *)pItem->lpCurValue);
+ }
+ else Instance::PropUpdate(pItem);
+}
diff --git a/src/source/DataModelV2/PartInstance.cpp b/src/source/DataModelV2/PartInstance.cpp
new file mode 100644
index 0000000..9a9033c
--- /dev/null
+++ b/src/source/DataModelV2/PartInstance.cpp
@@ -0,0 +1,1124 @@
+#include "DataModelV2/PartInstance.h"
+#include "Globals.h"
+#include
+#include
+
+
+PartInstance::PartInstance(void) : _bevelSize(0.07f), _parseVert(0), _debugTimer(0)
+{
+ PVInstance::PVInstance();
+ glList = glGenLists(1);
+ name = "Unnamed PVItem";
+ className = "Part";
+ canCollide = true;
+ anchored = false;
+ size = Vector3(2,1,4);
+ setCFrame(CoordinateFrame(Vector3(0,0,0)));
+ color = Color3::gray();
+ velocity = Vector3(0,0,0);
+ rotVelocity = Vector3(0,0,0);
+ top = Enum::SurfaceType::Smooth;
+ front = Enum::SurfaceType::Smooth;
+ right = Enum::SurfaceType::Smooth;
+ back = Enum::SurfaceType::Smooth;
+ left = Enum::SurfaceType::Smooth;
+ bottom = Enum::SurfaceType::Smooth;
+ shape = Enum::Shape::Block;
+}
+
+
+Vector3 PartInstance::getVelocity()
+{
+ return velocity;
+}
+Vector3 PartInstance::getRotVelocity()
+{
+ return rotVelocity;
+}
+
+void PartInstance::setVelocity(Vector3 v)
+{
+ velocity = v;
+}
+void PartInstance::setRotVelocity(Vector3 v)
+{
+ rotVelocity = v;
+}
+
+void PartInstance::postRender(RenderDevice *rd)
+{
+ if(!nameShown)
+ return;
+ G3D::GFontRef fnt = NULL;
+ Instance* dm = parent;
+ while(dm != NULL)
+ {
+ if(DataModelInstance* mod = dynamic_cast(dm))
+ {
+ fnt = mod->font;
+ break;
+ }
+ dm = dm->getParent();
+ }
+ if(!fnt.isNull())
+ {
+ Vector3 gamepoint = position + Vector3(0,1.5,0);
+ Vector3 camerapoint = rd->getCameraToWorldMatrix().translation;
+ float distance = pow(pow((double)gamepoint.x - (double)camerapoint.x, 2) + pow((double)gamepoint.y - (double)camerapoint.y, 2) + pow((double)gamepoint.z - (double)camerapoint.z, 2), 0.5);
+ if(distance < 100 && distance > -100)
+ {
+ if(distance < 0)
+ distance = distance*-1;
+ glDisable(GL_DEPTH_TEST);
+ fnt->draw3D(rd, name, CoordinateFrame(rd->getCameraToWorldMatrix().rotation, gamepoint), 0.03*distance, Color3::yellow(), Color3::black(), G3D::GFont::XALIGN_CENTER, G3D::GFont::YALIGN_CENTER);
+ glEnable(GL_DEPTH_TEST);
+ }
+ }
+}
+
+void PartInstance::setParent(Instance* prnt)
+{
+ Instance * cparent = getParent();
+ while(cparent != NULL)
+ {
+ if(WorkspaceInstance* workspace = dynamic_cast(cparent))
+ {
+ std::cout << "Removed from partarray " << std::endl;
+ workspace->partObjects.erase(std::remove(workspace->partObjects.begin(), workspace->partObjects.end(), this), workspace->partObjects.end());
+ break;
+ }
+ cparent = cparent->getParent();
+ }
+ Instance::setParent(prnt);
+ while(parent != NULL)
+ {
+ if(WorkspaceInstance* workspace = dynamic_cast(parent))
+ {
+ workspace->partObjects.push_back(this);
+ break;
+ }
+ parent = parent->getParent();
+ }
+}
+
+PartInstance::PartInstance(const PartInstance &oinst) : _bevelSize(0.07f), _parseVert(0), _debugTimer(0)
+{
+ PVInstance::PVInstance(oinst);
+ glList = glGenLists(1);
+ //name = oinst.name;
+ //className = "Part";
+ name = oinst.name;
+ canCollide = oinst.canCollide;
+ setParent(oinst.parent);
+ anchored = oinst.anchored;
+ size = oinst.size;
+ setCFrame(oinst.cFrame);
+ color = oinst.color;
+ velocity = oinst.velocity;
+ rotVelocity = oinst.rotVelocity;
+ top = oinst.top;
+ front = oinst.front;
+ right = oinst.right;
+ back = oinst.back;
+ left = oinst.left;
+ bottom = oinst.bottom;
+ shape = oinst.shape;
+ changed = true;
+}
+
+void PartInstance::setSize(Vector3 newSize)
+{
+ int minsize = 1;
+ int maxsize = 512;
+ changed = true;
+ int sizex = (int)newSize.x;
+ if(sizex <= 0)
+ sizex = 1;
+ if(sizex > 512)
+ sizex = 512;
+
+ int sizey = (int)newSize.y;
+ if(sizey <= 0)
+ sizey = 1;
+ if(sizey > 512)
+ sizey = 512;
+
+ int sizez = (int)newSize.z;
+ if(sizez <= 0)
+ sizez = 1;
+ if(sizez > 512)
+ sizez = 512;
+
+ if(shape != Enum::Shape::Block)
+ {
+ int max = sizex;
+ if(sizey > max)
+ max = sizey;
+ if(sizez > max)
+ max = sizez;
+ sizex = sizey = sizez = max;
+ }
+
+ size = Vector3(sizex, sizey, sizez);
+
+
+
+}
+Vector3 PartInstance::getSize()
+{
+ return size;
+}
+Vector3 PartInstance::getPosition()
+{
+ return position;
+}
+void PartInstance::setShape(Enum::Shape::Value shape)
+{
+ switch(shape)
+ {
+ case Enum::Shape::Block:
+ this->shape = shape;
+ break;
+ default:
+ this->shape = shape;
+ this->setSize(this->getSize());
+ }
+ changed = true;
+}
+
+void PartInstance::setPosition(Vector3 pos)
+{
+ position = pos;
+ cFrame = CoordinateFrame(cFrame.rotation, pos);
+ changed = true;
+}
+
+CoordinateFrame PartInstance::getCFrame()
+{
+ return cFrame;
+}
+void PartInstance::setCFrame(CoordinateFrame coordinateFrame)
+{
+ cFrame = coordinateFrame;
+ position = coordinateFrame.translation;
+ changed = true;
+}
+// Can probably be deleted
+CoordinateFrame PartInstance::getCFrameRenderBased()
+{
+ return cFrame;//CoordinateFrame(getCFrame().rotation,Vector3(getCFrame().translation.x, getCFrame().translation.y, getCFrame().translation.z));
+}
+
+bool PartInstance::collides(PartInstance * part)
+{
+ if(shape == Enum::Shape::Block)
+ {
+ if(part->shape == Enum::Shape::Block)
+ return G3D::CollisionDetection::fixedSolidBoxIntersectsFixedSolidBox(getBox(), part->getBox());
+ else
+ return G3D::CollisionDetection::fixedSolidSphereIntersectsFixedSolidBox(part->getSphere(), getBox());
+ }
+ else
+ {
+ if(part->shape == Enum::Shape::Block)
+ return G3D::CollisionDetection::fixedSolidSphereIntersectsFixedSolidBox(getSphere(), part->getBox());
+ else
+ return G3D::CollisionDetection::fixedSolidSphereIntersectsFixedSolidSphere(getSphere(), part->getSphere());
+ }
+}
+
+#ifdef NEW_BOX_RENDER
+Box PartInstance::getBox()
+{
+ Box box = Box(Vector3(size.x/2, size.y/2, size.z/2) ,Vector3(-size.x/2,-size.y/2,-size.z/2));
+ CoordinateFrame c = getCFrameRenderBased();
+ itemBox = c.toWorldSpace(box);
+ return itemBox;
+}
+Sphere PartInstance::getSphere()
+{
+ Sphere sphere = Sphere(Vector3(0,0,0), size.y/2);
+ CoordinateFrame c = getCFrameRenderBased();
+ //itemBox = c.toWorldSpace(Sphere);
+ return sphere;//itemBox;
+}
+#else
+Box PartInstance::getBox()
+{
+ if(changed)
+ {
+ Box box = Box(Vector3(0+size.x/4, 0+size.y/4, 0+size.z/4) ,Vector3(0-size.x/4,0-size.y/4,0-size.z/4));
+ CoordinateFrame c = getCFrameRenderBased();
+ itemBox = c.toWorldSpace(box);
+ Vector3 v0,v1,v2,v3;
+ for (int f = 0; f < 6; f++) {
+ itemBox.getFaceCorners(f, v0,v1,v2,v3);
+ _vertices[f*16] = v0.x;
+ _vertices[(f*16)+1] = v0.y;
+ _vertices[(f*16)+2] = v0.z;
+ _vertices[(f*16)+3] = v1.x;
+ _vertices[(f*16)+4] = v1.y;
+ _vertices[(f*16)+5] = v1.z;
+ _vertices[(f*16)+6] = v2.x;
+ _vertices[(f*16)+7] = v2.y;
+ _vertices[(f*16)+8] = v2.z;
+ _vertices[(f*16)+9] = v3.x;
+ _vertices[(f*16)+10] = v3.y;
+ _vertices[(f*16)+11] = v3.z;
+ _vertices[(f*16)+12] = color.r;
+ _vertices[(f*16)+13] = color.g;
+ _vertices[(f*16)+14] = color.b;
+ _vertices[(f*16)+15] = 1;
+ }
+ }
+ return itemBox;
+}
+#endif
+
+bool PartInstance::collides(Box box)
+{
+ return CollisionDetection::fixedSolidBoxIntersectsFixedSolidBox(getBox(), box);
+}
+#ifdef NEW_BOX_RENDER
+void PartInstance::addVertex(Vector3 vertexPos,Color3 color)
+{
+ _vertices.push_back(vertexPos.x);
+ _vertices.push_back(vertexPos.y);
+ _vertices.push_back(vertexPos.z);
+ _vertices.push_back(color.r);
+ _vertices.push_back(color.g);
+ _vertices.push_back(color.b);
+}
+ void PartInstance::addNormals(Vector3 normal)
+{
+ for (unsigned int i=0;i<3;i+=1) {
+ _normals.push_back(normal.x);
+ _normals.push_back(normal.y);
+ _normals.push_back(normal.z);
+ }
+}
+ void PartInstance::addSingularNormal(Vector3 normal)
+{
+ _normals.push_back(normal.x);
+ _normals.push_back(normal.y);
+ _normals.push_back(normal.z);
+}
+ void PartInstance::addTriangle(Vector3 v1,Vector3 v2,Vector3 v3)
+{
+ addVertex(v1,color);
+ addVertex(v2,color);
+ addVertex(v3,color);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(v3-v2,v1-v2).direction());
+ addSingularNormal(cross(v1-v3,v2-v3).direction());
+}
+
+void PartInstance::addQuad(Vector3 v1,Vector3 v2, Vector3 v3, Vector3 v4)
+{
+ addTriangle(v1, v2, v3);
+ addTriangle(v1, v3, v4);
+}
+
+void PartInstance::genSmoothNormals(int count = -1)
+{
+ if(count < 0)
+ {
+
+ }
+}
+
+void PartInstance::addSmoothTriangle(Vector3 v1, Vector3 v2, Vector3 v3)
+{
+ addVertex(v1,color);
+ addVertex(v2,color);
+ addVertex(v3,color);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ //addSingularNormal(Vector3(cross(v2-v1,v3-v1) + cross(v3-v2,v1-v2) + cross(v1-v3,v2-v3)).direction());
+ addSingularNormal(v1.direction());
+ addSingularNormal(v2.direction());
+ addSingularNormal(v3.direction());
+}
+
+
+void PartInstance::addPlus(Vector3 v1)
+{
+ float renderY = max(size.z, max(size.x, size.y))/2 * 0.775;
+ Vector3 vx1 = v1 + Vector3(0, -renderY, -0.1f);
+ Vector3 vx2 = v1 + Vector3(0, -renderY, 0.1f);
+ Vector3 vx3 = v1 + Vector3(0, renderY, 0.1f);
+
+ addVertex(vx1,Color3::WHITE);
+ addVertex(vx2,Color3::WHITE);
+ addVertex(vx3,Color3::WHITE);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(vx2-vx1,vx3-vx1).direction());
+ addSingularNormal(cross(vx3-vx2,vx1-vx2).direction());
+ addSingularNormal(cross(vx1-vx3,vx2-vx3).direction());
+
+ vx1 = v1 + Vector3(0, renderY, 0.1f);
+ vx2 = v1 + Vector3(0, renderY, -0.1f);
+ vx3 = v1 + Vector3(0, -renderY, -0.1f);
+
+ addVertex(vx1,Color3::WHITE);
+ addVertex(vx2,Color3::WHITE);
+ addVertex(vx3,Color3::WHITE);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(vx2-vx1,vx3-vx1).direction());
+ addSingularNormal(cross(vx3-vx2,vx1-vx2).direction());
+ addSingularNormal(cross(vx1-vx3,vx2-vx3).direction());
+
+ vx3 = v1 + Vector3(0, -0.1f, -renderY);
+ vx2 = v1 + Vector3(0, 0.1f, -renderY);
+ vx1 = v1 + Vector3(0, 0.1f, renderY);
+
+ addVertex(vx1,Color3::WHITE);
+ addVertex(vx2,Color3::WHITE);
+ addVertex(vx3,Color3::WHITE);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(vx2-vx1,vx3-vx1).direction());
+ addSingularNormal(cross(vx3-vx2,vx1-vx2).direction());
+ addSingularNormal(cross(vx1-vx3,vx2-vx3).direction());
+
+ vx3 = v1 + Vector3(0, 0.1f, renderY);
+ vx2 = v1 + Vector3(0, -0.1f, renderY);
+ vx1 = v1 + Vector3(0, -0.1f, -renderY);
+
+ addVertex(vx1,Color3::WHITE);
+ addVertex(vx2,Color3::WHITE);
+ addVertex(vx3,Color3::WHITE);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(vx2-vx1,vx3-vx1).direction());
+ addSingularNormal(cross(vx3-vx2,vx1-vx2).direction());
+ addSingularNormal(cross(vx1-vx3,vx2-vx3).direction());
+
+}
+
+
+void PartInstance::addPlus2(Vector3 v1)
+{
+ float renderY = max(size.z, max(size.x, size.y))/2 * 0.775;
+ Vector3 vx3 = v1 + Vector3(0, -renderY, -0.1f);
+ Vector3 vx2 = v1 + Vector3(0, -renderY, 0.1f);
+ Vector3 vx1 = v1 + Vector3(0, renderY, 0.1f);
+
+ addVertex(vx1,Color3::WHITE);
+ addVertex(vx2,Color3::WHITE);
+ addVertex(vx3,Color3::WHITE);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(vx2-vx1,vx3-vx1).direction());
+ addSingularNormal(cross(vx3-vx2,vx1-vx2).direction());
+ addSingularNormal(cross(vx1-vx3,vx2-vx3).direction());
+
+ vx3 = v1 + Vector3(0, renderY, 0.1f);
+ vx2 = v1 + Vector3(0, renderY, -0.1f);
+ vx1 = v1 + Vector3(0, -renderY, -0.1f);
+
+ addVertex(vx1,Color3::WHITE);
+ addVertex(vx2,Color3::WHITE);
+ addVertex(vx3,Color3::WHITE);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(vx2-vx1,vx3-vx1).direction());
+ addSingularNormal(cross(vx3-vx2,vx1-vx2).direction());
+ addSingularNormal(cross(vx1-vx3,vx2-vx3).direction());
+
+ vx1 = v1 + Vector3(0, -0.1f, -renderY);
+ vx2 = v1 + Vector3(0, 0.1f, -renderY);
+ vx3 = v1 + Vector3(0, 0.1f, renderY);
+
+ addVertex(vx1,Color3::WHITE);
+ addVertex(vx2,Color3::WHITE);
+ addVertex(vx3,Color3::WHITE);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(vx2-vx1,vx3-vx1).direction());
+ addSingularNormal(cross(vx3-vx2,vx1-vx2).direction());
+ addSingularNormal(cross(vx1-vx3,vx2-vx3).direction());
+
+ vx1 = v1 + Vector3(0, 0.1f, renderY);
+ vx2 = v1 + Vector3(0, -0.1f, renderY);
+ vx3 = v1 + Vector3(0, -0.1f, -renderY);
+
+ addVertex(vx1,Color3::WHITE);
+ addVertex(vx2,Color3::WHITE);
+ addVertex(vx3,Color3::WHITE);
+ //addNormals(cross(v2-v1,v3-v1).direction());
+ addSingularNormal(cross(vx2-vx1,vx3-vx1).direction());
+ addSingularNormal(cross(vx3-vx2,vx1-vx2).direction());
+ addSingularNormal(cross(vx1-vx3,vx2-vx3).direction());
+
+}
+ void PartInstance::debugPrintVertexIDs(RenderDevice* rd,GFontRef font,Matrix3 rot)
+{
+ _debugUniqueVertices.clear();
+ glDisable(GL_DEPTH_TEST);
+
+ for (unsigned int i=0;i<_vertices.size();i+=6)
+ {
+ std::stringstream stream;
+ stream << std::fixed << std::setprecision(1) << i;
+ Vector3 testVector = Vector3(_vertices[i],_vertices[i+1],_vertices[i+2]);
+ if (isUniqueVertex(testVector))
+ {
+
+ font->draw3D(rd, stream.str(), CoordinateFrame(testVector) * -rot, 0.05, Color3::fromARGB(0xFF4F0000), Color4::clear());
+ _debugUniqueVertices.push_back(testVector);
+ }
+ }
+ glEnable(GL_DEPTH_TEST);
+}
+ void PartInstance::makeFace(int vertex1,int vertex2, int vertex3)
+{
+ addTriangle(Vector3(_vertices[vertex1],_vertices[vertex1+1],_vertices[vertex1+2]),
+ Vector3(_vertices[vertex2],_vertices[vertex2+1],_vertices[vertex2+2]),
+ Vector3(_vertices[vertex3],_vertices[vertex3+1],_vertices[vertex3+2]));
+}
+ void PartInstance::fromArrays(float verts[], float norms[], float ind[], unsigned int countVN, unsigned int countInd)
+{
+ for(unsigned int i = 0; i < countVN; i++)
+ {
+ _vertices.push_back(verts[i]);
+ _normals.push_back(norms[i]);
+ }
+ for(unsigned int i = 0; i < countInd; i++)
+ {
+ _indices.push_back(ind[i]);
+ }
+
+}
+void PartInstance::makeSmoothFace(int vertex1,int vertex2, int vertex3)
+{
+ addSmoothTriangle(Vector3(_vertices[vertex1],_vertices[vertex1+1],_vertices[vertex1+2]),
+ Vector3(_vertices[vertex2],_vertices[vertex2+1],_vertices[vertex2+2]),
+ Vector3(_vertices[vertex3],_vertices[vertex3+1],_vertices[vertex3+2]));
+}
+bool PartInstance::isUniqueVertex(Vector3 pos)
+{
+ for (unsigned int i=0;i<_debugUniqueVertices.size();i+=1)
+ {
+ if (pos==_debugUniqueVertices[i])
+ {
+ return false;
+ }
+ }
+ return true;
+}
+//int rings = 15;
+//int sectors = 15;
+void PartInstance::render(RenderDevice* rd) {
+ int sectorCount = 12;
+ int stackCount = 12;
+ float radius = 0.5F;
+ //if(nameShown)
+ //postRenderStack.push_back(this);
+ if (changed)
+ {
+
+ getBox();
+ _vertices.clear();
+ _normals.clear();
+ _indices.clear();
+ //std::vector(_vertices).swap(_vertices); //Clear the memory
+ Vector3 renderSize = size/2;
+ switch(this->shape)
+ {
+ case Enum::Shape::Ball:
+ {
+ glNewList(glList, GL_COMPILE);
+ glColor(this->color);
+ glPushMatrix();
+ glScalef(renderSize.x, renderSize.y, renderSize.z);
+ gluSphere(gluNewQuadric(), 1, 20, 20);
+ glPopMatrix();
+ glEndList();
+ rd->setObjectToWorldMatrix(cFrame);
+ glCallList(glList);
+ changed = false;
+ return;
+ }
+ break;
+ case Enum::Shape::Block:
+ {
+ // Front
+ addTriangle(Vector3(renderSize.x-_bevelSize,renderSize.y-_bevelSize,renderSize.z),
+ Vector3(-renderSize.x+_bevelSize,-renderSize.y+_bevelSize,renderSize.z),
+ Vector3(renderSize.x-_bevelSize,-renderSize.y+_bevelSize,renderSize.z)
+ );
+
+ addTriangle(Vector3(-renderSize.x+_bevelSize,renderSize.y-_bevelSize,renderSize.z),
+ Vector3(-renderSize.x+_bevelSize,-renderSize.y+_bevelSize,renderSize.z),
+ Vector3(renderSize.x-_bevelSize,renderSize.y-_bevelSize,renderSize.z)
+ );
+
+ // Top
+ addTriangle(Vector3(renderSize.x-_bevelSize,renderSize.y,renderSize.z-_bevelSize),
+ Vector3(renderSize.x-_bevelSize,renderSize.y,-renderSize.z+_bevelSize),
+ Vector3(-renderSize.x+_bevelSize,renderSize.y,renderSize.z-_bevelSize)
+ );
+ addTriangle(Vector3(-renderSize.x+_bevelSize,renderSize.y,renderSize.z-_bevelSize),
+ Vector3(renderSize.x-_bevelSize,renderSize.y,-renderSize.z+_bevelSize),
+ Vector3(-renderSize.x+_bevelSize,renderSize.y,-renderSize.z+_bevelSize)
+ );
+
+ // Back
+ addTriangle(Vector3(renderSize.x-_bevelSize,renderSize.y-_bevelSize,-renderSize.z),
+ Vector3(renderSize.x-_bevelSize,-renderSize.y+_bevelSize,-renderSize.z),
+ Vector3(-renderSize.x+_bevelSize,-renderSize.y+_bevelSize,-renderSize.z)
+ );
+ addTriangle(Vector3(renderSize.x-_bevelSize,renderSize.y-_bevelSize,-renderSize.z),
+ Vector3(-renderSize.x+_bevelSize,-renderSize.y+_bevelSize,-renderSize.z),
+ Vector3(-renderSize.x+_bevelSize,renderSize.y-_bevelSize,-renderSize.z)
+ );
+
+ // Bottom
+ addTriangle(Vector3(renderSize.x-_bevelSize,-renderSize.y,-renderSize.z+_bevelSize),
+ Vector3(renderSize.x-_bevelSize,-renderSize.y,renderSize.z-_bevelSize),
+ Vector3(-renderSize.x+_bevelSize,-renderSize.y,renderSize.z-_bevelSize)
+ );
+ addTriangle(Vector3(-renderSize.x+_bevelSize,-renderSize.y,renderSize.z-_bevelSize),
+ Vector3(-renderSize.x+_bevelSize,-renderSize.y,-renderSize.z+_bevelSize),
+ Vector3(renderSize.x-_bevelSize,-renderSize.y,-renderSize.z+_bevelSize)
+ );
+ // Left
+ addTriangle(Vector3(-renderSize.x,renderSize.y-_bevelSize,-renderSize.z+_bevelSize),
+ Vector3(-renderSize.x,-renderSize.y+_bevelSize,renderSize.z-_bevelSize),
+ Vector3(-renderSize.x,renderSize.y-_bevelSize,renderSize.z-_bevelSize)
+ );
+ addTriangle(Vector3(-renderSize.x,-renderSize.y+_bevelSize,renderSize.z-_bevelSize),
+ Vector3(-renderSize.x,renderSize.y-_bevelSize,-renderSize.z+_bevelSize),
+ Vector3(-renderSize.x,-renderSize.y+_bevelSize,-renderSize.z+_bevelSize)
+ );
+
+ // Right
+ addTriangle(Vector3(renderSize.x,renderSize.y-_bevelSize,renderSize.z-_bevelSize),
+ Vector3(renderSize.x,-renderSize.y+_bevelSize,renderSize.z-_bevelSize),
+ Vector3(renderSize.x,renderSize.y-_bevelSize,-renderSize.z+_bevelSize)
+ );
+ addTriangle(Vector3(renderSize.x,-renderSize.y+_bevelSize,-renderSize.z+_bevelSize),
+ Vector3(renderSize.x,renderSize.y-_bevelSize,-renderSize.z+_bevelSize),
+ Vector3(renderSize.x,-renderSize.y+_bevelSize,renderSize.z-_bevelSize)
+ );
+
+
+ // Bevel Top Front
+ makeFace(0,36,48);
+ makeFace(48,18,0);
+ // Bevel Left Front Corner
+ makeFace(18,156,162);
+ makeFace(24,18,162);
+ // Bevel Left Front Top Corner
+ makeFace(48,156,18);
+ // Bevel Left Front Bottom Corner
+ makeFace(120,6,150);
+ // Bevel Left Top
+ makeFace(48,66,156);
+ makeFace(144,156,66);
+ // Bevel Bottom
+ makeFace(6,120,114);
+ makeFace(114,12,6);
+ // Left Bottom
+ makeFace(120,150,174);
+ makeFace(174,132,120);
+ // Right Front Top Corner
+ makeFace(36,0,180);
+ // Right Front Corner
+ makeFace(180,0,12);
+ makeFace(186,180,12);
+ // Right Front Bottom Corner
+ makeFace(186,12,114);
+ // Right Bottom
+ makeFace(186,114,108);
+ makeFace(108,198,186);
+ // Right Top Corner
+ makeFace(180,192,36);
+ makeFace(192,42,36);
+ // Right Back Top Corner
+ makeFace(72,42,192);
+ // Right Back Bottom Corner
+ makeFace(78,198,108);
+ // Right Back Corner
+ makeFace(72,192,198);
+ makeFace(198,78,72);
+ // Back Bottom Corner
+ makeFace(78,108,132);
+ makeFace(132,84,78);
+ // Back Top
+ makeFace(42,72,102);
+ makeFace(102,66,42);
+ // Back Left Top Corner
+ makeFace(144,66,102);
+ // Back Left Corner
+ makeFace(144,102,84);
+ makeFace(84,174,144);
+ // Back Left Bottom Corner
+ makeFace(174,84,132);
+ for (unsigned short i=0;i<_vertices.size()/6;i++) {
+ _indices.push_back(i);
+ }
+ }
+ break;
+ case Enum::Shape::Cylinder:
+ {
+ /*int fsize = renderSize.y/(pi()/2);
+ //makeFace(0,0,48);
+ // Front
+ addTriangle(Vector3(renderSize.x,renderSize.y-fsize,renderSize.z),
+ Vector3(-renderSize.x,-renderSize.y+fsize,renderSize.z),
+ Vector3(renderSize.x,-renderSize.y+fsize,renderSize.z)
+ );
+
+ addTriangle(Vector3(-renderSize.x,renderSize.y-fsize,renderSize.z),
+ Vector3(-renderSize.x,-renderSize.y+fsize,renderSize.z),
+ Vector3(renderSize.x,renderSize.y-fsize,renderSize.z)
+ );
+
+ // Top
+ addTriangle(Vector3(renderSize.x,renderSize.y,renderSize.z-fsize),
+ Vector3(renderSize.x,renderSize.y,-renderSize.z+fsize),
+ Vector3(-renderSize.x,renderSize.y,renderSize.z-fsize)
+ );
+ addTriangle(Vector3(-renderSize.x,renderSize.y,renderSize.z-fsize),
+ Vector3(renderSize.x,renderSize.y,-renderSize.z+fsize),
+ Vector3(-renderSize.x,renderSize.y,-renderSize.z+fsize)
+ );
+
+ // Back
+ addTriangle(Vector3(renderSize.x,renderSize.y-fsize,-renderSize.z),
+ Vector3(renderSize.x,-renderSize.y+fsize,-renderSize.z),
+ Vector3(-renderSize.x,-renderSize.y+fsize,-renderSize.z)
+ );
+ addTriangle(Vector3(renderSize.x,renderSize.y-fsize,-renderSize.z),
+ Vector3(-renderSize.x,-renderSize.y+fsize,-renderSize.z),
+ Vector3(-renderSize.x,renderSize.y-fsize,-renderSize.z)
+ );
+
+ // Bottom
+ addTriangle(Vector3(renderSize.x,-renderSize.y,-renderSize.z+fsize),
+ Vector3(renderSize.x,-renderSize.y,renderSize.z-fsize),
+ Vector3(-renderSize.x,-renderSize.y,renderSize.z-fsize)
+ );
+ addTriangle(Vector3(-renderSize.x,-renderSize.y,renderSize.z-fsize),
+ Vector3(-renderSize.x,-renderSize.y,-renderSize.z+fsize),
+ Vector3(renderSize.x,-renderSize.y,-renderSize.z+fsize)
+ );
+ // Left
+ /*addTriangle(Vector3(-renderSize.x,renderSize.y-fsize,-renderSize.z+fsize),
+ Vector3(-renderSize.x,-renderSize.y+fsize,renderSize.z-fsize),
+ Vector3(-renderSize.x,renderSize.y-fsize,renderSize.z-fsize)
+ );
+ addTriangle(Vector3(-renderSize.x,-renderSize.y+fsize,renderSize.z-fsize),
+ Vector3(-renderSize.x,renderSize.y-fsize,-renderSize.z+fsize),
+ Vector3(-renderSize.x,-renderSize.y+fsize,-renderSize.z+fsize)
+ );
+ // Right
+ addTriangle(Vector3(renderSize.x,renderSize.y-fsize,renderSize.z-fsize),
+ Vector3(renderSize.x,-renderSize.y+fsize,renderSize.z-fsize),
+ Vector3(renderSize.x,renderSize.y-fsize,-renderSize.z+fsize)
+ );
+ addTriangle(Vector3(renderSize.x,-renderSize.y+fsize,-renderSize.z+fsize),
+ Vector3(renderSize.x,renderSize.y-fsize,-renderSize.z+fsize),
+ Vector3(renderSize.x,-renderSize.y+fsize,renderSize.z-fsize)
+ );//*/
+
+
+ /*// Bevel Top Front
+ makeFace(0,36,48);
+ makeFace(48,18,0);
+ // Bevel Left Front Corner
+ makeFace(18,156,162);
+ makeFace(24,18,162);
+ // Bevel Left Front Top Corner
+ makeFace(48,156,18);
+ // Bevel Left Front Bottom Corner
+ makeFace(120,6,150);
+ // Bevel Left Top
+ makeFace(48,66,156);
+ makeFace(144,156,66);
+ // Bevel Bottom
+ makeFace(6,120,114);
+ makeFace(114,12,6);
+ // Left Bottom
+ makeFace(120,150,174);
+ makeFace(174,132,120);
+ // Right Front Top Corner
+ makeFace(36,0,180);
+ // Right Front Corner
+ makeFace(180,0,12);
+ makeFace(186,180,12);
+ // Right Front Bottom Corner
+ makeFace(186,12,114);
+ // Right Bottom
+ makeFace(186,114,108);
+ makeFace(108,198,186);
+ // Right Top Corner
+ makeFace(180,192,36);
+ makeFace(192,42,36);
+ // Right Back Top Corner
+ makeFace(72,42,192);
+ // Right Back Bottom Corner
+ makeFace(78,198,108);
+ // Right Back Corner
+ makeFace(72,192,198);
+ makeFace(198,78,72);
+ // Back Bottom Corner
+ makeFace(78,108,132);
+ makeFace(132,84,78);
+ // Back Top
+ makeFace(42,72,102);
+ makeFace(102,66,42);
+ // Back Left Top Corner
+ makeFace(144,66,102);
+ // Back Left Corner
+ makeFace(144,102,84);
+ makeFace(84,174,144);
+ // Back Left Bottom Corner
+ makeFace(174,84,132);*/
+ /*float radius = renderSize.y + (renderSize.y * (1 - cos(pi() / 12)));
+ Vector2 xy[13];
+ for(int i = 0; i < 13; i++)
+ {
+ //Get the next point
+ float y = radius * cos(((double)i-G3D::toRadians(29)) * pi()/6);
+ float z = radius * sin(((double)i-G3D::toRadians(29)) * pi()/6);
+ xy[i] = Vector2(y,z);
+ }
+ for(int i = 0; i < 12; i++)
+ {
+ //Create a Quad for the face (i to i+1)
+ addSmoothTriangle(
+ Vector3(renderSize.x, xy[i].x, xy[i].y),
+ Vector3(-renderSize.x, xy[i].x, xy[i].y),
+ Vector3(-renderSize.x, xy[i+1].x, xy[i+1].y));
+ addSmoothTriangle(
+ Vector3(renderSize.x, xy[i].x, xy[i].y),
+ Vector3(-renderSize.x, xy[i+1].x, xy[i+1].y),
+ Vector3(renderSize.x, xy[i+1].x, xy[i+1].y));
+ //Cap on the right
+ addTriangle(
+ Vector3(renderSize.x, xy[0].x, xy[0].y),
+ Vector3(renderSize.x, xy[i].x, xy[i].y),
+ Vector3(renderSize.x, xy[i+1].x, xy[i+1].y));
+ //Cap on the left
+ addTriangle(
+ Vector3(-renderSize.x, xy[i+1].x, xy[i+1].y),
+ Vector3(-renderSize.x, xy[i].x, xy[i].y),
+ Vector3(-renderSize.x, xy[0].x, xy[0].y));
+ }*/
+ /*float facetRatio = renderSize.x / (pi() * 0.5F);
+ addQuad(
+ Vector3(renderSize.x, renderSize.y, renderSize.z-facetRatio),
+ Vector3(renderSize.x, renderSize.y, -renderSize.z+facetRatio),
+ Vector3(-renderSize.x, renderSize.y, -renderSize.z+facetRatio),
+ Vector3(-renderSize.x, renderSize.y, renderSize.z-facetRatio));
+
+ addQuad(
+ Vector3(renderSize.x, renderSize.y-facetRatio, renderSize.z),
+ Vector3(-renderSize.x, renderSize.y-facetRatio, renderSize.z),
+ Vector3(-renderSize.x, -renderSize.y+facetRatio, renderSize.z),
+ Vector3(renderSize.x, -renderSize.y+facetRatio, renderSize.z));
+ addQuad(
+ Vector3(-renderSize.x, -renderSize.y, renderSize.z-facetRatio),
+ Vector3(-renderSize.x, -renderSize.y, -renderSize.z+facetRatio),
+ Vector3(renderSize.x, -renderSize.y, -renderSize.z+facetRatio),
+ Vector3(renderSize.x, -renderSize.y, renderSize.z-facetRatio));
+ addQuad(
+ Vector3(renderSize.x, -renderSize.y+facetRatio, -renderSize.z),
+ Vector3(-renderSize.x, -renderSize.y+facetRatio, -renderSize.z),
+ Vector3(-renderSize.x, renderSize.y-facetRatio, -renderSize.z),
+ Vector3(renderSize.x, renderSize.y-facetRatio, -renderSize.z));*/
+
+ /*addPlus(Vector3(-renderSize.x-0.01,0,0));
+ addPlus2(Vector3(renderSize.x+0.01,0,0));
+
+ for (unsigned short i=0;i<_vertices.size()/6;i++) {
+ _indices.push_back(i);
+ }
+ //std::reverse(_vertices.begin(), _vertices.end());
+ //std::reverse(_normals.begin(), _normals.end());
+ )*/
+ GLUquadric* q = gluNewQuadric();
+
+ addPlus(Vector3(-renderSize.x-0.01,0,0));
+ addPlus2(Vector3(renderSize.x+0.01,0,0));
+ for (unsigned short i=0;i<_vertices.size()/6;i++) {
+ _indices.push_back(i);
+ }
+ glVertexPointer(3, GL_FLOAT,6 * sizeof(GLfloat), &_vertices[0]);
+ glColorPointer(3, GL_FLOAT,6 * sizeof(GLfloat), &_vertices[3]);
+ glNormalPointer(GL_FLOAT,3 * sizeof(GLfloat), &_normals[0]);
+ glNewList(glList, GL_COMPILE);
+ glColor(this->color);
+ glPushMatrix();
+ glRotatef(90, 0, 1, 0);
+ glScalef(renderSize.x, renderSize.y, renderSize.z);
+ glTranslatef(0,0,1);
+ gluDisk(q, 0, 1, 12, 12);
+ glTranslatef(0,0,-2);
+ gluCylinder(q, 1, 1, 2, 12, 1);
+ glRotatef(180, 1, 0, 0);
+ gluDisk(q, 0, 1, 12, 12);
+ glPopMatrix();
+ glDrawElements(GL_TRIANGLES, _indices.size(), GL_UNSIGNED_SHORT, &_indices[0]);
+ glEndList();
+ rd->setObjectToWorldMatrix(cFrame);
+ glCallList(glList);
+ changed = false;
+ return;
+
+ }
+ break;
+ }
+
+ changed=false;
+ glVertexPointer(3, GL_FLOAT,6 * sizeof(GLfloat), &_vertices[0]);
+ glColorPointer(3, GL_FLOAT,6 * sizeof(GLfloat), &_vertices[3]);
+ glNormalPointer(GL_FLOAT,3 * sizeof(GLfloat), &_normals[0]);
+ glNewList(glList, GL_COMPILE);
+ //glPushMatrix();
+ //glTranslatef(2,7,0);
+ glDrawElements(GL_TRIANGLES, _indices.size(), GL_UNSIGNED_SHORT, &_indices[0]);
+ //glPopMatrix();
+ glEndList();
+ }
+ rd->setObjectToWorldMatrix(cFrame);
+ glCallList(glList);
+ postRender(rd);
+ //rd->setObjectToWorldMatrix(cFrame);
+
+}
+#else
+void PartInstance::render(RenderDevice* rd)
+{
+
+ if(changed)
+ {
+ Box box = getBox();
+ changed = false;
+ glNewList(glList, GL_COMPILE);
+ glColor(color);
+ /*glEnable( GL_TEXTURE_2D );
+ glEnable(GL_BLEND);// you enable blending function
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glBindTexture( GL_TEXTURE_2D, Globals::surfaceId);
+ glBegin(GL_QUADS);*/
+ for(int i = 0; i < 96; i+=16)
+ {
+ /*double add = 0.8;
+ Enum::SurfaceType::Value face;
+ if(i == 0)//Back
+ face = back;
+ else if(i == 16)//Right
+ face = right;
+ else if(i == 32)//Front
+ face = front;
+ else if(i == 48)//Top
+ face = top;
+ else if(i == 64)//Left
+ face = left;
+ else if(i == 80)//Bottom
+ face = bottom;
+
+ /*if(face == Snaps)
+ add = 0.0;
+ else if(face == Inlets)
+ add = 0.2;*/
+
+ Vector3 v0 = Vector3(_vertices[i], _vertices[i+1], _vertices[i+2]), v1 = Vector3(_vertices[i+3], _vertices[i+4], _vertices[i+5]), v3 = Vector3(_vertices[i+9], _vertices[i+10], _vertices[i+11]);
+ /*glNormal3fv((v1 - v0).cross(v3 - v0).direction());
+ glTexCoord2f(0.0F,0.0F);
+ glVertex3fv(v0);
+ glTexCoord2f(1.0F,0.0F);
+ glVertex3fv(v1);
+ glTexCoord2f(1.0F,0.25F);
+ glVertex3f(_vertices[i+6], _vertices[i+7], _vertices[i+8]);
+ glTexCoord2f(0.0F,0.25F);
+ glVertex3fv(v3);*/
+
+ glEnable(GL_BLEND);// you enable blending function
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glBegin( GL_QUADS );
+ glNormal3fv((v1 - v0).cross(v3 - v0).direction());
+ //glTexCoord2d(0.0,0.0+add);
+ glVertex3fv(v0);
+ //glTexCoord2d( 1.0,0.0+add);
+ glVertex3fv(v1);
+ //glTexCoord2d(1.0,0.2+add);
+ glVertex3f(_vertices[i+6], _vertices[i+7], _vertices[i+8]);
+ //glTexCoord2d( 0.0,0.2+add);
+ glVertex3fv(v3);
+ glEnd();
+ //glDisable( GL_TEXTURE_2D );
+ }
+ glEndList();
+ /*glEnd();
+ glDisable(GL_TEXTURE_2D);*/
+ }
+ glCallList(glList);
+ glColor(Color3::white());
+ if(!children.empty())
+ {
+ for(size_t i = 0; i < children.size(); i++)
+ {
+ children.at(i)->render(rd);
+ }
+ }
+
+}
+#endif
+
+PartInstance::~PartInstance(void)
+{
+ glDeleteLists(glList, 1);
+}
+char pto[512];
+char pto2[512];
+#include
+
+static Enum::Shape::Value strEnum(TCHAR* shape)
+{
+ if(strcmp("Block", shape) == 0)
+ return Enum::Shape::Block;
+ if(strcmp("Cylinder", shape) == 0)
+ return Enum::Shape::Cylinder;
+ return Enum::Shape::Ball;
+}
+
+static TCHAR* enumStr(int shape)
+{
+ switch(shape)
+ {
+ case Enum::Shape::Block:
+ return "Block";
+ case Enum::Shape::Ball:
+ return "Ball";
+ case Enum::Shape::Cylinder:
+ return "Cylinder";
+ }
+ return "Block";
+}
+
+void PartInstance::PropUpdate(LPPROPGRIDITEM &item)
+{
+ if(strcmp(item->lpszPropName, "Color3") == 0)
+ {
+ color = Color3(GetRValue(item->lpCurValue)/255.0F,GetGValue(item->lpCurValue)/255.0F,GetBValue(item->lpCurValue)/255.0F);
+ changed=true;
+ }
+ if(strcmp(item->lpszPropName, "Anchored") == 0)
+ {
+ anchored= item->lpCurValue == TRUE;
+ changed=true;
+ }
+ else if(strcmp(item->lpszPropName, "Offset") == 0)
+ {
+ std::string str = (LPTSTR)item->lpCurValue;
+ std::vector vect;
+ std::stringstream ss(str);
+ float i;
+
+ while (ss >> i)
+ {
+ vect.push_back(i);
+
+ if (ss.peek() == ',')
+ ss.ignore();
+ }
+
+ //if(vect.size() != 3)
+ //{
+ //sprintf(pto, "%g, %g, %g", cFrame.translation.x, cFrame.translation.y, cFrame.translation.z, "what");
+ //LPCSTR str = LPCSTR(pto);
+ //item->lpCurValue = (LPARAM)str;
+ //}
+ //else
+ if(vect.size() == 3)
+ {
+ Vector3 pos(vect.at(0),vect.at(1),vect.at(2));
+ setPosition(pos);
+ }
+ }
+
+ else if(strcmp(item->lpszPropName, "Size") == 0)
+ {
+ std::string str = (LPTSTR)item->lpCurValue;
+ std::vector vect;
+ std::stringstream ss(str);
+ float i;
+
+ while (ss >> i)
+ {
+ vect.push_back(i);
+
+ if (ss.peek() == ',')
+ ss.ignore();
+ }
+
+ /*if(vect.size() != 3)
+ {
+ sprintf(pto, "%g, %g, %g", cFrame.translation.x, cFrame.translation.y, cFrame.translation.z, "what");
+ LPCSTR str = LPCSTR(pto);
+ item->lpCurValue = (LPARAM)str;
+ }
+ else*/
+ if(vect.size() == 3)
+ {
+ Vector3 size(vect.at(0),vect.at(1),vect.at(2));
+ setSize(size);
+ }
+ }
+ if(strcmp(item->lpszPropName, "Shape") == 0)
+ {
+ printf("%s", enumStr(strEnum((TCHAR*)item->lpCurValue)));
+ setShape(strEnum((TCHAR*)item->lpCurValue));
+ }
+ else PVInstance::PropUpdate(item);
+}
+
+
+
+std::vector PartInstance::getProperties()
+{
+ std::vector properties = PVInstance::getProperties();
+
+
+ properties.push_back(createPGI(
+ "Properties",
+ "Color3",
+ "The color of the selected part",
+ RGB((color.r*255),(color.g*255),(color.b*255)),
+ PIT_COLOR
+ ));
+ properties.push_back(createPGI(
+ "Item",
+ "Anchored",
+ "Whether the block can move or not",
+ (LPARAM)anchored,
+ PIT_CHECK
+ ));
+ sprintf_s(pto, "%g, %g, %g", position.x, position.y, position.z);
+ properties.push_back(createPGI(
+ "Item",
+ "Offset",
+ "The position of the object in the workspace",
+ (LPARAM)pto,
+ PIT_EDIT
+ ));
+ sprintf_s(pto2, "%g, %g, %g", size.x, size.y, size.z);
+ properties.push_back(createPGI(
+ "Item",
+ "Size",
+ "The position of the object in the workspace",
+ (LPARAM)pto2,
+ PIT_EDIT
+ ));
+ properties.push_back(createPGI(
+ "Item",
+ "Shape",
+ "The shape of the object in the workspace",
+ (LPARAM)enumStr(shape),
+ PIT_COMBO,
+ TEXT("Ball\0Block\0Cylinder\0")
+ ));
+ return properties;
+}
+
+
diff --git a/src/source/DataModelV2/TextButtonInstance.cpp b/src/source/DataModelV2/TextButtonInstance.cpp
new file mode 100644
index 0000000..f8b9cb5
--- /dev/null
+++ b/src/source/DataModelV2/TextButtonInstance.cpp
@@ -0,0 +1,117 @@
+#include "DataModelV2/TextButtonInstance.h"
+
+
+TextButtonInstance::TextButtonInstance(void)
+{
+ BaseButtonInstance::BaseButtonInstance();
+ boxBegin = Vector2(0,0);
+ boxEnd = Vector2(0,0);
+ fontLocationRelativeTo = Vector2(0,0);
+ centeredWithinBox = false;
+ title = "TextBox";
+ textColor = Color4(1, 1, 1, 1);
+ textOutlineColor = Color4(0, 0, 0, 0);
+ boxColor = Color4(0.6F,0.6F,0.6F,0.4F);
+ boxOutlineColor = Color4(0, 0, 0, 0);
+ setAllColorsSame();
+ textSize = 12;
+ floatBottom = false;
+ floatRight = false;
+ floatCenter = false;
+ visible = true;
+ className = "TextButton";
+ disabled = false;
+ selected = false;
+}
+
+bool TextButtonInstance::mouseInButton(float mousex, float mousey, RenderDevice* rd)
+{
+ Vector3 point1;
+ Vector3 point2;
+ if(floatBottom)
+ {
+ point1 = Vector3(boxBegin.x, rd->getHeight() + boxBegin.y,0);
+ point2 = Vector3(boxEnd.x, rd->getHeight() + boxEnd.y,0);
+
+ }
+ else
+ {
+ point1 = Vector3(boxBegin.x, boxBegin.y,0);
+ point2 = Vector3(boxEnd.x, boxEnd.y,0);
+ }
+ if(mousex >= point1.x && mousey >= point1.y)
+ {
+ if(mousex < point2.x && mousey < point2.y)
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+void TextButtonInstance::setAllColorsSame()
+{
+ textColorOvr = textColor;
+ textOutlineColorOvr = textOutlineColor;
+ boxColorOvr = boxColor;
+ boxOutlineColorOvr = boxOutlineColor;
+ textColorDn = textColor;
+ textOutlineColorDn = textOutlineColor;
+ boxColorDn = boxColor;
+ boxOutlineColorDn = boxOutlineColor;
+ textColorDis = textColor;
+ textOutlineColorDis = textOutlineColor;
+ boxColorDis = boxColor;
+ boxOutlineColorDis = boxOutlineColor;
+}
+
+TextButtonInstance::~TextButtonInstance(void)
+{
+}
+
+void TextButtonInstance::drawObj(RenderDevice* rd, Vector2 mousePos, bool mouseDown)
+{
+ Vector3 point1;
+ Vector3 point2;
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glDisableClientState(GL_COLOR_ARRAY);
+
+ if(floatBottom)
+ {
+ point1 = Vector3(boxBegin.x, rd->getHeight() + boxBegin.y,0);
+ point2 = Vector3(boxEnd.x, rd->getHeight() + boxEnd.y,0);
+
+ }
+ else
+ {
+ point1 = Vector3(boxBegin.x, boxBegin.y,0);
+ point2 = Vector3(boxEnd.x, boxEnd.y,0);
+ }
+ Vector2 RelativeTo = Vector2(point1.x + fontLocationRelativeTo.x, point1.y + fontLocationRelativeTo.y);
+ if(disabled)
+ {
+ Draw::box(Box(point1, point2), rd, boxColorDis, boxOutlineColorDis);
+ font->draw2D(rd, title, RelativeTo, textSize, textColorDis, textOutlineColorDis);
+ }
+ else if(mouseInArea(point1.x, point1.y, point2.x, point2.y, mousePos.x, mousePos.y) && mouseDown)
+ {
+ Draw::box(Box(point1, point2), rd, boxColorDn, boxOutlineColorDn);
+ font->draw2D(rd, title, RelativeTo, textSize, textColorDn, textOutlineColorDn);
+ }
+ else if(selected || mouseInArea(point1.x, point1.y, point2.x, point2.y, mousePos.x, mousePos.y))
+ {
+ Draw::box(Box(point1, point2), rd, boxColorOvr, boxOutlineColorOvr);
+ font->draw2D(rd, title, RelativeTo, textSize, textColorOvr, textOutlineColorOvr);
+ }
+ else
+ {
+ Draw::box(Box(point1, point2), rd, boxColor, boxOutlineColor);
+ font->draw2D(rd, title, RelativeTo, textSize, textColor, textOutlineColor);
+ }
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glEnableClientState(GL_COLOR_ARRAY);
+}
+
+void doNullCheck()
+{
+}
\ No newline at end of file
diff --git a/src/source/DataModelV2/ToggleImageButtonInstance.cpp b/src/source/DataModelV2/ToggleImageButtonInstance.cpp
new file mode 100644
index 0000000..34267c4
--- /dev/null
+++ b/src/source/DataModelV2/ToggleImageButtonInstance.cpp
@@ -0,0 +1,139 @@
+#include "DataModelV2/ToggleImageButtonInstance.h"
+
+ToggleImageButtonInstance::ToggleImageButtonInstance(G3D::TextureRef newImage,
+ G3D::TextureRef overImage,
+ G3D::TextureRef downImage,
+ G3D::TextureRef disableImage,
+ G3D::TextureRef newImage2,
+ G3D::TextureRef overImage2,
+ G3D::TextureRef downImage2,
+ G3D::TextureRef disableImage2) : ImageButtonInstance(newImage, overImage, downImage, disableImage)
+{
+ image2 = newImage2;
+ openGLID2 = image2->getOpenGLID();
+ image_ovr2 = overImage2;
+ if(!image_ovr2.isNull())
+ openGLID2_ovr = image_ovr2->getOpenGLID();
+ image_dn2 = downImage2;
+ if(!image_dn2.isNull())
+ openGLID2_dn = image_dn2->getOpenGLID();
+ image_ds2 = disableImage2;
+ if(!image_ds2.isNull())
+ openGLID2_ds = image_ds2->getOpenGLID();
+ checked = false;
+ className = "ToggleImageButton";
+}
+
+ToggleImageButtonInstance::~ToggleImageButtonInstance(void)
+{
+ //Delete everything on destruction
+ image2.~ReferenceCountedPointer();
+ delete image2.getPointer();
+ image_ovr2.~ReferenceCountedPointer();
+ delete image_ovr2.getPointer();
+ image_ds2.~ReferenceCountedPointer();
+ delete image_ds2.getPointer();
+ image_dn2.~ReferenceCountedPointer();
+ delete image_dn2.getPointer();
+ image = NULL;
+ image_ovr = NULL;
+ image_ds = NULL;
+ image_dn = NULL;
+ delete listener;
+ listener = NULL;
+ selected = false;
+}
+
+
+void ToggleImageButtonInstance::drawObj(RenderDevice* rd, Vector2 mousePos, bool mouseDown)
+{
+ bool drawDisabledBox = false;
+ Vector2 positionRelative = position;
+ if(floatRight && floatBottom)
+ {
+ positionRelative = Vector2(rd->getWidth() + position.x, rd->getHeight() + position.y);
+ }
+ else if(floatBottom)
+ {
+ positionRelative = Vector2(position.x, rd->getHeight() + position.y);
+ }
+ else if(floatRight)
+ {
+ positionRelative = Vector2(rd->getWidth() + position.x, position.y);
+ }
+ int renderimage = openGLID;
+ if(checked)
+ {
+ renderimage = openGLID2;
+ if(selected == true && !image_dn2.isNull() && !disabled)
+ {
+ renderimage = openGLID2_dn;
+ }
+ else if(disabled)
+ {
+ if(!image_ds2.isNull())
+ renderimage = openGLID2_ds;
+ else
+ drawDisabledBox = true;
+ }
+ else if(mouseInArea(positionRelative.x, positionRelative.y, positionRelative.x + size.x, positionRelative.y + size.y, mousePos.x, mousePos.y))
+ {
+ if(mouseDown && !image_dn2.isNull())
+ {
+ renderimage = openGLID2_dn;
+ }
+ else if(!image_ovr2.isNull())
+ {
+ renderimage = openGLID2_ovr;
+ }
+ }
+ }
+ else
+ {
+ if(selected == true && !image_dn.isNull() && !disabled)
+ {
+ renderimage = openGLID_dn;
+ }
+ else if(disabled)
+ {
+ if(!image_ds.isNull())
+ renderimage = openGLID_ds;
+ else
+ drawDisabledBox = true;
+ }
+ else if(mouseInArea(positionRelative.x, positionRelative.y, positionRelative.x + size.x, positionRelative.y + size.y, mousePos.x, mousePos.y))
+ {
+ if(mouseDown && !image_dn.isNull())
+ {
+ renderimage = openGLID_dn;
+ }
+ else if(!image_ovr.isNull())
+ {
+ renderimage = openGLID_ovr;
+ }
+ }
+ }
+
+
+
+ glEnable( GL_TEXTURE_2D );
+ glEnable(GL_BLEND);// you enable blending function
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glBindTexture( GL_TEXTURE_2D, renderimage);
+ glBegin( GL_QUADS );
+ glTexCoord2d(0.0,0.0);
+ glVertex2f( positionRelative.x, positionRelative.y );
+ glTexCoord2d( 1.0,0.0 );
+ glVertex2f( positionRelative.x + size.x, positionRelative.y );
+ glTexCoord2d( 1.0,1.0 );
+ glVertex2f( positionRelative.x + size.x, positionRelative.y + size.y );
+ glTexCoord2d( 0.0,1.0 );
+ glVertex2f( positionRelative.x, positionRelative.y + size.y );
+ glEnd();
+ glDisable( GL_TEXTURE_2D );
+
+ if(drawDisabledBox)
+ {
+ Draw::box(Box(Vector3(positionRelative.x, positionRelative.y, 0), Vector3(positionRelative.x+size.x, positionRelative.y+size.y, 0)), rd, Color4(0.7F,0.7F,0.7F,0.3F), Color4::clear());
+ }
+}
\ No newline at end of file
diff --git a/src/source/DataModelV2/WorkspaceInstance.cpp b/src/source/DataModelV2/WorkspaceInstance.cpp
new file mode 100644
index 0000000..a0d2a00
--- /dev/null
+++ b/src/source/DataModelV2/WorkspaceInstance.cpp
@@ -0,0 +1,14 @@
+#include "DataModelV2/WorkspaceInstance.h"
+
+
+WorkspaceInstance::WorkspaceInstance(void)
+{
+ GroupInstance::GroupInstance();
+ name = "Workspace";
+ className = "Workspace";
+ canDelete = false;
+}
+
+WorkspaceInstance::~WorkspaceInstance(void)
+{
+}
diff --git a/src/source/Listener/ButtonListener.cpp b/src/source/Listener/ButtonListener.cpp
index 74799f2..c02b555 100644
--- a/src/source/Listener/ButtonListener.cpp
+++ b/src/source/Listener/ButtonListener.cpp
@@ -1,4 +1,4 @@
-#include "DataModel/BaseButtonInstance.h"
+#include "DataModelV2/BaseButtonInstance.h"
#include "Listener/ButtonListener.h"
diff --git a/src/source/Listener/MenuButtonListener.cpp b/src/source/Listener/MenuButtonListener.cpp
index c2298ee..ab644c8 100644
--- a/src/source/Listener/MenuButtonListener.cpp
+++ b/src/source/Listener/MenuButtonListener.cpp
@@ -1,5 +1,5 @@
#include "Listener/MenuButtonListener.h"
-#include "DataModel/ToggleImageButtonInstance.h"
+#include "DataModelV2/ToggleImageButtonInstance.h"
#include "Application.h"
#include "Globals.h"
void MenuButtonListener::onButton1MouseClick(BaseButtonInstance* button)
diff --git a/src/source/Listener/ModeSelectionListener.cpp b/src/source/Listener/ModeSelectionListener.cpp
index 336fbab..a311e0d 100644
--- a/src/source/Listener/ModeSelectionListener.cpp
+++ b/src/source/Listener/ModeSelectionListener.cpp
@@ -1,5 +1,5 @@
#include "Globals.h"
-#include "DataModel/Instance.h"
+#include "DataModelV2/Instance.h"
#include "Listener/ModeSelectionListener.h"
#include "Application.h"
#include "Tool/ArrowTool.h"
diff --git a/src/source/Listener/RotateButtonListener.cpp b/src/source/Listener/RotateButtonListener.cpp
index 4c655bb..d2d1b6b 100644
--- a/src/source/Listener/RotateButtonListener.cpp
+++ b/src/source/Listener/RotateButtonListener.cpp
@@ -1,4 +1,4 @@
-#include "DataModel/BaseButtonInstance.h"
+#include "DataModelV2/BaseButtonInstance.h"
#include "Listener/RotateButtonListener.h"
#include "Globals.h"
#include "AudioPlayer.h"