CSPublic/Blocks3D
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added dragger tool, removed useless stuff

Browse Source
This commit is contained in:
FlareMicrosystems
2022-10-15 16:43:06 -07:00
parent efbc832321
commit 575f5dab46
23 changed files with 45 additions and 3322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
Blocks3D.vcproj
View File

@@ -321,6 +321,10 @@
RelativePath=".\src\source\Tool\ArrowTool.cpp"
>
</File>
<File
RelativePath=".\src\source\Tool\DraggerTool.cpp"
>
</File>
<File
RelativePath=".\src\source\Tool\SurfaceTool.cpp"
>
@@ -506,7 +510,7 @@
</FileConfiguration>
</File>
<File
RelativePath=".\src\source\DataModel\SelectionService.cpp"
RelativePath=".\src\source\DataModelV2\SelectionService.cpp"
>
</File>
<File
@@ -850,6 +854,10 @@
RelativePath=".\src\include\Tool\ArrowTool.h"
>
</File>
<File
RelativePath=".\src\include\Tool\DraggerTool.h"
>
</File>
<File
RelativePath=".\src\include\Tool\SurfaceTool.h"
>

1
src/include/DataModelV2/LightingInstance.h
View File

@@ -27,7 +27,6 @@ public:
void suppressSky(bool doSuppress);
void update();
void drawEffects();
void drawOutlines(Vector3 from, Vector3 to, RenderDevice* rd, Vector3 size, Vector3 pos, CoordinateFrame c);
// Properties
void PropUpdate(LPPROPGRIDITEM &pItem);

1
src/include/DataModelV2/SelectionService.h
View File

@@ -15,6 +15,7 @@ public:
void removeSelected(Instance * instance);
void addSelected(const std::vector<Instance *> &instances);
void setPropertyWindow(PropertyWindow * propertyWindow);
void render(RenderDevice * rd);
private:
std::vector<Instance *> selection;
PropertyWindow * propertyWindow;

4
src/include/Mouse.h
View File

@@ -27,8 +27,10 @@ public:
bool isMouseOnScreen();
bool isMouseDown();
void setMouseDown(bool mouseDown);
G3D::Ray * getRay();
G3D::Ray getRay();
G3D::Ray getLastRay();
G3D::Plane getPlane();
G3D::Plane getInversePlane();
private:
bool mouseDown;
};

1
src/include/Tool/Tool.h
View File

@@ -26,6 +26,7 @@ public:
virtual void onMouseScroll(Mouse);//Kinda
virtual void onKeyDown(int);//yes
virtual void onKeyUp(int);//yes
virtual void render(RenderDevice * rd, Mouse mouse);//yes
//virtual int getCursorId();//yes
protected:
//virtual void setCursor(std::string);

62
src/source/DataModel/BaseButtonInstance.cpp
View File

@@ -1,62 +0,0 @@
#include "DataModel/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;
}

613
src/source/DataModel/DataModelInstance.cpp
View File

