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

to support newly String<>/IDName/Compare

Browse Source
This commit is contained in:
hyzboy 2025-01-15 02:42:04 +08:00
parent d810540b81
commit bd0a3d8be1
33 changed files with 644 additions and 677 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMAssetsManage

@ -1 +1 @@
Subproject commit 85436b5a7b0bc9347fcd3321a6895464470f1353 Subproject commit 0fae462338cd01c5a26d0a8f0175fe3729a65c94

2
CMCore

@ -1 +1 @@
Subproject commit 7c08fbc530c97394932bfafab73d35073b49f7d8 Subproject commit 5aad7d81419d02141b3b3f53661e2c8e3e763163

2
CMPlatform

@ -1 +1 @@
Subproject commit 103b0d845dc9fdbc10e2e40ab0fa346d133dc1ae Subproject commit aa7abe47631cdb687528400409ef295fd2c050b8

2
CMSceneGraph

@ -1 +1 @@
Subproject commit c958a6cb2ac4a52716eabc1c45eba184f4c7e46c Subproject commit 4949c2e3e82c8a88a783579aff120617c4ecfdab

2
CMUtil

@ -1 +1 @@
Subproject commit f7dce0304822280d0db23ae607783b7c3cd183fa Subproject commit 57ff3a70c99265ed7bb97b3b6840709e84bac0c1

2
example/GUI/DrawText.cpp
View File

