Ejemplo n.º 1
0
Length* newCoordsArray(const String& string, int& len)
{
    unsigned length = string.length();
    const UChar* data = string.characters();
    StringBuffer spacified(length);
    for (unsigned i = 0; i < length; i++) {
        UChar cc = data[i];
        if (cc > '9' || (cc < '0' && cc != '-' && cc != '*' && cc != '.'))
            spacified[i] = ' ';
        else
            spacified[i] = cc;
    }
    RefPtr<StringImpl> str = StringImpl::adopt(spacified);

    str = str->simplifyWhiteSpace();

    len = countCharacter(str->characters(), str->length(), ' ') + 1;
    Length* r = new Length[len];

    int i = 0;
    int pos = 0;
    int pos2;

    while ((pos2 = str->find(' ', pos)) != -1) {
        r[i++] = parseLength(str->characters() + pos, pos2 - pos);
        pos = pos2+1;
    }
    r[i] = parseLength(str->characters() + pos, str->length() - pos);

    ASSERT(i == len - 1);

    return r;
}
Ejemplo n.º 2
0
std::unique_ptr<Length[]> newCoordsArray(const String& string, int& len)
{
    unsigned length = string.length();
    StringBuffer<UChar> spacified(length);
    for (unsigned i = 0; i < length; i++) {
        UChar cc = string[i];
        if (cc > '9' || (cc < '0' && cc != '-' && cc != '*' && cc != '.'))
            spacified[i] = ' ';
        else
            spacified[i] = cc;
    }
    RefPtr<StringImpl> str = StringImpl::adopt(spacified);

    str = str->simplifyWhiteSpace();

    len = countCharacter(*str, ' ') + 1;
    auto r = std::make_unique<Length[]>(len);

    int i = 0;
    unsigned pos = 0;
    size_t pos2;

    auto upconvertedCharacters = StringView(str.get()).upconvertedCharacters();
    while ((pos2 = str->find(' ', pos)) != notFound) {
        r[i++] = parseLength(upconvertedCharacters + pos, pos2 - pos);
        pos = pos2+1;
    }
    r[i] = parseLength(upconvertedCharacters + pos, str->length() - pos);

    ASSERT(i == len - 1);

    return r;
}
Ejemplo n.º 3
0
Length* newLengthArray(const String& string, int& len)
{
    RefPtr<StringImpl> str = string.impl()->simplifyWhiteSpace();
    if (!str->length()) {
        len = 1;
        return 0;
    }

    len = countCharacter(str->characters(), str->length(), ',') + 1;
    Length* r = new Length[len];

    int i = 0;
    int pos = 0;
    int pos2;

    while ((pos2 = str->find(',', pos)) != -1) {
        r[i++] = parseLength(str->characters() + pos, pos2 - pos);
        pos = pos2+1;
    }

    ASSERT(i == len - 1);

    // IE Quirk: If the last comma is the last char skip it and reduce len by one.
    if (str->length()-pos > 0)
        r[i] = parseLength(str->characters() + pos, str->length() - pos);
    else
        len--;

    return r;
}
Ejemplo n.º 4
0
std::unique_ptr<Length[]> newLengthArray(const String& string, int& len)
{
    RefPtr<StringImpl> str = string.impl()->simplifyWhiteSpace();
    if (!str->length()) {
        len = 1;
        return nullptr;
    }

    len = countCharacter(*str, ',') + 1;
    auto r = std::make_unique<Length[]>(len);

    int i = 0;
    unsigned pos = 0;
    size_t pos2;

    auto upconvertedCharacters = StringView(str.get()).upconvertedCharacters();
    while ((pos2 = str->find(',', pos)) != notFound) {
        r[i++] = parseLength(upconvertedCharacters + pos, pos2 - pos);
        pos = pos2+1;
    }

    ASSERT(i == len - 1);

    // IE Quirk: If the last comma is the last char skip it and reduce len by one.
    if (str->length()-pos > 0)
        r[i] = parseLength(upconvertedCharacters + pos, str->length() - pos);
    else
        len--;

    return r;
}
Ejemplo n.º 5
0
Archivo: Font.cpp Proyecto: rtisne/Pdp
void Font::removeCharacter(int id)
{
  assert(id>=0 && id<countCharacter());
  m_listCharacter.erase(m_listCharacter.begin() + id);
}
Ejemplo n.º 6
0
Archivo: Font.cpp Proyecto: rtisne/Pdp
Character* Font::characterAtIndex(int id)
{
  assert(id>=0 && id<countCharacter());
  return &m_listCharacter.at(id);
}
Ejemplo n.º 7
0
std::vector<triangle> OBJFileReader::getFacesFromLine(char* line, const OBJFileData* data, material use_mtl) {
    std::vector<triangle> triangles;
    
    int vertex_count = countCharacter(' ', line);
    
    char **all_vertices = (char**) malloc (sizeof(char*)*vertex_count + 1);
    
    strtok(line, " ");
    
    for(int i = 0; i < vertex_count-1; i++) {
        all_vertices[i] = strtok(NULL, " ");
    }
    
    all_vertices[vertex_count-1] = strtok(NULL, " \n\0");
    
    for(int vert = 1; vert < vertex_count - 1; vert++) {
        char* vertices[3] = {all_vertices[0], all_vertices[vert], all_vertices[vert+1]};
        
        int   vertex_indices[3] = {-1, -1, -1};
        int   texture_coord_indices[3] = {-1, -1, -1};
        int   normal_indices[3] = {-1, -1, -1};
        
        // Boolean containing whether we haven't declared a normal.
        bool  undeclared_normal = false;
        bool  has_texture = false;
        
        for(int i = 0; i < 3; i++) {
            int size = strlen(vertices[i]);
            std::string data[] = {std::string(), std::string() ,std::string()};
            int counter = 0; // The amount of '/' we have encountered.
            
            for(int j = 0; j < size; j++) {
                if(vertices[i][j] == '/') {
                    counter++;
                } else {
                    data[counter].push_back(vertices[i][j]);
                }
            }
            
            vertex_indices[i] = atoi(data[0].data());
            if(counter >= 1) {
                if(data[1].size()) {
                    texture_coord_indices[i] = atoi(data[1].data());
                    has_texture = true;
                }
            }
            if(counter == 2)
                normal_indices[i] = atoi(data[2].data());
            else
                undeclared_normal = true;
        }
        
        vertex first(data->vertexList[vertex_indices[0]]);
        vertex secnd(data->vertexList[vertex_indices[1]]);
        vertex third(data->vertexList[vertex_indices[2]]);
        
        
        first.setColour(use_mtl.diffuse);
        secnd.setColour(use_mtl.diffuse);
        third.setColour(use_mtl.diffuse);
        
        if(has_texture && use_mtl.texture) {
            //printf("has texture!! %p\n", use_mtl.texture);
            first.setTexCoord(data->textureCoordList[texture_coord_indices[0]]);
            secnd.setTexCoord(data->textureCoordList[texture_coord_indices[1]]);
            third.setTexCoord(data->textureCoordList[texture_coord_indices[2]]);
        } else {
            //printf("has no texture\n");
            has_texture = false;
        }
        
        triangle new_triangle(first, secnd, third);
        if(has_texture)
            new_triangle.setTexture(use_mtl.texture);
        
        if(undeclared_normal) {
            new_triangle.generateNormals();
        } else {
            new_triangle[0].setNormal(data->normalList[normal_indices[0]]);
            new_triangle[1].setNormal(data->normalList[normal_indices[1]]);
            new_triangle[2].setNormal(data->normalList[normal_indices[2]]);
        }
        
        float4 avg_normal = new_triangle.getAverageNormal();
        //Check for NaN
        if(   new_triangle.getAverageNormal()[0] == new_triangle.getAverageNormal()[0]
           || new_triangle.getAverageNormal()[1] == new_triangle.getAverageNormal()[1]
           || new_triangle.getAverageNormal()[2] == new_triangle.getAverageNormal()[2])
            triangles.push_back(new_triangle);
    }
    
    return triangles;
}
Ejemplo n.º 8
0
std::map<std::string,std::vector<std::string> > StringTools::tabDelimitedSpreadsheetFileToStringMap(const std::string& tabDelimitedSpreadsheetFileName)
{
	const char rowDelim = '\n';
	const char fieldDelim = '\t';
	const char surplusRowDelim = '\r';

	std::map<std::string,std::vector<std::string> > result;
	std::vector<std::string> headerEntries;
	std::map<std::string,std::vector<std::string> >::iterator resultMapIterator;
	std::vector<std::string> emptyStringVector;
	std::string tmpString;
	int numberOfFieldDelims;
	std::istringstream iStringStream;

	char* inputFileName  = new char [tabDelimitedSpreadsheetFileName.size()+1];
	std::strcpy (inputFileName, tabDelimitedSpreadsheetFileName.c_str());
	std::ifstream spreadsheetFile(inputFileName);
	delete[] inputFileName;


	if( !(spreadsheetFile) )
	{
		std::string fileExistErrorMessageString = "Following file cannot be found:\n";
		fileExistErrorMessageString.append(tabDelimitedSpreadsheetFileName);
		fileExistErrorMessageString.append("\n");
		char* fileExistErrorMessageNotConst = new char [fileExistErrorMessageString.size()+1];
		std::strcpy (fileExistErrorMessageNotConst,fileExistErrorMessageString.c_str());
		const char *const fileExistErrorMessage = fileExistErrorMessageNotConst;
		throw(fileExistErrorMessage);
	}

	std::copy(std::istreambuf_iterator<char>(spreadsheetFile), std::istreambuf_iterator<char>(), std::back_inserter(tmpString));
	spreadsheetFile.close();
	std::replace(tmpString.begin(),tmpString.end(),surplusRowDelim,rowDelim);
	removeAdjacentDuplicatesOfCertainCharacter(tmpString,rowDelim);
	std::istringstream spreadsheet;
	spreadsheet.str(tmpString);
	tmpString.clear();

	for(bool firstLine = true; std::getline(spreadsheet,tmpString,rowDelim); )
	{
		removeAdjacentDuplicatesOfCertainCharacter(tmpString,fieldDelim);
		removeSingleCertainCharacterFromBeginning(tmpString,fieldDelim);
		removeSingleCertainCharacterFromEnd(tmpString,fieldDelim);
		iStringStream.clear();
		iStringStream.str( tmpString );
		numberOfFieldDelims = countCharacter(tmpString,fieldDelim);
		tmpString.clear();

		if(firstLine)
		{
			for(;std::getline(iStringStream,tmpString,fieldDelim);tmpString.clear())
			{
				headerEntries.push_back(tmpString);
				result[tmpString] = emptyStringVector;
			}
			firstLine = false;
		}
		else
		{
			if( numberOfFieldDelims >= (headerEntries.size()-1) )
			{
				for(std::vector<std::string>::const_iterator currentHeaderEntry = headerEntries.begin(); currentHeaderEntry < headerEntries.end(); ++currentHeaderEntry)
				{
					resultMapIterator = result.find(*currentHeaderEntry);
					std::getline(iStringStream,tmpString,fieldDelim);
					resultMapIterator->second.push_back(tmpString);
					tmpString.clear();
				}
			}
		}
	}

	if( (result.begin())->second.size() == 0 )
	{
		std::string noSufficientRowErrorMessageString = "The following file does not contain any row with the minimum number of entries defined by the header line:\n";
		noSufficientRowErrorMessageString.append(tabDelimitedSpreadsheetFileName);
		noSufficientRowErrorMessageString.append("\n");
		char* noSufficientRowErrorMessageNotConst = new char [noSufficientRowErrorMessageString.size()+1];
		std::strcpy (noSufficientRowErrorMessageNotConst,noSufficientRowErrorMessageString.c_str());
		const char *const noSufficientRowErrorMessage = noSufficientRowErrorMessageNotConst;
		throw(noSufficientRowErrorMessage);
	}

	return result;
}