示例#1
0
int main(int argc, char *argv[])
{
    // use an ArgumentParser object to manage the program arguments.
    osg::ArgumentParser arguments(&argc,argv);

    // set up the usage document, in case we need to print out how to use this program.
    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which demonstrate support for ARB_vertex_program.");
    arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
    arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information");

    // construct the viewer.
    osgViewer::Viewer viewer;

    // add the stats handler
    viewer.addEventHandler(new osgViewer::StatsHandler);

    std::string shader("simple");
    while(arguments.read("-s",shader)) {}

    std::string textureFileName("Images/lz.rgb");
    while(arguments.read("-t",textureFileName)) {}

    std::string terrainFileName("");
    while(arguments.read("-d",terrainFileName)) {}

    bool dynamic = true;
    while(arguments.read("--static")) { dynamic = false; }

    bool vbo = false;
    while(arguments.read("--vbo")) { vbo = true; }

    // if user request help write it out to cout.
    if (arguments.read("-h") || arguments.read("--help"))
    {
        arguments.getApplicationUsage()->write(std::cout);
        return 1;
    }

    // load the nodes from the commandline arguments.
    osg::Node* model = createModel(shader,textureFileName,terrainFileName, dynamic, vbo);
    if (!model)
    {
        return 1;
    }

    viewer.setSceneData(model);

    return viewer.run();
}
示例#2
0
	void ResourceModel::LoadMaterialLibrary(const std::string& filename) {
		std::string materialFilename = filename;
		std::string path = filename.substr(0, filename.find_last_of("\\/") + 1); // We keep the final dash
		// Replace the last character of the extension - tmf becomes tml
		materialFilename[filename.size()-1] = 'l';

		std::ifstream fp;
		fp.open(materialFilename.c_str(), std::ios::in);
		
		if (!fp.is_open()) {
			FrameWork::GetLogger()->LogError("Couldn't load material library for %s", filename);	
			return;
		}

		Material* currentMaterial = 0;

		char buffer[256];
		char shaderName[64];
		char parameterType[16];
		char parameterName[64];
		char parameterValue[64];
		memset(shaderName, 0, sizeof(shaderName));
		memset(parameterType, 0, sizeof(parameterType));
		memset(parameterName, 0, sizeof(parameterName));
		memset(parameterValue, 0, sizeof(parameterValue));
		int numTextureMap = 0;
		while (fp.getline(buffer, sizeof(buffer))) {
			if (buffer[0] != ' ' && buffer[0] != '\n') {
				if (currentMaterial) {
					numTextureMap = 0;
					currentMaterial->shader = new Shader(shaderName, currentMaterial->shaderParameters);
					mMaterialList.push_back(currentMaterial);
				}
				
				currentMaterial = new Material();
				currentMaterial->name = std::string(buffer);
				currentMaterial->shaderParameters = new ShaderParameters();
				currentMaterial->shader = 0;
				continue;
			}

			sscanf_s(buffer, "  %s", parameterType, sizeof(parameterType));
			std::string sparameterType(parameterType);

			if (sparameterType == "INT") {
				int v = 0;
				sscanf_s(buffer, "%*s %s %d", parameterName, sizeof(parameterName), &v);
				currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_INT, v);
			}
			else if (sparameterType == "FLOAT") {
				float v = 0.0f;
				sscanf_s(buffer, "%*s %s %f", parameterName, sizeof(parameterName), &v);
				currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_FLOAT, v);
			}
			else if (sparameterType == "FLOAT2") {
				float v1, v2;
				sscanf_s(buffer, "%*s %s %f %f", parameterName, sizeof(parameterName), &v1, &v2);
				currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_FLOAT2, float2(v1, v2));
			}
			else if (sparameterType == "FLOAT3") {
				float v1, v2, v3;
				sscanf_s(buffer, "%*s %s %f %f %f", parameterName, sizeof(parameterName), &v1, &v2, &v3);
				currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_FLOAT3, float3(v1, v2, v3));
			}
			else if (sparameterType == "FLOAT4") {
				float v1, v2, v3, v4;
				sscanf_s(buffer, "%*s %s %f %f %f %f", parameterName, sizeof(parameterName), &v1, &v2, &v3, &v4);
				currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_FLOAT4, float4(v1, v2, v3, v4));
			}
			else if (sparameterType == "TEXTUREMAP") {
				sscanf_s(buffer, "%*s %s", parameterName, sizeof(parameterName));
				std::string textureFileName(path);
				textureFileName += parameterName;
				ResourceImage* image = (ResourceImage*)FrameWork::GetResourceManager()->GetResource(textureFileName);
				currentMaterial->shaderParameters->SetTextureMap((TextureMap)numTextureMap, image->GetTexture());
				numTextureMap++;
			}
			else if (sparameterType == "SHADER") {
				sscanf_s(buffer, "%*s %s", shaderName, sizeof(parameterName));
			}
		}
		if (currentMaterial) {
			currentMaterial->shader = new Shader(shaderName, currentMaterial->shaderParameters);
			mMaterialList.push_back(currentMaterial);
		}

		fp.close();
	}