@@ -1,613 +0,0 @@
#include <string>
#include "DataModel/GuiRootInstance.h"
#include "DataModel/DataModelInstance.h"
#include <fstream>
#include <iostream>
#include <sstream>
#include <commdlg.h>
#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<Instance*> inst = getAllChildren();
for(size_t i = 0; i < inst.size(); i++)
{
if(PartInstance* moveTo = dynamic_cast<PartInstance*>(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;
}

77
src/source/DataModel/GroupInstance.cpp
View File

@@ -1,77 +0,0 @@
#include "DataModel/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<PROPGRIDITEM> GroupInstance::getProperties()
{
std::vector<PROPGRIDITEM> properties = PVInstance::getProperties();
return properties;
}
void GroupInstance::PropUpdate(LPPROPGRIDITEM &pItem)
{
PVInstance::PropUpdate(pItem);
}
std::vector<Instance *> GroupInstance::unGroup()
{
std::vector<Instance *> 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();
}
}

538
src/source/DataModel/GuiRootInstance.cpp
View File

@@ -1,538 +0,0 @@
#include <iomanip>
#include <sstream>
#include "G3DAll.h"
#include "DataModel/BaseButtonInstance.h"
#include "DataModel/TextButtonInstance.h"
#include "DataModel/ImageButtonInstance.h"
#include "DataModel/ToggleImageButtonInstance.h"
#include "DataModel/GuiRootInstance.h"
#include "DataModel/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<Instance*> instances_2D = g_dataModel->getGuiRoot()->getAllChildren();
for(size_t i = 0; i < instances_2D.size(); i++)
{
if(BaseButtonInstance* button = dynamic_cast<BaseButtonInstance*>(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<Instance*> instances_2D = this->getAllChildren();
for(size_t i = 0; i < instances_2D.size(); i++)
{
if(BaseButtonInstance* button = dynamic_cast<BaseButtonInstance*>(instances_2D[i]))
{
if(button->mouseInButton(x, y, renderDevice))
{
button->onMouseClick();
}
}
}
}

133
src/source/DataModel/ImageButtonInstance.cpp
View File

@@ -1,133 +0,0 @@
#include "DataModel/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());
}
}

169
src/source/DataModel/Instance.cpp
View File

@@ -1,169 +0,0 @@
#define WINVER 0x0400
#include <G3DAll.h>
#include "DataModel/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<PROPGRIDITEM> Instance::getProperties()
{
std::vector<PROPGRIDITEM> 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* > Instance::getChildren()
{
return children;
}
std::vector<Instance* > Instance::getAllChildren()
{
if(!children.empty())
{
std::vector<Instance* > totalchildren = children;
for(size_t i = 0; i < children.size(); i++)
{
std::vector<Instance* > 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;
}

73
src/source/DataModel/LevelInstance.cpp
View File

@@ -1,73 +0,0 @@
#include "DataModel/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<PROPGRIDITEM> LevelInstance::getProperties()
{
std::vector<PROPGRIDITEM> 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);
}

108
src/source/DataModel/PVInstance.cpp
View File

@@ -1,108 +0,0 @@
#include "DataModel/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<PROPGRIDITEM> PVInstance::getProperties()
{
std::vector<PROPGRIDITEM> 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);
}

1124
src/source/DataModel/PartInstance.cpp
View File

File diff suppressed because it is too large Load Diff

58
src/source/DataModel/SelectionService.cpp
View File

@@ -1,58 +0,0 @@
#include "DataModelV2/SelectionService.h"
SelectionService::SelectionService(void){
Instance::Instance();
propertyWindow = NULL;
}
SelectionService::~SelectionService(void){
}
SelectionService::SelectionService(const SelectionService &oinst){
Instance::Instance(oinst);
propertyWindow = NULL;
}
std::vector<Instance *> SelectionService::getSelection(){
return this->selection;
}
void SelectionService::clearSelection(){
this->selection.clear();
if(propertyWindow != NULL)
propertyWindow->ClearProperties();
printf("selectionSize: %d\n", selection.size());
}
bool SelectionService::isSelected(Instance * instance){
return std::find(selection.begin(), selection.end(), instance) != selection.end();
}
void SelectionService::addSelected(Instance * instance){
if(!isSelected(instance))
this->selection.push_back(instance);
if(propertyWindow != NULL)
propertyWindow->UpdateSelected(selection);
printf("selectionSize: %d\n", selection.size());
}
void SelectionService::removeSelected(Instance * instance){
selection.erase(std::remove(selection.begin(), selection.end(), instance), selection.end());
if(propertyWindow != NULL)
propertyWindow->UpdateSelected(selection);
printf("selectionSize: %d\n", selection.size());
}
void SelectionService::addSelected(const std::vector<Instance *> &instances){
for(size_t i = 0; i < instances.size(); i++)
{
if(!isSelected(instances[i]))
this->selection.push_back(instances[i]);
}
if(propertyWindow != NULL)
propertyWindow->UpdateSelected(selection);
printf("selectionSize: %d\n", selection.size());
}
void SelectionService::setPropertyWindow(PropertyWindow * propertyWindow)
{
this->propertyWindow = propertyWindow;
if(propertyWindow != NULL)
propertyWindow->ClearProperties();
printf("selectionSize: %d\n", selection.size());
}

117
src/source/DataModel/TextButtonInstance.cpp
View File

@@ -1,117 +0,0 @@
#include "DataModel/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()
{
}

139
src/source/DataModel/ToggleImageButtonInstance.cpp
View File

@@ -1,139 +0,0 @@
#include "DataModel/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());
}
}

14
src/source/DataModel/WorkspaceInstance.cpp
View File

@@ -1,14 +0,0 @@
#include "DataModel/WorkspaceInstance.h"
WorkspaceInstance::WorkspaceInstance(void)
{
GroupInstance::GroupInstance();
name = "Workspace";
className = "Workspace";
canDelete = false;
}
WorkspaceInstance::~WorkspaceInstance(void)
{
}

91
src/source/DataModelV2/LightingInstance.cpp
View File

