Font::Font(const String& filename) {
unsigned char* rawData = nullptr;
int_d size = 0;
if (!load_binary_file(filename, &rawData, &size)) {
//TODO: error
}
FONT_HEADER* header = (FONT_HEADER*)rawData;
this->x = header->xCount;
this->y = header->yCount;
texture = new Texture(rawData + sizeof(FONT_HEADER) + header->DataSize, header->ImageSize);
CHAR_INFO* cInfo = (CHAR_INFO*)(rawData + sizeof(FONT_HEADER));
if (header->CalcCoords) {
float xStep = 1.0f / (float)x;
float yStep = 1.0f / (float)y;
for (uint8 yp = 0; yp < y; yp++) {
for (uint8 xp = 0; xp < x; xp++) {
float x0 = (float)xp * xStep;
float x1 = x0 + xStep;
float y0 = (float)yp * yStep;
float y1 = y0 + yStep;
cInfo->texCoords[0] = vec2(x0, y0);
cInfo->texCoords[1] = vec2(x1, y0);
cInfo->texCoords[2] = vec2(x1, y1);
cInfo->texCoords[3] = vec2(x0, y1);
charMap.addObject(*cInfo);
cInfo++;
}
}
} else {
for (uint16 i = 0; i < x*y; i++) {
charMap.addObject(*cInfo);
cInfo++;
}
}
delete rawData;
}
char*
asim_load_file(const char* realfilename)
{
long len;
char* str = load_binary_file( realfilename, &len );
if (str != NULL && len >= 0)
str[len] = '\0';
return str;
}
/* Load file for DUMP function */
struct TAPE_BLOCKS *load_file(char *infile,char *filefmt,char recfm,int *recl,int *recc,size_t *filesz)
{
struct TAPE_BLOCKS *blks;
switch(filefmt[0])
{
case 'B':
blks=load_binary_file(infile,recfm,recl,recc,filesz);
break;
case 'T':
blks=load_text_file(infile,recfm,recl,recc,filesz);
break;
case 'S':
blks=load_structured_file(infile,recfm,recl,recc,filesz);
break;
default:
fprintf(stderr,"*** INTERNAL ERROR 0001\n");
return NULL;
}
return blks;
}
bool create_font(const String& filename, const String& texture, const String& order, const String& charInfo, uint8 width, uint8 height, bool genCoords) {
#ifdef _DEBUG
printf("Creating font \"%s\"\n", *filename);
#endif
FILE* file;
fopen_s(&file, *filename, "wb");
if (!file) {
//TODO: error
return false;
}
Font::FONT_HEADER header;
header.CalcCoords = !genCoords;
header.xCount = width;
header.yCount = height;
header.DataSize = sizeof(Font::CHAR_INFO) * width * height;
unsigned char* imageData = nullptr;
int_d size = 0;
if (!load_binary_file(texture, &imageData, &size)) {
//TODO: error
}
header.ImageSize = (uint32)size;
fwrite(&header, sizeof(Font::FONT_HEADER), 1, file);
List<Font::CHAR_INFO> spec = parseFontSpec(charInfo);
#ifdef _DEBUG
printf("\t Writing all characters!\n");
#endif
float xStep = 1.0f / (float)width;
float yStep = 1.0f / (float)height;
uint16 i = 0;
for (uint8 yp = 0; yp < height; yp++) {
for (uint8 xp = 0; xp < width; xp++) {
float x0 = (float)xp * xStep;
float x1 = x0 + xStep;
float y0 = (float)yp * yStep;
float y1 = y0 + yStep;
// Font::CHAR_INFO cInfo(order[xp + yp * width], vec2(x0, y1), vec2(x1, y1), vec2(x1, y0), vec2(x0, y0));
Font::CHAR_INFO cInfo = getCharInfoFromSpec(spec, order[xp + yp * width]);
if (genCoords) {
cInfo.texCoords[0] = vec2(x0, y0);
cInfo.texCoords[1] = vec2(x1, y0);
cInfo.texCoords[2] = vec2(x1, y1);
cInfo.texCoords[3] = vec2(x0, y1);
}
#ifdef _DEBUG
printf("\t\t Writing %c\n", cInfo.c);
#endif
fwrite(&cInfo, sizeof(Font::CHAR_INFO), 1, file);
}
}
#ifdef _DEBUG
printf("\t Done!\n");
printf("\t Writing texture\n");
#endif
fwrite(imageData, header.ImageSize, 1, file);
fclose(file);
#ifdef _DEBUG
printf("All Done!\n");
#endif
return true;
}
bool DXShader::Load(const String& vertexFileName, const String& pixelFileName)
{
HRESULT hr = S_OK;
String vertexFile("data/shaders/dx/");
vertexFile.Append(vertexFileName);
// create vertex shader
void* vBuffer = nullptr;
unsigned vSize = load_binary_file(&vBuffer, vertexFile.Data());
hr = _Device->CreateVertexShader(vBuffer, vSize, NULL, &vertexShader);
if(FAILED(hr))
{
delete[] vBuffer;
LOG_ISSUE("DIRECTX ERROR: %s - failed to load vertex shader: %s",
hresult_text(hr).Data(), vertexFileName.Data());
return false;
}
// create input layout
const D3D11_INPUT_ELEMENT_DESC basicVertexLayoutDesc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
const D3D11_INPUT_ELEMENT_DESC particleVertexLayoutDesc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
const D3D11_INPUT_ELEMENT_DESC* inputLayoutDesc = (layoutType == 0) ? basicVertexLayoutDesc : particleVertexLayoutDesc;
unsigned inputDescSize = (layoutType == 0) ? ARRAYSIZE(basicVertexLayoutDesc) : ARRAYSIZE(particleVertexLayoutDesc);
hr = _Device->CreateInputLayout(inputLayoutDesc, inputDescSize, vBuffer, vSize, &inputLayout);
delete[] vBuffer;
if(FAILED(hr))
{
LOG_ISSUE("DIRECTX ERROR: %s - failed to create input layout "
"for vertex shader: %s", hresult_text(hr).Data(), vertexFileName.Data());
return false;
}
// create pixel shader
String pixelFile("shaders/dx/");
pixelFile.Append(pixelFileName);
void* psBuffer = nullptr;
unsigned psSize = load_binary_file(&psBuffer, pixelFile.Data());
hr = _Device->CreatePixelShader(psBuffer, psSize, NULL, &pixelShader);
delete[] psBuffer;
if(FAILED(hr))
{
LOG_ISSUE("DIRECTX ERROR: %s - failed to load pixel shader: %s",
hresult_text(hr).Data(), pixelFileName.Data());
return false;
}
// initialize constants
numVertexConstants = 3;
vertexConstants[0].name = "model";
vertexConstants[0].type = ShaderConstant::MAT4X4;
vertexConstants[1].name = "view";
vertexConstants[1].type = ShaderConstant::MAT4X4;
vertexConstants[2].name = "projection";
vertexConstants[2].type = ShaderConstant::MAT4X4;
numPixelConstants = 1;
pixelConstants[0].name = "color";
pixelConstants[0].type = ShaderConstant::VEC4;
int count = 0;
for(int i = 0; i < numVertexConstants; i++)
{
vertexConstants[i].location = count;
count += vertexConstants[i].GetSize();
}
count = 0;
for(int i = 0; i < numPixelConstants; i++)
{
pixelConstants[i].location = count;
count += pixelConstants[i].GetSize();
}
// create constant buffers
int vertexConstantBufferSize = 0;
for(int i = 0; i < numVertexConstants; i++)
vertexConstantBufferSize += vertexConstants[i].GetSize();
D3D11_BUFFER_DESC constantBufferDesc = {0};
constantBufferDesc.ByteWidth = sizeof(float) * vertexConstantBufferSize;
constantBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constantBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
_Device->CreateBuffer(&constantBufferDesc, nullptr, &vertCB);
if(FAILED(hr))
{
LOG_ISSUE("DIRECTX ERROR: %s - failed to create constant buffer "
"for shaders: %s and %s", hresult_text(hr).Data(), vertexFileName.Data(),
pixelFileName.Data());
return false;
}
int pixelConstantBufferSize = 0;
for(int i = 0; i < numPixelConstants; i++)
pixelConstantBufferSize += pixelConstants[i].GetSize();
D3D11_BUFFER_DESC pixelCBDesc = {0};
pixelCBDesc.ByteWidth = sizeof(float) * pixelConstantBufferSize;
pixelCBDesc.Usage = D3D11_USAGE_DYNAMIC;
pixelCBDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
pixelCBDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
_Device->CreateBuffer(&pixelCBDesc, nullptr, &pixelCB);
if(FAILED(hr))
{
LOG_ISSUE("DIRECTX ERROR: %s - failed to create pixel constant buffer "
"for shaders: %s and %s", hresult_text(hr).Data(), vertexFileName.Data(),
pixelFileName.Data());
return false;
}
return true;
}
int
main(int argc, char *argv[]) {
if (test_set_intersection() != 0) {
return EXIT_FAILURE;
}
printf("Smoke tests pass, starting engine\n");
// set up command line params
unsigned short arg = 1;
char *set_ids_filename = argv[arg++],
*set_index_filename = argv[arg++],
*set_members_filename = argv[arg++],
*suggestions_filename = argv[arg++];
double good_threshold = atof(argv[arg++]);
// optional param with default
unsigned int begin_at = 0;
if (argc > 6) {
begin_at = atoi(argv[arg]);
printf("Using optional begin_at parameter: %d \n", begin_at);
}
printf("%s\n", argv[0]);
printf("set_ids_filename: %s \n", set_ids_filename);
printf("set_index_filename: %s \n", set_index_filename);
printf("set_members_filename: %s \n", set_members_filename);
printf("suggestions_filename: %s \n", suggestions_filename);
printf("good_threshold: %.3f \n", good_threshold);
printf("begin_at: %d \n", begin_at);
struct fileinfo set_ids_file = load_binary_file(set_ids_filename);
unsigned int *set_ids = (unsigned int*)(set_ids_file.head);
unsigned int set_id_count = set_ids_file.filesize / sizeof(unsigned int);
printf("Loaded %d sets\n", set_id_count);
// visual inspection sanity check
first_10_elements(set_ids, set_ids_filename);
// set_index_filename: binary image of set id file offsets in set_members_filename
// acts as a set_id -> memory offset lookup table
// eg, indexarray[set_id] == arrays + offset_of_set_id_in_image
struct fileinfo indexarray = load_binary_file(set_index_filename);
unsigned int *indexptr = (unsigned int*) indexarray.head;
// visual inspection sanity check
first_10_elements((unsigned int*)indexarray.head, set_index_filename);
// set_members_filename : binary image of set id membership arrays
struct fileinfo arrays = load_binary_file(set_members_filename);
const unsigned int *arraysptr = (unsigned int*) arrays.head;
// visual inspection sanity check
first_10_elements((unsigned int*)arrays.head, set_members_filename);
pid_t pids[NUM_PROCESSES];
int active_pids = NUM_PROCESSES;
printf("Spinning up %d worker processes...\n", NUM_PROCESSES);
print_progress_headers();
for (int i = 0; i < active_pids; i++) {
pids[i] = fork();
if (pids[i] < 0) {
perror(NULL);
return EXIT_FAILURE;
} else if (pids[i] == 0) {
unsigned long intersection_count;
int started_at = (int)time(NULL);
char *process_filename = malloc(80);
sprintf(process_filename, "%s.%u", suggestions_filename, i);
FILE* fout = fopen(process_filename, "w");
for (int a = begin_at + i; a < set_id_count; a+= NUM_PROCESSES) {
similarity_for_set(
a,
fout,
good_threshold,
set_ids,
set_id_count,
indexptr,
arraysptr,
arrays
);
if (0 == a % 10) { print_progress_headers(); }
}
fclose(fout);
printf("Segment starting at %d finished\n", begin_at + i);
return EXIT_SUCCESS;
}
}
pid_t pid;
int status;
while (active_pids > 0) {
pid = wait(&status);
printf("Child with PID %ld exited with status 0x%x.\n", (long)pid, status);
active_pids--;
}
printf("\nSuggestomatic success!\n");
return EXIT_SUCCESS;
}
