spirv-cross 0.1.1 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: fb194ce8b2a446d9a001e805612cda73fab6a8427fc2e5f26f28b6fcdcbd2ac8
4
- data.tar.gz: d5026e933273619449fcac4b51813dc2ac1157ee2602057c790e753d963dc0ed
3
+ metadata.gz: 2441261f9f58a2fc569cfa3fab88a9a6ecc9666514e89d5a559a55f83f6b9487
4
+ data.tar.gz: 4545b775ac721125cdbf1af53377a1ce26c5924cf6957ce1d47c3f9180788537
5
5
  SHA512:
6
- metadata.gz: 44bd431febeed0c878bebb574bbcd43626eec98021fe9b28332751347cecf9b76d557cd8277e7301d552b25dafa7ac9d3a8ab7029d7b4e057ef47ea2a5cde609
7
- data.tar.gz: 896b277dfeaf2074a7904082c28f091285cecf52a5a0530a0bcd754fcb2de6555fb52db6d2fc4ab095fa23acff36f1bbc78952bbff513461b7943b66199c7bf3
6
+ metadata.gz: c9ae1805ee23b5c02c047dbb39820e9a1990fef23357fe26d7eaeabbaa8c16a1e1c5fd4a68489d2628ca01ea3d177f8cbe66e27a8408e4316eaa31a9192d0d8d
7
+ data.tar.gz: 9aa286c888bbda09f8f56d29a0a5bd728295d1e1ea65235d88988f3a415a4436c54e5797a26f1d5453eb77416a2d98f6958721959a7385d0bcd299efc4f76940
@@ -1,25 +1,25 @@
1
1
  PATH
2
2
  remote: .
3
3
  specs:
4
- spirv-cross (0.1.1)
4
+ spirv-cross (0.1.2)
5
5
 
6
6
  GEM
7
7
  remote: https://rubygems.org/
8
8
  specs:
9
- minitest (5.11.3)
10
- rake (10.5.0)
11
- rake-compiler (1.0.5)
9
+ minitest (5.13.0)
10
+ rake (13.0.1)
11
+ rake-compiler (1.1.0)
12
12
  rake
13
13
 
14
14
  PLATFORMS
15
15
  ruby
16
16
 
17
17
  DEPENDENCIES
18
- bundler (~> 1.17)
18
+ bundler (~> 2.1)
19
19
  minitest (~> 5.0)
20
- rake (~> 10.0)
20
+ rake (~> 13.0)
21
21
  rake-compiler
22
22
  spirv-cross!
23
23
 
24
24
  BUNDLED WITH
25
- 1.17.1
25
+ 2.1.1
@@ -1,6 +1,12 @@
1
1
  #!/bin/env ruby
2
2
  require 'spirv-cross'
3
3
  require 'pp'
4
+
5
+ unless ARGV[0]
6
+ puts 'Usage: spirv-dump [FILE]'
7
+ exit 1
8
+ end
9
+
4
10
  compiler = SPIRV::Cross::Compiler.new(File.open(ARGV[0], 'rb').read)
