void bhSolve() {
octree->calculateMassAndCentre(octree); // find mass and centre of mass of octree
for(int i = 0; i < npositions; i++) { // loops over particles
Particles[i].xforce = 0; // zero the particles forces
Particles[i].yforce = 0;
Particles[i].zforce = 0;
octree->Calculateforce(octree, &Particles[i]); // calculate the force acting on the particle from all others
Particles[i].updatePosition(0.06); // update position
}
octree->~ocTree(); // call destructor or octree to clean up
octree = new ocTree(posVec(250,250,250), posVec(5000,5000,5000)); // initialise a new octree as octree
for(int i = 0; i < npositions; i++) { // loops over the particles
octree->insert(&Particles[i]); // reinsert to octree
}
}
void initialise() {
// Create an Octree centered at 250, 250, 250
// with physical dimension 10000x10000x10000
octree = new ocTree(posVec(250,250,250), posVec(5000,5000,5000));
// Create 200 positions vectors
npositions = 300;
for(int i=0; i<npositions; ++i) {
positions.push_back(randPosVec());
}
Particles = new Particle[npositions]; // array to hold particles initialised to the size of number of positions/particles
for (int i=0; i<npositions; ++i) { // loop over number of positions
Particles[i].setPosition(positions[i]); // set position of particle at i
octree->insert(&Particles[i]); // insert particle in to oct tree
}
}
void c4_FormatB::OldDefine(char type_, c4_Persist &pers_) {
int rows = Owner().NumRows();
c4_ColOfInts sizes(_data.Persist());
if (type_ == 'M') {
InitOffsets(sizes);
c4_ColOfInts szVec(_data.Persist());
pers_.FetchOldLocation(szVec);
szVec.SetRowCount(rows);
c4_ColOfInts posVec(_data.Persist());
pers_.FetchOldLocation(posVec);
posVec.SetRowCount(rows);
for (int r = 0; r < rows; ++r) {
t4_i32 sz = szVec.GetInt(r);
if (sz > 0) {
c4_Column *mc = d4_new c4_Column(_data.Persist());
d4_assert(mc != 0);
_memos.SetAt(r, mc);
mc->SetLocation(posVec.GetInt(r), sz);
}
}
} else {
pers_.FetchOldLocation(_data);
if (type_ == 'B') {
pers_.FetchOldLocation(sizes);
#if !q4_OLD_IS_ALWAYS_V2
// WARNING - HUGE HACK AHEAD - THIS IS NOT 100% FULLPROOF!
//
// The above is correct for MK versions 2.0 and up, but *NOT*
// for MK 1.8.6 datafiles, which store sizes first (OUCH!!!).
// This means that there is not a 100% safe way to auto-convert
// both 1.8.6 and 2.0 files - since there is no way to detect
// unambiguously which version a datafile is. All we can do,
// is to carefully check both vectors, and *hope* that only one
// of them is valid as sizes vector. This problem applies to
// the 'B' (bytes) property type only, and only pre 2.0 files.
//
// To build a version which *always* converts assuming 1.8.6,
// add flag "-Dq4_OLD_IS_PRE_V2" to the compiler command line.
// Conversely, "-Dq4_OLD_IS_ALWAYS_V2" forces 2.0 conversion.
if (rows > 0) {
t4_i32 s1 = sizes.ColSize();
t4_i32 s2 = _data.ColSize();
#if !q4_OLD_IS_PRE_V2
// if the size vector is clearly impossible, swap vectors
bool fix = c4_ColOfInts::CalcAccessWidth(rows, s1) < 0;
// if the other vector might be valid as well, check further
if (!fix && c4_ColOfInts::CalcAccessWidth(rows, s2) >= 0) {
sizes.SetRowCount(rows);
t4_i32 total = 0;
for (int i = 0; i < rows; ++i) {
t4_i32 w = sizes.GetInt(i);
if (w < 0 || total > s2) {
total = - 1;
break;
}
total += w;
}
// if the sizes don't add up, swap vectors
fix = total != s2;
}
if (fix)
#endif
{
t4_i32 p1 = sizes.Position();
t4_i32 p2 = _data.Position();
_data.SetLocation(p1, s1);
sizes.SetLocation(p2, s2);
}
}
#endif
InitOffsets(sizes);
} else {
d4_assert(type_ == 'S');
sizes.SetRowCount(rows);
t4_i32 pos = 0;
t4_i32 lastEnd = 0;
int k = 0;
c4_ColIter iter(_data, 0, _data.ColSize());
while (iter.Next()) {
const t4_byte *p = iter.BufLoad();
for (int j = 0; j < iter.BufLen(); ++j)
if (!p[j]) {
sizes.SetInt(k++, pos + j + 1-lastEnd);
lastEnd = pos + j + 1;
}
pos += iter.BufLen();
}
d4_assert(pos == _data.ColSize());
if (lastEnd < pos) {
// last entry had no zero byte
_data.InsertData(pos++, 1, true);
sizes.SetInt(k, pos - lastEnd);
}
InitOffsets(sizes);
// get rid of entries with just a null byte
for (int r = 0; r < rows; ++r)
if (c4_FormatB::ItemSize(r) == 1)
SetOne(r, c4_Bytes());
}
}
}
posVec randPosVec(){ // Random vector
return posVec(randLimited(), randLimited(), randLimited());
}
bool AlembicCurves::Save(double time, bool bLastFrame)
{
ESS_PROFILE_FUNC();
//TimeValue ticks = GET_MAX_INTERFACE()->GetTime();
TimeValue ticks = GetTimeValueFromFrame(time);
Object *obj = mMaxNode->EvalWorldState(ticks).obj;
if(mNumSamples == 0){
bForever = CheckIfObjIsValidForever(obj, ticks);
}
else{
bool bNewForever = CheckIfObjIsValidForever(obj, ticks);
if(bForever && bNewForever != bForever){
ESS_LOG_INFO( "bForever has changed" );
}
}
SaveMetaData(mMaxNode, this);
// check if the spline is animated
if(mNumSamples > 0)
{
if(bForever)
{
return true;
}
}
AbcG::OCurvesSchema::Sample curvesSample;
std::vector<AbcA::int32_t> nbVertices;
std::vector<Point3> vertices;
std::vector<float> knotVector;
std::vector<Abc::uint16_t> orders;
if(obj->ClassID() == EDITABLE_SURF_CLASS_ID){
NURBSSet nurbsSet;
BOOL success = GetNURBSSet(obj, ticks, nurbsSet, TRUE);
AbcG::CurvePeriodicity cPeriod = AbcG::kNonPeriodic;
AbcG::CurveType cType = AbcG::kCubic;
AbcG::BasisType cBasis = AbcG::kNoBasis;
int n = nurbsSet.GetNumObjects();
for(int i=0; i<n; i++){
NURBSObject* pObject = nurbsSet.GetNURBSObject((int)i);
//NURBSType type = pObject->GetType();
if(!pObject){
continue;
}
if( pObject->GetKind() == kNURBSCurve ){
NURBSCurve* pNurbsCurve = (NURBSCurve*)pObject;
int degree;
int numCVs;
NURBSCVTab cvs;
int numKnots;
NURBSKnotTab knots;
pNurbsCurve->GetNURBSData(ticks, degree, numCVs, cvs, numKnots, knots);
orders.push_back(degree+1);
const int cvsCount = cvs.Count();
const int knotCount = knots.Count();
for(int j=0; j<cvs.Count(); j++){
NURBSControlVertex cv = cvs[j];
double x, y, z;
cv.GetPosition(ticks, x, y, z);
vertices.push_back( Point3((float)x, (float)y, (float)z) );
}
nbVertices.push_back(cvsCount);
//skip the first and last entry because Maya and XSI use this format
for(int j=1; j<knots.Count()-1; j++){
knotVector.push_back((float)knots[j]);
}
if(i == 0){
if(pNurbsCurve->IsClosed()){
cPeriod = AbcG::kPeriodic;
}
}
else{
if(pNurbsCurve->IsClosed()){
if(cPeriod != AbcG::kPeriodic){
ESS_LOG_WARNING("Mixed curve wrap types not supported.");
}
}
else{
if(cPeriod != AbcG::kNonPeriodic){
ESS_LOG_WARNING("Mixed curve wrap types not supported.");
}
}
}
}
}
curvesSample.setType(cType);
curvesSample.setWrap(cPeriod);
curvesSample.setBasis(cBasis);
}
else
{
BezierShape beziershape;
PolyShape polyShape;
bool bBezier = false;
// Get a pointer to the spline shpae
ShapeObject *pShapeObject = NULL;
if (obj->IsShapeObject())
{
pShapeObject = reinterpret_cast<ShapeObject *>(obj);
}
else
{
return false;
}
// Determine if we are a bezier shape
if (pShapeObject->CanMakeBezier())
{
pShapeObject->MakeBezier(ticks, beziershape);
bBezier = true;
}
else
{
pShapeObject->MakePolyShape(ticks, polyShape);
bBezier = false;
}
// Get the control points
//std::vector<Point3> inTangents;
//std::vector<Point3> outTangents;
if (bBezier)
{
int oldVerticesCount = (int)vertices.size();
for (int i = 0; i < beziershape.SplineCount(); i += 1)
{
Spline3D *pSpline = beziershape.GetSpline(i);
int knots = pSpline->KnotCount();
for(int ix = 0; ix < knots; ++ix)
{
Point3 in = pSpline->GetInVec(ix);
Point3 p = pSpline->GetKnotPoint(ix);
Point3 out = pSpline->GetOutVec(ix);
vertices.push_back( p );
//inTangents.push_back( in );
//outTangents.push_back( out );
}
int nNumVerticesAdded = (int)vertices.size() - oldVerticesCount;
nbVertices.push_back( nNumVerticesAdded );
oldVerticesCount = (int)vertices.size();
}
}
else
{
for (int i = 0; i < polyShape.numLines; i += 1)
{
PolyLine &refLine = polyShape.lines[i];
nbVertices.push_back(refLine.numPts);
for (int j = 0; j < refLine.numPts; j += 1)
{
Point3 p = refLine.pts[j].p;
vertices.push_back(p);
}
}
}
// set the type + wrapping
curvesSample.setType(bBezier ? AbcG::kCubic : AbcG::kLinear);
curvesSample.setWrap(pShapeObject->CurveClosed(ticks, 0) ? AbcG::kPeriodic : AbcG::kNonPeriodic);
curvesSample.setBasis(AbcG::kNoBasis);
}
if(nbVertices.size() == 0 || vertices.size() == 0){
ESS_LOG_WARNING("No curve data to export.");
return false;
}
const int vertCount = (int)vertices.size();
// prepare the bounding box
Abc::Box3d bbox;
// allocate the points and normals
std::vector<Abc::V3f> posVec(vertCount);
Matrix3 wm = mMaxNode->GetObjTMAfterWSM(ticks);
for(int i=0;i<vertCount;i++)
{
posVec[i] = ConvertMaxPointToAlembicPoint(vertices[i] );
bbox.extendBy(posVec[i]);
// Set the archive bounding box
if (mJob)
{
Point3 worldMaxPoint = wm * vertices[i];
Abc::V3f alembicWorldPoint = ConvertMaxPointToAlembicPoint(worldMaxPoint);
mJob->GetArchiveBBox().extendBy(alembicWorldPoint);
}
}
if(knotVector.size() > 0 && orders.size() > 0){
if(!mKnotVectorProperty.valid()){
mKnotVectorProperty = Abc::OFloatArrayProperty(mCurvesSchema.getArbGeomParams(), ".knot_vector", mCurvesSchema.getMetaData(), mJob->GetAnimatedTs() );
}
mKnotVectorProperty.set(Abc::FloatArraySample(knotVector));
if(!mOrdersProperty.valid()){
mOrdersProperty = Abc::OUInt16ArrayProperty(mCurvesSchema.getArbGeomParams(), ".orders", mCurvesSchema.getMetaData(), mJob->GetAnimatedTs() );
}
mOrdersProperty.set(Abc::UInt16ArraySample(orders));
}
// store the bbox
curvesSample.setSelfBounds(bbox);
mCurvesSchema.getChildBoundsProperty().set(bbox);
Abc::Int32ArraySample nbVerticesSample(&nbVertices.front(),nbVertices.size());
curvesSample.setCurvesNumVertices(nbVerticesSample);
// allocate for the points and normals
Abc::P3fArraySample posSample(&posVec.front(),posVec.size());
curvesSample.setPositions(posSample);
mCurvesSchema.set(curvesSample);
mNumSamples++;
return true;
}
///////////////////////////////////////////////////////////
/// Entry point of application
////////////////////////////////////////////////////////////
int main()
{
float width=800,height=600;
//Create the main window and an OpenGL4.0 rendering context (compatibilty flag set)
sf::RenderWindow window(sf::VideoMode(width, height, 32), "SFML OpenGL Demo");
sf::ContextSettings cs=window.getSettings();
printf("Created an OpenGL %d.%d context [version 3.3 or greater is required for these samples]\n",cs.majorVersion,cs.minorVersion);
initialiseOpenGL(); //initialise various OpenGl Stuff (same for every program)
//create an array and populate it with vertices for a trianlge fan for a n N sided polygon
const int N =7;//num sides of our polygon
const float PI=3.141;
int arraySize=(N+2)*3; // for an N triangle-fan sided polygon, we need n+2 vertices
GLfloat *vertexPositions1= new GLfloat[arraySize];
int index=0;
vertexPositions1[index++]=0;vertexPositions1[index++]=0;vertexPositions1[index++]=0; //first vertex will be the centre at the origin
for(int i=0;i<=N;i++){
float angle=i*2*PI/N;
vertexPositions1[index++]=cos(angle); //x
vertexPositions1[index++]=sin(angle); //y
vertexPositions1[index++]=0; //z
}
//create a VBO for positions AND colours of object_1, an array of x,y,z position of 3 vertices, followed by rgb of each vertex
GLuint positionsBufferObject1; //integer variable to store the VBO handle
glGenBuffers(1, &positionsBufferObject1); //generate a new VBO, store the handle in the handle variable
glBindBuffer(GL_ARRAY_BUFFER, positionsBufferObject1); //make positionsBufferObject the 'current' VBO for next few commands
glBufferData(GL_ARRAY_BUFFER, arraySize*sizeof(GLfloat), vertexPositions1, GL_STATIC_DRAW);// push the vextex data into the VBO in video memory
//set up shader
sf::Shader shader; //create a shader object
if(!shader.loadFromFile("..//shaders//simplest_vertex.glsl","..//shaders//simplest_fragment.glsl")){
fatalError("Problem loading glsl files");
}//load shader code from these text files
sf::Shader::bind(&shader);//
glEnableVertexAttribArray(0); //open up the 0th attribute to receive data, in this case this is the 'position' attribute in the shader
sf::Vector2f posVec(0,0);
// this is our game loop
while (window.isOpen())
{
// Process events
sf::Event event;
while (window.pollEvent(event)) //process all events
{
// Close window : exit
if (event.type == sf::Event::Closed)
window.close();
// Escape key : exit
if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
window.close();
// Resize event : adjust viewport
if (event.type == sf::Event::Resized){
glViewport(0, 0, event.size.width,event.size.height); //tell opengl the window size has changed
}
/*
if ((event.type == sf::Event::KeyPressed) && (event.Key.Code == sf::Key::A)){
//do something
}
*/
}
//start rendering our scene
//update the position
//Clear color and depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindBuffer(GL_ARRAY_BUFFER, positionsBufferObject1); //make positionsBufferObject the 'current' VBO for next command
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); // tell openGL that vertex 'position' attributes are in current VBO
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glDrawArrays(GL_TRIANGLE_FAN, 0, N+2); // draw object (in positionsBufferObject1) (use N+1 vertices)
// Finally, display rendered frame in window (swap buffers)
window.display();
}// end of game loop
return EXIT_SUCCESS;
}
