【ANT】構建文件build.xml

 

• 運行ant：

ant 使用當前目錄下的build.xml運行ant，指定缺省的target;

ant –buildfile mybuild.xml 使用當前目錄下的mybuild.xml運行ant，並執行缺省的target；

ant –buildfile mybuild.xml mytarget使用當前目錄下mybuild.xml運行ant，並執行名為mytarget的target;

• 編寫build.xml

1. project
   

   例如：

   <project name="Cesium" default="combine">

   屬性：

   name : 項目名稱

   default:指定運行的target名稱，沒有指定時使用缺省的target；

   basedir：基准路徑，其他的相對路徑都是基於這個基准路徑的；

   description:項目描述信息。 

2. target
   

   <target name="combine" depends="build,combineJavaScript" description="Combines all source files into a single stand-alone script." />

   注意：一個target可以依賴於其他target。例如combine依賴於build target和combineJaveScript target，ant會按照depends中target出現的順序依次執行，並且每個target只會被執行依次，即使有多個target依賴於他。

   target有以下屬性：

   name：target名稱，這個屬性是必須的；

   depends：依賴目標，非必須

   if：當屬性設置時才執行該target，非必須；

   unless：當屬性沒有設置時才執行該target，非必須；

   description：target的描述信息，非必須；

3. task

   Task分為內置task和自定義task，每個task都是一段可執行的代碼。

   1.  內置task：
      

      <copy file="${requirejsPath}/require.min.js" tofile="${cesiumViewerOutputDirectory}/require.js" />

   2. 自定義task
      

      調用任務：

      <glslToJavascript minify="${build.minification}" minifystatefile="${buildDirectory}/minifyShaders.state">
      
          <glslfiles dir="${shadersDirectory}" includes="**/*.glsl" />
      
          <existingjsfiles dir="${shadersDirectory}" includes="**/*.js" excludes="*.profile.js" />
      
      </glslToJavascript>

      定義任務：

      <scriptdef name="glslToJavascript" language="javascript" src="${tasksDirectory}/glslToJavaScript.js" manager="bsf" classpathref="javascriptClassPath" loaderref="javascript.loader">
      
                  <attribute name="minify" />
      
                  <attribute name="minifystatefile" />
      
                  <element name="glslfiles" type="fileset" />
      
                  <element name="existingjsfiles" type="fileset" />
      
      </scriptdef>

      這是glslToJavaScript.js源代碼：

      /*global importClass,project,attributes,elements,java,Packages*/
      importClass(Packages.org.mozilla.javascript.tools.shell.Main); /*global Main*/
      Main.exec(['-e', '{}']);
      var load = Main.global.load;
      
      load(project.getProperty('tasksDirectory') + '/shared.js'); /*global forEachFile,readFileContents,writeFileContents,File,FileReader,FileWriter,FileUtils*/
      
      importClass(java.io.StringReader); /*global StringReader*/
      importClass(java.util.HashSet); /*global HashSet*/
      importClass(Packages.org.apache.tools.ant.filters.StripJavaComments); /*global StripJavaComments*/
      
      var minify = /^true$/.test(attributes.get('minify'));
      
      var minifyStateFilePath = attributes.get('minifystatefile');
      writeFileContents(minifyStateFilePath, minify);
      
      var minifyStateFileLastModified = new File(minifyStateFilePath).lastModified();
      
      // collect all currently existing JS files into a set, later we will remove the ones
      // we still are using from the set, then delete any files remaining in the set.
      var leftOverJsFiles = new HashSet();
      
      forEachFile('existingjsfiles', function(relativePath, file) {
          "use strict";
          leftOverJsFiles.add(file.getAbsolutePath());
      });
      
      var builtinFunctions = [];
      var builtinConstants = [];
      var builtinStructs = [];
      
      forEachFile('glslfiles', function(relativePath, file) {
          "use strict";
          var glslFile = file;
          var jsFile = new File(file.getParent(), file.getName().replace('.glsl', '.js'));
      
          // identify built in functions, structs, and constants
          if(glslFile.getPath().indexOf('Builtin' + File.separator + 'Functions') !== -1) {
              builtinFunctions.push(file.getName().replace('.glsl', ''));
          }
          else if(glslFile.getPath().indexOf('Builtin' + File.separator + 'Constants') !== -1) {
              builtinConstants.push(file.getName().replace('.glsl', ''));
          }
          else if(glslFile.getPath().indexOf('Builtin' + File.separator + 'Structs') !== -1) {
              builtinStructs.push(file.getName().replace('.glsl', ''));
          }
      
          leftOverJsFiles.remove(jsFile.getAbsolutePath());
      
          if (jsFile.exists() && jsFile.lastModified() > glslFile.lastModified() && jsFile.lastModified() > minifyStateFileLastModified) {
              return;
          }
      
          var contents = readFileContents(glslFile);
          contents = contents.replace(/\r\n/gm, '\n');
      
          var copyrightComments = '';
          var extractedCopyrightComments = contents.match(/\/\*\*(?:[^*\/]|\*(?!\/)|\n)*?@license(?:.|\n)*?\*\//gm);
          if (extractedCopyrightComments) {
              copyrightComments = extractedCopyrightComments.join('\n') + '\n';
          }
      
          if (minify) {
              contents = String(FileUtils.readFully(new StripJavaComments(new StringReader(contents))));
              contents = contents.replace(/\s+$/gm, '').replace(/^\s+/gm, '').replace(/\n+/gm, '\n');
              contents += '\n';
          }
      
          contents = contents.split('"').join('\\"').replace(/\n/gm, '\\n\\\n');
          contents = copyrightComments + '\
          //This file is automatically rebuilt by the Cesium build process.\n\
          /*global define*/\n\
          define(function() {\n\
          "use strict";\n\
          return "' + contents + '";\n\
      });';
      
          writeFileContents(jsFile.getAbsolutePath(), contents, true);
      });
      
      // delete any left over JS files from old shaders
      for ( var it = leftOverJsFiles.iterator(); it.hasNext();) {
          new File(it.next())['delete']();
      }
      
      var generateBuiltinContents = function(contents, builtins, path){
          "use strict";
          var amdPath = contents.amdPath;
          var amdClassName = contents.amdClassName;
          var builtinLookup = contents.builtinLookup;
          for (var i = 0; i < builtins.length; i++) {
              var builtin = builtins[i];
              amdPath = amdPath + ',\n        \'./' + path + '/' + builtin + '\'';
              amdClassName = amdClassName + ',\n        ' + 'czm_' + builtin;
              builtinLookup = builtinLookup + ',\n        ' + 'czm_' + builtin + ' : ' + 'czm_' + builtin;
          }
          contents.amdPath = amdPath;
          contents.amdClassName = amdClassName;
          contents.builtinLookup = builtinLookup;
      };
      
      //generate the JS file for Built-in GLSL Functions, Structs, and Constants
      var contents = {amdPath:'', amdClassName:'', builtinLookup:''};
      generateBuiltinContents(contents, builtinConstants, 'Constants');
      generateBuiltinContents(contents, builtinStructs, 'Structs');
      generateBuiltinContents(contents, builtinFunctions, 'Functions');
      
      contents.amdPath = contents.amdPath.replace(',\n', '');
      contents.amdClassName = contents.amdClassName.replace(',\n', '');
      contents.builtinLookup = contents.builtinLookup.replace(',\n', '');
      
      var fileContents = '\
      //This file is automatically rebuilt by the Cesium build process.\n\
      /*global define*/\n\
      define([\n' +
      contents.amdPath +
      '\n    ], function(\n' +
      contents.amdClassName +
      ') {\n\
          "use strict";\n\
          return {\n' + contents.builtinLookup + '};\n\
      });';
      
      var builtinFile = new File(project.getProperty('shadersDirectory') + '/Builtin', 'CzmBuiltins.js');
      writeFileContents(builtinFile.getAbsolutePath(), fileContents, true);

      Scriptdef使用腳本語言定義一個ant task，ant scripting languanges支持BSF引擎和JSR_223引擎來定義腳本。

      屬性：

      name : 任務名稱，必需；

      language ： 腳本語言，必須被BSF或者JSR引擎支持，必須；

      manager ： BSF或者JSR引擎；

      src ：執行任務的腳本路徑

      uri ： xml 命名空間；

      classpath ： script引入的class的classpath路徑

      classpathref ： 使用refid引入classpath；

      loaderfef ： 加載script的loader，從指定的classpath來構造