5
11
  pp({
6
12
  shader_resources: compiler.shader_resources,
@@ -4,7 +4,7 @@ require 'rake/file_utils'
4
4
 
5
5
  include FileUtils
6
6
 
7
- REVISION = 'ea6bdacd056b77ec1004822482d08b6f31473f25'
7
+ REVISION = 'f912c328'
8
8
 
9
9
  unless File.directory?(File.expand_path('spirv-cross', __dir__))
10
10
  sh 'git', 'clone', 'https://github.com/KhronosGroup/SPIRV-Cross', File.expand_path('spirv-cross', __dir__)
@@ -1,17 +1,13 @@
1
1
  #include "rb_spirv_cross.h"
2
2
  #include "spirv_cross.hpp"
3
3
 
4
- using namespace spirv_cross;
5
- using namespace std;
6
- using namespace spv;
7
-
8
4
  void compiler_free(void* data) {
9
- Compiler *comp = (Compiler *) data;
5
+ spirv_cross::Compiler *comp = (spirv_cross::Compiler *) data;
10
6
  delete comp;
11
7
  }
12
8
 
13
9
  size_t compiler_size(const void* data) {
14
- return sizeof(Compiler);
10
+ return sizeof(spirv_cross::Compiler);
15
11
  }
16
12
 
17
13
  static const rb_data_type_t compiler_type = {
@@ -19,8 +15,7 @@ static const rb_data_type_t compiler_type = {
19
15
  .function = {
20
16
  .dmark = NULL,
21
17
  .dfree = compiler_free,
22
- .dsize = compiler_size,
23
- .reserved = { 0, 0 }
18
+ .dsize = compiler_size
24
19
  },
25
20
  .parent = NULL,
26
21
  .data = NULL,
@@ -28,25 +23,25 @@ static const rb_data_type_t compiler_type = {
28
23
  };
29
24
 
30
25
  extern "C" {
31
- VALUE rb_spirv_type(Compiler &compiler, uint32_t type_id) {
26
+ VALUE rb_spirv_type(spirv_cross::Compiler &compiler, uint32_t type_id) {
32
27
  VALUE vres = rb_hash_new();
33
28
  auto &base_type = compiler.get_type(type_id);
34
29
  switch(base_type.basetype) {
35
- case SPIRType::BaseType::Void: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("void"))); break;
36
- case SPIRType::BaseType::Boolean: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("boolean"))); break;
37
- case SPIRType::BaseType::Char: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("char"))); break;
38
- case SPIRType::BaseType::Int: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("int"))); break;
39
- case SPIRType::BaseType::UInt: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("uint"))); break;
40
- case SPIRType::BaseType::Int64: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("int64"))); break;
41
- case SPIRType::BaseType::UInt64: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("uint64"))); break;
42
- case SPIRType::BaseType::AtomicCounter: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("atomic_counter"))); break;
43
- case SPIRType::BaseType::Half: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("half"))); break;
44
- case SPIRType::BaseType::Float: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("float"))); break;
45
- case SPIRType::BaseType::Double: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("double"))); break;
46
- case SPIRType::BaseType::Struct: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("struct"))); break;
47
- case SPIRType::BaseType::Image: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("image"))); break;
48
- case SPIRType::BaseType::SampledImage: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("sampled_image"))); break;
49
- case SPIRType::BaseType::Sampler: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("sampler"))); break;
30
+ case spirv_cross::SPIRType::BaseType::Void: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("void"))); break;
31
+ case spirv_cross::SPIRType::BaseType::Boolean: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("boolean"))); break;
32
+ case spirv_cross::SPIRType::BaseType::Char: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("char"))); break;
33
+ case spirv_cross::SPIRType::BaseType::Int: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("int"))); break;
34
+ case spirv_cross::SPIRType::BaseType::UInt: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("uint"))); break;
35
+ case spirv_cross::SPIRType::BaseType::Int64: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("int64"))); break;
36
+ case spirv_cross::SPIRType::BaseType::UInt64: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("uint64"))); break;
37
+ case spirv_cross::SPIRType::BaseType::AtomicCounter: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("atomic_counter"))); break;
38
+ case spirv_cross::SPIRType::BaseType::Half: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("half"))); break;
39
+ case spirv_cross::SPIRType::BaseType::Float: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("float"))); break;
40
+ case spirv_cross::SPIRType::BaseType::Double: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("double"))); break;
41
+ case spirv_cross::SPIRType::BaseType::Struct: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("struct"))); break;
42
+ case spirv_cross::SPIRType::BaseType::Image: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("image"))); break;
43
+ case spirv_cross::SPIRType::BaseType::SampledImage: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("sampled_image"))); break;
44
+ case spirv_cross::SPIRType::BaseType::Sampler: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("sampler"))); break;
50
45
  default: rb_hash_aset(vres, ID2SYM(rb_intern("type")), ID2SYM(rb_intern("unknown")));
51
46
  }
52
47
 
