mirror of
https://github.com/RandomityGuy/MBHaxe.git
synced 2025-12-02 22:23:10 +00:00
805 lines
27 KiB
Haxe
805 lines
27 KiB
Haxe
package src;
|
|
|
|
import shaders.NormalMaterial;
|
|
import shaders.NoiseTileMaterial;
|
|
import shaders.DirLight;
|
|
import shaders.PhongMaterial;
|
|
import dif.Edge;
|
|
import h3d.shader.pbr.PropsValues;
|
|
import h3d.mat.Material;
|
|
import src.ResourceLoader;
|
|
import src.PathedInterior;
|
|
import h3d.Vector;
|
|
import collision.CollisionSurface;
|
|
import collision.CollisionEntity;
|
|
import h3d.mat.Data.Wrap;
|
|
import hxd.fs.FileSystem;
|
|
import hxd.res.Loader;
|
|
import hxd.res.Image;
|
|
import h3d.mat.Texture;
|
|
import haxe.io.Path;
|
|
import hxd.File;
|
|
import h3d.scene.Mesh;
|
|
import h3d.prim.UV;
|
|
import h3d.col.Point;
|
|
import src.Polygon;
|
|
import dif.math.Point2F;
|
|
import dif.math.Point3F;
|
|
import h3d.prim.BigPrimitive;
|
|
import dif.Interior;
|
|
import dif.Dif;
|
|
import src.InteriorObject;
|
|
import src.MarbleGame;
|
|
import src.ResourceLoaderWorker;
|
|
import src.Console;
|
|
import src.Debug;
|
|
|
|
class DifBuilderTriangle {
|
|
public var texture:String;
|
|
public var normal1:Point3F;
|
|
public var normal2:Point3F;
|
|
public var normal3:Point3F;
|
|
public var p1:Point3F;
|
|
public var p2:Point3F;
|
|
public var p3:Point3F;
|
|
public var uv1:Point2F;
|
|
public var uv2:Point2F;
|
|
public var uv3:Point2F;
|
|
|
|
public function new() {}
|
|
}
|
|
|
|
class TriangleEdge {
|
|
public var index1:Int;
|
|
public var index2:Int;
|
|
public var farPoint:Int;
|
|
|
|
public var surfaceIndex:Int;
|
|
|
|
public function new(i1:Int, i2:Int, farPoint:Int, surfaceIndex:Int) {
|
|
if (i2 < i1) {
|
|
index1 = i2;
|
|
index2 = i1;
|
|
} else {
|
|
index1 = i1;
|
|
index2 = i2;
|
|
}
|
|
this.farPoint = farPoint;
|
|
this.surfaceIndex = surfaceIndex;
|
|
}
|
|
}
|
|
|
|
typedef VertexBucket = {
|
|
var referenceNormal:Point3F;
|
|
var triangleIndices:Array<Int>;
|
|
var normals:Array<Point3F>;
|
|
}
|
|
|
|
class DifBuilder {
|
|
static var materialDict:Map<String, {
|
|
friction:Float,
|
|
restitution:Float,
|
|
?force:Float
|
|
}> = [
|
|
"friction_none" => {
|
|
friction: 0.01,
|
|
restitution: 0.5
|
|
},
|
|
"friction_low" => {
|
|
friction: 0.2,
|
|
restitution: 0.5
|
|
},
|
|
"friction_high" => {
|
|
friction: 1.5,
|
|
restitution: 0.5
|
|
},
|
|
"friction_ramp_yellow" => {
|
|
friction: 2.0,
|
|
restitution: 1.0
|
|
},
|
|
"oilslick" => {
|
|
friction: 0.05,
|
|
restitution: 0.5
|
|
},
|
|
"base.slick" => {
|
|
friction: 0.05,
|
|
restitution: 0.5
|
|
},
|
|
"ice.slick" => {
|
|
friction: 0.05,
|
|
restitution: 0.5
|
|
},
|
|
"grass" => {
|
|
friction: 1.5,
|
|
restitution: 0.35
|
|
},
|
|
"ice1" => {
|
|
friction: 0.03,
|
|
restitution: 0.95
|
|
},
|
|
"rug" => {
|
|
friction: 6.0,
|
|
restitution: 0.5,
|
|
},
|
|
"tarmac" => {
|
|
friction: 0.35,
|
|
restitution: 0.7
|
|
},
|
|
"carpet" => {
|
|
friction: 6.0,
|
|
restitution: 0.5
|
|
},
|
|
"sand" => {
|
|
friction: 4.0,
|
|
restitution: 0.1
|
|
},
|
|
"water" => {
|
|
friction: 6.0,
|
|
restitution: 0.0,
|
|
},
|
|
"floor_bounce" => {
|
|
friction: 0.2,
|
|
restitution: 0.0,
|
|
force: 15
|
|
},
|
|
"mbp_chevron_friction" => {
|
|
friction: -1.0,
|
|
restitution: 1.0
|
|
},
|
|
"mbp_chevron_friction2" => {
|
|
friction: -1.0,
|
|
restitution: 1.0
|
|
},
|
|
"mbp_chevron_friction3" => {
|
|
friction: -1.0,
|
|
restitution: 1.0
|
|
},
|
|
"mmg_grass" => {
|
|
friction: 0.9,
|
|
restitution: 0.5
|
|
},
|
|
"mmg_sand" => {
|
|
friction: 6.0,
|
|
restitution: 0.1
|
|
},
|
|
"mmg_water" => {
|
|
friction: 6.0,
|
|
restitution: 0.0
|
|
},
|
|
"mmg_ice" => {
|
|
friction: 0.03,
|
|
restitution: 0.95
|
|
},
|
|
"mmg_ice_shadow" => {
|
|
friction: 0.03,
|
|
restitution: 0.95
|
|
},
|
|
"friction_mp_high" => {
|
|
friction: 6,
|
|
restitution: 0.3
|
|
},
|
|
"friction_mp_high_shadow" => {
|
|
friction: 6,
|
|
restitution: 0.3
|
|
},
|
|
];
|
|
|
|
static function createPhongMaterial(onFinish:hxsl.Shader->Void, baseTexture:String, normalTexture:String, shininess:Float, specularColor:Vector,
|
|
uvScaleFactor:Float = 1) {
|
|
var worker = new ResourceLoaderWorker(() -> {
|
|
var diffuseTex = ResourceLoader.getTexture('data/interiors_mbu/${baseTexture}').resource;
|
|
diffuseTex.wrap = Repeat;
|
|
diffuseTex.mipMap = Nearest;
|
|
var normalTex = ResourceLoader.getTexture('data/shaders/tex/${normalTexture}').resource;
|
|
normalTex.wrap = Repeat;
|
|
normalTex.mipMap = Nearest;
|
|
var shader = new PhongMaterial(diffuseTex, normalTex, shininess, specularColor, MarbleGame.instance.world.ambient,
|
|
MarbleGame.instance.world.dirLight, MarbleGame.instance.world.dirLightDir, uvScaleFactor);
|
|
if (uvScaleFactor == 0.5)
|
|
shader.isHalfTile = true;
|
|
onFinish(shader);
|
|
});
|
|
worker.loadFile('interiors_mbu/${baseTexture}');
|
|
worker.loadFile('shaders/tex/${normalTexture}');
|
|
worker.run();
|
|
}
|
|
|
|
static function createNoiseTileMaterial(onFinish:hxsl.Shader->Void, baseTexture:String, noiseSuffix:String, shininess:Float, specular:Vector,
|
|
uvScale:Float = 1) {
|
|
var worker = new ResourceLoaderWorker(() -> {
|
|
var diffuseTex = ResourceLoader.getTexture('data/interiors_mbu/${baseTexture}').resource;
|
|
diffuseTex.wrap = Repeat;
|
|
diffuseTex.mipMap = Nearest;
|
|
var normalTex = ResourceLoader.getTexture('data/shaders/tex/tile_mbu.normal.png').resource;
|
|
normalTex.wrap = Repeat;
|
|
normalTex.mipMap = Nearest;
|
|
var noiseTex = ResourceLoader.getTexture('data/shaders/tex/noise${noiseSuffix}.jpg').resource;
|
|
noiseTex.wrap = Repeat;
|
|
noiseTex.mipMap = Nearest;
|
|
var shader = new NoiseTileMaterial(diffuseTex, normalTex, noiseTex, shininess, specular, MarbleGame.instance.world.ambient,
|
|
MarbleGame.instance.world.dirLight, MarbleGame.instance.world.dirLightDir, uvScale);
|
|
onFinish(shader);
|
|
});
|
|
worker.loadFile('interiors_mbu/${baseTexture}');
|
|
worker.loadFile('shaders/tex/noise${noiseSuffix}.jpg');
|
|
worker.loadFile('shaders/tex/tile_mbu.spec.jpg');
|
|
worker.loadFile('shaders/tex/tile_mbu.normal.png');
|
|
worker.run();
|
|
}
|
|
|
|
static function createNormalMapMaterial(onFinish:hxsl.Shader->Void, baseTexture:String, normalTexture:String) {
|
|
var worker = new ResourceLoaderWorker(() -> {
|
|
var diffuseTex = ResourceLoader.getTexture('data/interiors_mbu/${baseTexture}').resource;
|
|
var normalTex = ResourceLoader.getTexture('data/shaders/tex/${normalTexture}').resource;
|
|
normalTex.wrap = Repeat;
|
|
var shader = new NormalMaterial(diffuseTex, normalTex, MarbleGame.instance.world.ambient, MarbleGame.instance.world.dirLight,
|
|
MarbleGame.instance.world.dirLightDir);
|
|
onFinish(shader);
|
|
});
|
|
worker.loadFile('interiors_mbu/${baseTexture}');
|
|
worker.loadFile('shaders/tex/${normalTexture}');
|
|
worker.run();
|
|
}
|
|
|
|
static var shaderMaterialDict:Map<String, (hxsl.Shader->Void)->Void> = [
|
|
'interiors_mbu/plate_1' => (onFinish) -> createPhongMaterial(onFinish, 'plate.randomize.png', 'plate.normal.png', 8, new Vector(1, 1, 0.8, 1), 0.5),
|
|
'interiors_mbu/tile_beginner' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_beginner.png', '', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_beginner_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_beginner.png', '_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_beginner_red' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_beginner.png', '_red', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_beginner_red_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_beginner.png', '_red_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_beginner_blue' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_beginner.png', '_blue', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_beginner_blue_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_beginner.png', '_blue_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_intermediate' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_intermediate.png', '', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_intermediate_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_intermediate.png', '_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_intermediate_red' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_intermediate.png', '_red', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_intermediate_red_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_intermediate.png', '_red_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_intermediate_green' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_intermediate.png', '_green', 40,
|
|
new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_intermediate_green_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_intermediate.png', '_green_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_advanced' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_advanced.png', '', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_advanced_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_advanced.png', '_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_advanced_blue' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_advanced.png', '_blue', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_advanced_blue_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_advanced.png', '_blue_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_advanced_green' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_advanced.png', '_green', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/tile_advanced_green_shadow' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_advanced.png', '_green_shadow', 40,
|
|
new Vector(0.2, 0.2, 0.2, 0.2), 1 / 4),
|
|
'interiors_mbu/tile_underside' => (onFinish) -> createNoiseTileMaterial(onFinish, 'tile_underside.png', '', 40, new Vector(1, 1, 1, 1)),
|
|
'interiors_mbu/wall_beginner' => (onFinish) -> createPhongMaterial(onFinish, 'wall_beginner.png', 'wall_mbu.normal.png', 12,
|
|
new Vector(0.8, 0.8, 0.6, 1)),
|
|
'interiors_mbu/edge_white' => (onFinish) -> createPhongMaterial(onFinish, 'edge_white.png', 'edge.normal.png', 50, new Vector(0.8, 0.8, 0.8, 1)),
|
|
'interiors_mbu/edge_white_shadow' => (onFinish) -> createPhongMaterial(onFinish, 'edge_white_shadow.png', 'edge.normal.png', 50,
|
|
new Vector(0.2, 0.2, 0.2, 0.2)),
|
|
'interiors_mbu/beam' => (onFinish) -> createPhongMaterial(onFinish, 'beam.png', 'beam.normal.png', 12, new Vector(0.8, 0.8, 0.6, 1)),
|
|
'interiors_mbu/beam_side' => (onFinish) -> createPhongMaterial(onFinish, 'beam_side.png', 'beam_side.normal.png', 12, new Vector(0.8, 0.8, 0.6, 1)),
|
|
'interiors_mbu/friction_low' => (onFinish) -> createPhongMaterial(onFinish, 'friction_low.png', 'friction_low.normal.png', 128,
|
|
new Vector(1, 1, 1, 0.8)),
|
|
'interiors_mbu/friction_low_shadow' => (onFinish) -> createPhongMaterial(onFinish, 'friction_low_shadow.png', 'friction_low.normal.png', 128,
|
|
new Vector(0.3, 0.3, 0.35, 1)),
|
|
'interiors_mbu/friction_high' => (onFinish) -> createPhongMaterial(onFinish, 'friction_high.png', 'friction_high.normal.png', 10,
|
|
new Vector(0.3, 0.3, 0.35, 1)),
|
|
'interiors_mbu/friction_high_shadow' => (onFinish) -> createPhongMaterial(onFinish, 'friction_high_shadow.png', 'friction_high.normal.png', 10,
|
|
new Vector(0.15, 0.15, 0.16, 1.0)),
|
|
'interiors_mbu/stripe_caution' => (onFinish) -> createPhongMaterial(onFinish, 'stripe_caution.png', 'DefaultNormal.png', 12,
|
|
new Vector(0.8, 0.8, 0.6, 1)),
|
|
];
|
|
|
|
public static function loadDif(path:String, itr:InteriorObject, onFinish:Void->Void, ?so:Int = -1) {
|
|
#if (js || android)
|
|
path = StringTools.replace(path, "data/", "");
|
|
#end
|
|
ResourceLoader.load(path).entry.load(() -> {
|
|
var difresource = ResourceLoader.loadInterior(path);
|
|
difresource.acquire();
|
|
var dif = difresource.resource;
|
|
dumbDownDif(dif);
|
|
var geo = so == -1 ? dif.interiors[0] : dif.subObjects[so];
|
|
var triangles = [];
|
|
var textures = [];
|
|
var collider = new CollisionEntity(itr);
|
|
function stripTexName(tex:String) {
|
|
var dotpos = tex.lastIndexOf(".");
|
|
var slashpos = tex.lastIndexOf("/") + 1;
|
|
if (dotpos == -1) {
|
|
dotpos = tex.length;
|
|
}
|
|
if (slashpos == -1) {
|
|
slashpos = 0;
|
|
}
|
|
return tex.substring(slashpos, dotpos);
|
|
}
|
|
var vertexBuckets = new Map<Point3F, Array<VertexBucket>>();
|
|
var edges = [];
|
|
var colliderSurfaces = [];
|
|
for (i in 0...geo.surfaces.length) {
|
|
var surfaceindex = i;
|
|
var surface = geo.surfaces[surfaceindex];
|
|
if (surface == null)
|
|
continue;
|
|
var planeindex = surface.planeIndex;
|
|
var planeFlipped = (planeindex & 0x8000) == 0x8000;
|
|
if (planeFlipped)
|
|
planeindex &= ~0x8000;
|
|
var plane = geo.planes[planeindex];
|
|
var normal = geo.normals[plane.normalIndex];
|
|
if (planeFlipped)
|
|
normal = normal.scalar(-1);
|
|
var texture = geo.materialList[surface.textureIndex];
|
|
if (!textures.contains(texture))
|
|
textures.push(texture);
|
|
var points = geo.points;
|
|
var colliderSurface = new CollisionSurface();
|
|
colliderSurface.points = [];
|
|
colliderSurface.normals = [];
|
|
colliderSurface.indices = [];
|
|
colliderSurface.transformKeys = [];
|
|
colliderSurface.originalIndices = [];
|
|
colliderSurface.originalSurfaceIndex = surfaceindex;
|
|
for (k in (surface.windingStart + 2)...(surface.windingStart + surface.windingCount)) {
|
|
var p1, p2, p3;
|
|
if ((k - (surface.windingStart + 2)) % 2 == 0) {
|
|
p1 = points[geo.windings[k]];
|
|
p2 = points[geo.windings[k - 1]];
|
|
p3 = points[geo.windings[k - 2]];
|
|
colliderSurface.originalIndices.push(geo.windings[k]);
|
|
colliderSurface.originalIndices.push(geo.windings[k - 1]);
|
|
colliderSurface.originalIndices.push(geo.windings[k - 2]);
|
|
} else {
|
|
p1 = points[geo.windings[k - 2]];
|
|
p2 = points[geo.windings[k - 1]];
|
|
p3 = points[geo.windings[k]];
|
|
colliderSurface.originalIndices.push(geo.windings[k - 2]);
|
|
colliderSurface.originalIndices.push(geo.windings[k - 1]);
|
|
colliderSurface.originalIndices.push(geo.windings[k]);
|
|
}
|
|
var e1 = new TriangleEdge(geo.windings[k], geo.windings[k - 1], geo.windings[k - 2], surfaceindex);
|
|
var e2 = new TriangleEdge(geo.windings[k - 1], geo.windings[k - 2], geo.windings[k], surfaceindex);
|
|
var e3 = new TriangleEdge(geo.windings[k], geo.windings[k - 2], geo.windings[k - 1], surfaceindex);
|
|
edges.push(e1);
|
|
edges.push(e2);
|
|
edges.push(e3);
|
|
var texgen = geo.texGenEQs[surface.texGenIndex];
|
|
var uv1 = new Point2F(p1.x * texgen.planeX.x
|
|
+ p1.y * texgen.planeX.y
|
|
+ p1.z * texgen.planeX.z
|
|
+ texgen.planeX.d,
|
|
p1.x * texgen.planeY.x
|
|
+ p1.y * texgen.planeY.y
|
|
+ p1.z * texgen.planeY.z
|
|
+ texgen.planeY.d);
|
|
var uv2 = new Point2F(p2.x * texgen.planeX.x
|
|
+ p2.y * texgen.planeX.y
|
|
+ p2.z * texgen.planeX.z
|
|
+ texgen.planeX.d,
|
|
p2.x * texgen.planeY.x
|
|
+ p2.y * texgen.planeY.y
|
|
+ p2.z * texgen.planeY.z
|
|
+ texgen.planeY.d);
|
|
var uv3 = new Point2F(p3.x * texgen.planeX.x
|
|
+ p3.y * texgen.planeX.y
|
|
+ p3.z * texgen.planeX.z
|
|
+ texgen.planeX.d,
|
|
p3.x * texgen.planeY.x
|
|
+ p3.y * texgen.planeY.y
|
|
+ p3.z * texgen.planeY.z
|
|
+ texgen.planeY.d);
|
|
var tri = new DifBuilderTriangle();
|
|
tri.texture = texture;
|
|
tri.normal1 = normal;
|
|
tri.normal2 = normal;
|
|
tri.normal3 = normal;
|
|
tri.p1 = p1;
|
|
tri.p2 = p2;
|
|
tri.p3 = p3;
|
|
tri.uv1 = uv1;
|
|
tri.uv2 = uv2;
|
|
tri.uv3 = uv3;
|
|
triangles.push(tri);
|
|
var materialName = stripTexName(texture).toLowerCase();
|
|
var hasMaterialInfo = materialDict.exists(materialName);
|
|
if (hasMaterialInfo) {
|
|
var minfo = materialDict.get(materialName);
|
|
colliderSurface.friction = minfo.friction;
|
|
colliderSurface.restitution = minfo.restitution;
|
|
colliderSurface.force = minfo.force != null ? minfo.force : 0;
|
|
}
|
|
colliderSurface.addPoint(-p1.x, p1.y, p1.z);
|
|
colliderSurface.addPoint(-p2.x, p2.y, p2.z);
|
|
colliderSurface.addPoint(-p3.x, p3.y, p3.z);
|
|
colliderSurface.addNormal(-normal.x, normal.y, normal.z);
|
|
colliderSurface.addNormal(-normal.x, normal.y, normal.z);
|
|
colliderSurface.addNormal(-normal.x, normal.y, normal.z);
|
|
colliderSurface.indices.push(colliderSurface.indices.length);
|
|
colliderSurface.indices.push(colliderSurface.indices.length);
|
|
colliderSurface.indices.push(colliderSurface.indices.length);
|
|
colliderSurface.transformKeys.push(0);
|
|
colliderSurface.transformKeys.push(0);
|
|
colliderSurface.transformKeys.push(0);
|
|
for (v in [p1, p2, p3]) {
|
|
var buckets = vertexBuckets.get(v);
|
|
if (buckets == null) {
|
|
buckets = [];
|
|
vertexBuckets.set(v, buckets);
|
|
}
|
|
var bucket:VertexBucket = null;
|
|
for (j in 0...buckets.length) {
|
|
bucket = buckets[j];
|
|
if (normal.dot(bucket.referenceNormal) > Math.cos(Math.PI / 12))
|
|
break;
|
|
bucket = null;
|
|
}
|
|
if (bucket == null) {
|
|
bucket = {
|
|
referenceNormal: normal,
|
|
triangleIndices: [],
|
|
normals: []
|
|
};
|
|
buckets.push(bucket);
|
|
}
|
|
bucket.triangleIndices.push(triangles.length - 1);
|
|
bucket.normals.push(normal);
|
|
}
|
|
}
|
|
colliderSurface.generateBoundingBox();
|
|
collider.addSurface(colliderSurface);
|
|
colliderSurfaces.push(colliderSurface);
|
|
}
|
|
var edgeMap:Map<Int, TriangleEdge> = new Map();
|
|
var internalEdges:Map<Int, Bool> = new Map();
|
|
var difEdges:Map<Int, Edge> = [];
|
|
for (edge in edges) {
|
|
var edgeHash = edge.index1 >= edge.index2 ? edge.index1 * edge.index1 + edge.index1 + edge.index2 : edge.index1 + edge.index2 * edge.index2;
|
|
if (internalEdges.exists(edgeHash))
|
|
continue;
|
|
if (edgeMap.exists(edgeHash)) {
|
|
if (edgeMap[edgeHash].surfaceIndex == edge.surfaceIndex) {
|
|
// Internal edge
|
|
internalEdges.set(edgeHash, true);
|
|
edgeMap.remove(edgeHash);
|
|
// trace('Removing internal edge: ${edge.index1} ${edge.index2}');
|
|
} else {
|
|
var difEdge = new Edge(edge.index1, edge.index2, edge.surfaceIndex, edgeMap[edgeHash].surfaceIndex);
|
|
difEdge.farPoint0 = edge.farPoint;
|
|
difEdge.farPoint1 = edgeMap[edgeHash].farPoint;
|
|
difEdges.set(edgeHash, difEdge); // Literal edge
|
|
}
|
|
} else {
|
|
edgeMap.set(edgeHash, edge);
|
|
}
|
|
}
|
|
function hashEdge(i1:Int, i2:Int) {
|
|
return i1 >= i2 ? i1 * i1 + i1 + i2 : i1 + i2 * i2;
|
|
}
|
|
function getEdgeConcavity(edge:Edge) {
|
|
var edgeSurface0 = edge.surfaceIndex0;
|
|
var surface0 = geo.surfaces[edgeSurface0];
|
|
|
|
var planeindex = surface0.planeIndex;
|
|
|
|
var planeFlipped = (planeindex & 0x8000) == 0x8000;
|
|
if (planeFlipped)
|
|
planeindex &= ~0x8000;
|
|
|
|
var plane = geo.planes[planeindex];
|
|
var normal0 = geo.normals[plane.normalIndex];
|
|
|
|
if (planeFlipped)
|
|
normal0 = normal0.scalar(-1);
|
|
|
|
var edgeSurface1 = edge.surfaceIndex1;
|
|
var surface1 = geo.surfaces[edgeSurface1];
|
|
|
|
planeindex = surface1.planeIndex;
|
|
|
|
planeFlipped = (planeindex & 0x8000) == 0x8000;
|
|
if (planeFlipped)
|
|
planeindex &= ~0x8000;
|
|
|
|
plane = geo.planes[planeindex];
|
|
var normal1 = geo.normals[plane.normalIndex];
|
|
|
|
if (planeFlipped)
|
|
normal1 = normal1.scalar(-1);
|
|
|
|
var dot = normal0.dot(normal1);
|
|
|
|
if (Math.abs(dot) < 0.1)
|
|
return false;
|
|
|
|
var farP0 = geo.points[edge.farPoint0];
|
|
var farP1 = geo.points[edge.farPoint1];
|
|
|
|
var diff = farP1.sub(farP0);
|
|
var cdot0 = normal0.dot(diff);
|
|
if (cdot0 > -0.1) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
function getEdgeNormal(edge:Edge) {
|
|
var edgeSurface0 = edge.surfaceIndex0;
|
|
var surface0 = geo.surfaces[edgeSurface0];
|
|
|
|
var planeindex = surface0.planeIndex;
|
|
|
|
var planeFlipped = (planeindex & 0x8000) == 0x8000;
|
|
if (planeFlipped)
|
|
planeindex &= ~0x8000;
|
|
|
|
var plane = geo.planes[planeindex];
|
|
var normal0 = geo.normals[plane.normalIndex];
|
|
|
|
if (planeFlipped)
|
|
normal0 = normal0.scalar(-1);
|
|
|
|
var edgeSurface1 = edge.surfaceIndex1;
|
|
var surface1 = geo.surfaces[edgeSurface1];
|
|
|
|
planeindex = surface1.planeIndex;
|
|
|
|
planeFlipped = (planeindex & 0x8000) == 0x8000;
|
|
if (planeFlipped)
|
|
planeindex &= ~0x8000;
|
|
|
|
plane = geo.planes[planeindex];
|
|
var normal1 = geo.normals[plane.normalIndex];
|
|
|
|
if (planeFlipped)
|
|
normal1 = normal1.scalar(-1);
|
|
|
|
var norm = normal0.add(normal1).scalarDiv(2).normalized();
|
|
|
|
var vec = new Vector(norm.x, norm.y, norm.z);
|
|
|
|
return vec;
|
|
}
|
|
for (vtex => buckets in vertexBuckets) {
|
|
for (i in 0...buckets.length) {
|
|
var bucket = buckets[i];
|
|
var avgNormal = new Point3F();
|
|
for (normal in bucket.normals)
|
|
avgNormal = avgNormal.add(normal);
|
|
avgNormal = avgNormal.scalarDiv(bucket.normals.length);
|
|
for (j in 0...bucket.triangleIndices.length) {
|
|
var index = bucket.triangleIndices[j];
|
|
var tri = triangles[index];
|
|
if (tri.p1 == vtex)
|
|
tri.normal1 = avgNormal;
|
|
if (tri.p2 == vtex)
|
|
tri.normal2 = avgNormal;
|
|
if (tri.p3 == vtex)
|
|
tri.normal3 = avgNormal;
|
|
}
|
|
}
|
|
}
|
|
var mats = new Map<String, Array<DifBuilderTriangle>>();
|
|
for (index => value in triangles) {
|
|
if (mats.exists(value.texture)) {
|
|
mats[value.texture].push(value);
|
|
} else {
|
|
mats.set(value.texture, [value]);
|
|
}
|
|
}
|
|
collider.finalize();
|
|
itr.collider = collider;
|
|
function canFindTex(tex:String) {
|
|
if (["NULL"].contains(tex)) {
|
|
return false;
|
|
}
|
|
if (tex.indexOf('/') != -1) {
|
|
tex = tex.split('/')[1];
|
|
}
|
|
|
|
#if (js || android)
|
|
path = StringTools.replace(path, "data/", "");
|
|
#end
|
|
|
|
if (ResourceLoader.exists(Path.directory(path) + "/" + tex + ".jpg")) {
|
|
return true;
|
|
}
|
|
if (ResourceLoader.exists(Path.directory(path) + "/" + tex + ".png")) {
|
|
return true;
|
|
}
|
|
var prevDir = Path.directory(Path.directory(path));
|
|
|
|
if (ResourceLoader.exists(prevDir + "/" + tex + ".jpg")) {
|
|
return true;
|
|
}
|
|
if (ResourceLoader.exists(prevDir + "/" + tex + ".png")) {
|
|
return true;
|
|
}
|
|
|
|
prevDir = Path.directory(prevDir);
|
|
|
|
if (ResourceLoader.exists(prevDir + "/" + tex + ".jpg")) {
|
|
return true;
|
|
}
|
|
if (ResourceLoader.exists(prevDir + "/" + tex + ".png")) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
function tex(tex:String):String {
|
|
if (tex.indexOf('/') != -1) {
|
|
tex = tex.split('/')[1];
|
|
}
|
|
|
|
if (ResourceLoader.exists(Path.directory(path) + "/" + tex + ".jpg")) {
|
|
return Path.directory(path) + "/" + tex + ".jpg";
|
|
}
|
|
if (ResourceLoader.exists(Path.directory(path) + "/" + tex + ".png")) {
|
|
return Path.directory(path) + "/" + tex + ".png";
|
|
}
|
|
|
|
var prevDir = Path.directory(Path.directory(path));
|
|
|
|
if (ResourceLoader.exists(prevDir + "/" + tex + ".jpg")) {
|
|
return prevDir + "/" + tex + ".jpg";
|
|
}
|
|
if (ResourceLoader.exists(prevDir + "/" + tex + ".png")) {
|
|
return prevDir + "/" + tex + ".png";
|
|
}
|
|
|
|
var prevDir = Path.directory(prevDir);
|
|
|
|
if (ResourceLoader.exists(prevDir + "/" + tex + ".jpg")) {
|
|
return prevDir + "/" + tex + ".jpg";
|
|
}
|
|
if (ResourceLoader.exists(prevDir + "/" + tex + ".png")) {
|
|
return prevDir + "/" + tex + ".png";
|
|
}
|
|
|
|
return null;
|
|
}
|
|
var loadtexs = [];
|
|
for (grp => tris in mats) {
|
|
if (canFindTex(grp)) {
|
|
loadtexs.push(tex(grp));
|
|
}
|
|
}
|
|
var worker = new ResourceLoaderWorker(() -> {
|
|
var shaderWorker = new ResourceLoaderWorker(() -> {
|
|
difresource.release();
|
|
onFinish();
|
|
});
|
|
|
|
for (grp => tris in mats) {
|
|
var points = [];
|
|
var normals = [];
|
|
var uvs = [];
|
|
for (tri in tris) {
|
|
var p1 = new Point(-tri.p1.x, tri.p1.y, tri.p1.z);
|
|
var p2 = new Point(-tri.p2.x, tri.p2.y, tri.p2.z);
|
|
var p3 = new Point(-tri.p3.x, tri.p3.y, tri.p3.z);
|
|
var n1 = new Point(-tri.normal1.x, tri.normal1.y, tri.normal1.z);
|
|
var n2 = new Point(-tri.normal2.x, tri.normal2.y, tri.normal2.z);
|
|
var n3 = new Point(-tri.normal3.x, tri.normal3.y, tri.normal3.z);
|
|
var uv1 = new UV(tri.uv1.x, tri.uv1.y);
|
|
var uv2 = new UV(tri.uv2.x, tri.uv2.y);
|
|
var uv3 = new UV(tri.uv3.x, tri.uv3.y);
|
|
points.push(p3);
|
|
points.push(p2);
|
|
points.push(p1);
|
|
normals.push(n3);
|
|
normals.push(n2);
|
|
normals.push(n1);
|
|
uvs.push(uv3);
|
|
uvs.push(uv2);
|
|
uvs.push(uv1);
|
|
}
|
|
var prim = new Polygon(points);
|
|
prim.setUVs(uvs);
|
|
prim.setNormals(normals);
|
|
var material:Material;
|
|
var texture:Texture;
|
|
if (canFindTex(grp)) {
|
|
texture = ResourceLoader.getTextureRealpath(tex(grp)).resource; // ResourceLoader.getTexture(tex(grp), false).resource;
|
|
texture.wrap = Wrap.Repeat;
|
|
texture.mipMap = Nearest;
|
|
var exactName = StringTools.replace(texture.name, "data/", "").toLowerCase();
|
|
exactName = exactName.substring(0, exactName.lastIndexOf('.'));
|
|
material = h3d.mat.Material.create(texture);
|
|
var matDictName = exactName;
|
|
if (!shaderMaterialDict.exists(matDictName)) {
|
|
matDictName = StringTools.replace(exactName, "multiplayer/interiors/mbu", "interiors_mbu");
|
|
}
|
|
if (shaderMaterialDict.exists(matDictName)) {
|
|
var retrievefunc = shaderMaterialDict[matDictName];
|
|
shaderWorker.addTask(fwd -> {
|
|
retrievefunc(shad -> {
|
|
material.mainPass.removeShader(material.textureShader);
|
|
material.mainPass.addShader(shad);
|
|
var thisprops:Dynamic = material.getDefaultProps();
|
|
thisprops.light = false; // We will calculate our own lighting
|
|
material.props = thisprops;
|
|
material.shadows = false;
|
|
material.receiveShadows = true;
|
|
fwd();
|
|
});
|
|
});
|
|
prim.addTangents();
|
|
} else {
|
|
material.shadows = false;
|
|
material.receiveShadows = true;
|
|
}
|
|
} else {
|
|
Console.warn('Unable to load ${grp} texture for dif ${path}');
|
|
material = Material.create();
|
|
material.shadows = false;
|
|
material.receiveShadows = true;
|
|
}
|
|
// material.mainPass.addShader(new h3d.shader.pbr.PropsValues(1, 0, 0, 1));
|
|
if (Debug.wireFrame)
|
|
material.mainPass.wireframe = true;
|
|
var mesh = new Mesh(prim, material, itr);
|
|
}
|
|
|
|
shaderWorker.run();
|
|
});
|
|
for (f in loadtexs) {
|
|
worker.loadFile(f);
|
|
}
|
|
worker.run();
|
|
});
|
|
}
|
|
|
|
// Keeps only relevant parts of the dif to reduce memory footprint
|
|
static function dumbDownDif(dif:Dif) {
|
|
dif.aiSpecialNodes = null;
|
|
dif.forceFields = null;
|
|
dif.triggers = null;
|
|
dif.gameEntities = null;
|
|
dif.interiorPathfollowers = null;
|
|
dif.triggers = null;
|
|
dif.vehicleCollision = null;
|
|
for (itr in dif.interiors.concat(dif.subObjects)) {
|
|
itr.alarmAmbientColor = null;
|
|
itr.alarmLMapIndices = null;
|
|
itr.animatedLights = null;
|
|
itr.baseAmbientColor = null;
|
|
itr.bspNodes = null;
|
|
itr.bspSolidLeaves = null;
|
|
itr.convexHullEmitStrings = null;
|
|
itr.convexHulls = null;
|
|
itr.coordBinIndices = null;
|
|
itr.boundingSphere = null;
|
|
itr.coordBins = null;
|
|
itr.edges = null;
|
|
itr.edges2 = null;
|
|
itr.hullEmitStringIndices = null;
|
|
itr.hullIndices = null;
|
|
itr.hullPlaneIndices = null;
|
|
itr.hullSurfaceIndices = null;
|
|
itr.lightMaps = null;
|
|
itr.lightStates = null;
|
|
itr.nameBuffer = null;
|
|
itr.normalIndices = null;
|
|
itr.normalLMapIndices = null;
|
|
itr.nullSurfaces = null;
|
|
itr.pointVisibilities = null;
|
|
itr.polyListPlanes = null;
|
|
itr.polyListPoints = null;
|
|
itr.polyListStrings = null;
|
|
itr.portals = null;
|
|
itr.solidLeafSurfaces = null;
|
|
itr.stateDataBuffers = null;
|
|
itr.zones = null;
|
|
itr.zoneSurfaces = null;
|
|
itr.zoneStaticMeshes = null;
|
|
itr.windingIndices = null;
|
|
itr.texNormals = null;
|
|
itr.texMatrices = null;
|
|
itr.texMatIndices = null;
|
|
itr.stateDatas = null;
|
|
}
|
|
}
|
|
}
|