hyzboy/ULRE
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

newly Primitive/PrimitiveData/PrimitiveCreater, and test OK! can RUN!

Browse Source
This commit is contained in:
hyzboy 2024-05-25 01:46:19 +08:00
parent 78b1982849
commit 299d3bd019
10 changed files with 286 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
inc/hgl/graph/PrimitiveCreater.h
View File

@ -1,12 +1,11 @@
#pragma once
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/VertexAttribDataAccess.h>
#include<hgl/graph/VKShaderModule.h>
#include<hgl/graph/VKIndexBuffer.h>
#include<hgl/graph/VKVertexAttribBuffer.h>
VK_NAMESPACE_BEGIN
/**
* 可绘制图元创建器
*/
@ -14,37 +13,30 @@ class PrimitiveCreater
{
protected:
GPUDevice *device;
const GPUPhysicalDevice *phy_device;
GPUDevice * device;
const VIL * vil;
protected:
AnsiString prim_name;
PrimitiveData * prim_data;
AnsiString prim_name; ///<名称
PrimitiveData * prim_data; ///<图元数据
protected:
VkDeviceSize vertices_number; ///<顶点数量
uint vab_proc_count; ///<操作的vab数量
VkDeviceSize index_number; ///<索引数量
IBAccess * iba;
protected:
void ClearAllData();
IndexType index_type; ///<索引类型
IBAccess * iba; ///<索引缓冲区
public:
PrimitiveCreater(GPUDevice *,const VIL *,const AnsiString &name);
PrimitiveCreater(VertexDataManager *);
virtual ~PrimitiveCreater()
{
ClearAllData();
}
virtual ~PrimitiveCreater();
virtual bool Init(const VkDeviceSize vertices_count,const VkDeviceSize index_count,IndexType it=IndexType::AUTO); ///<初始化，参数为顶点数量
public: //顶点缓冲区
const VkDeviceSize GetVertexCount()const{ return vertices_number; } ///<取得顶点数量
VABAccess * AcquirePVB (const AnsiString &name,const VkFormat &format,const void *data=nullptr,const VkDeviceSize bytes=0); ///<请求一个顶点属性数据区
@ -53,15 +45,21 @@ public:
return AcquirePVB(name,format,data,bytes);
}
const IndexType GetIndexType()const{return iba->buffer->GetType();}
IBAccess * AcquireIBO(){return iba;}
public: //索引缓冲区
const IndexType GetIndexType()const{return index_type;}
void * MapIBO();
void UnmapIBO();
bool WriteIBO(const void *data,const VkDeviceSize bytes);
template<typename T>
bool WriteIBO(const T *data){return WriteIBO(data,index_number*sizeof(T));}
virtual Primitive * Finish(RenderResource *); ///<结束并创建可渲染对象
public: //创建可渲染对象
virtual Primitive * Create(); ///<创建一个可渲染对象
};//class PrimitiveCreater
/**
@ -186,30 +184,28 @@ typedef VABMap<VB4d> VABMap4d;
*/
template<typename T> class IBMap
{
IBAccess *iba;
PrimitiveCreater *pc;
T *map_ptr;
public:
IBMap(IBAccess *a)
IBMap(PrimitiveCreater *c)
{
iba=a;
pc=c;
if(iba)
map_ptr=(T *)(iba->buffer->Map(iba->start,iba->count));
if(pc)
map_ptr=(T *)(pc->MapIBO());
else
map_ptr=nullptr;
}
IBMap(PrimitiveCreater *pc):IBMap(pc->AcquireIBO()){}
~IBMap()
{
if(iba)
iba->buffer->Unmap();
if(map_ptr&&pc)
pc->UnmapIBO();
}
const bool IsValid()const{ return iba; }
const bool IsValid()const{ return map_ptr; }
operator T *(){ return map_ptr; }
};//template<typename T> class IBMap

2
inc/hgl/graph/VK.h
View File

@ -118,7 +118,7 @@ using VIF=VertexInputFormat;
class VertexInputLayout;
using VIL=VertexInputLayout;
struct PrimitiveData;
class PrimitiveData;
class Primitive;
class Renderable;

23
inc/hgl/graph/VKPrimitive.h
View File

