We mentioned particularly about the camera setting. If you start a basic OpenGL project from scratch, normally tuning the camera needs some effort. For examples, we show the boudings of model bunny.gts and cube.gts as the following.

bunny.gts:
xmin,xmax: -0.0946899,0.0610091 ymin,ymax: 0.0,0.187321 zmin,zmax: -0.0618736,0.0587997

cube.gts:
xmin,xmax: -1.63299,1.63299 ymin,ymax: -1.63299,1.63299 zmin,zmax: -1.1547,1.1547

If you can compare the boundings of these two models, the size of bunny is so small. In reality, many confused for such model failed to be rendered than scale the model or change settings of the camera. We will explain our approach.

First, we know for the given camera setting, model.OBJ_SIZE =10.0f, is a good size for the model being rendered. So far we only discuss the scenario to render only one model without any translation (displacement to where other than the origin). We use the following code to compute the scale to use, we can either scale up, or scale down.

public void calculateScale() { scale1 = OBJ_SIZE/(xmax - xmin); scale2 = OBJ_SIZE/(ymax - ymin); scale3 = OBJ_SIZE/(zmax - zmin); scale = ( ((OBJ_SIZE/(xmax - xmin)<OBJ_SIZE/(ymax - ymin)) ?OBJ_SIZE/(xmax - xmin):OBJ_SIZE/(ymax - ymin))<OBJ_SIZE/(zmax - zmin) ) ? ((OBJ_SIZE/(xmax - xmin)<OBJ_SIZE/(ymax - ymin)) ?OBJ_SIZE/(xmax - xmin):OBJ_SIZE/(ymax - ymin)):OBJ_SIZE/(zmax - zmin); }

Here we use division operation without any guard by assuming we can trust the model creator that their data will not cause exception by dividing zero. For mission critical system, or you just don't want the program crash without any clue, such assumption should not be made for granted. The scale computed is to make the largest length dimension to fit to OBJ_SIZE. Other dimensions scale together with this scale but may not fit to OBJ_SIZE.

After the scale is computed, we can use the following function to scale the model.

public void offSet() { float tmpxmin = xmin,tmpymin = ymin,tmpzmin = zmin; float tmpxmax = xmax,tmpymax = ymax,tmpzmax = zmax; tmpxmin *= scale; tmpymin *= scale; tmpzmin *= scale; tmpxmax *= scale; tmpymax *= scale; tmpzmax *= scale; //printf("\nscale:%f\n",scale); float offsetx = (tmpxmin + tmpxmax)/2.0f; float offsety = (tmpymin + tmpymax)/2.0f; float offsetz = (tmpzmin + tmpzmax)/2.0f; xmin = tmpxmin - offsetx; xmax = tmpxmax - offsetx; ymin = tmpymin - offsety; ymax = tmpymax - offsety; zmin = tmpzmin - offsetz; zmax = tmpzmax - offsetz; edgemin *= scale; edgemax *= scale; int i = 0; //vertices[iv1-1]->p. try { for ( i = 0; i<verticesCount;i++) { vertices[i].p.x *= scale; vertices[i].p.x -= offsetx; vertices[i].p.y *= scale; vertices[i].p.y -= offsety; vertices[i].p.z *= scale; vertices[i].p.z -= offsetz; } } catch (Exception e) { System.out.println("i = "+i); } }

It is not a simple scale call, we also repostion the model to the origin (0f,0f,0f).

float offsetx = (tmpxmin + tmpxmax)/2.0f; float offsety = (tmpymin + tmpymax)/2.0f; float offsetz = (tmpzmin + tmpzmax)/2.0f; xmin = tmpxmin - offsetx; xmax = tmpxmax - offsetx; ymin = tmpymin - offsety; ymax = tmpymax - offsety; zmin = tmpzmin - offsetz; zmax = tmpzmax - offsetz;
For model bunny, we have (ymin,ymax: 0.0,0.187321), if we don't reposition, the scaling will be incorrect. The following picture is proper scaling while setting the OBJ_SIZE be 1.5f.

If we change the offset function as the following:
public void offSetWithoutRepositioning() { // float tmpxmin = xmin,tmpymin = ymin,tmpzmin = zmin; // float tmpxmax = xmax,tmpymax = ymax,tmpzmax = zmax; // // tmpxmin *= scale; tmpymin *= scale; tmpzmin *= scale; // tmpxmax *= scale; tmpymax *= scale; tmpzmax *= scale; // //printf("\nscale:%f\n",scale); //// float offsetx = (tmpxmin + tmpxmax)/2.0f; //// float offsety = (tmpymin + tmpymax)/2.0f; //// float offsetz = (tmpzmin + tmpzmax)/2.0f; float offsetx = 0f; float offsety = 0f; float offsetz = 0f; // xmin = tmpxmin - offsetx; // xmax = tmpxmax - offsetx; // ymin = tmpymin - offsety; // ymax = tmpymax - offsety; // zmin = tmpzmin - offsetz; // zmax = tmpzmax - offsetz; // edgemin *= scale; // edgemax *= scale; int i = 0; //vertices[iv1-1]->p. try { for ( i = 0; i<verticesCount;i++) { vertices[i].p.x *= scale; //vertices[i].p.x -= offsetx; vertices[i].p.y *= scale; //vertices[i].p.y -= offsety; vertices[i].p.z *= scale; //vertices[i].p.z -= offsetz; } } catch (Exception e) { System.out.println("i = "+i); } }
The result will be the following: