this.origMeshInstances = meshInstances;

this._aabb = new pc.BoundingBox();

this.meshInstance = null;

this.model = null;

this.dynamic = dynamic;

this.batchGroupId = batchGroupId;

this.refCounter = 0;

this.dynamic = dynamic;

this.maxAabbSize = maxAabbSize;

this.id = id;

this.name = name;

this.layers = layers === undefined ? [pc.LAYERID_WORLD] : layers;

this.device = device;

this.rootNode = rootNode;

this._dirty = true;

// Unique per clone

this.bones = nodes;

var numBones = nodes.length;

if (device.supportsBoneTextures) {

var size;

if (numBones > 256)

size = 64;

else if (numBones > 64)

size = 32;

else if (numBones > 16)

size = 16;

else

size = 8;

this.boneTexture = new pc.Texture(device, {

width: size,

height: size,

format: pc.PIXELFORMAT_RGBA32F,

mipmaps: false,

minFilter: pc.FILTER_NEAREST,

magFilter: pc.FILTER_NEAREST

});

this.matrixPalette = this.boneTexture.lock();

} else {

this.matrixPalette = new Float32Array(numBones * 16);

}

var pe;

var mp = this.matrixPalette;

var base;

for (var i = this.bones.length - 1; i >= 0; i--) {

pe = this.bones[i].getWorldTransform().data;

// Copy the matrix into the palette, ready to be sent to the vertex shader

base = i * 16;

mp[base] = pe[0];

mp[base + 1] = pe[1];

mp[base + 2] = pe[2];

mp[base + 3] = pe[3];

mp[base + 4] = pe[4];

mp[base + 5] = pe[5];

mp[base + 6] = pe[6];

mp[base + 7] = pe[7];

mp[base + 8] = pe[8];

mp[base + 9] = pe[9];

mp[base + 10] = pe[10];

mp[base + 11] = pe[11];

mp[base + 12] = pe[12];

mp[base + 13] = pe[13];

mp[base + 14] = pe[14];

mp[base + 15] = pe[15];

}

if (this.device.supportsBoneTextures) {

this.boneTexture.lock();

this.boneTexture.unlock();

}

this.device = device;

this.rootNode = root;

this.scene = scene;

this._init = false;

this._batchGroups = {};

this._batchGroupCounter = 0;

this._batchList = [];

this._dirtyGroups = [];

// #ifdef PROFILER

this._stats = {

createTime: 0,

updateLastFrameTime: 0

};

// #endif

if (id === undefined) {

id = this._batchGroupCounter;

this._batchGroupCounter++;

}

if (this._batchGroups[id]) {

// #ifdef DEBUG

console.error("batch group with id " + id + " already exists");

// #endif

return;

}

var group;

this._batchGroups[id] = group = new pc.BatchGroup(id, name, dynamic, maxAabbSize, layers);

return group;

if (!this._batchGroups[id]) {

// #ifdef DEBUG

console.error("batch group with id " + id + " doesn't exist");

// #endif

return;

}

// delete batches with matching id

var newBatchList = [];

for (var i = 0; i < this._batchList.length; i++) {

if (this._batchList[i].batchGroupId !== id) {

newBatchList.push(this._batchList[i]);

continue;

}

this.destroy(this._batchList[i]);

}

this._batchList = newBatchList;

this._removeModelsFromBatchGroup(this.rootNode, id);

delete this._batchGroups[id];

if (!node.enabled) return;

if (node.model && node.model.batchGroupId === id) {

node.model.batchGroupId = -1;

}

if (node.element && node.element.batchGroupId === id) {

node.element.batchGroupId = -1;

}

if (node.sprite && node.sprite.batchGroupId === id) {

node.sprite.batchGroupId = -1;

}

for (var i = 0; i < node._children.length; i++) {

this._removeModelsFromBatchGroup(node._children[i], id);

}

if (!node.enabled) return;

var i, arr;

