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

2005 Model works, but is mirrored

Browse Source
This commit is contained in:
MusicalProgrammer
2018-10-30 16:10:24 -04:00
parent 33a43c5072
commit e9a13b8163
7 changed files with 76 additions and 641 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
DataModelInstance.cpp
View File

@@ -22,7 +22,7 @@ DataModelInstance::DataModelInstance(void)
mouseButton1Down = false; mouseButton1Down = false;
showMessage = false; showMessage = false;
canDelete = false; canDelete = false;
_modY=0;
workspace->setParent(this); workspace->setParent(this);
level->setParent(this); level->setParent(this);
@@ -32,6 +32,20 @@ DataModelInstance::~DataModelInstance(void)
{ {
} }
#ifdef _DEBUG
void DataModelInstance::modXMLLevel(float modY)
{
_modY += modY;
clearLevel();
load();
}
#endif
void DataModelInstance::clearLevel()
{
workspace->clearChildren();
}
PartInstance* DataModelInstance::makePart() PartInstance* DataModelInstance::makePart()
{ {
PartInstance* part = new PartInstance(); PartInstance* part = new PartInstance();
@@ -85,6 +99,7 @@ bool DataModelInstance::scanXMLObject(xml_node<> * scanNode)
xml_node<> *cFrameNode=0; xml_node<> *cFrameNode=0;
xml_node<> *sizeNode=0; xml_node<> *sizeNode=0;
xml_node<> *colorNode=0; xml_node<> *colorNode=0;
xml_node<> *nameNode=0;
for (xml_node<> *partPropNode = propNode->first_node();partPropNode; partPropNode = partPropNode->next_sibling()) for (xml_node<> *partPropNode = propNode->first_node();partPropNode; partPropNode = partPropNode->next_sibling())
{ {
@@ -97,6 +112,10 @@ bool DataModelInstance::scanXMLObject(xml_node<> * scanNode)
{ {
cFrameNode = partPropNode; cFrameNode = partPropNode;
} }
if (xmlValue=="Name")
{
nameNode = partPropNode;
}
if (xmlValue=="Color") if (xmlValue=="Color")
{ {
colorNode=partPropNode; colorNode=partPropNode;
@@ -104,6 +123,7 @@ bool DataModelInstance::scanXMLObject(xml_node<> * scanNode)
if (xmlValue=="size") if (xmlValue=="size")
{ {
sizeNode = partPropNode; sizeNode = partPropNode;
_legacyLoad=false;
} }
if (xmlValue=="Part") if (xmlValue=="Part")
{ {
@@ -116,6 +136,7 @@ bool DataModelInstance::scanXMLObject(xml_node<> * scanNode)
if (xmlValue=="size") if (xmlValue=="size")
{ {
sizeNode=featureNode; sizeNode=featureNode;
_legacyLoad=true;
} }
} }
} }
@@ -143,6 +164,7 @@ bool DataModelInstance::scanXMLObject(xml_node<> * scanNode)
B = getFloatValue(colorNode,"B"); B = getFloatValue(colorNode,"B");
} }
std::string newName = nameNode->value();
float X = getFloatValue(cFrameNode,"X"); float X = getFloatValue(cFrameNode,"X");
float Y = getFloatValue(cFrameNode,"Y"); float Y = getFloatValue(cFrameNode,"Y");
float Z = getFloatValue(cFrameNode,"Z"); float Z = getFloatValue(cFrameNode,"Z");
@@ -159,17 +181,30 @@ bool DataModelInstance::scanXMLObject(xml_node<> * scanNode)
float sizeX = getFloatValue(sizeNode,"X"); float sizeX = getFloatValue(sizeNode,"X");
float sizeY = getFloatValue(sizeNode,"Y"); float sizeY = getFloatValue(sizeNode,"Y");
float sizeZ = getFloatValue(sizeNode,"Z"); float sizeZ = getFloatValue(sizeNode,"Z");
//sizeX=1;
//sizeY=1;
//sizeZ=1;
if (_successfulLoad) { if (_successfulLoad) {
PartInstance* test = makePart(); PartInstance* test = makePart();
test->setParent(getWorkspace()); test->setParent(getWorkspace());
test->color = Color3(R,G,B); test->color = Color3(R,G,B);
test->setSize(Vector3(sizeX,sizeY,sizeZ)); test->setSize(Vector3(sizeX,sizeY+_modY,sizeZ));
test->setName(newName);
CoordinateFrame what; CoordinateFrame cf;
what.translation = Vector3(X,Y,Z);
what.rotation = Matrix3(R00,R01,R02,R10,R11,R12,R20,R21,R22); if (_legacyLoad)
test->setCFrame(what); {
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 else
{ {
@@ -193,7 +228,7 @@ bool DataModelInstance::scanXMLObject(xml_node<> * scanNode)
bool DataModelInstance::load() bool DataModelInstance::load()
{ {
ifstream levelFile("..//skooterFix.rbxm",ios::binary); ifstream levelFile("..//skooter.rbxm",ios::binary);
if (levelFile) { if (levelFile) {
levelFile.seekg(0,levelFile.end); levelFile.seekg(0,levelFile.end);
int length = levelFile.tellg(); int length = levelFile.tellg();
@@ -204,13 +239,15 @@ bool DataModelInstance::load()
xml_document<> doc; xml_document<> doc;
doc.parse<0>(buffer); doc.parse<0>(buffer);
xml_node<> *mainNode = doc.first_node(); xml_node<> *mainNode = doc.first_node();
std::string xmlName = mainNode->name(); _legacyLoad=false;
//std::string xmlName = mainNode->name();
//node = node->first_node(); //node = node->first_node();
//xmlName = node->name(); //xmlName = node->name();
scanXMLObject(mainNode); scanXMLObject(mainNode);
delete[] buffer; delete[] buffer;
} }
return true; return true;
} }

9
DataModelInstance.h
View File

@@ -30,7 +30,11 @@ public:
void setMousePos(int x,int y); void setMousePos(int x,int y);
void setMousePos(Vector2 pos); void setMousePos(Vector2 pos);
bool mouseButton1Down; bool mouseButton1Down;
PartInstance* makePart(); PartInstance* makePart();
void clearLevel();
#if _DEBUG
void modXMLLevel(float modY);
#endif
private: private:
bool isBrickCount; bool isBrickCount;
bool scanXMLObject(rapidxml::xml_node<>* node); bool scanXMLObject(rapidxml::xml_node<>* node);
@@ -38,5 +42,6 @@ private:
float getFloatValue(rapidxml::xml_node<> * node,const char* name); float getFloatValue(rapidxml::xml_node<> * node,const char* name);
bool _successfulLoad; bool _successfulLoad;
std::string _errMsg; std::string _errMsg;
bool _legacyLoad;
float _modY;
}; };

9
Instance.cpp
View File

@@ -85,6 +85,11 @@ Instance::~Instance(void)
} }
} }
void Instance::setName(std::string newName)
{
name = newName;
}
std::string Instance::getClassName() std::string Instance::getClassName()
{ {
return className; return className;
@@ -134,6 +139,10 @@ void Instance::addChild(Instance* newChild)
children.push_back(newChild); children.push_back(newChild);
} }
void Instance::clearChildren()
{
children.clear();
}
void Instance::removeChild(Instance* oldChild) void Instance::removeChild(Instance* oldChild)
{ {
for(size_t i = 0; i < children.size(); i++) for(size_t i = 0; i < children.size(); i++)

2
Instance.h
View File

@@ -17,8 +17,10 @@ public:
std::vector<Instance* > getChildren(); std::vector<Instance* > getChildren();
std::vector<Instance* > getAllChildren(); std::vector<Instance* > getAllChildren();
void setParent(Instance*); void setParent(Instance*);
void setName(std::string newName);
void addChild(Instance*); void addChild(Instance*);
void removeChild(Instance*); void removeChild(Instance*);
void clearChildren();
Instance* getParent(); Instance* getParent();
virtual Instance* clone() const { return new Instance(*this); } virtual Instance* clone() const { return new Instance(*this); }
virtual std::vector<PROPGRIDITEM> getProperties(); virtual std::vector<PROPGRIDITEM> getProperties();

563
PhysicalInstance.cpp
View File

@@ -1,563 +0,0 @@
#include "PhysicalInstance.h"
#include "Globals.h"
#include <sstream>
#include <iomanip>
using namespace G3D;
PhysicalInstance::PhysicalInstance(void) : _bevelSize(0.03f), _parseVert(0), _debugTimer(0)
{
name = "Default PhysicalInstance";
className = "Part";
canCollide = true;
anchored = true;
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;
}
PhysicalInstance::PhysicalInstance(const PhysicalInstance &oinst)
{
Instance::Instance(oinst);
//name = oinst.name;
//className = "Part";
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;
}
void PhysicalInstance::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;
float sizey = newSize.y;
if(sizey <= 0)
sizey = 0.4;
if(sizey > 512)
sizey = 512;
int sizez = (int)newSize.z;
if(sizez <= 0)
sizez = 1;
if(sizez > 512)
sizez = 512;
size = Vector3(sizex, sizey, sizez);
}
Vector3 PhysicalInstance::getSize()
{
return size;
}
Vector3 PhysicalInstance::getPosition()
{
return position;
}
void PhysicalInstance::setPosition(Vector3 pos)
{
position = pos;
cFrame = CoordinateFrame(pos);
changed = true;
}
CoordinateFrame PhysicalInstance::getCFrame()
{
return cFrame;
}
void PhysicalInstance::setCFrame(CoordinateFrame coordinateFrame)
{
cFrame = coordinateFrame;
position = coordinateFrame.translation;
changed = true;
}
CoordinateFrame PhysicalInstance::getCFrameRenderBased()
{
return CoordinateFrame(getCFrame().rotation,Vector3(getCFrame().translation.x, getCFrame().translation.y, getCFrame().translation.z));
}
#ifdef NEW_BOX_RENDER
Box PhysicalInstance::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;
}
#else
Box PhysicalInstance::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 PhysicalInstance::collides(Box box)
{
return CollisionDetection::fixedSolidBoxIntersectsFixedSolidBox(getBox(), box);
}
#ifdef NEW_BOX_RENDER
void PhysicalInstance::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 PhysicalInstance::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 PhysicalInstance::addTriangle(Vector3 v1,Vector3 v2,Vector3 v3)
{
addVertex(v1,color);
addVertex(v2,color);
addVertex(v3,color);
addNormals(cross(v2-v1,v3-v1).direction());
}
void PhysicalInstance::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 PhysicalInstance::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]));
}
bool PhysicalInstance::isUniqueVertex(Vector3 pos)
{
for (unsigned int i=0;i<_debugUniqueVertices.size();i+=1)
{
if (pos==_debugUniqueVertices[i])
{
return false;
}
}
return true;
}
void PhysicalInstance::render(RenderDevice* rd) {
if (changed)
{
getBox();
_vertices.clear();
Vector3 renderSize = size/2;
// 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);
}
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]);
glPushMatrix();
glTranslatef(position.x,position.y,position.z);
glDrawElements(GL_TRIANGLES, _indices.size(), GL_UNSIGNED_SHORT, &_indices[0]);
glPopMatrix();
}
#else
void PhysicalInstance::render(RenderDevice* rd)
{
if(changed)
{
Box box = getBox();
changed=false;
}
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_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 );
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 );
}
/*glEnd();
glDisable(GL_TEXTURE_2D);*/
glColor(Color3::white());
if(!children.empty())
{
for(size_t i = 0; i < children.size(); i++)
{
children.at(i)->render(rd);
}
}
}
#endif
PhysicalInstance::~PhysicalInstance(void)
{
}
char pto[512];
char pto2[512];
#include <sstream>
void PhysicalInstance::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);
}
else if(strcmp(item->lpszPropName, "Offset") == 0)
{
std::string str = (LPTSTR)item->lpCurValue;
std::vector<float> 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;
MessageBox(NULL, "NO","NO", MB_OK);
}
else
{
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<float> 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;
MessageBox(NULL, "NO","NO", MB_OK);
}
else
{
Vector3 size(vect.at(0),vect.at(1),vect.at(2));
setSize(size);
}
}
else Instance::PropUpdate(item);
}
std::vector<PROPGRIDITEM> PhysicalInstance::getProperties()
{
std::vector<PROPGRIDITEM> properties = Instance::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
));
sprintf(pto, "%g, %g, %g", cFrame.translation.x, cFrame.translation.y, cFrame.translation.z);
properties.push_back(createPGI(
"Item",
"Offset",
"The position of the object in the workspace",
(LPARAM)pto,
PIT_EDIT
));
sprintf(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
));
return properties;
}