@ -24,36 +24,27 @@ class Primitive
{
protected:
AnsiString prim_name;
PrimitiveData *prim_data;
AnsiString prim_name;
PrimitiveData * prim_data;
protected:
AABB BoundingBox;
protected:
Primitive(const AnsiString &pn,PrimitiveData *pd)
{
prim_name=pn;
prim_data=pd;
}
public:
virtual ~Primitive()=default;
Primitive(const AnsiString &pn,PrimitiveData *pd);
virtual ~Primitive();
public:
const AnsiString & GetName ()const{ return prim_name; }
const VkDeviceSize GetVertexCount ()const;
const int GetVACount ()const;
const int GetVABCount ()const;
VABAccess * GetVABAccess (const AnsiString &);
IBAccess * GetIBAccess ();
const AABB & GetBoundingBox ()const{return BoundingBox;}
};//class Primitive
Primitive *CreatePrimitivePrivate(const AnsiString &,PrimitiveData *);
Primitive *CreatePrimitivePrivate(VertexDataManager *,const AnsiString &,PrimitiveData *);
VK_NAMESPACE_END

2
inc/hgl/graph/VertexAttribDataAccess.h
View File

@ -6,6 +6,8 @@
#include<hgl/type/RectScope.h>
#include<hgl/type/String.h>
#include<hgl/log/LogInfo.h>
#include<hgl/graph/VKFormat.h>
#include<hgl/graph/AABB.h>
namespace hgl
{
namespace graph

1
src/SceneGraph/CMakeLists.txt
View File

@ -17,6 +17,7 @@ SOURCE_GROUP("VertexDataManager" FILES ${SG_VDM_SOURCE})
SET(SG_PRIMITIVE_SOURCE ${SG_INCLUDE_PATH}/VKPrimitive.h
Vulkan/VKPrimitive.cpp
Vulkan/VKPrimitiveData.cpp
Vulkan/VKPrimitiveData.h
${SG_INCLUDE_PATH}/VKRenderablePrimitiveCreater.h
${SG_INCLUDE_PATH}/PrimitiveCreater.h
PrimitiveCreater.cpp)

121
src/SceneGraph/PrimitiveCreater.cpp
View File

@ -1,52 +1,36 @@
#include<hgl/graph/PrimitiveCreater.h>
#include<hgl/graph/VKShaderModule.h>
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKIndexBuffer.h>
#include<hgl/graph/VKVertexAttribBuffer.h>
#include<hgl/graph/VKPrimitive.h>
//#include<hgl/graph/VertexDataManager.h>
#include"vulkan/VKPrimitiveData.h"
VK_NAMESPACE_BEGIN
PrimitiveData *CreatePrimitiveData(const VIL *_vil,const VkDeviceSize vc);
IBAccess * GetIBAccess( PrimitiveData *pd);
void SetIndexBuffer( PrimitiveData *pd,IndexBuffer *ib,const VkDeviceSize ic);
VABAccess * GetVABAccess( PrimitiveData *pd,const int);
void Destory( PrimitiveData *pd);
PrimitiveCreater::PrimitiveCreater(GPUDevice *dev,const VIL *v,const AnsiString &name)
{
device =dev;
phy_device =device->GetPhysicalDevice();
vil =v;
prim_name =name;
prim_data =nullptr;
vertices_number =0;
vab_proc_count =0;
index_number =0;
index_type =IndexType::ERR;
iba =nullptr;
}
//PrimitiveCreater::PrimitiveCreater(VertexDataManager *_vdm)
//{
// device =_vdm->GetDevice();
// phy_device =device->GetPhysicalDevice();
//
// vdm =_vdm;
// vil =vdm->GetVIL();
//
// vertices_number =0;
// index_number =0;
// ibo =nullptr;
// ibo_map =nullptr;
//}
PrimitiveCreater::~PrimitiveCreater()
{
SAFE_CLEAR(prim_data);
}
bool PrimitiveCreater::Init(const VkDeviceSize vertex_count,const VkDeviceSize index_count,IndexType it)
{
if(vertex_count<=0)return(false);
prim_data=CreatePrimitiveData(vil,vertex_count);
prim_data=CreatePrimitiveData(device,vil,vertex_count);
if(!prim_data)return(false);
@ -67,15 +51,12 @@ bool PrimitiveCreater::Init(const VkDeviceSize vertex_count,const VkDeviceSize i
return(false);
}
iba=GetIBAccess(prim_data);
iba=prim_data->InitIBO(index_count,it);
iba->buffer=device->CreateIBO(it,index_count);
if(!iba->buffer)return(false);
iba->start=0;
iba->count=index_count;
if(!iba)
return(false);
index_type=it;
index_number=index_count;
#ifdef _DEBUG
@ -94,37 +75,16 @@ bool PrimitiveCreater::Init(const VkDeviceSize vertex_count,const VkDeviceSize i
VABAccess *PrimitiveCreater::AcquirePVB(const AnsiString &name,const VkFormat &acquire_format,const void *data,const VkDeviceSize bytes)
{
if(!vil)return(nullptr);
if(!prim_data)return(nullptr);
if(name.IsEmpty())return(nullptr);
const int index=vil->GetIndex(name);
if(index<0||index>=vil->GetCount())
return(nullptr);
const VertexInputFormat *vif=vil->GetConfig(index);
if(!vif)
return(nullptr);
if(vif->format!=acquire_format)
return(nullptr);
if(data)
if(vif->stride*vertices_number!=bytes)
return(nullptr);
VABAccess *vab_access=GetVABAccess(prim_data,index);
VABAccess *vab_access=prim_data->InitVAB(name,acquire_format,data,bytes);
if(!vab_access)
return(nullptr);
if(!vab_access->vab)
{
vab_access->vab=device->CreateVAB(vif->format,vertices_number,data);
vab_access->start=0;
vab_access->count=vertices_number;
if(vab_access->vab)
{
#ifdef _DEBUG
DebugUtils *du=device->GetDebugUtils();
@ -134,19 +94,32 @@ VABAccess *PrimitiveCreater::AcquirePVB(const AnsiString &name,const VkFormat &a
du->SetDeviceMemory(vab_access->vab->GetVkMemory(), prim_name+":VAB:Memory:"+name);
}
#endif//_DEBUG
++vab_proc_count;
}
if(data)
vab_access->vab->Write(data,bytes);
return vab_access;
}
void *PrimitiveCreater::MapIBO()
{
if(!prim_data)return(nullptr);
if(!iba)return(nullptr);
return iba->buffer->Map(iba->start,iba->count);
}
void PrimitiveCreater::UnmapIBO()
{
if(iba)
iba->buffer->Unmap();
}
bool PrimitiveCreater::WriteIBO(const void *data,const VkDeviceSize bytes)
{
if(!data)return(false);
if(!prim_data)return(false);
IBAccess *iba=prim_data->GetIBAccess();
if(bytes>0)
if(iba->buffer->GetStride()*index_number<bytes)return(false);
@ -154,34 +127,18 @@ bool PrimitiveCreater::WriteIBO(const void *data,const VkDeviceSize bytes)
return iba->buffer->Write(data,bytes);
}
void PrimitiveCreater::ClearAllData()
Primitive *PrimitiveCreater::Create()
{
iba=nullptr;
if(prim_data)
{
Destory(prim_data);
prim_data=nullptr;
}
}
Primitive *PrimitiveCreater::Finish(RenderResource *rr)
{
const uint si_count=vil->GetCount(VertexInputGroup::Basic);
if(vab_proc_count!=si_count)
if(!prim_data)
return(nullptr);
Primitive *primitive=rr->CreatePrimitive(prim_name,prim_data);
Primitive *primitive=new Primitive(prim_name,prim_data);
if(!primitive)
{
ClearAllData();
return(nullptr);
}
iba=nullptr;
prim_data=nullptr;
iba=nullptr;
return primitive;
}

83
src/SceneGraph/Vulkan/VKPrimitive.cpp
View File

@ -3,6 +3,7 @@
#include<hgl/graph/VKShaderModule.h>
#include<hgl/graph/VKVertexAttribBuffer.h>
#include<hgl/graph/VKIndexBuffer.h>
#include"VKPrimitiveData.h"
#ifdef _DEBUG
#include<hgl/graph/VKDevice.h>
@ -11,65 +12,6 @@
VK_NAMESPACE_BEGIN
const VkDeviceSize GetVertexCount( PrimitiveData *pd);
const int GetVABCount( PrimitiveData *pd);
VABAccess * GetVABAccess( PrimitiveData *pd,const AnsiString &name);
IBAccess * GetIBAccess( PrimitiveData *pd);
void Destory( PrimitiveData *pd);
void Free( PrimitiveData *pd);
class PrimitivePrivateBuffer:public Primitive
{
public:
using Primitive::Primitive;
~PrimitivePrivateBuffer() override
{
Destory(prim_data);
}
friend Primitive *CreatePrimitivePrivate(const AnsiString &,PrimitiveData *);
};//class PrimitivePrivateBuffer
class PrimitiveVDM:public Primitive
{
VertexDataManager *vdm;
public:
PrimitiveVDM(VertexDataManager *_vdm,const AnsiString &pn,PrimitiveData *pd):Primitive(pn,pd)
{
vdm=_vdm;
}
~PrimitiveVDM() override
{
Free(prim_data);
}
friend Primitive *CreatePrimitivePrivate(VertexDataManager *,const AnsiString &,PrimitiveData *);
};//class PrimitiveVDM;
Primitive *CreatePrimitivePrivate(const AnsiString &name,PrimitiveData *pd)
{
if(!pd)return(nullptr);
if(name.IsEmpty())return(nullptr);
return(new PrimitivePrivateBuffer(name,pd));
}
Primitive *CreatePrimitivePrivate(VertexDataManager *vdm,const AnsiString &name,PrimitiveData *pd)
{
if(!vdm)return(nullptr);
if(!pd)return(nullptr);
if(name.IsEmpty())return(nullptr);
return(new PrimitiveVDM(vdm,name,pd));
}
//bool Renderable::Set(const int stage_input_binding,VIL *vil,VkDeviceSize offset)
//{
// if(stage_input_binding<0||stage_input_binding>=buf_count||!vil)return(false);
@ -88,24 +30,35 @@ Primitive *CreatePrimitivePrivate(VertexDataManager *vdm,const AnsiString &name,
// return(true);
//}
const VkDeviceSize Primitive::GetVertexCount()const
Primitive::Primitive(const AnsiString &pn,PrimitiveData *pd)
{
return VK_NAMESPACE::GetVertexCount(prim_data);
prim_name=pn;
prim_data=pd;
}
const int Primitive::GetVACount()const
Primitive::~Primitive()
{
return GetVABCount(prim_data);
SAFE_CLEAR(prim_data);
}
const VkDeviceSize Primitive::GetVertexCount()const
{
return prim_data->GetVertexCount();
}
const int Primitive::GetVABCount()const
{
return prim_data->GetVABCount();
}
VABAccess *Primitive::GetVABAccess(const AnsiString &name)
{
return VK_NAMESPACE::GetVABAccess(prim_data,name);
return prim_data->GetVABAccess(name);
}
IBAccess *Primitive::GetIBAccess()
{
return VK_NAMESPACE::GetIBAccess(prim_data);
return prim_data->GetIBAccess();
}
VK_NAMESPACE_END

231
src/SceneGraph/Vulkan/VKPrimitiveData.cpp
View File

@ -1,122 +1,55 @@
#include"VKPrimitiveData.h"
#include<hgl/graph/VKVertexInputLayout.h>
#include<hgl/graph/VKVertexAttribBuffer.h>
#include<hgl/graph/VKIndexBuffer.h>
#include<hgl/graph/VKDevice.h>
VK_NAMESPACE_BEGIN
struct PrimitiveData
PrimitiveData::PrimitiveData(const VIL *_vil,const VkDeviceSize vc)
{
const VIL * vil;
vil=_vil;
VkDeviceSize vertex_count;
/*
1.截止2024.4.27，根据vulkan.gpuinfo.org统计，只有9%的设备maxVertexInputAttributes为16，不存在低于16的设备。
9.0%的设备为28 - 31
70.7%的设备为32
9.6%的设备为64
vertex_count=vc;
由于我们暂时没有发现需要使用16个以上属性的情况，所以这里暂定使用16。
(如果时间过去久远，可再次查询此值是否可改成更高的值，以及是否需要)
vab_access=hgl_zero_new<VABAccess>(_vil->GetCount());
2.为何va_name使用char[][]而不是String以及动态分配内存？
就是为了必避动态分配内存，以及可以直接memcpy处理，所以此处这样定义。
*/
VABAccess vab_access[HGL_MAX_VERTEX_ATTRIB_COUNT];
IBAccess ib_access;
};//struct PrimitiveData
PrimitiveData *CreatePrimitiveData(const VIL *_vil,const VkDeviceSize vc)
{
if(!_vil)return(nullptr);
if(vc<=0)return(nullptr);
PrimitiveData *pd=hgl_zero_new<PrimitiveData>();
pd->vil =_vil;
pd->vertex_count=vc;
return(pd);
hgl_zero(ib_access);
}
void Free(PrimitiveData *pd)
PrimitiveData::~PrimitiveData()
{
if(!pd)return;
delete pd;
SAFE_CLEAR_ARRAY(vab_access); //注意：这里并不释放VAB，在派生类中释放
}
void Destory(PrimitiveData *pd)
const int PrimitiveData::GetVABCount()const
{
if(!pd)return;
VABAccess *vab=pd->vab_access;
for(uint32_t i=0;i<pd->vil->GetCount();i++)
{
if(vab->vab)
{
delete vab->vab;
vab->vab=nullptr;
}
++vab;
}
if(pd->ib_access.buffer)
{
delete pd->ib_access.buffer;
pd->ib_access.buffer=nullptr;
}
delete pd;
return vil->GetCount();
}
const VkDeviceSize GetVertexCount(PrimitiveData *pd)
const int PrimitiveData::GetVABIndex(const AnsiString &name) const
{
if(!pd)return(0);
return pd->vertex_count;
}
const int GetVABCount(PrimitiveData *pd)
{
if(!pd)return(-1);
if(!pd->vil)return(-2);
return pd->vil->GetCount();
}
int GetVABIndex(const PrimitiveData *pd,const AnsiString &name)
{
if(!pd)return(-1);
if(!pd->vil)return(-1);
if(name.IsEmpty())return(-1);
return pd->vil->GetIndex(name);
return vil->GetIndex(name);
}
VABAccess *GetVABAccess(PrimitiveData *pd,const int index)
VABAccess *PrimitiveData::GetVABAccess(const int index)
{
if(!pd)return(nullptr);
if(!pd->vil)return(nullptr);
if(index<0||index>=pd->vil->GetCount())return(nullptr);
if(index<0||index>=vil->GetCount())return(nullptr);
return pd->vab_access+index;
return vab_access+index;
}
VABAccess *GetVABAccess(PrimitiveData *pd,const AnsiString &name)
VABAccess *PrimitiveData::GetVABAccess(const AnsiString &name)
{
if(!pd)return(nullptr);
if(!pd->vil)return(nullptr);
if(name.IsEmpty())return(nullptr);
const int index=pd->vil->GetIndex(name);
const int index=vil->GetIndex(name);
if(index<0)return(nullptr);
return pd->vab_access+index;
return vab_access+index;
}
//VABAccess *SetVAB(PrimitiveData *pd,const int index,VAB *vab,VkDeviceSize start,VkDeviceSize count)
@ -153,11 +86,125 @@ VABAccess *GetVABAccess(PrimitiveData *pd,const AnsiString &name)
// pd->ib_access.count=ic;
//}
IBAccess *GetIBAccess(PrimitiveData *pd)
namespace
{
if(!pd)return(nullptr);
/**
* 直接使用GPUDevice创建VAB/IBO,并在释构时释放
*/
class PrimitiveDataPrivateBuffer:public PrimitiveData
{
GPUDevice *device;
return &(pd->ib_access);
public:
PrimitiveDataPrivateBuffer(GPUDevice *dev,const VIL *_vil,const VkDeviceSize vc):PrimitiveData(_vil,vc)
{
device=dev;
}
~PrimitiveDataPrivateBuffer()
{
VABAccess *vab=vab_access;
for(uint i=0;i<vil->GetCount();i++)
{
if(vab->vab)
{
delete vab->vab;
vab->vab=nullptr;
}
++vab;
}
if(ib_access.buffer)
{
delete ib_access.buffer;
ib_access.buffer=nullptr;
}
}
IBAccess *InitIBO(const VkDeviceSize index_count,IndexType it) override
{
if(!device)return(nullptr);
if(ib_access.buffer)
{
delete ib_access.buffer;
ib_access.buffer=nullptr;
}
ib_access.buffer=device->CreateIBO(it,index_count);
if(!ib_access.buffer)
return(nullptr);
ib_access.start=0;
ib_access.count=index_count;
return(&ib_access);
}
VABAccess *InitVAB(const AnsiString &name,const VkFormat &format,const void *data,const VkDeviceSize bytes)
{
if(!device)return(nullptr);
if(!vil)return(nullptr);
if(name.IsEmpty())return(nullptr);
const int index=vil->GetIndex(name);
if(index<0||index>=vil->GetCount())
return(nullptr);
const VertexInputFormat *vif=vil->GetConfig(index);
if(!vif)return(nullptr);
if(vif->format!=format)
return(nullptr);
if(data)
{
if(vif->stride*vertex_count!=bytes)
return(nullptr);
}
VABAccess *vaba=vab_access+index;
if(!vaba->vab)
{
vaba->vab=device->CreateVAB(format,vertex_count,data);
if(!vaba->vab)
return(nullptr);
vaba->start=0;
vaba->count=vertex_count;
}
else
{
vaba->vab->Write(data,vertex_count);
}
return vaba;
}
};//class PrimitiveDataPrivateBuffer:public PrimitiveData
/**
* 使用VertexDataBuffer分配VAB/IBO，在本类析构时归还数据
*/
class PrimitiveDataVDM:public PrimitiveData
{
};
}//namespace
PrimitiveData *CreatePrimitiveData(GPUDevice *dev,const VIL *_vil,const VkDeviceSize vc)
{
if(!dev)return(nullptr);
if(!_vil)return(nullptr);
if(vc<=0)return(nullptr);
return(new PrimitiveDataPrivateBuffer(dev,_vil,vc));
}
VK_NAMESPACE_END
VK_NAMESPACE_END

50
src/SceneGraph/Vulkan/VKPrimitiveData.h Normal file
View File

@ -0,0 +1,50 @@
#include<hgl/graph/VK.h>
VK_NAMESPACE_BEGIN
/*
1.截止2024.4.27，根据vulkan.gpuinfo.org统计，只有9%的设备maxVertexInputAttributes为16，不存在低于16的设备。
9.0%的设备为28 - 31
70.7%的设备为32
9.6%的设备为64
由于我们暂时没有发现需要使用16个以上属性的情况，所以这里暂定使用16。
(如果时间过去久远，可再次查询此值是否可改成更高的值，以及是否需要)
2.为何va_name使用char[][]而不是String以及动态分配内存？
就是为了必避动态分配内存，以及可以直接memcpy处理，所以此处这样定义。
*/
class PrimitiveData
{
protected:
const VIL * vil;
VkDeviceSize vertex_count;
VABAccess *vab_access;
IBAccess ib_access;
public:
PrimitiveData(const VIL *_vil,const VkDeviceSize vc);
virtual ~PrimitiveData();
public:
const VkDeviceSize GetVertexCount ()const{return vertex_count;}
const int GetVABCount ()const;
const int GetVABIndex (const AnsiString &name)const;
VABAccess * GetVABAccess (const int index);
VABAccess * GetVABAccess (const AnsiString &name);
IBAccess * GetIBAccess (){return &ib_access;}
public:
virtual IBAccess * InitIBO(const VkDeviceSize index_count,IndexType it)=0;
virtual VABAccess *InitVAB(const AnsiString &name,const VkFormat &format,const void *data,const VkDeviceSize bytes)=0;
};//class PrimitiveData
PrimitiveData *CreatePrimitiveData(GPUDevice *dev,const VIL *_vil,const VkDeviceSize vc);
VK_NAMESPACE_END

4
src/SceneGraph/Vulkan/VKRenderable.cpp
View File

@ -1,4 +1,4 @@
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/VKMaterialInstance.h>
#include<hgl/graph/VKMaterialParameters.h>
#include<hgl/graph/VKMaterial.h>
@ -51,7 +51,7 @@ Renderable *CreateRenderable(Primitive *prim,MaterialInstance *mi,Pipeline *p)
const uint32_t input_count=vil->GetCount(VertexInputGroup::Basic); //不统计Bone/LocalToWorld组的
const UTF8String &mtl_name=mi->GetMaterial()->GetName();
if(prim->GetVACount()<input_count) //小于材质要求的数量？那自然是不行的
if(prim->GetVABCount()<input_count) //小于材质要求的数量？那自然是不行的
{
LOG_ERROR("[FATAL ERROR] input buffer count of Renderable lesser than Material, Material name: "+mtl_name);