Exemplo n.º 1
0
void Bumper::GenerateSocketMesh(Vertex3D_NoTex2 *buf)
{
   const float scalexy = m_d.m_radius*2.0f;

   for (int i = 0; i < bumperSocketNumVertices; i++)
   {
      Vertex3Ds vert(bumperSocket[i].x, bumperSocket[i].y, bumperSocket[i].z);
      vert = m_fullMatrix.MultiplyVector(vert);
      buf[i].x = vert.x*scalexy + m_d.m_vCenter.x;
      buf[i].y = vert.y*scalexy + m_d.m_vCenter.y;
      // scale z by 0.6 to make the skirt a bit more flat
      buf[i].z = (0.6f*vert.z*m_d.m_heightScale)*m_ptable->m_BG_scalez[m_ptable->m_BG_current_set] + m_baseHeight;

      vert = Vertex3Ds(bumperSocket[i].nx, bumperSocket[i].ny, bumperSocket[i].nz);
      vert = m_fullMatrix.MultiplyVectorNoTranslate(vert);
      buf[i].nx = vert.x;
      buf[i].ny = vert.y;
      buf[i].nz = vert.z;
      buf[i].tu = bumperSocket[i].tu;
      buf[i].tv = bumperSocket[i].tv;
   }
}
Exemplo n.º 2
0
/* Loads a curve from a ".vert" file, which is constructed as such:
 * 2				//First line is the number of vec3f's to read (call this 'n')
 * 1.0 1.0 1.0		// Second line is always the colour to render the curve
 * -1.0 1.0 0.0		// The remaining n -1 lines are the vertices of the curve
 */
void FileHelper::loadCurveFromFile(const char* file, Renderable & curve){

	char buffer[50];
	FILE* fp;
	int numPoints;

	fp = fopen(file, "r");

	fgets(buffer, 50, fp);
	numPoints = atoi(buffer);

	std::vector<Vec3f> verts;
	for(int i = 0; i < numPoints; i++){
		float temp1, temp2, temp3;
		fgets(buffer, 50, fp);
		sscanf(buffer, "%f %f %f\n", &temp1, &temp2, &temp3);
		Vec3f vert(temp1, temp2, temp3);

		// First point is the colour
		if(i == 0)
		{
			curve.setColour(vert);
		}

		// Remaining points are the vertices
		else
		{
			verts.push_back(vert);
		}

	}

	curve.setVerts(verts);

	fclose(fp);
	printf("Loaded %s!\n", file);
}
Exemplo n.º 3
0
double start(FILE* in){
    double f, R, t, r, g;   //f : 파리 반지름, R : 라켓 바깥 반지름, t : 라켓 두께, r : 줄 두께, g : 줄 간격
    double s;   //누적
    
    fscanf(in, "%lf", &f);
    fscanf(in, "%lf", &R);
    fscanf(in, "%lf", &t);
    fscanf(in, "%lf", &r);
    fscanf(in, "%lf", &g);
    
    
    if(2*f >= g) {      //gap이 좁을 경우 종료
        return 1.0;
    }
    
    t = t + f;  // 유효면적(?)
    r = r + f;
    g = g - 2*f;
    
    
    coordinate d;
    d.x = r;
    d.y = r;
    
    s = 0;
    while(d.y*d.y + d.x*d.x < (R-t)*(R-t)){
        s += vert(d, f, R, t, r, g);
        d.x += g+2*r;
        d.y += g+2*r;
    }
    
    s *= 8;

    return 1.0-s/(acos(-1)*R*R);
    
}
Exemplo n.º 4
0
bool CPath::getShape(CGeomProxy* geomObj[1],CShape* shapeObj[1])
{
	bool retVal=false;
	if (_shapingEnabled&&(_pathShapeVertices.size()!=0))
	{
		std::vector<float> vert(_pathShapeVertices);
		C7Vector tr(getCumulativeTransformation());
		for (int i=0;i<int(vert.size()/3);i++)
		{
			C3Vector v(&vert[3*i]);
			v=tr*v;
			vert[3*i+0]=v(0);
			vert[3*i+1]=v(1);
			vert[3*i+2]=v(2);
		}
		std::vector<int> ind(_pathShapeIndices);
		geomObj[0]=new CGeomProxy(NULL,vert,ind,NULL,NULL);
		shapeObj[0]=new CShape();
		shapeObj[0]->setLocalTransformation(geomObj[0]->getCreationTransformation());
		geomObj[0]->setCreationTransformation(C7Vector::identityTransformation);
		retVal=true;
	}
	return(retVal);
}
Exemplo n.º 5
0
int AssimpScene::uncompress_recursive_old(float * arr, float arr_size, float vertex_size, int arr_index_start, const aiScene * sc, const aiNode * nd, aiMatrix4x4 * matrix_before)
{
	aiMatrix4x4 m = (*matrix_before) * nd->mTransformation;
	int arr_index = arr_index_start;
	int count_vertex = 0; //combined sum is returned at the end

	for (int n = 0; n < nd->mNumMeshes; ++n) {
		const aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]];
		for (int t = 0; t < mesh->mNumFaces; ++t) {
			const struct aiFace* face = &mesh->mFaces[t];
			bool isNormal = mesh->mNormals != NULL;

			for (int i = 0; i < face->mNumIndices; i++) {
				count_vertex++;
				int index = face->mIndices[i];
				aiVector3D 
					vert(m*mesh->mVertices[index]),
					normal((isNormal)? aiVector3D (mesh->mNormals[index]): aiVector3D());
				adjust_scene_roperty(vert.x, vert.y, vert.z);
				arr[arr_index]		= vert.x;
				arr[arr_index + 1]	= vert.y;
				arr[arr_index + 2]	= vert.z;
				arr[arr_index + 3]	= normal.x;
				arr[arr_index + 4]	= normal.y;
				arr[arr_index + 5]	= normal.z;
				arr_index			+= vertex_size;
			}
		}

	}

	for (int n = 0; n < nd->mNumChildren; ++n) {
		count_vertex += uncompress_recursive_old(arr, arr_size, vertex_size, arr_index, sc, nd, &m);
	}
	return count_vertex;
}
Exemplo n.º 6
0
int code_one(struct zint_symbol *symbol, unsigned char source[], int length)
{
	int size = 1, i, j, data_blocks;

	char datagrid[136][120];
	int row, col;
	int sub_version = 0;
	
	if((symbol->option_2 < 0) || (symbol->option_2 > 10)) {
		strcpy(symbol->errtxt, "Invalid symbol size");
		return ERROR_INVALID_OPTION;
	}
	
	if(symbol->option_2 == 9) {
		/* Version S */
		int codewords;
		short int elreg[112];
		unsigned int data[15], ecc[15];
		int stream[30];
		int block_width;
		
		if(length > 18) {
			strcpy(symbol->errtxt, "Input data too long");
			return ERROR_TOO_LONG;
		}
		if(is_sane(NEON, source, length) == ERROR_INVALID_DATA) {
			strcpy(symbol->errtxt, "Invalid input data (Version S encodes numeric input only)");
			return ERROR_INVALID_DATA;
		}
		
		sub_version = 3; codewords = 12; block_width = 6; /* Version S-30 */
		if(length <= 12) { sub_version = 2; codewords = 8; block_width = 4; } /* Version S-20 */
		if(length <= 6) { sub_version = 1; codewords = 4; block_width = 2; } /* Version S-10 */
		
		binary_load(elreg, (char *)source, length);
		hex_dump(elreg);
		
		for(i = 0; i < 15; i++) {
			data[i] = 0;
			ecc[i] = 0;
		}
		
		for(i = 0; i < codewords; i++) {
			data[codewords - i - 1] += 1 * elreg[(i * 5)];
			data[codewords - i - 1] += 2 * elreg[(i * 5) + 1];
			data[codewords - i - 1] += 4 * elreg[(i * 5) + 2];
			data[codewords - i - 1] += 8 * elreg[(i * 5) + 3];
			data[codewords - i - 1] += 16 * elreg[(i * 5) + 4];
		}
		
		rs_init_gf(0x25);
		rs_init_code(codewords, 1);
		rs_encode_long(codewords, data, ecc);
		rs_free();
		
		for(i = 0; i < codewords; i++) {
			stream[i] = data[i];
			stream[i + codewords] = ecc[codewords - i - 1];
		}
		
		for(i = 0; i < 136; i++) {
			for(j = 0; j < 120; j++) {
				datagrid[i][j] = '0';
			}
		}
		
		i = 0;
		for(row = 0; row < 2; row++) {
			for(col = 0; col < block_width; col++) {
				if(stream[i] & 0x10) { datagrid[row * 2][col * 5] = '1'; }
				if(stream[i] & 0x08) { datagrid[row * 2][(col * 5) + 1] = '1'; }
				if(stream[i] & 0x04) { datagrid[row * 2][(col * 5) + 2] = '1'; }
				if(stream[i] & 0x02) { datagrid[(row * 2) + 1][col * 5] = '1'; }
				if(stream[i] & 0x01) { datagrid[(row * 2) + 1][(col * 5) + 1] = '1'; }
				if(stream[i + 1] & 0x10) { datagrid[row * 2][(col * 5) + 3] = '1'; }
				if(stream[i + 1] & 0x08) { datagrid[row * 2][(col * 5) + 4] = '1'; }
				if(stream[i + 1] & 0x04) { datagrid[(row * 2) + 1][(col * 5) + 2] = '1'; }
				if(stream[i + 1] & 0x02) { datagrid[(row * 2) + 1][(col * 5) + 3] = '1'; }
				if(stream[i + 1] & 0x01) { datagrid[(row * 2) + 1][(col * 5) + 4] = '1'; }
				i += 2;
			}
		}
		
		size = 9;	
		symbol->rows = 8;
		symbol->width = 10 * sub_version + 1;
	}
	
	if(symbol->option_2 == 10) {
		/* Version T */
		unsigned int data[40], ecc[25];
		unsigned int stream[65];
		int data_length;
		int data_cw, ecc_cw, block_width;
		
		for(i = 0; i < 40; i++) { data[i] = 0; }
		data_length = c1_encode(symbol, source, data, length);
		
		if(data_length == 0) {
			return ERROR_TOO_LONG;
		}
		
		if(data_length > 38) {
			strcpy(symbol->errtxt, "Input data too long");
			return ERROR_TOO_LONG;
		}
		
		size = 10;
		sub_version = 3; data_cw = 38; ecc_cw = 22; block_width = 12;
		if(data_length <= 24) { sub_version = 2; data_cw = 24; ecc_cw = 16; block_width = 8; }
		if(data_length <= 10) { sub_version = 1; data_cw = 10; ecc_cw = 10; block_width = 4; }
		
		for(i = data_length; i < data_cw; i++) {
			data[i] = 129; /* Pad */
		}
		
		/* Calculate error correction data */
		rs_init_gf(0x12d);
		rs_init_code(ecc_cw, 1);	
		rs_encode_long(data_cw, data, ecc);
		rs_free();
		
		/* "Stream" combines data and error correction data */
		for(i = 0; i < data_cw; i++) {
			stream[i] = data[i];
		}
		for(i = 0; i < ecc_cw; i++) {
			stream[data_cw + i] = ecc[ecc_cw - i - 1];
		}
	
		for(i = 0; i < 136; i++) {
			for(j = 0; j < 120; j++) {
				datagrid[i][j] = '0';
			}
		}
		
		i = 0;
		for(row = 0; row < 5; row++) {
			for(col = 0; col < block_width; col++) {
				if(stream[i] & 0x80) { datagrid[row * 2][col * 4] = '1'; }
				if(stream[i] & 0x40) { datagrid[row * 2][(col * 4) + 1] = '1'; }
				if(stream[i] & 0x20) { datagrid[row * 2][(col * 4) + 2] = '1'; }
				if(stream[i] & 0x10) { datagrid[row * 2][(col * 4) + 3] = '1'; }
				if(stream[i] & 0x08) { datagrid[(row * 2) + 1][col * 4] = '1'; }
				if(stream[i] & 0x04) { datagrid[(row * 2) + 1][(col * 4) + 1] = '1'; }
				if(stream[i] & 0x02) { datagrid[(row * 2) + 1][(col * 4) + 2] = '1'; }
				if(stream[i] & 0x01) { datagrid[(row * 2) + 1][(col * 4) + 3] = '1'; }
				i++;
			}
		}
		
		symbol->rows = 16;
		symbol->width = (sub_version * 16) + 1;
	}
		
	if((symbol->option_2 != 9) && (symbol->option_2 != 10)) {
		/* Version A to H */
		unsigned int data[1500], ecc[600];
		unsigned int sub_data[190], sub_ecc[75];
		unsigned int stream[2100];
		int data_length;
				
		for(i = 0; i < 1500; i++) { data[i] = 0; }
		data_length = c1_encode(symbol, source, data, length);
		
		if(data_length == 0) {
			return ERROR_TOO_LONG;
		}
		
		for(i = 7; i >= 0; i--) {
			if(c1_data_length[i] >= data_length) {
				size = i + 1;
			}
		}
		
		if(symbol->option_2 > size) {
			size = symbol->option_2;
		}
		
		for(i = data_length; i < c1_data_length[size - 1]; i++) {
			data[i] = 129; /* Pad */
		}
		
		/* Calculate error correction data */
		data_length = c1_data_length[size - 1];
		for(i = 0; i < 190; i++) { sub_data[i] = 0; }
		for(i = 0; i < 75; i++) { sub_ecc[i] = 0; }
		
		data_blocks = c1_blocks[size - 1];
		
		rs_init_gf(0x12d);
		rs_init_code(c1_ecc_blocks[size - 1], 0);	
		for(i = 0; i < data_blocks; i++) {
			for(j = 0; j < c1_data_blocks[size - 1]; j++) {
				
				sub_data[j] = data[j * data_blocks + i];
			}
			rs_encode_long(c1_data_blocks[size - 1], sub_data, sub_ecc);
			for(j = 0; j < c1_ecc_blocks[size - 1]; j++) {
				ecc[c1_ecc_length[size - 1] - (j * data_blocks + i) - 1] = sub_ecc[j];
			}
		}
		rs_free();
		
		/* "Stream" combines data and error correction data */
		for(i = 0; i < data_length; i++) {
			stream[i] = data[i];
		}
		for(i = 0; i < c1_ecc_length[size - 1]; i++) {
			stream[data_length + i] = ecc[i];
		}
	
		for(i = 0; i < 136; i++) {
			for(j = 0; j < 120; j++) {
				datagrid[i][j] = '0';
			}
		}
		
		i = 0;
		for(row = 0; row < c1_grid_height[size - 1]; row++) {
			for(col = 0; col < c1_grid_width[size - 1]; col++) {
				if(stream[i] & 0x80) { datagrid[row * 2][col * 4] = '1'; }
				if(stream[i] & 0x40) { datagrid[row * 2][(col * 4) + 1] = '1'; }
				if(stream[i] & 0x20) { datagrid[row * 2][(col * 4) + 2] = '1'; }
				if(stream[i] & 0x10) { datagrid[row * 2][(col * 4) + 3] = '1'; }
				if(stream[i] & 0x08) { datagrid[(row * 2) + 1][col * 4] = '1'; }
				if(stream[i] & 0x04) { datagrid[(row * 2) + 1][(col * 4) + 1] = '1'; }
				if(stream[i] & 0x02) { datagrid[(row * 2) + 1][(col * 4) + 2] = '1'; }
				if(stream[i] & 0x01) { datagrid[(row * 2) + 1][(col * 4) + 3] = '1'; }
				i++;
			}
		}
		
		/* for(i = 0; i < (c1_grid_height[size - 1] * 2); i++) {
			for(j = 0; j < (c1_grid_width[size - 1] * 4); j++) {
				printf("%c", datagrid[i][j]);
			}
			printf("\n");
		} */
		
		symbol->rows = c1_height[size - 1];
		symbol->width = c1_width[size - 1];
	}
	
	switch(size) {
		case 1: /* Version A */
			central_finder(symbol, 6, 3, 1);
			vert(symbol, 4, 6, 1);
			vert(symbol, 12, 5, 0); 
			set_module(symbol, 5, 12);
			spigot(symbol, 0);
			spigot(symbol, 15);
			block_copy(symbol, datagrid, 0, 0, 5, 4, 0, 0);
			block_copy(symbol, datagrid, 0, 4, 5, 12, 0, 2);
			block_copy(symbol, datagrid, 5, 0, 5, 12, 6, 0);
			block_copy(symbol, datagrid, 5, 12, 5, 4, 6, 2);
			break;
		case 2: /* Version B */
			central_finder(symbol, 8, 4, 1);
			vert(symbol, 4, 8, 1);
			vert(symbol, 16, 7, 0); 
			set_module(symbol, 7, 16);
			spigot(symbol, 0);
			spigot(symbol, 21);
			block_copy(symbol, datagrid, 0, 0, 7, 4, 0, 0);
			block_copy(symbol, datagrid, 0, 4, 7, 16, 0, 2);
			block_copy(symbol, datagrid, 7, 0, 7, 16, 8, 0);
			block_copy(symbol, datagrid, 7, 16, 7, 4, 8, 2);
			break;
		case 3: /* Version C */
			central_finder(symbol, 11, 4, 2);
			vert(symbol, 4, 11, 1);
			vert(symbol, 26, 13, 1);
			vert(symbol, 4, 10, 0);
			vert(symbol, 26, 10, 0); 
			spigot(symbol, 0);
			spigot(symbol, 27);
			block_copy(symbol, datagrid, 0, 0, 10, 4, 0, 0);
			block_copy(symbol, datagrid, 0, 4, 10, 20, 0, 2);
			block_copy(symbol, datagrid, 0, 24, 10, 4, 0, 4);
			block_copy(symbol, datagrid, 10, 0, 10, 4, 8, 0);
			block_copy(symbol, datagrid, 10, 4, 10, 20, 8, 2);
			block_copy(symbol, datagrid, 10, 24, 10, 4, 8, 4);
			break;
		case 4: /* Version D */
			central_finder(symbol, 16, 5, 1); 
			vert(symbol, 4, 16, 1);
			vert(symbol, 20, 16, 1);
			vert(symbol, 36, 16, 1);
			vert(symbol, 4, 15, 0);
			vert(symbol, 20, 15, 0);
			vert(symbol, 36, 15, 0);
			spigot(symbol, 0);
			spigot(symbol, 12);
			spigot(symbol, 27);
			spigot(symbol, 39);
			block_copy(symbol, datagrid, 0, 0, 15, 4, 0, 0);
			block_copy(symbol, datagrid, 0, 4, 15, 14, 0, 2);
			block_copy(symbol, datagrid, 0, 18, 15, 14, 0, 4);
			block_copy(symbol, datagrid, 0, 32, 15, 4, 0, 6);
			block_copy(symbol, datagrid, 15, 0, 15, 4, 10, 0);
			block_copy(symbol, datagrid, 15, 4, 15, 14, 10, 2);
			block_copy(symbol, datagrid, 15, 18, 15, 14, 10, 4);
			block_copy(symbol, datagrid, 15, 32, 15, 4, 10, 6);
			break;
		case 5: /* Version E */
			central_finder(symbol, 22, 5, 2); 
			vert(symbol, 4, 22, 1);
			vert(symbol, 26, 24, 1);
			vert(symbol, 48, 22, 1);
			vert(symbol, 4, 21, 0);
			vert(symbol, 26, 21, 0);
			vert(symbol, 48, 21, 0);
			spigot(symbol, 0);
			spigot(symbol, 12);
			spigot(symbol, 39);
			spigot(symbol, 51);
			block_copy(symbol, datagrid, 0, 0, 21, 4, 0, 0);
			block_copy(symbol, datagrid, 0, 4, 21, 20, 0, 2);
			block_copy(symbol, datagrid, 0, 24, 21, 20, 0, 4);
			block_copy(symbol, datagrid, 0, 44, 21, 4, 0, 6);
			block_copy(symbol, datagrid, 21, 0, 21, 4, 10, 0);
			block_copy(symbol, datagrid, 21, 4, 21, 20, 10, 2);
			block_copy(symbol, datagrid, 21, 24, 21, 20, 10, 4);
			block_copy(symbol, datagrid, 21, 44, 21, 4, 10, 6);
			break;
		case 6: /* Version F */
			central_finder(symbol, 31, 5, 3); 
			vert(symbol, 4, 31, 1);
			vert(symbol, 26, 35, 1);
			vert(symbol, 48, 31, 1);
			vert(symbol, 70, 35, 1);
			vert(symbol, 4, 30, 0);
			vert(symbol, 26, 30, 0);
			vert(symbol, 48, 30, 0);
			vert(symbol, 70, 30, 0);
			spigot(symbol, 0);
			spigot(symbol, 12);
			spigot(symbol, 24);
			spigot(symbol, 45);
			spigot(symbol, 57);
			spigot(symbol, 69);
			block_copy(symbol, datagrid, 0, 0, 30, 4, 0, 0);
			block_copy(symbol, datagrid, 0, 4, 30, 20, 0, 2);
			block_copy(symbol, datagrid, 0, 24, 30, 20, 0, 4);
			block_copy(symbol, datagrid, 0, 44, 30, 20, 0, 6);
			block_copy(symbol, datagrid, 0, 64, 30, 4, 0, 8);
			block_copy(symbol, datagrid, 30, 0, 30, 4, 10, 0);
			block_copy(symbol, datagrid, 30, 4, 30, 20, 10, 2);
			block_copy(symbol, datagrid, 30, 24, 30, 20, 10, 4);
			block_copy(symbol, datagrid, 30, 44, 30, 20, 10, 6);
			block_copy(symbol, datagrid, 30, 64, 30, 4, 10, 8);
			break;
		case 7: /* Version G */
			central_finder(symbol, 47, 6, 2); 
			vert(symbol, 6, 47, 1);
			vert(symbol, 27, 49, 1);
			vert(symbol, 48, 47, 1);
			vert(symbol, 69, 49, 1);
			vert(symbol, 90, 47, 1);
			vert(symbol, 6, 46, 0);
			vert(symbol, 27, 46, 0);
			vert(symbol, 48, 46, 0);
			vert(symbol, 69, 46, 0);
			vert(symbol, 90, 46, 0);
			spigot(symbol, 0);
			spigot(symbol, 12);
			spigot(symbol, 24);
			spigot(symbol, 36);
			spigot(symbol, 67);
			spigot(symbol, 79);
			spigot(symbol, 91);
			spigot(symbol, 103);
			block_copy(symbol, datagrid, 0, 0, 46, 6, 0, 0);
			block_copy(symbol, datagrid, 0, 6, 46, 19, 0, 2);
			block_copy(symbol, datagrid, 0, 25, 46, 19, 0, 4);
			block_copy(symbol, datagrid, 0, 44, 46, 19, 0, 6);
			block_copy(symbol, datagrid, 0, 63, 46, 19, 0, 8);
			block_copy(symbol, datagrid, 0, 82, 46, 6, 0, 10);
			block_copy(symbol, datagrid, 46, 0, 46, 6, 12, 0);
			block_copy(symbol, datagrid, 46, 6, 46, 19, 12, 2);
			block_copy(symbol, datagrid, 46, 25, 46, 19, 12, 4);
			block_copy(symbol, datagrid, 46, 44, 46, 19, 12, 6);
			block_copy(symbol, datagrid, 46, 63, 46, 19, 12, 8);
			block_copy(symbol, datagrid, 46, 82, 46, 6, 12, 10);
			break;
		case 8: /* Version H */
			central_finder(symbol, 69, 6, 3);
			vert(symbol, 6, 69, 1);
			vert(symbol, 26, 73, 1);
			vert(symbol, 46, 69, 1);
			vert(symbol, 66, 73, 1);
			vert(symbol, 86, 69, 1);
			vert(symbol, 106, 73, 1);
			vert(symbol, 126, 69, 1);
			vert(symbol, 6, 68, 0);
			vert(symbol, 26, 68, 0);
			vert(symbol, 46, 68, 0);
			vert(symbol, 66, 68, 0);
			vert(symbol, 86, 68, 0);
			vert(symbol, 106, 68, 0);
			vert(symbol, 126, 68, 0); 
			spigot(symbol, 0);
			spigot(symbol, 12);
			spigot(symbol, 24);
			spigot(symbol, 36);
			spigot(symbol, 48);
			spigot(symbol, 60);
			spigot(symbol, 87);
			spigot(symbol, 99);
			spigot(symbol, 111);
			spigot(symbol, 123);
			spigot(symbol, 135);
			spigot(symbol, 147);
			block_copy(symbol, datagrid, 0, 0, 68, 6, 0, 0);
			block_copy(symbol, datagrid, 0, 6, 68, 18, 0, 2);
			block_copy(symbol, datagrid, 0, 24, 68, 18, 0, 4);
			block_copy(symbol, datagrid, 0, 42, 68, 18, 0, 6);
			block_copy(symbol, datagrid, 0, 60, 68, 18, 0, 8);
			block_copy(symbol, datagrid, 0, 78, 68, 18, 0, 10);
			block_copy(symbol, datagrid, 0, 96, 68, 18, 0, 12);
			block_copy(symbol, datagrid, 0, 114, 68, 6, 0, 14);
			block_copy(symbol, datagrid, 68, 0, 68, 6, 12, 0);
			block_copy(symbol, datagrid, 68, 6, 68, 18, 12, 2);
			block_copy(symbol, datagrid, 68, 24, 68, 18, 12, 4);
			block_copy(symbol, datagrid, 68, 42, 68, 18, 12, 6);
			block_copy(symbol, datagrid, 68, 60, 68, 18, 12, 8);
			block_copy(symbol, datagrid, 68, 78, 68, 18, 12, 10);
			block_copy(symbol, datagrid, 68, 96, 68, 18, 12, 12);
			block_copy(symbol, datagrid, 68, 114, 68, 6, 12, 14);
			break;
		case 9: /* Version S */
			horiz(symbol, 5, 1);
			horiz(symbol, 7, 1);
			set_module(symbol, 6, 0);
			set_module(symbol, 6, symbol->width - 1);
			unset_module(symbol, 7, 1);
			unset_module(symbol, 7, symbol->width - 2);
			switch(sub_version) {
				case 1: /* Version S-10 */
					set_module(symbol, 0, 5);
					block_copy(symbol, datagrid, 0, 0, 4, 5, 0, 0);
					block_copy(symbol, datagrid, 0, 5, 4, 5, 0, 1);
					break;
				case 2: /* Version S-20 */
					set_module(symbol, 0, 10);
					set_module(symbol, 4, 10);
					block_copy(symbol, datagrid, 0, 0, 4, 10, 0, 0);
					block_copy(symbol, datagrid, 0, 10, 4, 10, 0, 1);
					break;
				case 3: /* Version S-30 */
					set_module(symbol, 0, 15);
					set_module(symbol, 4, 15);
					set_module(symbol, 6, 15);
					block_copy(symbol, datagrid, 0, 0, 4, 15, 0, 0);
					block_copy(symbol, datagrid, 0, 15, 4, 15, 0, 1);
					break;
			}
			break;
		case 10: /* Version T */
			horiz(symbol, 11, 1);
			horiz(symbol, 13, 1);
			horiz(symbol, 15, 1);
			set_module(symbol, 12, 0);
			set_module(symbol, 12, symbol->width - 1);
			set_module(symbol, 14, 0);
			set_module(symbol, 14, symbol->width - 1);
			unset_module(symbol, 13, 1);
			unset_module(symbol, 13, symbol->width - 2);
			unset_module(symbol, 15, 1);
			unset_module(symbol, 15, symbol->width - 2);
			switch(sub_version) {
				case 1: /* Version T-16 */
					set_module(symbol, 0, 8);
					set_module(symbol, 10, 8);
					block_copy(symbol, datagrid, 0, 0, 10, 8, 0, 0);
					block_copy(symbol, datagrid, 0, 8, 10, 8, 0, 1);
					break;
				case 2: /* Version T-32 */
					set_module(symbol, 0, 16);
					set_module(symbol, 10, 16);
					set_module(symbol, 12, 16);
					block_copy(symbol, datagrid, 0, 0, 10, 16, 0, 0);
					block_copy(symbol, datagrid, 0, 16, 10, 16, 0, 1);
					break;
				case 3: /* Verion T-48 */
					set_module(symbol, 0, 24);
					set_module(symbol, 10, 24);
					set_module(symbol, 12, 24);
					set_module(symbol, 14, 24);
					block_copy(symbol, datagrid, 0, 0, 10, 24, 0, 0);
					block_copy(symbol, datagrid, 0, 24, 10, 24, 0, 1);
					break;
			}
			break;
	}
	
	for(i = 0; i < symbol->rows; i++) {
		symbol->row_height[i] = 1;
	}
	
	return 0;
}
Exemplo n.º 7
0
bool QChain::testPoint(const QPointF &point) const {
  QPointF p = mapFromItem(world(), point);
  std::vector<Vector2d> vert(m_vertices.begin(), m_vertices.end() - 1);
  return Geometry::pointInPolygon(vert.begin(), vert.end(), Vector2d(p));
}
Exemplo n.º 8
0
static inline void _build_faces(uint8_t ***p_cell_status, int x, int y, int z, int len_x, int len_y, int len_z, PoolVector<Face3> &p_faces) {

	ERR_FAIL_INDEX(x, len_x);
	ERR_FAIL_INDEX(y, len_y);
	ERR_FAIL_INDEX(z, len_z);

	if (p_cell_status[x][y][z] & _CELL_EXTERIOR)
		return;

/*	static const Vector3 vertices[8]={
		Vector3(0,0,0),
		Vector3(0,0,1),
		Vector3(0,1,0),
		Vector3(0,1,1),
		Vector3(1,0,0),
		Vector3(1,0,1),
		Vector3(1,1,0),
		Vector3(1,1,1),
	};
*/
#define vert(m_idx) Vector3((m_idx & 4) >> 2, (m_idx & 2) >> 1, m_idx & 1)

	static const uint8_t indices[6][4] = {
		{ 7, 6, 4, 5 },
		{ 7, 3, 2, 6 },
		{ 7, 5, 1, 3 },
		{ 0, 2, 3, 1 },
		{ 0, 1, 5, 4 },
		{ 0, 4, 6, 2 },

	};
	/*

		{0,1,2,3},
		{0,1,4,5},
		{0,2,4,6},
		{4,5,6,7},
		{2,3,7,6},
		{1,3,5,7},

		{0,2,3,1},
		{0,1,5,4},
		{0,4,6,2},
		{7,6,4,5},
		{7,3,2,6},
		{7,5,1,3},
*/

	for (int i = 0; i < 6; i++) {

		Vector3 face_points[4];
		int disp_x = x + ((i % 3) == 0 ? ((i < 3) ? 1 : -1) : 0);
		int disp_y = y + (((i - 1) % 3) == 0 ? ((i < 3) ? 1 : -1) : 0);
		int disp_z = z + (((i - 2) % 3) == 0 ? ((i < 3) ? 1 : -1) : 0);

		bool plot = false;

		if (disp_x < 0 || disp_x >= len_x)
			plot = true;
		if (disp_y < 0 || disp_y >= len_y)
			plot = true;
		if (disp_z < 0 || disp_z >= len_z)
			plot = true;

		if (!plot && (p_cell_status[disp_x][disp_y][disp_z] & _CELL_EXTERIOR))
			plot = true;

		if (!plot)
			continue;

		for (int j = 0; j < 4; j++)
			face_points[j] = vert(indices[i][j]) + Vector3(x, y, z);

		p_faces.push_back(
				Face3(
						face_points[0],
						face_points[1],
						face_points[2]));

		p_faces.push_back(
				Face3(
						face_points[2],
						face_points[3],
						face_points[0]));
	}
}
Exemplo n.º 9
0
        typename property_traits<CoreMap>::value_type
        core_numbers_impl(Graph& g, CoreMap c, PositionMap pos, Visitor vis)
        {
            typedef typename graph_traits<Graph>::vertices_size_type size_type;
            typedef typename graph_traits<Graph>::degree_size_type degree_type;
            typedef typename graph_traits<Graph>::vertex_descriptor vertex;
            typename graph_traits<Graph>::vertex_iterator vi,vi_end;

            // store the vertex core numbers
            typename property_traits<CoreMap>::value_type v_cn = 0;

            // compute the maximum degree (degrees are in the coremap)
            typename graph_traits<Graph>::degree_size_type max_deg = 0;
            for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
                max_deg = (std::max<typename graph_traits<Graph>::degree_size_type>)(max_deg, get(c,*vi));
            }

            // store the vertices in bins by their degree
            // allocate two extra locations to ease boundary cases
            std::vector<size_type> bin(max_deg+2);
            for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
                ++bin[get(c,*vi)];
            }

            // this loop sets bin[d] to the starting position of vertices
            // with degree d in the vert array for the bucket sort
            size_type cur_pos = 0;
            for (degree_type cur_deg = 0; cur_deg < max_deg+2; ++cur_deg) {
                degree_type tmp = bin[cur_deg];
                bin[cur_deg] = cur_pos;
                cur_pos += tmp;
            }

            // perform the bucket sort with pos and vert so that
            // pos[0] is the vertex of smallest degree
            std::vector<vertex> vert(num_vertices(g));
            for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
                vertex v=*vi;
                size_type p=bin[get(c,v)];
                put(pos,v,p);
                vert[p]=v;
                ++bin[get(c,v)];
            }
            // we ``abused'' bin while placing the vertices, now,
            // we need to restore it
            std::copy(boost::make_reverse_iterator(bin.end()-2),
                boost::make_reverse_iterator(bin.begin()),
                boost::make_reverse_iterator(bin.end()-1));
            // now simulate removing the vertices
            for (size_type i=0; i < num_vertices(g); ++i) {
                vertex v = vert[i];
                vis.examine_vertex(v,g);
                v_cn = get(c,v);
                typename graph_traits<Graph>::out_edge_iterator oi,oi_end;
                for (boost::tie(oi,oi_end) = out_edges(v,g); oi!=oi_end; ++oi) {
                    vis.examine_edge(*oi,g);
                    vertex u = target(*oi,g);
                    // if c[u] > c[v], then u is still in the graph,
                    if (get(c,u) > v_cn) {
                        degree_type deg_u = get(c,u);
                        degree_type pos_u = get(pos,u);
                        // w is the first vertex with the same degree as u
                        // (this is the resort operation!)
                        degree_type pos_w = bin[deg_u];
                        vertex w = vert[pos_w];
                        if (u!=v) {
                            // swap u and w
                            put(pos,u,pos_w);
                            put(pos,w,pos_u);
                            vert[pos_w] = u;
                            vert[pos_u] = w;
                        }
                        // now, the vertices array is sorted assuming
                        // we perform the following step
                        // start the set of vertices with degree of u
                        // one into the future (this now points at vertex
                        // w which we swapped with u).
                        ++bin[deg_u];
                        // we are removing v from the graph, so u's degree
                        // decreases
                        put(c,u,get(c,u)-1);
                    }
                }
                vis.finish_vertex(v,g);
            }
            return v_cn;
        }
