build/scripts/dali_env

   1 #!/usr/bin/perl
   2
   3 # Copyright (c) 2024 Samsung Electronics Co., Ltd.
   4
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8
   9 # http://www.apache.org/licenses/LICENSE-2.0
  10
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 use Config;
  18 use Cwd;
  19 use Cwd 'abs_path';
  20 use File::Basename;
  21 use File::Path;
  22 use File::Copy;
  23 use File::Copy::Recursive qw(dircopy);
  24 use strict;
  25 use Getopt::Long;
  26 use Pod::Usage;
  27
  28 ################################################################################
  29 #                                SYSTEM PACKAGES                               #
  30 ################################################################################
  31 # Add any required system packages to this list - if they are not present, then
  32 # this script will attempt to install them for you.
  33 my @system_packages = (
  34     "automake",
  35     "cmake",
  36     "g++",
  37     "pkg-config",
  38     "libtool",
  39     "ccache",
  40     "libexif-dev",
  41     "libgles2-mesa-dev",
  42     "libdrm-dev",
  43     "libgif-dev",
  44     "libturbojpeg",
  45     "libturbojpeg0-dev",
  46     "libfribidi-dev",
  47     "libharfbuzz-dev",
  48     "libhyphen-dev",
  49     "doxygen",
  50     "lcov",
  51     "libcurl4-gnutls-dev",
  52     "curl",
  53     "libssl-dev",
  54     "cifs-utils",
  55     "libgtest-dev",
  56     "libcairo2-dev",
  57     "libopencv-dev",
  58     "gettext",
  59     "libwebp-dev",
  60     "libmagick++-dev",
  61 );
  62
  63 my $ubuntu_version = (split(/\s+/, `lsb_release -d`))[2];
  64 if (${ubuntu_version} > 20)
  65 {
  66     # Add unique packages for 20.04 and above
  67     push @system_packages, "libefl-all-dev";
  68 }
  69 else
  70 {
  71     # Add unique packages for Ubuntu releases before 20.04
  72     push @system_packages, "libelementary-dev";
  73 }
  74
  75 # Some packages like require building from source
  76 # v8 is currently disabled until we can get it working without a http proxy being setup
  77 my @source_pkgs = (
  78
  79     {"name" => "disabled-v8",
  80      "force-rebuild" => 0,
  81      "use_depot_tools" => 1,
  82      "repo" => "https://chromium.googlesource.com/v8/v8.git",
  83      "depot_tools_repo" => "https://chromium.googlesource.com/chromium/tools/depot_tools.git",
  84
  85      # original version used with DALi is 3.25.19. 3.32.7 is the latest we can use before
  86      # upgrading DALi to use  c++0x or c++11
  87      "version" => " 3.32.7", "make" => "make -j8 library=shared", "build-mode" =>"debug" },
  88     {"name" => "gtest" },
  89 );
  90
  91 ### Detect any http proxy, part of v8 installation requires this information
  92 my $http_proxy_port;
  93 my $http_proxy_ip;
  94
  95 if( exists $ENV{http_proxy} )
  96 {
  97   # string  split into 3 items  http, //ip, port
  98   my @http_proxy_info =  split( /:/,$ENV{http_proxy}, );
  99
 100   $http_proxy_ip =  @http_proxy_info[1];
 101   $http_proxy_ip =~ s/[\/]//g;;  # remove forward slashes
 102   $http_proxy_port =  @http_proxy_info[2];
 103 }
 104
 105 # Make best guess as to where this program was run from (note, it is
 106 # always possible to override the location of $0 by the calling
 107 # program, so we can't really tell for sure that this is where we
 108 # expect it to be. :/
 109
 110 my $new_env   = 0;
 111 my $exec_path = $0;
 112 if($0 !~ m!^/!)
 113 {
 114     $exec_path = abs_path($0);
 115 }
 116 $exec_path = dirname($exec_path);
 117
 118 my $root_path = getcwd();
 119
 120 # Search for the root dali-env directory
 121 if($exec_path =~ m!dali-env/opt/bin!)
 122 {
 123     # We are using the installed dali_env script
 124
 125     $root_path = $exec_path;
 126     while(basename($root_path) ne "dali-env" && $root_path ne "")
 127     {
 128         $root_path = dirname($root_path);
 129     }
 130 }
 131 elsif($root_path =~ m!dali-env$! or $root_path =~ m!dali-env/!)
 132 {
 133     # We are NOT using the installed dali_env script
 134     # Find dali-env root from current directory
 135
 136     while(basename($root_path) ne "dali-env" && $root_path ne "")
 137     {
 138         $root_path = dirname($root_path);
 139     }
 140 }
 141 else
 142 {
 143     # dali-env root dir should be in the current directory
 144
 145     $root_path .= "/dali-env";
 146
 147     if(! -e $root_path)
 148     {
 149       # Creating a new dali-env
 150
 151       $new_env = 1;
 152     }
 153 }
 154
 155 my $src_path         = "$root_path/src-packages";
 156 my $sbs_path         = "$root_path/target";
 157 my $install_path     = "$root_path/opt";
 158
 159 my $opt_create=0;
 160 my $opt_force;
 161 my $opt_envfile="setenv";
 162 my $opt_setenv=0;
 163 my $opt_help=0;
 164 my $opt_man=0;
 165 my $opt_vk_version="1.3.280.1";
 166 my $opt_vulkan;
 167 my $VULKAN_ENV="";
 168
 169 GetOptions("create"     => \$opt_create,
 170            "envfile=s"  => \$opt_envfile,
 171            "force"      => \$opt_force,
 172            "setenv"     => \$opt_setenv,
 173            "help"       => \$opt_help,
 174            "vulkan:s"   => \$opt_vulkan,
 175            "man"        => \$opt_man) or pod2usage(2);
 176
 177 pod2usage(1) if $opt_help;
 178 pod2usage(-exitstatus => 0, -verbose => 2) if $opt_man;
 179
 180 if($opt_vulkan ne "")
 181 {
 182     $opt_vk_version=$opt_vulkan;
 183 }
 184
 185 ################################################################################
 186
 187 sub create_env
 188 {
 189     mkpath("$install_path/bin");
 190     mkpath("$install_path/lib/pkgconfig");
 191     mkpath("$install_path/include");
 192     mkpath("$install_path/share/aclocal");
 193     mkpath("$src_path");
 194     mkpath("$sbs_path");
 195
 196     copy($0, "$install_path/bin/dali_env");
 197     chmod(0755, "$install_path/bin/dali_env");
 198 }
 199
 200 ################################################################################
 201
 202 sub in_dali_env
 203 {
 204     my $cwd = substr(getcwd(), 0, length($root_path));
 205     #print "cwd = $cwd\nroot = $root_path\n";
 206     return $cwd eq $root_path;
 207 }
 208
 209 ################################################################################
 210
 211 sub create_setenv
 212 {
 213     my $oldfh;
 214     my $fh;
 215     if($opt_envfile)
 216     {
 217         print "Writing environment script to $opt_envfile\n";
 218         open($fh, ">", $opt_envfile)|| die "Can't open $opt_envfile for writing:$!\n";
 219         $oldfh = select($fh);
 220     }
 221     print <<"EOF";
 222 #
 223 # To use the desktop libraries, please add the following lines to your .bashrc or
 224 # create a setenv script from them, e.g. by running this command as follows
 225 # \$ $install_path/bin/dali_env -s > setenv
 226 #
 227 # You can then source this script by using
 228 # \$ . setenv
 229 #
 230 # Use DESKTOP_PREFIX when running configure or cmake in dali/build/tizen:
 231 # \$ CXXFLAGS="-g -O0" ./configure --prefix=\$DESKTOP_PREFIX
 232 # _OR_
 233 # \$ CXXFLAGS="-g -O0" cmake -DCMAKE_INSTALL_PREFIX=\$DESKTOP_PREFIX
 234
 235 ${VULKAN_ENV}
 236 export DESKTOP_PREFIX=$install_path
 237 export PATH=$install_path/bin:\$PATH
 238 export LD_LIBRARY_PATH=$install_path/lib:\$LD_LIBRARY_PATH
 239 export INCLUDEDIR=$install_path/include
 240 export PKG_CONFIG_PATH=$install_path/lib/pkgconfig:/usr/lib/pkgconfig:/usr/share/pkgconfig
 241 export DOTNET_CLI_TELEMETRY_OPTOUT=1
 242 export DALI_MULTI_SAMPLING_LEVEL=4
 243 export DALI_WINDOW_WIDTH=480
 244 export DALI_WINDOW_HEIGHT=800
 245
 246 EOF
 247     if($opt_envfile)
 248     {
 249         close($fh);
 250         select($oldfh);
 251     }
 252 }
 253
 254 ################################################################################
 255
 256 sub install_vulkan
 257 {
 258     if($opt_vulkan)
 259     {
 260         my $archive="vulkansdk-linux-x86_64-${opt_vk_version}.tar.xz";
 261         my $url="https://sdk.lunarg.com/sdk/download/${opt_vk_version}/linux/$archive";
 262
 263         # Avoid excessive downloading of the same file
 264         if(! -e "/tmp/$archive")
 265         {
 266             print "Downloading Vulkan SDK version ${opt_vk_version}\nfrom: $url\n";
 267             system('wget','-P','/tmp',$url);
 268             die "Can't download archive" if(! -e "/tmp/$archive");
 269         }
 270
 271         my $vulkan_install_path="$root_path/vulkan";
 272         print "Unpacking archive\n";
 273         mkpath($vulkan_install_path);
 274         chdir($vulkan_install_path);
 275         system('tar','-xf',"/tmp/$archive", '--checkpoint=5000', '--checkpoint-action=ttyout=.');
 276         print("\n");
 277         chdir("$root_path/..");
 278
 279         my $fh;
 280         open($fh, ">", "$install_path/lib/pkgconfig/vulkan.pc") || die "Can't open vulkan.pc for writing: $!\n";
 281
 282         $vulkan_install_path .= "/${opt_vk_version}";
 283         print $fh <<"EOF";
 284 prefix=${vulkan_install_path}/x86_64
 285 exec_prefix=${vulkan_install_path}/x86_64
 286 libdir=\${prefix}/lib
 287 includedir=\${prefix}/include
 288
 289 Name: Vulkan-Loader
 290 Description: Vulkan Loader
 291 Version: ${opt_vk_version}
 292 Libs: -L\${libdir} -lvulkan
 293 Libs.private:  -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc
 294 Cflags: -I\${includedir}
 295 EOF
 296         close($fh);
 297
 298         open($fh, ">", "$install_path/lib/pkgconfig/glslang.pc") || die "Can't open glslang.pc for writing: $!\n";
 299         print $fh <<"EOF";
 300 prefix=${vulkan_install_path}/x86_64
 301 exec_prefix=${vulkan_install_path}/x86_64
 302 libdir=\${prefix}/lib
 303 includedir=\${prefix}/include
 304
 305 Name: glslang
 306 Description: OpenGL and OpenGL ES shader front end and validator
 307 Version: ${opt_vk_version}
 308 Libs: -L\${libdir} -lglslang -lOSDependent -lHLSL -lOGLCompiler -lSPVRemapper -lshaderc -lshaderc_combined
 309 Cflags: -I\${includedir}
 310 EOF
 311         close($fh);
 312
 313         open($fh, ">", "$install_path/lib/pkgconfig/SPIRV-Tools.pc") || die "Can't open SPIRV-Tools.pc for writing: $!\n";
 314         print $fh <<"EOF";
 315 prefix=${vulkan_install_path}/x86_64
 316 exec_prefix=${vulkan_install_path}/x86_64
 317 libdir=\${prefix}/lib
 318 includedir=\${prefix}/include
 319
 320 Name: SPIRV-Tools
 321 Description: Tools for SPIR-V
 322 Version: ${opt_vk_version}
 323 Libs: -L\${libdir} -lSPIRV-Tools -lSPIRV-Tools-link -lSPIRV-Tools-opt
 324 Cflags: -I\${includedir}
 325 EOF
 326         close($fh);
 327
 328         $VULKAN_ENV=<<"EOF";
 329 export VULKAN_VERSION=${opt_vk_version}
 330 export VULKAN_ROOT=${root_path}/vulkan/\${VULKAN_VERSION}
 331 . \${VULKAN_ROOT}/setup-env.sh
 332 EOF
 333         print "Written pkg-config files to $install_path/lib/pkg-config\n";
 334     }
 335 }
 336
 337 sub check_system_package
 338 {
 339     my $package;
 340     foreach $package (@_)
 341     {
 342         my @x=split(/\s+/, `dpkg -l $package 2> /dev/null|grep $package`);
 343         if($x[0] ne "ii")
 344         {
 345             # Check if the package is available to install, exit-code is 0 if the package is found.
 346             if(system("apt-cache show $package > /dev/null 2>&1") == 0)
 347             {
 348                 print "Attempting to install $package\n";
 349                 system("sudo apt-get -y --allow-change-held-packages --allow-downgrades install $package");
 350             }
 351         }
 352     }
 353 }
 354
 355 sub check_system_packages
 356 {
 357     print "Checking for required system packages (may require sudo password)\n";
 358
 359     check_system_package(@system_packages);
 360
 361     my $gnome_v =`dpkg -l gnome-common| tail -1| sed "s/ \\+/ /g" | cut -d' ' -f 3`;
 362     my @am = split(/\./, `automake --version | head -1 | cut -f4 -d' '`);
 363     if($gnome_v =~ /$2.24/ && $am[1]>10)
 364     {
 365         die "Gnome common and automake are not compatible - automake is too new\n";
 366     }
 367     my @gpp_v = (`g++ --version  | head -1` =~ /(\d+)\.(\d+)\.(\d+)/);
 368
 369     if(! (($gpp_v[0] > 4)
 370           ||
 371           ($gpp_v[0] == 4 && $gpp_v[1] > 4)
 372           ||
 373           ($gpp_v[0] == 4 && $gpp_v[1] == 4 && $gpp_v[2] >= 5)))
 374     {
 375         die "You need g++ 4.5.1 or greater to build dali\n";
 376     }
 377 }
 378
 379 sub check_source_packages
 380 {
 381     my $pkgref;
 382
 383     foreach $pkgref (@source_pkgs)
 384     {
 385         my $pkg = $pkgref->{"name"};
 386         if($pkg eq "v8")
 387         {
 388             install_v8( $pkgref );
 389         }
 390         elsif ($pkg eq "gtest")
 391         {
 392             if(! -e "/usr/lib/libgtest.a")
 393             {
 394                 print "Attempting to build $pkg\n";
 395                 # from https://www.eriksmistad.no/getting-started-with-google-test-on-ubuntu/
 396                 run_command("cd /usr/src/gtest; sudo cmake CMakeLists.txt; sudo make; sudo cp *.a /usr/lib; cd -;");
 397             }
 398         }
 399     }
 400 }
 401
 402 ################################################################################
 403
 404 sub create_link
 405 {
 406     my $arch=`uname -i`;
 407     $arch =~ s/\r|\n//g;
 408
 409     my $link = "/usr/lib/$arch-linux-gnu/libturbojpeg.so";
 410
 411     unless (-e $link)
 412     {
 413        print "Creating libjpegturbo symbolic link\n";
 414        system("sudo ln -s $link.0 $link");
 415     }
 416 }
 417
 418 ################################################################################
 419 # Helper to run and print out the command being run and quit if it fails
 420 #
 421 sub run_command
 422 {
 423   my $command = $_[0];
 424   my $ret;
 425   print("Running: $command\n");
 426   $ret = system("$command");
 427   if($ret >> 8) { die "$command failed \n"; }
 428 }
 429
 430 ################################################################################
 431 # later versions of v8 (post mid 2014) require googles depot_tools to build.
 432 #
 433 sub install_google_depot_tools
 434 {
 435
 436 ####
 437 # clone the depo_tools into the source directory and set the path up
 438 ####
 439     my $v8 = $_[0];
 440
 441     my $depot_tools_directory = $src_path . "/depot_tools";
 442     my $depot_tools_repo = $v8->{"depot_tools_repo"};
 443
 444     # clear the directory if exists
 445     rmtree( $depot_tools_directory );
 446
 447     # clone the depot tools
 448     run_command( "git clone " . $depot_tools_repo. " " . $depot_tools_directory );
 449
 450     # add it the the path
 451     $ENV{PATH} = "$ENV{PATH}:$depot_tools_directory";
 452
 453     # need to setup a config file for the proxy
 454     create_boto_config_file( $v8 , $depot_tools_directory );
 455
 456     # set the config location as an environment variable ( used by scripts depot_tools)
 457     $ENV{NO_AUTH_BOTO_CONFIG}="$src_path/depot_tools/.boto";
 458
 459     # change to depot tools directory
 460     chdir( $depot_tools_directory );
 461
 462     # fetch v8
 463     run_command("fetch --nohooks v8");
 464
 465 }
 466
 467
 468 ################################################################################
 469 # later versions of v8 use boto, which currently requires having proxy manually set
 470 #
 471 sub create_boto_config_file
 472 {
 473     my $v8 = $_[0];
 474     my $depot_tools_directory = $_[1];
 475     print(" depot_tools directory = $depot_tools_directory\n");
 476
 477     print("Configuring boto with http proxy IP = ". $http_proxy_ip . ", Port = " . $http_proxy_port . "\n");
 478
 479 # Create the proxy info for the boto file
 480 my $fileContents = <<"END";
 481 [Boto]
 482 debug = 0
 483 num_retries = 2
 484
 485 proxy = $http_proxy_ip
 486 proxy_port = $http_proxy_port
 487 END
 488       # Place the config file in the depot tools folder
 489     my $filename = $depot_tools_directory . "/" . ".boto";
 490     print("Creating Boto config file with proxy settings to file ". $filename . "\n");
 491     my $fh;
 492     open( $fh, '>',  $filename );
 493     print { $fh } $fileContents;
 494     close( $fh );
 495
 496     # export the environment variable
 497     run_command("gclient config https://gclient.googlecode.com/svn/trunk/gclient");
 498
 499     run_command("gclient runhooks");
 500
 501
 502
 503 }
 504 ################################################################################
 505 # We need a specific version of V8 to work with DALi
 506 # - Check a txt file in dali-env to see if v8 needs upgrading (checks gcc version too)
 507 # - Clones the source
 508 # - builds dependencies (v8 automatically clones it's GYP build system)
 509 # - Builds it
 510 # - Create a package file
 511 # It is cloned, then built from source, we create a package file for it, then
 512 # it's copied into dali-env
 513 sub install_v8
 514 {
 515     my $v8 = $_[0];
 516     my $ret;
 517     my $v8Version = $v8->{"version"};
 518     print( "Checking if V8 ". $v8Version. " is installed \n");
 519
 520 ####
 521 # Check currently installed version
 522 # We create a text file with v8 and gcc version in the filename to compare with
 523 # Version file is stored as "v8_2.3.4_installed_built_with_gcc_4_8_3.txt"
 524 ####
 525     # get the gcc version, so if the compiler is updated v8 is re-built
 526     # note: v8 requires gcc version GCC >= 4.6
 527     my $gccVersion = `gcc --version | grep ^gcc | sed 's/^.* //g'`;
 528     chomp( $gccVersion );
 529     my $versionTextFile = $src_path . "/v8_" . $v8Version. "_" . $v8->{"build-mode"} . "_installed_built_with_gcc_". $gccVersion .".txt";
 530
 531     # use stat to see if file exists
 532     my @install_stats = stat $versionTextFile;
 533     if( (scalar(@install_stats)) && $v8->{"force-rebuild"} != 1 )
 534     {
 535       print("Correct V8 version installed\n");
 536       return;
 537     }
 538     else
 539     {
 540       # delete older versions of the version file first ( otherwise when downgrading it thinks version is still installed)
 541       system( "rm " . $src_path . "/v8_*.txt  >/dev/null 2>&1");
 542     }
 543
 544
 545 ####
 546 # Clone the v8 source repository and checkout the version we want
 547 ####
 548     # Need to clone it from repo
 549     my $v8_source_directory;
 550
 551
 552
 553     # newer version of v8 use depot_tools with gclient, git cloned builds do not work
 554     if( $v8->{"use_depot_tools"} == 1)
 555     {
 556       install_google_depot_tools( $v8 );
 557
 558       # v8 is checkout out under depot_tools path
 559       $v8_source_directory = $src_path . "/depot_tools/v8";
 560     }
 561     else
 562     {
 563       $v8_source_directory = $src_path . "/v8";
 564
 565       # delete the old v8 source directpry if exists
 566       rmtree( $v8_source_directory );
 567
 568       # clone the repository
 569       run_command( "git clone " . $v8->{"repo"} . " " . $v8_source_directory );
 570     }
 571
 572     # change to the source directoy for the checkout
 573     chdir( $v8_source_directory );
 574
 575     # checkout the version DALi is compatible with
 576     run_command( "git checkout ". $v8Version );
 577
 578 ####
 579 # Run make dependencies then make for the specific target
 580 ####
 581     if( $v8->{"use_depot_tools"} == 1)
 582     {
 583       run_command("gclient sync");
 584     }
 585     else
 586     {
 587       run_command("make dependencies");
 588     }
 589
 590     # assemble the make command
 591     my $makeCommand = $v8->{"make"};
 592
 593     # need to append architecture and build mode, e.g. x64.debug
 594     my $buildTarget;
 595     if( $Config{use64bitint} ) {
 596        print("Building 64 bit version of V8\n");
 597        $buildTarget= "x64." . $v8->{"build-mode"}
 598     }
 599     else{
 600       print("Building 32 bit version of V8\n");
 601        $buildTarget= "ia32." . $v8->{"build-mode"}
 602     }
 603     $makeCommand .= " " . $buildTarget;
 604     print("Running: $makeCommand\n");
 605     run_command( $makeCommand );
 606
 607 ####
 608 # Manually install the library / header files
 609 ####
 610
 611     # Need to manually install (make install not available on v8 )
 612     my $libSourceDir = "$v8_source_directory/out/$buildTarget/lib.target/";
 613     my $headerSourceDir = "$v8_source_directory/include/";
 614
 615     my $libDestinationDir = $install_path . "/lib/";
 616     my $headerDestinationDir = $install_path . "/include/v8/";
 617
 618     # delete any current v8 libs
 619     system( "rm " . $libDestinationDir . "libv8*");
 620     system( "rm " . $libDestinationDir . "libicu*");
 621
 622
 623     # copy the library and header files
 624     dircopy( $libSourceDir, $libDestinationDir);
 625     dircopy( $headerSourceDir, $headerDestinationDir);
 626
 627
 628     # Copy libv8.so to libv8.so.version (  e.g. libv8.so.1.2.4)
 629     my $v8SoFile = $libDestinationDir . "libv8.so";
 630     my $v8SoVersionFile = $libDestinationDir . "libv8.so." . $v8Version;
 631     move( $v8SoFile, $v8SoVersionFile );
 632
 633     # symlink the libv8.so.1.2.3 to libv8.so
 634     symlink( $v8SoVersionFile, $v8SoFile );
 635     print( "source dir = " . $libSourceDir . " dest dir ". $libDestinationDir . " \n" );
 636
 637
 638 ####
 639 # Create the package file in,
 640 # we keep the library files and header files in v8 sub-directories
 641 ####
 642 my $fileContents = <<"END";
 643 prefix=$install_path
 644 exec_prefix=\${prefix}
 645 apiversion=$v8Version
 646 libdir=\${exec_prefix}/lib
 647 includedir=\${prefix}/include/v8
 648
 649 Name: v8 JavaScript engine - runtime library
 650 Description: V8 is Google's open source JavaScript engine.
 651 Version: \${apiversion}
 652 Libs: -L\${libdir} -lv8 -licuuc -licui18n
 653 Cflags: -I\${includedir}
 654 END
 655
 656   my $filename = $install_path . "/lib/pkgconfig/" . "v8.pc";
 657   print("writing to file ". $filename . "\n");
 658   my $fh;
 659   if( open( $fh, '>',  $filename ) )
 660   {
 661     print { $fh } $fileContents;
 662     close( $fh );
 663   }
 664   else
 665   {
 666     die "failed to create " . $filename ."\n";
 667   }
 668
 669   print("Installed V8 " .$v8Version . " OK\n");
 670
 671 #####
 672 #
 673 ####
 674       my $versionFile;
 675       open( $versionFile, '>',  $versionTextFile );
 676       close( $versionFile );
 677       print("Installing V8 version $v8Version\n");
 678
 679 }
 680
 681 ################################################################################
 682 #                                       MAIN
 683 ################################################################################
 684
 685
 686 if($opt_create)
 687 {
 688     my $new_root = getcwd() . "/dali-env";
 689
 690     if($exec_path =~ m!dali-env/opt/bin!)
 691     {
 692         die "Already in a dali-env directory\n";
 693         # Could query if user wants to re-create?
 694     }
 695     elsif(-e $root_path && !$opt_force)
 696     {
 697         die "$root_path already exists\n";
 698     }
 699     elsif(-e $new_root && !$opt_force)
 700     {
 701         die "A dali-env directory already exists here\n";
 702     }
 703     if($opt_force)
 704     {
 705         system('rm','-rf',"$root_path");
 706     }
 707
 708     #check_system_packages();
 709
 710     create_link();
 711
 712     create_env();
 713
 714     # do this after source directory structure created in create_env
 715     #check_source_packages();
 716
 717     install_vulkan();
 718     create_setenv();
 719 }
 720 elsif($opt_setenv)
 721 {
 722     if(! -d $root_path)
 723     {
 724         die "$root_path does not exist\n";
 725     }
 726     elsif($new_env)
 727     {
 728         die "$root_path is not an existing environment\n";
 729     }
 730     create_setenv();
 731 }
 732 else
 733 {
 734     pod2usage(1);
 735 }
 736
 737 __END__
 738
 739 =head1 NAME
 740
 741 dali_env - Create the DALi environment for Ubuntu
 742
 743 =head1 SYNOPSIS
 744
 745 dali_env [-c] [-s] [-h|-m]
 746
 747 =head1 OPTIONS
 748
 749 =over 28
 750
 751 =item B<-c|--create>
 752
 753 Create a DALi environment directory in the current directory.
 754
 755 =item B<-f|--force>
 756
 757 Removes any existing dali-env directory before creating a new one.
 758
 759 =item B<-s|--setenv>
 760
 761 Display environment variables to setup.
 762
 763 =item B<-e|--envfile> environment-file
 764
 765 Write the environment settings to the given file
 766
 767 =item B<-v|--vulkan> [vulkan-option]
 768
 769 Install the Vulkan SDK (By default, uses 1.3.280.1) with the optional version
 770 number. Adds several .pc files into dali-env/opt/lib/pkg-config directory,
 771 and requires a new environment file to be written.
 772
 773 =item B<-h|--help>
 774
 775 Display this help
 776
 777 =item B<-m|--man>
 778
 779 Display the manual page
 780
 781 =back
 782
 783 =head1 DESCRIPTION
 784
 785 B<dali_env>
 786
 787 Gets the required dependencies for DALi and installs them to a local directory. Can also create a setenv script to point to the installation.
 788
 789 =cut