コード例 #1
0
ファイル: UMSoftwareIO.cpp プロジェクト: uimac/burger2
/** 
 * import umdraw mesh list
 */
bool UMSoftwareIO::import_mesh_list(UMMeshList& dst, const umio::UMObjectPtr src, const umstring& absolute_file_path)
{
	if (!src) return false;

	bool result = false;
	umio::UMMesh::IDToMeshMap::iterator it = src->mutable_mesh_map().begin();
	for (; it != src->mutable_mesh_map().end(); ++it)
	{
		umio::UMMesh& ummesh = it->second;

		UMMeshPtr mesh(std::make_shared<UMMesh>());
		dst.push_back(mesh);
		result = true;
		
		sort_by_material(ummesh);
		load_material(absolute_file_path, mesh, ummesh);
		load_vertex_index(mesh, ummesh);
		load_vertex(mesh, ummesh);
		load_normal(mesh, ummesh);
		load_uv(mesh, ummesh);
		load_skin(mesh, ummesh);
		mesh->update_box();
	}
	return result;
}
コード例 #2
0
ファイル: obj_loader.cpp プロジェクト: mseskas/robotics
obj_loader::obj_loader(string file_name) : movable()
{
    sc_x = 1;
    sc_y = 1;
    sc_z = 1;

    init(0,0,0,0,1,0);


    load_object(file_name);

    string material_file = file_name.substr(0, file_name.length() - 4);

    load_material(material_file.append(".mtl"));
}
コード例 #3
0
ファイル: FbxFileLoader.cpp プロジェクト: je-pu-pu/blue-sky
/**
 * FbxNode からメッシュ情報を再帰的に読み込む
 *
 * @param node FbxNode
 */
void FbxFileLoader::load_mesh_recursive( FbxNode* node )
{
	load_mesh( node->GetMesh() );

	// std::cout << "material count : " << node->GetMaterialCount() << std::endl;

	for ( int n = 0; n < node->GetMaterialCount(); n++ )
	{
		fbx_material_index_ = n;
		load_material( node->GetMaterial( n ) );
	}

	for ( int n = 0; n < node->GetChildCount(); n++ )
	{
		load_mesh_recursive( node->GetChild( n ) );
	}
}
コード例 #4
0
ファイル: model_obj.c プロジェクト: mksn/objview
struct model *load_obj_model(char *filename)
{
	char dirname[1024];
	char line[200];
	struct model *model;
	struct mesh *curmesh = NULL;
	int fvp[20], fvt[20], fvn[20];
	char *p, *s;
	int i, n;
	FILE *fp;

	strlcpy(dirname, filename, sizeof dirname);
	p = strrchr(dirname, '/');
	if (!p) p = strrchr(dirname, '\\');
	if (p) *p = 0;
	else strlcpy(dirname, ".", sizeof dirname);

	printf("loading obj model: %s\n", filename);

	fp = fopen(filename, "r");
	if (!fp) {
		fprintf(stderr, "error: cannot load model '%s'\n", filename);
		return NULL;
	}

	model = malloc(sizeof(struct model));
	memset(model, 0, sizeof(struct model));

	model->min[0] = model->min[1] = model->min[2] = 1e10;
	model->max[0] = model->max[1] = model->max[2] = -1e10;
	model->radius = 0;

	while (1) {
		if (!fgets(line, sizeof line, fp))
			break;

		s = strtok(line, SEP);
		if (!s) {
			continue;
		} else if (!strcmp(s, "v")) {
			char *x = strtok(NULL, SEP);
			char *y = strtok(NULL, SEP);
			char *z = strtok(NULL, SEP);
			add_position(model, atof(x), atof(y), atof(z));
		} else if (!strcmp(s, "vt")) {
			char *u = strtok(NULL, SEP);
			char *v = strtok(NULL, SEP);
			add_texcoord(model, atof(u), atof(v));
		} else if (!strcmp(s, "vn")) {
			char *x = strtok(NULL, SEP);
			char *y = strtok(NULL, SEP);
			char *z = strtok(NULL, SEP);
			add_normal(model, atof(x), atof(y), atof(z));
		} else if (!strcmp(s, "f")) {
			n = 0;
			s = strtok(NULL, SEP);
			while (s) {
				if (*s) {
					splitfv(s, fvp+n, fvt+n, fvn+n);
					n++;
				}
				s = strtok(NULL, SEP);
			}
			for (i = 1; i < n - 1; i++) {
				add_triangle(curmesh,
                     fvp[0], fvt[0], fvn[0],
                     fvp[i], fvt[i], fvn[i],
                     fvp[i+1], fvt[i+1], fvn[i+1]);
			}
		} else if (!strcmp(s, "mtllib")) {
			s = strtok(NULL, SEP);
			model->material = load_material(dirname, s);
		} else if (!strcmp(s, "usemtl")) {
			s = strtok(NULL, SEP);
			curmesh = find_mesh(model, s);
		}
	}