@@ -156,24 +156,10 @@ void LightingInstance::update()
glDisableClientState(GL_NORMAL_ARRAY);
rd->setObjectToWorldMatrix(forDraw);
rd->afterPrimitive();
g_dataModel->getSelectionService()->render(rd);
g_usableApp->tool->render(rd, g_usableApp->mouse);
// Draw outlines
for(size_t i = 0; i < g_dataModel->getSelectionService()->getSelection().size(); i++)
{
if(PartInstance* part = dynamic_cast<PartInstance*>(g_dataModel->getSelectionService()->getSelection()[i]))
{
Vector3 size = part->getSize();
Vector3 pos = part->getPosition();
drawOutlines(
Vector3(0+size.x/2, 0+size.y/2, 0+size.z/2) ,
Vector3(0-size.x/2,0-size.y/2,0-size.z/2),
rd,
Vector3(size.x/2, size.y/2, size.z/2),
Vector3(pos.x, pos.y, pos.z),
part->getCFrame()
);
}
}
rd->disableLighting();
@@ -186,75 +172,4 @@ void LightingInstance::drawEffects()
if (sky.notNull()) {
sky->renderLensFlare(rd, lighting);
}
}
void LightingInstance::drawOutlines(Vector3 from, Vector3 to, RenderDevice* rd, Vector3 size, Vector3 pos, CoordinateFrame c)
{
Color3 outline = Color3::cyan();
float offsetSize = 0.05F;
//X
Draw::box(c.toWorldSpace(Box(Vector3(from.x - offsetSize, from.y + offsetSize, from.z + offsetSize), Vector3(to.x + offsetSize, from.y - offsetSize, from.z - offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(from.x - offsetSize, to.y + offsetSize, from.z + offsetSize), Vector3(to.x + offsetSize, to.y - offsetSize, from.z - offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(from.x - offsetSize, to.y + offsetSize, to.z + offsetSize), Vector3(to.x + offsetSize, to.y - offsetSize, to.z - offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(from.x - offsetSize, from.y + offsetSize, to.z + offsetSize), Vector3(to.x + offsetSize, from.y - offsetSize, to.z - offsetSize))), rd, outline, Color4::clear());
//Y
Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, from.y - offsetSize + 0.1, from.z + offsetSize), Vector3(from.x - offsetSize, to.y + offsetSize - 0.1, from.z - offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(to.x + offsetSize, from.y - offsetSize + 0.1, from.z + offsetSize), Vector3(to.x - offsetSize, to.y + offsetSize - 0.1, from.z - offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(to.x + offsetSize, from.y - offsetSize + 0.1, to.z + offsetSize), Vector3(to.x - offsetSize, to.y + offsetSize-0.1, to.z - offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, from.y - offsetSize + 0.1, to.z + offsetSize), Vector3(from.x - offsetSize, to.y + offsetSize - 0.1, to.z - offsetSize))), rd, outline, Color4::clear());
//Z
Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, from.y + offsetSize, from.z - offsetSize), Vector3(from.x - offsetSize, from.y - offsetSize, to.z + offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(from.x + offsetSize, to.y + offsetSize, from.z - offsetSize), Vector3(from.x - offsetSize, to.y - offsetSize, to.z + offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(to.x + offsetSize, from.y + offsetSize, from.z - offsetSize), Vector3(to.x - offsetSize, from.y - offsetSize, to.z + offsetSize))), rd, outline, Color4::clear());
Draw::box(c.toWorldSpace(Box(Vector3(to.x + offsetSize, to.y + offsetSize, from.z - offsetSize), Vector3(to.x - offsetSize, to.y - offsetSize, to.z + offsetSize))), rd, outline, Color4::clear());
if(g_usableApp->getMode() == ARROWS)
{
AABox box;
c.toWorldSpace(Box(from, to)).getBounds(box);
float max = box.high().y - pos.y;
Draw::arrow(pos, Vector3(0, 1.5+max, 0), rd);
Draw::arrow(pos, Vector3(0, (-1.5)-max, 0), rd);
max = box.high().x - pos.x;
Draw::arrow(pos, Vector3(1.5+max, 0, 0), rd);
Draw::arrow(pos, Vector3((-1.5)-max, 0, 0), rd);
max = box.high().z - pos.z;
Draw::arrow(pos, Vector3(0, 0, 1.5+max), rd);
Draw::arrow(pos, Vector3(0, 0, (-1.5)-max), rd);
}
else if(g_usableApp->getMode() == RESIZE)
{
Color3 sphereColor = outline;
Vector3 gamepoint = pos;
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 < 200)
{
float multiplier = distance * 0.025F/2;
if(multiplier < 0.25F)
multiplier = 0.25F;
Vector3 position = pos + (c.lookVector()*((size.z)+1));
Draw::sphere(Sphere(position, multiplier), rd, sphereColor, Color4::clear());
position = pos - (c.lookVector()*((size.z)+1));
Draw::sphere(Sphere(position, multiplier), rd, sphereColor, Color4::clear());
position = pos + (c.rightVector()*((size.x)+1));
Draw::sphere(Sphere(position, multiplier), rd, sphereColor, Color4::clear());
position = pos - (c.rightVector()*((size.x)+1));
Draw::sphere(Sphere(position, multiplier), rd, sphereColor, Color4::clear());
position = pos + (c.upVector()*((size.y)+1));
Draw::sphere(Sphere(position, multiplier), rd, sphereColor, Color4::clear());
position = pos - (c.upVector()*((size.y)+1));
Draw::sphere(Sphere(position, multiplier), rd, sphereColor, Color4::clear());
}
}
}

