{

// disabled SSE version as it's acting dodgy

#if 0

__m128 avec = _mm_load_ps(aflt);

__m128 bvec = _mm_load_ps(bflt);

__m128 diff = _mm_xor_ps(avec, bvec);

__m128 eq = _mm_cmpeq_ps(diff, zero);

int mask = _mm_movemask_ps(eq);

int signMask = _mm_movemask_ps(diff);

// first check ensures that diff is floatequal to zero (ie. avec bitwise equal to bvec).

// HOWEVER -0 is floatequal to 0, so we ensure no sign bits are set on diff

if((mask^0xf) || signMask != 0)

{

return true;

}

return false;

#elif defined(WIN64)

uint64_t *a64 = (uint64_t *)a;

uint64_t *b64 = (uint64_t *)b;

return a64[0] != b64[0] ||

a64[1] != b64[1];

#else

uint32_t *a32 = (uint32_t *)a;

uint32_t *b32 = (uint32_t *)b;

return a32[0] != b32[0] ||

a32[1] != b32[1] ||

a32[2] != b32[2] ||

a32[3] != b32[3];

#endif

{

RDCASSERT(uintptr_t(a)%16 == 0);

RDCASSERT(uintptr_t(b)%16 == 0);

diffStart = bufSize+1;

diffEnd = 0;

size_t alignedSize = bufSize&(~0xf);

size_t numVecs = alignedSize/16;

size_t offs = 0;

float *aflt = (float *)a;

float *bflt = (float *)b;

// sweep to find the start of differences

for(size_t v=0; v < numVecs; v++)

{

if(Vec16NotEqual(aflt, bflt))

{

diffStart = offs;

break;

}

aflt+=4;bflt+=4;offs+=4*sizeof(float);

}

// make sure we're byte-accurate, to comply with WRITE_NO_OVERWRITE

while(diffStart < bufSize && *((byte *)a + diffStart) == *((byte *)b + diffStart)) diffStart++;

// do we have some unaligned bytes at the end of the buffer?

if(bufSize > alignedSize)

{

size_t numBytes = alignedSize-bufSize;

// if we haven't even found a start, check in these bytes

if(diffStart > bufSize)

{

offs = bufSize;

for(size_t by=0; by < numBytes; by++)

{

if(*((byte *)a + alignedSize + by) != *((byte *)b + alignedSize + by))

{

diffStart = offs;

break;

}

offs++;

}

}

// sweep from the last byte to find the end

for(size_t by=0; by < numBytes; by++)

{

if(*((byte *)a + bufSize-1 - by) != *((byte *)b + bufSize-1 - by))

{

diffEnd = bufSize-by;

break;

}

}

}

// if we haven't found a start, or we've found a start AND and end,

// then we're done.

if(diffStart > bufSize || diffEnd > 0)

return diffStart < bufSize;

offs = alignedSize;

// sweep from the last __m128

aflt = (float *)a + offs/sizeof(float) - 4;

bflt = (float *)b + offs/sizeof(float) - 4;

for(size_t v=0; v < numVecs; v++)

{

if(Vec16NotEqual(aflt, bflt))

{

diffEnd = offs;

break;

}

aflt-=4;bflt-=4;offs-=16;

}

// make sure we're byte-accurate, to comply with WRITE_NO_OVERWRITE

while(diffEnd > 0 && *((byte *)a + diffEnd - 1) == *((byte *)b + diffEnd - 1)) diffEnd--;

// if we found a start then we necessarily found an end

return diffStart < bufSize;

{

int mipLevels = 1;

while(w > 1 || h > 1 || d > 1)

{

w = RDCMAX(1, w>>1);

h = RDCMAX(1, h>>1);

d = RDCMAX(1, d>>1);

mipLevels++;

}

return mipLevels;

{

logfile() = "";

if(filename && filename[0])

logfile() = filename;

{

static Threading::CriticalSection lock;

SCOPED_LOCK(lock);

#if defined(OUTPUT_LOG_TO_DEBUG_OUT)

OSUtility::WriteOutput(OSUtility::Output_DebugMon, str);

#endif

#if defined(OUTPUT_LOG_TO_STDOUT)

OSUtility::WriteOutput(OSUtility::Output_StdOut, str);

#endif

#if defined(OUTPUT_LOG_TO_STDERR)

OSUtility::WriteOutput(OSUtility::Output_StdErr, str);

#endif

#if defined(OUTPUT_LOG_TO_DISK)

if(!logfile().empty())

{

FILE *f = FileIO::fopen(logfile().c_str(), "a");

if(f)

{

// strlen used as byte length - str is UTF-8 so this is NOT number of characters

FileIO::fwrite(str, 1, strlen(str), f);

FileIO::fclose(f);

}

}

#endif

{

if(type <= RDCLog_First || type >= RDCLog_NumTypes)

{

RDCFATAL("Unexpected log type");

return;

}

va_list args;

va_start(args, fmt);

const char *name = "RENDERDOC: ";

char timestamp[64] = {0};

#if defined(INCLUDE_TIMESTAMP_IN_LOG)

StringFormat::sntimef(timestamp, 63, "[%H:%M:%S] ");

#endif

char location[64] = {0};

#if defined(INCLUDE_LOCATION_IN_LOG)

string loc;

loc = basename(string(file));

StringFormat::snprintf(location, 63, "% 20s(%4d) - ", loc.c_str(), line);

#endif

const char *typestr[RDCLog_NumTypes] = {

"Debug ",

"Log ",

"Warning",

"Error ",

"Fatal ",

};

const size_t outBufSize = 4*1024;

char outputBuffer[outBufSize+1];

outputBuffer[outBufSize] = 0;

char *output = outputBuffer;

size_t available = outBufSize;

int numWritten = StringFormat::snprintf(output, available, "%s %s%s%s - ", name, timestamp, location, typestr[type]);

if(numWritten < 0)

{

va_end(args);

return;

}

output += numWritten;

available -= numWritten;

numWritten = StringFormat::vsnprintf(output, available, fmt, args);

va_end(args);

if(numWritten < 0)

return;

output += numWritten;

available -= numWritten;

if(available < 2)

return;

*output = '\n';

*(output+1) = 0;

rdclogprint_int(outputBuffer);