@@ -55,19 +50,19 @@ extern "C" {
55
50
  rb_hash_aset(vres, ID2SYM(rb_intern("columns")), UINT2NUM(base_type.columns));
56
51
  rb_hash_aset(vres, ID2SYM(rb_intern("is_pointer")), base_type.pointer ? Qtrue : Qfalse);
57
52
 
58
- if (base_type.basetype == SPIRType::BaseType::Image || base_type.basetype == SPIRType::BaseType::SampledImage) {
53
+ if (base_type.basetype == spirv_cross::SPIRType::BaseType::Image || base_type.basetype == spirv_cross::SPIRType::BaseType::SampledImage) {
59
54
  VALUE vimg = rb_hash_new();
60
55
  rb_hash_aset(vimg, ID2SYM(rb_intern("type")), rb_spirv_type(compiler, base_type.image.type));
61
56
  switch(base_type.image.dim) {
62
- case Dim::Dim1D: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), INT2NUM(1)); break;
63
- case Dim::Dim2D: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), INT2NUM(2)); break;
64
- case Dim::Dim3D: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), INT2NUM(3)); break;
65
- case Dim::DimCube: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("cube"))); break;
66
- case Dim::DimRect: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("rect"))); break;
67
- case Dim::DimBuffer: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("buffer"))); break;
68
- case Dim::DimSubpassData: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("subpass_data"))); break;
69
- case Dim::DimMax: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("max"))); break;
70
- default: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("unknown")));
57
+ case spv::Dim::Dim1D: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), INT2NUM(1)); break;
58
+ case spv::Dim::Dim2D: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), INT2NUM(2)); break;
59
+ case spv::Dim::Dim3D: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), INT2NUM(3)); break;
60
+ case spv::Dim::DimCube: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("cube"))); break;
61
+ case spv::Dim::DimRect: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("rect"))); break;
62
+ case spv::Dim::DimBuffer: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("buffer"))); break;
63
+ case spv::Dim::DimSubpassData: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("subpass_data"))); break;
64
+ case spv::Dim::DimMax: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("max"))); break;
65
+ default: rb_hash_aset(vimg, ID2SYM(rb_intern("dimensions")), ID2SYM(rb_intern("unknown")));
71
66
  }
72
67
  rb_hash_aset(vimg, ID2SYM(rb_intern("depth")), base_type.image.depth ? Qtrue : Qfalse);
73
68
  rb_hash_aset(vimg, ID2SYM(rb_intern("arrayed")), base_type.image.arrayed ? Qtrue : Qfalse);
@@ -78,74 +73,74 @@ extern "C" {
78
73
  default: rb_hash_aset(vimg, ID2SYM(rb_intern("sampling")), Qfalse);
79
74
  }
80
75
  switch(base_type.image.format) {
81
- case ImageFormatRgba32f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba32f"))); break;
82
- case ImageFormatRgba16f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16f"))); break;
83
- case ImageFormatR32f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r32f"))); break;
84
- case ImageFormatRgba8: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba8"))); break;
85
- case ImageFormatRgba8Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba8snorm"))); break;
86
- case ImageFormatRg32f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg32f"))); break;
87
- case ImageFormatRg16f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16f"))); break;
88
- case ImageFormatR11fG11fB10f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r11fg11fb10f"))); break;
89
- case ImageFormatR16f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16f"))); break;
90
- case ImageFormatRgba16: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16"))); break;
91
- case ImageFormatRgb10A2: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgb10a2"))); break;
92
- case ImageFormatRg16: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16"))); break;
93
- case ImageFormatRg8: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg8"))); break;
94
- case ImageFormatR16: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16"))); break;
95
- case ImageFormatR8: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r8"))); break;
96
- case ImageFormatRgba16Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16snorm"))); break;
97
- case ImageFormatRg16Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16snorm"))); break;
98
- case ImageFormatRg8Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg8snorm"))); break;
99
- case ImageFormatR16Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16snorm"))); break;
100
- case ImageFormatR8Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r8snorm"))); break;
101
- case ImageFormatRgba32i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba32i"))); break;
102
- case ImageFormatRgba16i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16i"))); break;
103
- case ImageFormatRgba8i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba8i"))); break;
104
- case ImageFormatR32i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r32i"))); break;
105
- case ImageFormatRg32i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg32i"))); break;
106
- case ImageFormatRg16i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16i"))); break;
107
- case ImageFormatRg8i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg8i"))); break;
108
- case ImageFormatR16i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16i"))); break;
109
- case ImageFormatR8i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r8i"))); break;
110
- case ImageFormatRgba32ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba32ui"))); break;
111
- case ImageFormatRgba16ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16ui"))); break;
112
- case ImageFormatRgba8ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba8ui"))); break;
113
- case ImageFormatR32ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r32ui"))); break;
114
- case ImageFormatRgb10a2ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgb10a2ui"))); break;
115
- case ImageFormatRg32ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg32ui"))); break;
116
- case ImageFormatRg16ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16ui"))); break;
117
- case ImageFormatRg8ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg8ui"))); break;
118
- case ImageFormatR16ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16ui"))); break;
119
- case ImageFormatR8ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r8ui"))); break;
120
- case ImageFormatMax: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("max"))); break;
121
- default: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("unknown")));
76
+ case spv::ImageFormatRgba32f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba32f"))); break;
77
+ case spv::ImageFormatRgba16f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16f"))); break;
78
+ case spv::ImageFormatR32f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r32f"))); break;
79
+ case spv::ImageFormatRgba8: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba8"))); break;
80
+ case spv::ImageFormatRgba8Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba8snorm"))); break;
81
+ case spv::ImageFormatRg32f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg32f"))); break;
82
+ case spv::ImageFormatRg16f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16f"))); break;
83
+ case spv::ImageFormatR11fG11fB10f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r11fg11fb10f"))); break;
84
+ case spv::ImageFormatR16f: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16f"))); break;
85
+ case spv::ImageFormatRgba16: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16"))); break;
86
+ case spv::ImageFormatRgb10A2: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgb10a2"))); break;
87
+ case spv::ImageFormatRg16: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16"))); break;
88
+ case spv::ImageFormatRg8: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg8"))); break;
89
+ case spv::ImageFormatR16: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16"))); break;
90
+ case spv::ImageFormatR8: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r8"))); break;
91
+ case spv::ImageFormatRgba16Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16snorm"))); break;
92
+ case spv::ImageFormatRg16Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16snorm"))); break;
93
+ case spv::ImageFormatRg8Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg8snorm"))); break;
94
+ case spv::ImageFormatR16Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16snorm"))); break;
95
+ case spv::ImageFormatR8Snorm: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r8snorm"))); break;
96
+ case spv::ImageFormatRgba32i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba32i"))); break;
97
+ case spv::ImageFormatRgba16i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16i"))); break;
98
+ case spv::ImageFormatRgba8i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba8i"))); break;
99
+ case spv::ImageFormatR32i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r32i"))); break;
100
+ case spv::ImageFormatRg32i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg32i"))); break;
101
+ case spv::ImageFormatRg16i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16i"))); break;
102
+ case spv::ImageFormatRg8i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg8i"))); break;
103
+ case spv::ImageFormatR16i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16i"))); break;
104
+ case spv::ImageFormatR8i: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r8i"))); break;
105
+ case spv::ImageFormatRgba32ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba32ui"))); break;
106
+ case spv::ImageFormatRgba16ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba16ui"))); break;
107
+ case spv::ImageFormatRgba8ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgba8ui"))); break;
108
+ case spv::ImageFormatR32ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r32ui"))); break;
109
+ case spv::ImageFormatRgb10a2ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rgb10a2ui"))); break;
110
+ case spv::ImageFormatRg32ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg32ui"))); break;
111
+ case spv::ImageFormatRg16ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg16ui"))); break;
112
+ case spv::ImageFormatRg8ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("rg8ui"))); break;
113
+ case spv::ImageFormatR16ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r16ui"))); break;
114
+ case spv::ImageFormatR8ui: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("r8ui"))); break;
115
+ case spv::ImageFormatMax: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("max"))); break;
116
+ default: rb_hash_aset(vimg, ID2SYM(rb_intern("format")), ID2SYM(rb_intern("unknown")));
122
117
  }