Exemplo n.º 10
0
int main(int argc, char **argv)
{
    if (argc != 3)
    {
        std::cout << "Usage: XO_tester <program1> <program2>\n";
        return 1;
    }
    const char *program1 = argv[1];
    const char *program2 = argv[2];

    //initLog(program1, program2);

	// save field and score before the first move
	saveField();
	
    ExecutionResult result = ER_OK;
    for (int move = 0 ; move < size * size ; ++move)
    {
        bool first = move % 2 == 0;
        std::ostringstream outs;
		outs << !first + 1 << "\n"; 
        for (int i = 0 ; i < size ; ++i)
        {
            for (int j = 0 ; j < size ; ++j)
            {
                outs << field[i][j] << " ";
            }
            outs << "\n";
        }
        std::string output;
        result = runProcess(first ? program1 : program2, 
            outs.str(), output, 1000, 64000);
        if (result == ER_OK)
        {
            std::istringstream ins(output);
            int x, y;
            ins >> y >> x;
            if (x >= 1 && x <= size && y >= 1 && y <= size
                && !field[y-1][x-1])
            {
                printLog(first, result, output);

                int xo = first ? 1 : 2;
                field[y-1][x-1] = xo;
				
				saveField();
				
				// check win
                if (diag1(xo) || diag2(xo) || horz(xo, y - 1) || vert(xo, x - 1))
                {
                    result = ER_WIN;
                    printLog(first, result, output);
                    break;
                }
            }
            else
            {
                result = ER_IM;
                printLog(first, result, output);
                break;
            }
        }
        else
        {
Exemplo n.º 11
0
/*
 * ellipsoidGate does not follow the regular transforming process
 * for historical reason, it is defined in 256 * 256 scale, and we don't know
 * how to translate it to the transformed scale yet, thus simply throw exception
 * for the EllipsoidGate defined on the non-linear data channel
 * for linear channels, we will do the same rescaling here.
 */
void ellipsoidGate::transforming(trans_local & trans){

	if(!Transformed())
	{
		/*
		 * get channel names to select respective transformation functions
		 */
		string channel_x=param.xName();
		string channel_y=param.yName();

		//get vertices in valarray format
		vertices_valarray vert(antipodal_vertices);


		transformation * trans_x=trans.getTran(channel_x);
		transformation * trans_y=trans.getTran(channel_y);


		/*
		 * we don't know the exact scaling rules for ellipsoidGate of non-linear space yet
		 * so simply throws error for now
		 */
		string err="Don't know how to scale the ellipsoidGate on the non-linear data space: ";
		if(trans_x==NULL)
		{
			//do the special scaling first for linear ellipsoidGate
			scaleTrans scale_f(1024);//assuming the max value is always 262144, thus 262144/256 = 1024
			if(g_loglevel>=POPULATION_LEVEL)
				COUT<<"scaling: "<<channel_x<<endl;;

			scale_f.transforming(vert.x);
			for(unsigned i=0;i<antipodal_vertices.size();i++)
				antipodal_vertices.at(i).x=vert.x[i];
		}
		else
		{
			err.append(channel_x);
			throw(domain_error(err));
		}

		if(trans_y==NULL)
		{
			//do the special scaling first for linear ellipsoidGate
			scaleTrans scale_f(1024);//assuming the max value is always 262144, thus 262144/256 = 1024
			if(g_loglevel>=POPULATION_LEVEL)
				COUT<<"scaling: "<<channel_y<<endl;;

			scale_f.transforming(vert.y);
			for(unsigned i=0;i<antipodal_vertices.size();i++)
				antipodal_vertices.at(i).y=vert.y[i];
		}
		else
		{
			err.append(channel_y);
			throw(domain_error(err));
		}

		if(g_loglevel>=POPULATION_LEVEL)
			COUT<<endl;

		computeCov();
		isTransformed=true;
	}

}
Exemplo n.º 12
0
void RoadGraph::_generateMeshVerticesDefault(VBORenderManager& renderManager, const QString &linesN, const QString &pointsN) {

	//////////////////////////////////////
	// EDGES
	{
		RoadEdgeIter ei, eend;
		for (boost::tie(ei, eend) = boost::edges(graph); ei != eend; ++ei) {
			if (!graph[*ei]->valid) continue;

			int num = graph[*ei]->polyline3D.size();
			if (num <= 1) continue;

			float halfWidth = graph[*ei]->getWidth()*0.5f;//it should not have /2.0f (but compensated below)
			

			std::vector<Vertex> vert(4*(num - 1));
			std::vector<Vertex> vertBg(4*(num - 1));
			
			// Type
			QColor color;// = graph[*ei]->color;
			QColor colorO;
			float heightOffset = 0.0f;
			float heightOffsetO=0.0f;

			switch (graph[*ei]->type) {
			case RoadEdge::TYPE_HIGHWAY:
				heightOffset = 0.8f;
				heightOffsetO = 0.3f;
				color=QColor(0xfa,0x9e,0x25);
				colorO=QColor(0x00, 0x00, 0x00);//QColor(0xdf,0x9c,0x13);
				halfWidth*=1.4f;
				break;
			case RoadEdge::TYPE_BOULEVARD:
				heightOffset = 0.5f;
				heightOffsetO = 0.2f;
				color=QColor(0xff,0xe1,0x68);
				colorO=QColor(0x00, 0x00, 0x00);//QColor(0xe5,0xbd,0x4d);
				halfWidth*=1.4f;
				break;
			case RoadEdge::TYPE_AVENUE:
				heightOffset = 0.6f;
				heightOffsetO = 0.1f;
				color=QColor(0xff,0xe1,0x68);
				colorO=QColor(0x00, 0x00, 0x00);//QColor(0xe5,0xbd,0x4d);
				halfWidth*=1.4f;
				break;
			case RoadEdge::TYPE_STREET:
				heightOffset = 0.4f;
				heightOffsetO = 0.1f;
				color=QColor(0xff,0xff,0xff);
				colorO=QColor(0x00, 0x00, 0x00);//QColor(0xd7,0xd1,0xc7);
				halfWidth*=1.8f;
				break;
			}

			halfWidth+= G::global().getFloat("2DroadsExtraWidth");
			heightOffset+=0.45f;//to have park below
			heightOffsetO+=0.45f;//to have park below

			float halfWidthBg = halfWidth + G::global().getFloat("2DroadsStroke");//it should not depend on the type 3.5f

			QVector3D p0, p1, p2, p3;
			QVector3D p0Bg, p1Bg, p2Bg, p3Bg;
			for (int i = 0; i < num - 1; ++i) {
				QVector3D pt1 = graph[*ei]->polyline3D[i];
				QVector3D pt2 = graph[*ei]->polyline3D[i + 1];

				QVector3D perp = pt2 - pt1;
				perp = QVector3D(-perp.y(), perp.x(), 0.0f);
				perp.normalize();

				if (i == 0) {
					p0 = pt1 + perp * halfWidth;
					p1 = pt1 - perp * halfWidth;
					p0Bg = pt1 + perp * halfWidthBg;
					p1Bg = pt1 - perp * halfWidthBg;
				}
				p2 = pt2 - perp * halfWidth;
				p3 = pt2 + perp * halfWidth;
				p2Bg = pt2 - perp * halfWidthBg;
				p3Bg = pt2 + perp * halfWidthBg;
				QVector3D normal = Util::calculateNormal(p0, p1, p2);

				if (i < num - 2) {
					QVector3D pt3 = graph[*ei]->polyline3D[i + 2];

					Util::getIrregularBisector(pt1, pt2, pt3, halfWidth, halfWidth, p3);
					Util::getIrregularBisector(pt1, pt2, pt3, -halfWidth, -halfWidth, p2);
					Util::getIrregularBisector(pt1, pt2, pt3, halfWidthBg, halfWidthBg, p3Bg);
					Util::getIrregularBisector(pt1, pt2, pt3, -halfWidthBg, -halfWidthBg, p2Bg);
				}

				
					vert[i*4+0]=Vertex(p0,QVector3D(),QVector3D(0,0,1.0f),QVector3D(0,0,0));// pos color normal texture
					vert[i*4+1]=Vertex(p1,QVector3D(),QVector3D(0,0,1.0f),QVector3D(1,0,0));// pos color normal texture
					vert[i*4+2]=Vertex(p2,QVector3D(),QVector3D(0,0,1.0f),QVector3D(1,1,0));// pos color normal texture
					vert[i*4+2]=Vertex(p3,QVector3D(),QVector3D(0,0,1.0f),QVector3D(0,1,0));// pos color normal texture
					/*
					vert[i*4+0]=Vertex(p0.x(),p0.y(),p0.z()+heightOffset,color.redF(),color.greenF(),color.blueF(),0,0,1.0f,0,0,0);// pos color normal texture
					vert[i*4+1]=Vertex(p1.x(),p1.y(),p1.z()+heightOffset,color.redF(),color.greenF(),color.blueF(),0,0,1.0f,1,0,0);// pos color normal texture
					vert[i*4+2]=Vertex(p2.x(),p2.y(),p2.z()+heightOffset,color.redF(),color.greenF(),color.blueF(),0,0,1.0f,1,1,0);// pos color normal texture
					vert[i*4+3]=Vertex(p3.x(),p3.y(),p3.z()+heightOffset,color.redF(),color.greenF(),color.blueF(),0,0,1.0f,0,1,0);// pos color normal texture
					*/
					vertBg[i*4+0]=Vertex(p0Bg.x(),p0Bg.y(),p0Bg.z()+heightOffsetO,colorO.redF(),colorO.greenF(),colorO.blueF(),0,0,1.0f,0,0,0);// pos color normal texture
					vertBg[i*4+1]=Vertex(p1Bg.x(),p1Bg.y(),p1Bg.z()+heightOffsetO,colorO.redF(),colorO.greenF(),colorO.blueF(),0,0,1.0f,0,0,0);// pos color normal texture
					vertBg[i*4+2]=Vertex(p2Bg.x(),p2Bg.y(),p2Bg.z()+heightOffsetO,colorO.redF(),colorO.greenF(),colorO.blueF(),0,0,1.0f,0,0,0);// pos color normal texture
					vertBg[i*4+3]=Vertex(p3Bg.x(),p3Bg.y(),p3Bg.z()+heightOffsetO,colorO.redF(),colorO.greenF(),colorO.blueF(),0,0,1.0f,0,0,0);// pos color normal texture
					

				p0 = p3;
				p1 = p2;
				p0Bg = p3Bg;
				p1Bg = p2Bg;
			}

			//renderManager.addStaticGeometry(linesN, vert, "", GL_QUADS, 1);//MODE=1 color
			//renderManager.addStaticGeometry(linesN, vertBg, "", GL_QUADS, 1);//MODE=1 color
			renderManager.addStaticGeometry(linesN, vert, "../data/extures/roads/road_2lines.jpg", GL_QUADS, 2|mode_AdaptTerrain);
		}
	}

	/////////////////////////////////////////////////////
	// INTERSECTIONS
	{
		RoadVertexIter vi, vend;
		for (boost::tie(vi, vend) = boost::vertices(graph); vi != vend; ++vi) {
			if (!graph[*vi]->valid) continue;

			// get the largest width of the outing edges
			QColor color;// = graph[*ei]->color;
			QColor colorO;
			float heightOffset = 0.0f;
			float heightOffsetO=0.0f;
			bool render = false;
			int maxType=-1;
			float halfWidth;

			RoadOutEdgeIter oei, oeend;
			for (boost::tie(oei, oeend) = boost::out_edges(*vi, graph); oei != oeend; ++oei) {
				if (!graph[*oei]->valid) continue;
				//printf("type %d\n",graph[*oei]->type);
				if(maxType>graph[*oei]->type)
					continue;
				maxType=graph[*oei]->type;
				halfWidth=graph[*oei]->getWidth()*0.5f;//it should not have /2.0f (but compensated below)

				switch (graph[*oei]->type) {
				case RoadEdge::TYPE_HIGHWAY:
					render = true;
					heightOffset = 0.6f;
					heightOffsetO = 0.3f;
					color=QColor(0xfa,0x9e,0x25);
					colorO=QColor(0x00, 0x00, 0x00);//QColor(0xdf,0x9c,0x13);
					halfWidth*=1.4f;
					continue;
				case RoadEdge::TYPE_BOULEVARD:
					heightOffset = 0.5f;
					heightOffsetO = 0.2f;
					color=QColor(0xff,0xe1,0x68);
					colorO=QColor(0x00, 0x00, 0x00);//QColor(0xe5,0xbd,0x4d);
					halfWidth*=1.4f;
					continue;
				case RoadEdge::TYPE_AVENUE:
					render = true;
					heightOffset = 0.5f;
					heightOffsetO = 0.2f;
					color=QColor(0xff,0xe1,0x68);
					colorO=QColor(0x00, 0x00, 0x00);//QColor(0xe5,0xbd,0x4d);
					halfWidth*=1.4f;
					continue;
				case RoadEdge::TYPE_STREET:
					render = true;
					heightOffset = 0.4f;
					heightOffsetO = 0.2f;
					color=QColor(0xff,0xff,0xff);
					colorO=QColor(0x00, 0x00, 0x00);//QColor(0xd7,0xd1,0xc7);
					halfWidth*=1.8f;
					continue;
				}
			}
			halfWidth+= G::global().getFloat("2DroadsExtraWidth");
			heightOffset+=0.45f;//to have park below
			heightOffsetO+=0.45f;//to have park below

			float max_r=halfWidth;
			float max_rO=halfWidth + G::global().getFloat("2DroadsStroke");//it should not depend on the type 3.5f

			std::vector<Vertex> vert(3*20);
			std::vector<Vertex> vertBg(3*20);

			for (int i = 0; i < 20; ++i) {
				float angle1 = 2.0 * M_PI * i / 20.0f;
				float angle2 = 2.0 * M_PI * (i + 1) / 20.0f;

				vert[i*3+0]=Vertex(graph[*vi]->pt3D.x(), graph[*vi]->pt3D.y(), graph[*vi]->pt3D.z() + heightOffset, color.redF(), color.greenF(), color.blueF(), 0, 0, 1.0f, 0, 0, 0);
				vert[i*3+1]=Vertex(graph[*vi]->pt3D.x() + max_r * cosf(angle1), graph[*vi]->pt3D.y() + max_r * sinf(angle1), graph[*vi]->pt3D.z() + heightOffset, color.redF(), color.greenF(), color.blueF(), 0, 0, 1.0f, 0, 0, 0);
				vert[i*3+2]=Vertex(graph[*vi]->pt3D.x() + max_r * cosf(angle2), graph[*vi]->pt3D.y() + max_r * sinf(angle2), graph[*vi]->pt3D.z() + heightOffset, color.redF(), color.greenF(), color.blueF(), 0, 0, 1.0f, 0, 0, 0);

				vertBg[i*3+0]=Vertex(graph[*vi]->pt3D.x(), graph[*vi]->pt3D.y(), graph[*vi]->pt3D.z() + heightOffsetO, colorO.redF(), colorO.greenF(), colorO.blueF(), 0, 0, 1.0f, 0, 0, 0);
				vertBg[i*3+1]=Vertex(graph[*vi]->pt3D.x() + max_rO * cosf(angle1), graph[*vi]->pt3D.y() + max_rO * sinf(angle1), graph[*vi]->pt3D.z() + heightOffsetO, colorO.redF(), colorO.greenF(), colorO.blueF(), 0, 0, 1.0f, 0, 0, 0);
				vertBg[i*3+2]=Vertex(graph[*vi]->pt3D.x() + max_rO * cosf(angle2), graph[*vi]->pt3D.y() + max_rO * sinf(angle2), graph[*vi]->pt3D.z() + heightOffsetO, colorO.redF(), colorO.greenF(), colorO.blueF(), 0, 0, 1.0f, 0, 0, 0);
			}
			
			//renderManager.addStaticGeometry(pointsN, vert, "", GL_TRIANGLES, 1);//MODE=1 color
			//renderManager.addStaticGeometry(pointsN, vertBg, "", GL_TRIANGLES, 1);//MODE=1 color
		}
	}
}
void
ZoneDefaultInteraction::onProximityUpdate(QPointF const& mouse_pos, InteractionState& interaction)
{
	m_screenMousePos = mouse_pos;

	QTransform const to_screen(m_rContext.imageView().imageToWidget());
	QTransform const from_screen(m_rContext.imageView().widgetToImage());
	QPointF const image_mouse_pos(from_screen.map(mouse_pos));

	m_ptrNearestVertex.reset();
	m_ptrNearestVertexSpline.reset();
	m_nearestSegment = SplineSegment();
	m_ptrNearestSegmentSpline.reset();

	Proximity best_vertex_proximity;
	Proximity best_segment_proximity;

	bool has_zone_under_mouse = false;

	BOOST_FOREACH(EditableZoneSet::Zone const& zone, m_rContext.zones()) {
		EditableSpline::Ptr const& spline = zone.spline();

		if (!has_zone_under_mouse) {
			QPainterPath path;
			path.setFillRule(Qt::WindingFill);
			path.addPolygon(spline->toPolygon());
			has_zone_under_mouse = path.contains(image_mouse_pos);
		}

		// Process vertices.
		for (SplineVertex::Ptr vert(spline->firstVertex());
				vert; vert = vert->next(SplineVertex::NO_LOOP)) {

			Proximity const proximity(mouse_pos, to_screen.map(vert->point()));
			if (proximity < best_vertex_proximity) {
				m_ptrNearestVertex = vert;
				m_ptrNearestVertexSpline = spline;
				best_vertex_proximity = proximity;
			}
		}

		// Process segments.
		for (EditableSpline::SegmentIterator it(*spline); it.hasNext(); ) {
			SplineSegment const segment(it.next());
			QLineF const line(to_screen.map(segment.toLine()));
			QPointF point_on_segment;
			Proximity const proximity(Proximity::pointAndLineSegment(mouse_pos, line, &point_on_segment));
			if (proximity < best_segment_proximity) {
				m_nearestSegment = segment;
				m_ptrNearestSegmentSpline = spline;
				best_segment_proximity = proximity;
				m_screenPointOnSegment = point_on_segment;
			}
		}
	}

	interaction.updateProximity(m_vertexProximity, best_vertex_proximity, 1);
	interaction.updateProximity(m_segmentProximity, best_segment_proximity, 0);

	if (has_zone_under_mouse) {
		Proximity const zone_area_proximity(std::min(best_vertex_proximity, best_segment_proximity));
		interaction.updateProximity(m_zoneAreaProximity, zone_area_proximity, -1, zone_area_proximity);
	}
}
Exemplo n.º 14
0
	TessellationExample(void)
	 : prog()
	 , projection_matrix(prog, "ProjectionMatrix")
	 , camera_matrix(prog, "CameraMatrix")
	{
		VertexShader vert(ObjectDesc("Vertex"));
		vert.Source(
			"#version 330\n"
			"uniform mat4 CameraMatrix;"

			"in vec4 Position;"
			"out vec4 vertPosition;"

			"void main(void)"
			"{"
			"	vertPosition = CameraMatrix * Position;"
			"}"
		);
		vert.Compile();
		prog << vert;

		TessControlShader teco(ObjectDesc("TessControl"));
		teco.Source(
			"#version 330\n"
			"#extension ARB_tessellation_shader: enable\n"
			"layout(vertices = 16) out;"

			"in vec4 vertPosition[];"
			"patch out vec3 tecoPosition[16];"

			"void main(void)"
			"{"
			"	if(gl_InvocationID == 0)"
			"	{"
			"		int tl = 1-int(100.0 / vertPosition[gl_InvocationID].z);"
			"		gl_TessLevelInner[0] = tl;"
			"		gl_TessLevelInner[1] = tl;"
			"		gl_TessLevelOuter[0] = tl;"
			"		gl_TessLevelOuter[1] = tl;"
			"		gl_TessLevelOuter[2] = tl;"
			"		gl_TessLevelOuter[3] = tl;"
			"	}"
			"	tecoPosition[gl_InvocationID] = "
			"		vertPosition[gl_InvocationID].xyz;"
			"}"
		);
		teco.Compile();
		prog << teco;

		TessEvaluationShader teev(ObjectDesc("TessEvaluation"));
		teev.Source(
			"#version 330\n"
			"#extension ARB_tessellation_shader: enable\n"
			"layout(quads, equal_spacing, ccw) in;"
			"uniform mat4 ProjectionMatrix;"
			"patch in vec3 tecoPosition[16];"

			"const mat4 B = mat4("
			"	-1, 3,-3, 1,"
			"	 3,-6, 3, 0,"
			"	-3, 3, 0, 0,"
			"	 1, 0, 0, 0 "
			");"

			"mat4 Px, Py, Pz;"

			"void main(void)"
			"{"
			"	float u = gl_TessCoord.x, v = gl_TessCoord.y;"

			"	for(int j=0; j!=4; ++j)"
			"	for(int i=0; i!=4; ++i)"
			"	{"
			"		int k = j*4+i;"
			"		Px[j][i] = tecoPosition[k].x;"
			"		Py[j][i] = tecoPosition[k].y;"
			"		Pz[j][i] = tecoPosition[k].z;"
			"	}"

			"	mat4 Cx = B * Px * B;"
			"	mat4 Cy = B * Py * B;"
			"	mat4 Cz = B * Pz * B;"

			"	vec4 up = vec4(u*u*u, u*u, u, 1);"
			"	vec4 vp = vec4(v*v*v, v*v, v, 1);"

			"	vec4 tempPosition = vec4(dot(Cx * vp, up), dot(Cy * vp, up), dot(Cz * vp, up), 1.0);"

			"	gl_Position = ProjectionMatrix * tempPosition;"
			"}"
		);
		teev.Compile();
		prog << teev;

		FragmentShader frag(ObjectDesc("Fragment"));
		frag.Source(
			"#version 330\n"
			"out vec3 fragColor;"
			"void main(void)"
			"{"
			"	fragColor = vec3(0.1, 0.1, 0.1);"
			"}"
		);
		frag.Compile();
		prog << frag;

		prog.Link();
		prog.Use();

		vao.Bind();

		GLfloat patch_cp_pos[16*3] = {
			-2.0f,  0.0f, -2.0f,
			-1.0f,  0.0f, -3.0f,
			 1.0f,  0.0f, -5.0f,
			 2.0f,  0.0f, -2.0f,
			-1.0f,  0.0f, -1.0f,
			 0.0f,  4.0f, -1.0f,
			 1.0f,  4.0f, -1.0f,
			 3.0f,  0.0f, -1.0f,
			-1.0f,  0.0f,  1.0f,
			-1.0f,  4.0f,  1.0f,
			 0.0f,  4.0f,  1.0f,
			 1.0f,  0.0f,  1.0f,
			-2.0f,  0.0f,  2.0f,
			-1.0f,  0.0f,  5.0f,
			 1.0f,  0.0f,  3.0f,
			 2.0f,  0.0f,  2.0f
		};
		positions.Bind(Buffer::Target::Array);
		Buffer::Data(Buffer::Target::Array, 16*3, patch_cp_pos);
		VertexArrayAttrib position_attr(prog, "Position");
		position_attr.Setup<Vec3f>();
		position_attr.Enable();

		gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
		gl.ClearDepth(1.0f);
		gl.PolygonMode(PolygonMode::Line);
		gl.PatchParameter(PatchParameter::PatchVertices, 16);
	}
Exemplo n.º 15
0
void AsymmetricUnit::SetSpaceGroup(const SpaceGroup &spg)
{
   VFN_DEBUG_MESSAGE("AsymmetricUnit::SetSpaceGroup(SpGroup)",5)
   tmp_C_Numeric_locale tmploc;
   # if 0
   TAU_PROFILE("(AsymmetricUnit::SetSpaceGroup)","void (SpaceGroup)",TAU_DEFAULT);
   mXmin=0.;
   mYmin=0.;
   mZmin=0.;
   mXmax=1.;
   mYmax=1.;
   mZmax=1.;
   if(1==spg.GetSpaceGroupNumber()) return;//no need to search an asymmetric unit
   // Test points=reular grid of points inside the unit cell
   // All points must be or have at least a symmetric in the asymmetric unit
   const long nbPoints=13;
   CrystMatrix_REAL testPoints(nbPoints*nbPoints*nbPoints,3);
   {
      long l=0;
      for(long i=0;i<nbPoints;i++)
         for(long j=0;j<nbPoints;j++)
            for(long k=0;k<nbPoints;k++)
            {
               testPoints(l  ,0)=i/(REAL)nbPoints;
               testPoints(l  ,1)=j/(REAL)nbPoints;
               testPoints(l++,2)=k/(REAL)nbPoints;
            }
   }
   testPoints += 0.01;

   CrystVector_REAL vert(8);//vertices limits
   vert(0)=1/8.; vert(1)=1/6.; vert(2)=1/4.; vert(3)=1/3.;
   vert(4)=1/2.; vert(5)=2/3.; vert(6)=3/4.; vert(7)=1.;

   const int NbStep=vert.numElements();

   CrystMatrix_REAL coords;

   double junk;

   REAL minVolume=1.;

   bool allPtsInAsym,tmp;
   for(long nx=0;nx<NbStep;nx++)
      for(long ny=0;ny<NbStep;ny++)
         for(long nz=0;nz<NbStep;nz++)
         {
            if(minVolume<(vert(nx)*vert(ny)*vert(nz)-.0001)) break;
            allPtsInAsym=true;
            for(int i=0;i<testPoints.rows();i++)
            {
               coords=spg.GetAllSymmetrics(testPoints(i,0),testPoints(i,1),testPoints(i,2));
               for(long j=0;j<coords.numElements();j++) coords(j)=modf(coords(j)+10.,&junk) ;
               tmp=false;
               for(long j=0;j<coords.rows();j++)
               {//Test if at least one of the symmetrics is in the parallelepiped
                  if(  (coords(j,0) < vert(nx))
                     &&(coords(j,1) < vert(ny))
                     &&(coords(j,2) < vert(nz)))
                  {
                     //cout  << modf(coords(j,0)+10.,junk) << " "
                     //      << modf(coords(j,1)+10.,junk) << " "
                     //      << modf(coords(j,2)+10.,junk) << endl;
                     tmp=true;
                     break;
                  }
               }
               if(false==tmp)
               {
                  //cout << " Rejected:"<<vert(nx)<<" "<<vert(ny)<<" "<<vert(nz)<<" "<<i<<endl;
                  //cout << coords <<endl;
                  allPtsInAsym=false;
                  break;
               }
            }
            if( (true==allPtsInAsym))
            {
               mXmax=vert(nx);
               mYmax=vert(ny);
               mZmax=vert(nz);
               VFN_DEBUG_MESSAGE("->ACCEPTED:" << mXmax <<" "<< mYmax <<" "<< mZmax <<endl,2)
               //cout << "->ACCEPTED:" << mXmax <<" "<< mYmax <<" "<< mZmax <<endl;
               minVolume=vert(nx)*vert(ny)*vert(nz);
               break;//no need to grow any more along z
            }
         }
   cout<<"->Finished Generating (pseudo) Asymmetric Unit, with:"<<endl
       <<"     0 <= x <= "<< mXmax<<endl
       <<"     0 <= y <= "<< mYmax<<endl
       <<"     0 <= z <= "<< mZmax<<endl<<endl;
   #else
   const cctbx::sgtbx::brick b(spg.GetCCTbxSpg().type());
   #ifdef __DEBUG__
   cout<<"->>Parallelepipedic Asymmetric Unit, from cctbx::sgtbx::brick:"<<endl
       <<b.as_string()<<endl;
   #endif
   mXmin=boost::rational_cast<REAL,int>(b(0,0).value());
   mYmin=boost::rational_cast<REAL,int>(b(1,0).value());
   mZmin=boost::rational_cast<REAL,int>(b(2,0).value());
   mXmax=boost::rational_cast<REAL,int>(b(0,1).value());
   mYmax=boost::rational_cast<REAL,int>(b(1,1).value());
   mZmax=boost::rational_cast<REAL,int>(b(2,1).value());

   #endif
}
Exemplo n.º 16
0
gp_XY SMESH_MesherHelper::GetNodeUV(const TopoDS_Face&   F,
                                    const SMDS_MeshNode* n,
                                    const SMDS_MeshNode* n2) const
{
  gp_Pnt2d uv( 1e100, 1e100 );
  const SMDS_PositionPtr Pos = n->GetPosition();
  if(Pos->GetTypeOfPosition()==SMDS_TOP_FACE)
  {
    // node has position on face
    const SMDS_FacePosition* fpos =
      static_cast<const SMDS_FacePosition*>(n->GetPosition().get());
    uv = gp_Pnt2d(fpos->GetUParameter(),fpos->GetVParameter());
  }
  else if(Pos->GetTypeOfPosition()==SMDS_TOP_EDGE)
  {
    // node has position on edge => it is needed to find
    // corresponding edge from face, get pcurve for this
    // edge and recieve value from this pcurve
    const SMDS_EdgePosition* epos =
      static_cast<const SMDS_EdgePosition*>(n->GetPosition().get());
    SMESHDS_Mesh* meshDS = GetMeshDS();
    int edgeID = Pos->GetShapeId();
    TopoDS_Edge E = TopoDS::Edge(meshDS->IndexToShape(edgeID));
    double f, l;
    Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
    uv = C2d->Value( epos->GetUParameter() );
    // for a node on a seam edge select one of UVs on 2 pcurves
    if ( n2 && IsSeamShape( edgeID ) )
      uv = GetUVOnSeam( uv, GetNodeUV( F, n2, 0 ));
  }
  else if(Pos->GetTypeOfPosition()==SMDS_TOP_VERTEX)
  {
    if ( int vertexID = n->GetPosition()->GetShapeId() ) {
      bool ok = true;
      const TopoDS_Vertex& V = TopoDS::Vertex(GetMeshDS()->IndexToShape(vertexID));
      try {
        uv = BRep_Tool::Parameters( V, F );
      }
      catch (Standard_Failure& exc) {
        ok = false;
      }
      if ( !ok ) {
        for ( TopExp_Explorer vert(F,TopAbs_VERTEX); !ok && vert.More(); vert.Next() )
          ok = ( V == vert.Current() );
        if ( !ok ) {
#ifdef _DEBUG_
          MESSAGE ( "SMESH_MesherHelper::GetNodeUV(); Vertex " << vertexID
               << " not in face " << GetMeshDS()->ShapeToIndex( F ) );
#endif
          // get UV of a vertex closest to the node
          double dist = 1e100;
          gp_Pnt pn ( n->X(),n->Y(),n->Z() );
          for ( TopExp_Explorer vert(F,TopAbs_VERTEX); !ok && vert.More(); vert.Next() ) {
            TopoDS_Vertex curV = TopoDS::Vertex( vert.Current() );
            gp_Pnt p = BRep_Tool::Pnt( curV );
            double curDist = p.SquareDistance( pn );
            if ( curDist < dist ) {
              dist = curDist;
              uv = BRep_Tool::Parameters( curV, F );
              if ( dist < DBL_MIN ) break;
            }
          }
        }
        else {
          TopTools_ListIteratorOfListOfShape it( myMesh->GetAncestors( V ));
          for ( ; it.More(); it.Next() ) {
            if ( it.Value().ShapeType() == TopAbs_EDGE ) {
              const TopoDS_Edge & edge = TopoDS::Edge( it.Value() );
              double f,l;
              Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edge, F, f, l);
              if ( !C2d.IsNull() ) {
                double u = ( V == TopExp::FirstVertex( edge ) ) ?  f : l;
                uv = C2d->Value( u );
                break;
              }
            }
          }
        }
      }
      if ( n2 && IsSeamShape( vertexID ) )
        uv = GetUVOnSeam( uv, GetNodeUV( F, n2, 0 ));
    }
  }
  return uv.XY();
}
Exemplo n.º 17
0
int main(int argc, char **argv)
{
    if (argc != 3)
    {
        std::cout << "Usage: tester <program1> <program2>\n";
        return 1;
    }
    const char *program1 = argv[1];
    const char *program2 = argv[2];

    ExecutionResult result = ER_OK;
    for (int move = 0 ; move < size * size ; ++move)
    {
        bool first = move % 2 == 0;
        std::ostringstream outs;
		outs << !first + 1 << "\n"; 
        for (int i = 0 ; i < size ; ++i)
        {
            for (int j = 0 ; j < size ; ++j)
            {
                outs << field[i][j] << " ";
            }
            outs << "\n";
        }
        std::string output;
        result = runProcess(first ? program1 : program2, 
            outs.str(), output, 1000, 64000);
        if (result == ER_OK)
        {
            std::istringstream ins(output);
            int x, y;
            ins >> y >> x;
            if (x >= 1 && x <= size && y >= 1 && y <= size
                && !field[y-1][x-1])
            {
                printLog(first, result, output);

                int xo = first ? 1 : 2;
                field[y-1][x-1] = xo;
                score[0] = score[1] = 0;
                for (int i = 0 ; i < size ; ++i)
                {
                    for (int j = 0 ; j < size ; ++j)
                    {
                        horz(i, j);
                        vert(i, j);
                        diag1(i, j);
                        diag2(i, j);
                    }
                }

                std::ostringstream outs;
                for (int i = 0 ; i < size ; ++i)
                {
                    for (int j = 0 ; j < size ; ++j)
                        outs << field[i][j] << " ";
                    outs << "\n";
                }
                outs << score[0] << " " << score[1] << "\n";
                printField(outs.str());
            }
            else
            {
                result = ER_IM;
                printLog(first, result, output);
                break;
            }
        }
        else
        {
Exemplo n.º 18
0
void TreeSegGeo::constructGeometryData(Quaternion orient, bool topPlane, bool bottomPlane)
{
	int numVerts = mSegmentsW * (mSegmentsH + 1) + 2;

	// positionData
	mGeoData.posData.push_back(Vector3::Zero);
	mGeoData.posData.push_back(Vector3(0, mLength, 0));

	float heightDelta = mLength / mSegmentsH;
	float deltaTheta = 2*PI / mSegmentsW;

	for(int i = 0; i <= mSegmentsH; ++i)
	{
		float circleHeight = i * heightDelta;
		float circleRadius = mRadius[i];
		for(int j = 0; j < mSegmentsW; ++j)
		{
			float x = circleRadius * cos(j*deltaTheta);
			float z = circleRadius * sin(j*deltaTheta);

			Vector3 vertPos(x, circleHeight, z);
			if(i == 0)
				vertPos = vertPos * orient.Conjugate();

			mGeoData.posData.push_back(vertPos);
		}
	}

	// verts
	for(size_t i = 0; i < mGeoData.posData.size(); ++i)
	{
		Vert vert(i);
		mGeoData.verts.push_back(vert);
	}

	// triangles
	if(bottomPlane)
	{
		for(int i = 0; i < mSegmentsW; ++i)		// 底圆面
		{
			// 顶点索引为2 ~ sw+1
			Triangle triangle(0, 2+i, 2 + (i + 1) % mSegmentsW);
			mGeoData.tris.push_back(triangle);
		}
	}

	if(topPlane)
	{
		for(int i = 0; i < mSegmentsW; ++i)		// 顶圆面
		{
			// 顶点索引为sw*sh + 2 ~ sw*(sh + 1) + 1
			Triangle triangle(1, mSegmentsW*mSegmentsH + 2 + (i + 1) % mSegmentsW, mSegmentsW*mSegmentsH + 2 + i);
			mGeoData.tris.push_back(triangle);
		}
	}

	for(int i = 0; i < mSegmentsH; ++i)		// 柱面
	{
		for(int j = 0; j < mSegmentsW; ++j)		
		{
			Triangle tri1;
			Triangle tri2;

			tri1.vertexIndex[0] = mSegmentsW * i + j + 2;
			tri1.vertexIndex[1] = mSegmentsW * (i + 1) + j + 2;
			tri1.vertexIndex[2] = mSegmentsW * i + (j + 1)%mSegmentsW + 2;

			tri2.vertexIndex[0] = mSegmentsW * (i + 1) + j + 2;
			tri2.vertexIndex[1] = mSegmentsW * (i + 1) + (j + 1)%mSegmentsW + 2;
			tri2.vertexIndex[2] = mSegmentsW * i + (j + 1)%mSegmentsW + 2;

			_Assert(tri1.vertexIndex[0] < mSegmentsW * (mSegmentsH + 1) + 2);
			_Assert(tri1.vertexIndex[1] < mSegmentsW * (mSegmentsH + 1) + 2);
			_Assert(tri1.vertexIndex[2] < mSegmentsW * (mSegmentsH + 1) + 2);

			_Assert(tri2.vertexIndex[0] < mSegmentsW * (mSegmentsH + 1) + 2);
			_Assert(tri2.vertexIndex[1] < mSegmentsW * (mSegmentsH + 1) + 2);
			_Assert(tri2.vertexIndex[2] < mSegmentsW * (mSegmentsH + 1) + 2);

			mGeoData.tris.push_back(tri1);
			mGeoData.tris.push_back(tri2);
		}
	}
}
Exemplo n.º 19
0
MeshVisualizer::MeshVisualizer(const Flags flags): flags(flags), transformationProjectionMatrixUniform(0), viewportSizeUniform(1), colorUniform(2), wireframeColorUniform(3), wireframeWidthUniform(4), smoothnessUniform(5) {
    #ifndef MAGNUM_TARGET_GLES
    if(flags & Flag::Wireframe && !(flags & Flag::NoGeometryShader))
        MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::geometry_shader4);
    #elif defined(MAGNUM_TARGET_GLES2)
    if(flags & Flag::Wireframe)
        MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::OES::standard_derivatives);
    #endif

    Utility::Resource rs("MagnumShaders");

    #ifndef MAGNUM_TARGET_GLES
    const Version v = Context::current()->supportedVersion({Version::GL320, Version::GL310, Version::GL210});
    #else
    const Version v = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
    #endif

    Shader vert(v, Shader::Type::Vertex);
    vert.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
        .addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
        .addSource(rs.get("compatibility.glsl"))
        .addSource(rs.get("MeshVisualizer.vert"));
    CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
    vert.compile();
    attachShader(vert);

    #ifndef MAGNUM_TARGET_GLES
    if(flags & Flag::Wireframe && !(flags & Flag::NoGeometryShader)) {
        Shader geom(v, Shader::Type::Geometry);
        geom.addSource(rs.get("compatibility.glsl"))
            .addSource(rs.get("MeshVisualizer.geom"));
        CORRADE_INTERNAL_ASSERT_OUTPUT(geom.compile());
        geom.compile();
        attachShader(geom);
    }
    #endif

    Shader frag(v, Shader::Type::Fragment);
    frag.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
        .addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
        .addSource(rs.get("compatibility.glsl"))
        .addSource(rs.get("MeshVisualizer.frag"));
    CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
    frag.compile();
    attachShader(frag);

    #ifndef MAGNUM_TARGET_GLES
    if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>() ||
        Context::current()->version() == Version::GL210)
    #else
    if(!Context::current()->isVersionSupported(Version::GLES300))
    #endif
    {
        bindAttributeLocation(Position::Location, "position");

        #ifndef MAGNUM_TARGET_GLES
        if(!Context::current()->isVersionSupported(Version::GL310))
        #endif
        {
            bindAttributeLocation(VertexIndex::Location, "vertexIndex");
        }
    }

    CORRADE_INTERNAL_ASSERT_OUTPUT(link());
    link();

    #ifndef MAGNUM_TARGET_GLES
    if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>())
    #endif
    {
        transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
        colorUniform = uniformLocation("color");
        if(flags & Flag::Wireframe) {
            wireframeColorUniform = uniformLocation("wireframeColor");
            wireframeWidthUniform = uniformLocation("wireframeWidth");
            smoothnessUniform = uniformLocation("smoothness");
            if(!(flags & Flag::NoGeometryShader))
                viewportSizeUniform = uniformLocation("viewportSize");
        }
    }

    /* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
    #ifdef MAGNUM_TARGET_GLES
    setColor(Color3<>(1.0f));
    if(flags & Flag::Wireframe) {
        setWireframeColor(Color3<>(0.0f));
        setWireframeWidth(1.0f);
        setSmoothness(2.0f);
    }
    #endif
}
Exemplo n.º 20
0
bool MeshMod_FixPipe::apply(Mesh *mesh)
{
	int i, j;
	rvfloat minHeights[8] = { -1e9,-1e9,-1e9,-1e9,-1e9,-1e9,-1e9,-1e9 };
	Polygon *newPolys [8] = { NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };
	Vector polyCenters[8];

	bool pipe = false;

	for (i = 0; i < mesh->data.num_polys; i++) {
		if (mesh->poly[i]->detTEPart() & TEP_PIPE) {
			pipe = true;
			break;
		}
	}

	if (!pipe) {
		return true;
	}

	rvfloat meshMinX = mesh->verts[0]->pos.coord[0];
	rvfloat meshMaxX = mesh->verts[0]->pos.coord[0];
	rvfloat meshMinZ = mesh->verts[0]->pos.coord[2];
	rvfloat meshMaxZ = mesh->verts[0]->pos.coord[2];

	for (i = 1; i < mesh->data.num_vecs; i++) {
		Vertex *v = mesh->verts[i];

		if (meshMinX > v->pos.coord[0] - 0.5) {
			meshMinX = v->pos.coord[0];
		}

		if (meshMaxX < v->pos.coord[0] + 0.5) {
			meshMaxX = v->pos.coord[0];
		}

		if (meshMinZ > v->pos.coord[2] - 0.5) {
			meshMinZ = v->pos.coord[2];
		}

		if (meshMaxZ < v->pos.coord[2] + 0.5) {
			meshMaxZ = v->pos.coord[2];
		}
	}

	Vector meshCenter(
		floor((meshMinX + meshMaxX) / 2000 + 0.5) * 1000,
		0.0f,
		floor((meshMinZ + meshMaxZ) / 2000 + 0.5) * 1000);

	for (i = 0; i < mesh->data.num_polys; i++) {
		Polygon *p = mesh->poly[i];

		if (p->detTEPart() & (TEP_PWALL | TEP_PIPE)) {
			rvfloat minHeight = -1e9;
			Vector polyCenter(0.0, 0.0, 0.0);

			for (j = 0; j < p->numverts(); j++) {
				Vertex *v = mesh->verts[p->vertidx(j)];

				polyCenter = polyCenter + v->pos;

				if (minHeight < v->pos.coord[1]) {
					minHeight = v->pos.coord[1];
				}
			}

			Vector polyCoord = polyCenter * 0.25;

			polyCenter = polyCoord - meshCenter;

			int octant = (int) ((atan2(polyCenter.z(), polyCenter.x()) + M_PI) / (M_PI / 4));

			if (p->detTEPart() & TEP_PIPE) {
				if (minHeights[octant] < minHeight) {
					minHeights[octant] = minHeight;
				}
			}

			if ((p->detTEPart() & TEP_PWALL) && p->numverts() == 4) {
				Vector& v0 = mesh->verts[p->vertidx(0)]->pos;
				Vector& v1 = mesh->verts[p->vertidx(1)]->pos;
				Vector& v2 = mesh->verts[p->vertidx(2)]->pos;

				rvfloat w = (v0 - v1).length();
				rvfloat h = (v2 - v1).length();

				if (fabs(w - 125.0) < 0.5 && fabs(h - 125.0) < 0.5) {
					// Check if we've encountered an indentical polygon before,
					// and if so, delete the current one so we don't end up with
					// duplicates

					bool found = false;

					for (j = 0; j < polyList.size(); j++) {
						if ((polyList[j].center - polyCoord).length() < 1.0) {
							found = true;
							break;
						}
					}

					if (found) {
						delete mesh->poly[i];
						mesh->poly[i] = NULL;
					} else {
						polyList.push_back(PolyInfo(p, polyCoord));
					}
				}
			}
		}
	}

	for (i = 0; i < mesh->data.num_polys; i++) {
		Polygon *p = mesh->poly[i];

		if (p->isInTexture(0,  0.5,1.0,  0.0,0.375)) {
			rvfloat minX = 1.0e9f, maxX = -1.0e9f;
			rvfloat minZ = 1.0e9f, maxZ = -1.0e9f;
			Vector polyCenter(0.0, 0.0, 0.0);

			for (j = 0; j < p->numverts(); j++) {
				Vertex *v = mesh->verts[p->vertidx(j)];

				polyCenter = polyCenter + v->pos;

				if (minX > v->pos.coord[0]) {
					minX = v->pos.coord[0];
				}

				if (maxX < v->pos.coord[0]) {
					maxX = v->pos.coord[0];
				}

				if (minZ > v->pos.coord[2]) {
					minZ = v->pos.coord[2];
				}

				if (maxZ < v->pos.coord[2]) {
					maxZ = v->pos.coord[2];
				}
			}

			Vector polyCoord = polyCenter / (rvfloat) p->numverts();

			polyCenter = polyCoord - meshCenter;

			int octant = (int) ((atan2(polyCenter.z(), polyCenter.x()) + M_PI) / (M_PI / 4));

			if (newPolys[octant] == NULL
			&&	(fabs(maxX - minX) < 0.5 || fabs(maxZ - minZ) < 0.5)
			&&	fabs(polyCenter.x()) > 10.0 && fabs(polyCenter.z()) > 10.0) {
				Vector p[4];
				Vector norm;

				// Find the corners of the new polygon

				switch (octant) {

				case 0:
					p[3] = Vector(-500, minHeights[octant] + 125, -500);
					p[2] = Vector(-500, minHeights[octant]      , -500);
					p[1] = Vector(-500, minHeights[octant]      , -375);
					p[0] = Vector(-500, minHeights[octant] + 125, -375);

					norm = Vector(-1.0, 0.0, 0.0);
					break;

				case 1:
					p[0] = Vector(-375, minHeights[octant]      , -500);
					p[1] = Vector(-375, minHeights[octant] + 125, -500);
					p[2] = Vector(-500, minHeights[octant] + 125, -500);
					p[3] = Vector(-500, minHeights[octant]      , -500);

					norm = Vector(0.0, 0.0, -1.0);
					break;
				case 2:
					p[3] = Vector(375, minHeights[octant]      , -500);
					p[2] = Vector(375, minHeights[octant] + 125, -500);
					p[1] = Vector(500, minHeights[octant] + 125, -500);
					p[0] = Vector(500, minHeights[octant]      , -500);

					norm = Vector(0.0, 0.0, -1.0);
					break;

				case 3:
					p[0] = Vector(500, minHeights[octant] + 125, -500);
					p[1] = Vector(500, minHeights[octant]      , -500);
					p[2] = Vector(500, minHeights[octant]      , -375);
					p[3] = Vector(500, minHeights[octant] + 125, -375);

					norm = Vector(-1.0, 0.0, 0.0);
					break;

				case 4:
					p[3] = Vector(500, minHeights[octant] + 125, 500);
					p[2] = Vector(500, minHeights[octant]      , 500);
					p[1] = Vector(500, minHeights[octant]      , 375);
					p[0] = Vector(500, minHeights[octant] + 125, 375);

					norm = Vector(-1.0, 0.0, 0.0);
					break;

				case 5:
					p[0] = Vector(375, minHeights[octant]      , 500);
					p[1] = Vector(375, minHeights[octant] + 125, 500);
					p[2] = Vector(500, minHeights[octant] + 125, 500);
					p[3] = Vector(500, minHeights[octant]      , 500);

					norm = Vector(0.0, 0.0, -1.0);
					break;

				case 6:
					p[3] = Vector(-375, minHeights[octant]      , 500);
					p[2] = Vector(-375, minHeights[octant] + 125, 500);
					p[1] = Vector(-500, minHeights[octant] + 125, 500);
					p[0] = Vector(-500, minHeights[octant]      , 500);

					norm = Vector(0.0, 0.0, -1.0);
					break;

				case 7:
					p[0] = Vector(-500, minHeights[octant] + 125, 500);
					p[1] = Vector(-500, minHeights[octant]      , 500);
					p[2] = Vector(-500, minHeights[octant]      , 375);
					p[3] = Vector(-500, minHeights[octant] + 125, 375);

					norm = Vector(-1.0, 0.0, 0.0);
					break;
				}

				for (j = 0; j < 4; j++) {
					// Translate to the mesh position
	
					p[j] = p[j] + meshCenter;

					// Add the vertex

					Vertex vert(p[j], norm);

					mesh->add(new Vertex(&vert));
				}

				// add a new polygon

				RV_Poly polyData = {
					1, 0,
					{
						mesh->data.num_vecs - 4,
						mesh->data.num_vecs - 3,
						mesh->data.num_vecs - 2,
						mesh->data.num_vecs - 1
					},
					{ {0xFFFFFF}, {0xFFFFFF}, {0xFFFFFF}, {0xFFFFFF} },
					{ { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 } }
				};

				polyCenter = (p[0] + p[1] + p[2] + p[3]) / 4;

				// Check if we've encountered an indentical polygon before,
				// and if so, use that instead of creating a new one

				bool found = false;

				for (j = 0; j < polyList.size(); j++) {
					if ((polyList[j].center - polyCenter).length() < 1.0) {
						found = true;
						break;
					}
				}

				if (found) {
					newPolys[octant] = polyList[j].poly;
				} else {
					newPolys[octant] = new Polygon(mesh, &polyData);

					mesh->add(newPolys[octant]);

					polyList.push_back(PolyInfo(newPolys[octant], polyCenter));
				}

				polyCenters[octant] = polyCenter;
			}
		}
	}

	// Finally, put textures on the "missing pieces"

	for (i = 0; i < 8; i++) {
		if (newPolys[i]) {
			Polygon *p = newPolys[i];

			p->data.texture = 0;

			for (int j = 0; j < p->numverts(); j++) {
				Vertex *v = mesh->verts[p->vertidx(j)];

				Vector relPos = v->pos - Vector(meshMinX, 0, meshMinZ);
				rvfloat x = relPos.lengthXZ();
				rvfloat y = relPos.y();

				if ((relPos.x() < 0.5 || relPos.x() > 999.5)
				&&	(relPos.z() < 0.5 || relPos.z() > 999.5)) {
					p->data.texcoord[j].u = 0.504f;
				} else {
					p->data.texcoord[j].u = 0.625f;
				}

				if (relPos.y() > polyCenters[i].y() + 0.5) {
					p->data.texcoord[j].v = 0.371f;
				} else {
					p->data.texcoord[j].v = 0.250f;
				}

				p->data.color[j].value = 0xFFFFFF;
			}
		}
	}

	return true;
}
Exemplo n.º 21
0
btCollisionShape* convertURDFToCollisionShape(const UrdfCollision* collision, const char* urdfPathPrefix)
{
	btCollisionShape* shape = 0;

    switch (collision->m_geometry.m_type)
    {
        case URDF_GEOM_CYLINDER:
        {
			btScalar cylRadius = collision->m_geometry.m_cylinderRadius;
			btScalar cylLength = collision->m_geometry.m_cylinderLength;
			
            btAlignedObjectArray<btVector3> vertices;
            //int numVerts = sizeof(barrel_vertices)/(9*sizeof(float));
            int numSteps = 32;
            for (int i=0;i<numSteps;i++)
            {

                btVector3 vert(cylRadius*btSin(SIMD_2_PI*(float(i)/numSteps)),cylRadius*btCos(SIMD_2_PI*(float(i)/numSteps)),cylLength/2.);
                vertices.push_back(vert);
                vert[2] = -cylLength/2.;
                vertices.push_back(vert);

            }
            btConvexHullShape* cylZShape = new btConvexHullShape(&vertices[0].x(), vertices.size(), sizeof(btVector3));
            cylZShape->setMargin(0.001);
			cylZShape->initializePolyhedralFeatures();
			//btConvexShape* cylZShape = new btConeShapeZ(cyl->radius,cyl->length);//(vexHullShape(&vertices[0].x(), vertices.size(), sizeof(btVector3));
            
            //btVector3 halfExtents(cyl->radius,cyl->radius,cyl->length/2.);
            //btCylinderShapeZ* cylZShape = new btCylinderShapeZ(halfExtents);
            

            shape = cylZShape;
            break;
        }
        case URDF_GEOM_BOX:
        {
			btVector3 extents = collision->m_geometry.m_boxSize;
			btBoxShape* boxShape = new btBoxShape(extents*0.5f);
			//btConvexShape* boxShape = new btConeShapeX(extents[2]*0.5,extents[0]*0.5);
            shape = boxShape;
			shape ->setMargin(0.001);
            break;
        }
        case URDF_GEOM_SPHERE:
        {
            
			btScalar radius = collision->m_geometry.m_sphereRadius;
			btSphereShape* sphereShape = new btSphereShape(radius);
            shape = sphereShape;
			shape ->setMargin(0.001);
            break;

            break;
        }
        case URDF_GEOM_MESH:
        {
			if (collision->m_name.length())
			{
				//b3Printf("collision->name=%s\n",collision->m_name.c_str());
			}
			if (1)
			{
				if (collision->m_geometry.m_meshFileName.length())
				{
					const char* filename = collision->m_geometry.m_meshFileName.c_str();
					//b3Printf("mesh->filename=%s\n",filename);
					char fullPath[1024];
					int fileType = 0;
					sprintf(fullPath,"%s%s",urdfPathPrefix,filename);
					b3FileUtils::toLower(fullPath);
                    char tmpPathPrefix[1024];
                    int maxPathLen = 1024;
                    b3FileUtils::extractPath(filename,tmpPathPrefix,maxPathLen);
                    
                    char collisionPathPrefix[1024];
                    sprintf(collisionPathPrefix,"%s%s",urdfPathPrefix,tmpPathPrefix);
                    
                    
                    
					if (strstr(fullPath,".dae"))
					{
						fileType = FILE_COLLADA;
					}
					if (strstr(fullPath,".stl"))
					{
						fileType = FILE_STL;
					}
                    if (strstr(fullPath,".obj"))
                   {
                       fileType = FILE_OBJ;
                   }

					sprintf(fullPath,"%s%s",urdfPathPrefix,filename);
					FILE* f = fopen(fullPath,"rb");
					if (f)
					{
						fclose(f);
						GLInstanceGraphicsShape* glmesh = 0;
						
						
						switch (fileType)
						{
                            case FILE_OBJ:
                            {
                                glmesh = LoadMeshFromObj(fullPath,collisionPathPrefix);
                                break;
                            }
						case FILE_STL:
							{
								glmesh = LoadMeshFromSTL(fullPath);
							break;
							}
						case FILE_COLLADA:
							{
								
								btAlignedObjectArray<GLInstanceGraphicsShape> visualShapes;
								btAlignedObjectArray<ColladaGraphicsInstance> visualShapeInstances;
								btTransform upAxisTrans;upAxisTrans.setIdentity();
								float unitMeterScaling=1;
								int upAxis = 2;
								LoadMeshFromCollada(fullPath,
													visualShapes, 
													visualShapeInstances,
													upAxisTrans,
													unitMeterScaling,
													upAxis );
								
								glmesh = new GLInstanceGraphicsShape;
						//		int index = 0;
								glmesh->m_indices = new b3AlignedObjectArray<int>();
								glmesh->m_vertices = new b3AlignedObjectArray<GLInstanceVertex>();

								for (int i=0;i<visualShapeInstances.size();i++)
								{
									ColladaGraphicsInstance* instance = &visualShapeInstances[i];
									GLInstanceGraphicsShape* gfxShape = &visualShapes[instance->m_shapeIndex];
		
									b3AlignedObjectArray<GLInstanceVertex> verts;
									verts.resize(gfxShape->m_vertices->size());

									int baseIndex = glmesh->m_vertices->size();

									for (int i=0;i<gfxShape->m_vertices->size();i++)
									{
										verts[i].normal[0] = 	gfxShape->m_vertices->at(i).normal[0];
										verts[i].normal[1] = 	gfxShape->m_vertices->at(i).normal[1];
										verts[i].normal[2] = 	gfxShape->m_vertices->at(i).normal[2];
										verts[i].uv[0] = gfxShape->m_vertices->at(i).uv[0];
										verts[i].uv[1] = gfxShape->m_vertices->at(i).uv[1];
										verts[i].xyzw[0] = gfxShape->m_vertices->at(i).xyzw[0];
										verts[i].xyzw[1] = gfxShape->m_vertices->at(i).xyzw[1];
										verts[i].xyzw[2] = gfxShape->m_vertices->at(i).xyzw[2];
										verts[i].xyzw[3] = gfxShape->m_vertices->at(i).xyzw[3];

									}

									int curNumIndices = glmesh->m_indices->size();
									int additionalIndices = gfxShape->m_indices->size();
									glmesh->m_indices->resize(curNumIndices+additionalIndices);
									for (int k=0;k<additionalIndices;k++)
									{
										glmesh->m_indices->at(curNumIndices+k)=gfxShape->m_indices->at(k)+baseIndex;
									}
			
									//compensate upAxisTrans and unitMeterScaling here
									btMatrix4x4 upAxisMat;
                                    upAxisMat.setIdentity();
									//upAxisMat.setPureRotation(upAxisTrans.getRotation());
									btMatrix4x4 unitMeterScalingMat;
									unitMeterScalingMat.setPureScaling(btVector3(unitMeterScaling,unitMeterScaling,unitMeterScaling));
									btMatrix4x4 worldMat = unitMeterScalingMat*instance->m_worldTransform*upAxisMat;
									//btMatrix4x4 worldMat = instance->m_worldTransform;
									int curNumVertices = glmesh->m_vertices->size();
									int additionalVertices = verts.size();
									glmesh->m_vertices->reserve(curNumVertices+additionalVertices);
									
									for(int v=0;v<verts.size();v++)
									{
										btVector3 pos(verts[v].xyzw[0],verts[v].xyzw[1],verts[v].xyzw[2]);
										pos = worldMat*pos;
										verts[v].xyzw[0] = float(pos[0]);
										verts[v].xyzw[1] = float(pos[1]);
										verts[v].xyzw[2] = float(pos[2]);
										glmesh->m_vertices->push_back(verts[v]);
									}
								}
								glmesh->m_numIndices = glmesh->m_indices->size();
								glmesh->m_numvertices = glmesh->m_vertices->size();
								//glmesh = LoadMeshFromCollada(fullPath);

								break;
							}
						default:
							{
                                b3Warning("Unsupported file type in Collision: %s\n",fullPath);
                                btAssert(0);
							}
						}
					

						if (glmesh && (glmesh->m_numvertices>0))
						{
							//b3Printf("extracted %d verticed from STL file %s\n", glmesh->m_numvertices,fullPath);
							//int shapeId = m_glApp->m_instancingRenderer->registerShape(&gvertices[0].pos[0],gvertices.size(),&indices[0],indices.size());
							//convex->setUserIndex(shapeId);
							btAlignedObjectArray<btVector3> convertedVerts;
							convertedVerts.reserve(glmesh->m_numvertices);
							for (int i=0;i<glmesh->m_numvertices;i++)
							{
								convertedVerts.push_back(btVector3(glmesh->m_vertices->at(i).xyzw[0],glmesh->m_vertices->at(i).xyzw[1],glmesh->m_vertices->at(i).xyzw[2]));
							}
							//btConvexHullShape* cylZShape = new btConvexHullShape(&glmesh->m_vertices->at(0).xyzw[0], glmesh->m_numvertices, sizeof(GLInstanceVertex));
							btConvexHullShape* cylZShape = new btConvexHullShape(&convertedVerts[0].getX(), convertedVerts.size(), sizeof(btVector3));
							//cylZShape->initializePolyhedralFeatures();
							//btVector3 halfExtents(cyl->radius,cyl->radius,cyl->length/2.);
							//btCylinderShapeZ* cylZShape = new btCylinderShapeZ(halfExtents);
							cylZShape->setMargin(0.001);
							shape = cylZShape;
						} else
						{
							b3Warning("issue extracting mesh from STL file %s\n", fullPath);
						}

                        delete glmesh;
                       
					} else
					{
						b3Warning("mesh geometry not found %s\n",fullPath);
					}
							
				}
			}

					
            break;
        }
        default:
        {
            b3Warning("Error: unknown visual geometry type\n");
        }
    }
	return shape;
}
Exemplo n.º 22
0
  void MeshLoader::loadScene(const aiScene *scene) {
    m_entity = std::make_shared<Entity>();

    for (int i = 0; i < scene->mNumMeshes; i++) {
      const aiMesh *model = scene->mMeshes[i];

      std::vector<Vertex> vertices;
      std::vector<unsigned int> indices;

      const aiVector3D aiZeroVector(0.0f, 0.0f, 0.0f);
      for (unsigned int i = 0; i < model->mNumVertices; i++) {
        const aiVector3D *pPos = &(model->mVertices[i]);
        const aiVector3D *pNormal = &(model->mNormals[i]);
        const aiVector3D *pTexCoord = model->HasTextureCoords(0) ? &(model->mTextureCoords[0][i]) : &aiZeroVector;
        const aiVector3D *pTangent = model->HasTangentsAndBitangents() ? &(model->mTangents[i]) : &aiZeroVector;

        Vertex vert(glm::vec3(pPos->x, pPos->y, pPos->z),
                    glm::vec2(pTexCoord->x, pTexCoord->y),
                    glm::vec3(pNormal->x, pNormal->y, pNormal->z),
                    glm::vec3(pTangent->x, pTangent->y, pTangent->z));

        vertices.push_back(vert);
      }

      for (unsigned int i = 0; i < model->mNumFaces; i++) {
        const aiFace &face = model->mFaces[i];
        indices.push_back(face.mIndices[0]);
        indices.push_back(face.mIndices[1]);
        indices.push_back(face.mIndices[2]);
      }

      const aiMaterial *pMaterial = scene->mMaterials[model->mMaterialIndex];
      log_info("tex num: %i", model->mMaterialIndex);

      std::shared_ptr<Texture> diffuseMap;
      std::shared_ptr<Texture> normalMap;
      std::shared_ptr<Texture> specularMap;

      aiString Path;

      if (pMaterial->GetTextureCount(aiTextureType_DIFFUSE) > 0 &&
          pMaterial->GetTexture(aiTextureType_DIFFUSE, 0, &Path, NULL, NULL, NULL, NULL, NULL) == AI_SUCCESS) {
        diffuseMap = std::make_shared<Texture>(Asset(Path.data));
      } else {
        diffuseMap = std::make_shared<Texture>(Asset("default_normal.jpg"));
      }

      if (pMaterial->GetTextureCount(aiTextureType_HEIGHT) > 0 &&
          pMaterial->GetTexture(aiTextureType_HEIGHT, 0, &Path, NULL, NULL, NULL, NULL, NULL) == AI_SUCCESS) {
        normalMap = std::make_shared<Texture>(Asset(Path.data));
      } else {
        normalMap = std::make_shared<Texture>(Asset("default_normal.jpg"));
      }

      if (pMaterial->GetTextureCount(aiTextureType_SPECULAR) > 0 &&
          pMaterial->GetTexture(aiTextureType_SPECULAR, 0, &Path, NULL, NULL, NULL, NULL, NULL) == AI_SUCCESS) {
        specularMap = std::make_shared<Texture>(Asset(Path.data));
      } else {
        specularMap = std::make_shared<Texture>(Asset("default_specular.jpg"));
      }

      MeshRendererData meshRenderData;
      meshRenderData.mesh = std::make_shared<Mesh>(m_fileName + std::string(model->mName.C_Str()), &vertices[0],
                                                   vertices.size(), &indices[0], indices.size());
      meshRenderData.material = std::make_shared<Material>(diffuseMap, normalMap, specularMap);

      MeshLoader::sceneMeshRendererDataCache[m_fileName].push_back(meshRenderData);
      m_entity->addComponent<MeshRenderer>(meshRenderData.mesh, meshRenderData.material);
    }
  }
Exemplo n.º 23
0
bool  Tessellation(int& OutputVertNum, int& OutputIndiceNum)
{
	if (ExtRingCoords == NULL)
	{
		return false;
	}
#ifdef _DEBUG
	//test
	std::cout<<"EXT"<<std::endl;
	std::cout<<ExtRingVertNum<<std::endl;
	for (int i = 0; i < ExtRingVertNum; i++)
	{
		std::cout<<ExtRingCoords[i][0]<<ExtRingCoords[i][1]<<ExtRingCoords[i][2]<<std::endl;
	}
	std::cout<<"INT"<<std::endl;
	std::cout<<IntRingCoordsNum.size()<<std::endl;
	std::vector<int>::iterator itr = IntRingCoordsNum.begin();
	std::vector<Vec3*>::iterator itr2 = IntRingCoords.begin();
	for (;itr != IntRingCoordsNum.end(); itr++, itr2++)
	{
		std::cout<<*itr<<std::endl;
		for (int i = 0 ; i <*itr; i ++ )
		{
			std::cout<<(*itr2)[i][0]<<(*itr2)[i][1]<<(*itr2)[i][2]<<std::endl;
		}
	}
	std::cout<<"good1"<<std::endl;
#endif

	int IntRingNum = IntRingCoords.size();
	//calculate the normal
	Vec3 pNorm;
	pNorm[0] = 0.0;
	pNorm[1] = 0.0;
	pNorm[2] = 0.0;

	Vec3 lVert;
	lVert[0] = ExtRingCoords[ExtRingVertNum - 1][0];
	lVert[1] = ExtRingCoords[ExtRingVertNum - 1][1];
	lVert[2] = ExtRingCoords[ExtRingVertNum - 1][2];

	for (int i = 0 ; i < ExtRingVertNum; i++)
	{
		Vec3 pStep;
		pStep[0] = (lVert[2] + ExtRingCoords[i][2]) * (lVert[1] - ExtRingCoords[i][1]);
		pStep[1] = (lVert[0] + ExtRingCoords[i][0]) * (lVert[2] - ExtRingCoords[i][2]);
		pStep[2] = (lVert[1] + ExtRingCoords[i][1]) * (lVert[0] - ExtRingCoords[i][0]);

		pNorm[0] = pNorm[0] + pStep[0];
		pNorm[1] = pNorm[1] + pStep[1];
		pNorm[2] = pNorm[2] + pStep[2];

		lVert[0] = ExtRingCoords[i][0];
		lVert[1] = ExtRingCoords[i][1];
		lVert[2] = ExtRingCoords[i][2];
	}
#ifdef _DEBUG
	//test
	std::cout<<"good2"<<std::endl;
#endif
	//do tessellation
	//verts number
	int VertNum = ExtRingVertNum;
	for (int i = 0; i < IntRingCoordsNum.size(); i++)
		VertNum += IntRingCoordsNum[i];
	//
#ifdef _DEBUG
	//test
	std::cout<<"good2.1"<<std::endl;
	std::cout<<"VertNum: "<<VertNum<<std::endl;
	std::cout<<pNorm[0]<<pNorm[1]<<pNorm[2]<<std::endl;
#endif
	tess.init(VertNum, TVec3d(pNorm[0], pNorm[1], pNorm[2]));
	std::vector<TVec3d> ring;
	std::vector<TVec2f> tag;//no use
	//add ExtierRing
	for (int i = 0; i < ExtRingVertNum; i++)
	{
		TVec3d vert(ExtRingCoords[i][0], ExtRingCoords[i][1], ExtRingCoords[i][2]);
		ring.push_back(vert);
	}
#ifdef _DEBUG
	//test
	std::cout<<"good2.2"<<std::endl;
	std::cout<<ring.size()<<std::endl;
#endif
	tess.addContour(ring, tag);
	ring.clear();
	//add InteriorRings
	for (int i = 0; i < IntRingNum; i++)
	{	
		for (int j = 0 ; j < IntRingCoordsNum[i]; j++)
		{
			TVec3d vert(IntRingCoords[i][j][0], IntRingCoords[i][j][1], IntRingCoords[i][j][2]);
			ring.push_back(vert);
		}
		tess.addContour(ring, tag);
		ring.clear();
	}
#ifdef _DEBUG
	//test
	std::cout<<"good2.3"<<std::endl;
#endif
	tess.compute();
	//return results
	if (tess.getIndices().size() == 0)
	{
		return false;
	}
#ifdef _DEBUG
	//test
	std::cout<<"good3"<<std::endl;
#endif
	//return coordsSAT
	OutputVertNum = tess.getVertices().size();
	OutputIndiceNum = tess.getIndices().size()/3;

	//
	{
		delete[] ExtRingCoords;
		ExtRingCoords = NULL;
		std::vector<Vec3*>::iterator itr = IntRingCoords.begin();
		for (; itr != IntRingCoords.end(); itr++)
		{
			delete[] *itr;
			*itr = NULL;
		}
	}
#ifdef _DEBUG
	//test
	std::cout<<"good4"<<std::endl;
#endif
	return true;
}
Exemplo n.º 24
0
  void 
  RTriangleMesh::init(const std::tr1::shared_ptr<magnet::thread::TaskQueue>& systemQueue)
  {
    RTriangles::init(systemQueue);

    //Send the data we already have
    setGLPositions(_vertices);
    setGLElements(_elements);

    {//Calculate the normal vectors
      std::vector<float> VertexNormals(_vertices.size(), 0);
    
      //For every triangle, add the cross product of the two edges. We
      //then renormalize the normal to get a
      //"weighted-by-the-triangle-size" normal.
    
      for (size_t triangle(0); triangle < _elements.size() / 3; ++triangle)
	{
	  //Grab the vertex IDs
	  size_t v1(_elements[3 * triangle + 0]),
	    v2(_elements[3 * triangle + 1]),
	    v3(_elements[3 * triangle + 2]);
	
	  Vector V1(_vertices[3 * v1 + 0],
		    _vertices[3 * v1 + 1],
		    _vertices[3 * v1 + 2]),
	    V2(_vertices[3 * v2 + 0],
	       _vertices[3 * v2 + 1],
	       _vertices[3 * v2 + 2]),
	    V3(_vertices[3 * v3 + 0],
	       _vertices[3 * v3 + 1],
	       _vertices[3 * v3 + 2]);

	  Vector norm = (V2-V1)^(V3-V2);
	
	  for (size_t i(0); i < 3; ++i)
	    {
	      VertexNormals[3 * v1 + i] += norm[i];
	      VertexNormals[3 * v2 + i] += norm[i];
	      VertexNormals[3 * v3 + i] += norm[i];
	    }
	}

      //Now normalize those vertices
      for (size_t vert(0); vert < _vertices.size() / 3; ++vert)
	{
	  double norm 
	    = VertexNormals[3 * vert + 0] * VertexNormals[3 * vert + 0]
	    + VertexNormals[3 * vert + 1] * VertexNormals[3 * vert + 1]
	    + VertexNormals[3 * vert + 2] * VertexNormals[3 * vert + 2];
	
	  if (norm)
	    {
	      double factor = 1 / std::sqrt(norm);
	      VertexNormals[3 * vert + 0] *= factor;
	      VertexNormals[3 * vert + 1] *= factor;
	      VertexNormals[3 * vert + 2] *= factor;
	    }
	  else
	    {
	      VertexNormals[3 * vert + 0] = 1;
	      VertexNormals[3 * vert + 1] = 0;
	      VertexNormals[3 * vert + 2] = 0;
	    }
	}

      setGLNormals(VertexNormals);
    }
  
    //Reclaim some memory
    _vertices.clear();
    _elements.clear();
  }
void convertURDFToVisualShape(const UrdfVisual* visual, const char* urdfPathPrefix, const btTransform& visualTransform, btAlignedObjectArray<GLInstanceVertex>& verticesOut, btAlignedObjectArray<int>& indicesOut, btAlignedObjectArray<MyTexture2>& texturesOut)
{

	
	GLInstanceGraphicsShape* glmesh = 0;

	btConvexShape* convexColShape = 0;

	switch (visual->m_geometry.m_type)
	{
		case URDF_GEOM_CYLINDER:
		{
			btAlignedObjectArray<btVector3> vertices;
		
			//int numVerts = sizeof(barrel_vertices)/(9*sizeof(float));
			int numSteps = 32;
			for (int i = 0; i<numSteps; i++)
			{

				btScalar cylRadius = visual->m_geometry.m_cylinderRadius;
				btScalar cylLength = visual->m_geometry.m_cylinderLength;
				
				btVector3 vert(cylRadius*btSin(SIMD_2_PI*(float(i) / numSteps)), cylRadius*btCos(SIMD_2_PI*(float(i) / numSteps)), cylLength / 2.);
				vertices.push_back(vert);
				vert[2] = -cylLength / 2.;
				vertices.push_back(vert);
			}

			btConvexHullShape* cylZShape = new btConvexHullShape(&vertices[0].x(), vertices.size(), sizeof(btVector3));
			cylZShape->setMargin(0.001);
			convexColShape = cylZShape;
			break;
		}
		case URDF_GEOM_BOX:
		{
			
			btVector3 extents = visual->m_geometry.m_boxSize;
			
			btBoxShape* boxShape = new btBoxShape(extents*0.5f);
			//btConvexShape* boxShape = new btConeShapeX(extents[2]*0.5,extents[0]*0.5);
			convexColShape = boxShape;
			convexColShape->setMargin(0.001);
			break;
		}
		case URDF_GEOM_SPHERE:
		{
			btScalar radius = visual->m_geometry.m_sphereRadius;
			btSphereShape* sphereShape = new btSphereShape(radius);
			convexColShape = sphereShape;
			convexColShape->setMargin(0.001);
			break;

			break;
		}
		case URDF_GEOM_MESH:
		{
			if (visual->m_name.length())
			{
				//b3Printf("visual->name=%s\n", visual->m_name.c_str());
			}
			if (1)//visual->m_geometry)
			{
				if (visual->m_geometry.m_meshFileName.length())
				{
					const char* filename = visual->m_geometry.m_meshFileName.c_str();
					//b3Printf("mesh->filename=%s\n", filename);
					char fullPath[1024];
					int fileType = 0;
                    
                    char tmpPathPrefix[1024];
                    std::string xml_string;
                    int maxPathLen = 1024;
                    b3FileUtils::extractPath(filename,tmpPathPrefix,maxPathLen);
                   
                    char visualPathPrefix[1024];
                    sprintf(visualPathPrefix,"%s%s",urdfPathPrefix,tmpPathPrefix);
                    
                    
					sprintf(fullPath, "%s%s", urdfPathPrefix, filename);
					b3FileUtils::toLower(fullPath);
					if (strstr(fullPath, ".dae"))
					{
						fileType = MY_FILE_COLLADA;
					}
					if (strstr(fullPath, ".stl"))
					{
						fileType = MY_FILE_STL;
					}
                    if (strstr(fullPath,".obj"))
                    {
                        fileType = MY_FILE_OBJ;
                    }


					sprintf(fullPath, "%s%s", urdfPathPrefix, filename);
					FILE* f = fopen(fullPath, "rb");
					if (f)
					{
						fclose(f);
						


						switch (fileType)
						{
                            case MY_FILE_OBJ:
                            {
                                //glmesh = LoadMeshFromObj(fullPath,visualPathPrefix);
								b3ImportMeshData meshData;
								if (b3ImportMeshUtility::loadAndRegisterMeshFromFileInternal(fullPath, meshData))
								{
									
									if (meshData.m_textureImage)
									{
										MyTexture2 texData;
										texData.m_width = meshData.m_textureWidth;
										texData.m_height = meshData.m_textureHeight;
										texData.textureData = meshData.m_textureImage;
										texturesOut.push_back(texData);
									}
									glmesh = meshData.m_gfxShape;
								}

								
                                break;
                            }
                           
						case MY_FILE_STL:
						{
							glmesh = LoadMeshFromSTL(fullPath);
							break;
						}
						case MY_FILE_COLLADA:
						{

							btAlignedObjectArray<GLInstanceGraphicsShape> visualShapes;
							btAlignedObjectArray<ColladaGraphicsInstance> visualShapeInstances;
							btTransform upAxisTrans; upAxisTrans.setIdentity();
							float unitMeterScaling = 1;
							int upAxis = 2;

							LoadMeshFromCollada(fullPath,
								visualShapes,
								visualShapeInstances,
								upAxisTrans,
								unitMeterScaling,
												upAxis);

							glmesh = new GLInstanceGraphicsShape;
					//		int index = 0;
							glmesh->m_indices = new b3AlignedObjectArray<int>();
							glmesh->m_vertices = new b3AlignedObjectArray<GLInstanceVertex>();

							for (int i = 0; i<visualShapeInstances.size(); i++)
							{
								ColladaGraphicsInstance* instance = &visualShapeInstances[i];
								GLInstanceGraphicsShape* gfxShape = &visualShapes[instance->m_shapeIndex];

								b3AlignedObjectArray<GLInstanceVertex> verts;
								verts.resize(gfxShape->m_vertices->size());

								int baseIndex = glmesh->m_vertices->size();

								for (int i = 0; i<gfxShape->m_vertices->size(); i++)
								{
									verts[i].normal[0] = gfxShape->m_vertices->at(i).normal[0];
									verts[i].normal[1] = gfxShape->m_vertices->at(i).normal[1];
									verts[i].normal[2] = gfxShape->m_vertices->at(i).normal[2];
									verts[i].uv[0] = gfxShape->m_vertices->at(i).uv[0];
									verts[i].uv[1] = gfxShape->m_vertices->at(i).uv[1];
									verts[i].xyzw[0] = gfxShape->m_vertices->at(i).xyzw[0];
									verts[i].xyzw[1] = gfxShape->m_vertices->at(i).xyzw[1];
									verts[i].xyzw[2] = gfxShape->m_vertices->at(i).xyzw[2];
									verts[i].xyzw[3] = gfxShape->m_vertices->at(i).xyzw[3];

								}

								int curNumIndices = glmesh->m_indices->size();
								int additionalIndices = gfxShape->m_indices->size();
								glmesh->m_indices->resize(curNumIndices + additionalIndices);
								for (int k = 0; k<additionalIndices; k++)
								{
									glmesh->m_indices->at(curNumIndices + k) = gfxShape->m_indices->at(k) + baseIndex;
								}

								//compensate upAxisTrans and unitMeterScaling here
								btMatrix4x4 upAxisMat;
								upAxisMat.setIdentity();
//								upAxisMat.setPureRotation(upAxisTrans.getRotation());
								btMatrix4x4 unitMeterScalingMat;
								unitMeterScalingMat.setPureScaling(btVector3(unitMeterScaling, unitMeterScaling, unitMeterScaling));
								btMatrix4x4 worldMat = unitMeterScalingMat*upAxisMat*instance->m_worldTransform;
								//btMatrix4x4 worldMat = instance->m_worldTransform;
								int curNumVertices = glmesh->m_vertices->size();
								int additionalVertices = verts.size();
								glmesh->m_vertices->reserve(curNumVertices + additionalVertices);

								for (int v = 0; v<verts.size(); v++)
								{
									btVector3 pos(verts[v].xyzw[0], verts[v].xyzw[1], verts[v].xyzw[2]);
									pos = worldMat*pos;
									verts[v].xyzw[0] = float(pos[0]);
									verts[v].xyzw[1] = float(pos[1]);
									verts[v].xyzw[2] = float(pos[2]);
									glmesh->m_vertices->push_back(verts[v]);
								}
							}
							glmesh->m_numIndices = glmesh->m_indices->size();
							glmesh->m_numvertices = glmesh->m_vertices->size();
							//glmesh = LoadMeshFromCollada(fullPath);

							break;
						}
						default:
						{
                            b3Warning("Error: unsupported file type for Visual mesh: %s\n", fullPath);
                            btAssert(0);
						}
						}


						if (glmesh && glmesh->m_vertices && (glmesh->m_numvertices>0))
						{
						    //apply the geometry scaling
						    for (int i=0;i<glmesh->m_vertices->size();i++)
                            {
                                glmesh->m_vertices->at(i).xyzw[0] *= visual->m_geometry.m_meshScale[0];
                                glmesh->m_vertices->at(i).xyzw[1] *= visual->m_geometry.m_meshScale[1];
                                glmesh->m_vertices->at(i).xyzw[2] *= visual->m_geometry.m_meshScale[2];
                            }
						    
						}
						else
						{
							b3Warning("issue extracting mesh from COLLADA/STL file %s\n", fullPath);
						}

					}
					else
					{
						b3Warning("mesh geometry not found %s\n", fullPath);
					}


				}
			}


			break;
		}
		default:
		{
			b3Warning("Error: unknown visual geometry type\n");
		}
	}

	//if we have a convex, tesselate into localVertices/localIndices
	if ((glmesh==0) && convexColShape)
	{
		btShapeHull* hull = new btShapeHull(convexColShape);
		hull->buildHull(0.0);
		{
			//	int strideInBytes = 9*sizeof(float);
			int numVertices = hull->numVertices();
			int numIndices = hull->numIndices();

			
			glmesh = new GLInstanceGraphicsShape;
		//	int index = 0;
			glmesh->m_indices = new b3AlignedObjectArray<int>();
			glmesh->m_vertices = new b3AlignedObjectArray<GLInstanceVertex>();


			for (int i = 0; i < numVertices; i++)
			{
				GLInstanceVertex vtx;
				btVector3 pos = hull->getVertexPointer()[i];
				vtx.xyzw[0] = pos.x();
				vtx.xyzw[1] = pos.y();
				vtx.xyzw[2] = pos.z();
				vtx.xyzw[3] = 1.f;
				pos.normalize();
				vtx.normal[0] = pos.x();
				vtx.normal[1] = pos.y();
				vtx.normal[2] = pos.z();
				vtx.uv[0] = 0.5f;
				vtx.uv[1] = 0.5f;
				glmesh->m_vertices->push_back(vtx);
			}

			btAlignedObjectArray<int> indices;
			for (int i = 0; i < numIndices; i++)
			{
				glmesh->m_indices->push_back(hull->getIndexPointer()[i]);
			}
			
			glmesh->m_numvertices = glmesh->m_vertices->size();
			glmesh->m_numIndices = glmesh->m_indices->size();
		}
        delete hull;
		delete convexColShape;
		convexColShape = 0;

	}
	
	if (glmesh && glmesh->m_numIndices>0 && glmesh->m_numvertices >0)
	{

		int baseIndex = verticesOut.size();



		for (int i = 0; i < glmesh->m_indices->size(); i++)
		{
			indicesOut.push_back(glmesh->m_indices->at(i) + baseIndex);
		}

		for (int i = 0; i < glmesh->m_vertices->size(); i++)
		{
			GLInstanceVertex& v = glmesh->m_vertices->at(i);
			btVector3 vert(v.xyzw[0],v.xyzw[1],v.xyzw[2]);
			btVector3 vt = visualTransform*vert;
			v.xyzw[0] = vt[0];
			v.xyzw[1] = vt[1];
			v.xyzw[2] = vt[2];
			btVector3 triNormal(v.normal[0],v.normal[1],v.normal[2]);
			triNormal = visualTransform.getBasis()*triNormal;
			v.normal[0] = triNormal[0];
			v.normal[1] = triNormal[1];
			v.normal[2] = triNormal[2];
			verticesOut.push_back(v);
		}
	}
    delete glmesh;
    
}
Exemplo n.º 26
0
void StochasticPointRenderer::initializeShader( void )
{
    const std::string vert_code = "StochasticShader/point.vert";
    const std::string frag_code = "StochasticShader/point.frag";

    kvs::glew::ShaderSource vert( vert_code );
    kvs::glew::ShaderSource frag( frag_code );

    if ( BaseClass::isEnabledShading() )
    {
        switch ( BaseClass::m_shader->type() )
        {
        case kvs::Shader::LambertShading: frag.define("ENABLE_LAMBERT_SHADING"); break;
        case kvs::Shader::PhongShading: frag.define("ENABLE_PHONG_SHADING"); break;
        case kvs::Shader::BlinnPhongShading: frag.define("ENABLE_BLINN_PHONG_SHADING"); break;
        default: /* NO SHADING */ break;
        }
    }

    this->create_shaders( m_shader_program, vert, frag );
    m_loc_identifier = m_shader_program.attributeLocation( "identifier" );

    if ( BaseClass::isEnabledShading() )
    {
        m_shader_program.bind();
        switch ( BaseClass::m_shader->type() )
        {
        case kvs::Shader::LambertShading:
        {
            const GLfloat Ka = ((kvs::Shader::Lambert*)(BaseClass::m_shader))->Ka;
            const GLfloat Kd = ((kvs::Shader::Lambert*)(BaseClass::m_shader))->Kd;
            m_shader_program.setUniformValuef( "shading.Ka", Ka );
            m_shader_program.setUniformValuef( "shading.Kd", Kd );
            break;
        }
        case kvs::Shader::PhongShading:
        {
            const GLfloat Ka = ((kvs::Shader::Phong*)(BaseClass::m_shader))->Ka;
            const GLfloat Kd = ((kvs::Shader::Phong*)(BaseClass::m_shader))->Kd;
            const GLfloat Ks = ((kvs::Shader::Phong*)(BaseClass::m_shader))->Ks;
            const GLfloat S  = ((kvs::Shader::Phong*)(BaseClass::m_shader))->S;
            m_shader_program.setUniformValuef( "shading.Ka", Ka );
            m_shader_program.setUniformValuef( "shading.Kd", Kd );
            m_shader_program.setUniformValuef( "shading.Ks", Ks );
            m_shader_program.setUniformValuef( "shading.S",  S );
            break;
        }
        case kvs::Shader::BlinnPhongShading:
        {
            const GLfloat Ka = ((kvs::Shader::BlinnPhong*)(BaseClass::m_shader))->Ka;
            const GLfloat Kd = ((kvs::Shader::BlinnPhong*)(BaseClass::m_shader))->Kd;
            const GLfloat Ks = ((kvs::Shader::BlinnPhong*)(BaseClass::m_shader))->Ks;
            const GLfloat S  = ((kvs::Shader::BlinnPhong*)(BaseClass::m_shader))->S;
            m_shader_program.setUniformValuef( "shading.Ka", Ka );
            m_shader_program.setUniformValuef( "shading.Kd", Kd );
            m_shader_program.setUniformValuef( "shading.Ks", Ks );
            m_shader_program.setUniformValuef( "shading.S",  S );
            break;
        }
        default: /* NO SHADING */ break;
        }
        m_shader_program.unbind();
    }
}
Exemplo n.º 27
0
bool Map::LoadV2(FILE *f) {
	uint32 data_size;
	if (fread(&data_size, sizeof(data_size), 1, f) != 1) {
		return false;
	}

	uint32 buffer_size;
	if (fread(&buffer_size, sizeof(buffer_size), 1, f) != 1) {
		return false;
	}

	std::vector<char> data;
	data.resize(data_size);
	if (fread(&data[0], data_size, 1, f) != 1) {
		return false;
	}

	std::vector<char> buffer;
	buffer.resize(buffer_size);
	uint32 v = InflateData(&data[0], data_size, &buffer[0], buffer_size);

	char *buf = &buffer[0];
	uint32 vert_count;
	uint32 ind_count;
	uint32 nc_vert_count;
	uint32 nc_ind_count;
	uint32 model_count;
	uint32 plac_count;
	uint32 plac_group_count;
	uint32 tile_count;
	uint32 quads_per_tile;
	float units_per_vertex;

	vert_count = *(uint32*)buf;
	buf += sizeof(uint32);

	ind_count = *(uint32*)buf;
	buf += sizeof(uint32);

	nc_vert_count = *(uint32*)buf;
	buf += sizeof(uint32);

	nc_ind_count = *(uint32*)buf;
	buf += sizeof(uint32);

	model_count = *(uint32*)buf;
	buf += sizeof(uint32);

	plac_count = *(uint32*)buf;
	buf += sizeof(uint32);

	plac_group_count = *(uint32*)buf;
	buf += sizeof(uint32);

	tile_count = *(uint32*)buf;
	buf += sizeof(uint32);

	quads_per_tile = *(uint32*)buf;
	buf += sizeof(uint32);

	units_per_vertex = *(float*)buf;
	buf += sizeof(float);

	std::vector<Vertex> verts;
	std::vector<uint32> indices;

	for (uint32 i = 0; i < vert_count; ++i) {
		float x;
		float y;
		float z;

		x = *(float*)buf;
		buf += sizeof(float);

		y = *(float*)buf;
		buf += sizeof(float);

		z = *(float*)buf;
		buf += sizeof(float);

		Vertex vert(x, y, z);
		verts.push_back(vert);
	}

	for (uint32 i = 0; i < ind_count; ++i) {
		uint32 index;
		index = *(uint32*)buf;
		buf += sizeof(uint32);

		indices.push_back(index);
	}

	for (uint32 i = 0; i < nc_vert_count; ++i) {
		buf += sizeof(float) * 3;
	}

	for (uint32 i = 0; i < nc_ind_count; ++i) {
		buf += sizeof(uint32);
	}

	std::map<std::string, std::shared_ptr<ModelEntry>> models;
	for (uint32 i = 0; i < model_count; ++i) {
		std::shared_ptr<ModelEntry> me(new ModelEntry);
		std::string name = buf;
		buf += name.length() + 1;

		uint32 vert_count = *(uint32*)buf;
		buf += sizeof(uint32);

		uint32 poly_count = *(uint32*)buf;
		buf += sizeof(uint32);

		me->verts.resize(vert_count);
		for (uint32 j = 0; j < vert_count; ++j) {
			float x = *(float*)buf;
			buf += sizeof(float);
			float y = *(float*)buf;
			buf += sizeof(float);
			float z = *(float*)buf;
			buf += sizeof(float);

			me->verts[j] = Vertex(x, y, z);
		}

		me->polys.resize(poly_count);
		for (uint32 j = 0; j < poly_count; ++j) {
			uint32 v1 = *(uint32*)buf;
			buf += sizeof(uint32);
			uint32 v2 = *(uint32*)buf;
			buf += sizeof(uint32);
			uint32 v3 = *(uint32*)buf;
			buf += sizeof(uint32);
			uint8 vis = *(uint8*)buf;
			buf += sizeof(uint8);

			ModelEntry::Poly p;
			p.v1 = v1;
			p.v2 = v2;
			p.v3 = v3;
			p.vis = vis;
			me->polys[j] = p;
		}

		models[name] = me;
	}

	for (uint32 i = 0; i < plac_count; ++i) {
		std::string name = buf;
		buf += name.length() + 1;

		float x = *(float*)buf;
		buf += sizeof(float);
		float y = *(float*)buf;
		buf += sizeof(float);
		float z = *(float*)buf;
		buf += sizeof(float);

		float x_rot = *(float*)buf;
		buf += sizeof(float);
		float y_rot = *(float*)buf;
		buf += sizeof(float);
		float z_rot = *(float*)buf;
		buf += sizeof(float);

		float x_scale = *(float*)buf;
		buf += sizeof(float);
		float y_scale = *(float*)buf;
		buf += sizeof(float);
		float z_scale = *(float*)buf;
		buf += sizeof(float);

		if (models.count(name) == 0)
			continue;

		auto model = models[name];
		auto &mod_polys = model->polys;
		auto &mod_verts = model->verts;
		for (uint32 j = 0; j < mod_polys.size(); ++j) {
			auto &current_poly = mod_polys[j];
			auto v1 = mod_verts[current_poly.v1];
			auto v2 = mod_verts[current_poly.v2];
			auto v3 = mod_verts[current_poly.v3];

			RotateVertex(v1, x_rot, y_rot, z_rot);
			RotateVertex(v2, x_rot, y_rot, z_rot);
			RotateVertex(v3, x_rot, y_rot, z_rot);

			ScaleVertex(v1, x_scale, y_scale, z_scale);
			ScaleVertex(v2, x_scale, y_scale, z_scale);
			ScaleVertex(v3, x_scale, y_scale, z_scale);

			TranslateVertex(v1, x, y, z);
			TranslateVertex(v2, x, y, z);
			TranslateVertex(v3, x, y, z);

			float t = v1.x;
			v1.x = v1.y;
			v1.y = t;

			t = v2.x;
			v2.x = v2.y;
			v2.y = t;

			t = v3.x;
			v3.x = v3.y;
			v3.y = t;

			if (current_poly.vis != 0) {
				verts.push_back(v1);
				verts.push_back(v2);
				verts.push_back(v3);

				indices.push_back((uint32)verts.size() - 3);
				indices.push_back((uint32)verts.size() - 2);
				indices.push_back((uint32)verts.size() - 1);
			}
		}
	}

	for (uint32 i = 0; i < plac_group_count; ++i) {
		float x = *(float*)buf;
		buf += sizeof(float);
		float y = *(float*)buf;
		buf += sizeof(float);
		float z = *(float*)buf;
		buf += sizeof(float);

		float x_rot = *(float*)buf;
		buf += sizeof(float);
		float y_rot = *(float*)buf;
		buf += sizeof(float);
		float z_rot = *(float*)buf;
		buf += sizeof(float);

		float x_scale = *(float*)buf;
		buf += sizeof(float);
		float y_scale = *(float*)buf;
		buf += sizeof(float);
		float z_scale = *(float*)buf;
		buf += sizeof(float);

		float x_tile = *(float*)buf;
		buf += sizeof(float);
		float y_tile = *(float*)buf;
		buf += sizeof(float);
		float z_tile = *(float*)buf;
		buf += sizeof(float);

		uint32 p_count = *(uint32*)buf;
		buf += sizeof(uint32);

		for (uint32 j = 0; j < p_count; ++j) {
			std::string name = buf;
			buf += name.length() + 1;

			float p_x = *(float*)buf;
			buf += sizeof(float);
			float p_y = *(float*)buf;
			buf += sizeof(float);
			float p_z = *(float*)buf;
			buf += sizeof(float);

			float p_x_rot = *(float*)buf * 3.14159f / 180;
			buf += sizeof(float);
			float p_y_rot = *(float*)buf * 3.14159f / 180;
			buf += sizeof(float);
			float p_z_rot = *(float*)buf * 3.14159f / 180;
			buf += sizeof(float);

			float p_x_scale = *(float*)buf;
			buf += sizeof(float);
			float p_y_scale = *(float*)buf;
			buf += sizeof(float);
			float p_z_scale = *(float*)buf;
			buf += sizeof(float);

			if (models.count(name) == 0)
				continue;

			auto &model = models[name];

			for (size_t k = 0; k < model->polys.size(); ++k) {
				auto &poly = model->polys[k];
				Vertex v1, v2, v3;

				v1 = model->verts[poly.v1];
				v2 = model->verts[poly.v2];
				v3 = model->verts[poly.v3];

				ScaleVertex(v1, p_x_scale, p_y_scale, p_z_scale);
				ScaleVertex(v2, p_x_scale, p_y_scale, p_z_scale);
				ScaleVertex(v3, p_x_scale, p_y_scale, p_z_scale);

				TranslateVertex(v1, p_x, p_y, p_z);
				TranslateVertex(v2, p_x, p_y, p_z);
				TranslateVertex(v3, p_x, p_y, p_z);

				RotateVertex(v1, x_rot * 3.14159f / 180.0f, 0, 0);
				RotateVertex(v2, x_rot * 3.14159f / 180.0f, 0, 0);
				RotateVertex(v3, x_rot * 3.14159f / 180.0f, 0, 0);

				RotateVertex(v1, 0, y_rot * 3.14159f / 180.0f, 0);
				RotateVertex(v2, 0, y_rot * 3.14159f / 180.0f, 0);
				RotateVertex(v3, 0, y_rot * 3.14159f / 180.0f, 0);

				Vertex correction(p_x, p_y, p_z);

				RotateVertex(correction, x_rot * 3.14159f / 180.0f, 0, 0);

				TranslateVertex(v1, -correction.x, -correction.y, -correction.z);
				TranslateVertex(v2, -correction.x, -correction.y, -correction.z);
				TranslateVertex(v3, -correction.x, -correction.y, -correction.z);

				RotateVertex(v1, p_x_rot, 0, 0);
				RotateVertex(v2, p_x_rot, 0, 0);
				RotateVertex(v3, p_x_rot, 0, 0);

				RotateVertex(v1, 0, -p_y_rot, 0);
				RotateVertex(v2, 0, -p_y_rot, 0);
				RotateVertex(v3, 0, -p_y_rot, 0);

				RotateVertex(v1, 0, 0, p_z_rot);
				RotateVertex(v2, 0, 0, p_z_rot);
				RotateVertex(v3, 0, 0, p_z_rot);

				TranslateVertex(v1, correction.x, correction.y, correction.z);
				TranslateVertex(v2, correction.x, correction.y, correction.z);
				TranslateVertex(v3, correction.x, correction.y, correction.z);

				RotateVertex(v1, 0, 0, z_rot * 3.14159f / 180.0f);
				RotateVertex(v2, 0, 0, z_rot * 3.14159f / 180.0f);
				RotateVertex(v3, 0, 0, z_rot * 3.14159f / 180.0f);

				ScaleVertex(v1, x_scale, y_scale, z_scale);
				ScaleVertex(v2, x_scale, y_scale, z_scale);
				ScaleVertex(v3, x_scale, y_scale, z_scale);

				TranslateVertex(v1, x_tile, y_tile, z_tile);
				TranslateVertex(v2, x_tile, y_tile, z_tile);
				TranslateVertex(v3, x_tile, y_tile, z_tile);

				TranslateVertex(v1, x, y, z);
				TranslateVertex(v2, x, y, z);
				TranslateVertex(v3, x, y, z);

				float t = v1.x;
				v1.x = v1.y;
				v1.y = t;

				t = v2.x;
				v2.x = v2.y;
				v2.y = t;

				t = v3.x;
				v3.x = v3.y;
				v3.y = t;

				if (poly.vis != 0) {
					verts.push_back(v1);
					verts.push_back(v2);
					verts.push_back(v3);

					indices.push_back((uint32)verts.size() - 3);
					indices.push_back((uint32)verts.size() - 2);
					indices.push_back((uint32)verts.size() - 1);
				}
			}
		}
	}

	uint32 ter_quad_count = (quads_per_tile * quads_per_tile);
	uint32 ter_vert_count = ((quads_per_tile + 1) * (quads_per_tile + 1));
	std::vector<uint8> flags;
	std::vector<float> floats;
	flags.resize(ter_quad_count);
	floats.resize(ter_vert_count);
	for (uint32 i = 0; i < tile_count; ++i) {
		bool flat;
		flat = *(bool*)buf;
		buf += sizeof(bool);

		float x;
		x = *(float*)buf;
		buf += sizeof(float);

		float y;
		y = *(float*)buf;
		buf += sizeof(float);

		if (flat) {
			float z;
			z = *(float*)buf;
			buf += sizeof(float);

			float QuadVertex1X = x;
			float QuadVertex1Y = y;
			float QuadVertex1Z = z;

			float QuadVertex2X = QuadVertex1X + (quads_per_tile * units_per_vertex);
			float QuadVertex2Y = QuadVertex1Y;
			float QuadVertex2Z = QuadVertex1Z;

			float QuadVertex3X = QuadVertex2X;
			float QuadVertex3Y = QuadVertex1Y + (quads_per_tile * units_per_vertex);
			float QuadVertex3Z = QuadVertex1Z;

			float QuadVertex4X = QuadVertex1X;
			float QuadVertex4Y = QuadVertex3Y;
			float QuadVertex4Z = QuadVertex1Z;

			uint32 current_vert = (uint32)verts.size() + 3;
			verts.push_back(Vertex(QuadVertex1X, QuadVertex1Y, QuadVertex1Z));
			verts.push_back(Vertex(QuadVertex2X, QuadVertex2Y, QuadVertex2Z));
			verts.push_back(Vertex(QuadVertex3X, QuadVertex3Y, QuadVertex3Z));
			verts.push_back(Vertex(QuadVertex4X, QuadVertex4Y, QuadVertex4Z));

			indices.push_back(current_vert);
			indices.push_back(current_vert - 2);
			indices.push_back(current_vert - 1);

			indices.push_back(current_vert);
			indices.push_back(current_vert - 3);
			indices.push_back(current_vert - 2);
		}
		else {
			//read flags
			for (uint32 j = 0; j < ter_quad_count; ++j) {
				uint8 f;
				f = *(uint8*)buf;
				buf += sizeof(uint8);

				flags[j] = f;
			}

			//read floats
			for (uint32 j = 0; j < ter_vert_count; ++j) {
				float f;
				f = *(float*)buf;
				buf += sizeof(float);

				floats[j] = f;
			}

			int row_number = -1;
			std::map<std::tuple<float, float, float>, uint32> cur_verts;
			for (uint32 quad = 0; quad < ter_quad_count; ++quad) {
				if ((quad % quads_per_tile) == 0) {
					++row_number;
				}

				if (flags[quad] & 0x01)
					continue;

				float QuadVertex1X = x + (row_number * units_per_vertex);
				float QuadVertex1Y = y + (quad % quads_per_tile) * units_per_vertex;
				float QuadVertex1Z = floats[quad + row_number];

				float QuadVertex2X = QuadVertex1X + units_per_vertex;
				float QuadVertex2Y = QuadVertex1Y;
				float QuadVertex2Z = floats[quad + row_number + quads_per_tile + 1];

				float QuadVertex3X = QuadVertex1X + units_per_vertex;
				float QuadVertex3Y = QuadVertex1Y + units_per_vertex;
				float QuadVertex3Z = floats[quad + row_number + quads_per_tile + 2];

				float QuadVertex4X = QuadVertex1X;
				float QuadVertex4Y = QuadVertex1Y + units_per_vertex;
				float QuadVertex4Z = floats[quad + row_number + 1];

				uint32 i1, i2, i3, i4;
				std::tuple<float, float, float> t = std::make_tuple(QuadVertex1X, QuadVertex1Y, QuadVertex1Z);
				auto iter = cur_verts.find(t);
				if (iter != cur_verts.end()) {
					i1 = iter->second;
				}
				else {
					i1 = (uint32)verts.size();
					verts.push_back(Vertex(QuadVertex1X, QuadVertex1Y, QuadVertex1Z));
					cur_verts[std::make_tuple(QuadVertex1X, QuadVertex1Y, QuadVertex1Z)] = i1;
				}

				t = std::make_tuple(QuadVertex2X, QuadVertex2Y, QuadVertex2Z);
				iter = cur_verts.find(t);
				if (iter != cur_verts.end()) {
					i2 = iter->second;
				}
				else {
					i2 = (uint32)verts.size();
					verts.push_back(Vertex(QuadVertex2X, QuadVertex2Y, QuadVertex2Z));
					cur_verts[std::make_tuple(QuadVertex2X, QuadVertex2Y, QuadVertex2Z)] = i2;
				}

				t = std::make_tuple(QuadVertex3X, QuadVertex3Y, QuadVertex3Z);
				iter = cur_verts.find(t);
				if (iter != cur_verts.end()) {
					i3 = iter->second;
				}
				else {
					i3 = (uint32)verts.size();
					verts.push_back(Vertex(QuadVertex3X, QuadVertex3Y, QuadVertex3Z));
					cur_verts[std::make_tuple(QuadVertex3X, QuadVertex3Y, QuadVertex3Z)] = i3;
				}

				t = std::make_tuple(QuadVertex4X, QuadVertex4Y, QuadVertex4Z);
				iter = cur_verts.find(t);
				if (iter != cur_verts.end()) {
					i4 = iter->second;
				}
				else {
					i4 = (uint32)verts.size();
					verts.push_back(Vertex(QuadVertex4X, QuadVertex4Y, QuadVertex4Z));
					cur_verts[std::make_tuple(QuadVertex4X, QuadVertex4Y, QuadVertex4Z)] = i4;
				}

				indices.push_back(i4);
				indices.push_back(i2);
				indices.push_back(i3);

				indices.push_back(i4);
				indices.push_back(i1);
				indices.push_back(i2);
			}
		}
	}

	uint32 face_count = indices.size() / 3;

	if (imp) {
		imp->rm->release();
		imp->rm = nullptr;
	}
	else {
		imp = new impl;
	}

	imp->rm = createRaycastMesh((RmUint32)verts.size(), (const RmReal*)&verts[0], face_count, &indices[0]);

	if (!imp->rm) {
		delete imp;
		imp = nullptr;
		return false;
	}

	return true;
}
Exemplo n.º 28
0
void Pyramid::createVAO(void)
{

	struct pyramidVertexStride
	{
		float x;
		float y;
		float z;
		float s;
		float t;
		float nx; 
		float ny;
		float nz;
	};

	struct triangleList
	{
		unsigned short v1;
		unsigned short v2;
		unsigned short v3;
	};

	pyramidVertexStride pVerts[5];

	triangleList		pList[6];

	#if 1
		FileHandle fh2;
		FileError ferror;

		ferror = File::open(fh2, "pyramid.vbo", FILE_READ);
		assert(ferror == FILE_SUCCESS);

		ferror = File::read(fh2, &pVerts, 5 * sizeof(pyramidVertexStride));
		assert(ferror == FILE_SUCCESS);

		ferror = File::read(fh2, &pList, 6 * sizeof(triangleList));
		assert(ferror == FILE_SUCCESS);

		ferror = File::close(fh2);
		assert(ferror == FILE_SUCCESS);

	#else

		// apex
		pVerts[0].x = 0.0f;
		pVerts[0].y = 1.0f;
		pVerts[0].z = 0.0f;
		pVerts[0].s = 0.5f;
		pVerts[0].t = 0.5f;
		pVerts[0].nx = 0.0f;
		pVerts[0].ny = 2.0f;
		pVerts[0].nz = 0.0f;

		// left front
		pVerts[1].x = -1.0f;
		pVerts[1].y = -1.0f;
		pVerts[1].z = 1.0f;//-1.0f;
		pVerts[1].s = 0.0f;
		pVerts[1].t = 0.0f;

		pVerts[1].nx = -3.0f;
		pVerts[1].ny = -5.0f;
		pVerts[1].nz = -3.0f;

		// right front
		pVerts[2].x = 1.0f;
		pVerts[2].y = -1.0f;
		pVerts[2].z = 1.0f;
		pVerts[2].s = 1.0f;
		pVerts[2].t = 0.0f;

		pVerts[2].nx = 3.0f;
		pVerts[2].ny = -5.0f;
		pVerts[2].nz = -3.0f;

		// left back
		pVerts[3].x = -1.0f;
		pVerts[3].y = -1.0f;
		pVerts[3].z = -1.0f;
		pVerts[3].s = 0.0f;
		pVerts[3].t = 1.0f;

		pVerts[3].nx = -3.0f;
		pVerts[3].ny = -5.0f;
		pVerts[3].nz = 3.0f;

		// right back
		pVerts[4].x = 1.0f;
		pVerts[4].y = -1.0f;
		pVerts[4].z = -1.0f;
		pVerts[4].s = 1.0f;
		pVerts[4].t = 1.0f;

		pVerts[4].nx = 3.0f;
		pVerts[4].ny = -5.0f;
		pVerts[4].nz = 3.0f;

		// front
		pList[0].v1 = 0;
		pList[0].v2 = 1;
		pList[0].v3 = 2;

		// left
		pList[1].v1 = 0;
		pList[1].v2 = 3;
		pList[1].v3 = 1;

		// right
		pList[2].v1 = 0;
		pList[2].v2 = 2;
		pList[2].v3 = 4;

		// back
		pList[3].v1 = 0;
		pList[3].v2 = 4;
		pList[3].v3 = 3;

		// bottom 1
		pList[4].v1 = 2;
		pList[4].v2 = 1;
		pList[4].v3 = 3;

		// bottom 2
		pList[5].v1 = 4;
		pList[5].v2 = 2;
		pList[5].v3 = 3;

		//Write the data to a file ---------------------

		FileHandle fh;
		FileError ferror;

		//-----------WRITE--------------------------------

		ferror = File::open(fh, "pyramid.vbo", FILE_WRITE);
		assert(ferror == FILE_SUCCESS);

		//Write the data
		ferror = File::write(fh, &pVerts, 5 * sizeof(pyramidVertexStride));
		assert(ferror == FILE_SUCCESS);

		ferror = File::write(fh, &pList, 6 * sizeof(triangleList));
		assert(ferror == FILE_SUCCESS);

		ferror = File::close(fh);
		assert(ferror == FILE_SUCCESS);

	#endif

	if (test)
	{
		for( int i = 0; i<5; i++)
		{
			Matrix Trans(TRANS, 0.0f, 1.0f, 0.0f);
			//Matrix Scale(SCALE, 1.0f, 0.5f, 1.0f);
			Matrix Scale(SCALE, 0.3f, 0.1f, 0.3f);
			Matrix Rot( ROT_X, 90.0f * MATH_PI_180);

			Matrix M = Trans * Scale * Rot;
     

			Matrix Scale2( SCALE, 13.0f, 13.0f, 109.43f);

			Matrix Rot2; 
			Rot2.set(ROT_ORIENT, Vect(1.0f,0.0f,0.0f), Vect( 0.0f, 1.0f, 0.0f) );

			M =  M * Scale2 * Rot2;
      
			//M =  M * Scale2 ;

			Vect vert( pVerts[i].x, pVerts[i].y, pVerts[i].z);
			Vect vertNorm( pVerts[i].nx, pVerts[i].ny, pVerts[i].nz);

			Vect vout;
			Vect voutNorm;

			vout = vert * M;
			voutNorm = vertNorm * M;

			pVerts[i].x  = vout[x] ;
			pVerts[i].y  = vout[y] ;
			pVerts[i].z  = vout[z] ;
			pVerts[i].nx = voutNorm[x];
			pVerts[i].ny = voutNorm[y];
			pVerts[i].nz = voutNorm[z];

			printf(" vert[%d]  %f  %f  %f\n",i, vout[x], vout[y], vout[z]);

		}
	}

	/* Allocate and assign a Vertex Array Object to our handle */
    glGenVertexArrays(1, &this->vao);
 
    /* Bind our Vertex Array Object as the current used object */
    glBindVertexArray(this->vao);

	//Create two buffers
	GLuint vbo[2];

    /* Allocate and assign two Vertex Buffer Objects to our handle */
    glGenBuffers(2, vbo);

	// Load the combined data: ---------------------------------------------------------

	/* Bind our first VBO as being the active buffer and storing vertex attributes (coordinates) */
	glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
 
	/* Copy the vertex data to our buffer */
    // glBufferData(type, size in bytes, data, usage) 
	glBufferData(GL_ARRAY_BUFFER, sizeof(pyramidVertexStride) * 5, &pVerts, GL_STATIC_DRAW);

	// VERTEX data: ---------------------------------------------------------
		
	// Set Attribute to 0
    // WHY - 0? and not 1,2,3 (this is tied to the shader attribute, it is defined in GLShaderManager.h)
    // GLT_ATTRIBUTE_VERTEX = 0

    // Specifies the index of the generic vertex attribute to be enabled
	glEnableVertexAttribArray(0);  

	//Compute offset
	void *offsetVert = (void *)((unsigned int)&pVerts[0].x - (unsigned int)&pVerts);

	/* Specify that our coordinate data is going into attribute index 0, and contains 3 floats per vertex */
    // ( GLuint index,  GLint size,  GLenum type,  GLboolean normalized,  GLsizei stride,  const GLvoid * pointer);
	glVertexAttribPointer(0, 3, GL_FLOAT,  GL_FALSE, sizeof(pyramidVertexStride), offsetVert);

	// Texture data: ---------------------------------------------------------
		
	// Set Attribute to 3
    // WHY - 3? and not 1,2,3 (this is tied to the shader attribute, it is defined in GLShaderManager.h)
    // GLT_ATTRIBUTE_TEXTURE0 = 3

    // Specifies the index of the generic vertex attribute to be enabled
	glEnableVertexAttribArray(3);  

	//Compute offset
	void *offsetTex = (void *)((unsigned int)&pVerts[0].s - (unsigned int)&pVerts);

	/* Specify that our coordinate data is going into attribute index 3, and contains 2 floats per vertex */
    // ( GLuint index,  GLint size,  GLenum type,  GLboolean normalized,  GLsizei stride,  const GLvoid * pointer);
	glVertexAttribPointer(3, 2, GL_FLOAT,  GL_FALSE, sizeof(pyramidVertexStride), offsetTex);

	// Normal data: ---------------------------------------------------------
		
	// Set Attribute to 2
    // WHY - 2? and not 1,2,3 (this is tied to the shader attribute, it is defined in GLShaderManager.h)
    // GLT_ATTRIBUTE_NORMAL = 2

    // Specifies the index of the generic vertex attribute to be enabled
	glEnableVertexAttribArray(2);  

	//Compute offset
	void *offsetNorm = (void *)((unsigned int)&pVerts[0].nx - (unsigned int)&pVerts);

	/* Specify that our coordinate data is going into attribute index 3, and contains 2 floats per vertex */
    // ( GLuint index,  GLint size,  GLenum type,  GLboolean normalized,  GLsizei stride,  const GLvoid * pointer);
	glVertexAttribPointer(2, 3, GL_FLOAT,  GL_FALSE, sizeof(pyramidVertexStride), offsetNorm);

	// Load the index data: ---------------------------------------------------------
	
    /* Bind our 2nd VBO as being the active buffer and storing index ) */
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[1]);

	/* Copy the index data to our buffer */
    // glBufferData(type, size in bytes, data, usage) 
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(triangleList)*6, pList, GL_STATIC_DRAW);

}
Exemplo n.º 29
0
	void core_numbers(const Graph& g, KCoreMap kcm, PositionMap pos)
	{
		typedef typename graph_traits<Graph>::vertex_descriptor vertex;
		typedef typename graph_traits<Graph>::degree_size_type size_type;

		BGL_FORALL_VERTICES_T(v,g,Graph)
		{
			kcm[v] = 0;
		}

		// compute the degree of all vertices
		BGL_FORALL_EDGES_T(e,g,Graph)
		{
			++kcm[source(e,g)];
		}

		size_type max_deg = 0;

		// compute the maximum degree
		BGL_FORALL_VERTICES_T(v,g,Graph)
		{
			if (kcm[v] > max_deg)
			{
				max_deg = kcm[v];
			}
		}

		// now we sort vertices into bins by their degree 
		// (we buffer this vector by 2 extra spots to make
		// some of the computations easier.
		//   1.  because deg > 0, we need max_deg+1 to index w/ deg itself
		//   2.  because we want to make things really easy, we extend
		//       the array one past degree to make computing partial_sums
		//       trivial
		std::vector<size_type> bin(max_deg+2);

		// compute the size of each bin
		BGL_FORALL_VERTICES_T(v,g,Graph)
		{
			++bin[kcm[v]];
		}

		// this loop sets bin[d] to the starting position of vertices
		// with degree d in the vert array
		size_type cur_pos = 0;
		for (size_type cur_deg = 0; cur_deg < max_deg+2; ++cur_deg)
		{
			size_type tmp = bin[cur_deg];
			bin[cur_deg] = cur_pos;
			cur_pos += tmp;
		}

		// place the vertices
		std::vector<vertex> vert(num_vertices(g));

		BGL_FORALL_VERTICES_T(v,g,Graph)
		{
			pos[v] = bin[kcm[v]];
			vert[pos[v]] = v;

			++bin[kcm[v]];
		}
Exemplo n.º 30
0
/*===========================================================================*/
void StochasticUniformGridRenderer::Engine::create_shader_program( const kvs::StructuredVolumeObject* volume )
{
    // Build bounding cube shader.
    {
        kvs::ShaderSource vert("RC_bounding_cube.vert");
        kvs::ShaderSource frag("RC_bounding_cube.frag");
        m_bounding_cube_shader.build( vert, frag );
    }

    // Build ray caster.
    {
        kvs::ShaderSource vert("SR_uniform_grid.vert");
        kvs::ShaderSource frag("SR_uniform_grid.frag");
        if ( isEnabledShading() )
        {
            switch ( shader().type() )
            {
            case kvs::Shader::LambertShading: frag.define("ENABLE_LAMBERT_SHADING"); break;
            case kvs::Shader::PhongShading: frag.define("ENABLE_PHONG_SHADING"); break;
            case kvs::Shader::BlinnPhongShading: frag.define("ENABLE_BLINN_PHONG_SHADING"); break;
            default: /* NO SHADING */ break;
            }
        }
        m_ray_casting_shader.build( vert, frag );
    }

    // Set uniform variables.
    const kvs::Vector3ui r = volume->resolution();
    const kvs::Real32 max_ngrids = static_cast<kvs::Real32>( kvs::Math::Max( r.x(), r.y(), r.z() ) );
    const kvs::Vector3f resolution( static_cast<float>(r.x()), static_cast<float>(r.y()), static_cast<float>(r.z()) );
    const kvs::Vector3f ratio( r.x() / max_ngrids, r.y() / max_ngrids, r.z() / max_ngrids );
    const kvs::Vector3f reciprocal( 1.0f / r.x(), 1.0f / r.y(), 1.0f / r.z() );
    kvs::Real32 min_range = 0.0f;
    kvs::Real32 max_range = 0.0f;
    kvs::Real32 min_value = m_transfer_function.colorMap().minValue();
    kvs::Real32 max_value = m_transfer_function.colorMap().maxValue();
    const std::type_info& type = volume->values().typeInfo()->type();
    if ( type == typeid( kvs::UInt8 ) )
    {
        min_range = 0.0f;
        max_range = 255.0f;
        if ( !m_transfer_function.hasRange() )
        {
            min_value = 0.0f;
            max_value = 255.0f;
        }
    }
    else if ( type == typeid( kvs::Int8 ) )
    {
        min_range = static_cast<kvs::Real32>( kvs::Value<kvs::UInt8>::Min() );
        max_range = static_cast<kvs::Real32>( kvs::Value<kvs::UInt8>::Max() );
        if ( !m_transfer_function.hasRange() )
        {
            min_value = -128.0f;
            max_value = 127.0f;
        }
    }
    else if ( type == typeid( kvs::UInt16 ) )
    {
        min_range = static_cast<kvs::Real32>( kvs::Value<kvs::UInt16>::Min() );
        max_range = static_cast<kvs::Real32>( kvs::Value<kvs::UInt16>::Max() );
        if ( !m_transfer_function.hasRange() )
        {
            min_value = static_cast<kvs::Real32>( volume->minValue() );
            max_value = static_cast<kvs::Real32>( volume->maxValue() );
        }
    }
    else if ( type == typeid( kvs::Int16 ) )
    {
        min_range = static_cast<kvs::Real32>( kvs::Value<kvs::Int16>::Min() );
        max_range = static_cast<kvs::Real32>( kvs::Value<kvs::Int16>::Max() );
        if ( !m_transfer_function.hasRange() )
        {
            min_value = static_cast<kvs::Real32>( volume->minValue() );
            max_value = static_cast<kvs::Real32>( volume->maxValue() );
        }
    }
    else if ( type == typeid( kvs::UInt32 ) || type == typeid( kvs::Int32  ) || type == typeid( kvs::Real32 ) )
    {
        min_range = 0.0f;
        max_range = 1.0f;
        min_value = 0.0f;
        max_value = 1.0f;
    }
    else
    {
        kvsMessageError( "Not supported data type '%s'.", volume->values().typeInfo()->typeName() );
    }

    m_ray_casting_shader.bind();
    m_ray_casting_shader.setUniform( "volume.resolution", resolution );
    m_ray_casting_shader.setUniform( "volume.resolution_ratio", ratio );
    m_ray_casting_shader.setUniform( "volume.resolution_reciprocal", reciprocal );
    m_ray_casting_shader.setUniform( "volume.min_range", min_range );
    m_ray_casting_shader.setUniform( "volume.max_range", max_range );
    m_ray_casting_shader.setUniform( "transfer_function.min_value", min_value );
    m_ray_casting_shader.setUniform( "transfer_function.max_value", max_value );
    m_ray_casting_shader.setUniform( "dt", m_step );
    m_ray_casting_shader.setUniform( "shading.Ka", shader().Ka );
    m_ray_casting_shader.setUniform( "shading.Kd", shader().Kd );
    m_ray_casting_shader.setUniform( "shading.Ks", shader().Ks );
    m_ray_casting_shader.setUniform( "shading.S",  shader().S );
    m_ray_casting_shader.unbind();
}