if (node.model && node.model.batchGroupId >= 0 && node.model.model && node.model.enabled) {

if (!groupIds || (groupIds && groupIds.indexOf(node.model.batchGroupId) >= 0)) {

arr = groupMeshInstances[node.model.batchGroupId];

if (!arr) arr = groupMeshInstances[node.model.batchGroupId] = [];

if (node.model.isStatic) {

// static mesh instances can be in both drawCall array with _staticSource linking to original

// and in the original array as well, if no triangle splitting was done

var drawCalls = this.scene.drawCalls;

var nodeMeshInstances = node.model.meshInstances;

for (i = 0; i < drawCalls.length; i++) {

if (!drawCalls[i]._staticSource) continue;

if (nodeMeshInstances.indexOf(drawCalls[i]._staticSource) < 0) continue;

groupMeshInstances[node.model.batchGroupId].push(drawCalls[i]);

}

for (i = 0; i < nodeMeshInstances.length; i++) {

if (drawCalls.indexOf(nodeMeshInstances[i]) >= 0) {

groupMeshInstances[node.model.batchGroupId].push(nodeMeshInstances[i]);

}

}

} else {

groupMeshInstances[node.model.batchGroupId] = arr.concat(node.model.meshInstances);

}

node.model.removeModelFromLayers(node.model.model);

// #ifdef DEBUG

node.model._batchGroup = this._batchGroups[node.model.batchGroupId];

// #endif

}

}

if (node.element && node.element.batchGroupId >= 0 && node.element.enabled) {

if (!groupIds || (groupIds && groupIds.indexOf(node.element.batchGroupId) >= 0)) {

arr = groupMeshInstances[node.element.batchGroupId];

if (!arr) arr = groupMeshInstances[node.element.batchGroupId] = [];

var valid = false;

if (node.element._text) {

groupMeshInstances[node.element.batchGroupId].push(node.element._text._model.meshInstances[0]);

node.element.removeModelFromLayers(node.element._text._model);

valid = true;

} else if (node.element._image) {

groupMeshInstances[node.element.batchGroupId].push(node.element._image._model.meshInstances[0]);

node.element.removeModelFromLayers(node.element._image._model);

valid = true;

}

// #ifdef DEBUG

if (valid) {

node.element._batchGroup = this._batchGroups[node.element.batchGroupId];

}

// #endif

}

}

if (node.sprite && node.sprite.batchGroupId >= 0 && node.sprite.enabled) {

if (!groupIds || (groupIds && groupIds.indexOf(node.sprite.batchGroupId) >= 0)) {

arr = groupMeshInstances[node.sprite.batchGroupId];

if (!arr) arr = groupMeshInstances[node.sprite.batchGroupId] = [];

if (node.sprite._meshInstance) {

groupMeshInstances[node.sprite.batchGroupId].push(node.sprite._meshInstance);

this.scene.removeModel(node.sprite._model);

node.sprite._batchGroup = this._batchGroups[node.sprite.batchGroupId];

}

}

}

for (i = 0; i < node._children.length; i++) {

this._collectAndRemoveModels(node._children[i], groupMeshInstances, groupIds);

}

if (this._dirtyGroups.indexOf(id) < 0) {

this._dirtyGroups.push(id);

}

var node;

var ents = [];

for (var i = 0; i < meshInstances.length; i++) {

node = meshInstances[i].node;

while (!node._app && node._parent) {

node = node._parent;

}

if (!node._app) continue;

// node is entity

ents.push(node);

}

this.register(batch, ents);

var i, j;

var groupMeshInstances = {};

