INT valtoi(
LPTSTR pszValue)
{
return (pszValue[0] == CHAR_0 &&
(pszValue[1] == CHAR_CAP_X || pszValue[1] == CHAR_X)) ?
axtoi(&pszValue[2]) : awtoi(pszValue);
}
/*
** Virer les 40 axatoi
*/
void add_brkpoints(char* brkp)
{
if (!(*brkp >= '0' && *brkp <= '9'))
{
humanbrk[hlen++] = brkp;
humanbrk[hlen] = NULL;
return;
}
if (!brkpoints)
brkpoints = malloc(2 * sizeof(caddr_t*));
else
brkpoints = realloc(brkpoints, (len + 1) * sizeof(char*));
if (!brkpoints)
errexit("backtrace: malloc/realloc(), %s", strerror(errno));
brkpoints[len] = (caddr_t) axtoi(brkp);
printf("Add brkp: 0x%x\n", axtoi(brkp));
brkpoints[++len] = NULL;
}
/** Sets drawing flags for the CECHO command.
*/
static void COM_CEchoFlags_f(void)
{
if (COM_Argc() > 1)
{
const char *arg = COM_Argv(1);
if (arg[0] && arg[0] == '0' &&
arg[1] && arg[1] == 'x') // Use hexadecimal!
HU_SetCEchoFlags(axtoi(arg+2));
else
HU_SetCEchoFlags(atoi(arg));
}
else
CONS_Printf(M_GetText("cechoflags <flags>: set CEcho flags, prepend with 0x to use hexadecimal\n"));
}
VOID StrToNameOrd(
LPTSTR pszNameOrd,
BOOL fDecOnly)
{
register INT i;
INT nOrd;
INT nLen;
/*
* Empty string?
*/
if (!(*pszNameOrd))
return;
nLen = lstrlen(pszNameOrd);
/*
* Is a hex value ok and does this appear to be a hex value?
*/
if (!fDecOnly && pszNameOrd[0] == CHAR_0 &&
(pszNameOrd[1] == CHAR_X || pszNameOrd[1] == CHAR_CAP_X)) {
for (i = 2; i < nLen; i++) {
if (!iswxdigit(pszNameOrd[i]))
return;
}
nOrd = axtoi(&pszNameOrd[2]);
}
else {
/*
* All characters must be numeric. Negative numbers may
* or may not be allowed, based on the fDecOnly flag.
*/
for (i = 0; i < nLen; i++) {
if (!iswdigit(pszNameOrd[i]) &&
(fDecOnly || i != 0 || pszNameOrd[0] != CHAR_MINUS))
return;
}
nOrd = awtoi(pszNameOrd);
}
/*
* Return the ordinal in the original buffer.
*/
WriteOrd((PORDINAL)pszNameOrd, nOrd);
}
char *showUserLevel(char *inputStr)
{
int Index;
char formatInputStr[6];
char hexString[3];
if (strstr(inputStr, "0x") == NULL)
{
return("***Error***");
}
if (strlen(inputStr) < 6)
{
sprintf(formatInputStr, "0x0%s", inputStr+2);
}
else
{
sprintf(formatInputStr, "%s", inputStr);
}
strncpy(hexString, formatInputStr+2, strlen((formatInputStr) -3));
Index = axtoi(hexString);
return(UserPermissions[Index]);
#if 0
if (strcmp(inputStr, "0x01,") == 0)
{
return(UserPermissions[1]);
}
else if (strcmp(inputStr, "0x02,") == 0)
{
return("General RW-User");
}
else if (strcmp(inputStr, "0x100,") == 0)
{
return("OBER-User");
}
return("***Error***");
#endif
}
/**Creates/loads an animated mesh from the file.
\return Pointer to the created mesh. Returns 0 if loading failed.
If you no longer need the mesh, you should call IAnimatedMesh::drop().
See IReferenceCounted::drop() for more information.*/
IAnimatedMesh* CDMFLoader::createMesh(io::IReadFile* file)
{
if (!file)
return 0;
video::IVideoDriver* driver = SceneMgr->getVideoDriver();
//Load stringlist
StringList dmfRawFile;
LoadFromFile(file, dmfRawFile);
if (dmfRawFile.size()==0)
return 0;
SMesh * mesh = new SMesh();
u32 i;
dmfHeader header;
//load header
core::array<dmfMaterial> materiali;
if (GetDMFHeader(dmfRawFile, header))
{
//let's set ambient light
SceneMgr->setAmbientLight(header.dmfAmbient);
//let's create the correct number of materials, vertices and faces
dmfVert *verts=new dmfVert[header.numVertices];
dmfFace *faces=new dmfFace[header.numFaces];
//let's get the materials
#ifdef _IRR_DMF_DEBUG_
os::Printer::log("Loading materials", core::stringc(header.numMaterials).c_str());
#endif
GetDMFMaterials(dmfRawFile, materiali, header.numMaterials);
//let's get vertices and faces
#ifdef _IRR_DMF_DEBUG_
os::Printer::log("Loading geometry");
#endif
GetDMFVerticesFaces(dmfRawFile, verts, faces);
//create a meshbuffer for each material, then we'll remove empty ones
#ifdef _IRR_DMF_DEBUG_
os::Printer::log("Creating meshbuffers.");
#endif
for (i=0; i<header.numMaterials; i++)
{
//create a new SMeshBufferLightMap for each material
SSkinMeshBuffer* buffer = new SSkinMeshBuffer();
buffer->Material.MaterialType = video::EMT_LIGHTMAP_LIGHTING;
buffer->Material.Wireframe = false;
buffer->Material.Lighting = true;
mesh->addMeshBuffer(buffer);
buffer->drop();
}
// Build the mesh buffers
#ifdef _IRR_DMF_DEBUG_
os::Printer::log("Adding geometry to mesh.");
#endif
for (i = 0; i < header.numFaces; i++)
{
#ifdef _IRR_DMF_DEBUG_
os::Printer::log("Polygon with #vertices", core::stringc(faces[i].numVerts).c_str());
#endif
if (faces[i].numVerts < 3)
continue;
const core::vector3df normal =
core::triangle3df(verts[faces[i].firstVert].pos,
verts[faces[i].firstVert+1].pos,
verts[faces[i].firstVert+2].pos).getNormal().normalize();
SSkinMeshBuffer* meshBuffer = (SSkinMeshBuffer*)mesh->getMeshBuffer(
faces[i].materialID);
const bool use2TCoords = meshBuffer->Vertices_2TCoords.size() ||
materiali[faces[i].materialID].lightmapName.size();
if (use2TCoords && meshBuffer->Vertices_Standard.size())
meshBuffer->convertTo2TCoords();
const u32 base = meshBuffer->Vertices_2TCoords.size()?meshBuffer->Vertices_2TCoords.size():meshBuffer->Vertices_Standard.size();
// Add this face's verts
if (use2TCoords)
{
// make sure we have the proper type set
meshBuffer->VertexType=video::EVT_2TCOORDS;
for (u32 v = 0; v < faces[i].numVerts; v++)
{
const dmfVert& vv = verts[faces[i].firstVert + v];
video::S3DVertex2TCoords vert(vv.pos,
normal, video::SColor(255,255,255,255), vv.tc, vv.lc);
if (materiali[faces[i].materialID].textureBlend==4 &&
SceneMgr->getParameters()->getAttributeAsBool(DMF_FLIP_ALPHA_TEXTURES))
{
vert.TCoords.set(vv.tc.X,-vv.tc.Y);
}
meshBuffer->Vertices_2TCoords.push_back(vert);
}
}
else
{
for (u32 v = 0; v < faces[i].numVerts; v++)
{
const dmfVert& vv = verts[faces[i].firstVert + v];
video::S3DVertex vert(vv.pos,
normal, video::SColor(255,255,255,255), vv.tc);
if (materiali[faces[i].materialID].textureBlend==4 &&
SceneMgr->getParameters()->getAttributeAsBool(DMF_FLIP_ALPHA_TEXTURES))
{
vert.TCoords.set(vv.tc.X,-vv.tc.Y);
}
meshBuffer->Vertices_Standard.push_back(vert);
}
}
// Now add the indices
// This weird loop turns convex polygons into triangle strips.
// I do it this way instead of a simple fan because it usually
// looks a lot better in wireframe, for example.
u32 h = faces[i].numVerts - 1, l = 0, c; // High, Low, Center
for (u32 v = 0; v < faces[i].numVerts - 2; v++)
{
if (v & 1) // odd
c = h - 1;
else // even
c = l + 1;
meshBuffer->Indices.push_back(base + h);
meshBuffer->Indices.push_back(base + l);
meshBuffer->Indices.push_back(base + c);
if (v & 1) // odd
h--;
else // even
l++;
}
}
delete [] verts;
delete [] faces;
}
// delete all buffers without geometry in it.
#ifdef _IRR_DMF_DEBUG_
os::Printer::log("Cleaning meshbuffers.");
#endif
i = 0;
while(i < mesh->MeshBuffers.size())
{
if (mesh->MeshBuffers[i]->getVertexCount() == 0 ||
mesh->MeshBuffers[i]->getIndexCount() == 0)
{
// Meshbuffer is empty -- drop it
mesh->MeshBuffers[i]->drop();
mesh->MeshBuffers.erase(i);
materiali.erase(i);
}
else
{
i++;
}
}
{
//load textures and lightmaps in materials.
//don't worry if you receive a could not load texture, cause if you don't need
//a particular material in your scene it will be loaded and then destroyed.
#ifdef _IRR_DMF_DEBUG_
os::Printer::log("Loading textures.");
#endif
const bool use_mat_dirs=!SceneMgr->getParameters()->getAttributeAsBool(DMF_IGNORE_MATERIALS_DIRS);
core::stringc path;
if ( SceneMgr->getParameters()->existsAttribute(DMF_TEXTURE_PATH) )
path = SceneMgr->getParameters()->getAttributeAsString(DMF_TEXTURE_PATH);
else
path = FileSystem->getFileDir(file->getFileName());
path += ('/');
for (i=0; i<mesh->getMeshBufferCount(); i++)
{
//texture and lightmap
video::ITexture *tex = 0;
video::ITexture *lig = 0;
//current buffer to apply material
video::SMaterial& mat = mesh->getMeshBuffer(i)->getMaterial();
//Primary texture is normal
if (materiali[i].textureFlag==0)
{
if (materiali[i].textureBlend==4)
driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT,true);
findFile(use_mat_dirs, path, materiali[i].pathName, materiali[i].textureName);
tex = driver->getTexture(materiali[i].textureName);
}
//Primary texture is just a colour
else if(materiali[i].textureFlag==1)
{
video::SColor color(axtoi(materiali[i].textureName.c_str()));
//just for compatibility with older Irrlicht versions
//to support transparent materials
if (color.getAlpha()!=255 && materiali[i].textureBlend==4)
driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT,true);
video::IImage *immagine= driver->createImage(video::ECF_A8R8G8B8,
core::dimension2d<u32>(8,8));
immagine->fill(color);
tex = driver->addTexture("", immagine);
immagine->drop();
//to support transparent materials
if (color.getAlpha()!=255 && materiali[i].textureBlend==4)
{
mat.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
mat.MaterialTypeParam =(((f32) (color.getAlpha()-1))/255.0f);
}
}
//Lightmap is present
if (materiali[i].lightmapFlag == 0)
{
findFile(use_mat_dirs, path, materiali[i].pathName, materiali[i].lightmapName);
lig = driver->getTexture(materiali[i].lightmapName);
}
else //no lightmap
{
mat.MaterialType = video::EMT_SOLID;
const f32 mult = 100.0f - header.dmfShadow;
mat.AmbientColor=header.dmfAmbient.getInterpolated(video::SColor(255,0,0,0),mult/100.f);
}
if (materiali[i].textureBlend==4)
{
mat.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
mat.MaterialTypeParam =
SceneMgr->getParameters()->getAttributeAsFloat(DMF_ALPHA_CHANNEL_REF);
}
//if texture is present mirror vertically owing to DeleD representation
if (tex && header.dmfVersion<1.1)
{
const core::dimension2d<u32> texsize = tex->getSize();
void* pp = tex->lock();
if (pp)
{
const video::ECOLOR_FORMAT format = tex->getColorFormat();
if (format == video::ECF_A1R5G5B5)
{
s16* p = (s16*)pp;
s16 tmp=0;
for (u32 x=0; x<texsize.Width; x++)
for (u32 y=0; y<texsize.Height/2; y++)
{
tmp=p[y*texsize.Width + x];
p[y*texsize.Width + x] = p[(texsize.Height-y-1)*texsize.Width + x];
p[(texsize.Height-y-1)*texsize.Width + x]=tmp;
}
}
else
if (format == video::ECF_A8R8G8B8)
{
s32* p = (s32*)pp;
s32 tmp=0;
for (u32 x=0; x<texsize.Width; x++)
for (u32 y=0; y<texsize.Height/2; y++)
{
tmp=p[y*texsize.Width + x];
p[y*texsize.Width + x] = p[(texsize.Height-y-1)*texsize.Width + x];
p[(texsize.Height-y-1)*texsize.Width + x]=tmp;
}
}
}
tex->unlock();
tex->regenerateMipMapLevels();
}
//if lightmap is present mirror vertically owing to DeleD rapresentation
if (lig && header.dmfVersion<1.1)
{
const core::dimension2d<u32> ligsize=lig->getSize();
void* pp = lig->lock();
if (pp)
{
video::ECOLOR_FORMAT format = lig->getColorFormat();
if (format == video::ECF_A1R5G5B5)
{
s16* p = (s16*)pp;
s16 tmp=0;
for (u32 x=0; x<ligsize.Width; x++)
{
for (u32 y=0; y<ligsize.Height/2; y++)
{
tmp=p[y*ligsize.Width + x];
p[y*ligsize.Width + x] = p[(ligsize.Height-y-1)*ligsize.Width + x];
p[(ligsize.Height-y-1)*ligsize.Width + x]=tmp;
}
}
}
else if (format == video::ECF_A8R8G8B8)
{
s32* p = (s32*)pp;
s32 tmp=0;
for (u32 x=0; x<ligsize.Width; x++)
{
for (u32 y=0; y<ligsize.Height/2; y++)
{
tmp=p[y*ligsize.Width + x];
p[y*ligsize.Width + x] = p[(ligsize.Height-y-1)*ligsize.Width + x];
p[(ligsize.Height-y-1)*ligsize.Width + x]=tmp;
}
}
}
}
lig->unlock();
lig->regenerateMipMapLevels();
}
mat.setTexture(0, tex);
mat.setTexture(1, lig);
}
}
// create bounding box
for (i = 0; i < mesh->MeshBuffers.size(); ++i)
{
mesh->MeshBuffers[i]->recalculateBoundingBox();
}
mesh->recalculateBoundingBox();
// Set up an animated mesh to hold the mesh
SAnimatedMesh* AMesh = new SAnimatedMesh();
AMesh->Type = EAMT_UNKNOWN;
AMesh->addMesh(mesh);
AMesh->recalculateBoundingBox();
mesh->drop();
return AMesh;
}
/*
* recursive expression parser
*
* Input: pointer to argument rest string
*
* Output: computed value
*/
int eval(char *s)
{
register char *p;
register int val;
char word[MAXLINE];
struct sym *sp;
val = 0;
while (*s) {
p = word;
if (*s == '(') {
s++;
while (*s != ')') {
if (*s == '\0') {
asmerr(E_MISPAR);
goto eval_break;
}
*p++ = *s++;
}
*p = '\0';
s++;
val = eval(word);
continue;
}
if (*s == STRSEP) {
s++;
while (*s != STRSEP) {
if (*s == '\n' || *s == '\0') {
asmerr(E_MISHYP);
goto hyp_error;
}
*p++ = *s++;
}
s++;
hyp_error:
*p = '\0';
val = strval(word);
continue;
}
if (isari(*s))
*p++ = *s++;
else
while (!isspace(*s) && !isari(*s) && (*s != '\0'))
*p++ = *s++;
*p = '\0';
switch (get_type(word)) {
case OPESYM: /* symbol */
if (strcmp(word, "$") == 0) {
val = pc;
break;
}
if (strlen(word) > SYMSIZE)
word[SYMSIZE] = '\0';
if ((sp = get_sym(word)) != NULL)
val = sp->sym_val;
else
asmerr(E_UNDSYM);
break;
case OPEDEC: /* decimal number */
val = atoi(word);
break;
case OPEHEX: /* hexadecimal number */
val = axtoi(word);
break;
case OPEBIN: /* binary number */
val = abtoi(word);
break;
case OPEOCT: /* octal number */
val = aotoi(word);
break;
case OPESUB: /* arithmetical - */
val -= eval(s);
goto eval_break;
case OPEADD: /* arithmetical + */
val += eval(s);
goto eval_break;
case OPEMUL: /* arithmetical * */
val *= eval(s);
goto eval_break;
case OPEDIV: /* arithmetical / */
val /= eval(s);
goto eval_break;
case OPEMOD: /* arithmetical modulo */
val %= eval(s);
goto eval_break;
case OPESHL: /* logical shift left */
val <<= eval(s);
goto eval_break;
case OPESHR: /* logical shift right */
val >>= eval(s);
goto eval_break;
case OPELOR: /* logical OR */
val |= eval(s);
goto eval_break;
case OPELAN: /* logical AND */
val &= eval(s);
goto eval_break;
case OPEXOR: /* logical XOR */
val ^= eval(s);
goto eval_break;
case OPECOM: /* logical complement */
val = ~(eval(s));
goto eval_break;
}
}
eval_break:
return(val);
}
void NMEAParser::ParseRecursive(const char ch)
{
// printf("%c",ch);
enum NMEAParserState { SearchForSOS = 1,
RetrieveAddressField,
ReceiveSentenceData,
GetFirstChecksumCharacter,
GetSecondChecksumCharacter,
WaitForST,
ValidSentence };
static const unsigned int ADDRESS_FIELD_MAX_LENGTH = 10;
static const unsigned int NMEA_SEQUENCE_MAX_LENGTH = 81;
static NMEAParserState m_State = SearchForSOS;
static unsigned int m_CalcChecksum;
static char m_Checksum[3];
static char m_NMEASequence[NMEA_SEQUENCE_MAX_LENGTH];
static unsigned int m_NMEASequenceIndex;
static char m_AddressField[ADDRESS_FIELD_MAX_LENGTH];
static unsigned int m_AddressFieldIndex;
switch( m_State )
{
case SearchForSOS:
{
// printf("searchSOS\n");
if( ch == '$' )
{
// printf("$");
m_AddressFieldIndex = 0;
m_NMEASequenceIndex = 0;
m_CalcChecksum = 0;
m_State = RetrieveAddressField;
}
break;
}
case RetrieveAddressField:
{
// printf("retrieveaddressfield\n");
if( m_NMEASequenceIndex == NMEA_SEQUENCE_MAX_LENGTH - 1 )
m_State = SearchForSOS;
else
{
m_NMEASequence[m_NMEASequenceIndex++] = ch;
m_CalcChecksum ^= ch;
if( ch == ',' )
{
// printf(",");
m_AddressField[m_AddressFieldIndex] = '\0';
m_State = ReceiveSentenceData;
}
else if( m_AddressFieldIndex == ADDRESS_FIELD_MAX_LENGTH - 1 ||
!isalpha(ch) || islower(ch) )
m_State = SearchForSOS;
else
m_AddressField[m_AddressFieldIndex++] = ch;
}
break;
}
case ReceiveSentenceData:
{
// printf("retrievesentence\n");
if( m_NMEASequenceIndex == NMEA_SEQUENCE_MAX_LENGTH - 1 )
m_State = SearchForSOS;
else
{
m_NMEASequence[m_NMEASequenceIndex++] = ch;
if( ch == '*' )
m_State = GetFirstChecksumCharacter;
else if( ch == 10 )
m_State = WaitForST;
else if( ch == 13 )
{
m_NMEASequence[m_NMEASequenceIndex++] = ch;
m_NMEASequence[m_NMEASequenceIndex] = '\0';
ParseNMEASentence( m_AddressField, m_NMEASequence, m_NMEASequenceIndex );
m_State = SearchForSOS;
}
else
m_CalcChecksum ^= ch;
}
break;
}
case GetFirstChecksumCharacter:
{
// printf("getchecksum\n");
if( m_NMEASequenceIndex == NMEA_SEQUENCE_MAX_LENGTH - 1 ||
( !isdigit(ch) && ( ch < 'A' || ch > 'F' ) ) )
m_State = SearchForSOS;
else
{
m_NMEASequence[m_NMEASequenceIndex++] = ch;
m_Checksum[0] = ch;
m_State = GetSecondChecksumCharacter;
}
break;
}
case GetSecondChecksumCharacter:
{
// printf("get2ndchecksum\n");
if( m_NMEASequenceIndex == NMEA_SEQUENCE_MAX_LENGTH - 1 ||
( !isdigit(ch) && ( ch < 'A' || ch > 'F' ) ) )
m_State = SearchForSOS;
else
{
m_NMEASequence[m_NMEASequenceIndex++] = ch;
m_Checksum[1] = ch;
m_Checksum[2] = '\0';
unsigned int iChecksum = axtoi( m_Checksum );
if( iChecksum == m_CalcChecksum )
m_State = WaitForST;
else
m_State = SearchForSOS;
}
break;
}
case WaitForST:
{
if( m_NMEASequenceIndex == NMEA_SEQUENCE_MAX_LENGTH - 1 ||
(ch != 10 && ch != 13) )
m_State = SearchForSOS;
else if(ch == 13)
{
m_NMEASequence[m_NMEASequenceIndex++] = ch;
m_NMEASequence[m_NMEASequenceIndex] = '\0';
ParseNMEASentence( m_AddressField, m_NMEASequence, m_NMEASequenceIndex );
m_State = SearchForSOS;
}
break;
}
}
}
