No Pity for the Masses

var rotateSpeed : float = 1.0;
var center : Vector3 = Vector3.zero;
var prefab : Transform;
 
 
private var windowRect : Rect = new Rect(0,0,150,50);
 
function Awake(){
	///calculate model center;
	var mesh : Mesh = GetComponent(MeshFilter).mesh;
	var bounds = mesh.bounds;
 
	///Be sure to apply all transformations current present in the model.
	center = mesh.bounds.center;
	center = transform.rotation * center;
	center = center * transform.localScale.x;
	center += transform.position;
 
	///Draw a dummy object to the scene, not necessary but helps to debug odd centers.
	print("Center: " + center.x + "," + center.y + "," + center.z);
	Instantiate(prefab,center, Quaternion.identity);
}
 
function OnGUI () {
	windowRect = GUI.Window (0, windowRect, SpeedGUI, "Speed Control");
}
function SpeedGUI(id : int){
	rotateSpeed = GUI.HorizontalSlider (Rect (25, 25, 100, 30), rotateSpeed, 1.0, 25.0);
}
function Update () {
 
	//Key left/right & up/down key movements
	var rotZ = Input.GetAxis("Vertical");
	var rotY = Input.GetAxis("Horizontal");
 
	//Rotate model around it's center.
	transform.RotateAround(center, Vector3.up,-rotY * rotateSpeed);
	transform.RotateAround(center, Vector3.right,rotZ * rotateSpeed);
}

ref class ScpRun {
public:
	ScpRun(){
		_commandList = gcnew System::Collections::Generic::List<WinScpCmd^>;
		_scp = gcnew WinScpWrapper();
		_this = this;
		_account = gcnew String("");
	};
	bool Done(){return _bDone;}
	void Run();
	void Stop(){_this->_scp->RequestStop();}
 
	///Get/Set WinSCP account name
	property String ^Account {
		String ^ get(){return _account;}
		void set(System::String ^ s){_account = s;}
	};
protected:
 
	///WinSCP message is complete
	static void ScpMessageComplete(System::Object ^sender, WinScpEventArgs ^args);
private:
 
	///WinSCP wrapper API
	WinScpWrapper ^_scp;
 
	///Command stack (each return message from WinSCP)
	System::Collections::Generic::List<WinScpCmd^> ^_commandList;
 
	///Self-referential pointer for worker thread
	private: static ScpRun ^_this;
 
	///Worker thread complete?
	bool _bDone;
 
        ///WinSCP account name
	System::String ^_account;
};

void ScpRun::Run(){
	_bDone = false;
	{	///Create command list
 
                //The very first call MUST be to open an account name.  I suggest setting up an easy name using WinSCP that you can reference here.
                _commandList->Add(gcnew WinScpCmd(WSC_OPEN,_account));
 
                //Next we'll add a command to print the current working directory	
		_commandList->Add(gcnew WinScpCmd(WSC_PWD,""));
 
                //Now lets dump the contents of our current directory
		_commandList->Add(gcnew WinScpCmd(WSC_LS,""));
 
                //Lastly be sure to kill your connection
		_commandList->Add(gcnew WinScpCmd(WSC_CLOSE,""));
	}
 
        //Pull the first command off our command stack and call WinSCP
	WinScpCmd ^tmp = _commandList[0];
	_commandList->RemoveAt(0);
 
        //Here we send our command to WinSCP, arguments are parsed by the class
	scp->wsc_call(tmp->Command,tmp->Arguments);
 
        //Be sure to assigned a MessageComplete callback function
	scp->WSCMessageComplete += gcnew WinScpWrapper::MessageComplete(&ScpRun::ScpMessageComplete);
 
        //Tell WinSCPWrapper it's time to start
        scp->RequestStart();
}