if (!groupIds) {

// Full scene

// delete old batches

for (i = 0; i < this._batchList.length; i++) {

this.destroy(this._batchList[i]);

}

this._batchList.length = 0;

// collect

this._collectAndRemoveModels(this.rootNode, groupMeshInstances);

this._dirtyGroups.length = 0;

} else {

// Selected groups

// delete old batches with matching batchGroupId

var newBatchList = [];

for (i = 0; i < this._batchList.length; i++) {

if (groupIds.indexOf(this._batchList[i].batchGroupId) < 0) {

newBatchList.push(this._batchList[i]);

continue;

}

this.destroy(this._batchList[i]);

}

this._batchList = newBatchList;

// collect

this._collectAndRemoveModels(this.rootNode, groupMeshInstances, groupIds);

if (groupIds === this._dirtyGroups) {

this._dirtyGroups.length = 0;

} else {

var newDirtyGroups = [];

for (i = 0; i < this._dirtyGroups.length; i++) {

if (groupIds.indexOf(this._dirtyGroups[i]) < 0) newDirtyGroups.push(this._dirtyGroups[i]);

}

this._dirtyGroups = newDirtyGroups;

}

}

var group, lists, groupData, batch;

for (var groupId in groupMeshInstances) {

if (!groupMeshInstances.hasOwnProperty(groupId)) continue;

group = groupMeshInstances[groupId];

groupData = this._batchGroups[groupId];

if (!groupData) {

// #ifdef DEBUG

console.error("batch group " + groupId + " not found");

// #endif

continue;

}

lists = this.prepare(group, groupData.dynamic, groupData.maxAabbSize);

for (i = 0; i < lists.length; i++) {

batch = this.create(lists[i], groupData.dynamic, parseInt(groupId, 10));

for (j = 0; j < groupData.layers.length; j++) {

this.scene.layers.getLayerById(groupData.layers[j]).addMeshInstances(batch.model.meshInstances);

}

this._registerEntities(batch, lists[i]);

}

}

var groups = this._batchGroups;

for (var group in groups) {

if (!groups.hasOwnProperty(group)) continue;

if (groups[group].name === name) {

return groups[group];

}

}

return null;

if (a && !b) return false;

if (!a && b) return false;

a = a.data;

b = b.data;

if (a === b) return true;

if (a instanceof Float32Array && b instanceof Float32Array) {

if (a.length !== b.length) return false;

for (var i = 0; i < a.length; i++) {

if (a[i] !== b[i]) return false;

}

return true;

}

return false;

if (meshInstances.length === 0) return [];

if (maxAabbSize === undefined) maxAabbSize = Number.POSITIVE_INFINITY;

var halfMaxAabbSize = maxAabbSize * 0.5;

var maxInstanceCount = this.device.supportsBoneTextures ? 1024 : this.device.boneLimit;

var i;

var material, layer, vertCount, params, params2, param, paramFailed, lightList, defs;

var aabb = new pc.BoundingBox();

var testAabb = new pc.BoundingBox();

var lists = [];

var j = 0;

var meshInstancesLeftA = meshInstances;

var meshInstancesLeftB;

var k;

