void MaterialDataManager::loadMaterialData( const char* fName ,int& ret)
{
std::ifstream Input(fName);
if(!Input.is_open())
{
ret = ObjUtility::ReturnType::MTL_FAIL;
return;
}
char key[100];
char name[100];
MaterialData* mData = NULL;
while (Input >> key)
{
if(ISEQUAL(key,"#"))
Input.ignore(1024,'\n');//ºöÂÔÒ»ÐÐ
else if(ISEQUAL(key,"newmtl"))
{
if(mData != NULL)
m_map.insert(std::map<std::string,MaterialData*>::value_type(name,mData));
Input >> name;
mData = new MaterialData;
}
else if(ISEQUAL(key,"Ka"))
{
Input >> mData->ka[0] >> mData->ka[1] >> mData->ka[2];
}
////////////////////////////////////////////////////////////////////////////
// Generates a new value based on the animation mode
// Will also adjust the current value if needed
//
void CFloatAnimator::GetNewValue(f32& fromValue, f32& toValue, f32 min, f32 max, EAMode mode)
{
switch (mode)
{
case AM_NONE: toValue = fromValue; break;
case AM_RAND: toValue = min + (RandFloat()*(max-min)); break;
case AM_LOOPUP:
if (ISEQUAL(fromValue, max, 0.01f))
fromValue = min;
toValue = max;
break;
case AM_LOOPDOWN:
if (ISEQUAL(fromValue, min, 0.01f))
fromValue = max;
toValue = min;
break;
case AM_PINGPONG:
if (ISEQUAL(fromValue, min, 0.01f))
{
toValue = max;
}
else
{
toValue = min;
}
break;
default:
break;
}
}
/**IsEqualShortIntegerArray
* compare if two short int (1,2 or 4 bytes) arrays of size n, are identical
* @param int type: int type 1, 2, 4 or 11, 12, 14 for unsigned int
* @param int n: array size
* @param int *d1: pointer on the beginning of the first array
* @param int *d2: pointer on the beginning of the second array
* @return 0 is the arrays differ and 1 if they are identical
* @author Serge Steer
*/
int IsEqualShortIntegerArray(int typ, int n, int *d1, int *d2)
{
int i;
/*DEBUG_BASE("comparison of %d int %d bytes\n",n,typ);*/
if (n == 0) return 1;
switch (typ) {
case 0:
ISEQUAL(double);
break;
case 1:
ISEQUAL(integer1);
break;
case 2:
ISEQUAL(integer2);
break;
case 4:
ISEQUAL(int) ;
break;
case 11:
ISEQUAL(unsigned char);
break;
case 12:
ISEQUAL(unsigned short);
break;
case 14:
ISEQUAL(unsigned int);
break;
}
return 1;
}
ObjEntity* ObjUtility::createObjEntity(const char* filename , int& ret)
{
#ifdef MY_DEBUG
ofstream output("debug.txt",ios::app);
#endif // MY_DEBUG
ret = ReturnType::SUCCESS;
vector<Vertex*> *m_vertexList = new vector<Vertex*>;
vector<NormalVector*> *m_normalVectorList = new vector<NormalVector*>;
vector<TextureCoordinate*> *m_textureCoordinateList = new vector<TextureCoordinate*>;
vector<Face*> *m_faceList = new vector<Face*>;
MaterialDataManager* materialDataManager = NULL;
ifstream Input(filename);
if(!Input.is_open())
{
ret = ReturnType::OBJ_FAIL;
return NULL;
}
char key[80];
int i = 0;
while(Input >> key)
{
i ++;
if(ISEQUAL(key,"#"))
Input.ignore(1024,'\n');//ºöÂÔÒ»ÐÐ
else if(ISEQUAL(key, "mtllib"))
{
materialDataManager = new MaterialDataManager;
char name[100];
Input>>name;
char filePath[100];
sprintf_s(filePath,"%s",name);
materialDataManager->loadMaterialData(filePath,ret);
if(ret == ReturnType::MTL_FAIL||ret == ReturnType::TEXTURE_FAIL)
return NULL;
}
else if(ISEQUAL(key,"usemtl"))
int GMRFLib_which(double val, double *array, int len)
{
/*
* return the first index in array such that array[idx] == val, and -1 if not there
*/
int i;
for (i = 0; i < len; i++) {
if (ISEQUAL(val, array[i])) {
return i;
}
}
return -1;
}
ICEILTEMPDECL
#endif
/*
* Written by Todd Newman; April. 1987.
*
* Fill a convex polygon. If the given polygon
* is not convex, then the result is undefined.
* The algorithm is to order the edges from smallest
* y to largest by partitioning the array into a left
* edge list and a right edge list. The algorithm used
* to traverse each edge is digital differencing analyzer
* line algorithm with y as the major axis. There's some funny linear
* interpolation involved because of the subpixel postioning.
*
* count: number of points
* ptsIn: the points
* xTrans, yTrans: Translate each point by this
* xFtrans, yFtrans: translate before conversion
* by this amount. This provides
* a mechanism to match rounding
* errors with any shape that must
* meet the polygon exactly.
*/
void miFillSppPoly (PDC pdc, int count, SppPointPtr ptsIn, int xTrans, int yTrans, double xFtrans, double yFtrans)
{
double xl = 0, xr = 0, /* x vals of left and right edges */
ml = 0, /* left edge slope */
mr = 0, /* right edge slope */
dy, /* delta y */
i; /* loop counter */
int y, /* current scanline */
j,
imin, /* index of vertex with smallest y */
ymin, /* y-extents of polygon */
ymax,
*Marked; /* set if this vertex has been used */
register int left, right, /* indices to first endpoints */
nextleft,
nextright; /* indices to second endpoints */
Span *ptsOut, *FirstPoint; /* output buffer */
imin = GetFPolyYBounds(ptsIn, count, yFtrans, &ymin, &ymax);
y = ymax - ymin + 1;
if ((count < 3) || (y <= 0))
return;
ptsOut = FirstPoint = (Span*)ALLOCATE_LOCAL(sizeof(Span) * y);
Marked = (int *) ALLOCATE_LOCAL(sizeof(int) * count);
if(!ptsOut || !Marked)
{
if (Marked) DEALLOCATE_LOCAL(Marked);
if (ptsOut) DEALLOCATE_LOCAL(ptsOut);
return;
}
for(j = 0; j < count; j++)
Marked[j] = 0;
nextleft = nextright = imin;
Marked[imin] = -1;
y = ICEIL(ptsIn[nextleft].y + yFtrans);
/*
* loop through all edges of the polygon
*/
do
{
/* add a left edge if we need to */
if ((y > (ptsIn[nextleft].y + yFtrans) ||
ISEQUAL(y, ptsIn[nextleft].y + yFtrans)) &&
Marked[nextleft] != 1)
{
Marked[nextleft]++;
left = nextleft++;
/* find the next edge, considering the end conditions */
if (nextleft >= count)
nextleft = 0;
/* now compute the starting point and slope */
dy = ptsIn[nextleft].y - ptsIn[left].y;
if (dy != 0.0)
{
ml = (ptsIn[nextleft].x - ptsIn[left].x) / dy;
dy = y - (ptsIn[left].y + yFtrans);
xl = (ptsIn[left].x + xFtrans) + ml * MAX(dy, 0);
}
}
/* add a right edge if we need to */
if ((y > ptsIn[nextright].y + yFtrans) ||
(ISEQUAL(y, ptsIn[nextright].y + yFtrans)
&& Marked[nextright] != 1))
{
Marked[nextright]++;
right = nextright--;
/* find the next edge, considering the end conditions */
if (nextright < 0)
nextright = count - 1;
/* now compute the starting point and slope */
dy = ptsIn[nextright].y - ptsIn[right].y;
if (dy != 0.0)
{
mr = (ptsIn[nextright].x - ptsIn[right].x) / dy;
dy = y - (ptsIn[right].y + yFtrans);
xr = (ptsIn[right].x + xFtrans) + mr * MAX(dy, 0);
}
}
/*
* generate scans to fill while we still have
* a right edge as well as a left edge.
*/
i = (MIN(ptsIn[nextleft].y, ptsIn[nextright].y) + yFtrans) - y;
if (i < EPSILON)
{
if(Marked[nextleft] && Marked[nextright])
{
/* Arrgh, we're trapped! (no more points)
* Out, we've got to get out of here before this decadence saps
* our will completely! */
break;
}
continue;
}
else
{
j = (int) i;
if(!j)
j++;
}
while (j > 0)
{
int cxl, cxr;
ptsOut->y = (y) + yTrans;
cxl = ICEIL(xl);
cxr = ICEIL(xr);
/* reverse the edges if necessary */
if (xl < xr)
{
ptsOut->width = cxr - cxl;
(ptsOut++)->x = cxl + xTrans;
}
else
{
ptsOut->width = cxl - cxr;
(ptsOut++)->x = cxr + xTrans;
}
y++;
/* increment down the edges */
xl += ml;
xr += mr;
j--;
}
} while (y <= ymax);
/* Finally, fill the spans we've collected */
_dc_fill_spans (pdc, FirstPoint, ptsOut-FirstPoint, FALSE);
DEALLOCATE_LOCAL(Marked);
DEALLOCATE_LOCAL(FirstPoint);
}
/*
* Written by Todd Newman; April. 1987.
*
* Fill a convex polygon. If the given polygon
* is not convex, then the result is undefined.
* The algorithm is to order the edges from smallest
* y to largest by partitioning the array into a left
* edge list and a right edge list. The algorithm used
* to traverse each edge is digital differencing analyzer
* line algorithm with y as the major axis. There's some funny linear
* interpolation involved because of the subpixel postioning.
*/
void
miFillSppPoly(DrawablePtr dst, GCPtr pgc, int count, /* number of points */
SppPointPtr ptsIn, /* the points */
int xTrans, int yTrans, /* Translate each point by this */
double xFtrans, double yFtrans /* translate before conversion
by this amount. This provides
a mechanism to match rounding
errors with any shape that must
meet the polygon exactly.
*/
)
{
double xl = 0.0, xr = 0.0, /* x vals of left and right edges */
ml = 0.0, /* left edge slope */
mr = 0.0, /* right edge slope */
dy, /* delta y */
i; /* loop counter */
int y, /* current scanline */
j, imin, /* index of vertex with smallest y */
ymin, /* y-extents of polygon */
ymax, *width, *FirstWidth, /* output buffer */
*Marked; /* set if this vertex has been used */
int left, right, /* indices to first endpoints */
nextleft, nextright; /* indices to second endpoints */
DDXPointPtr ptsOut, FirstPoint; /* output buffer */
if (pgc->miTranslate) {
xTrans += dst->x;
yTrans += dst->y;
}
imin = GetFPolyYBounds(ptsIn, count, yFtrans, &ymin, &ymax);
y = ymax - ymin + 1;
if ((count < 3) || (y <= 0))
return;
ptsOut = FirstPoint = malloc(sizeof(DDXPointRec) * y);
width = FirstWidth = malloc(sizeof(int) * y);
Marked = malloc(sizeof(int) * count);
if (!ptsOut || !width || !Marked) {
free(Marked);
free(width);
free(ptsOut);
return;
}
for (j = 0; j < count; j++)
Marked[j] = 0;
nextleft = nextright = imin;
Marked[imin] = -1;
y = ICEIL(ptsIn[nextleft].y + yFtrans);
/*
* loop through all edges of the polygon
*/
do {
/* add a left edge if we need to */
if ((y > (ptsIn[nextleft].y + yFtrans) ||
ISEQUAL(y, ptsIn[nextleft].y + yFtrans)) &&
Marked[nextleft] != 1) {
Marked[nextleft]++;
left = nextleft++;
/* find the next edge, considering the end conditions */
if (nextleft >= count)
nextleft = 0;
/* now compute the starting point and slope */
dy = ptsIn[nextleft].y - ptsIn[left].y;
if (dy != 0.0) {
ml = (ptsIn[nextleft].x - ptsIn[left].x) / dy;
dy = y - (ptsIn[left].y + yFtrans);
xl = (ptsIn[left].x + xFtrans) + ml * max(dy, 0);
}
}
/* add a right edge if we need to */
if ((y > ptsIn[nextright].y + yFtrans) ||
(ISEQUAL(y, ptsIn[nextright].y + yFtrans)
&& Marked[nextright] != 1)) {
Marked[nextright]++;
right = nextright--;
/* find the next edge, considering the end conditions */
if (nextright < 0)
nextright = count - 1;
/* now compute the starting point and slope */
dy = ptsIn[nextright].y - ptsIn[right].y;
if (dy != 0.0) {
mr = (ptsIn[nextright].x - ptsIn[right].x) / dy;
dy = y - (ptsIn[right].y + yFtrans);
xr = (ptsIn[right].x + xFtrans) + mr * max(dy, 0);
}
}
/*
* generate scans to fill while we still have
* a right edge as well as a left edge.
*/
i = (min(ptsIn[nextleft].y, ptsIn[nextright].y) + yFtrans) - y;
if (i < EPSILON) {
if (Marked[nextleft] && Marked[nextright]) {
/* Arrgh, we're trapped! (no more points)
* Out, we've got to get out of here before this decadence saps
* our will completely! */
break;
}
continue;
}
else {
j = (int) i;
if (!j)
j++;
}
while (j > 0) {
int cxl, cxr;
ptsOut->y = (y) + yTrans;
cxl = ICEIL(xl);
cxr = ICEIL(xr);
/* reverse the edges if necessary */
if (xl < xr) {
*(width++) = cxr - cxl;
(ptsOut++)->x = cxl + xTrans;
}
else {
*(width++) = cxl - cxr;
(ptsOut++)->x = cxr + xTrans;
}
y++;
/* increment down the edges */
xl += ml;
xr += mr;
j--;
}
} while (y <= ymax);
/* Finally, fill the spans we've collected */
(*pgc->ops->FillSpans) (dst, pgc,
ptsOut - FirstPoint, FirstPoint, FirstWidth, 1);
free(Marked);
free(FirstWidth);
free(FirstPoint);
}