void ScpRun::ScpMessageComplete(System::Object ^sender, WinScpEventArgs ^args){
	//Arguments only have 2 states, success or failure.
        if(!args->_bSuccess){
		switch(args->_trigger){
			case WSC_PWD:
			case WSC_LS:
			case WSC_OPEN:
			case WSC_CLOSE:
				printf("Crap-sicle our command has failed.");
				break;
			default:
				break;
		}
		printf("[Command %s failed.]\n",args->_fullCommand);
	} else {
		switch(args->_trigger){
			case WSC_LS:{
				break;
			case WSC_PWD:
				break;
			default:
				printf("Command %s complete.\n",args->_fullCommand);
				printf("   - Value: %s.\n",args->_value);
				break;
		}
	}
 
	///If command list contains more commands, run them.  (Demo only)
	if(_this->_commandList->Count > 0){
		WinScpCmd ^tmp = _this->_commandList[0];
		_this->_commandList->RemoveAt(0);
		_this->scp->wsc_call(tmp->Command,tmp->Arguments);
	} else {
		_this->_bDone = true;
	}
}

	ScpRun ^scp = gcnew ScpRun ();
	scp->Account		= "dummy_account_name";
	scp->Run();
 
	//loop until done
	while(!scp->Done()){
		Threading::Thread::Sleep(15);
	}
	//Tell SCP to stop which in turn tells our WinSCP wrapper to kill its worker thread.
	scp->Stop();

#include <GIniWrapper.h>
//gcnew String(config.getValue.....

// Bezier.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <3DIO/3DIO.h>
#include <vector>
#include <string>
 
using namespace tdio_library;
using namespace std;
 
void create_patch(float step);
void save_patch(const string &name);
void load_bez(const string &name);
 
vector<vector3> pts;
vector3 ctrlPts[4][4];
vector<std::vector<int>> faces;
 
int main(int argc, char* argv[])
{
	load_bez("config.txt");
	if(argc >= 2)create_patch(atof(argv[1]));
	else create_patch(0.2);
 
	save_patch("test.obj");
	return 0;
}
void load_bez(const string &name){
	FILE *stream = fopen(name.c_str(),"r");
	char buffer[256];
	int ct = 0;
	while(!feof(stream)){
		if(fgets(buffer,256,stream)==NULL)break;
 
		float x[4],y[4],z[4];
		char ch;
		if(buffer[0] == 'c'){
			sscanf(buffer,"%c %f %f %f %f %f %f %f %f %f %f %f %f",&ch,&x[0],&y[0],&z[0],&x[1],&y[1],&z[1],&x[2],&y[2],&z[2],&x[3],&y[3],&z[3]);
			ctrlPts[ct][0] = vector3(x[0],y[0],z[0]);
			ctrlPts[ct][1] = vector3(x[1],y[1],z[1]);
			ctrlPts[ct][2] = vector3(x[2],y[2],z[2]);
			ctrlPts[ct][3] = vector3(x[3],y[3],z[3]);
			ct++;
		}
 
		if(ct >= 4)break;
	}
	if(ct != 4){
		printf("  - Warning, read %d control lines.  Should be 4\n",ct);
	}
	fclose(stream);
}
void save_patch(const string &name){
	FILE *stream = fopen(name.c_str(),"w");
	for(int v = 0; v < pts.size(); v++){
		fprintf(stream,"v %f %f %f\n",pts[v].x,pts[v].y,pts[v].z);
	}
	for(int f = 0; f < faces.size(); f++){
		fprintf(stream,"f %d %d %d\n",faces[f][0]+1,faces[f][1]+1,faces[f][2]+1);
	}
	fclose(stream);
 
}
vector3 get_bez_pt(float u, float v){
	double tmp = 0;
	double c[4] = {1,3,3,1};
	vector3 ret(0,0,0);
	for(int i = 0; i < 4; i++){
		for(int j = 0; j < 4; j++){
			tmp = c[i]*c[j] * pow(u,i) * pow(1-u,3-i)*pow(v,j)*pow(1-v,3-j);
			ret.x += ctrlPts[i][j].cell[0] *tmp;
			ret.y += ctrlPts[i][j].cell[1] *tmp;
			ret.z += ctrlPts[i][j].cell[2] *tmp;
		}
	}
	return ret;
}
void create_patch(float step){
	printf("-- Create Patch--\n");
	printf("  - Step: %f\n",step);
 
	for(float x = 0; x < 3; x+=step){
		for(float z = 0; z < 3; z+=step){
			vector3 pt = get_bez_pt(x/3,z/3);
			pts.push_back(pt);
		}
	}
	printf("  - nPts: %d\n",pts.size());
 
	int width = (float)(3.0f/step + 1.0);
	int height = width;
 
	printf("  - Height/Width: %d\n",height);
	int f = 0;
	for(int v = 0; v < pts.size(); v++){
		if(v+width+1 >= pts.size())break;
 
		if((v+1) % (int)width != 0 || v ==0){
			std::vector<int> tmp;
			faces.push_back(tmp);
 
		        faces[f].push_back(v);
			faces[f].push_back(v+1);
			faces[f].push_back(v+width);
			f++;
 
			faces.push_back(tmp);
			faces[f].push_back(v+1);
			faces[f].push_back(v+width+1);	
			faces[f].push_back(v+width);
 
			f++;
		}
	}
	printf("  - %d faces created\n",faces.size());
}