65
PhysicalInstance.h
View File

@@ -1,65 +0,0 @@
#pragma once
#include "instance.h"
#include "Enum.h"
#define NEW_BOX_RENDER
class PhysicalInstance :
public Instance
{
public:
PhysicalInstance(void);
PhysicalInstance(const PhysicalInstance &oinst);
Instance* clone() const { return new PhysicalInstance(*this); }
~PhysicalInstance(void);
virtual void render(RenderDevice*);
Vector3 velocity;
Enum::SurfaceType::Value top;
Enum::SurfaceType::Value front;
Enum::SurfaceType::Value right;
Enum::SurfaceType::Value back;
Enum::SurfaceType::Value left;
Enum::SurfaceType::Value bottom;
CoordinateFrame cFrame;
Color3 color;
Vector3 getPosition();
void setPosition(Vector3);
CoordinateFrame getCFrame();
void setCFrame(CoordinateFrame);
Box getBox();
Box getScaledBox();
CoordinateFrame getCFrameRenderBased();
Vector3 getSize();
void setSize(Vector3);
bool canCollide;
bool anchored;
Vector3 rotVelocity;
bool collides(Box);
virtual std::vector<PROPGRIDITEM> getProperties();
virtual void PropUpdate(LPPROPGRIDITEM &pItem);
void addVertex(Vector3 vertexPos,Color3 color);
void addNormals(Vector3 normal);
void addTriangle(Vector3 vertexPos,Vector3 vertexPos2, Vector3 vertexPos3);
void debugPrintVertexIDs(RenderDevice* rd, GFontRef font, Matrix3 camRot);
void makeFace(int vertex1, int vertex2, int vertex3);
bool isUniqueVertex(Vector3 pos);
private:
Vector3 position;
Vector3 size;
float _bevelSize;
int _parseVert;
int _debugTimer;
std::vector<Vector3> _debugUniqueVertices;
#ifdef NEW_BOX_RENDER
std::vector<GLfloat> _vertices;
std::vector<GLfloat> _normals;
#else
GLfloat _vertices[96];
#endif
std::vector<GLushort> _indices;
bool changed;
Box itemBox;
};

12
main.cpp
View File

@@ -1248,7 +1248,7 @@ void Demo::onGraphics(RenderDevice* rd) {
Matrix4 lightMVP = lightProjectionMatrix * lightCFrame.inverse(); Matrix4 lightMVP = lightProjectionMatrix * lightCFrame.inverse();
if (GLCaps::supports_GL_ARB_shadow()) { if (GLCaps::supports_GL_ARB_shadow()) {
generateShadowMap(lightCFrame); //generateShadowMap(lightCFrame);
} }
@@ -1430,6 +1430,16 @@ void Demo::onKeyPressed(int key)
{ {
deleteInstance(); deleteInstance();
} }
#ifdef _DEBUG
if (key==VK_ADD)
{
dataModel->modXMLLevel(1);
}
if (key==VK_SUBTRACT)
{
dataModel->modXMLLevel(-1);
}
#endif
} }
void Demo::onKeyUp(int key) void Demo::onKeyUp(int key)
{ {