while (meshInstancesLeftA.length > 0) {

lists[j] = [];

meshInstancesLeftB = [];

material = meshInstancesLeftA[0].material;

layer = meshInstancesLeftA[0].layer;

defs = meshInstancesLeftA[0]._shaderDefs;

params = meshInstancesLeftA[0].parameters;

lightList = meshInstancesLeftA[0]._staticLightList;

vertCount = meshInstancesLeftA[0].mesh.vertexBuffer.getNumVertices();

aabb.copy(meshInstancesLeftA[0].aabb);

for (i = 0; i < meshInstancesLeftA.length; i++) {

if (i > 0) {

// Split by material

if (material !== meshInstancesLeftA[i].material) {

meshInstancesLeftB.push(meshInstancesLeftA[i]);

continue;

}

// Split by layer (legacy)

if (layer !== meshInstancesLeftA[i].layer) {

meshInstancesLeftB.push(meshInstancesLeftA[i]);

continue;

}

// Split by shader defines

if (defs !== meshInstancesLeftA[i]._shaderDefs) {

meshInstancesLeftB.push(meshInstancesLeftA[i]);

continue;

}

// Split by static source

// Split by vert count

if (vertCount + meshInstancesLeftA[i].mesh.vertexBuffer.getNumVertices() > 0xFFFF) {

meshInstancesLeftB.push(meshInstancesLeftA[i]);

continue;

}

// Split by AABB

testAabb.copy(aabb);

testAabb.add(meshInstancesLeftA[i].aabb);

if (testAabb.halfExtents.x > halfMaxAabbSize ||

testAabb.halfExtents.y > halfMaxAabbSize ||

testAabb.halfExtents.z > halfMaxAabbSize) {

meshInstancesLeftB.push(meshInstancesLeftA[i]);

continue;

}

// Split by parameters

params2 = meshInstancesLeftA[i].parameters;

paramFailed = false;

for (param in params) { // compare A -> B

if (!params.hasOwnProperty(param)) continue;

if (!paramsIdentical(params[param], params2[param])) {

paramFailed = true;

break;

}

}

if (!paramFailed) {

for (param in params2) { // compare B -> A

if (!params2.hasOwnProperty(param)) continue;

if (!paramsIdentical(params2[param], params[param])) {

paramFailed = true;

break;

}

}

}

if (paramFailed) {

meshInstancesLeftB.push(meshInstancesLeftA[i]);

continue;

}

// Split by static/non static

params2 = meshInstancesLeftA[i]._staticLightList;

if ((lightList && !params2) || (!lightList && params2)) {

meshInstancesLeftB.push(meshInstancesLeftA[i]);

continue;

}

// Split by static light list

if (lightList && params2) {

paramFailed = false;

for (k = 0; k < lightList.length; k++) {

if (params2.indexOf(lightList[k]) < 0) {

paramFailed = true;

break;

}

}

for (k = 0; k < params2.length; k++) {

if (lightList.indexOf(params2[k]) < 0) {

paramFailed = true;

break;

}

}

if (paramFailed) {

meshInstancesLeftB.push(meshInstancesLeftA[i]);

continue;

}

}

}

aabb.add(meshInstancesLeftA[i].aabb);

vertCount += meshInstancesLeftA[i].mesh.vertexBuffer.getNumVertices();

lists[j].push(meshInstancesLeftA[i]);

// Split by instance number

if (dynamic && lists[j].length === maxInstanceCount) {

if (i === meshInstancesLeftA.length) {

meshInstancesLeftB = [];

} else {

meshInstancesLeftB = meshInstancesLeftA.slice(i + 1);

}

break;

}

}

j++;

meshInstancesLeftA = meshInstancesLeftB;

}

return lists;

// #ifdef PROFILER

var time = pc.now();

// #endif

if (!this._init) {

var boneLimit = "#define BONE_LIMIT " + this.device.getBoneLimit() + "\n";

this.transformVS = boneLimit + "#define DYNAMICBATCH\n" + pc.shaderChunks.transformVS;

this.skinTexVS = pc.shaderChunks.skinBatchTexVS;

this.skinConstVS = pc.shaderChunks.skinBatchConstVS;

this.vertexFormats = {};

this._init = true;

}

var i, j;

var batch = new pc.Batch(meshInstances, dynamic, batchGroupId);

this._batchList.push(batch);

// Check which vertex format and buffer size are needed, find out material

var material = null;

var mesh, elems, numVerts, vertSize;

var hasPos, hasNormal, hasUv, hasUv2, hasTangent, hasColor;

var batchNumVerts = 0;

var batchNumIndices = 0;

