bool Context::RequireSDL(unsigned int sdlFlags)
{
// Always increment, the caller must match with ReleaseSDL(), regardless of
// what happens.
++sdlInitCounter;
// Need to call SDL_Init() at least once before SDL_InitSubsystem()
if (sdlInitCounter == 1)
{
ATOMIC_LOGDEBUG("Initialising SDL");
if (SDL_Init(0) != 0)
{
ATOMIC_LOGERRORF("Failed to initialise SDL: %s", SDL_GetError());
return false;
}
}
Uint32 remainingFlags = sdlFlags & ~SDL_WasInit(0);
if (remainingFlags != 0)
{
if (SDL_InitSubSystem(remainingFlags) != 0)
{
ATOMIC_LOGERRORF("Failed to initialise SDL subsystem: %s", SDL_GetError());
return false;
}
}
return true;
}
void Context::RequireIK()
{
// Always increment, the caller must match with ReleaseSDL(), regardless of
// what happens.
++ikInitCounter;
if (ikInitCounter == 1)
{
ATOMIC_LOGDEBUG("Initialising Inverse Kinematics library");
ik_memory_init();
ik_log_init(IK_LOG_NONE);
ik_log_register_listener(HandleIKLog);
}
}
void Context::ReleaseSDL()
{
--sdlInitCounter;
if (sdlInitCounter == 0)
{
ATOMIC_LOGDEBUG("Quitting SDL");
SDL_QuitSubSystem(SDL_INIT_EVERYTHING);
SDL_Quit();
}
if (sdlInitCounter < 0)
ATOMIC_LOGERROR("Too many calls to Context::ReleaseSDL()!");
}
void Context::ReleaseIK()
{
--ikInitCounter;
if (ikInitCounter == 0)
{
ATOMIC_LOGDEBUG("De-initialising Inverse Kinematics library");
ik_log_unregister_listener(HandleIKLog);
ik_log_deinit();
ik_memory_deinit();
}
if (ikInitCounter < 0)
ATOMIC_LOGERROR("Too many calls to Context::ReleaseIK()");
}
HttpRequest::HttpRequest(const String& url, const String& verb, const Vector<String>& headers, const String& postData) :
url_(url.Trimmed()),
verb_(!verb.Empty() ? verb : "GET"),
headers_(headers),
postData_(postData),
state_(HTTP_INITIALIZING),
httpReadBuffer_(new unsigned char[READ_BUFFER_SIZE]),
readBuffer_(new unsigned char[READ_BUFFER_SIZE]),
readPosition_(0),
writePosition_(0)
{
// Size of response is unknown, so just set maximum value. The position will also be changed
// to maximum value once the request is done, signaling end for Deserializer::IsEof().
size_ = M_MAX_UNSIGNED;
ATOMIC_LOGDEBUG("HTTP " + verb_ + " request to URL " + url_);
#ifdef ATOMIC_THREADING
// Start the worker thread to actually create the connection and read the response data.
Run();
#else
ATOMIC_LOGERROR("HTTP request will not execute as threading is disabled");
#endif
}
bool ShaderVariation::Compile()
{
const String& sourceCode = owner_->GetSourceCode(type_);
Vector<String> defines = defines_.Split(' ');
// Set the entrypoint, profile and flags according to the shader being compiled
const char* entryPoint = 0;
const char* profile = 0;
unsigned flags = D3DCOMPILE_OPTIMIZATION_LEVEL3;
if (type_ == VS)
{
entryPoint = "VS";
defines.Push("COMPILEVS");
profile = "vs_3_0";
}
else
{
entryPoint = "PS";
defines.Push("COMPILEPS");
profile = "ps_3_0";
flags |= D3DCOMPILE_PREFER_FLOW_CONTROL;
}
defines.Push("MAXBONES=" + String(Graphics::GetMaxBones()));
// Collect defines into macros
Vector<String> defineValues;
PODVector<D3D_SHADER_MACRO> macros;
for (unsigned i = 0; i < defines.Size(); ++i)
{
unsigned equalsPos = defines[i].Find('=');
if (equalsPos != String::NPOS)
{
defineValues.Push(defines[i].Substring(equalsPos + 1));
defines[i].Resize(equalsPos);
}
else
defineValues.Push("1");
}
for (unsigned i = 0; i < defines.Size(); ++i)
{
D3D_SHADER_MACRO macro;
macro.Name = defines[i].CString();
macro.Definition = defineValues[i].CString();
macros.Push(macro);
// In debug mode, check that all defines are referenced by the shader code
#ifdef _DEBUG
if (sourceCode.Find(defines[i]) == String::NPOS)
ATOMIC_LOGWARNING("Shader " + GetFullName() + " does not use the define " + defines[i]);
#endif
}
D3D_SHADER_MACRO endMacro;
endMacro.Name = 0;
endMacro.Definition = 0;
macros.Push(endMacro);
// Compile using D3DCompile
ID3DBlob* shaderCode = 0;
ID3DBlob* errorMsgs = 0;
HRESULT hr = D3DCompile(sourceCode.CString(), sourceCode.Length(), owner_->GetName().CString(), ¯os.Front(), 0,
entryPoint, profile, flags, 0, &shaderCode, &errorMsgs);
if (FAILED(hr))
{
// Do not include end zero unnecessarily
compilerOutput_ = String((const char*)errorMsgs->GetBufferPointer(), (unsigned)errorMsgs->GetBufferSize() - 1);
}
else
{
if (type_ == VS)
ATOMIC_LOGDEBUG("Compiled vertex shader " + GetFullName());
else
ATOMIC_LOGDEBUG("Compiled pixel shader " + GetFullName());
// Inspect the produced bytecode using MojoShader, then strip and store it
unsigned char* bufData = (unsigned char*)shaderCode->GetBufferPointer();
unsigned bufSize = (unsigned)shaderCode->GetBufferSize();
ParseParameters(bufData, bufSize);
CopyStrippedCode(byteCode_, bufData, bufSize);
}
ATOMIC_SAFE_RELEASE(shaderCode);
ATOMIC_SAFE_RELEASE(errorMsgs);
return !byteCode_.Empty();
}
bool ShaderVariation::LoadByteCode(const String& binaryShaderName)
{
ResourceCache* cache = owner_->GetSubsystem<ResourceCache>();
if (!cache->Exists(binaryShaderName))
return false;
FileSystem* fileSystem = owner_->GetSubsystem<FileSystem>();
unsigned sourceTimeStamp = owner_->GetTimeStamp();
// If source code is loaded from a package, its timestamp will be zero. Else check that binary is not older
// than source
if (sourceTimeStamp && fileSystem->GetLastModifiedTime(cache->GetResourceFileName(binaryShaderName)) < sourceTimeStamp)
return false;
SharedPtr<File> file = cache->GetFile(binaryShaderName);
if (!file || file->ReadFileID() != "USHD")
{
ATOMIC_LOGERROR(binaryShaderName + " is not a valid shader bytecode file");
return false;
}
/// \todo Check that shader type and model match
/*unsigned short shaderType = */file->ReadUShort();
/*unsigned short shaderModel = */file->ReadUShort();
unsigned numParameters = file->ReadUInt();
for (unsigned i = 0; i < numParameters; ++i)
{
String name = file->ReadString();
unsigned reg = file->ReadUByte();
unsigned regCount = file->ReadUByte();
ShaderParameter parameter;
parameter.type_ = type_;
parameter.name_ = name;
parameter.register_ = reg;
parameter.regCount_ = regCount;
parameters_[StringHash(name)] = parameter;
}
unsigned numTextureUnits = file->ReadUInt();
for (unsigned i = 0; i < numTextureUnits; ++i)
{
/*String unitName = */file->ReadString();
unsigned reg = file->ReadUByte();
if (reg < MAX_TEXTURE_UNITS)
useTextureUnit_[reg] = true;
}
unsigned byteCodeSize = file->ReadUInt();
if (byteCodeSize)
{
byteCode_.Resize(byteCodeSize);
file->Read(&byteCode_[0], byteCodeSize);
if (type_ == VS)
ATOMIC_LOGDEBUG("Loaded cached vertex shader " + GetFullName());
else
ATOMIC_LOGDEBUG("Loaded cached pixel shader " + GetFullName());
return true;
}
else
{
ATOMIC_LOGERROR(binaryShaderName + " has zero length bytecode");
return false;
}
}