VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
VkSurfaceKHR surface, VkBool32 *pSupported) {
const auto instance_dat = *GetGlobalContext().GetInstanceData(
GetGlobalContext().GetPhysicalDeviceData(physicalDevice)->instance_);
for (uint32_t i = 0; i <= queueFamilyIndex; ++i) {
uint32_t property_count = 0;
instance_dat.vkGetPhysicalDeviceQueueFamilyProperties(
physicalDevice, &property_count, nullptr);
assert(property_count > queueFamilyIndex);
std::vector<VkQueueFamilyProperties> properties(property_count);
instance_dat.vkGetPhysicalDeviceQueueFamilyProperties(
physicalDevice, &property_count, properties.data());
if (properties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
*pSupported = (i == queueFamilyIndex);
return VK_SUCCESS;
}
}
// For now only support the FIRST graphics queue. It looks like all of
// the commands we will have to run are transfer commands, so
// we can probably get away with ANY queue (other than
// SPARSE_BINDING).
*pSupported = false;
return VK_SUCCESS;
}
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
DeviceData &dev_dat = *GetGlobalContext().GetDeviceData(device);
PhysicalDeviceData &pdd =
*GetGlobalContext().GetPhysicalDeviceData(dev_dat.physicalDevice);
InstanceData &inst_dat = *GetGlobalContext().GetInstanceData(pdd.instance_);
uint32_t property_count = 0;
inst_dat.vkGetPhysicalDeviceQueueFamilyProperties(dev_dat.physicalDevice,
&property_count, nullptr);
std::vector<VkQueueFamilyProperties> queue_properties(property_count);
inst_dat.vkGetPhysicalDeviceQueueFamilyProperties(
dev_dat.physicalDevice, &property_count, queue_properties.data());
size_t queue = 0;
for (; queue < queue_properties.size(); ++queue) {
if (queue_properties[queue].queueFlags & VK_QUEUE_GRAPHICS_BIT)
break;
}
assert(queue < queue_properties.size());
*pSwapchain = reinterpret_cast<VkSwapchainKHR>(new VirtualSwapchain(
device, queue, &pdd.physical_device_properties_, &pdd.memory_properties_,
&dev_dat, pCreateInfo, pAllocator));
return VK_SUCCESS;
}
void CreditsState::Update(){
mUpdateTime += mFrameRateDeltaTime;
if(!mStartedFinalStage){
if(mUpdateTime >= UPDATE_TIME){
if(mShowFull){
mWaitTime += mFrameRateDeltaTime;
if(mWaitTime >= WAIT_TIME){
mWaitTime = 0.f;
mUpdateTime = 0.f;
mShowFull = false;
}
}else{
mShowFull = true;
mCurrentText ++;
if(mCurrentText >= TEXT_MAX){ mStartedFinalStage = true; }
mUpdateTime = 0.f;
}
}
}else{
if(mDoneFinalStage){
GetGlobalContext().gameStateManager->Pop();
}else{
if(mTankSmasher.GetPosition().y <= ((Game::WINDOW_HEIGHT / 2) - 50)){
if(mUpdateTime >= (WAIT_TIME + UPDATE_TIME)) mDoneFinalStage = true;
}else{
mTankSmasher.Move(0, -50 * mFrameRateDeltaTime);
mUpdateTime = 0.f;
}
}
}
}
VKAPI_ATTR VkResult VKAPI_CALL
vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
// We submit to the queue the commands set up by the virtual swapchain.
// This will start a copy operation from the image to the swapchain
// buffers.
uint32_t res = VK_SUCCESS;
std::vector<VkPipelineStageFlags> pipeline_stages(
pPresentInfo->waitSemaphoreCount, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
for (size_t i = 0; i < pPresentInfo->swapchainCount; ++i) {
uint32_t image_index = pPresentInfo->pImageIndices[i];
VirtualSwapchain *swp =
reinterpret_cast<VirtualSwapchain *>(pPresentInfo->pSwapchains[i]);
VkSubmitInfo submitInfo{
VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
nullptr, // nullptr
i == 0 ? pPresentInfo->waitSemaphoreCount : 0, // waitSemaphoreCount
i == 0 ? pPresentInfo->pWaitSemaphores : nullptr, // pWaitSemaphores
i == 0 ? pipeline_stages.data() : nullptr, // pWaitDstStageMask
1, // commandBufferCount
&swp->GetCommandBuffer(image_index), // pCommandBuffers
0, // semaphoreCount
nullptr // pSemaphores
};
res |= GetGlobalContext().GetQueueData(queue)->vkQueueSubmit(
queue, 1, &submitInfo, swp->GetFence(image_index));
swp->NotifySubmitted(image_index);
}
return VkResult(res);
}
void ScriptSystem::Tick(const dtEntity::Message& m)
{
if(mGlobalTickFunction.IsEmpty())
{
return;
}
HandleScope scope;
Context::Scope context_scope(GetGlobalContext());
const dtEntity::TickMessage& msg = static_cast<const dtEntity::TickMessage&>(m);
TryCatch try_catch;
Handle<Value> argv[3] = {
Number::New(msg.GetDeltaSimTime()),
Number::New(msg.GetSimulationTime()),
Uint32::New(osg::Timer::instance()->time_m())
};
Handle<Value> ret = mGlobalTickFunction->Call(mGlobalTickFunction, 3, argv);
if(ret.IsEmpty())
{
ReportException(&try_catch);
}
}
VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents,
VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier *pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *pImageMemoryBarriers) {
std::vector<VkImageMemoryBarrier> imageBarriers(imageMemoryBarrierCount);
for (size_t i = 0; i < imageMemoryBarrierCount; ++i) {
imageBarriers[i] = pImageMemoryBarriers[i];
if (imageBarriers[i].oldLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
imageBarriers[i].oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
imageBarriers[i].srcAccessMask |= VK_ACCESS_TRANSFER_READ_BIT;
}
if (imageBarriers[i].newLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
imageBarriers[i].newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
imageBarriers[i].dstAccessMask |= VK_ACCESS_TRANSFER_READ_BIT;
}
}
PFN_vkCmdWaitEvents func =
GetGlobalContext().GetCommandBufferData(commandBuffer)->vkCmdWaitEvents;
func(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask,
memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
pBufferMemoryBarriers, imageMemoryBarrierCount, imageBarriers.data());
}
// We actually have to be able to submit data to the Queue right now.
// The user can supply either a semaphore, or a fence or both to this function.
// Because of this, once the image is available we have to submit
// a command to the queue to signal these.
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
VirtualSwapchain *swp = reinterpret_cast<VirtualSwapchain *>(swapchain);
if (!swp->GetImage(timeout, pImageIndex)) {
return timeout == 0 ? VK_NOT_READY : VK_TIMEOUT;
}
// It is important that we do not keep the lock here.
// *GetGlobalContext().GetDeviceData() only holds the lock
// for the duration of the call, if we instead do something like
// auto dat = GetGlobalContext().GetDeviceData(device),
// then the lock will be let go when dat is destroyed, which is
// AFTER swapchain::vkQueueSubmit, this would be a priority
// inversion on the locks.
DeviceData &dat = *GetGlobalContext().GetDeviceData(device);
VkQueue q;
dat.vkGetDeviceQueue(device, swp->DeviceQueue(), 0, &q);
bool has_semaphore = semaphore != VK_NULL_HANDLE;
VkSubmitInfo info{VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
nullptr, // pNext
0, // waitSemaphoreCount
nullptr, // waitSemaphores
nullptr, // waitDstStageMask
0, // commandBufferCount
nullptr, // pCommandBuffers
(has_semaphore ? 1u : 0u), // waitSemaphoreCount
(has_semaphore ? &semaphore : nullptr)};
return swapchain::vkQueueSubmit(q, 1, &info, fence);
}
Handle<Value> ScriptSystem::ExecuteJS(const std::string& code, const std::string& path)
{
// Init JavaScript context
HandleScope handle_scope;
Context::Scope context_scope(GetGlobalContext());
// We're just about to compile the script; set up an error handler to
// catch any exceptions the script might throw.
TryCatch try_catch;
// Compile the source code.
Local<Script> compiled_script = Script::Compile(ToJSString(code), ToJSString(path));
// if an exception occured
if(try_catch.HasCaught())
{
ReportException(&try_catch);
// return try_catch;
}
// Run the script!
Local<Value> ret = compiled_script->Run();
if(try_catch.HasCaught())
{
ReportException(&try_catch);
// return try_catch;
}
FetchGlobalTickFunction();
return handle_scope.Close(ret);
}
EGLBoolean EGLAPIENTRY DestroyContext(EGLDisplay dpy, EGLContext ctx)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p)", dpy, ctx);
Display *display = static_cast<Display*>(dpy);
gl::Context *context = static_cast<gl::Context*>(ctx);
Error error = ValidateContext(display, context);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
if (ctx == EGL_NO_CONTEXT)
{
SetGlobalError(Error(EGL_BAD_CONTEXT));
return EGL_FALSE;
}
if (context == GetGlobalContext())
{
SetGlobalDisplay(NULL);
SetGlobalContext(NULL);
}
display->destroyContext(context);
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
// EGL 1.4
EGLContext EGLAPIENTRY GetCurrentContext(void)
{
EVENT("()");
gl::Context *context = GetGlobalContext();
SetGlobalError(Error(EGL_SUCCESS));
return static_cast<EGLContext>(context);
}
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue,
uint32_t submitCount,
const VkSubmitInfo *pSubmits,
VkFence fence) {
// We actually DO have to lock here, we may share this queue with
// vkAcquireNextImageKHR, which is not externally synchronized on Queue.
return GetGlobalContext().GetQueueData(queue)->vkQueueSubmit(queue, submitCount,
pSubmits, fence);
}
void ScriptSystem::SetupContext()
{
HandleScope handle_scope;
if(!mGlobalContext.IsEmpty())
{
mGlobalContext.Dispose();
}
// create a template for the global object
Handle<ObjectTemplate> global = ObjectTemplate::New();
// create persistent global context
mGlobalContext = Persistent<Context>::New(Context::New(NULL, global));
// store pointer to script system into isolate data to have it globally available in javascript
Isolate::GetCurrent()->SetData(this);
RegisterGlobalFunctions(this, mGlobalContext);
RegisterPropertyFunctions(this, mGlobalContext);
InitializeAllWrappers(GetEntityManager());
Handle<Context> context = GetGlobalContext();
Context::Scope context_scope(context);
Handle<FunctionTemplate> tmplt = FunctionTemplate::New();
tmplt->InstanceTemplate()->SetInternalFieldCount(2);
tmplt->SetClassName(String::New("ScriptSystem"));
context->Global()->Set(String::New("Screen"), WrapScreen(this));
dtEntity::InputInterface* ipiface = dtEntity::GetInputInterface();
if(ipiface)
{
context->Global()->Set(String::New("Input"), WrapInputInterface(GetGlobalContext(), ipiface));
context->Global()->Set(String::New("Axis"), WrapAxes(ipiface));
context->Global()->Set(String::New("Key"), WrapKeys(ipiface));
}
context->Global()->Set(String::New("TouchPhase"), WrapTouchPhases());
context->Global()->Set(String::New("Priority"), WrapPriorities());
context->Global()->Set(String::New("Order"), WrapPriorities());
}
// EGL 1.1
EGLBoolean EGLAPIENTRY BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint buffer = %d)", dpy, surface, buffer);
Display *display = static_cast<Display*>(dpy);
Surface *eglSurface = static_cast<Surface*>(surface);
Error error = ValidateSurface(display, eglSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
if (buffer != EGL_BACK_BUFFER)
{
SetGlobalError(Error(EGL_BAD_PARAMETER));
return EGL_FALSE;
}
if (surface == EGL_NO_SURFACE || eglSurface->getWindowHandle())
{
SetGlobalError(Error(EGL_BAD_SURFACE));
return EGL_FALSE;
}
if (eglSurface->getBoundTexture())
{
SetGlobalError(Error(EGL_BAD_ACCESS));
return EGL_FALSE;
}
if (eglSurface->getTextureFormat() == EGL_NO_TEXTURE)
{
SetGlobalError(Error(EGL_BAD_MATCH));
return EGL_FALSE;
}
gl::Context *context = GetGlobalContext();
if (context)
{
gl::Texture *textureObject = context->getTargetTexture(GL_TEXTURE_2D);
ASSERT(textureObject != NULL);
if (textureObject->isImmutable())
{
SetGlobalError(Error(EGL_BAD_MATCH));
return EGL_FALSE;
}
eglSurface->bindTexImage(textureObject, buffer);
}
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
GLenum GL_APIENTRY GetGraphicsResetStatusEXT(void)
{
EVENT("()");
Context *context = GetGlobalContext();
if (context)
{
return context->getResetStatus();
}
return GL_NO_ERROR;
}
CreditsState::CreditsState(){
FontManager::FontPtr font = GetGlobalContext().fontManager->Get("Vera.ttf;40");
mText[TEXT_PROGRAMMING].SetText(" Programming\n\nDmitry skwee Kudryavtsev");
mText[TEXT_PROGRAMMING].SetFont(*font);
mText[TEXT_PROGRAMMING].SetSize(20);
mText[TEXT_PROGRAMMING].SetPosition((Game::WINDOW_WIDTH / 2) - 140, (Game::WINDOW_HEIGHT / 2) - 80);
mText[TEXT_PROGRAMMING].SetBlendMode(sf::Blend::Alpha);
mText[TEXT_MUSIC].SetText(" Background Music\n\n Megaminute\n\nComposed By Akcija");
mText[TEXT_MUSIC].SetFont(*font);
mText[TEXT_MUSIC].SetSize(20);
mText[TEXT_MUSIC].SetPosition((Game::WINDOW_WIDTH / 2) - 120, (Game::WINDOW_HEIGHT / 2) - 80);
mText[TEXT_MUSIC].SetBlendMode(sf::Blend::Alpha);
mText[TEXT_SOUND].SetText(" Sound Effects\n\nSoundBible.com");
mText[TEXT_SOUND].SetFont(*font);
mText[TEXT_SOUND].SetSize(20);
mText[TEXT_SOUND].SetPosition((Game::WINDOW_WIDTH / 2) - 100, (Game::WINDOW_HEIGHT / 2) - 80);
mText[TEXT_SOUND].SetBlendMode(sf::Blend::Alpha);
mText[TEXT_MISC].SetText(" Special Thanks\n\n Unknown Sprite Authors\n\nGameDev.ru Beta Testers");
mText[TEXT_MISC].SetFont(*font);
mText[TEXT_MISC].SetSize(20);
mText[TEXT_MISC].SetPosition((Game::WINDOW_WIDTH / 2) - 140, (Game::WINDOW_HEIGHT / 2) - 80);
mText[TEXT_MISC].SetBlendMode(sf::Blend::Alpha);
mTankSmasher.SetText("Tank Smasher");
mTankSmasher.SetFont(*GetGlobalContext().fontManager->Get("BattleCity.ttf;52"));
mTankSmasher.SetSize(42);
mTankSmasher.SetPosition(40, Game::WINDOW_HEIGHT);
mTankSmasher.SetColor(sf::Color(25, 71, 131));
mUpdateTime = mWaitTime = mFinalStageTime = 0.f;
mCurrentText = 0;
mShowFull = true;
mStartedFinalStage = mDoneFinalStage = false;
}
void CreditsState::HandleInput(const sf::Event& evt){
if(evt.Type == sf::Event::KeyReleased){
if(evt.Key.Code == sf::Key::Escape) GetGlobalContext().gameStateManager->Pop();
else if(evt.Key.Code == sf::Key::Space){
if(mStartedFinalStage) return;
mCurrentText ++;
mUpdateTime = mWaitTime = 0.f;
mShowFull = true;
if(mCurrentText >= TEXT_MAX){
mStartedFinalStage = true;
}
}
}
}
void ScriptSystem::OnLoadScript(const dtEntity::Message& m)
{
const ExecuteScriptMessage& msg = static_cast<const ExecuteScriptMessage&>(m);
HandleScope scope;
Handle<Context> context = GetGlobalContext();
Context::Scope context_scope(context);
if(msg.GetIncludeOnce())
{
ExecuteFileOnce(msg.GetPath());
}
else
{
ExecuteFile(msg.GetPath());
}
}
Context *GetValidGlobalContext()
{
gl::Context *context = GetGlobalContext();
if (context)
{
if (context->isContextLost())
{
context->recordError(gl::Error(GL_OUT_OF_MEMORY, "Context has been lost."));
return nullptr;
}
else
{
return context;
}
}
return nullptr;
}
void RegisterInstance(VkInstance instance, const InstanceData &data) {
uint32_t num_devices = 0;
data.vkEnumeratePhysicalDevices(instance, &num_devices, nullptr);
std::vector<VkPhysicalDevice> physical_devices(num_devices);
data.vkEnumeratePhysicalDevices(instance, &num_devices,
physical_devices.data());
auto physical_device_map = GetGlobalContext().GetPhysicalDeviceMap();
for (VkPhysicalDevice physical_device : physical_devices) {
PhysicalDeviceData dat{instance};
data.vkGetPhysicalDeviceMemoryProperties(physical_device,
&dat.memory_properties_);
data.vkGetPhysicalDeviceProperties(physical_device,
&dat.physical_device_properties_);
(*physical_device_map)[physical_device] = dat;
}
}
void OptionsState::HandleInput(const sf::Event& evt){
if(evt.Type == sf::Event::KeyReleased){
if(evt.Key.Code == sf::Key::Escape)
GetGlobalContext().gameStateManager->Pop();
}else if(evt.Type == sf::Event::KeyPressed){
if(evt.Key.Code == sf::Key::Down) mSelectedOption ++;
else if(evt.Key.Code == sf::Key::Up) mSelectedOption --;
else if(evt.Key.Code == sf::Key::Return){
switch(mSelectedOption){
case OPTION_MUSIC:
Game::gGameSettings.MusicOn = !Game::gGameSettings.MusicOn;
break;
case OPTION_SOUND:
Game::gGameSettings.SoundOn = !Game::gGameSettings.SoundOn;
default:
break;
}
}
}
}
void ScriptSystem::FetchGlobalTickFunction()
{
HandleScope scope;
Handle<Context> context = GetGlobalContext();
mGlobalTickFunction.Clear();
Handle<String> funcname = String::New("__executeTimeOuts");
if(context->Global()->Has(funcname))
{
Handle<Value> func = context->Global()->Get(funcname);
if(!func.IsEmpty())
{
Handle<Function> f = Handle<Function>::Cast(func);
if(!f.IsEmpty())
{
mGlobalTickFunction = Persistent<Function>::New(f);
}
}
}
}
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) {
VkRenderPassCreateInfo intercepted = *pCreateInfo;
std::vector<VkAttachmentDescription> attachments(
pCreateInfo->attachmentCount);
for (size_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
attachments[i] = pCreateInfo->pAttachments[i];
if (attachments[i].initialLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
attachments[i].initialLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
}
if (attachments[i].finalLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
attachments[i].finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
}
}
PFN_vkCreateRenderPass func =
GetGlobalContext().GetDeviceData(device)->vkCreateRenderPass;
return func(device, &intercepted, pAllocator, pRenderPass);
}
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
// It would be illegal for the program to call VkDestroyInstance here.
// We do not need to lock the map for the whole time, just
// long enough to get the data out. unordered_map guarantees that
// even if re-hashing occurs, references remain valid.
VkPhysicalDeviceProperties &properties =
GetGlobalContext()
.GetPhysicalDeviceData(physicalDevice)
->physical_device_properties_;
pSurfaceCapabilities->minImageCount = 1;
pSurfaceCapabilities->maxImageCount = 0;
pSurfaceCapabilities->currentExtent = {0xFFFFFFFF, 0xFFFFFFFF};
pSurfaceCapabilities->minImageExtent = {1, 1};
pSurfaceCapabilities->maxImageExtent = {
properties.limits.maxImageDimension2D,
properties.limits.maxImageDimension2D};
pSurfaceCapabilities->maxImageArrayLayers =
properties.limits.maxImageArrayLayers;
pSurfaceCapabilities->supportedTransforms =
VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
// TODO(awoloszyn): Handle all of the transforms eventually
pSurfaceCapabilities->currentTransform =
VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
pSurfaceCapabilities->supportedCompositeAlpha =
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
// TODO(awoloszyn): Handle all of the composite types.
pSurfaceCapabilities->supportedUsageFlags =
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
// TODO(awoloszyn): Find a good set of formats that we can use
// for rendering.
return VK_SUCCESS;
}
void ScriptSystem::LoadAutoStartScripts(const std::string& path)
{
HandleScope handle_scope;
Handle<Context> global = GetGlobalContext();
Context::Scope context_scope(global);
std::set<std::string> executed;
osgDB::FilePathList paths = osgDB::getDataFilePathList();
for(osgDB::FilePathList::iterator i = paths.begin(); i != paths.end(); ++i)
{
std::ostringstream autostartpath;
autostartpath << *i << "/" << path;
osgDB::FilePathList currentPathList;
currentPathList.push_back(autostartpath.str());
const std::string absPath = dtEntity::GetSystemInterface()->FindDataFile(autostartpath.str());
if(!dtEntity::GetSystemInterface()->FileExists(absPath))
{
continue;
}
osgDB::DirectoryContents contents = osgDB::getDirectoryContents(absPath);
osgDB::DirectoryContents::const_iterator j;
for(j = contents.begin(); j != contents.end(); ++j)
{
std::string filepath = *j;
if(osgDB::getFileExtension(filepath).compare("js") != 0) continue;
if(executed.find(filepath) == executed.end())
{
ExecuteFile(path + "/" + filepath);
executed.insert(filepath);
}
}
}
}
Local<Value> ScriptSystem::ExecuteFile(const std::string& path)
{
HandleScope handle_scope;
Handle<Script> script = GetScriptFromFile(path);
if(!script.IsEmpty())
{
v8::Context::Scope context_scope(GetGlobalContext());
TryCatch try_catch;
Local<Value> ret = script->Run();
FetchGlobalTickFunction();
if(try_catch.HasCaught())
{
ReportException(&try_catch);
return Local<Value>();
}
return handle_scope.Close(ret);
}
return Local<Value>();
}
Handle<Script> ScriptSystem::GetScriptFromFile(const std::string& path)
{
std::string code;
bool success = GetFileContents(path, code);
if(!success)
{
LOG_ERROR("Could not load script file from " + path);
return Handle<Script>();
}
HandleScope handle_scope;
Context::Scope context_scope(GetGlobalContext());
TryCatch try_catch;
Local<Script> compiled_script = Script::Compile(ToJSString(code), ToJSString(path));
if(try_catch.HasCaught())
{
ReportException(&try_catch);
return Handle<Script>();
}
return handle_scope.Close(compiled_script);
}
EGLBoolean EGLAPIENTRY Terminate(EGLDisplay dpy)
{
EVENT("(EGLDisplay dpy = 0x%0.8p)", dpy);
Display *display = static_cast<Display *>(dpy);
if (dpy == EGL_NO_DISPLAY || !Display::isValidDisplay(display))
{
SetGlobalError(Error(EGL_BAD_DISPLAY));
return EGL_FALSE;
}
gl::Context *context = GetGlobalContext();
if (display->isValidContext(context))
{
SetGlobalContext(NULL);
SetGlobalDisplay(NULL);
}
display->terminate();
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
OptionsState::OptionsState(){
mNormalTextColor = sf::Color(25, 71, 131);
mSelectedTextColor = sf::Color(255, 255, 255);
FontManager::FontPtr font = GetGlobalContext().fontManager->Get("BattleCity.ttf;52");
mTitle.SetText("Options");
mTitle.SetFont(*font);
mTitle.SetSize(42);
mTitle.SetColor(mNormalTextColor);
mTitle.Move(150, 20);
mOptions[OPTION_MUSIC].SetText("Music");
mOptions[OPTION_MUSIC].SetFont(*font);
mOptions[OPTION_MUSIC].SetSize(24);
//mOptions[OPTION_MUSIC].SetColor(mNormalTextColor);
mOptions[OPTION_MUSIC].Move(20, 100);
//mOptionValues[OPTION_MUSIC].SetText();
mOptionValues[OPTION_MUSIC].SetFont(*font);
mOptionValues[OPTION_MUSIC].SetSize(24);
//mOptionValues[OPTION_MUSIC].SetColor(mNormalTextColor);
mOptionValues[OPTION_MUSIC].Move(500, 100);
mOptions[OPTION_SOUND].SetText("Sound");
mOptions[OPTION_SOUND].SetFont(*font);
mOptions[OPTION_SOUND].SetSize(24);
//mOptions[OPTION_MUSIC].SetColor(mNormalTextColor);
mOptions[OPTION_SOUND].Move(20, 140);
//mOptionValues[OPTION_MUSIC].SetText();
mOptionValues[OPTION_SOUND].SetFont(*font);
mOptionValues[OPTION_SOUND].SetSize(24);
//mOptionValues[OPTION_MUSIC].SetColor(mNormalTextColor);
mOptionValues[OPTION_SOUND].Move(500, 140);
}
EGLBoolean EGLAPIENTRY MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface draw = 0x%0.8p, EGLSurface read = 0x%0.8p, EGLContext ctx = 0x%0.8p)",
dpy, draw, read, ctx);
Display *display = static_cast<Display*>(dpy);
gl::Context *context = static_cast<gl::Context*>(ctx);
// If ctx is EGL_NO_CONTEXT and either draw or read are not EGL_NO_SURFACE, an EGL_BAD_MATCH
// error is generated.
if (ctx == EGL_NO_CONTEXT && (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
{
SetGlobalError(Error(EGL_BAD_MATCH));
return EGL_FALSE;
}
if (ctx != EGL_NO_CONTEXT && draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE)
{
SetGlobalError(Error(EGL_BAD_MATCH));
return EGL_FALSE;
}
// If either of draw or read is a valid surface and the other is EGL_NO_SURFACE, an
// EGL_BAD_MATCH error is generated.
if ((read == EGL_NO_SURFACE) != (draw == EGL_NO_SURFACE))
{
SetGlobalError(Error(
EGL_BAD_MATCH, "read and draw must both be valid surfaces, or both be EGL_NO_SURFACE"));
return EGL_FALSE;
}
if (dpy == EGL_NO_DISPLAY || !Display::isValidDisplay(display))
{
SetGlobalError(Error(EGL_BAD_DISPLAY, "'dpy' not a valid EGLDisplay handle"));
return EGL_FALSE;
}
// EGL 1.5 spec: dpy can be uninitialized if all other parameters are null
if (!display->isInitialized() && (ctx != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
{
SetGlobalError(Error(EGL_NOT_INITIALIZED, "'dpy' not initialized"));
return EGL_FALSE;
}
if (ctx != EGL_NO_CONTEXT)
{
Error error = ValidateContext(display, context);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
if (display->isInitialized())
{
if (display->testDeviceLost())
{
display->notifyDeviceLost();
return EGL_FALSE;
}
if (display->isDeviceLost())
{
SetGlobalError(Error(EGL_CONTEXT_LOST));
return EGL_FALSE;
}
}
Surface *drawSurface = static_cast<Surface*>(draw);
if (draw != EGL_NO_SURFACE)
{
Error error = ValidateSurface(display, drawSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
Surface *readSurface = static_cast<Surface*>(read);
if (read != EGL_NO_SURFACE)
{
Error error = ValidateSurface(display, readSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
if (readSurface)
{
Error readCompatError = ValidateCompatibleConfigs(readSurface->getConfig(), context->getConfig(), readSurface->getType());
if (readCompatError.isError())
{
SetGlobalError(readCompatError);
return EGL_FALSE;
}
}
if (draw != read)
{
UNIMPLEMENTED(); // FIXME
if (drawSurface)
{
Error drawCompatError = ValidateCompatibleConfigs(drawSurface->getConfig(), context->getConfig(), drawSurface->getType());
if (drawCompatError.isError())
{
SetGlobalError(drawCompatError);
return EGL_FALSE;
}
}
}
Error makeCurrentError = display->makeCurrent(drawSurface, readSurface, context);
if (makeCurrentError.isError())
{
SetGlobalError(makeCurrentError);
return EGL_FALSE;
}
gl::Context *previousContext = GetGlobalContext();
SetGlobalDisplay(display);
SetGlobalDrawSurface(drawSurface);
SetGlobalReadSurface(readSurface);
SetGlobalContext(context);
// Release the surface from the previously-current context, to allow
// destroyed surfaces to delete themselves.
if (previousContext != nullptr && context != previousContext)
{
previousContext->releaseSurface();
}
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
EGLBoolean EGLAPIENTRY MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{
EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface draw = 0x%0.8p, EGLSurface read = 0x%0.8p, EGLContext ctx = 0x%0.8p)",
dpy, draw, read, ctx);
Display *display = static_cast<Display*>(dpy);
gl::Context *context = static_cast<gl::Context*>(ctx);
bool noContext = (ctx == EGL_NO_CONTEXT);
bool noSurface = (draw == EGL_NO_SURFACE || read == EGL_NO_SURFACE);
if (noContext != noSurface)
{
SetGlobalError(Error(EGL_BAD_MATCH));
return EGL_FALSE;
}
if (dpy == EGL_NO_DISPLAY)
{
SetGlobalError(Error(EGL_BAD_DISPLAY, "'dpy' not a valid EGLDisplay handle"));
return EGL_FALSE;
}
// EGL 1.5 spec: dpy can be uninitialized if all other parameters are null
if (dpy != EGL_NO_DISPLAY && !display->isInitialized() &&
(ctx != EGL_NO_CONTEXT || draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE))
{
SetGlobalError(Error(EGL_NOT_INITIALIZED, "'dpy' not initialized"));
return EGL_FALSE;
}
if (ctx != EGL_NO_CONTEXT)
{
Error error = ValidateContext(display, context);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
if (dpy != EGL_NO_DISPLAY && display->isInitialized())
{
if (display->testDeviceLost())
{
display->notifyDeviceLost();
return EGL_FALSE;
}
if (display->isDeviceLost())
{
SetGlobalError(Error(EGL_CONTEXT_LOST));
return EGL_FALSE;
}
}
Surface *drawSurface = static_cast<Surface*>(draw);
if (draw != EGL_NO_SURFACE)
{
Error error = ValidateSurface(display, drawSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
Surface *readSurface = static_cast<Surface*>(read);
if (read != EGL_NO_SURFACE)
{
Error error = ValidateSurface(display, readSurface);
if (error.isError())
{
SetGlobalError(error);
return EGL_FALSE;
}
}
if (draw != read)
{
UNIMPLEMENTED(); // FIXME
}
gl::Context *previousContext = GetGlobalContext();
SetGlobalDisplay(display);
SetGlobalDrawSurface(drawSurface);
SetGlobalReadSurface(readSurface);
SetGlobalContext(context);
display->makeCurrent(drawSurface, readSurface, context);
// Release the surface from the previously-current context, to allow
// destroyed surfaces to delete themselves.
if (previousContext != nullptr && context != previousContext)
{
previousContext->releaseSurface();
}
SetGlobalError(Error(EGL_SUCCESS));
return EGL_TRUE;
}