123
118
  switch(base_type.image.access) {
124
- case AccessQualifierReadOnly: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("read_only"))); break;
125
- case AccessQualifierWriteOnly: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("write_only"))); break;
126
- case AccessQualifierReadWrite: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("read_write"))); break;
127
- case AccessQualifierMax: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("max"))); break;
128
- default: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("unknown"))); break;
119
+ case spv::AccessQualifierReadOnly: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("read_only"))); break;
120
+ case spv::AccessQualifierWriteOnly: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("write_only"))); break;
121
+ case spv::AccessQualifierReadWrite: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("read_write"))); break;
122
+ case spv::AccessQualifierMax: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("max"))); break;
123
+ default: rb_hash_aset(vimg, ID2SYM(rb_intern("access")), ID2SYM(rb_intern("unknown"))); break;
129
124
  }
130
125
  rb_hash_aset(vres, ID2SYM(rb_intern("image")), vimg);
131
126
  }
132
127
 
133
128
  switch(base_type.storage) {
134
- case StorageClassGeneric: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("generic"))); break;
135
- case StorageClassUniformConstant: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("uniform_constant"))); break;
136
- case StorageClassInput: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("input"))); break;
137
- case StorageClassUniform: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("uniform"))); break;
138
- case StorageClassOutput: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("output"))); break;
139
- case StorageClassWorkgroup: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("workgroup"))); break;
140
- case StorageClassCrossWorkgroup: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("cross_work_group"))); break;
141
- case StorageClassPrivate: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("private"))); break;
142
- case StorageClassFunction: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("function"))); break;
143
- case StorageClassPushConstant: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("push_constant"))); break;
144
- case StorageClassAtomicCounter: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("atomic_counter"))); break;
145
- case StorageClassImage: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("image"))); break;
146
- case StorageClassStorageBuffer: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("storage_buffer"))); break;
147
- case StorageClassMax: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("max"))); break;
148
- default: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("unknown")));
129
+ case spv::StorageClassGeneric: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("generic"))); break;
130
+ case spv::StorageClassUniformConstant: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("uniform_constant"))); break;
131
+ case spv::StorageClassInput: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("input"))); break;
132
+ case spv::StorageClassUniform: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("uniform"))); break;
133
+ case spv::StorageClassOutput: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("output"))); break;
134
+ case spv::StorageClassWorkgroup: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("workgroup"))); break;
135
+ case spv::StorageClassCrossWorkgroup: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("cross_work_group"))); break;
136
+ case spv::StorageClassPrivate: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("private"))); break;
137
+ case spv::StorageClassFunction: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("function"))); break;
138
+ case spv::StorageClassPushConstant: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("push_constant"))); break;
139
+ case spv::StorageClassAtomicCounter: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("atomic_counter"))); break;
140
+ case spv::StorageClassImage: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("image"))); break;
141
+ case spv::StorageClassStorageBuffer: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("storage_buffer"))); break;
142
+ case spv::StorageClassMax: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("max"))); break;
143
+ default: rb_hash_aset(vres, ID2SYM(rb_intern("storage_class")), ID2SYM(rb_intern("unknown")));
149
144
  }
