⬆️

Kotlin 1.2.41

Author: elect86

build.gradle

@@ -9,7 +9,7 @@ group = 'com.github.kotlin-graphics'
 
 buildscript {
 
-    ext.kotlinVersion = '1.2.40'
+    ext.kotlinVersion = '1.2.41'
 
     repositories {
         jcenter()
@@ -33,9 +33,9 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
     implementation "org.jetbrains.kotlin:kotlin-reflect"
 
-    implementation 'com.github.kotlin-graphics:uno-sdk:f97f9853e6158a86550268b63ad2800e0e08737f'
+    implementation 'com.github.kotlin-graphics:uno-sdk:6db5c2919e60af45389b5f255d1c0a29c29f7ef6'
 
-    testCompile 'io.kotlintest:kotlintest-runner-junit5:3.0.6'
+    testCompile 'io.kotlintest:kotlintest-runner-junit5:3.0.5'
 
     implementation 'io.github.microutils:kotlin-logging:1.4.6'
 
@@ -65,13 +65,15 @@ dependencies {
     implementation "org.lwjgl:lwjgl-openal:${lwjglVersion}"
     implementation "org.lwjgl:lwjgl-opengl:${lwjglVersion}"
     implementation "org.lwjgl:lwjgl-stb:${lwjglVersion}"
+    implementation "org.lwjgl:lwjgl-tootle:$lwjglVersion"
 
     testRuntime "org.lwjgl:lwjgl:${lwjglVersion}:${lwjglNatives}"
     testRuntime "org.lwjgl:lwjgl-glfw:${lwjglVersion}:${lwjglNatives}"
     testRuntime "org.lwjgl:lwjgl-jemalloc:${lwjglVersion}:${lwjglNatives}"
     testRuntime "org.lwjgl:lwjgl-openal:${lwjglVersion}:${lwjglNatives}"
     testRuntime "org.lwjgl:lwjgl-opengl:${lwjglVersion}:${lwjglNatives}"
     testRuntime "org.lwjgl:lwjgl-stb:${lwjglVersion}:${lwjglNatives}"
+    testRuntime "org.lwjgl:lwjgl-tootle:$lwjglVersion:$lwjglNatives"
 }
 
 repositories {

src/main/kotlin/assimp/Importer.kt

@@ -43,6 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 package assimp
 
 import assimp.format.ProgressHandler
+import assimp.postProcess.OptimizeMeshes
+import assimp.postProcess.ValidateDSProcess
 import glm_.BYTES
 import glm_.i
 import glm_.size
@@ -320,7 +322,7 @@ constructor() {
             if (!ASSIMP.NO.VALIDATEDS_PROCESS)
             // The ValidateDS process is an exception. It is executed first, even before ScenePreprocessor is called.
                 if (flags has Pps.ValidateDataStructure) {
-                    ValidateDSProcess.executeOnScene(this)
+                    ValidateDSProcess().executeOnScene(this)
                     if (impl.scene == null) return null
                 }
             // Preprocess the scene and prepare it for post-processing
@@ -409,11 +411,11 @@ constructor() {
         /*  The ValidateDS process plays an exceptional role. It isn't contained in the global list of post-processing
             steps, so we need to call it manually.         */
             if (flags has Pps.ValidateDataStructure) {
-                ValidateDSProcess.executeOnScene(this)
+                ValidateDSProcess().executeOnScene(this)
                 if (impl.scene == null) return null
             }
         if (flags has Pps.OptimizeMeshes) {
-            OptimizeMeshes.executeOnScene(this)
+            OptimizeMeshes().executeOnScene(this)
             if (impl.scene == null) return null
         }
         var flags = flags
@@ -445,7 +447,7 @@ constructor() {
                 // If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
                 if (impl.extraVerbose) {
                     logger.debug { "Verbose Import: revalidating data structures" }
-                    ValidateDSProcess.executeOnScene(this)
+                    ValidateDSProcess().executeOnScene(this)
                     if (impl.scene == null) {
                         logger.error { "Verbose Import: failed to revalidate data structures" }
                         break
@@ -472,7 +474,7 @@ constructor() {
             // The ValidateDS process plays an exceptional role. It isn't contained in the global
             // list of post-processing steps, so we need to call it manually.
             if (requestValidation) {
-                ValidateDSProcess.executeOnScene(this)
+                ValidateDSProcess().executeOnScene(this)
                 if (impl.scene == null) return null
             }
         }
@@ -492,7 +494,7 @@ constructor() {
         // If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
         if (impl.extraVerbose || requestValidation) {
             logger.debug { "Verbose Import: revalidating data structures" }
-            ValidateDSProcess.executeOnScene(this)
+            ValidateDSProcess().executeOnScene(this)
             if (impl.scene == null)
                 logger.error { "Verbose Import: failed to revalidate data structures" }
         }

src/main/kotlin/assimp/assimp.kt

@@ -10,15 +10,15 @@ val logger = KotlinLogging.logger {}
 fun Mat4.decompose(pScaling: AiVector3D, pRotation: AiQuaternion, pPosition: AiVector3D) {
 
     /* extract translation */
-    pPosition.x = this[0][3]
-    pPosition.y = this[1][3]
-    pPosition.z = this[2][3]
+    pPosition[0] = this[0][3]
+    pPosition[1] = this[1][3]
+    pPosition[2] = this[2][3]
 
     /* extract the columns of the matrix. */
     val vCols = listOf(
-            AiVector3D(this[0][0], this[1][0], this[2][0]),
-            AiVector3D(this[0][1], this[1][1], this[2][1]),
-            AiVector3D(this[0][2], this[1][2], this[2][2]))
+            AiVector3D(this[0, 0], this[1, 0], this[2, 0]),
+            AiVector3D(this[0, 1], this[1, 1], this[2, 1]),
+            AiVector3D(this[0 ,2], this[1, 2], this[2, 2]))
 
     /* extract the scaling factors */
     pScaling.x = vCols[0].length

src/main/kotlin/assimp/camera.kt

@@ -43,6 +43,7 @@ package assimp
 
 import glm_.BYTES
 import glm_.f
+import glm_.glm
 import glm_.mat4x4.Mat4
 import glm_.vec3.Vec3
 
@@ -129,7 +130,7 @@ class AiCamera(
          *  line of the screen and the left or right border.
          *  The default value is 1/4PI.
          */
-        var horizontalFOV: Float = .25f * Math.PI.f, // TODO glm
+        var horizontalFOV: Float = .25f * glm.PIf,
 
         /** Distance of the near clipping plane from the camera.
          *

src/main/kotlin/assimp/defs.kt

@@ -91,9 +91,9 @@ val String.words get() = trim().split("\\s+".toRegex())
 //////////////////////////////////////////////////////////////////////////
 
 /* This is PI. Hi PI. */
-val AI_MATH_TWO_PI = glm.PI * 2   // TODO glm?
-val AI_MATH_TWO_PIf = glm.PIf * 2   // TODO glm?
-val AI_MATH_HALF_PI = glm.PIf * 0.5
+val AI_MATH_TWO_PI = glm.PI2
+val AI_MATH_TWO_PIf = glm.PI2f
+val AI_MATH_HALF_PI = glm.HPIf
 
 val AiVector3D.squareLength get() = x * x + y * y + z * z
 

src/main/kotlin/assimp/mesh.kt

@@ -328,26 +328,30 @@ open class AiMesh(
     //! Check whether the mesh contains a vertex color set
     //! \param index Index of the vertex color set
     fun hasVertexColors(index: Int) =
-            if (index >= assimp.AI_MAX_NUMBER_OF_COLOR_SETS) false
-            else index < colors.size && numVertices > 0
+            if (index >= AI_MAX_NUMBER_OF_COLOR_SETS)
+                false
+            else
+                index < colors.size && numVertices > 0
 
     //! Check whether the mesh contains a texture coordinate set
     //! \param index Index of the texture coordinates set
     fun hasTextureCoords(index: Int) =
-            if (index >= assimp.AI_MAX_NUMBER_OF_TEXTURECOORDS) false
-            else textureCoords[index].isNotEmpty() && numVertices > 0
+            if (index >= AI_MAX_NUMBER_OF_TEXTURECOORDS || index >= textureCoords.size)
+                false
+            else
+                textureCoords[index].isNotEmpty() && numVertices > 0
 
     //! Get the number of UV channels the mesh contains
     fun getNumUVChannels(): Int {
         var n = 0
-        while (n < assimp.AI_MAX_NUMBER_OF_TEXTURECOORDS && n < textureCoords.size && textureCoords[n].isNotEmpty()) ++n
+        while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && n < textureCoords.size && textureCoords[n].isNotEmpty()) ++n
         return n
     }
 
     //! Get the number of vertex color channels the mesh contains
     fun getNumColorChannels(): Int {
         var n = 0
-        while (n < assimp.AI_MAX_NUMBER_OF_COLOR_SETS && n < colors.size) ++n
+        while (n < AI_MAX_NUMBER_OF_COLOR_SETS && n < colors.size) ++n
         return n
     }
 

src/main/kotlin/assimp/postProcess/convertToLhProcess.kt renamed to src/main/kotlin/assimp/postProcess/ConvertToLhProcess.kt

@@ -63,7 +63,7 @@ import glm_.mat4x4.Mat4
  *
  * @note RH-LH and LH-RH is the same, so this class can be used for both
  */
-class MakeLeftHandedProcess : BaseProcess() {
+object MakeLeftHandedProcess : BaseProcess() {
 
     /** Returns whether the processing step is present in the given flag field. */
     override fun isActive(flags: AiPostProcessStepsFlags): Boolean = flags has AiPostProcessStep.MakeLeftHanded
@@ -183,7 +183,7 @@ class MakeLeftHandedProcess : BaseProcess() {
 // ---------------------------------------------------------------------------
 /** Postprocessing step to flip the face order of the imported data
  */
-class FlipWindingOrderProcess : BaseProcess() {
+object FlipWindingOrderProcess : BaseProcess() {
 
     /** Returns whether the processing step is present in the given flag field. */
     override fun isActive(flags: AiPostProcessStepsFlags): Boolean = flags has AiPostProcessStep.FlipWindingOrder
@@ -210,7 +210,7 @@ class FlipWindingOrderProcess : BaseProcess() {
 }
 
 /** Postprocessing step to flip the UV coordinate system of the import data */
-class FlipUVsProcess : BaseProcess() {
+object FlipUVsProcess : BaseProcess() {
 
     override fun isActive(flags: AiPostProcessStepsFlags): Boolean = flags has AiPostProcessStep.FlipUVs
 

src/main/kotlin/assimp/optimizeMeshes.kt renamed to src/main/kotlin/assimp/postProcess/OptimizeMeshes.kt

@@ -1,9 +1,11 @@
-package assimp
+package assimp.postProcess
 
+import assimp.*
 import assimp.AiPostProcessStep as Pps
 import assimp.AiShadingMode as Sm
 
-object OptimizeMeshes : BaseProcess(){
+class OptimizeMeshes : BaseProcess(){
+
     private val NotSet = 0xffffffff
     private val DeadBeef = 0xdeadbeef
     private lateinit var mScene : AiScene
@@ -37,14 +39,14 @@ object OptimizeMeshes : BaseProcess(){
         mScene = scene
 
         findInstancedMeshes(mScene.rootNode)
-        if( maxVerts == DeadBeef ) /* undo the magic hack */
+        if( maxVerts == DeadBeef) /* undo the magic hack */
             maxVerts = NotSet
 
         var n : Long = 0
         for (i in 0 until mScene.numMeshes) {
             meshes[i].vertex_format = ProcessHelper.getMeshVFormatUnique(mScene.meshes[i])
 
-            if (meshes[i].instance_cnt > 1 && meshes[i].output_id == NotSet ) {
+            if (meshes[i].instance_cnt > 1 && meshes[i].output_id == NotSet) {
                 meshes[i].output_id = n++
                 output.add(mScene.meshes[i])
             }
@@ -59,10 +61,10 @@ object OptimizeMeshes : BaseProcess(){
         assert(output.size <= oldNum)
 
         mScene.numMeshes = output.size
-        System.arraycopy(output,0,mScene.meshes,0,output.size)
+        System.arraycopy(output,0, mScene.meshes,0, output.size)
 
         if (output.size != oldNum) {
-            logger.info("OptimizeMeshesProcess finished. Input meshes: %d, Output meshes: %d",oldNum,mScene.numMeshes)
+            logger.info("OptimizeMeshesProcess finished. Input meshes: %d, Output meshes: %d",oldNum, mScene.numMeshes)
         } else {
             logger.debug( "OptimizeMeshesProcess finished" )
         }
@@ -82,7 +84,7 @@ object OptimizeMeshes : BaseProcess(){
             ++meshes[ pNode.meshes[ i ] ].instance_cnt
         }
         for(i in 0 until pNode.numChildren) {
-            findInstancedMeshes( pNode.children[ i ] )
+            findInstancedMeshes(pNode.children[i])
         }
     }
 
@@ -102,8 +104,8 @@ object OptimizeMeshes : BaseProcess(){
                 // Find meshes to merge with us
                 var a = 0
                 while(a < pNode.numMeshes){
-                    var am = pNode.meshes[a]
-                    if (meshes[am].instance_cnt == 1 && canJoin(im,am,verts,faces)) {
+                    val am = pNode.meshes[a]
+                    if (meshes[am].instance_cnt == 1 && canJoin(im, am, verts, faces)) {
 
                         merge_list.add(mScene.meshes[am])
                         verts += mScene.meshes[am].numVertices
@@ -120,8 +122,8 @@ object OptimizeMeshes : BaseProcess(){
                 if (merge_list.size != 0 ){
                     merge_list.add(mScene.meshes[im])
 
-                    var out = ArrayList<AiMesh>()
-                    SceneCombiner.mergeMeshes(out,0,merge_list,0,merge_list.size)
+                    val out = ArrayList<AiMesh>()
+                    SceneCombiner.mergeMeshes(out, 0, merge_list, 0, merge_list.size)
                     for(oMesh in out){
                         output.add(oMesh)
                     }
@@ -134,7 +136,7 @@ object OptimizeMeshes : BaseProcess(){
 
 
         for(i in 0 until pNode.numChildren) {
-            processNode( pNode.children[ i ] )
+            processNode(pNode.children[i])
         }
     }
 
@@ -143,8 +145,8 @@ object OptimizeMeshes : BaseProcess(){
         if (meshes[a].vertex_format != meshes[b].vertex_format)
             return false
 
-        var ma = mScene.meshes[a]
-        var mb = mScene.meshes[b]
+        val ma = mScene.meshes[a]
+        val mb = mScene.meshes[b]
 
         if ((NotSet != maxVerts && verts+mb.numVertices > maxVerts) || (NotSet != maxFaces && faces+mb.numFaces    > maxFaces)) {
             return false