9
src/source/Listener/ModeSelectionListener.cpp
View File

@@ -3,9 +3,11 @@
#include "Listener/ModeSelectionListener.h"
#include "Application.h"
#include "Tool/ArrowTool.h"
#include "Tool/DraggerTool.h"
void ModeSelectionListener::onButton1MouseClick(BaseButtonInstance* button)
{
//CoordinateFrame frame = g_usableApp->g3dCamera.getCoordinateFrame();
int mode = g_usableApp->getMode();
std::vector<Instance*> instances_2D = g_dataModel->getGuiRoot()->getAllChildren();
@@ -22,7 +24,12 @@ void ModeSelectionListener::onButton1MouseClick(BaseButtonInstance* button)
if(button->name == "Cursor")
g_usableApp->changeTool(new ArrowTool());
else if(button->name == "Resize")
{
g_usableApp->setMode(RESIZE);
}
else if(button->name == "Arrows")
g_usableApp->setMode(ARROWS);
{
g_usableApp->changeTool(new DraggerTool());
g_usableApp->setMode(NULL);
}
}

20
src/source/Mouse.cpp
View File

@@ -33,9 +33,9 @@ PartInstance * Mouse::getTarget()
return selectedInstance;
}
G3D::Ray * Mouse::getRay()
G3D::Ray Mouse::getRay()
{
return &g_usableApp->cameraController.getCamera()->worldRay(x, y, g_usableApp->getRenderDevice()->getViewport());
return g_usableApp->cameraController.getCamera()->worldRay(x, y, g_usableApp->getRenderDevice()->getViewport());
}
G3D::Ray Mouse::getLastRay()
@@ -43,6 +43,22 @@ G3D::Ray Mouse::getLastRay()
return testRay;
}
G3D::Plane Mouse::getPlane()
{
G3D::Ray ray = g_usableApp->cameraController.getCamera()->worldRay(x, y, g_usableApp->getRenderDevice()->getViewport());
Vector3 origin = Vector3(ray.origin.x, ray.origin.y, ray.origin.z);
Vector3 direction = -Vector3(ray.direction.x, ray.direction.y, ray.direction.z);
return G3D::Plane(origin, origin+Vector3(0,1,0), origin+direction);
}
G3D::Plane Mouse::getInversePlane()
{
G3D::Ray ray = g_usableApp->cameraController.getCamera()->worldRay(x, y, g_usableApp->getRenderDevice()->getViewport());
Vector3 origin = Vector3(ray.origin.x, ray.origin.y, ray.origin.z);
Vector3 direction = Vector3(ray.direction.x, ray.direction.y, ray.direction.z);
return G3D::Plane(origin, origin+Vector3(0,1,0), origin+direction);
}
double getVectorDistance(Vector3 vector1, Vector3 vector2)
{

4
src/source/Tool/Tool.cpp
View File

@@ -2,7 +2,6 @@
Tool::Tool(void)
{
}
Tool::~Tool(void)
@@ -20,4 +19,5 @@ void Tool::onSelect(Mouse mouse){}
void Tool::onDeselect(Mouse mouse){}
void Tool::onMouseScroll(Mouse mouse){}
void Tool::onKeyDown(int key){}
void Tool::onKeyUp(int key){}
void Tool::onKeyUp(int key){}
void Tool::render(RenderDevice * rd, Mouse mouse){}

1
src/source/main.cpp
View File

@@ -137,7 +137,6 @@ LRESULT CALLBACK G3DProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
return DefWindowProc(hwnd, msg, wParam, lParam);
}
}
return 0;
}