150
145
 
151
146
  VALUE vmembers = rb_ary_new();
@@ -177,17 +172,17 @@ extern "C" {
177
172
  size_t matrix_stride = compiler.type_struct_member_matrix_stride(base_type, i);
178
173
  rb_hash_aset(vmember, ID2SYM(rb_intern("matrix_stride")), SIZET2NUM(matrix_stride));
179
174
  }
180
- const string &name = compiler.get_member_name(base_type.self, i);
175
+ const std::string &name = compiler.get_member_name(base_type.self, i);
181
176
  rb_hash_aset(vmember, ID2SYM(rb_intern("name")), rb_str_new2(name.c_str()));
182
177
  }
183
178
 
184
179
  return vres;
185
180
  }
186
181
 
187
- VALUE shader_resource_vector_to_ary(Compiler &compiler, vector<Resource> &vec, bool print_ssbo) {
182
+ VALUE shader_resource_vector_to_ary(spirv_cross::Compiler &compiler, spirv_cross::SmallVector<spirv_cross::Resource> &vec, bool print_ssbo) {
188
183
  VALUE ret = rb_ary_new();
189
184
  for (size_t i = 0; i < vec.size(); i++) {
190
- Resource &res = vec[i];
185
+ spirv_cross::Resource &res = vec[i];
191
186
 
192
187
  // just merge extra data into the type hash instead of creating a nested type hash
193
188
  VALUE vres = rb_spirv_type(compiler, res.type_id);
@@ -198,7 +193,7 @@ extern "C" {
198
193
  // // rb_hash_aset(vres, ID2SYM(rb_intern("base_type")), rb_spirv_type(compiler, res.base_type_id));
199
194
  // rb_hash_aset(vres, ID2SYM(rb_intern("type")), rb_spirv_type(compiler, res.type_id));
200
195
 
201
- vector<BufferRange> ranges = compiler.get_active_buffer_ranges(res.id);
196
+ spirv_cross::SmallVector<spirv_cross::BufferRange> ranges = compiler.get_active_buffer_ranges(res.id);
202
197
  VALUE vranges = rb_ary_new();
203
198
  rb_hash_aset(vres, ID2SYM(rb_intern("active_buffer_ranges")), vranges);
204
199
  for (auto &range : ranges) {
@@ -219,12 +214,12 @@ extern "C" {
219
214
  // If we don't have a name, use the fallback for the type instead of the variable
220
215
  // for SSBOs and UBOs since those are the only meaningful names to use externally.
221
216
  // Push constant blocks are still accessed by name and not block name, even though they are technically Blocks.
222
- bool is_push_constant = compiler.get_storage_class(res.id) == StorageClassPushConstant;
223
- bool is_block = compiler.get_decoration_bitset(type.self).get(DecorationBlock) ||
224
- compiler.get_decoration_bitset(type.self).get(DecorationBufferBlock);
225
- bool is_sized_block = is_block && (compiler.get_storage_class(res.id) == StorageClassUniform ||
226
- compiler.get_storage_class(res.id) == StorageClassUniformConstant);
227
- uint32_t fallback_id = !is_push_constant && is_block ? res.base_type_id : res.id;
217
+ bool is_push_constant = compiler.get_storage_class(res.id) == spv::StorageClassPushConstant;
218
+ bool is_block = compiler.get_decoration_bitset(type.self).get(spv::DecorationBlock) ||
219
+ compiler.get_decoration_bitset(type.self).get(spv::DecorationBufferBlock);
220
+ bool is_sized_block = is_block && (compiler.get_storage_class(res.id) == spv::StorageClassUniform ||
221
+ compiler.get_storage_class(res.id) == spv::StorageClassUniformConstant);
222
+ spirv_cross::ID fallback_id = !is_push_constant && is_block ? spirv_cross::ID(res.base_type_id) : spirv_cross::ID(res.id);
228
223
 
229
224
  uint32_t block_size = 0;
230
225
  uint32_t runtime_array_stride = 0;
@@ -236,7 +231,7 @@ extern "C" {
236
231
  compiler.get_declared_struct_size_runtime_array(base_type, 0));
237
232
  }
238
233
 
239
- Bitset mask;
234
+ spirv_cross::Bitset mask;
240
235
  if (print_ssbo)
241
236
  mask = compiler.get_buffer_block_flags(res.id);
242
237
  else
@@ -256,17 +251,17 @@ extern "C" {
256
251
  res.name.c_str() :
257
252
  compiler.get_fallback_name(fallback_id).c_str()));
258
253
 
259
- if (mask.get(DecorationLocation))
260
- rb_hash_aset(vres, ID2SYM(rb_intern("location")), UINT2NUM(compiler.get_decoration(res.id, DecorationLocation)));
261
- if (mask.get(DecorationDescriptorSet))
262
- rb_hash_aset(vres, ID2SYM(rb_intern("descriptor_set")), UINT2NUM(compiler.get_decoration(res.id, DecorationDescriptorSet)));
263
- if (mask.get(DecorationBinding))
264
- rb_hash_aset(vres, ID2SYM(rb_intern("binding")), UINT2NUM(compiler.get_decoration(res.id, DecorationBinding)));
265
- if (mask.get(DecorationInputAttachmentIndex))
266
- rb_hash_aset(vres, ID2SYM(rb_intern("attachment")), UINT2NUM(compiler.get_decoration(res.id, DecorationInputAttachmentIndex)));
267
- if (mask.get(DecorationNonReadable))
254
+ if (mask.get(spv::DecorationLocation))
255
+ rb_hash_aset(vres, ID2SYM(rb_intern("location")), UINT2NUM(compiler.get_decoration(res.id, spv::DecorationLocation)));
256
+ if (mask.get(spv::DecorationDescriptorSet))
257
+ rb_hash_aset(vres, ID2SYM(rb_intern("descriptor_set")), UINT2NUM(compiler.get_decoration(res.id, spv::DecorationDescriptorSet)));
258
+ if (mask.get(spv::DecorationBinding))
259
+ rb_hash_aset(vres, ID2SYM(rb_intern("binding")), UINT2NUM(compiler.get_decoration(res.id, spv::DecorationBinding)));
260
+ if (mask.get(spv::DecorationInputAttachmentIndex))
261
+ rb_hash_aset(vres, ID2SYM(rb_intern("attachment")), UINT2NUM(compiler.get_decoration(res.id, spv::DecorationInputAttachmentIndex)));
262
+ if (mask.get(spv::DecorationNonReadable))
268
263
  rb_hash_aset(vres, ID2SYM(rb_intern("write_only")), Qtrue);
269
- if (mask.get(DecorationNonWritable))
264
+ if (mask.get(spv::DecorationNonWritable))
270
265
  rb_hash_aset(vres, ID2SYM(rb_intern("read_only")), Qtrue);
271
266
  if (is_sized_block)
272
267
  {
@@ -284,7 +279,7 @@ extern "C" {
284
279
  return ret;
285
280
  }
286
281
 
287
- inline VALUE shader_resources_to_hash(Compiler *comp, ShaderResources &resources) {
282
+ inline VALUE shader_resources_to_hash(spirv_cross::Compiler *comp, spirv_cross::ShaderResources &resources) {
288
283
  VALUE vsr = rb_hash_new();
289
284
  #define HASH_PUSH_RESOURCE_ARY(name, ssbo) \
290
285
  rb_hash_aset(vsr, ID2SYM(rb_intern(#name)), shader_resource_vector_to_ary(*comp, resources.name, ssbo));
@@ -303,49 +298,49 @@ extern "C" {
303
298
  }
304
299
 
305
300
  VALUE rb_spvx_compiler_all_shader_resources(VALUE self) {
306
- Compiler *comp;
307
- TypedData_Get_Struct(rb_ivar_get(self, rb_intern("@handle")), Compiler, &compiler_type, comp);
308
- ShaderResources resources = comp->get_shader_resources();
301
+ spirv_cross::Compiler *comp;
302
+ TypedData_Get_Struct(rb_ivar_get(self, rb_intern("@handle")), spirv_cross::Compiler, &compiler_type, comp);
303
+ spirv_cross::ShaderResources resources = comp->get_shader_resources();
309
304
  return shader_resources_to_hash(comp, resources);
310
305
  }
311
306
 
312
307
  VALUE rb_spvx_compiler_active_shader_resources(VALUE self) {
313
- Compiler *comp;
314
- TypedData_Get_Struct(rb_ivar_get(self, rb_intern("@handle")), Compiler, &compiler_type, comp);
308
+ spirv_cross::Compiler *comp;
309
+ TypedData_Get_Struct(rb_ivar_get(self, rb_intern("@handle")), spirv_cross::Compiler, &compiler_type, comp);
315
310
  auto active = comp->get_active_interface_variables();
316
- ShaderResources resources = comp->get_shader_resources(active);
317
- // comp->set_enabled_interface_variables(move(active));
311
+ spirv_cross::ShaderResources resources = comp->get_shader_resources(active);
312
+ // comp->set_enabled_interface_variables(std::move(active));
318
313
  return shader_resources_to_hash(comp, resources);
319
314
  }
320
315
 
321
316
  VALUE rb_spvx_compiler_entry_points(VALUE self) {
322
- Compiler *comp;
323
- TypedData_Get_Struct(rb_ivar_get(self, rb_intern("@handle")), Compiler, &compiler_type, comp);
324
- std::vector<EntryPoint> entry_points = comp->get_entry_points_and_stages();
317
+ spirv_cross::Compiler *comp;
318
+ TypedData_Get_Struct(rb_ivar_get(self, rb_intern("@handle")), spirv_cross::Compiler, &compiler_type, comp);
319
+ spirv_cross::SmallVector<spirv_cross::EntryPoint> entry_points = comp->get_entry_points_and_stages();
325
320
  VALUE ret = rb_ary_new();
326
321
  for (auto &ep : entry_points) {
327
322
  VALUE vep = rb_hash_new();
328
323
  rb_ary_push(ret, vep);
329
324
  rb_hash_aset(vep, ID2SYM(rb_intern("name")), rb_str_new2(ep.name.c_str()));
330
325
  switch(ep.execution_model) {
331
- case ExecutionModel::ExecutionModelVertex: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("vertex"))); break;
332
- case ExecutionModel::ExecutionModelTessellationControl: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("tessellation_control"))); break;
333
- case ExecutionModel::ExecutionModelTessellationEvaluation: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("tessellation_evaluation"))); break;
334
- case ExecutionModel::ExecutionModelGeometry: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("geometry"))); break;
335
- case ExecutionModel::ExecutionModelFragment: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("fragment"))); break;
336
- case ExecutionModel::ExecutionModelGLCompute: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("gl_compute"))); break;
337
- case ExecutionModel::ExecutionModelKernel: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("kernel"))); break;
338
- case ExecutionModel::ExecutionModelMax: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("max"))); break;
339
- default: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("unknown"))); break;
326
+ case spv::ExecutionModel::ExecutionModelVertex: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("vertex"))); break;
327
+ case spv::ExecutionModel::ExecutionModelTessellationControl: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("tessellation_control"))); break;
328
+ case spv::ExecutionModel::ExecutionModelTessellationEvaluation: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("tessellation_evaluation"))); break;
329
+ case spv::ExecutionModel::ExecutionModelGeometry: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("geometry"))); break;
330
+ case spv::ExecutionModel::ExecutionModelFragment: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("fragment"))); break;
331
+ case spv::ExecutionModel::ExecutionModelGLCompute: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("gl_compute"))); break;
332
+ case spv::ExecutionModel::ExecutionModelKernel: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("kernel"))); break;
333
+ case spv::ExecutionModel::ExecutionModelMax: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("max"))); break;
334
+ default: rb_hash_aset(vep, ID2SYM(rb_intern("execution_model")), ID2SYM(rb_intern("unknown"))); break;
340
335
  }