	model->radius = sqrtf(model->radius);

	fclose(fp);
	return model;
}
コード例 #5
0
ファイル: main.cpp プロジェクト: devtomilk/LearnOpenGL
void initScene()
{
    cubeShader = new Shader( "basic.vert", "basic.frag" );
    lampShader = new Shader( "basic.vert", "lamp.frag" );

    glClearColor( 0.2f, 0.2f, 0.3f, 1.0f );
    glEnable( GL_DEPTH_TEST );

    //--------------------------------------------------
    // Geometry
    //--------------------------------------------------
    // cube
    glGenVertexArrays( 1, &cubeVAO );
    glGenBuffers( 1, &VBO );

    glBindVertexArray( cubeVAO );
    {
	// vbo
	glBindBuffer( GL_ARRAY_BUFFER, VBO );
	glBufferData( GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW );

	// position
	glEnableVertexAttribArray( 0 );
	glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0 );

	// normals
	glEnableVertexAttribArray( 1 );
	glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)) );

    }
    glBindVertexArray( 0 );
    glBindBuffer( GL_ARRAY_BUFFER, 0 );

    // lamp
    glGenVertexArrays( 1, &lampVAO );

    glBindVertexArray( lampVAO );
    {
	glBindBuffer( GL_ARRAY_BUFFER, VBO );
	// positions
	glEnableVertexAttribArray( 0 );
	glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0 );
    }
    glBindVertexArray( 0 );

    cubeShader->use();
    uniformLocLightColor = glGetUniformLocation( cubeShader->program, "lightColor" );
    uniformLocObjectColor = glGetUniformLocation( cubeShader->program, "objectColor" );
    glUniform3f( uniformLocLightColor, 1.0f, 1.0f, 1.0f );
    glUniform3f( uniformLocObjectColor, 0.5f, 0.2f, 0.0f );
    //--------------------------------------------------
    // Textures
    //--------------------------------------------------
    /*
    glGenTextures( 1, &texture1 );
    glBindTexture( GL_TEXTURE_2D, texture1 );

    //glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT );
    //glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT );

    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

    int width, height;
    unsigned char* image = SOIL_load_image( "../../container.jpg", &width, &height, 0, SOIL_LOAD_RGB );
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image );
    glGenerateMipmap( GL_TEXTURE_2D );
    SOIL_free_image_data( image );
    glBindTexture( GL_TEXTURE_2D, 0 );

    // second texture
    glGenTextures( 1, &texture2 );
    glBindTexture( GL_TEXTURE_2D, texture2 );

    image = SOIL_load_image( "../../awesomeface.png", &width, &height, 0, SOIL_LOAD_RGB );
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image );
    glGenerateMipmap( GL_TEXTURE_2D );
    SOIL_free_image_data( image );
    glBindTexture( GL_TEXTURE_2D, 0 );
    */


    //--------------------------------------------------
    // MVP Matrix
    //--------------------------------------------------
    // setup camera
    camera = new Camera( glm::vec3(1.0f,0.0f,3.0f), // position
			 glm::vec3(0.0f,0.0f,-1.0f), // front
			 glm::vec3(0.0f,1.0f,0.0f), // up
			 45.0f, // fov
			 0.1f, // near
			 100.0f ); // far
    model = glm::mat4(1.0f);
    view = glm::mat4(1.0f);
    view = glm::lookAt(camera->getPos(), camera->getPos() + camera->getFront(), camera->getUp() );
    projection = glm::mat4(1.0f);
    projection = glm::perspective( camera->getFov(), (GLfloat)WIN_WIDTH/WIN_HEIGHT, camera->getNear(),
				   camera->getFar() );

    cubeShader->use();
    uniformLocView = glGetUniformLocation( cubeShader->program, "V" );
    glUniformMatrix4fv( glGetUniformLocation(cubeShader->program, "M"), 1, GL_FALSE, glm::value_ptr(model) );
    glUniformMatrix4fv( uniformLocView, 1, GL_FALSE, glm::value_ptr(view) );
    glUniformMatrix4fv( glGetUniformLocation(cubeShader->program, "P"), 1, GL_FALSE, glm::value_ptr(projection) );

    // setup material
    material = load_material( "./Materials/ruby.material" );
    glUniform3f( glGetUniformLocation(cubeShader->program, "material.ambient"),
		 material->getAmbient().x,
		 material->getAmbient().y,
		 material->getAmbient().z
		 );
    glUniform3f( glGetUniformLocation(cubeShader->program, "material.diffuse"),
		 material->getDiffuse().x,
		 material->getDiffuse().y,
		 material->getDiffuse().z
		 );
    glUniform3f( glGetUniformLocation(cubeShader->program, "material.specular"),
		 material->getSpecular().x,
		 material->getSpecular().y,
		 material->getSpecular().z
		 );
    glUniform1f( glGetUniformLocation(cubeShader->program, "material.shininess"), material->getShininess() );
    // setup lighting parameters
    lampPos = glm::vec3( 1.2f, 0.8f, -1.0f );
    glUniform3f( glGetUniformLocation(cubeShader->program, "light.position"), lampPos.x, lampPos.y, lampPos.z );
    glUniform3f( glGetUniformLocation(cubeShader->program, "light.ambient"), 0.5f, 0.5f, 0.5f );
    glUniform3f( glGetUniformLocation(cubeShader->program, "light.diffuse"), 0.8f, 0.8f, 0.8f );
    glUniform3f( glGetUniformLocation(cubeShader->program, "light.specular"), 1.0f, 1.0f, 1.0f );

    // setup lamp vertices
    lampShader->use();
    uniformLocView = glGetUniformLocation( lampShader->program, "V" );
    model = glm::mat4( 1.0f );
    model = glm::translate( model, lampPos );
    model = glm::scale( model, glm::vec3(0.2f, 0.2f, 0.2f) );
    glUniformMatrix4fv( glGetUniformLocation(lampShader->program, "M"), 1, GL_FALSE, glm::value_ptr(model) );
    glUniformMatrix4fv( uniformLocView, 1, GL_FALSE, glm::value_ptr(view) );
    glUniformMatrix4fv( glGetUniformLocation(lampShader->program, "P"), 1, GL_FALSE, glm::value_ptr(projection) );


}
コード例 #6
0
static bool load_objects(Lib3dsFile *file, Scene *scene) {
	// load meshes
	unsigned long poly_count = 0;
	Lib3dsMesh *m = file->meshes;
	while(m) {

		Lib3dsNode *node = lib3ds_file_node_by_name(file, m->name, LIB3DS_OBJECT_NODE);
		if(!node) {
			warning("object \"%s\" does not have a corresponding node!", m->name);
		}
		Vector3 node_pos = node ? CONV_VEC3(node->data.object.pos) : Vector3();
		Quaternion node_rot = node ? CONV_QUAT(node->data.object.rot) : Quaternion();
		Vector3 node_scl = node ? CONV_VEC3(node->data.object.scl) : Vector3(1,1,1);
		Vector3 pivot = node ? CONV_VEC3(node->data.object.pivot) : Vector3();

		// load the vertices
		Vertex *varray = new Vertex[m->points];
		Vertex *vptr = varray;
		for(int i=0; i<(int)m->points; i++) {
			vptr->pos = CONV_VEC3(m->pointL[i].pos) - node_pos;
			vptr->pos.transform(node_rot);
			
			if(m->texels) {
				vptr->tex[0] = vptr->tex[1] = CONV_TEXCOORD(m->texelL[i]);
			}
			
			vptr++;
		}
		
		if(m->faces) {
			poly_count += m->faces;
			// -------- object ---------
			Object *obj = new Object;
			obj->set_dynamic(false);

			obj->name = m->name;

			obj->set_position(node_pos - pivot);
			obj->set_rotation(node_rot);
			obj->set_scaling(node_scl);

			obj->set_pivot(pivot);
		
			// load the polygons
			Triangle *tarray = new Triangle[m->faces];
			Triangle *tptr = tarray;
			for(int i=0; i<(int)m->faces; i++) {
				*tptr = CONV_TRIANGLE(m->faceL[i]);
				tptr->normal = CONV_VEC3(m->faceL[i].normal);
				tptr->smoothing_group = m->faceL[i].smoothing;

				tptr++;
			}

			// set the geometry data to the object
			obj->get_mesh_ptr()->set_data(varray, m->points, tarray, m->faces);
			obj->get_mesh_ptr()->calculate_normals();
		
			delete [] tarray;

			// load the material
			load_material(file, m->faceL[0].material, obj->get_material_ptr());

			// load the keyframes (if any)
			if(load_keyframes(file, m->name, LIB3DS_OBJECT_NODE, obj)) {
				obj->set_position(Vector3());
				obj->set_rotation(Quaternion());
				obj->set_scaling(Vector3(1, 1, 1));
			}

			scene->add_object(obj);
			
		} else {
			// --------- curve ------------
			Curve *curve = new CatmullRomSplineCurve;
			curve->name = m->name;

			Vector3 offs = node_pos - pivot;
			
			for(int i=0; i<(int)m->points; i++) {
				curve->add_control_point(varray[i].pos + offs);
			}

			scene->add_curve(curve);
		}

		delete [] varray;


		m = m->next;
	}
	
	scene->set_poly_count(poly_count);
	return true;
}