@ -28,7 +28,7 @@ private:
bool InitTextRenderable() bool InitTextRenderable()
{ {
UTF16String str; U16String str;
LoadStringFromTextFile(str,OS_TEXT("res/text/DaoDeBible.txt")); LoadStringFromTextFile(str,OS_TEXT("res/text/DaoDeBible.txt"));

1
example/Gizmo/Gizmo3DMove.cpp
View File

@ -22,6 +22,7 @@
*/ */
#include"GizmoResource.h" #include"GizmoResource.h"
#include<hgl/graph/SceneNode.h>
#include<hgl/graph/VKRenderResource.h> #include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/InlineGeometry.h> #include<hgl/graph/InlineGeometry.h>

1
example/Gizmo/Gizmo3DRotate.cpp
View File

@ -1,4 +1,5 @@
#include"GizmoResource.h" #include"GizmoResource.h"
#include<hgl/graph/SceneNode.h>
#include<hgl/graph/VKRenderResource.h> #include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/TransformFaceToCamera.h> #include<hgl/graph/TransformFaceToCamera.h>

1
example/Gizmo/Gizmo3DScale.cpp
View File

@ -22,6 +22,7 @@
*/ */
#include"GizmoResource.h" #include"GizmoResource.h"
#include<hgl/graph/SceneNode.h>
#include<hgl/graph/VKRenderResource.h> #include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/InlineGeometry.h> #include<hgl/graph/InlineGeometry.h>

1
example/Gizmo/GizmoResource.cpp
View File

@ -8,6 +8,7 @@
#include<hgl/graph/VKRenderResource.h> #include<hgl/graph/VKRenderResource.h>
#include<hgl/color/Color.h> #include<hgl/color/Color.h>
#include<hgl/graph/InlineGeometry.h> #include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/SceneNode.h>
#include"GizmoResource.h" #include"GizmoResource.h"
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN

51
inc/hgl/graph/MaterialRenderList.h
View File

@ -8,15 +8,48 @@ class RenderAssignBuffer;
class SceneNode; class SceneNode;
struct CameraInfo; struct CameraInfo;
struct RenderPipelineIndex:public Comparator<RenderPipelineIndex>
{
Material *material;
Pipeline *pipeline;
public:
const int compare(const RenderPipelineIndex &rli)const override
{
if(material<rli.material)return(-1);
if(material>rli.material)return(1);
if(pipeline<rli.pipeline)return(-1);
if(pipeline>rli.pipeline)return(1);
return(0);
}
public:
RenderPipelineIndex()
{
material=nullptr;
pipeline=nullptr;
}
RenderPipelineIndex(Material *m,Pipeline *p)
{
material=m;
pipeline=p;
}
};//struct RenderPipelineIndex
/** /**
* 同一材质的对象渲染列表 * 同一材质与管线的渲染列表
*/ */
class MaterialRenderList class MaterialRenderList
{ {
GPUDevice *device; GPUDevice *device;
RenderCmdBuffer *cmd_buf; RenderCmdBuffer *cmd_buf;
Material *material; RenderPipelineIndex rp_index;
CameraInfo *camera_info; CameraInfo *camera_info;
@ -33,7 +66,6 @@ private:
uint32_t first_instance; ///<第一个绘制实例(和instance渲染无关,对应InstanceRate的VAB) uint32_t first_instance; ///<第一个绘制实例(和instance渲染无关,对应InstanceRate的VAB)
uint32_t instance_count; uint32_t instance_count;
Pipeline * pipeline;
MaterialInstance * mi; MaterialInstance * mi;
const PrimitiveDataBuffer * pdb; const PrimitiveDataBuffer * pdb;
@ -60,7 +92,6 @@ protected:
VABList * vab_list; VABList * vab_list;
Pipeline * last_pipeline;
const PrimitiveDataBuffer * last_data_buffer; const PrimitiveDataBuffer * last_data_buffer;
const VDM * last_vdm; const VDM * last_vdm;
const PrimitiveRenderData * last_render_data; const PrimitiveRenderData * last_render_data;
@ -75,20 +106,14 @@ protected:
public: public:
MaterialRenderList(GPUDevice *d,bool l2w,Material *m); MaterialRenderList(GPUDevice *d,bool l2w,const RenderPipelineIndex &rpi);
~MaterialRenderList(); ~MaterialRenderList();
void Add(SceneNode *); void Add(SceneNode *);
void SetCameraInfo(CameraInfo *ci) void SetCameraInfo(CameraInfo *ci){camera_info=ci;}
{
camera_info=ci;
}
void Clear() void Clear(){rn_list.Clear();}
{
rn_list.Clear();
}
void End(); void End();

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

@ -2,7 +2,7 @@
#include<hgl/graph/MaterialRenderList.h> #include<hgl/graph/MaterialRenderList.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
class MaterialRenderMap:public ObjectMap<Material *,MaterialRenderList> class MaterialRenderMap:public ObjectMap<RenderPipelineIndex,MaterialRenderList>
{ {
public: public:

14
inc/hgl/graph/RenderNode.h
View File

@ -11,9 +11,9 @@ namespace hgl
class MaterialInstance; class MaterialInstance;
class SceneNode; class SceneNode;
struct RenderNode struct RenderNode:public Comparator<RenderNode>
{ {
uint index; ///<在MaterialRenderList中的索引 uint index; ///<在MaterialRenderList中的索引
SceneNode * scene_node; SceneNode * scene_node;
@ -22,6 +22,11 @@ namespace hgl
Vector3f world_position; Vector3f world_position;
float to_camera_distance; float to_camera_distance;
public:
//该函数位于MaterialRenderList.cpp
const int compare(const RenderNode &)const override;
}; };
using RenderNodeList=List<RenderNode>; using RenderNodeList=List<RenderNode>;
@ -29,5 +34,10 @@ namespace hgl
using MaterialInstanceSets=SortedSet<MaterialInstance *>; ///<材质实例集合 using MaterialInstanceSets=SortedSet<MaterialInstance *>; ///<材质实例集合
}//namespace graph }//namespace graph
template<> inline const int ItemComparator<graph::RenderNode>::compare(const graph::RenderNode &a,const graph::RenderNode &b)
{
return a.compare(b);
}
}//namespace hgl }//namespace hgl
#endif//HGL_GRAPH_RENDER_NODE_INCLUDE #endif//HGL_GRAPH_RENDER_NODE_INCLUDE

16
inc/hgl/graph/SceneNode.h
View File

@ -10,7 +10,7 @@ namespace hgl
namespace graph namespace graph
{ {
using SceneNodeID =uint64; using SceneNodeID =uint64;
using SceneNodeName =UTF16IDName; using SceneNodeName =U16IDName;
/** /**
* 场景节点数据类<br> * 场景节点数据类<br>
@ -19,6 +19,8 @@ namespace hgl
*/ */
class SceneNode:public SceneOrient ///场景节点类 class SceneNode:public SceneOrient ///场景节点类
{ {
SceneNode *Owner; ///<上级节点
SceneNodeID NodeID; ///<节点ID SceneNodeID NodeID; ///<节点ID
SceneNodeName NodeName; ///<节点名称 SceneNodeName NodeName; ///<节点名称
@ -59,6 +61,8 @@ namespace hgl
{ {
SceneOrient::Clear(); SceneOrient::Clear();
Owner=nullptr;
BoundingBox.SetZero(); BoundingBox.SetZero();
LocalBoundingBox.SetZero(); LocalBoundingBox.SetZero();
@ -74,8 +78,13 @@ namespace hgl
return(true); return(true);
} }
Renderable *GetRenderable(){return render_obj;} void SetOwner(SceneNode *sn) {Owner=sn;}
void SetRenderable(Renderable *); SceneNode * GetOwner() noexcept{return Owner;}
const SceneNode * GetOwner()const noexcept{return Owner;}
void SetRenderable(Renderable *);
Renderable *GetRenderable() noexcept{return render_obj;}
const Renderable *GetRenderable()const noexcept{return render_obj;}
SceneNode *Add(SceneNode *sn) SceneNode *Add(SceneNode *sn)
{ {
@ -83,6 +92,7 @@ namespace hgl
return(nullptr); return(nullptr);
ChildNode.Add(sn); ChildNode.Add(sn);
sn->SetOwner(this);
return sn; return sn;
} }

11
inc/hgl/graph/VKDeviceRenderPassManage.h
View File

@ -1,12 +1,16 @@
#ifndef HGL_VULKAN_DEVICE_RENDERPASS_MANAGE_INCLUDE #pragma once
#define HGL_VULKAN_DEVICE_RENDERPASS_MANAGE_INCLUDE
#include<hgl/graph/VK.h> #include<hgl/graph/VK.h>
#include<hgl/type/Map.h> #include<hgl/type/Map.h>
#include<hgl/util/hash/Hash.h> #include<hgl/util/hash/Hash.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
using RenderPassHASHCode=util::HashCodeSHA1LE;
using RenderPassHASHCode=util::HashCode<128/8>;
inline util::Hash *CreateRenderPassHash()
{
return util::CreateHash(util::HASH::xxH3_128);
}
class DeviceRenderPassManage class DeviceRenderPassManage
{ {
@ -34,4 +38,3 @@ private:
RenderPass * AcquireRenderPass( const RenderbufferInfo *,const uint subpass_count=2); RenderPass * AcquireRenderPass( const RenderbufferInfo *,const uint subpass_count=2);
};//class DeviceRenderPassManage };//class DeviceRenderPassManage
VK_NAMESPACE_END VK_NAMESPACE_END
#endif//HGL_VULKAN_DEVICE_RENDERPASS_MANAGE_INCLUDE

9
inc/hgl/graph/VKRenderable.h
View File

@ -12,7 +12,7 @@ VK_NAMESPACE_BEGIN
* 原始图元数据缓冲区<Br> * 原始图元数据缓冲区<Br>
* 提供在渲染之前的数据绑定信息 * 提供在渲染之前的数据绑定信息
*/ */
struct PrimitiveDataBuffer struct PrimitiveDataBuffer:public Comparator<PrimitiveDataBuffer>
{ {
uint32_t vab_count; uint32_t vab_count;
VkBuffer * vab_list; VkBuffer * vab_list;
@ -32,14 +32,14 @@ public:
PrimitiveDataBuffer(const uint32_t,IndexBuffer *,VertexDataManager *_v=nullptr); PrimitiveDataBuffer(const uint32_t,IndexBuffer *,VertexDataManager *_v=nullptr);
~PrimitiveDataBuffer(); ~PrimitiveDataBuffer();
const bool Comp(const PrimitiveDataBuffer *pdb)const; const int compare(const PrimitiveDataBuffer &pdb)const override;
};//struct PrimitiveDataBuffer };//struct PrimitiveDataBuffer
/** /**
* 原始图元渲染数据<Br> * 原始图元渲染数据<Br>
* 提供在渲染时的数据 * 提供在渲染时的数据
*/ */
struct PrimitiveRenderData struct PrimitiveRenderData:public ComparatorData<PrimitiveRenderData>
{ {
//因为要VAB是流式访问，所以我们这个结构会被用做排序依据 //因为要VAB是流式访问，所以我们这个结构会被用做排序依据
//也因此，把vertex_offset放在最前面 //也因此，把vertex_offset放在最前面
@ -59,9 +59,6 @@ public:
vertex_offset =vo; vertex_offset =vo;
first_index =fi; first_index =fi;
} }
CompOperatorMemcmp(const PrimitiveRenderData &);
CompOperatorMemcmpPointer(PrimitiveRenderData);
}; };
/** /**

4
inc/hgl/graph/font/Font.h
View File

@ -12,7 +12,7 @@ namespace hgl
/** /**
* 字体信息 * 字体信息
*/ */
struct Font struct Font:public ComparatorData<Font>
{ {
os_char name[MAX_FONT_NAME_LENGTH]; ///<字体名称 os_char name[MAX_FONT_NAME_LENGTH]; ///<字体名称
@ -28,8 +28,6 @@ namespace hgl
Font(); Font();
Font(const os_char *,int,int,bool b=false,bool i=false,bool=true); Font(const os_char *,int,int,bool b=false,bool i=false,bool=true);
CompOperatorMemcmp(const Font &); ///<比较操作符重载
};//struct Font };//struct Font
}//namespace graph }//namespace graph
}//namespace hgl }//namespace hgl

4
inc/hgl/graph/font/TextLayout.h
View File

@ -100,8 +100,8 @@ namespace hgl
int draw_chars_count; ///<要绘制字符列表 int draw_chars_count; ///<要绘制字符列表
SortedSet<u32char> chars_sets; ///<不重复字符统计缓冲区 SortedSets<u32char> chars_sets; ///<不重复字符统计缓冲区
SortedSet<u32char> clear_chars_sets; ///<待清除的字符合集 SortedSets<u32char> clear_chars_sets; ///<待清除的字符合集
TileUVFloatMap chars_uv; ///<所有要绘制字符的uv TileUVFloatMap chars_uv; ///<所有要绘制字符的uv
struct CharDrawAttr struct CharDrawAttr

6
inc/hgl/graph/font/TextRender.h
View File

@ -33,7 +33,7 @@ namespace hgl
Color4f color; Color4f color;
DeviceBuffer * ubo_color; DeviceBuffer * ubo_color;
SortedSet<TextPrimitive *> tr_sets; SortedSets<TextPrimitive *> tr_sets;
private: private:
@ -54,9 +54,9 @@ namespace hgl
public: public:
TextPrimitive *CreatePrimitive(); TextPrimitive *CreatePrimitive();
TextPrimitive *CreatePrimitive(const UTF16String &str); TextPrimitive *CreatePrimitive(const U16String &str);
bool Layout(TextPrimitive *tr,const UTF16String &str); bool Layout(TextPrimitive *tr,const U16String &str);
Renderable *CreateRenderable(TextPrimitive *text_primitive); Renderable *CreateRenderable(TextPrimitive *text_primitive);

2
inc/hgl/graph/font/TileFont.h
View File

@ -37,7 +37,7 @@ namespace hgl
TileFont(TileData *td,FontSource *fs); TileFont(TileData *td,FontSource *fs);
virtual ~TileFont(); virtual ~TileFont();
bool Registry(TileUVFloatMap &,SortedSet<u32char> &chars_sets); ///<注册要使用的字符 bool Registry(TileUVFloatMap &,SortedSet<u32char> &chars_sets); ///<注册要使用的字符
void Unregistry(const List<u32char> &); ///<注销要使用的字符 void Unregistry(const List<u32char> &); ///<注销要使用的字符
};//class TileFont };//class TileFont
}//namespace graph }//namespace graph

8
inc/hgl/graph/mtl/Material2DCreateConfig.h
View File

@ -6,7 +6,7 @@
#include<hgl/graph/VertexAttrib.h> #include<hgl/graph/VertexAttrib.h>
STD_MTL_NAMESPACE_BEGIN STD_MTL_NAMESPACE_BEGIN
struct Material2DCreateConfig:public MaterialCreateConfig struct Material2DCreateConfig:public MaterialCreateConfig,public Comparator<Material2DCreateConfig>
{ {
CoordinateSystem2D coordinate_system; ///<使用的坐标系 CoordinateSystem2D coordinate_system; ///<使用的坐标系
@ -32,9 +32,9 @@ public:
position_format=VAT_VEC2; position_format=VAT_VEC2;
} }
int Comp(const Material2DCreateConfig &cfg)const const int compare(const Material2DCreateConfig &cfg)const override
{ {
int off=MaterialCreateConfig::Comp(cfg); int off=MaterialCreateConfig::compare(cfg);
if(off)return off; if(off)return off;
@ -48,8 +48,6 @@ public:
return off; return off;
} }
CompOperator(const Material2DCreateConfig &,Comp)
};//struct Material2DCreateConfig:public MaterialCreateConfig };//struct Material2DCreateConfig:public MaterialCreateConfig
MaterialCreateInfo *CreateVertexColor2D(const Material2DCreateConfig *); MaterialCreateInfo *CreateVertexColor2D(const Material2DCreateConfig *);

58
inc/hgl/graph/mtl/Material3DCreateConfig.h
View File

@ -5,58 +5,8 @@
#include<hgl/graph/VertexAttrib.h> #include<hgl/graph/VertexAttrib.h>
STD_MTL_NAMESPACE_BEGIN STD_MTL_NAMESPACE_BEGIN
enum class LightingModel:uint8
{
Unlit,
Gizmo, ///<Gizmo专用(Blinnphong的特定版本，内置假的太阳光方向、高光系数等，使其不需要外部UBO传入) struct Material3DCreateConfig:public MaterialCreateConfig,public Comparator<Material3DCreateConfig>
Blinnphong, ///<Blinnphong光照模型
FakePBR, ///<假PBR(使用Blinnphong+HalfLambert模拟)
MicroPBR, ///<微型PBR(只有BaseColor/Normal/Metallic/Roughness四个基础数据的PBR)
WebPBR, ///<Khronos为WebGL提供的PBR
FilamentPBR, ///<Filament引擎所使用的PBR
AMDPBR, ///<AMD Caulrdon框架所使用的PBR
BlenderPBR, ///<Blender所使用的PBR
ENUM_CLASS_RANGE(Unlit,BlenderPBR)
};
constexpr const char *LightingModelName[]=
{
"Unlit",
"Gizmo",
"Blinnphong",
"FakePBR",
"MicroPBR",
"WebPBR",
"FilamentPBR",
"AMDPBR",
"BlenderPBR"
};
/**
* 天光来源
*/
enum class SkyLightSource:uint8
{
PureColor, ///<纯色
Simplest, ///<极简(一行代码)
Cubemap, ///<立方体贴图
IBL, ///<IBL立方体贴图
ENUM_CLASS_RANGE(PureColor,IBL)
};
struct Material3DCreateConfig:public MaterialCreateConfig
{ {
bool camera; ///<包含摄像机矩阵信息 bool camera; ///<包含摄像机矩阵信息
@ -82,9 +32,9 @@ public:
// reverse_depth=false; // reverse_depth=false;
} }
int Comp(const Material3DCreateConfig &cfg)const const int compare(const Material3DCreateConfig &cfg)const override
{ {
int off=MaterialCreateConfig::Comp(cfg); int off=MaterialCreateConfig::compare(cfg);
if(off)return off; if(off)return off;
@ -98,8 +48,6 @@ public:
return off; return off;
} }
CompOperator(const Material3DCreateConfig &,Comp)
};//struct Material3DCreateConfig:public MaterialCreateConfig };//struct Material3DCreateConfig:public MaterialCreateConfig
MaterialCreateInfo *CreateVertexColor3D(const Material3DCreateConfig *); MaterialCreateInfo *CreateVertexColor3D(const Material3DCreateConfig *);

6
inc/hgl/graph/mtl/MaterialConfig.h
View File

@ -13,7 +13,7 @@ class MaterialCreateInfo;
/** /**
* 材质配置结构 * 材质配置结构
*/ */
struct MaterialCreateConfig struct MaterialCreateConfig:public Comparator<MaterialCreateConfig>
{ {
const GPUDeviceAttribute *dev_attr; const GPUDeviceAttribute *dev_attr;
@ -42,7 +42,7 @@ public:
prim=p; prim=p;
} }
virtual int Comp(const MaterialCreateConfig &cfg)const const int compare(const MaterialCreateConfig &cfg)const override
{ {
int off; int off;
@ -59,8 +59,6 @@ public:
return off; return off;
} }
CompOperator(const MaterialCreateConfig &,Comp)
};//struct MaterialCreateConfig };//struct MaterialCreateConfig
STD_MTL_NAMESPACE_END STD_MTL_NAMESPACE_END
#endif//HGL_GRAPH_MTL_CONFIG_INCLUDE #endif//HGL_GRAPH_MTL_CONFIG_INCLUDE

873
inc/hgl/graph/mtl/ShaderVariableType.h
View File

@ -6,551 +6,436 @@
#include<hgl/graph/VKInterpolation.h> #include<hgl/graph/VKInterpolation.h>
#include<hgl/graph/VKSamplerType.h> #include<hgl/graph/VKSamplerType.h>
#include<hgl/graph/VKImageType.h> #include<hgl/graph/VKImageType.h>
#include<hgl/CompOperator.h> #include<hgl/Comparator.h>
namespace hgl VK_NAMESPACE_BEGIN
enum class ShaderVariableBaseType:uint8
{ {
namespace graph Scalar=0,
{ Vector,
enum class ShaderVariableBaseType:uint8 Matrix,
{ Sampler,
Scalar=0, Image,
Vector, AtomicCounter,
Matrix,
Sampler,
Image,
AtomicCounter,
ENUM_CLASS_RANGE(Scalar,AtomicCounter) ENUM_CLASS_RANGE(Scalar,AtomicCounter)
};//enum class ShaderVariableBaseType };//enum class ShaderVariableBaseType
using SVBaseType=ShaderVariableBaseType; using SVBaseType=ShaderVariableBaseType;
#pragma pack(push,1) #pragma pack(push,1)
struct ShaderVariableType struct ShaderVariableType:public Comparator<ShaderVariableType>
{
union
{
struct
{ {
union union
{ {
struct struct
{ {
SVBaseType base_type;
union union
{ {
struct struct Scalar
{ {
SVBaseType base_type; VABaseType type;
}scalar;
union struct Vector
{ {
struct Scalar VABaseType type;
{ uint8 vec_size;
VABaseType type; }vector;
}scalar;
struct Vector struct Matrix
{ {
VABaseType type; VABaseType type;
uint8 vec_size; uint8 n;
}vector; uint8 m;
}matrix;
struct Matrix struct Sampler
{ {
VABaseType type; SamplerType type;
uint8 n; }sampler;
uint8 m;
}matrix;
struct Sampler struct Image
{ {
SamplerType type; ShaderImageType type;
}sampler; }image;
struct Image
{
ShaderImageType type;
}image;
};
};
uint32 type_code;
}; };
uint32 array_size;
}; };
uint64 svt_code; uint32 type_code;
}; };
public: uint32 array_size;
ShaderVariableType()
{
svt_code=0;
}
ShaderVariableType(const ShaderVariableType &svt)
{
svt_code=svt.svt_code;
}
ShaderVariableType(const VAType &vat,const uint count)
{
From(vat,count);
}
ShaderVariableType(const VABaseType &vabt,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Scalar;
scalar.type=vabt;
array_size=count;
}
ShaderVariableType(const VABaseType &vabt,const uint8 size,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Vector;
vector.type=vabt;
vector.vec_size=size;
array_size=count;
}
ShaderVariableType(const VABaseType &vabt,const uint8 row,const uint8 col,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Matrix;
matrix.type=vabt;
matrix.n=col;
matrix.m=row;
array_size=count;
}
ShaderVariableType(const SamplerType &st,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Sampler;
sampler.type=st;
array_size=count;
}
ShaderVariableType(const ShaderImageType &sit,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Image;
image.type=sit;
array_size=count;
}
const bool Check()const
{
if(!RangeCheck(base_type))return(false);
RANGE_CHECK_RETURN_FALSE(base_type)
if(base_type==SVBaseType::Scalar)
return(true);
if(base_type==SVBaseType::Vector)
{
if(vector.vec_size<2||vector.vec_size>4)return(false);
return(true);
}
if(base_type==SVBaseType::Matrix)
{
if(matrix.m==0)
{
if(matrix.n<2||matrix.n>4)return(false);
}
else
{
if(matrix.n<2||matrix.n>4)return(false);
if(matrix.m<2||matrix.m>4)return(false);
}
return(true);
}
if(base_type==SVBaseType::Sampler)
return RangeCheck(sampler.type);
if(base_type==SVBaseType::Image)
return RangeCheck(image.type);
return(true);
}
int Comp(const ShaderVariableType &svt)const
{
int off=(int)base_type-(int)svt.base_type;
if(off)return(off);
if(base_type==SVBaseType::Scalar)
return int(scalar.type)-int(svt.scalar.type);
if(base_type==SVBaseType::Vector)
{
off=int(vector.type)-int(svt.vector.type);
if(off)return(off);
off=vector.vec_size-svt.vector.vec_size;
if(off)return(off);
return int(vector.type)-int(svt.vector.type);
}
if(base_type==SVBaseType::Matrix)
{
off=int(matrix.type)-int(svt.matrix.type);
if(off)return(off);
off=matrix.n-svt.matrix.n;
if(off)return(off);
return matrix.m-svt.matrix.m;
}
if(base_type==SVBaseType::Sampler)
return int(sampler.type)-int(svt.sampler.type);
if(base_type==SVBaseType::Image)
return int(image.type)-int(svt.image.type);
return 0;
}
CompOperator(const ShaderVariableType &,Comp)
const char *GetTypename()const;
bool ParseTypeString(const char *str);
const uint64 ToCode()const{return svt_code;}
const bool FromCode(const uint64 code)
{
svt_code=code;
return Check();
}
const bool From(const VAType &vat,const uint16 count=1)
{
array_size=count;
if(vat.vec_size==1)
{
base_type=SVBaseType::Scalar;
scalar.type=vat.basetype;
return(true);
}
else if(vat.vec_size<=4)
{
base_type=SVBaseType::Vector;
vector.type=vat.basetype;
vector.vec_size=vat.vec_size;
return(true);
}
return(false);
}
static const ShaderVariableType Scalar(const VABaseType &vabt,const uint count=1)
{
ShaderVariableType svt;
svt.base_type =SVBaseType::Scalar;
svt.scalar.type =vabt;
svt.array_size =count;
return svt;
}
};//struct ShaderVariableType
#pragma pack(pop)
using SVType=ShaderVariableType;
const SVType SVT_BOOL (VABaseType::Bool, 1);
const SVType SVT_INT (VABaseType::Int, 1);
const SVType SVT_UINT (VABaseType::UInt, 1);
const SVType SVT_FLOAT (VABaseType::Float, 1);
const SVType SVT_DOUBLE(VABaseType::Double, 1);
const SVType SVT_BVEC2 (VABaseType::Bool, 2,1);
const SVType SVT_BVEC3 (VABaseType::Bool, 3,1);
const SVType SVT_BVEC4 (VABaseType::Bool, 4,1);
const SVType SVT_IVEC2 (VABaseType::Int, 2,1);
const SVType SVT_IVEC3 (VABaseType::Int, 3,1);
const SVType SVT_IVEC4 (VABaseType::Int, 4,1);
const SVType SVT_UVEC2 (VABaseType::UInt, 2,1);
const SVType SVT_UVEC3 (VABaseType::UInt, 3,1);
const SVType SVT_UVEC4 (VABaseType::UInt, 4,1);
const SVType SVT_VEC2 (VABaseType::Float, 2,1);
const SVType SVT_VEC3 (VABaseType::Float, 3,1);
const SVType SVT_VEC4 (VABaseType::Float, 4,1);
const SVType SVT_DVEC2 (VABaseType::Double, 2,1);
const SVType SVT_DVEC3 (VABaseType::Double, 3,1);
const SVType SVT_DVEC4 (VABaseType::Double, 4,1);
const SVType SVT_MAT2 (VABaseType::Float, 2,2,1);
const SVType SVT_MAT3 (VABaseType::Float, 3,3,1);
const SVType SVT_MAT4 (VABaseType::Float, 4,4,1);
const SVType SVT_MAT2x3(VABaseType::Float, 2,3,1);
const SVType SVT_MAT2x4(VABaseType::Float, 2,4,1);
const SVType SVT_MAT3x2(VABaseType::Float, 3,2,1);
const SVType SVT_MAT3x4(VABaseType::Float, 3,4,1);
const SVType SVT_MAT4x2(VABaseType::Float, 4,2,1);
const SVType SVT_MAT4x3(VABaseType::Float, 4,3,1);
const SVType SVT_Sampler1D(SamplerType::Sampler1D, 1);
const SVType SVT_Sampler2D(SamplerType::Sampler2D, 1);
const SVType SVT_Sampler3D(SamplerType::Sampler3D, 1);
const SVType SVT_SamplerCube(SamplerType::SamplerCube, 1);
const SVType SVT_Sampler2DRect(SamplerType::Sampler2DRect, 1);
const SVType SVT_Sampler1DArray(SamplerType::Sampler1DArray,1);
const SVType SVT_Sampler2DArray(SamplerType::Sampler2DArray,1);
const SVType SVT_SamplerCubeArray(SamplerType::SamplerCubeArray,1);
const SVType SVT_SamplerBuffer(SamplerType::SamplerBuffer,1);
const SVType SVT_Sampler2DMS(SamplerType::Sampler2DMS,1);
const SVType SVT_Sampler2DMSArray(SamplerType::Sampler2DMSArray,1);
const SVType SVT_Sampler1DShadow(SamplerType::Sampler1DShadow,1);
const SVType SVT_Sampler2DShadow(SamplerType::Sampler2DShadow,1);
const SVType SVT_SamplerCubeShadow(SamplerType::SamplerCubeShadow,1);
const SVType SVT_Sampler2DRectShadow(SamplerType::Sampler2DRectShadow,1);
const SVType SVT_Sampler1DArrayShadow(SamplerType::Sampler1DArrayShadow,1);
const SVType SVT_Sampler2DArrayShadow(SamplerType::Sampler2DArrayShadow,1);
const SVType SVT_SamplerCubeArrayShadow(SamplerType::SamplerCubeArrayShadow,1);
const SVType SVT_Image1D(ShaderImageType::Image1D,1);
const SVType SVT_Image2D(ShaderImageType::Image2D,1);
const SVType SVT_Image3D(ShaderImageType::Image3D,1);
const SVType SVT_ImageCube(ShaderImageType::ImageCube,1);
const SVType SVT_Image2DRect(ShaderImageType::Image2DRect,1);
const SVType SVT_Image1DArray(ShaderImageType::Image1DArray,1);
const SVType SVT_Image2DArray(ShaderImageType::Image2DArray,1);
const SVType SVT_ImageCubeArray(ShaderImageType::ImageCubeArray,1);
const SVType SVT_ImageBuffer(ShaderImageType::ImageBuffer,1);
const SVType SVT_Image2DMS(ShaderImageType::Image2DMS,1);
const SVType SVT_Image2DMSArray(ShaderImageType::Image2DMSArray,1);
struct ShaderVariable
{
char name[VERTEX_ATTRIB_NAME_MAX_LENGTH];
uint location;
SVType type;
Interpolation interpolation; //插值方式
}; };
using SVList=List<ShaderVariable>; uint64 svt_code;
};
struct ShaderVariableArray public:
ShaderVariableType()
{
svt_code=0;
}
ShaderVariableType(const ShaderVariableType &svt)
{
svt_code=svt.svt_code;
}
ShaderVariableType(const VAType &vat,const uint count)
{
From(vat,count);
}
ShaderVariableType(const VABaseType &vabt,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Scalar;
scalar.type=vabt;
array_size=count;
}
ShaderVariableType(const VABaseType &vabt,const uint8 size,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Vector;
vector.type=vabt;
vector.vec_size=size;
array_size=count;
}
ShaderVariableType(const VABaseType &vabt,const uint8 row,const uint8 col,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Matrix;
matrix.type=vabt;
matrix.n=col;
matrix.m=row;
array_size=count;
}
ShaderVariableType(const SamplerType &st,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Sampler;
sampler.type=st;
array_size=count;
}
ShaderVariableType(const ShaderImageType &sit,const uint32 count)
{
svt_code=0;
base_type=SVBaseType::Image;
image.type=sit;
array_size=count;
}
const bool Check()const;
const int compare(const ShaderVariableType &svt)const override;
const char *GetTypename()const;
bool ParseTypeString(const char *str);
const uint64 ToCode()const{return svt_code;}
const bool FromCode(const uint64 code)
{
svt_code=code;
return Check();
}
const bool From(const VAType &vat,const uint16 count=1);
static const ShaderVariableType Scalar(const VABaseType &vabt,const uint count=1)
{
ShaderVariableType svt;
svt.base_type =SVBaseType::Scalar;
svt.scalar.type =vabt;
svt.array_size =count;
return svt;
}
};//struct ShaderVariableType
#pragma pack(pop)
using SVType=ShaderVariableType;
const SVType SVT_BOOL (VABaseType::Bool, 1);
const SVType SVT_INT (VABaseType::Int, 1);
const SVType SVT_UINT (VABaseType::UInt, 1);
const SVType SVT_FLOAT (VABaseType::Float, 1);
const SVType SVT_DOUBLE(VABaseType::Double, 1);
const SVType SVT_BVEC2 (VABaseType::Bool, 2,1);
const SVType SVT_BVEC3 (VABaseType::Bool, 3,1);
const SVType SVT_BVEC4 (VABaseType::Bool, 4,1);
const SVType SVT_IVEC2 (VABaseType::Int, 2,1);
const SVType SVT_IVEC3 (VABaseType::Int, 3,1);
const SVType SVT_IVEC4 (VABaseType::Int, 4,1);
const SVType SVT_UVEC2 (VABaseType::UInt, 2,1);
const SVType SVT_UVEC3 (VABaseType::UInt, 3,1);
const SVType SVT_UVEC4 (VABaseType::UInt, 4,1);
const SVType SVT_VEC2 (VABaseType::Float, 2,1);
const SVType SVT_VEC3 (VABaseType::Float, 3,1);
const SVType SVT_VEC4 (VABaseType::Float, 4,1);
const SVType SVT_DVEC2 (VABaseType::Double, 2,1);
const SVType SVT_DVEC3 (VABaseType::Double, 3,1);
const SVType SVT_DVEC4 (VABaseType::Double, 4,1);
const SVType SVT_MAT2 (VABaseType::Float, 2,2,1);
const SVType SVT_MAT3 (VABaseType::Float, 3,3,1);
const SVType SVT_MAT4 (VABaseType::Float, 4,4,1);
const SVType SVT_MAT2x3(VABaseType::Float, 2,3,1);
const SVType SVT_MAT2x4(VABaseType::Float, 2,4,1);
const SVType SVT_MAT3x2(VABaseType::Float, 3,2,1);
const SVType SVT_MAT3x4(VABaseType::Float, 3,4,1);
const SVType SVT_MAT4x2(VABaseType::Float, 4,2,1);
const SVType SVT_MAT4x3(VABaseType::Float, 4,3,1);
const SVType SVT_Sampler1D(SamplerType::Sampler1D, 1);
const SVType SVT_Sampler2D(SamplerType::Sampler2D, 1);
const SVType SVT_Sampler3D(SamplerType::Sampler3D, 1);
const SVType SVT_SamplerCube(SamplerType::SamplerCube, 1);
const SVType SVT_Sampler2DRect(SamplerType::Sampler2DRect, 1);
const SVType SVT_Sampler1DArray(SamplerType::Sampler1DArray,1);
const SVType SVT_Sampler2DArray(SamplerType::Sampler2DArray,1);
const SVType SVT_SamplerCubeArray(SamplerType::SamplerCubeArray,1);
const SVType SVT_SamplerBuffer(SamplerType::SamplerBuffer,1);
const SVType SVT_Sampler2DMS(SamplerType::Sampler2DMS,1);
const SVType SVT_Sampler2DMSArray(SamplerType::Sampler2DMSArray,1);
const SVType SVT_Sampler1DShadow(SamplerType::Sampler1DShadow,1);
const SVType SVT_Sampler2DShadow(SamplerType::Sampler2DShadow,1);
const SVType SVT_SamplerCubeShadow(SamplerType::SamplerCubeShadow,1);
const SVType SVT_Sampler2DRectShadow(SamplerType::Sampler2DRectShadow,1);
const SVType SVT_Sampler1DArrayShadow(SamplerType::Sampler1DArrayShadow,1);
const SVType SVT_Sampler2DArrayShadow(SamplerType::Sampler2DArrayShadow,1);
const SVType SVT_SamplerCubeArrayShadow(SamplerType::SamplerCubeArrayShadow,1);
const SVType SVT_Image1D(ShaderImageType::Image1D,1);
const SVType SVT_Image2D(ShaderImageType::Image2D,1);
const SVType SVT_Image3D(ShaderImageType::Image3D,1);
const SVType SVT_ImageCube(ShaderImageType::ImageCube,1);
const SVType SVT_Image2DRect(ShaderImageType::Image2DRect,1);
const SVType SVT_Image1DArray(ShaderImageType::Image1DArray,1);
const SVType SVT_Image2DArray(ShaderImageType::Image2DArray,1);
const SVType SVT_ImageCubeArray(ShaderImageType::ImageCubeArray,1);
const SVType SVT_ImageBuffer(ShaderImageType::ImageBuffer,1);
const SVType SVT_Image2DMS(ShaderImageType::Image2DMS,1);
const SVType SVT_Image2DMSArray(ShaderImageType::Image2DMSArray,1);
struct ShaderVariable
{
char name[VERTEX_ATTRIB_NAME_MAX_LENGTH];
uint location;
SVType type;
Interpolation interpolation; //插值方式
};
using SVList=List<ShaderVariable>;
struct ShaderVariableArray:public Comparator<ShaderVariableArray>
{
uint count;
ShaderVariable *items;
public:
const bool IsEmpty()const{return !items||count<=0;}
public:
ShaderVariableArray()
{
count=0;
items=nullptr;
}
~ShaderVariableArray()
{
Clear();
}
const int compare(const ShaderVariableArray &sva)const override
{
int off=count-sva.count;
if(off)return off;
for(uint i=0;i<count;i++)
{ {
uint count; off=items[i].location-sva.items[i].location;
if(off)
return off;
ShaderVariable *items; if(items[i].type.ToCode()>sva.items[i].type.ToCode())
return 1;
public: //ToCode返回的是uint64，可能差值超大，所以不能直接用-的结果
const bool IsEmpty()const{return !items||count<=0;} if(items[i].type.ToCode()<sva.items[i].type.ToCode())
return -1;
public: off=int(items[i].interpolation)-int(sva.items[i].interpolation);
if(off)
return off;
ShaderVariableArray() off=hgl::strcmp(items[i].name,sva.items[i].name);
{ if(off)
count=0; return off;
items=nullptr; }
}
~ShaderVariableArray() return 0;
{ }
Clear();
}
int Comp(const ShaderVariableArray *sva)const
{
if(!sva)
return 1;
int off=count-sva->count;
if(off)return off;
for(uint i=0;i<count;i++)
{
off=items[i].location-sva->items[i].location;
if(off)
return off;
if(items[i].type.ToCode()>sva->items[i].type.ToCode())
return 1;
//ToCode返回的是uint64，可能差值超大，所以不能直接用-的结果
if(items[i].type.ToCode()<sva->items[i].type.ToCode())
return -1;
off=int(items[i].interpolation)-int(sva->items[i].interpolation);
if(off)
return off;
off=hgl::strcmp(items[i].name,sva->items[i].name);
if(off)
return off;
}
return 0;
}
int Comp(const ShaderVariableArray &sva)const{return Comp(&sva);}
CompOperator(const ShaderVariableArray *,Comp)
CompOperator(const ShaderVariableArray &,Comp)
bool Init(const uint c=0) bool Init(const uint c=0)
{ {
if(items) if(items)
return(false); return(false);
if(c>0) if(c>0)
{ {
count=c; count=c;
items=array_alloc<ShaderVariable>(count); items=array_alloc<ShaderVariable>(count);
} }
else else
{ {
count=0; count=0;
items=nullptr; items=nullptr;
} }
return(true);
}
bool Contains(const char *name)const
{
if(count<=0)
return(false);
for(uint i=0;i<count;i++)
if(hgl::strcmp(items[i].name,name)==0)
return(true); return(true);
}
bool Contains(const char *name)const return(false);
{ }
if(count<=0)
return(false);
for(uint i=0;i<count;i++) bool Add(ShaderVariable &sv)
if(hgl::strcmp(items[i].name,name)==0) {
return(true); if(Contains(sv.name))
return(false);
return(false); sv.location=count;
}
bool Add(ShaderVariable &sv) if(!items)
{ {
if(Contains(sv.name)) items=array_alloc<ShaderVariable>(1);
return(false); count=1;
}
sv.location=count; else
{
if(!items) ++count;
{ items=array_realloc(items,count);
items=array_alloc<ShaderVariable>(1); }
count=1;
}
else
{
++count;
items=array_realloc(items,count);
}
hgl_cpy(items[count-1],sv); hgl_cpy(items[count-1],sv);
return(true); return(true);
} }
void Clear() void Clear()
{ {
if(items) if(items)
{ {
array_free(items); array_free(items);
items=nullptr; items=nullptr;
} }
count=0; count=0;
} }
bool Clone(const ShaderVariableArray *src) bool Clone(const ShaderVariableArray *src)
{ {
if(!src) if(!src)
return(false); return(false);
if(!Init(src->count)) if(!Init(src->count))
return(false); return(false);
hgl_cpy(items,src->items,src->count); hgl_cpy(items,src->items,src->count);
return(true); return(true);
} }
void ToString(AnsiString &output_string) void ToString(AnsiString &output_string)
{
if(IsEmpty())
return;
const ShaderVariable *sv=items;
for(uint i=0;i<count;i++)
{
output_string+=" ";
if(sv->interpolation!=Interpolation::Smooth)
{ {
if(IsEmpty()) if(RangeCheck(sv->interpolation))
return;
const ShaderVariable *sv=items;
for(uint i=0;i<count;i++)
{ {
output_string+=" "; output_string+=InterpolationName[size_t(sv->interpolation)];
if(sv->interpolation!=Interpolation::Smooth)
{
if(RangeCheck(sv->interpolation))
{
output_string+=InterpolationName[size_t(sv->interpolation)];
output_string+=" ";
}
}
output_string+=sv->type.GetTypename();
output_string+=" "; output_string+=" ";
output_string+=sv->name;
output_string+=";\n";
++sv;
} }
} }
};//struct ShaderVariableArray
using SVArray=ShaderVariableArray; output_string+=sv->type.GetTypename();
}//namespace graph output_string+=" ";
}//namespace hgl output_string+=sv->name;
output_string+=";\n";
++sv;
}
}
};//struct ShaderVariableArray
using SVArray=ShaderVariableArray;
VK_NAMESPACE_END

2
inc/hgl/shadergen/ShaderCreateInfo.h
View File

@ -96,7 +96,7 @@ public:
void SetMain(const AnsiString &str){main_function=str;} void SetMain(const AnsiString &str){main_function=str;}
void SetMain(const char *str,const int len) void SetMain(const char *str,const int len)
{ {
main_function.SetString(str,len); main_function.fromString(str,len);
} }
const AnsiString &GetOutputStruct()const{return output_struct;} const AnsiString &GetOutputStruct()const{return output_struct;}

70
src/SceneGraph/MaterialRenderList.cpp
View File

@ -26,22 +26,13 @@
这样就可以保证所有的渲染操作就算要切VBO，也不需要切换INDIRECT缓冲区，定位指令也很方便。 这样就可以保证所有的渲染操作就算要切VBO，也不需要切换INDIRECT缓冲区，定位指令也很方便。
*/ */
template<> VK_NAMESPACE_BEGIN
int Comparator<hgl::graph::RenderNode>::compare(const hgl::graph::RenderNode &obj_one,const hgl::graph::RenderNode &obj_two) const const int RenderNode::compare(const RenderNode &other)const
{ {
hgl::int64 off; hgl::int64 off;
hgl::graph::Renderable *ri_one=obj_one.scene_node->GetRenderable(); hgl::graph::Renderable *ri_one=other.scene_node->GetRenderable();
hgl::graph::Renderable *ri_two=obj_two.scene_node->GetRenderable(); hgl::graph::Renderable *ri_two=scene_node->GetRenderable();
//比较管线
{
off=ri_one->GetPipeline()
-ri_two->GetPipeline();
if(off)
return off;
}
auto *prim_one=ri_one->GetPrimitive(); auto *prim_one=ri_one->GetPrimitive();
auto *prim_two=ri_two->GetPrimitive(); auto *prim_two=ri_two->GetPrimitive();
@ -72,8 +63,8 @@ int Comparator<hgl::graph::RenderNode>::compare(const hgl::graph::RenderNode &ob
//比较距离。。。。。。。。。。。。。。。。。。。。。还不知道这个是正了还是反了，等测出来确认后修改下面的返回值和这里的注释 //比较距离。。。。。。。。。。。。。。。。。。。。。还不知道这个是正了还是反了，等测出来确认后修改下面的返回值和这里的注释
float foff=obj_one.to_camera_distance float foff=other.to_camera_distance
-obj_two.to_camera_distance; -to_camera_distance;
if(foff>0) if(foff>0)
return 1; return 1;
@ -81,18 +72,17 @@ int Comparator<hgl::graph::RenderNode>::compare(const hgl::graph::RenderNode &ob
return -1; return -1;
} }
VK_NAMESPACE_BEGIN MaterialRenderList::MaterialRenderList(GPUDevice *d,bool l2w,const RenderPipelineIndex &rpi)
MaterialRenderList::MaterialRenderList(GPUDevice *d,bool l2w,Material *m)
{ {
device=d; device=d;
cmd_buf=nullptr; cmd_buf=nullptr;
material=m; rp_index=rpi;
camera_info=nullptr; camera_info=nullptr;
assign_buffer=new RenderAssignBuffer(device,material); assign_buffer=new RenderAssignBuffer(device,rp_index.material);
vab_list=new VABList(material->GetVertexInput()->GetCount()); vab_list=new VABList(rp_index.material->GetVertexInput()->GetCount());
icb_draw=nullptr; icb_draw=nullptr;
icb_draw_indexed=nullptr; icb_draw_indexed=nullptr;
@ -215,7 +205,6 @@ void MaterialRenderList::UpdateMaterialInstance(SceneNode *sn)
void MaterialRenderList::RenderItem::Set(Renderable *ri) void MaterialRenderList::RenderItem::Set(Renderable *ri)
{ {
pipeline=ri->GetPipeline();
mi =ri->GetMaterialInstance(); mi =ri->GetMaterialInstance();
pdb =ri->GetDataBuffer(); pdb =ri->GetDataBuffer();
prd =ri->GetRenderData(); prd =ri->GetRenderData();
@ -248,6 +237,7 @@ void MaterialRenderList::WriteICB(VkDrawIndirectCommand *dicp,RenderItem *ri)
dicp->firstVertex =ri->prd->vertex_offset; dicp->firstVertex =ri->prd->vertex_offset;
dicp->firstInstance =ri->first_instance; dicp->firstInstance =ri->first_instance;
} }
void MaterialRenderList::WriteICB(VkDrawIndexedIndirectCommand *diicp,RenderItem *ri) void MaterialRenderList::WriteICB(VkDrawIndexedIndirectCommand *diicp,RenderItem *ri)
{ {
diicp->indexCount =ri->prd->index_count; diicp->indexCount =ri->prd->index_count;
@ -279,7 +269,6 @@ void MaterialRenderList::Stat()
ri->instance_count=1; ri->instance_count=1;
ri->Set(ro); ri->Set(ro);
last_pipeline =ri->pipeline;
last_data_buffer=ri->pdb; last_data_buffer=ri->pdb;
last_vdm =ri->pdb->vdm; last_vdm =ri->pdb->vdm;
last_render_data=ri->prd; last_render_data=ri->prd;
@ -290,14 +279,13 @@ void MaterialRenderList::Stat()
{ {
ro=rn->scene_node->GetRenderable(); ro=rn->scene_node->GetRenderable();
if(last_pipeline==ro->GetPipeline()) if(*last_data_buffer!=*ro->GetDataBuffer())
if(last_data_buffer->Comp(ro->GetDataBuffer())) if(*last_render_data==*ro->GetRenderData())
if(last_render_data->_Comp(ro->GetRenderData())==0) {
{ ++ri->instance_count;
++ri->instance_count; ++rn;
++rn; continue;
continue; }
}
if(ri->pdb->vdm) if(ri->pdb->vdm)
{ {
@ -317,7 +305,6 @@ void MaterialRenderList::Stat()
ri->instance_count=1; ri->instance_count=1;
ri->Set(ro); ri->Set(ro);
last_pipeline =ri->pipeline;
last_data_buffer=ri->pdb; last_data_buffer=ri->pdb;
last_vdm =ri->pdb->vdm; last_vdm =ri->pdb->vdm;
last_render_data=ri->prd; last_render_data=ri->prd;
@ -411,17 +398,7 @@ void MaterialRenderList::ProcIndirectRender()
void MaterialRenderList::Render(RenderItem *ri) void MaterialRenderList::Render(RenderItem *ri)
{ {
if(last_pipeline!=ri->pipeline) if(*(ri->pdb)!=*last_data_buffer) //换buf了
{
cmd_buf->BindPipeline(ri->pipeline);
last_pipeline=ri->pipeline;
last_data_buffer=nullptr;
//这里未来尝试换pipeline同时不换mi/primitive是否需要重新绑定mi/primitive
}
if(!ri->pdb->Comp(last_data_buffer)) //换buf了
{ {
if(indirect_draw_count) //如果有间接绘制的数据，赶紧给画了 if(indirect_draw_count) //如果有间接绘制的数据，赶紧给画了
ProcIndirectRender(); ProcIndirectRender();
@ -432,7 +409,7 @@ void MaterialRenderList::Render(RenderItem *ri)
BindVAB(ri->pdb,ri->first_instance); BindVAB(ri->pdb,ri->first_instance);
if(ri->pdb->ibo) if(ri->pdb->ibo)
cmd_buf->BindIBO(ri->pdb->ibo); cmd_buf->BindIBO(ri->pdb->ibo);
} }
if(ri->pdb->vdm) if(ri->pdb->vdm)
@ -459,15 +436,16 @@ void MaterialRenderList::Render(RenderCmdBuffer *rcb)
cmd_buf=rcb; cmd_buf=rcb;
last_pipeline =nullptr; cmd_buf->BindPipeline(rp_index.pipeline);
last_data_buffer=nullptr; last_data_buffer=nullptr;
last_vdm =nullptr; last_vdm =nullptr;
last_render_data=nullptr; last_render_data=nullptr;
if(assign_buffer) if(assign_buffer)
assign_buffer->Bind(material); assign_buffer->Bind(rp_index.material);
cmd_buf->BindDescriptorSets(material); cmd_buf->BindDescriptorSets(rp_index.material);
RenderItem *ri=ri_array.GetData(); RenderItem *ri=ri_array.GetData();
for(uint i=0;i<ri_count;i++) for(uint i=0;i<ri_count;i++)

13
src/SceneGraph/RenderList.cpp
View File

@ -26,14 +26,15 @@ namespace hgl
if(ri) if(ri)
{ {
Material *mtl=ri->GetMaterial(); RenderPipelineIndex rpi(ri->GetMaterial(),ri->GetPipeline());
MaterialRenderList *mrl; MaterialRenderList *mrl;
if(!mrl_map.Get(mtl,mrl)) if(!mrl_map.Get(rpi,mrl))
{ {
mrl=new MaterialRenderList(device,true,mtl); mrl=new MaterialRenderList(device,true,rpi);
mrl_map.Add(mtl,mrl); mrl_map.Add(rpi,mrl);
} }
mrl->Add(sn); mrl->Add(sn);
@ -92,10 +93,10 @@ namespace hgl
if(!ri)return; if(!ri)return;
Material *mtl=ri->GetMaterial(); RenderPipelineIndex rli(ri->GetMaterial(),ri->GetPipeline());
MaterialRenderList *mrl; MaterialRenderList *mrl;
if(!mrl_map.Get(mtl,mrl)) //找到对应的 if(!mrl_map.Get(rli,mrl)) //找到对应的
return; return;
mrl->UpdateMaterialInstance(sn); mrl->UpdateMaterialInstance(sn);

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

@ -48,9 +48,9 @@ MaterialParameters *GPUDevice::CreateMP(const MaterialDescriptorManager *desc_ma
if(!ds)return(nullptr); if(!ds)return(nullptr);
#ifdef _DEBUG #ifdef _DEBUG
const UTF8String addr_string=HexToString<u8char,uint64_t>((uint64_t)(ds->GetDescriptorSet())); const U8String addr_string=HexToString<u8char,uint64_t>((uint64_t)(ds->GetDescriptorSet()));
LOG_INFO(U8_TEXT("Create [DescriptSets:")+addr_string+U8_TEXT("] OK! Material Name: \"")+(const UTF8String &)(desc_manager->GetMaterialName())+U8_TEXT("\" Type: ")+(u8char *)(GetDescriptorSetTypeName(desc_set_type))); LOG_INFO(U8_TEXT("Create [DescriptSets:")+addr_string+U8_TEXT("] OK! Material Name: \"")+(const U8String &)(desc_manager->GetMaterialName())+U8_TEXT("\" Type: ")+(u8char *)(GetDescriptorSetTypeName(desc_set_type)));
#endif//_DEBUG #endif//_DEBUG
return(new MaterialParameters(desc_manager,desc_set_type,ds)); return(new MaterialParameters(desc_manager,desc_set_type,ds));

8
src/SceneGraph/Vulkan/VKDeviceRenderPassManage.cpp
View File

@ -188,8 +188,8 @@ DeviceRenderPassManage::DeviceRenderPassManage(VkDevice dev,VkPipelineCache pc)
{ {
device=dev; device=dev;
pipeline_cache=pc; pipeline_cache=pc;
hash=util::CreateSHA1LEHash(); hash=CreateRenderPassHash();
} }
DeviceRenderPassManage::~DeviceRenderPassManage() DeviceRenderPassManage::~DeviceRenderPassManage()
@ -250,8 +250,8 @@ namespace
// } // }
void HashRenderPass(RenderPassHASHCode *code,const RenderbufferInfo *rbi,const uint8 subpass_count) void HashRenderPass(RenderPassHASHCode *code,const RenderbufferInfo *rbi,const uint8 subpass_count)
{ {
util::Hash *hash=util::CreateSHA1LEHash(); util::Hash *hash=CreateRenderPassHash();
hash->Init(); hash->Init();

2
src/SceneGraph/Vulkan/VKRenderResource.cpp
View File

@ -158,7 +158,7 @@ Texture2D *RenderResource::LoadTexture2D(const OSString &filename,bool auto_mipm
if(du) if(du)
{ {
const UTF8String name=U8_TEXT("Tex2D:")+ToUTF8String(filename); const U8String name=U8_TEXT("Tex2D:")+ToU8String(filename);
du->SetImage(tex->GetImage(),(char *)(name.c_str())); du->SetImage(tex->GetImage(),(char *)(name.c_str()));
} }

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

@ -24,25 +24,29 @@ PrimitiveDataBuffer::~PrimitiveDataBuffer()
delete[] vab_list; delete[] vab_list;
} }
const bool PrimitiveDataBuffer::Comp(const PrimitiveDataBuffer *pdb)const const int PrimitiveDataBuffer::compare(const PrimitiveDataBuffer &pdb)const
{ {
if(!pdb)return(false); ptrdiff_t off;
if(vdm&&pdb->vdm) off=&vdm-&pdb.vdm;
return (vdm==pdb->vdm); if(off)
return off;
if(vab_count!=pdb->vab_count)return(false); off=vab_count-pdb.vab_count;
if(off)
return off;
for(uint32_t i=0;i<vab_count;i++) off=hgl_cmp(vab_list,pdb.vab_list,vab_count);
{ if(off)
if(vab_list[i]!=pdb->vab_list[i])return(false); return off;
if(vab_offset[i]!=pdb->vab_offset[i])return(false);
}
if(ibo!=pdb->ibo) off=hgl_cmp(vab_offset,pdb.vab_offset,vab_count);
return(false); if(off)
return off;
return(true); off=ibo-pdb.ibo;
return off;
} }
Renderable::Renderable(Primitive *r,MaterialInstance *mi,Pipeline *p,PrimitiveDataBuffer *pdb,PrimitiveRenderData *prd) Renderable::Renderable(Primitive *r,MaterialInstance *mi,Pipeline *p,PrimitiveDataBuffer *pdb,PrimitiveRenderData *prd)
@ -61,7 +65,7 @@ Renderable *CreateRenderable(Primitive *prim,MaterialInstance *mi,Pipeline *p)
const VIL *vil=mi->GetVIL(); const VIL *vil=mi->GetVIL();
if(vil->Comp(p->GetVIL())) if(*vil!=*p->GetVIL())
return(nullptr); return(nullptr);
const uint32_t input_count=vil->GetVertexAttribCount(VertexInputGroup::Basic); //不统计Bone/LocalToWorld组的 const uint32_t input_count=vil->GetVertexAttribCount(VertexInputGroup::Basic); //不统计Bone/LocalToWorld组的

2
src/ShaderGen/ShaderLibrary.cpp
View File

@ -35,7 +35,7 @@ const AnsiString *LoadShader(const AnsiString &shader_name)
shader=new AnsiString; shader=new AnsiString;
if(LoadStringFromTextFile((UTF8String &)*shader,os_fn)<=0) if(LoadStringFromTextFile((U8String &)*shader,os_fn)<=0)
{ {
delete shader; delete shader;
shader=nullptr; shader=nullptr;

108
src/ShaderGen/ShaderVariableType.cpp
View File

@ -45,6 +45,90 @@ namespace
constexpr const char AtomicCounterTypename[]="atomic_uint"; constexpr const char AtomicCounterTypename[]="atomic_uint";
}//namespace }//namespace
const bool ShaderVariableType::Check()const
{
if(!RangeCheck(base_type))return(false);
RANGE_CHECK_RETURN_FALSE(base_type)
if(base_type==SVBaseType::Scalar)
return(true);
if(base_type==SVBaseType::Vector)
{
if(vector.vec_size<2||vector.vec_size>4)return(false);
return(true);
}
if(base_type==SVBaseType::Matrix)
{
if(matrix.m==0)
{
if(matrix.n<2||matrix.n>4)return(false);
}
else
{
if(matrix.n<2||matrix.n>4)return(false);
if(matrix.m<2||matrix.m>4)return(false);
}
return(true);
}
if(base_type==SVBaseType::Sampler)
return RangeCheck(sampler.type);
if(base_type==SVBaseType::Image)
return RangeCheck(image.type);
return(true);
}
const int ShaderVariableType::compare(const ShaderVariableType &svt)const
{
int off=(int)base_type-(int)svt.base_type;
if(off)return(off);
if(base_type==SVBaseType::Scalar)
return int(scalar.type)-int(svt.scalar.type);
if(base_type==SVBaseType::Vector)
{
off=int(vector.type)-int(svt.vector.type);
if(off)return(off);
off=vector.vec_size-svt.vector.vec_size;
if(off)return(off);
return int(vector.type)-int(svt.vector.type);
}
if(base_type==SVBaseType::Matrix)
{
off=int(matrix.type)-int(svt.matrix.type);
if(off)return(off);
off=matrix.n-svt.matrix.n;
if(off)return(off);
return matrix.m-svt.matrix.m;
}
if(base_type==SVBaseType::Sampler)
return int(sampler.type)-int(svt.sampler.type);
if(base_type==SVBaseType::Image)
return int(image.type)-int(svt.image.type);
return 0;
}
const char *ShaderVariableType::GetTypename()const const char *ShaderVariableType::GetTypename()const
{ {
if(base_type==SVBaseType::Scalar) if(base_type==SVBaseType::Scalar)
@ -268,4 +352,28 @@ bool ShaderVariableType::ParseTypeString(const char *str)
return(false); return(false);
} }
const bool ShaderVariableType::From(const VAType &vat,const uint16 count)
{
array_size=count;
if(vat.vec_size==1)
{
base_type=SVBaseType::Scalar;
scalar.type=vat.basetype;
return(true);
}
else if(vat.vec_size<=4)
{
base_type=SVBaseType::Vector;
vector.type=vat.basetype;
vector.vec_size=vat.vec_size;
return(true);
}
return(false);
}
VK_NAMESPACE_END VK_NAMESPACE_END