示例#3
0
void writeFrames(const Kinect::FrameSource::IntrinsicParameters& ip,const Kinect::FrameBuffer& color,const Kinect::MeshBuffer& mesh,const char* lwoFileName)
	{
	/* Create the texture file name: */
	std::string textureFileName(lwoFileName,Misc::getExtension(lwoFileName));
	textureFileName.append("-color.png");
	
	/* Write the color frame as a texture image: */
	{
	Images::RGBImage texImage(color.getSize(0),color.getSize(1));
	Images::RGBImage::Color* tiPtr=texImage.modifyPixels();
	const unsigned char* cfPtr=reinterpret_cast<const unsigned char*>(color.getBuffer());
	for(int y=0;y<color.getSize(1);++y)
		for(int x=0;x<color.getSize(0);++x,++tiPtr,cfPtr+=3)
			*tiPtr=Images::RGBImage::Color(cfPtr);
	
	Images::writeImageFile(texImage,textureFileName.c_str());
	}
	
	/* Open the LWO file: */
	IO::FilePtr lwoFile=IO::openFile(lwoFileName,IO::File::WriteOnly);
	lwoFile->setEndianness(Misc::BigEndian);
	
	/* Create the LWO file structure via the FORM chunk: */
	{
	IFFChunkWriter form(lwoFile,"FORM");
	form.write<char>("LWO2",4);
	
	/* Create the TAGS chunk: */
	{
	IFFChunkWriter tags(&form,"TAGS");
	tags.writeString("ColorImage");
	tags.writeChunk();
	}
	
	/* Create the LAYR chunk: */
	{
	IFFChunkWriter layr(&form,"LAYR");
	layr.write<Misc::UInt16>(0U);
	layr.write<Misc::UInt16>(0x0U);
	for(int i=0;i<3;++i)
		layr.write<Misc::Float32>(0.0f);
	layr.writeString("DepthImage");
	layr.writeChunk();
	}
	
	/* Create an index map for all vertices to omit unused vertices: */
	unsigned int* indices=new unsigned int[mesh.numVertices];
	for(unsigned int i=0;i<mesh.numVertices;++i)
		indices[i]=~0x0U;
	unsigned int numUsedVertices=0;
	
	/* Create the PNTS, BBOX and VMAP chunks in one go: */
	{
	typedef Kinect::FrameSource::IntrinsicParameters::PTransform PTransform;
	typedef PTransform::Point Point;
	typedef Geometry::Box<Point::Scalar,3> Box;
	
	IFFChunkWriter bbox(&form,"BBOX");
	IFFChunkWriter pnts(&form,"PNTS");
	IFFChunkWriter vmap(&form,"VMAP");
	
	/* Write the VMAP header: */
	vmap.write<char>("TXUV",4);
	vmap.write<Misc::UInt16>(2U);
	vmap.writeString("ColorImageUV");
	
	/* Process all triangle vertices: */
	Box pBox=Box::empty;
	const Kinect::MeshBuffer::Vertex* vertices=mesh.getVertices();
	const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices();
	for(unsigned int i=0;i<mesh.numTriangles*3;++i,++tiPtr)
		{
		/* Check if the triangle vertex doesn't already have an index: */
		if(indices[*tiPtr]==~0x0U)
			{
			/* Assign an index to the triangle vertex: */
			indices[*tiPtr]=numUsedVertices;
			
			/* Transform the mesh vertex to camera space using the depth projection matrix: */
			Point dp(vertices[*tiPtr].position.getXyzw());
			Point cp=ip.depthProjection.transform(dp);
			
			/* Transform the depth-space point to texture space using the color projection matrix: */
			Point tp=ip.colorProjection.transform(dp);
			
			/* Add the point to the bounding box: */
			pBox.addPoint(cp);
			
			/* Store the point and its texture coordinates: */
			pnts.writePoint(cp);
			vmap.writeVarIndex(numUsedVertices);
			for(int i=0;i<2;++i)
				vmap.write<Misc::Float32>(tp[i]);
			
			++numUsedVertices;
			}
		}
	
	/* Write the bounding box: */
	bbox.writeBox(pBox);
	
	/* Write the BBOX, PNTS, and VMAP chunks: */
	bbox.writeChunk();
	pnts.writeChunk();
	vmap.writeChunk();
	}
	
	/* Create the POLS chunk: */
	{
	IFFChunkWriter pols(&form,"POLS");
	pols.write<char>("FACE",4);
	const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices();
	for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex,tiPtr+=3)
		{
		pols.write<Misc::UInt16>(3U);
		for(int i=0;i<3;++i)
			pols.writeVarIndex(indices[tiPtr[2-i]]);
		}
	pols.writeChunk();
	}
	
	/* Delete the vertex index map: */
	delete[] indices;
	
	/* Create the PTAG chunk: */
	{
	IFFChunkWriter ptag(&form,"PTAG");
	ptag.write<char>("SURF",4);
	for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex)
		{
		ptag.writeVarIndex(triangleIndex);
		ptag.write<Misc::UInt16>(0U);
		}
	ptag.writeChunk();
	}
	
	/* Create the CLIP chunk: */
	{
	IFFChunkWriter clip(&form,"CLIP");
	clip.write<Misc::UInt32>(1U);
	
	/* Create the STIL chunk: */
	{
	IFFChunkWriter stil(&clip,"STIL",true);
	stil.writeString(textureFileName.c_str());
	stil.writeChunk();
	}
	
	clip.writeChunk();
	}
	
	/* Create the SURF chunk: */
	{
	IFFChunkWriter surf(&form,"SURF");
	surf.writeString("ColorImage");
	surf.writeString("");
	
	/* Create the SIDE subchunk: */
	{
	IFFChunkWriter side(&surf,"SIDE",true);
	side.write<Misc::UInt16>(3U);
	side.writeChunk();
	}
	
	/* Create the SMAN subchunk: */
	{
	IFFChunkWriter sman(&surf,"SMAN",true);
	sman.write<Misc::Float32>(Math::rad(90.0f));
	sman.writeChunk();
	}
	
	/* Create the COLR subchunk: */
	{
	IFFChunkWriter colr(&surf,"COLR",true);
	colr.writeColor(1.0f,1.0f,1.0f);
	colr.writeVarIndex(0U);
	colr.writeChunk();
	}
	
	/* Create the DIFF subchunk: */
	{
	IFFChunkWriter diff(&surf,"DIFF",true);
	diff.write<Misc::Float32>(1.0f);
	diff.writeVarIndex(0U);
	diff.writeChunk();
	}
	
	/* Create the LUMI subchunk: */
	{
	IFFChunkWriter lumi(&surf,"LUMI",true);
	lumi.write<Misc::Float32>(0.0f);
	lumi.writeVarIndex(0U);
	lumi.writeChunk();
	}
	
	/* Create the BLOK subchunk: */
	{
	IFFChunkWriter blok(&surf,"BLOK",true);
	
	/* Create the IMAP subchunk: */
	{
	IFFChunkWriter imap(&blok,"IMAP",true);
	imap.writeString("1");
	
	/* Create the CHAN subchunk: */
	{
	IFFChunkWriter chan(&imap,"CHAN",true);
	chan.write<char>("COLR",4);
	chan.writeChunk();
	}
	
	imap.writeChunk();
	}
	
	/* Create the PROJ subchunk: */
	{
	IFFChunkWriter proj(&blok,"PROJ",true);
	proj.write<Misc::UInt16>(5U);
	proj.writeChunk();
	}
	
	/* Create the IMAG subchunk: */
	{
	IFFChunkWriter imag(&blok,"IMAG",true);
	imag.writeVarIndex(1U);
	imag.writeChunk();
	}
	
	/* Create the VMAP subchunk: */
	{
	IFFChunkWriter vmap(&blok,"VMAP",true);
	vmap.writeString("ColorImageUV");
	vmap.writeChunk();
	}
	
	blok.writeChunk();
	}
	
	/* Write the SURF chunk: */
	surf.writeChunk();
	}
	
	/* Write the FORM chunk: */
	form.writeChunk();
	}
	}
