static ParsedData parse(Allocator* alloc, unsigned char* data, unsigned data_size)
{
ParserState ps = {};
ps.data = data;
ps.head = data;
ps.end = (unsigned char*)mem_ptr_add(data, data_size);
ParsedData pd = {};
pd.vertices = dynamic_array_create<Vector3>(alloc);
pd.normals = dynamic_array_create<Vector3>(alloc);
pd.uvs = dynamic_array_create<Vector2>(alloc);
pd.faces = dynamic_array_create<ParsedFace>(alloc);
ps.head = ps.data;
while (ps.head < ps.end)
{
unsigned char c = *ps.head;
bool first_on_line = ps.head == ps.data || (ps.head > ps.data && (*(ps.head - 1)) == '\n');
if (!first_on_line)
skip_line(&ps);
else if (c == 'v' && ps.head + 1 < ps.end && (*(ps.head+1)) == 't')
parse_uv(&ps, &pd);
else if (c == 'v' && ps.head + 1 < ps.end && (*(ps.head+1)) == 'n')
parse_normal(&ps, &pd);
else if (c == 'v')
parse_vertex(&ps, &pd);
else if (c == 'f')
parse_face(&ps, &pd);
else
skip_line(&ps);
}
return pd;
}
static ats_err_t
parse_line(const char *line, struct ats_wft *wft)
{
switch (line[0]) {
case 'v':
return parse_vertex(line, wft);
case 'f':
return parse_face(line, wft);
default:
/* Skip this line. */
return ATS_NO_ERROR;
}
}
int cubepos::parse_move(const char*&p){
skip_whitespace(p);
const char*q= p;
int f= parse_face(q);
if(f<0)
return-1;
int t= 0;
switch(*q){
case'1':case'+':t= 0;break;
case'2':t= 1;break;
case'3':case'\'':case'-':t= TWISTS-1;break;
default:
return-1;
}
p= q+1;
return f*TWISTS+t;
}
int wavefront_parse(wavefront_obj_t *obj, char *data) {
char *line, *save;
assert(obj != NULL && data != NULL);
line = strtok_r(data, "\n", &save);
do {
if (line[1] == ' ') {
switch (line[0]) {
case 'v':
wavefront_add_vertex(obj, parse_vertex(line+2));
break;
case 'f':
wavefront_add_face(obj, parse_face(line+2));
break;
default:
break;
}
}
} while((line = strtok_r(NULL, "\n", &save)));
#ifdef OPTIMIZE
obj->vertices = realloc(obj->vertices, obj->_nvertex * sizeof(vertex_t));
obj->_vsize = obj->_nvertex;
obj->faces = realloc(obj->faces, obj->_nface * sizeof(face_t));
obj->_fsize = obj->_nface;
#ifdef DEBUG_MEM
puts("*** OPTIMIZED ***");
#endif // DEBUG_MEM
#endif // OPTIMIZE
#ifdef DEBUG_MEM
puts("*** Wavefront stats ***");
printf("V: %d (cap %d)\n", obj->_nvertex, obj->_vsize);
printf("F: %d (cap %d)\n", obj->_nface, obj->_fsize);
#endif // DEBUG_MEM
return 0;
}
int cubepos::parse_face(const char*&p){
int f= parse_face(*p);
if(f>=0)
p++;
return f;
}
void cubepos::init(){
static int initialized= 0;
if(initialized)
return;
initialized= 1;
/*14:*/
#line 287 "../cubepos.w"
for(int i= 0;i<CUBIES;i++){
int perm= corner_perm(i);
int ori= corner_ori(i);
corner_ori_inc[i]= corner_val(perm,(ori+1)%3);
corner_ori_dec[i]= corner_val(perm,(ori+2)%3);
corner_ori_neg_strip[i]= corner_val(0,(3-ori)%3);
mod24[i]= mod24[i+CUBIES]= i;
}
/*:14*//*28:*/
#line 563 "../cubepos.w"
for(int m= 0;m<NMOVES;m++)
for(int c= 0;c<CUBIES;c++){
edge_trans[m][c]= c;
corner_trans[m][c]= c;
}
/*:28*//*29:*/
#line 578 "../cubepos.w"
for(int f= 0;f<FACES;f++)
for(int t= 0;t<3;t++){
int m= f*TWISTS+t;
int isquarter= (t==0||t==2);
int perminc= t+1;
if(m<0)
continue;
for(int i= 0;i<4;i++){
int ii= (i+perminc)%4;
for(int o= 0;o<2;o++){
int oo= o;
if(isquarter)
oo^= edge_change[f];
edge_trans[m][edge_val(edge_twist_perm[f][i],o)]=
edge_val(edge_twist_perm[f][ii],oo);
}
for(int o= 0;o<3;o++){
int oo= o;
if(isquarter)
oo= (corner_change[f][i]+oo)%3;
corner_trans[m][corner_val(corner_twist_perm[f][i],o)]=
corner_val(corner_twist_perm[f][ii],oo);
}
}
}
/*:29*//*34:*/
#line 649 "../cubepos.w"
for(int i= 0;i<NMOVES;i++)
inv_move[i]= TWISTS*(i/TWISTS)+(NMOVES-i-1)%TWISTS;
/*:34*//*51:*/
#line 1040 "../cubepos.w"
memset(lookup_edge_cubie,INVALID,sizeof(lookup_edge_cubie));
memset(lookup_corner_cubie,INVALID,sizeof(lookup_corner_cubie));
for(int i= 0;i<CUBIES;i++){
const char*tmp= 0;
lookup_corner_cubie[parse_cubie(tmp= smcorners[i])-6*6*6]= i;
lookup_corner_cubie[parse_cubie(tmp= smcorners[CUBIES+i])-6*6*6]= CUBIES+i;
lookup_edge_cubie[parse_cubie(tmp= smedges[i])-6*6]= i;
}
const char*p= sing_solved;
for(int i= 0;i<12;i++){
int cv= parse_edge(p);
sm_edge_order[i]= edge_perm(cv);
sm_edge_flipped[i]= edge_ori(cv);
}
for(int i= 0;i<8;i++)
sm_corner_order[i]= corner_perm(parse_corner(p));
/*:51*//*60:*/
#line 1238 "../cubepos.w"
unsigned char face_to_m[FACES*FACES*FACES];
for(int i= 0;i<6;i++)
parse_corner_to_facemap(axis_permute_map[i],face_map[8*i]);
for(int i= 0;i<8;i++)
parse_corner_to_facemap(axis_negate_map[i],face_map[i]);
for(int i= 1;i<6;i++)
for(int j= 1;j<8;j++)
face_map_multiply(face_map[8*i],face_map[j],face_map[8*i+j]);
/*:60*//*61:*/
#line 1251 "../cubepos.w"
for(int i= 0;i<M;i++){
int v= face_map[i][0]*36+face_map[i][1]*6+face_map[i][2];
face_to_m[v]= i;
}
unsigned char tfaces[6];
for(int i= 0;i<M;i++)
for(int j= 0;j<M;j++){
face_map_multiply(face_map[i],face_map[j],tfaces);
int v= tfaces[0]*36+tfaces[1]*6+tfaces[2];
mm[i][j]= face_to_m[v];
if(mm[i][j]==0)
invm[i]= j;
}
for(int m= 0;m<M;m++){
int is_neg= (m^(m>>3))&1;
for(int f= 0;f<6;f++){
for(int t= 0;t<TWISTS;t++){
if(is_neg)
move_map[m][f*TWISTS+t]= face_map[m][f]*TWISTS+TWISTS-1-t;
else
move_map[m][f*TWISTS+t]= face_map[m][f]*TWISTS+t;
}
}
}
/*:61*//*62:*/
#line 1281 "../cubepos.w"
for(int m= 0;m<M;m++)
for(int c= 0;c<CUBIES;c++){
int v= 0;
for(int i= 0;i<2;i++)
v= 6*v+face_map[m][parse_face(smedges[c][i])];
rot_edge[m][c]= lookup_edge_cubie[v];
v= 0;
for(int i= 0;i<3;i++)
v= 6*v+face_map[m][parse_face(smcorners[c][i])];
rot_corner[m][c]= mod24[lookup_corner_cubie[v]];
}
/*:62*//*73:*/
#line 1467 "../cubepos.w"
for(int s= 0;s<CANONSEQSTATES;s++){
int prevface= (s-1)%FACES;
canon_seq_mask[s]= (1<<NMOVES)-1;
for(int mv= 0;mv<NMOVES;mv++){
int f= mv/TWISTS;
int isplus= 0;
if(s!=0&&(prevface==f||prevface==f+3))
{
canon_seq[s][mv]= INVALID;
canon_seq_mask[s]&= ~(1<<mv);
}else{
canon_seq[s][mv]= f+1+FACES*isplus;
}
}
canon_seq_mask_ext[s]= canon_seq_mask[s];
}
/*:73*/
#line 262 "../cubepos.w"
}
void Mesh :: load_mesh(char* the_mesh)
{
FILE* fp;
char buffer[300];
int status = 0;
int v = 0;
int f = 0;
int* vert_faces;
fp = fopen(the_mesh, "r+");
if(fp == NULL)
{
cout << "Error reading file: " << the_mesh << endl;
return;
}
while(!feof(fp))
{
fgets(buffer, 300, fp);
switch(buffer[0])
{
case '#':
break;
case 'v':
status++;
break;
case 'f':
status++;
break;
default:
if(status == 0)
{
parse_count(buffer, vert_faces);
vert_faces = new int[verts_size];
for( int i = 0; i < verts_size; i++ )
{
v_norms[i] = new GLfloat[4];
v_norms[i][0] = 0.0;
v_norms[i][1] = 0.0;
v_norms[i][2] = 0.0;
v_norms[i][3] = 1.0;
vert_faces[i] = 0;
}
}
else if(status == 1)
{
parse_vert(buffer, v);
v++;
}
else if(status == 2)
{
parse_face(buffer, f, vert_faces);
f++;
}
break;
for( int i = 0; i < verts_size; i++ )
{
v_norms[i][0] = v_norms[i][0] / vert_faces[i];
v_norms[i][1] = v_norms[i][1] / vert_faces[i];
v_norms[i][2] = v_norms[i][2] / vert_faces[i];
v_norms[i][3] = 1.0;
normalize(v_norms[i]);
}
}
}
}
