Difference between revisions of "Procedurally generated geometry tutorial"

From Horde3D Wiki
Jump to: navigation, search
Line 21: Line 21:
  
 
=StreamGenerator=
 
=StreamGenerator=
 +
 +
These classes are only for creating the character stream that will contain the geometry resource.
 +
 
{{CppSourceCode|
 
{{CppSourceCode|
 
description= StreamGenerator.h|  
 
description= StreamGenerator.h|  
Line 205: Line 208:
  
 
=CustomGeometry base class=
 
=CustomGeometry base class=
 +
 +
Base class for the custom geometry. This class currently contains lots of deprecated stuff, e.g. the update() function. This function was used to update an in-memory gemoetry resource in the "punk-rock"-way. Until Horde3D Beta3 the geometry resources were read-only, so directmanipulation of vertices was impossible. To modify the vertices I had to unload the geometry resource, re-create it with the new vertex-positions and load it into Horde again. '''This is not necessary any more because since Beta4 the geometry resources are not read-only anymore.'''
 +
 +
All custom geometry classes should be derived from this class and implement the abstract functions as needed. (See the examples below)
 +
 +
{{CppSourceCode|
 +
description= CustomGeometry.h|
 +
code=
 +
<source lang="cpp" line="1">
 +
#pragma once
 +
 +
 +
 +
/**
 +
 +
* Abstract class for custom/dynamic geometry
 +
 +
**/
 +
 +
 +
 +
#include "utMath.h"
 +
 +
#include "Horde3D.h"
 +
 +
#include <string>
 +
 +
 +
 +
class CustomGeometry
 +
{
 +
 +
protected:
 +
 +
float _size;
 +
 +
Vec3f _origin;
 +
 +
int _numVertices;
 +
 +
int _numTriangles;
 +
 +
int _numTriangleIndices;
 +
 +
float* _positions;
 +
 +
float* _normals;
 +
 +
float* _texCoords;
 +
 +
int* _tIndices;
 +
 +
std::string _name;
 +
 +
NodeHandle _model;
 +
 +
NodeHandle _parent;
 +
 +
ResHandle _material;
 +
 +
virtual void generatePositions() = 0;
 +
 +
virtual void generateNormals() = 0;
 +
 +
virtual void generateTexCoords() = 0;
 +
 +
virtual void generateTriangleIndices() = 0;
 +
 +
 +
 +
public:
 +
 +
CustomGeometry();
 +
 +
virtual void generate() = 0;
 +
 +
const int getNumVertices() { return _numVertices; }
 +
 +
const float* getPositions() { return _positions; }
 +
 +
const float* getNormals() { return _normals; }
 +
 +
const float* getTexCoords() { return _texCoords; }
 +
 +
const int* getTriangleIndices() { return _tIndices; }
 +
 +
const int getNumTriangles() { return _numTriangles; }
 +
 +
const int getNumTriangleIndices() { return _numTriangleIndices; }
 +
 +
void release();
 +
 +
const Vec3f getInterpolatedNormal(Vec3f n1_, Vec3f n2_);
 +
 +
// pass -1 as the parameter to leave the parent node unchanged
 +
 +
void addCustomModelNode(NodeHandle parent_);
 +
 +
bool removeCustomModelNode();
 +
 +
void setMaterial(ResHandle material_) { _material = material_; }
 +
 +
void setParent(NodeHandle parent_) { _parent = parent_; }
 +
 +
NodeHandle getModel() { return _model; }
 +
 +
ResHandle getMaterial() { return _material; }
 +
 +
void update();
 +
 +
Vec3f getOrigin() { return _origin; }
 +
 +
void setOrigin(Vec3f origin_) { _origin = origin_; }
 +
 +
const float getSize() { return _size; }
 +
 +
};
 +
 +
</source>
 +
}}
 +
 +
{{CppSourceCode|
 +
description= CustomGeometry.cpp|
 +
code=
 +
<source lang="cpp" line="1">
 +
#include "CustomGeometry.h"
 +
 +
#include <iostream>
 +
 +
#include <string>
 +
 +
#include <sstream>
 +
 +
#include <fstream>
 +
 +
#include "GeometryStreamGenerator.h"
 +
 +
#include "Horde3DUtils.h"
 +
 +
 +
 +
CustomGeometry::CustomGeometry() : _name("default"), _size(1)
 +
 +
{
 +
 +
_origin = Vec3f(0, 0, 0);
 +
 +
}
 +
 +
 +
 +
void CustomGeometry::release()
 +
 +
{
 +
 +
delete[] _positions;
 +
 +
_positions = 0;
 +
 +
delete[] _normals;
 +
 +
_normals = 0;
 +
 +
delete[] _texCoords;
 +
 +
_texCoords = 0;
 +
 +
delete[] _tIndices;
 +
 +
_tIndices = 0;
 +
 +
}
 +
 +
 +
 +
const Vec3f CustomGeometry::getInterpolatedNormal(Vec3f n1_, Vec3f n2_)
 +
 +
{
 +
 +
Vec3f newNormal = n1_ + n2_;
 +
 +
float length = newNormal.length();
 +
 +
return newNormal/length;
 +
 +
}
 +
 +
 +
 +
void CustomGeometry::addCustomModelNode(NodeHandle parent_)
 +
 +
{
 +
 +
//std::stringstream* sa = new std::stringstream();
 +
 +
std::stringstream ss;
 +
 +
if (parent_ != -1)
 +
 +
_parent = parent_;
 +
 +
ss<< "customGeometry-";
 +
 +
ss<<_name;
 +
 +
GeometryStreamGenerator* gsg = new GeometryStreamGenerator(this);
 +
 +
ResHandle customGeoRes = Horde3D::addResource(ResourceTypes::Geometry, ss.str().c_str(), 0);
 +
 +
Horde3D::loadResource(customGeoRes, gsg->getStream(), gsg->getStreamSize());
 +
 +
// model_node_name
 +
 +
ss<<"-Node";
 +
 +
_model = Horde3D::addModelNode(_parent, ss.str().c_str(), customGeoRes);
 +
 +
// mesh_name
 +
 +
ss<<"-Mesh";
 +
 +
Horde3D::addMeshNode(_model, ss.str().c_str(), _material, 0, gsg->getNumTriangleIndices(), 0, gsg->getNumVertices()-1);
 +
 +
Horde3DUtils::dumpMessages();
 +
 +
ss.str("");
 +
 +
ss.clear();
 +
 +
ss.flush();
 +
 +
gsg->release();
 +
 +
delete gsg;
 +
 +
gsg = 0;
 +
 +
//Horde3D::setNodeTransform(_model, _origin.x, _origin.y, _origin.z, 0, 0, 0, 1, 1, 1);
 +
 +
}
 +
 +
 +
 +
bool CustomGeometry::removeCustomModelNode()
 +
 +
{
 +
 +
std::stringstream* ss = new std::stringstream();
 +
 +
*ss<< "customGeometry-";
 +
 +
*ss<<_name;
 +
 +
ResHandle rh = Horde3D::findResource(ResourceTypes::Geometry, ss->str().c_str());
 +
 +
if (Horde3D::isResourceLoaded(rh)) {
 +
 +
Horde3D::removeResource(rh);
 +
 +
Horde3D::unloadResource(rh);
 +
 +
Horde3D::removeNode(_model);
 +
 +
Horde3D::releaseUnusedResources();
 +
 +
Horde3DUtils::dumpMessages();
 +
 +
delete ss;
 +
 +
return true;
 +
 +
}
 +
 +
else
 +
 +
return false;
 +
 +
 +
 +
}
 +
 +
 +
 +
void CustomGeometry::update()
 +
 +
{
 +
 +
removeCustomModelNode();
 +
 +
addCustomModelNode(-1);
 +
 +
}
 +
 +
 +
 +
 +
</source>
 +
}}
  
 
=Simple Square=
 
=Simple Square=

Revision as of 11:53, 26 October 2009

Due to the current changes in the Horde API this tutorial will be delayed

Work in progress


Important notes

  • The code used here has been tested with Horde3D 1.0.0 beta2 and beta3 and will NOT work with the latest release (beta4)


Overview

Basic approach

To create and display a procedurally generated mesh that, instead of being loaded from a Horde3D Scene node and a geoemtry file(*.scene.xml, *.geo), will be created in-memory by some algorithm, you have to create a mesh first and then "fake" the .geo-file and the scene node itself and pass it to the engine.

To do that you have to create your procedural geometry first. This is easy for simple shapes like single triangles, squares or triangle-strips, but will become way more difficult when we try to generate complex meshes, e.g. when we have a cloud of points in 3D space and have to describe which points make triangles, and which don't (calculating the triangle indices, texture coordinates and normals).

When we have calculated the geometry itself we need to create a char-stream to make Horde believe the geometry has been read from a file and pass it to Horde as a geometry Resource. The final step is to create a Horde3D Scene Node from our procedurally generated mesh and render it into our scene. [musicracer_intro.jpg This is how it could look like]

StreamGenerator

These classes are only for creating the character stream that will contain the geometry resource.

StreamGenerator.h 
#pragma once
#include <sstream>
#include <string>
#include <iostream>

class StreamGenerator 
{
public:
	StreamGenerator();
	virtual ~StreamGenerator();
	virtual const char* getStream() = 0;
	virtual const int getStreamSize() = 0;
};
StreamGenerator.cpp 
#include "StreamGenerator.h"

StreamGenerator::StreamGenerator() 
{
}

StreamGenerator::~StreamGenerator()
{
}
GeometryStreamGenerator.h 
#pragma once
#include "StreamGenerator.h"
#include "CustomGeometry.h"

class GeometryStreamGenerator : public StreamGenerator
{
private:
	std::stringstream* ss;
	void generate();
	int numVertices, numTriangleIndices;
	char* _stream;
	CustomGeometry* _geom;

public:
	GeometryStreamGenerator(CustomGeometry* geom_);
	~GeometryStreamGenerator();
	const char* getStream();
	const std::stringstream* getStringStream() { return ss; };
	const int getStreamSize();
	const int getNumVertices();
	const int getNumTriangleIndices();
	void release();
};
GeometryStreamGenerator.cpp 
#include "GeometryStreamGenerator.h"
#include "time.h"
#include "utMath.h"

GeometryStreamGenerator::GeometryStreamGenerator(CustomGeometry* geom_) : _geom(geom_)
{
	ss = new std::stringstream();
	generate();
}

GeometryStreamGenerator::~GeometryStreamGenerator()
{
}

void GeometryStreamGenerator::generate()
{
	numVertices = _geom->getNumVertices();
	numTriangleIndices = _geom->getNumTriangleIndices();
	const std::string _magicHeader = "H3DG";
	const int _version = 5;
	const int _numJoints = 1;
	const float _identityMatrix[] = {	1.0f, 0.0f, 0.0f, 0.0f,  
						0.0f, 1.0f, 0.0f, 0.0f,  
						0.0f, 0.0f, 1.0f, 0.0f,  
						0.0f, 0.0f, 0.0f, 1.0f};
	const int _numVertexStreams = 3;
	const int _magicVertices = 0;
	const int _vertexStreamElementSize = 12;
	const float* _positions = _geom->getPositions();
	const int _magicNormals = 1;
	const int _normalsStreamElementSize = 6;
	const float* _normals = _geom->getNormals();
	const int _magicTextureCoords1 = 6;
	const int _texCoordStreamElementSize = 8;
	const float* _texCoords = _geom->getTexCoords();
	const int* _triangleIndices = _geom->getTriangleIndices();
	const int _numMorphTragets = 0;
	// header
	ss->write(_magicHeader.c_str(), 4*sizeof(char));
	ss->write((char*)&_version, sizeof(int));
	// joints (mandatory)
	ss->write((char*)&_numJoints, sizeof(int));
	for (int i=0; i<16; ++i) {
		ss->write((char*)&_identityMatrix[i], sizeof(float));
	}
	// vertices
	ss->write((char*)&_numVertexStreams, sizeof(int));
	const int numVerts = _geom->getNumVertices();
	ss->write((char*)&numVerts, sizeof(int));
	ss->write((char*)&_magicVertices, sizeof(int));
	ss->write((char*)&_vertexStreamElementSize, sizeof(int));
	for (int i=0; i<_geom->getNumVertices()*3; ++i) {
		ss->write((char*)&_positions[i], sizeof(float));
	}
	// normals
	ss->write((char*)&_magicNormals, sizeof(int));
	ss->write((char*)&_normalsStreamElementSize, sizeof(int));
	for (int i=0; i<_geom->getNumVertices()*3; ++i) {
		// do not forget to mutliply the value with 32767 and 
		// then convert it to short before writing to the stream
		const short f = (short)(_normals[i]*32767);
		ss->write((char*)&f, sizeof(short));
	}
	// texture coordinates
	ss->write((char*)&_magicTextureCoords1, sizeof(int));
	ss->write((char*)&_texCoordStreamElementSize, sizeof(int));
	for (int i=0; i<_geom->getNumVertices()*2; ++i) {
		ss->write((char*)&_texCoords[i], sizeof(float));
	}
	// triangle indices
	const int numTriangleIndices = _geom->getNumTriangleIndices();
	ss->write((char*)&numTriangleIndices, sizeof(int));
	for (int i=0; i<_geom->getNumTriangleIndices(); ++i) {
		ss->write((char*)&_triangleIndices[i], sizeof(int));
	}
	ss->write((char*)&_numMorphTragets, sizeof(int));
	_stream = new char[ss->tellp()];
	ss->read(_stream, ss->tellp());
}

const char* GeometryStreamGenerator::getStream()
{
	return _stream;
}

const int GeometryStreamGenerator::getStreamSize() 
{
	int t = (int)ss->tellp();
	return t;
}

const int GeometryStreamGenerator::getNumVertices()
{
	return numVertices;
}

const int GeometryStreamGenerator::getNumTriangleIndices()
{
	return numTriangleIndices;
}

void GeometryStreamGenerator::release()
{
	ss->flush();
	ss->clear();
	delete ss;
	ss = 0;
	delete[] _stream;
	_stream = 0;
}

CustomGeometry base class

Base class for the custom geometry. This class currently contains lots of deprecated stuff, e.g. the update() function. This function was used to update an in-memory gemoetry resource in the "punk-rock"-way. Until Horde3D Beta3 the geometry resources were read-only, so directmanipulation of vertices was impossible. To modify the vertices I had to unload the geometry resource, re-create it with the new vertex-positions and load it into Horde again. This is not necessary any more because since Beta4 the geometry resources are not read-only anymore.

All custom geometry classes should be derived from this class and implement the abstract functions as needed. (See the examples below)

CustomGeometry.h 
#pragma once



/**

 * Abstract class for custom/dynamic geometry

 **/



#include "utMath.h"

#include "Horde3D.h"

#include <string>



class CustomGeometry 
{

protected:

	float _size;

	Vec3f _origin;

	int _numVertices;

	int _numTriangles;

	int _numTriangleIndices;

	float* _positions;

	float* _normals;

	float* _texCoords;

	int* _tIndices;

	std::string _name;

	NodeHandle _model;

	NodeHandle _parent;

	ResHandle _material;

	virtual void generatePositions() = 0;

	virtual void generateNormals() = 0;

	virtual void generateTexCoords() = 0;

	virtual void generateTriangleIndices() = 0;



public:

	CustomGeometry();

	virtual void generate() = 0;

	const int getNumVertices() { return _numVertices; }

	const float* getPositions() { return _positions; }

	const float* getNormals() { return _normals; }

	const float* getTexCoords() { return _texCoords; }

	const int* getTriangleIndices() { return _tIndices; }

	const int getNumTriangles() { return _numTriangles; }

	const int getNumTriangleIndices() { return _numTriangleIndices; }

	void release();

	const Vec3f getInterpolatedNormal(Vec3f n1_, Vec3f n2_);

	// pass -1 as the parameter to leave the parent node unchanged

	void addCustomModelNode(NodeHandle parent_);

	bool removeCustomModelNode();

	void setMaterial(ResHandle material_) { _material = material_; }

	void setParent(NodeHandle parent_) { _parent = parent_; }

	NodeHandle getModel() { return _model; }

	ResHandle getMaterial() { return _material; }

	void update();

	Vec3f getOrigin() { return _origin; }

	void setOrigin(Vec3f origin_) { _origin = origin_; }

	const float getSize() { return _size; }

};
CustomGeometry.cpp 
#include "CustomGeometry.h"

#include <iostream>

#include <string>

#include <sstream>

#include <fstream>

#include "GeometryStreamGenerator.h"

#include "Horde3DUtils.h"



CustomGeometry::CustomGeometry() : _name("default"), _size(1)

{

	_origin = Vec3f(0, 0, 0);

}



void CustomGeometry::release()

{

	delete[] _positions;

	_positions = 0;

	delete[] _normals;

	_normals = 0;

	delete[] _texCoords;

	_texCoords = 0;

	delete[] _tIndices;

	_tIndices = 0;

}



const Vec3f CustomGeometry::getInterpolatedNormal(Vec3f n1_, Vec3f n2_) 

{

	Vec3f newNormal = n1_ + n2_;

	float length = newNormal.length();

	return newNormal/length;

}



void CustomGeometry::addCustomModelNode(NodeHandle parent_)

{

	//std::stringstream* sa = new std::stringstream();

	std::stringstream ss;

	if (parent_ != -1) 

		_parent = parent_;

	ss<< "customGeometry-";

	ss<<_name;

	GeometryStreamGenerator* gsg = new GeometryStreamGenerator(this);

	ResHandle customGeoRes = Horde3D::addResource(ResourceTypes::Geometry, ss.str().c_str(), 0);

	Horde3D::loadResource(customGeoRes, gsg->getStream(), gsg->getStreamSize());

	// model_node_name

	ss<<"-Node";

	_model = Horde3D::addModelNode(_parent, ss.str().c_str(), customGeoRes);

	// mesh_name

	ss<<"-Mesh";

	Horde3D::addMeshNode(_model, ss.str().c_str(), _material, 0, gsg->getNumTriangleIndices(), 0, gsg->getNumVertices()-1);

	Horde3DUtils::dumpMessages();

	ss.str("");

	ss.clear();

	ss.flush();

	gsg->release();

	delete gsg;

	gsg = 0;

	//Horde3D::setNodeTransform(_model, _origin.x, _origin.y, _origin.z, 0, 0, 0, 1, 1, 1);

}



bool CustomGeometry::removeCustomModelNode()

{

	std::stringstream* ss = new std::stringstream();

	*ss<< "customGeometry-";

	*ss<<_name;

	ResHandle rh = Horde3D::findResource(ResourceTypes::Geometry, ss->str().c_str());

	if (Horde3D::isResourceLoaded(rh)) {

		Horde3D::removeResource(rh);

		Horde3D::unloadResource(rh);

		Horde3D::removeNode(_model);

		Horde3D::releaseUnusedResources();

		Horde3DUtils::dumpMessages();

		delete ss;

		return true;

	}

	else 

		return false;

	

}



void CustomGeometry::update()

{

	removeCustomModelNode();

	addCustomModelNode(-1);

}

Simple Square

Simple Grid

Usage example

Retrieved from "http://horde3d.org/wiki/index.php?title=Procedurally_generated_geometry_tutorial&oldid=561"