示例#4
0
// Load Material
void GLC_3dsToWorld::loadMaterial(Lib3dsMaterial* p3dsMaterial)
{
	GLC_Material* pMaterial= new GLC_Material;
	// Set the material name
	const QString materialName(p3dsMaterial->name);
	pMaterial->setName(materialName);
	// Check if there is a texture
	if (p3dsMaterial->texture1_map.name[0])
	{
		const QString textureName(p3dsMaterial->texture1_map.name);
		// Retrieve the .3ds file path
		QFileInfo fileInfo(m_FileName);
		QString textureFileName(fileInfo.absolutePath() + QDir::separator());
		textureFileName.append(textureName);

		// TGA file type are not supported
		if (!textureName.right(3).contains("TGA", Qt::CaseInsensitive))
		{
			QFile textureFile(textureFileName);

			if (textureFile.open(QIODevice::ReadOnly))
			{
				// Create the texture and assign it to the material
				GLC_Texture *pTexture = new GLC_Texture(textureFile);
				pMaterial->setTexture(pTexture);
				m_ListOfAttachedFileName << textureFileName;
				textureFile.close();
			}
			else
			{
				QStringList stringList(m_FileName);
				stringList.append("Open File : " + textureFileName + " failed");
				GLC_ErrorLog::addError(stringList);
			}

		}
		else
		{
			QStringList stringList(m_FileName);
			stringList.append("Image : " + textureFileName + " not suported");
			GLC_ErrorLog::addError(stringList);
		}
	}

	// Ambient Color
	QColor ambient;
	ambient.setRgbF(p3dsMaterial->ambient[0], p3dsMaterial->ambient[1], p3dsMaterial->ambient[2]);
	ambient.setAlphaF(p3dsMaterial->ambient[3]);
	pMaterial->setAmbientColor(ambient);
	// Diffuse Color
	QColor diffuse;
	diffuse.setRgbF(p3dsMaterial->diffuse[0], p3dsMaterial->diffuse[1], p3dsMaterial->diffuse[2]);
	diffuse.setAlphaF(p3dsMaterial->diffuse[3]);
	pMaterial->setDiffuseColor(diffuse);
	// Specular Color
	QColor specular;
	specular.setRgbF(p3dsMaterial->specular[0], p3dsMaterial->specular[1], p3dsMaterial->specular[2]);
	specular.setAlphaF(p3dsMaterial->specular[3]);
	pMaterial->setSpecularColor(specular);
	// Shininess

	if (0 != p3dsMaterial->shininess)
	{
		float matShininess= p3dsMaterial->shininess * 128.0f;
		if (matShininess > 128.0f) matShininess= 128.0f;
		if (matShininess < 5.0f) matShininess= 20.0f;
		pMaterial->setShininess(matShininess);
	}
	// Transparency

	pMaterial->setOpacity(1.0 - p3dsMaterial->transparency);

	// Add the material to the hash table
	m_Materials.insert(materialName, pMaterial);
}