use native middleware buffer (#12233)

* use native middleware buffer

* fix clang-tidy

* fix clang-tidy

* set useLinkData as meshBuffer's property

* refactoring some code

* set 2d.ini

* fix word component

* fix clip middleware2d

* ...

* function attributes to getAttributes
This commit is contained in:
zhakesi
2022-07-28 19:00:30 +08:00
committed by GitHub
parent 73673aba9e
commit dc91a469ae
14 changed files with 249 additions and 184 deletions
+11
View File
@@ -128,6 +128,17 @@ export class MeshBuffer {
}
}
protected _useLinkedData = false;
get useLinkedData () {
return this._useLinkedData;
}
set useLinkedData (val:boolean) {
if (JSB && this._useLinkedData !== val) {
this._nativeObj.useLinkData = val;
}
this._useLinkedData = val;
}
private _vertexFormatBytes = 0;
private _initVDataCount = 0;
private _initIDataCount = 0;
+2
View File
@@ -65,6 +65,8 @@ export declare class NativeUIMeshBuffer {
set vData(val: Float32Array);
get iData(): Uint16Array;
set iData(val: Uint16Array);
get useLinkData(): boolean;
set useLinkData(val: boolean);
syncSharedBufferToNative(data: TypedArray);
+1
View File
@@ -333,6 +333,7 @@ export class RenderData extends BaseRenderData {
private _height = 0;
private _frame: SpriteFrame | TextureBase | null = null;
protected _accessor: StaticVBAccessor = null!;
get accessor () { return this._accessor; }
public vertexRow = 1;
public vertexCol = 1;
+196 -154
View File
@@ -29,6 +29,7 @@
#include "core/Root.h"
#include "renderer/pipeline/Define.h"
#include "scene/Pass.h"
#include "editor-support/MiddlewareManager.h"
namespace cc {
Batcher2d::Batcher2d() : Batcher2d(nullptr) {
@@ -113,7 +114,7 @@ void Batcher2d::walk(Node* node, float parentOpacity) { // NOLINT(misc-no-recurs
breakWalk = true;
}
}
if (!breakWalk) {
const auto& children = node->getChildren();
float thisOpacity = entity ? entity->getOpacity() : parentOpacity;
@@ -142,163 +143,184 @@ void Batcher2d::handlePostRender(RenderEntity* entity) {
_stencilManager->enableMask();
}
}
CC_FORCE_INLINE void Batcher2d::handleComponentDraw(RenderEntity* entity, RenderDrawInfo* drawInfo, Node* node) {
ccstd::hash_t dataHash = drawInfo->getDataHash();
if (drawInfo->getIsMeshBuffer()) {
dataHash = 0;
}
entity->setEnumStencilStage(_stencilManager->getStencilStage());
auto tempStage = static_cast<StencilStage>(entity->getStencilStage());
if (_currHash != dataHash || dataHash == 0 || _currMaterial != drawInfo->getMaterial() || _currStencilStage != tempStage) {
// Generate a batch if not batching
generateBatch(_currEntity, _currDrawInfo);
bool isSubMask = entity->getIsSubMask();
if (isSubMask) {
// Mask subComp
_stencilManager->enterLevel(entity);
}
if (!drawInfo->getIsMeshBuffer()) {
UIMeshBuffer* buffer = drawInfo->getMeshBuffer();
if (_currMeshBuffer != buffer) {
_currMeshBuffer = buffer;
_indexStart = _currMeshBuffer->getIndexOffset();
}
}
_currHash = dataHash;
_currMaterial = drawInfo->getMaterial();
_currStencilStage = tempStage;
_currLayer = entity->getNode()->getLayer();
_currEntity = entity;
_currDrawInfo = drawInfo;
_currTexture = drawInfo->getTexture();
_currSampler = drawInfo->getSampler();
if (_currSampler == nullptr) {
_currSamplerHash = 0;
} else {
_currSamplerHash = _currSampler->getHash();
}
}
if (!drawInfo->getIsMeshBuffer()) {
if (node->getChangedFlags() || drawInfo->getVertDirty()) {
fillVertexBuffers(entity, drawInfo);
drawInfo->setVertDirty(false);
}
if (entity->getVBColorDirty()) {
fillColors(entity, drawInfo);
}
fillIndexBuffers(drawInfo);
}
}
CC_FORCE_INLINE void Batcher2d::handleModelDraw(RenderEntity* entity, RenderDrawInfo* drawInfo) {
generateBatch(_currEntity, _currDrawInfo);
resetRenderStates();
// stencil stage
gfx::DepthStencilState* depthStencil = nullptr;
ccstd::hash_t dssHash = 0;
Material* renderMat = drawInfo->getMaterial();
bool isMask = entity->getIsMask();
bool isSubMask = entity->getIsSubMask();
if (isMask) {
//Mask node
_stencilManager->pushMask();
_stencilManager->clear(entity);
} else if (isSubMask) {
//Mask Comp
_stencilManager->enterLevel(entity);
}
_currStencilStage = _stencilManager->getStencilStage();
StencilStage entityStage = entity->getEnumStencilStage();
if (entityStage == StencilStage::ENABLED || entityStage == StencilStage::DISABLED) {
entity->setEnumStencilStage(_stencilManager->getStencilStage());
}
depthStencil = _stencilManager->getDepthStencilState(entityStage, renderMat);
dssHash = _stencilManager->getStencilHash(entityStage);
// Model
auto* model = drawInfo->getModel();
if (model == nullptr) return;
auto stamp = CC_CURRENT_ENGINE()->getTotalFrames();
model->updateTransform(stamp);
model->updateUBOs(stamp);
const auto& subModelList = model->getSubModels();
for (const auto& submodel : subModelList) {
auto* curdrawBatch = _drawBatchPool.alloc();
curdrawBatch->setVisFlags(entity->getNode()->getLayer());
curdrawBatch->setModel(model);
curdrawBatch->setInputAssembler(submodel->getInputAssembler());
curdrawBatch->setDescriptorSet(submodel->getDescriptorSet());
curdrawBatch->fillPass(renderMat, depthStencil, dssHash, &(submodel->getPatches()));
_batches.push_back(curdrawBatch);
}
}
CC_FORCE_INLINE void Batcher2d::handleIADraw(RenderEntity* entity, RenderDrawInfo* drawInfo, Node* node) {
generateBatch(_currEntity, _currDrawInfo);
uint32_t dataHash = drawInfo->getDataHash();
entity->setEnumStencilStage(_stencilManager->getStencilStage());
auto tempStage = static_cast<StencilStage>(entity->getStencilStage());
_currHash = dataHash;
_currMaterial = drawInfo->getMaterial();
_currStencilStage = tempStage;
_currLayer = entity->getNode()->getLayer();
// make sure next generateBatch return.
_currEntity = nullptr;
_currDrawInfo = nullptr;
_currMeshBuffer = nullptr;
// if(frame)
_currTexture = drawInfo->getTexture();
_currSampler = drawInfo->getSampler();
_currSamplerHash = _currSampler->getHash();
setIndexRange(drawInfo);
UIMeshBuffer* currMeshBuffer = drawInfo->getMeshBuffer();
currMeshBuffer->setDirty(true);
gfx::InputAssembler* ia = currMeshBuffer->requireFreeIA(getDevice());
ia->setFirstIndex(drawInfo->getIndexOffset());
ia->setIndexCount(drawInfo->getIbCount());
// stencilstage
gfx::DepthStencilState* depthStencil = nullptr;
ccstd::hash_t dssHash = 0;
StencilStage entityStage = entity->getEnumStencilStage();
depthStencil = _stencilManager->getDepthStencilState(entityStage, drawInfo->getMaterial());
dssHash = _stencilManager->getStencilHash(entityStage);
auto* curdrawBatch = _drawBatchPool.alloc();
curdrawBatch->setVisFlags(_currLayer);
curdrawBatch->setInputAssembler(ia);
curdrawBatch->fillPass(_currMaterial, depthStencil, dssHash);
const auto& pass = curdrawBatch->getPasses().at(0);
if (entity->getUseLocal()) {
drawInfo->updateLocalDescriptorSet(node, pass->getLocalSetLayout());
curdrawBatch->setDescriptorSet(drawInfo->getLocalDes());
} else {
curdrawBatch->setDescriptorSet(getDescriptorSet(_currTexture, _currSampler, pass->getLocalSetLayout()));
}
_batches.push_back(curdrawBatch);
}
CC_FORCE_INLINE void Batcher2d::handleSubNode(RenderEntity* entity, RenderDrawInfo* drawInfo) { // NOLINT
if (drawInfo->getSubNode()) {
walk(drawInfo->getSubNode(), entity->getOpacity());
}
}
CC_FORCE_INLINE void Batcher2d::handleDrawInfo(RenderEntity* entity, RenderDrawInfo* drawInfo, Node* node) { //NOLINT(misc-no-recursion)
CC_ASSERT(entity);
CC_ASSERT(drawInfo);
RenderDrawInfoType drawInfoType = drawInfo->getEnumDrawInfoType();
if (drawInfoType == RenderDrawInfoType::COMP) {
ccstd::hash_t dataHash = drawInfo->getDataHash();
if (drawInfo->getIsMeshBuffer()) {
dataHash = 0;
}
entity->setEnumStencilStage(_stencilManager->getStencilStage());
auto tempStage = static_cast<StencilStage>(entity->getStencilStage());
if (_currHash != dataHash || dataHash == 0 || _currMaterial != drawInfo->getMaterial() || _currStencilStage != tempStage) {
// Generate a batch if not batching
generateBatch(_currEntity, _currDrawInfo);
bool isSubMask = entity->getIsSubMask();
if (isSubMask) {
// Mask subComp
_stencilManager->enterLevel(entity);
}
if (!drawInfo->getIsMeshBuffer()) {
UIMeshBuffer* buffer = drawInfo->getMeshBuffer();
if (_currMeshBuffer != buffer) {
_currMeshBuffer = buffer;
_indexStart = _currMeshBuffer->getIndexOffset();
}
}
_currHash = dataHash;
_currMaterial = drawInfo->getMaterial();
_currStencilStage = tempStage;
_currLayer = entity->getNode()->getLayer();
_currEntity = entity;
_currDrawInfo = drawInfo;
_currTexture = drawInfo->getTexture();
_currSampler = drawInfo->getSampler();
if (_currSampler == nullptr) {
_currSamplerHash = 0;
} else {
_currSamplerHash = _currSampler->getHash();
}
}
if (!drawInfo->getIsMeshBuffer()) {
if (node->getChangedFlags() || drawInfo->getVertDirty()) {
fillVertexBuffers(entity, drawInfo);
drawInfo->setVertDirty(false);
}
if (entity->getVBColorDirty()) {
fillColors(entity, drawInfo);
}
fillIndexBuffers(drawInfo);
}
} else if (drawInfoType == RenderDrawInfoType::MODEL) {
generateBatch(_currEntity, _currDrawInfo);
resetRenderStates();
// stencil stage
gfx::DepthStencilState* depthStencil = nullptr;
ccstd::hash_t dssHash = 0;
Material* renderMat = drawInfo->getMaterial();
bool isMask = entity->getIsMask();
bool isSubMask = entity->getIsSubMask();
if (isMask) {
//Mask node
_stencilManager->pushMask();
_stencilManager->clear(entity);
} else if (isSubMask) {
//Mask Comp
_stencilManager->enterLevel(entity);
}
_currStencilStage = _stencilManager->getStencilStage();
StencilStage entityStage = entity->getEnumStencilStage();
if (entityStage == StencilStage::ENABLED || entityStage == StencilStage::DISABLED) {
entity->setEnumStencilStage(_stencilManager->getStencilStage());
}
depthStencil = _stencilManager->getDepthStencilState(entityStage, renderMat);
dssHash = _stencilManager->getStencilHash(entityStage);
// Model
auto* model = drawInfo->getModel();
if (model == nullptr) return;
auto stamp = CC_CURRENT_ENGINE()->getTotalFrames();
model->updateTransform(stamp);
model->updateUBOs(stamp);
const auto& subModelList = model->getSubModels();
for (const auto& submodel : subModelList) {
auto* curdrawBatch = _drawBatchPool.alloc();
curdrawBatch->setVisFlags(entity->getNode()->getLayer());
curdrawBatch->setModel(model);
curdrawBatch->setInputAssembler(submodel->getInputAssembler());
curdrawBatch->setDescriptorSet(submodel->getDescriptorSet());
curdrawBatch->fillPass(renderMat, depthStencil, dssHash, &(submodel->getPatches()));
_batches.push_back(curdrawBatch);
}
} else if (drawInfoType == RenderDrawInfoType::IA) {
generateBatch(_currEntity, _currDrawInfo);
uint32_t dataHash = drawInfo->getDataHash();
entity->setEnumStencilStage(_stencilManager->getStencilStage());
auto tempStage = static_cast<StencilStage>(entity->getStencilStage());
_currHash = dataHash;
_currMaterial = drawInfo->getMaterial();
_currStencilStage = tempStage;
_currLayer = entity->getNode()->getLayer();
// make sure next generateBatch return.
_currEntity = nullptr;
_currDrawInfo = nullptr;
_currMeshBuffer = nullptr;
// if(frame)
_currTexture = drawInfo->getTexture();
_currSampler = drawInfo->getSampler();
_currSamplerHash = _currSampler->getHash();
setIndexRange(drawInfo);
UIMeshBuffer* currMeshBuffer = drawInfo->getMeshBuffer();
currMeshBuffer->setDirty(true);
gfx::InputAssembler* ia = currMeshBuffer->requireFreeIA(getDevice());
ia->setFirstIndex(drawInfo->getIndexOffset());
ia->setIndexCount(drawInfo->getIbCount());
// stencilstage
gfx::DepthStencilState* depthStencil = nullptr;
ccstd::hash_t dssHash = 0;
StencilStage entityStage = entity->getEnumStencilStage();
depthStencil = _stencilManager->getDepthStencilState(entityStage, drawInfo->getMaterial());
dssHash = _stencilManager->getStencilHash(entityStage);
auto* curdrawBatch = _drawBatchPool.alloc();
curdrawBatch->setVisFlags(_currLayer);
curdrawBatch->setInputAssembler(ia);
curdrawBatch->fillPass(_currMaterial, depthStencil, dssHash);
const auto& pass = curdrawBatch->getPasses().at(0);
if (entity->getUseLocal()) {
drawInfo->updateLocalDescriptorSet(node, pass->getLocalSetLayout());
curdrawBatch->setDescriptorSet(drawInfo->getLocalDes());
} else {
curdrawBatch->setDescriptorSet(getDescriptorSet(_currTexture, _currSampler, pass->getLocalSetLayout()));
}
_batches.push_back(curdrawBatch);
} else {
if (drawInfo->getSubNode()) {
walk(drawInfo->getSubNode(), entity->getOpacity());
}
switch (drawInfoType) {
case RenderDrawInfoType::COMP:
handleComponentDraw(entity, drawInfo, node);
break;
case RenderDrawInfoType::MODEL:
handleModelDraw(entity, drawInfo);
break;
case RenderDrawInfoType::IA:
handleIADraw(entity, drawInfo, node);
break;
case RenderDrawInfoType::SUB_NODE:
handleSubNode(entity, drawInfo);
break;
default:
break;
}
}
@@ -306,7 +328,6 @@ void Batcher2d::generateBatch(RenderEntity* entity, RenderDrawInfo* drawInfo) {
if (drawInfo == nullptr || _currMaterial == nullptr) {
return;
}
gfx::InputAssembler* ia = nullptr;
if (drawInfo->getIsMeshBuffer()) {
// Todo MeshBuffer RenderData
@@ -431,13 +452,34 @@ void Batcher2d::uploadBuffers() {
meshRenderData->uploadBuffers();
}
size_t i = 0;
size_t ii = 0;
for (auto& map : _meshBuffersMap) {
for (auto& buffer : map.second) {
#if CC_USE_MIDDLEWARE
// set vData and iData With Middleware buffer.
if (buffer->getUseLinkData()) {
int nativeFormat = 9;
size_t index = i;
if (buffer->getAttributes().size() == 3) {
i++;
} else {
nativeFormat = 13;
index = ii;
ii++;
}
auto *middleWare = middleware::MiddlewareManager::getInstance();
auto *middleBuffer = middleWare->getMeshBuffer(nativeFormat);
auto *srcIBuf = middleBuffer->getIBFromBufferArray(index);
auto *srcVBuf = middleBuffer->getVBFromBufferArray(index);
buffer->setVData(reinterpret_cast<float *>(srcVBuf));
buffer->setIData(reinterpret_cast<uint16_t*>(srcIBuf));
}
#endif
buffer->uploadBuffers();
buffer->reset();
}
}
updateDescriptorSet();
}
+4
View File
@@ -67,6 +67,10 @@ public:
void walk(Node* node, float parentOpacity);
void handlePostRender(RenderEntity* entity);
void handleDrawInfo(RenderEntity* entity, RenderDrawInfo* drawInfo, Node* node);
void handleComponentDraw(RenderEntity* entity, RenderDrawInfo* drawInfo, Node* node);
void handleModelDraw(RenderEntity* entity, RenderDrawInfo* drawInfo);
void handleIADraw(RenderEntity* entity, RenderDrawInfo* drawInfo, Node* node);
void handleSubNode(RenderEntity* entity, RenderDrawInfo* drawInfo);
void generateBatch(RenderEntity* entity, RenderDrawInfo* drawInfo);
void resetRenderStates();
+1 -1
View File
@@ -49,7 +49,7 @@ enum class RenderDrawInfoType: uint8_t {
COMP,
MODEL,
IA,
SUB_NODE
SUB_NODE,
};
struct LocalDSBF {
@@ -180,4 +180,5 @@ void UIMeshBuffer::setDirty(bool dirty) const {
void UIMeshBuffer::setFloatsPerVertex(uint32_t floatsPerVertex) {
_meshBufferLayout->floatsPerVertex = floatsPerVertex;
}
} // namespace cc
+6 -2
View File
@@ -52,9 +52,7 @@ public:
void destroy();
void setDirty();
void uploadBuffers();
void syncSharedBufferToNative(uint32_t* buffer);
void resetIA();
void recycleIA(gfx::InputAssembler* ia);
void parseLayout();
@@ -72,6 +70,11 @@ public:
void setDirty(bool dirty) const;
inline uint32_t getFloatsPerVertex() const { return _meshBufferLayout->floatsPerVertex; }
void setFloatsPerVertex(uint32_t floatsPerVertex);
inline bool getUseLinkData() const { return _useLinkData; }
inline void setUseLinkData(bool val) { _useLinkData = val;}
inline const ccstd::vector<gfx::Attribute> &getAttributes() const {
return _attributes;
}
protected:
CC_DISALLOW_COPY_MOVE_ASSIGN(UIMeshBuffer);
@@ -96,5 +99,6 @@ private:
gfx::InputAssemblerInfo _iaInfo;
uint32_t _nextFreeIAHandle{0};
bool _needDeleteVData{false};
bool _useLinkData{false};
};
} // namespace cc
+10
View File
@@ -48,6 +48,16 @@ public:
return _ibArr[bufferPos]->getTypeArray();
}
uint8_t *getVBFromBufferArray(std::size_t index) {
if (_vbArr.size() <= index) return nullptr;
return _vbArr[index]->getBuffer();
}
uint8_t *getIBFromBufferArray(std::size_t index) {
if (_ibArr.size() <= index) return nullptr;
return _ibArr[index]->getBuffer();
}
std::size_t getVBTypedArrayLength(std::size_t bufferPos) {
if (_vbArr.size() <= bufferPos) return 0;
return _vbArr[bufferPos]->length();
@@ -24,8 +24,8 @@
****************************************************************************/
#pragma once
// index buffer init capacity
#define INIT_INDEX_BUFFER_SIZE 1024000
// index buffer init capacity 8 * vertex size
#define INIT_INDEX_BUFFER_SIZE 524280
// max vertex buffer size
#define MAX_VERTEX_BUFFER_SIZE 65535
// render info int capacity
+3 -3
View File
@@ -47,14 +47,14 @@ classes = RenderDrawInfo UIMeshBuffer Batcher2d RenderEntity UIModelProxy
# will apply to all class names. This is a convenience wildcard to be able to skip similar named
# functions from all classes.
skip = RenderDrawInfo::[getBatcher setBatcher parseAttrLayout getRender2dLayout getEnumDrawInfoType],
Batcher2d::[addVertDirtyRenderer getMeshBuffer getDevice updateDescriptorSet fillBuffersAndMergeBatches walk generateBatch resetRenderStates handleDrawInfo],
UIMeshBuffer::[requireFreeIA createNewIA recycleIA resetIA parseLayout getByteOffset setByteOffset getVertexOffset setVertexOffset getIndexOffset setIndexOffset getDirty setDirty getFloatsPerVertex setFloatsPerVertex],
Batcher2d::[addVertDirtyRenderer getMeshBuffer getDevice updateDescriptorSet fillBuffersAndMergeBatches walk generateBatch resetRenderStates handleDrawInfo handleComponentDraw handleModelDraw handleIADraw handleSubNode],
UIMeshBuffer::[requireFreeIA createNewIA recycleIA resetIA parseLayout getByteOffset setByteOffset getVertexOffset setVertexOffset getIndexOffset setIndexOffset getDirty setDirty getFloatsPerVertex setFloatsPerVertex getAttributes],
RenderEntity::[getDynamicRenderDrawInfo getDynamicRenderDrawInfos getRenderEntityType getColorDirty getColor isEnabled getEnumStencilStage setEnumStencilStage getVBColorDirty setVBColorDirty]
rename_functions =
getter_setter = RenderDrawInfo::[bufferId accId vertexOffset indexOffset vbBuffer ibBuffer vDataBuffer iDataBuffer vbCount ibCount vertDirty dataHash isMeshBuffer material texture sampler model drawInfoType subNode stride],
UIMeshBuffer::[vData iData],
UIMeshBuffer::[vData iData useLinkData],
RenderEntity::[node staticDrawInfoSize stencilStage]
field =
+3 -2
View File
@@ -778,11 +778,12 @@ const cacheManager = require('./jsb-cache-manager');
const renderData = middleware.RenderInfoLookup[middleware.vfmtPosUvColor][_tempBufferIndex];
const drawInfo = this.requestDrawInfo(index);
drawInfo.setDrawInfoType(renderData.drawInfoType);
drawInfo.setAccId(renderData.accessor.id);
drawInfo.setBufferId(renderData.chunk.bufferId);
drawInfo.setTexture(realTexture.getGFXTexture());
drawInfo.setSampler(realTexture.getGFXSampler());
drawInfo.setMaterial(this.material);
renderData.fillDrawInfoAttributes(drawInfo);
drawInfo.setIndexOffset(_tempIndicesOffset);
drawInfo.setIBCount(_tempIndicesCount);
+6 -18
View File
@@ -84,32 +84,20 @@
const bufferCount = middlewareMgr.getBufferCount(nativeFormat);
for (let i = 0; i < bufferCount; i++) {
const ibBytesLength = middlewareMgr.getIBTypedArrayLength(nativeFormat, i);
const vbBytesLength = middlewareMgr.getVBTypedArrayLength(nativeFormat, i);
const srcIndicesCount = ibBytesLength / 2; // USHORT
const srcVertexCount = vbBytesLength / nativeFormat / 4;
const srcVertexFloatCount = srcVertexCount * nativeFormat;
let buffer = renderInfoLookup[nativeFormat][i];
if (!buffer) {
if (!_accessors[jsFormat]) {
_accessors[jsFormat] = cc.UI.RenderData.createStaticVBAccessor(jsFormat, 65535);
_accessors[jsFormat] = cc.UI.RenderData.createStaticVBAccessor(jsFormat, 65535, 524280);
}
buffer = cc.UI.RenderData.add(jsFormat, _accessors[jsFormat]);
buffer.multiOwner = true;
buffer.drawInfoType = RenderDrawInfoType_IA;
// vertex count 65535, indices count 8 * 65535
buffer.resize(65535, 524280);
const meshBuffer = buffer.getMeshBuffer();
meshBuffer.useLinkedData = true;
renderInfoLookup[nativeFormat][i] = buffer;
}
const srcVBuf = middlewareMgr.getVBTypedArray(nativeFormat, i);
const srcIBuf = middlewareMgr.getIBTypedArray(nativeFormat, i);
buffer.resize(srcVertexCount, srcIndicesCount);
const vData = buffer.chunk.vb;
const iData = buffer.chunk.meshBuffer.iData;
vData.set(srcVBuf.subarray(0, srcVertexFloatCount), 0);
iData.set(srcIBuf.subarray(0, srcIndicesCount), 0);
renderInfoLookup[nativeFormat][i] = buffer;
}
}
@@ -885,11 +885,12 @@ const cacheManager = require('./jsb-cache-manager');
const renderData = middleware.RenderInfoLookup[_tempVfmt][_tempBufferIndex];
const drawInfo = this.requestDrawInfo(index);
drawInfo.setDrawInfoType(renderData.drawInfoType);
drawInfo.setAccId(renderData.accessor.id);
drawInfo.setBufferId(renderData.chunk.bufferId);
drawInfo.setTexture(realTexture.getGFXTexture());
drawInfo.setSampler(realTexture.getGFXSampler());
drawInfo.setMaterial(this.material);
renderData.fillDrawInfoAttributes(drawInfo);
drawInfo.setIndexOffset(_tempIndicesOffset);
drawInfo.setIBCount(_tempIndicesCount);