static gctBOOL
ReadSource(
IN gcoOS Os,
IN gctCONST_STRING FileName,
OUT gctSIZE_T * SourceSize,
OUT gctSTRING * Source
)
{
gceSTATUS status;
gctFILE file;
gctUINT32 count;
gctSIZE_T byteRead;
gctSTRING source;
gcmASSERT(FileName);
status = gcoOS_Open(Os, FileName, gcvFILE_READ, &file);
if (gcmIS_ERROR(status))
{
printf("*ERROR* Failed to open input file: %s\n", FileName);
return gcvFALSE;
}
gcmVERIFY_OK(gcoOS_Seek(Os, file, 0, gcvFILE_SEEK_END));
gcmVERIFY_OK(gcoOS_GetPos(Os, file, &count));
status = gcoOS_Allocate(Os, count + 1, (gctPOINTER *) &source);
if (!gcmIS_SUCCESS(status))
{
printf("*ERROR* Not enough memory\n");
gcmVERIFY_OK(gcoOS_Close(Os, file));
return gcvFALSE;
}
gcmVERIFY_OK(gcoOS_SetPos(Os, file, 0));
status = gcoOS_Read(Os, file, count, source, &byteRead);
if (!gcmIS_SUCCESS(status) || byteRead != count)
{
printf("*ERROR* Failed to open input file: %s\n", FileName);
gcmVERIFY_OK(gcoOS_Close(Os, file));
return gcvFALSE;
}
source[count] = '\0';
gcmVERIFY_OK(gcoOS_Close(Os, file));
*SourceSize = count;
*Source = source;
return gcvTRUE;
}
static gctBOOL
OutputShaderData(
IN gcoOS Os,
IN gctCONST_STRING FileName,
IN gctSIZE_T Size,
IN gctCONST_STRING Data
)
{
gceSTATUS status;
gctSTRING dataFileName;
gctSIZE_T length;
gctFILE file;
gcmASSERT(FileName);
gcmVERIFY_OK(gcoOS_StrLen(FileName, &length));
length += 6;
gcmVERIFY_OK(gcoOS_Allocate(Os, length, (gctPOINTER *) &dataFileName));
gcmVERIFY_OK(gcoOS_StrCopySafe(dataFileName, length, FileName));
gcmVERIFY_OK(gcoOS_StrCatSafe(dataFileName, length, ".gcSL"));
status = gcoOS_Open(Os, dataFileName, gcvFILE_CREATE, &file);
if (gcmIS_ERROR(status))
{
gcoOS_Free(Os, dataFileName);
printf("*ERROR* Failed to open the data file: %s\n", dataFileName);
return gcvFALSE;
}
gcoOS_Free(Os, dataFileName);
gcmASSERT(file);
status = gcoOS_Write(Os, file, Size, Data);
if (!gcmIS_SUCCESS(status))
{
printf("*ERROR* Failed to write the data file: %s\n", dataFileName);
goto ErrorExit;
}
gcmVERIFY_OK(gcoOS_Close(Os, file));
return gcvTRUE;
ErrorExit:
gcmVERIFY_OK(gcoOS_Close(Os, file));
return gcvFALSE;
}
gceSTATUS
gcoPROFILER_Destroy(
IN gcoHAL Hal
)
{
gcmHEADER();
if (gcPLS.hal->profiler.enable == 1)
{
#if gcdNEW_PROFILER_FILE
gcmWRITE_CONST(VPG_END);
#else
gcmWRITE_STRING("</VProfile>\n");
#endif
gcoPROFILER_Flush(gcvNULL);
if (gcPLS.hal->profiler.useSocket)
{
/* Close the socket. */
gcmVERIFY_OK(gcoOS_CloseSocket(gcvNULL, gcPLS.hal->profiler.sockFd));
}
else
{
/* Close the profiler file. */
gcmVERIFY_OK(gcoOS_Close(gcvNULL, gcPLS.hal->profiler.file));
}
gcPLS.hal->profiler.enable = 0;
}
else
{
gcPLS.hal->profiler.enable--;
}
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
/*******************************************************************************
**
** gcoDUMP_Control
**
** Control dumping.
**
** INPUT:
**
** gcoDUMP Dump
** Pointer to a gcoDUMP object.
**
** gctSTRING FileName
** If 'FileName' is not gcvNULL, it points to the filename to be used for
** capturing all data. If 'FileName' is gcvNULL, turn off any current
** capturing.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoDUMP_Control(
IN gcoDUMP Dump,
IN gctSTRING FileName
)
{
gceSTATUS status = gcvSTATUS_OK;
gcsDUMP_FILE header;
gctUINT32 pos;
gcmHEADER_ARG("Dump=0x%x FileName=0x%x", Dump, FileName);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Dump, gcvOBJ_DUMP);
do
{
if (FileName != gcvNULL)
{
/* Need to create a new dump file. */
if (Dump->file == gcvNULL)
{
/* Create the dump file. */
gcmERR_BREAK(gcoOS_Open(gcvNULL,
FileName,
gcvFILE_CREATE,
&Dump->file));
/* Write the file header. */
header.signature = gcvDUMP_FILE_SIGNATURE;
header.length = Dump->length = 0;
header.frames = Dump->frameCount = 0;
gcmERR_BREAK(gcoOS_Write(gcvNULL,
Dump->file,
sizeof(header),
&header));
/* Frame is not yet started. */
Dump->frameStart = 0;
}
}
else
{
/* Need to close any current dump file. */
if (Dump->file != gcvNULL)
{
/* Close any open frame. */
if (Dump->frameStart != 0)
{
gcoDUMP_FrameEnd(Dump);
gcoDUMP_FrameBegin(Dump);
}
/* Get the current position. */
gcmERR_BREAK(gcoOS_GetPos(gcvNULL, Dump->file, &pos));
/* Seek to the beginnnig of the file. */
gcmERR_BREAK(gcoOS_SetPos(gcvNULL, Dump->file, 0));
/* Make sure we have the correct size. */
gcmASSERT(pos == Dump->length + sizeof(header));
/* Update the file header. */
header.signature = gcvDUMP_FILE_SIGNATURE;
header.length = Dump->length;
header.frames = Dump->frameCount;
gcmERR_BREAK(gcoOS_Write(gcvNULL,
Dump->file,
sizeof(header),
&header));
/* Seek to the end of the file. */
gcmERR_BREAK(gcoOS_SetPos(gcvNULL, Dump->file, pos));
/* Close the file. */
gcmERR_BREAK(gcoOS_Close(gcvNULL, Dump->file));
/* Mark the file as closed. */
Dump->file = gcvNULL;
}
}
}
while (gcvFALSE);
/* Return the status. */
gcmFOOTER();
return status;
}
static gcSHADER
CompileFile(
IN gcoOS Os,
IN gctCONST_STRING FileName,
IN gcoHAL Hal,
IN gctUINT Option,
IN gctBOOL DumpLog,
IN gctBOOL DumpCompiledShader
)
{
gceSTATUS status;
gctINT shaderType;
gctSIZE_T sourceSize;
gctSTRING source = gcvNULL;
gcSHADER binary;
gctSTRING log = gcvNULL;
gctSIZE_T bufferSize;
gctSTRING buffer;
gctSTRING dataFileName = gcvNULL;
gctSIZE_T length;
gctFILE logFile = gcvNULL;
gcmASSERT(FileName);
shaderType = GetShaderType(FileName);
if (!ReadSource(Os, FileName, &sourceSize, &source)) return gcvNULL;
status = gcCompileShader(Hal,
shaderType,
sourceSize, source,
&binary,
&log);
if (log != gcvNULL)
{
printf("<LOG>\n");
printf("%s", log);
printf("</LOG>\n");
}
if (gcmIS_ERROR(status))
{
gcmASSERT(binary == gcvNULL);
binary = gcvNULL;
printf("*ERROR* Failed to compile %s (error: %d)\n", FileName, status);
goto Exit;
}
gcmASSERT(binary != gcvNULL);
if (DumpLog)
{
gcmVERIFY_OK(gcoOS_StrLen(FileName, &length));
length += 5;
gcmVERIFY_OK(gcoOS_Allocate(Os, length, (gctPOINTER *) &dataFileName));
gcmVERIFY_OK(gcoOS_StrCopySafe(dataFileName, length, FileName));
gcmVERIFY_OK(gcoOS_StrCatSafe(dataFileName, length, ".log"));
status = gcoOS_Open(Os, dataFileName, gcvFILE_CREATETEXT, &logFile);
if (gcmIS_ERROR(status))
{
logFile = gcvNULL;
printf("*ERROR* Failed to open the log file: %s\n", dataFileName);
}
gcoOS_Free(Os, dataFileName);
}
gcmVERIFY_OK(gcSHADER_SetOptimizationOption(binary, Option));
status = gcOptimizeShader(binary, logFile);
if (!gcmIS_SUCCESS(status))
{
printf("*ERROR* Failed to optimize %s (error: %d)\n", FileName, status);
}
if (logFile != gcvNULL)
{
gcmVERIFY_OK(gcoOS_Close(Os, logFile));
}
if (DumpCompiledShader)
{
status = gcSHADER_Save(binary, gcvNULL, &bufferSize);
if (gcmIS_ERROR(status))
{
printf("*ERROR* Failed to get the buffer size of the shader\n");
goto Exit;
}
status = gcoOS_Allocate(Os, bufferSize, (gctPOINTER *) &buffer);
if (!gcmIS_SUCCESS(status))
{
printf("*ERROR* Not enough memory\n");
goto Exit;
}
status = gcSHADER_Save(binary, buffer, &bufferSize);
if (status != gcvSTATUS_OK)
{
printf("*ERROR* Failed to get the buffer size of the shader\n");
gcoOS_Free(Os, buffer);
goto Exit;
}
OutputShaderData(Os, FileName, bufferSize, buffer);
gcoOS_Free(Os, buffer);
}
Exit:
if (DumpLog && log != gcvNULL)
{
printf("**************** Compile Log ****************");
printf("%s", log);
printf("*********************************************");
}
if (log != gcvNULL) gcoOS_Free(Os, log);
if (source != gcvNULL) gcoOS_Free(Os, source);
return binary;
}