341
336
  }
342
337
  return ret;
343
338
  }
344
339
 
345
340
  VALUE rb_spvx_compiler_specialization_constants(VALUE self) {
346
- Compiler *comp;
347
- TypedData_Get_Struct(rb_ivar_get(self, rb_intern("@handle")), Compiler, &compiler_type, comp);
348
- vector<SpecializationConstant> consts = comp->get_specialization_constants();
341
+ spirv_cross::Compiler *comp;
342
+ TypedData_Get_Struct(rb_ivar_get(self, rb_intern("@handle")), spirv_cross::Compiler, &compiler_type, comp);
343
+ spirv_cross::SmallVector<spirv_cross::SpecializationConstant> consts = comp->get_specialization_constants();
349
344
  VALUE vconsts = rb_ary_new();
350
345
  for (auto &c : consts) {
351
346
  VALUE vconst = rb_hash_new();
@@ -359,15 +354,15 @@ extern "C" {
359
354
  VALUE rb_spvx_compiler_initialize(VALUE self, VALUE binstr) {
360
355
  size_t len = RSTRING_LEN(binstr) / sizeof(uint32_t);
361
356
  uint32_t *data = (uint32_t *) RSTRING_PTR(binstr);
362
- vector<uint32_t> spirv;
357
+ std::vector<uint32_t> spirv;
363
358
  for (size_t i = 0; i < len; i++) {
364
359
  spirv.push_back(data[i]);
365
360
  }
366
361
 
367
362
  try {
368
- Compiler *compiler = new Compiler(move(spirv));
363
+ spirv_cross::Compiler *compiler = new spirv_cross::Compiler(std::move(spirv));
369
364
  rb_ivar_set(self, rb_intern("@handle"), TypedData_Wrap_Struct(rb_cData, &compiler_type, compiler));
370
- } catch(const exception &ex) {
365
+ } catch(const std::exception &ex) {
371
366
  rb_raise(rb_eSPIRVError, "%s", ex.what());
372
367
  }
373
368
 
@@ -1,5 +1,5 @@
1
1
  module SPIRV
2
2
  module Cross
3
- VERSION = "0.1.1"
3
+ VERSION = "0.1.2"
4
4
  end
5
5
  end
@@ -33,8 +33,8 @@ Gem::Specification.new do |spec|
33
33
  spec.require_paths = ["lib"]
34
34
  spec.extensions = ["ext/spirv_cross/extconf.rb"]
35
35
 
36
- spec.add_development_dependency "bundler", "~> 1.17"
37
- spec.add_development_dependency "rake", "~> 10.0"
36
+ spec.add_development_dependency "bundler", "~> 2.1"
37
+ spec.add_development_dependency "rake", "~> 13.0"
38
38
  spec.add_development_dependency "rake-compiler"
39
39
  spec.add_development_dependency "minitest", "~> 5.0"
40
40
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: spirv-cross
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.1
4
+ version: 0.1.2
5
5
  platform: ruby
6
6
  authors:
7
7
  - Colin MacKenzie IV
8
8
  autorequire:
9
9
  bindir: exe
10
10
  cert_chain: []
11
- date: 2018-11-18 00:00:00.000000000 Z
11
+ date: 2020-01-10 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: bundler
@@ -16,28 +16,28 @@ dependencies:
16
16
  requirements:
17
17
  - - "~>"
18
18
  - !ruby/object:Gem::Version
19
- version: '1.17'
19
+ version: '2.1'
20
20
  type: :development
21
21
  prerelease: false
22
22
  version_requirements: !ruby/object:Gem::Requirement
23
23
  requirements:
24
24
  - - "~>"
25
25
  - !ruby/object:Gem::Version
26
- version: '1.17'
26
+ version: '2.1'
27
27
  - !ruby/object:Gem::Dependency
28
28
  name: rake
29
29
  requirement: !ruby/object:Gem::Requirement
30
30
  requirements:
31
31
  - - "~>"
32
32
  - !ruby/object:Gem::Version
33
- version: '10.0'
33
+ version: '13.0'
34
34
  type: :development
35
35
  prerelease: false
36
36
  version_requirements: !ruby/object:Gem::Requirement
37
37
  requirements:
38
38
  - - "~>"
39
39
  - !ruby/object:Gem::Version
40
- version: '10.0'
40
+ version: '13.0'
41
41
  - !ruby/object:Gem::Dependency
42
42
  name: rake-compiler
43
43
  requirement: !ruby/object:Gem::Requirement
@@ -115,8 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
115
115
  - !ruby/object:Gem::Version
116
116
  version: '0'
117
117
  requirements: []
118
- rubyforge_project:
119
- rubygems_version: 2.7.8
118
+ rubygems_version: 3.1.1
120
119
  signing_key:
121
120
  specification_version: 4
122
121
  summary: Ruby bindings for SPIRV-Cross to provide reflection of SPIR-V shaders.