for (i = 0; i < meshInstances.length; i++) {

if (!material) {

material = meshInstances[i].material;

} else {

if (material !== meshInstances[i].material) {

// #ifdef DEBUG

console.error("BatchManager.create: multiple materials");

// #endif

return;

}

}

mesh = meshInstances[i].mesh;

elems = mesh.vertexBuffer.format.elements;

numVerts = mesh.vertexBuffer.numVertices;

batchNumVerts += numVerts;

for (j = 0; j < elems.length; j++) {

if (elems[j].name === pc.SEMANTIC_POSITION) {

hasPos = true;

} else if (elems[j].name === pc.SEMANTIC_NORMAL) {

hasNormal = true;

} else if (elems[j].name === pc.SEMANTIC_TEXCOORD0) {

hasUv = true;

} else if (elems[j].name === pc.SEMANTIC_TEXCOORD1) {

hasUv2 = true;

} else if (elems[j].name === pc.SEMANTIC_TANGENT) {

hasTangent = true;

} else if (elems[j].name === pc.SEMANTIC_COLOR) {

hasColor = true;

}

}

batchNumIndices += mesh.primitive[0].count;

}

if (!hasPos) {

// #ifdef DEBUG

console.error("BatchManager.create: no position");

// #endif

return;

}

// Create buffers

var entityIndexSizeF = dynamic ? 1 : 0;

var batchVertSizeF = 3 + (hasNormal ? 3 : 0) + (hasUv ? 2 : 0) + (hasUv2 ? 2 : 0) + (hasTangent ? 4 : 0) + (hasColor ? 1 : 0) + entityIndexSizeF;

var batchOffsetNF = 3;

var batchOffsetUF = hasNormal ? 3 * 2 : 3;

var batchOffsetU2F = (hasNormal ? 3 * 2 : 3) + (hasUv ? 2 : 0);

var batchOffsetTF = (hasNormal ? 3 * 2 : 3) + (hasUv ? 2 : 0) + (hasUv2 ? 2 : 0);

var batchOffsetCF = (hasNormal ? 3 * 2 : 3) + (hasUv ? 2 : 0) + (hasUv2 ? 2 : 0) + (hasTangent ? 4 : 0);

var batchOffsetEF = (hasNormal ? 3 * 2 : 3) + (hasUv ? 2 : 0) + (hasUv2 ? 2 : 0) + (hasTangent ? 4 : 0) + (hasColor ? 1 : 0);

var arrayBuffer = new ArrayBuffer(batchNumVerts * batchVertSizeF * 4);

var batchData = new Float32Array(arrayBuffer);

var batchData8 = new Uint8Array(arrayBuffer);

var indexBuffer = new pc.IndexBuffer(this.device, pc.INDEXFORMAT_UINT16, batchNumIndices, pc.BUFFER_STATIC);

var batchIndexData = new Uint16Array(indexBuffer.lock());

var vertSizeF;

// Fill vertex/index/matrix buffers

var data, data8, indexBase, numIndices, indexData;

var verticesOffset = 0;

var indexOffset = 0;

var vbOffset = 0;

var offsetPF, offsetNF, offsetUF, offsetU2F, offsetTF, offsetCF;

var transform, vec, vecData;

if (!dynamic) {

vec = new pc.Vec3();

vecData = vec.data;

}

for (i = 0; i < meshInstances.length; i++) {

mesh = meshInstances[i].mesh;

elems = mesh.vertexBuffer.format.elements;

numVerts = mesh.vertexBuffer.numVertices;

vertSize = mesh.vertexBuffer.format.size;

vertSizeF = vertSize / 4;

for (j = 0; j < elems.length; j++) {

if (elems[j].name === pc.SEMANTIC_POSITION) {

offsetPF = elems[j].offset / 4;

} else if (elems[j].name === pc.SEMANTIC_NORMAL) {

offsetNF = elems[j].offset / 4;

} else if (elems[j].name === pc.SEMANTIC_TEXCOORD0) {

offsetUF = elems[j].offset / 4;

} else if (elems[j].name === pc.SEMANTIC_TEXCOORD1) {

offsetU2F = elems[j].offset / 4;

} else if (elems[j].name === pc.SEMANTIC_TANGENT) {

offsetTF = elems[j].offset / 4;

} else if (elems[j].name === pc.SEMANTIC_COLOR) {

offsetCF = elems[j].offset / 4;