bool FKDevelopSourceCodeAccessor::OpenSourceFiles(const TArray<FString>& AbsoluteSourcePaths)
{
if (IsIDERunning())
{
// use qdbus
STUBBED("OpenSourceFiles: KDevelop is running, use qdbus");
return false;
}
STUBBED("FKDevelopSourceCodeAccessor::OpenSourceFiles");
return false;
}
static bool createWebsocketContext(int port) {
assert(!wsState);
wsState = new WSState;
struct lws_context_creation_info info;
memset(&info, 0, sizeof(info));
if (port == PORT_ANY) {
info.port = CONTEXT_PORT_NO_LISTEN;
} else {
info.port = port;
}
info.protocols = protocols;
info.gid = -1;
info.uid = -1;
STUBBED("TODO: put keepalive stuff in cvars");
info.ka_time = 5;
info.ka_probes = 3;
info.ka_interval = 1;
wsState->websocketContext = libwebsocket_create_context(&info);
if (!wsState->websocketContext) {
delete wsState;
wsState = NULL;
return false;
}
int retval = libwebsocket_service(wsState->websocketContext, 0);
Com_Printf("libwebsocket_service returned %d\n", LOG_NET, retval);
return true;
}
bool FLinuxTargetDevice::GetUserCredentials( FString& OutUserName, FString& OutUserPassword )
{
STUBBED("FLinuxTargetDevice::GetUserCredentials");
OutUserName = UserName;
OutUserPassword = UserPassword;
return true;
}
bool FLinuxTargetDevice::TerminateProcess( const int64 ProcessId )
{
#if PLATFORM_LINUX // if running natively, just terminate the local process
// get process path from the ProcessId
const int32 ReadLinkSize = 1024;
char ReadLinkCmd[ReadLinkSize] = {0};
FCStringAnsi::Sprintf(ReadLinkCmd, "/proc/%lld/exe", ProcessId);
char ProcessPath[ MAX_PATH + 1 ] = {0};
int32 Ret = readlink(ReadLinkCmd, ProcessPath, ARRAY_COUNT(ProcessPath) - 1);
if (Ret != -1)
{
struct stat st;
uid_t euid;
stat(ProcessPath, &st);
euid = geteuid(); // get effective uid of current application, as this user is asking to kill a process
// now check if we own the process
if (st.st_uid == euid)
{
// terminate it (will this terminate children as well because we set their pgid?)
kill(ProcessId, SIGTERM);
sleep(2); // sleep in case process still remains then send a more strict signal
kill(ProcessId, SIGKILL);
return true;
}
}
#else
// @todo: support remote termination
STUBBED("FLinuxTargetDevice::TerminateProcess");
#endif // PLATFORM_LINUX
return false;
}
bool FLinuxTargetDevice::Deploy( const FString& SourceFolder, FString& OutAppId )
{
#if PLATFORM_LINUX // if running natively, support simplified, local deployment
OutAppId = TEXT("");
FString PlatformName = TEXT("Linux");
FString DeploymentDir = FPaths::EngineIntermediateDir() / TEXT("Devices") / PlatformName;
// delete previous build
IFileManager::Get().DeleteDirectory(*DeploymentDir, false, true);
// copy files into device directory
TArray<FString> FileNames;
IFileManager::Get().FindFilesRecursive(FileNames, *SourceFolder, TEXT("*.*"), true, false);
for (int32 FileIndex = 0; FileIndex < FileNames.Num(); ++FileIndex)
{
const FString& SourceFilePath = FileNames[FileIndex];
FString DestFilePath = DeploymentDir + SourceFilePath.RightChop(SourceFolder.Len());
IFileManager::Get().Copy(*DestFilePath, *SourceFilePath);
}
return true;
#else
// @todo: support deployment to a remote machine
STUBBED("FLinuxTargetDevice::Deploy");
return false;
#endif // PLATFORM_LINUX
}
// prepares pixel format for OpenGL context
BOOL CGfxLibrary::SetupPixelFormat_OGL( HDC hdc, BOOL bReport/*=FALSE*/)
{
SDL_Window *window = (SDL_Window *) hdc;
const DisplayDepth dd = gl_dmCurrentDisplayMode.dm_ddDepth;
// clamp depth/stencil values
extern INDEX gap_iDepthBits;
extern INDEX gap_iStencilBits;
if( gap_iDepthBits <12) gap_iDepthBits = 0;
else if( gap_iDepthBits <22) gap_iDepthBits = 16;
else if( gap_iDepthBits <28) gap_iDepthBits = 24;
else gap_iDepthBits = 32;
if( gap_iStencilBits<3) gap_iStencilBits = 0;
else if( gap_iStencilBits<7) gap_iStencilBits = 4;
else gap_iStencilBits = 8;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, (dd != DD_16BIT) ? 8 : 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, (dd != DD_16BIT) ? 8 : 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, (dd != DD_16BIT) ? 8 : 5);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, gap_iDepthBits);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, gap_iStencilBits);
STUBBED("co-opt the existing T-buffer support for multisampling?");
//SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, x);
//SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, y);
return TRUE;
}
bool FLinuxTargetDevice::Launch( const FString& AppId, EBuildConfigurations::Type BuildConfiguration, EBuildTargets::Type BuildTarget, const FString& Params, uint32* OutProcessId )
{
#if PLATFORM_LINUX // if running natively, support launching in place
// build executable path
FString PlatformName = TEXT("Linux");
FString ExecutablePath = FPaths::EngineIntermediateDir() / TEXT("Devices") / PlatformName / TEXT("Engine") / TEXT("Binaries") / PlatformName;
if (BuildTarget == EBuildTargets::Game)
{
ExecutablePath /= TEXT("UE4Game");
}
else if (BuildTarget == EBuildTargets::Server)
{
ExecutablePath /= TEXT("UE4Server");
}
else if (BuildTarget == EBuildTargets::Editor)
{
ExecutablePath /= TEXT("UE4Editor");
}
if (BuildConfiguration != EBuildConfigurations::Development)
{
ExecutablePath += FString::Printf(TEXT("-%s-%s"), *PlatformName, EBuildConfigurations::ToString(BuildConfiguration));
}
// launch the game
FProcHandle ProcessHandle = FPlatformProcess::CreateProc(*ExecutablePath, *Params, true, false, false, OutProcessId, 0, NULL, NULL);
return ProcessHandle.Close();
#else
// @todo: support launching on a remote machine
STUBBED("FLinuxTargetDevice::Launch");
return false;
#endif // PLATFORM_LINUX
}
bool FDesktopPlatformLinux::OpenProject(const FString &ProjectFileName)
{
// Get the project filename in a native format
FString PlatformProjectFileName = ProjectFileName;
FPaths::MakePlatformFilename(PlatformProjectFileName);
STUBBED("FDesktopPlatformLinux::OpenProject");
return false;
}
void SCRIPT_GetDouble
(
int32 scripthandle,
char * sectionname,
char * entryname,
double * number
)
{
STUBBED("GetDouble");
}
/*
==============
=
= SCRIPT_PutRaw
=
==============
*/
void SCRIPT_PutRaw
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * entryname,
uint8_t * raw
)
{
STUBBED("PutRaw");
}
/*
==============
=
= SCRIPT_GetBoolean
=
==============
*/
void SCRIPT_GetBoolean
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * entryname,
boolean * b
)
{
STUBBED("GetBoolean");
}
void FIntroTutorials::HandleCompilerNotFound()
{
#if PLATFORM_WINDOWS
LaunchTutorialByName( TEXT( "Engine/Tutorial/Installation/InstallingVisualStudioTutorial.InstallingVisualStudioTutorial" ) );
#elif PLATFORM_MAC
LaunchTutorialByName( TEXT( "Engine/Tutorial/Installation/InstallingXCodeTutorial.InstallingXCodeTutorial" ) );
#else
STUBBED("FIntroTutorials::HandleCompilerNotFound");
#endif
}
/*
==============
=
= SCRIPT_PutMultiComment
=
==============
*/
void SCRIPT_PutMultiComment
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * comment,
...
)
{
STUBBED("PutMultiComment");
}
void SCRIPT_PutDouble
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * entryname,
double number,
boolean defaultvalue
)
{
STUBBED("PutDouble");
}
bool FLinuxTargetDevice::Run( const FString& ExecutablePath, const FString& Params, uint32* OutProcessId )
{
#if PLATFORM_LINUX // if running natively, support simplified, local deployment
FProcHandle ProcessHandle = FPlatformProcess::CreateProc(*ExecutablePath, *Params, true, false, false, OutProcessId, 0, NULL, NULL);
return ProcessHandle.Close();
#else
// @todo: support remote run
STUBBED("FLinuxTargetDevice::Run");
return false;
#endif // PLATFORM_LINUX
}
void FLinuxPlatformProcess::TerminateProc( FProcHandle & ProcessHandle, bool KillTree )
{
if (KillTree)
{
// TODO: enumerate the children
STUBBED("FLinuxPlatformProcess::TerminateProc() : Killing a subtree is not implemented yet");
}
int KillResult = kill(ProcessHandle.Get(), SIGTERM); // graceful
check(KillResult != -1 || errno != EINVAL);
}
static std::unique_ptr<Connection> createConnection(const netadr_t &to) {
assert(wsState);
char addrBuf[3 * 4 + 5];
snprintf(addrBuf, sizeof(addrBuf), "%u.%u.%u.%u", to.ip[0], to.ip[1], to.ip[2], to.ip[3]);
struct libwebsocket *newWsi = libwebsocket_client_connect(wsState->websocketContext, addrBuf, ntohs(to.port), 0, "/", addrBuf, addrBuf, "quake2", -1);
if (newWsi == NULL) {
STUBBED("TODO: log connection create failure");
return std::unique_ptr<Connection>();
}
libwebsocket_callback_on_writable(wsState->websocketContext, newWsi);
STUBBED("TODO: unnecessary(?) libwebsocket_service");
libwebsocket_service(wsState->websocketContext, 0);
std::unique_ptr<Connection> conn(new Connection(to, newWsi));
wsState->wsiLookup.emplace(newWsi, conn.get());
return conn;
}
bool Connection::sendPacket(const char *data, size_t length) {
assert(socket > 0);
assert(readyState == Open);
STUBBED("TODO: allocate from sendBuf from heap, keep permanently"); // connection-specific?
char sendBuf[2 + length];
assert(length < 16384);
uint16_t l16 = length;
memcpy(&sendBuf[0], &l16, 2);
memcpy(&sendBuf[2], data, length);
return (q2wsSend(socket, &sendBuf[0], length + 2) >= 0);
}
static void websocketShutdown() {
assert(wsState);
wsState->connections.clear();
// destroying all the connections must have cleared these
assert(wsState->socketLookup.empty());
assert(wsState->pendingData.empty());
STUBBED("clean up javascript side");
delete wsState;
wsState = NULL;
}
bool FKDevelopSourceCodeAccessor::OpenFileAtLine(const FString& FullPath, int32 LineNumber, int32 ColumnNumber)
{
// column & line numbers are 1-based, so dont allow zero
if(LineNumber == 0)
{
LineNumber++;
}
if(ColumnNumber == 0)
{
ColumnNumber++;
}
// Automatically fail if there's already an attempt in progress
if (IsIDERunning())
{
// use qdbus
STUBBED("OpenFileAtLine: KDevelop is running, use qdbus");
return false;
}
STUBBED("FKDevelopSourceCodeAccessor::OpenFileAtLine");
return false;
}
/// This is tricky as we use our screen as both input and output
void PostAAPreRenderOperator::execute(const Camera& camera, GFX::CommandBuffer& bufferInOut) {
STUBBED("ToDo: Move PostAA to compute shaders to avoid a blit and RT swap. -Ionut");
RenderTargetHandle ldrTarget = _parent.outputRT();
PipelineDescriptor pipelineDescriptor;
pipelineDescriptor._stateHash = _context.get2DStateBlock();
pipelineDescriptor._shaderProgramHandle = (_useSMAA ? _smaa : _fxaa)->getID();
GFX::BindPipelineCommand pipelineCmd;
pipelineCmd._pipeline = _context.newPipeline(pipelineDescriptor);
GFX::EnqueueCommand(bufferInOut, pipelineCmd);
GFX::BlitRenderTargetCommand blitRTCommand;
blitRTCommand._source = ldrTarget._targetID;
blitRTCommand._destination = _samplerCopy._targetID;
blitRTCommand._blitColours.emplace_back();
GFX::EnqueueCommand(bufferInOut, blitRTCommand);
TextureData data0 = _samplerCopy._rt->getAttachment(RTAttachmentType::Colour, 0).texture()->getData();
GFX::BindDescriptorSetsCommand descriptorSetCmd;
descriptorSetCmd._set._textureData.setTexture(data0, to_U8(ShaderProgram::TextureUsage::UNIT0));
GFX::EnqueueCommand(bufferInOut, descriptorSetCmd);
// Apply FXAA/SMAA to the specified render target
GFX::BeginRenderPassCommand beginRenderPassCmd;
beginRenderPassCmd._target = ldrTarget._targetID;
beginRenderPassCmd._name = "DO_POSTAA_PASS";
GFX::EnqueueCommand(bufferInOut, beginRenderPassCmd);
GenericDrawCommand pointsCmd;
pointsCmd._primitiveType = PrimitiveType::API_POINTS;
pointsCmd._drawCount = 1;
GFX::SendPushConstantsCommand pushConstantsCommand;
pushConstantsCommand._constants = _fxaaConstants;
GFX::EnqueueCommand(bufferInOut, pushConstantsCommand);
GFX::DrawCommand drawCmd;
drawCmd._drawCommands.push_back(pointsCmd);
GFX::EnqueueCommand(bufferInOut, drawCmd);
GFX::EndRenderPassCommand endRenderPassCmd;
GFX::EnqueueCommand(bufferInOut, endRenderPassCmd);
}
bool Connection::sendPacket(const char *data, size_t length) {
assert(wsi);
assert(readyState == Open);
assert(length < 16384);
uint16_t l16 = length;
memcpy(&sendBuf[LWS_SEND_BUFFER_PRE_PADDING], &l16, 2);
memcpy(&sendBuf[LWS_SEND_BUFFER_PRE_PADDING + 2], data, length);
// TODO: too many calls to libwebsocket_service here
libwebsocket_service(wsState->websocketContext, 0);
if (!writable) {
// track socket writable status, only write when would not block
// TODO: buffer or drop?
return false;
}
int retval = libwebsocket_write(wsi, &sendBuf[LWS_SEND_BUFFER_PRE_PADDING], length + 2, LWS_WRITE_BINARY);
if (retval < 0) {
return false;
}
writable = false;
libwebsocket_callback_on_writable(wsState->websocketContext, wsi);
libwebsocket_service(wsState->websocketContext, 0);
if (retval < length) {
// partial send
// TODO: handle this better, try to resend rest later
STUBBED("resend");
return false;
}
return true;
}
bool FLinuxTargetDevice::Reboot( bool bReconnect)
{
STUBBED("FLinuxTargetDevice::Reboot");
return false;
}
int32 FLinuxTargetDevice::GetProcessSnapshot( TArray<FTargetDeviceProcessInfo>& OutProcessInfos )
{
STUBBED("FLinuxTargetDevice::GetProcessSnapshot");
return 0;
}
void FSourceControlModule::ShowLoginDialog(const FSourceControlLoginClosed& InOnSourceControlLoginClosed, ELoginWindowMode::Type InLoginWindowMode, EOnLoginWindowStartup::Type InOnLoginWindowStartup)
{
#if SOURCE_CONTROL_WITH_SLATE
// Get Active Provider Name
ActiveProviderName = GetProvider().GetName().ToString();
// if we are showing a modal version of the dialog & a modeless version already exists, we must destroy the modeless dialog first
if(InLoginWindowMode == ELoginWindowMode::Modal && SourceControlLoginPtr.IsValid())
{
// unhook the delegate so it doesn't fire in this case
SourceControlLoginWindowPtr->SetOnWindowClosed(FOnWindowClosed());
SourceControlLoginWindowPtr->RequestDestroyWindow();
SourceControlLoginWindowPtr = NULL;
SourceControlLoginPtr = NULL;
}
if(SourceControlLoginWindowPtr.IsValid())
{
SourceControlLoginWindowPtr->BringToFront();
}
else
{
// set provider to 'none'.
// When we open the window, we turn off the fact that source control is available, this solves issues that are present with
// being a three state modeless system (Accepted settings, disabled, and not yet decided).
if(InOnLoginWindowStartup == EOnLoginWindowStartup::ResetProviderToNone)
{
SetProvider("None");
}
// temporarily disable access to source control features
bTemporarilyDisabled = true;
// Create the window
SourceControlLoginWindowPtr = SNew(SWindow)
.Title( LOCTEXT("SourceControlLoginTitle", "Source Control Login") )
.HasCloseButton(false)
.SupportsMaximize(false)
.SupportsMinimize(false)
.SizingRule( ESizingRule::Autosized );
// Set the closed callback
SourceControlLoginWindowPtr->SetOnWindowClosed(FOnWindowClosed::CreateRaw(this, &FSourceControlModule::OnSourceControlDialogClosed));
// Setup the content for the created login window.
SourceControlLoginWindowPtr->SetContent(
SNew(SBox)
.WidthOverride(700.0f)
[
SAssignNew(SourceControlLoginPtr, SSourceControlLogin)
.ParentWindow(SourceControlLoginWindowPtr)
.OnSourceControlLoginClosed(InOnSourceControlLoginClosed)
]
);
TSharedPtr<SWindow> RootWindow = FGlobalTabmanager::Get()->GetRootWindow();
if(RootWindow.IsValid())
{
if(InLoginWindowMode == ELoginWindowMode::Modal)
{
FSlateApplication::Get().AddModalWindow(SourceControlLoginWindowPtr.ToSharedRef(), RootWindow);
}
else
{
FSlateApplication::Get().AddWindowAsNativeChild(SourceControlLoginWindowPtr.ToSharedRef(), RootWindow.ToSharedRef());
}
}
else
{
if(InLoginWindowMode == ELoginWindowMode::Modal)
{
FSlateApplication::Get().AddModalWindow(SourceControlLoginWindowPtr.ToSharedRef(), RootWindow);
}
else
{
FSlateApplication::Get().AddWindow(SourceControlLoginWindowPtr.ToSharedRef());
}
}
}
#else
STUBBED("FSourceControlModule::ShowLoginDialog - no Slate");
#endif // SOURCE_CONTROL_WITH_SLATE
}
bool FKDevelopSourceCodeAccessor::IsIDERunning()
{
// FIXME: implement
STUBBED("FKDevelopSourceCodeAccessor::IsIDERunning");
return false;
}
void FLinuxTargetDevice::SetUserCredentials( const FString& InUserName, const FString& InUserPassword )
{
STUBBED("FLinuxTargetDevice::SetUserCredentials");
UserName = InUserName;
UserPassword = InUserPassword;
}
bool FLinuxTargetDevice::SupportsSdkVersion( const FString& VersionString ) const
{
STUBBED("FLinuxTargetDevice::SupportsSdkVersion");
return true;
}
bool FKDevelopSourceCodeAccessor::SaveAllOpenDocuments() const
{
STUBBED("FKDevelopSourceCodeAccessor::SaveAllOpenDocuments");
return false;
}
bool FKDevelopSourceCodeAccessor::OpenSolution()
{
if (IsIDERunning())
{
// use qdbus to open the project within session?
STUBBED("OpenSolution: KDevelop is running, use qdbus to open the project within session?");
return false;
}
FString Solution = GetSolutionPath();
FString IDEPath;
if (!CanRunKDevelop(IDEPath))
{
UE_LOG(LogKDevelopAccessor, Warning, TEXT("FKDevelopSourceCodeAccessor::OpenSourceFiles: cannot find kdevelop binary"));
return false;
}
FProcHandle Proc = FPlatformProcess::CreateProc(*IDEPath, *Solution, true, false, false, nullptr, 0, nullptr, nullptr);
if (Proc.IsValid())
{
FPlatformProcess::CloseProc(Proc);
return true;
}
return false;
}
