qmuntal/gltf | Build 9713813290 | binary/encode.go | Coveralls

17

func Read(b []byte, byteStride uint32, data any) error {

324✔

18

        c, t, n := Type(data)

324✔

19

        size := gltf.SizeOfElement(c, t)

324✔

20

        if byteStride == 0 {

648✔

21

                byteStride = size

324✔

22

324✔

23

        e := int(byteStride)

324✔

24

        high := int(n) * e

324✔

25

        if byteStride != size {

324✔

28

        if len(b) < high {

330✔

29

                return io.ErrShortBuffer

6✔

30

6✔

31

        switch data := data.(type) {

318✔

32

        case []color.RGBA:

6✔

33

                for i := range data {

18✔

34

                        c := Ubyte.Vec4(b[e*i:])

12✔

35

                        data[i] = color.RGBA{R: c[0], G: c[1], B: c[2], A: c[3]}

12✔

36

12✔

37

        case []color.RGBA64:

6✔

38

                for i := range data {

18✔

39

                        c := Ushort.Vec4(b[e*i:])

12✔

40

                        data[i] = color.RGBA64{R: c[0], G: c[1], B: c[2], A: c[3]}

12✔

41

12✔

42

        case []int8:

18✔

43

                for i, x := range b {

48✔

44

                        data[i] = int8(x)

30✔

45

30✔

46

        case [][2]int8:

6✔

47

                for i := range data {

18✔

48

                        data[i] = Byte.Vec2(b[e*i:])

12✔

49

12✔

50

        case [][3]int8:

6✔

51

                for i := range data {

18✔

52

                        data[i] = Byte.Vec3(b[e*i:])

12✔

53

12✔

54

        case [][4]int8:

6✔

55

                for i := range data {

18✔

56

                        data[i] = Byte.Vec4(b[e*i:])

12✔

57

12✔

58

        case [][2][2]int8:

6✔

59

                for i := range data {

18✔

60

                        data[i] = Byte.Mat2(b[e*i:])

12✔

61

12✔

62

        case [][3][3]int8:

6✔

63

                for i := range data {

18✔

64

                        data[i] = Byte.Mat3(b[e*i:])

12✔

65

12✔

66

        case [][4][4]int8:

6✔

67

                for i := range data {

18✔

68

                        data[i] = Byte.Mat4(b[e*i:])

12✔

69

12✔

70

        case []uint8:

18✔

71

                if byteStride != 1 {

18✔

73

                } else {

18✔

74

                        for i := range data {

156✔

75

                                data[i] = Ubyte.Scalar(b[e*i:])

138✔

76

138✔

78

        case [][2]uint8:

6✔

79

                for i := range data {

18✔

80

                        data[i] = Ubyte.Vec2(b[e*i:])

12✔

81

12✔

82

        case [][3]uint8:

6✔

83

                for i := range data {

18✔

84

                        data[i] = Ubyte.Vec3(b[e*i:])

12✔

85

12✔

86

        case [][4]uint8:

6✔

87

                for i := range data {

18✔

88

                        data[i] = Ubyte.Vec4(b[e*i:])

12✔

89

12✔

90

        case [][2][2]uint8:

6✔

91

                for i := range data {

18✔

92

                        data[i] = Ubyte.Mat2(b[e*i:])

12✔

93

12✔

94

        case [][3][3]uint8:

6✔

95

                for i := range data {

18✔

96

                        data[i] = Ubyte.Mat3(b[e*i:])

12✔

97

12✔

98

        case [][4][4]uint8:

6✔

99

                for i := range data {

18✔

100

                        data[i] = Ubyte.Mat4(b[e*i:])

12✔

101

12✔

102

        case []int16:

12✔

103

                for i := range data {

42✔

104

                        data[i] = Short.Scalar(b[e*i:])

30✔

105

30✔

106

        case [][2]int16:

6✔

107

                for i := range data {

18✔

108

                        data[i] = Short.Vec2(b[e*i:])

12✔

109

12✔

110

        case [][3]int16:

6✔

111

                for i := range data {

18✔

112

                        data[i] = Short.Vec3(b[e*i:])

12✔

113

12✔

114

        case [][4]int16:

6✔

115

                for i := range data {

18✔

116

                        data[i] = Short.Vec4(b[e*i:])

12✔

117

12✔

118

        case [][2][2]int16:

6✔

119

                for i := range data {

18✔

120

                        data[i] = Short.Mat2(b[e*i:])

12✔

121

12✔

122

        case [][3][3]int16:

6✔

123

                for i := range data {

18✔

124

                        data[i] = Short.Mat3(b[e*i:])

12✔

125

12✔

126

        case [][4][4]int16:

6✔

127

                for i := range data {

18✔

128

                        data[i] = Short.Mat4(b[e*i:])

12✔

129

12✔

130

        case []uint16:

12✔

131

                for i := range data {

42✔

132

                        data[i] = Ushort.Scalar(b[e*i:])

30✔

133

30✔

134

        case [][2]uint16:

6✔

135

                for i := range data {

18✔

136

                        data[i] = Ushort.Vec2(b[e*i:])

12✔

137

12✔

138

        case [][3]uint16:

6✔

139

                for i := range data {

18✔

140

                        data[i] = Ushort.Vec3(b[e*i:])

12✔

141

12✔

142

        case [][4]uint16:

6✔

143

                for i := range data {

18✔

144

                        data[i] = Ushort.Vec4(b[e*i:])

12✔

145

12✔

146

        case [][2][2]uint16:

6✔

147

                for i := range data {

18✔

148

                        data[i] = Ushort.Mat2(b[e*i:])

12✔

149

12✔

150

        case [][3][3]uint16:

6✔

151

                for i := range data {

18✔

152

                        data[i] = Ushort.Mat3(b[e*i:])

12✔

153

12✔

154

        case [][4][4]uint16:

6✔

155

                for i := range data {

18✔

156

                        data[i] = Ushort.Mat4(b[e*i:])

12✔

157

12✔

158

        case []float32:

12✔

159

                for i := range data {

42✔

160

                        data[i] = Float.Scalar(b[e*i:])

30✔

161

30✔

162

        case [][2]float32:

6✔

163

                for i := range data {

18✔

164

                        data[i] = Float.Vec2(b[e*i:])

12✔

165

12✔

166

        case [][3]float32:

12✔

167

                for i := range data {

54✔

168

                        data[i] = Float.Vec3(b[e*i:])

42✔

169

42✔

170

        case [][4]float32:

6✔

171

                for i := range data {

18✔

172

                        data[i] = Float.Vec4(b[e*i:])

12✔

173

12✔

174

        case [][2][2]float32:

6✔

175

                for i := range data {

18✔

176

                        data[i] = Float.Mat2(b[e*i:])

12✔

177

12✔

178

        case [][3][3]float32:

6✔

179

                for i := range data {

18✔

180

                        data[i] = Float.Mat3(b[e*i:])

12✔

181

12✔

182

        case [][4][4]float32:

6✔

183

                for i := range data {

18✔

184

                        data[i] = Float.Mat4(b[e*i:])

12✔

185

12✔

186

        case []uint32:

12✔

187

                for i := range data {

42✔

188

                        data[i] = Uint.Scalar(b[e*i:])

30✔

189

30✔

190

        case [][2]uint32:

6✔

191

                for i := range data {

18✔

192

                        data[i] = Uint.Vec2(b[e*i:])

12✔

193

12✔

194

        case [][3]uint32:

6✔

195

                for i := range data {

18✔

196

                        data[i] = Uint.Vec3(b[e*i:])

12✔

197

12✔

198

        case [][4]uint32:

6✔

199

                for i := range data {

18✔

200

                        data[i] = Uint.Vec4(b[e*i:])

12✔

201

12✔

202

        case [][2][2]uint32:

6✔

203

                for i := range data {

18✔

204

                        data[i] = Uint.Mat2(b[e*i:])

12✔

205

12✔

206

        case [][3][3]uint32:

6✔

207

                for i := range data {

18✔

208

                        data[i] = Uint.Mat3(b[e*i:])

12✔

209

12✔

210

        case [][4][4]uint32:

6✔

211

                for i := range data {

18✔

212

                        data[i] = Uint.Mat4(b[e*i:])

12✔

213

12✔

217

        return nil

318✔

225

func Write(b []byte, stride uint32, data any) error {

324✔

226

        c, t, n := Type(data)

324✔

227

        if n == 0 {

330✔

228

                return binary.Write(bytes.NewBuffer(b), binary.LittleEndian, data)

6✔

229

6✔

230

        e := int(stride)

318✔

231

        sizeOfElement := int(gltf.SizeOfElement(c, t))

318✔

232

        if stride == 0 {

636✔

233

                e = sizeOfElement

318✔

234

318✔

235

        if len(b) < e*(int(n)-1)+sizeOfElement {

324✔

236

                return io.ErrShortBuffer

6✔

237

6✔

238

        switch data := data.(type) {

312✔

239

        case []color.RGBA:

6✔

240

                for i, x := range data {

18✔

241

                        Ubyte.PutVec4(b[e*i:], [4]uint8{x.R, x.G, x.B, x.A})

12✔

242

12✔

243

        case []color.RGBA64:

6✔

244

                for i, x := range data {

18✔

245

                        Ushort.PutVec4(b[e*i:], [4]uint16{x.R, x.G, x.B, x.A})

12✔

246

12✔

247

        case []int8:

12✔

248

                for i, x := range data {

42✔

249

                        b[e*i] = byte(x)

30✔

250

30✔

251

        case [][2]int8:

6✔

252

                for i := range data {

18✔

253

                        Byte.PutVec2(b[e*i:], data[i])

12✔

254

12✔

255

        case [][3]int8:

6✔

256

                for i := range data {

18✔

257

                        Byte.PutVec3(b[e*i:], data[i])

12✔

258

12✔

259

        case [][4]int8:

6✔

260

                for i := range data {

18✔

261

                        Byte.PutVec4(b[e*i:], data[i])

12✔

262

12✔

263

        case [][2][2]int8:

6✔

264

                for i := range data {

18✔

265

                        Byte.PutMat2(b[e*i:], data[i])

12✔

266

12✔

267

        case [][3][3]int8:

6✔

268

                for i := range data {

18✔

269

                        Byte.PutMat3(b[e*i:], data[i])

12✔

270

12✔

271

        case [][4][4]int8:

6✔

272

                for i := range data {

18✔

273

                        Byte.PutMat4(b[e*i:], data[i])

12✔

274

12✔

275

        case []uint8:

18✔

276

                copy(b, data)

18✔

277

        case [][2]uint8:

6✔

278

                for i := range data {

18✔

279

                        Ubyte.PutVec2(b[e*i:], data[i])

12✔

280

12✔

281

        case [][3]uint8:

6✔

282

                for i := range data {

18✔

283

                        Ubyte.PutVec3(b[e*i:], data[i])

12✔

284

12✔

285

        case [][4]uint8:

6✔

286

                for i := range data {

18✔

287

                        Ubyte.PutVec4(b[e*i:], data[i])

12✔

288

12✔

289

        case [][2][2]uint8:

6✔

290

                for i := range data {

18✔

291

                        Ubyte.PutMat2(b[e*i:], data[i])

12✔

292

12✔

293

        case [][3][3]uint8:

6✔

294

                for i := range data {

18✔

295

                        Ubyte.PutMat3(b[e*i:], data[i])

12✔

296

12✔

297

        case [][4][4]uint8:

6✔

298

                for i := range data {

18✔

299

                        Ubyte.PutMat4(b[e*i:], data[i])

12✔

300

12✔

301

        case []int16:

12✔

302

                for i := range data {

42✔

303

                        Short.PutScalar(b[e*i:], data[i])

30✔

304

30✔

305

        case [][2]int16:

6✔

306

                for i := range data {

18✔

307

                        Short.PutVec2(b[e*i:], data[i])

12✔

308

12✔

309

        case [][3]int16:

6✔

310

                for i := range data {

18✔

311

                        Short.PutVec3(b[e*i:], data[i])

12✔

312

12✔

313

        case [][4]int16:

6✔

314

                for i := range data {

18✔

315

                        Short.PutVec4(b[e*i:], data[i])

12✔

316

12✔

317

        case [][2][2]int16:

6✔

318

                for i := range data {

18✔

319

                        Short.PutMat2(b[e*i:], data[i])

12✔

320

12✔

321

        case [][3][3]int16:

6✔

322

                for i := range data {

18✔

323

                        Short.PutMat3(b[e*i:], data[i])

12✔

324

12✔

325

        case [][4][4]int16:

6✔

326

                for i := range data {

18✔

327

                        Short.PutMat4(b[e*i:], data[i])

12✔

328

12✔

329

        case []uint16:

12✔

330

                for i := range data {

42✔

331

                        Ushort.PutScalar(b[e*i:], data[i])

30✔

332

30✔

333

        case [][2]uint16:

6✔

334

                for i := range data {

18✔

335

                        Ushort.PutVec2(b[e*i:], data[i])

12✔

336

12✔

337

        case [][3]uint16:

6✔

338

                for i := range data {

18✔

339

                        Ushort.PutVec3(b[e*i:], data[i])

12✔

340

12✔

341

        case [][4]uint16:

6✔

342

                for i := range data {

18✔

343

                        Ushort.PutVec4(b[e*i:], data[i])

12✔

344

12✔

345

        case [][2][2]uint16:

6✔

346

                for i := range data {

18✔

347

                        Ushort.PutMat2(b[e*i:], data[i])

12✔

348

12✔

349

        case [][3][3]uint16:

6✔

350

                for i := range data {

18✔

351

                        Ushort.PutMat3(b[e*i:], data[i])

12✔

352

12✔

353

        case [][4][4]uint16:

6✔

354

                for i := range data {

18✔

355

                        Ushort.PutMat4(b[e*i:], data[i])

12✔

356

12✔

357

        case []float32:

12✔

358

                for i := range data {

42✔

359

                        Float.PutScalar(b[e*i:], data[i])

30✔

360

30✔

361

        case [][2]float32:

6✔

362

                for i := range data {

18✔

363

                        Float.PutVec2(b[e*i:], data[i])

12✔

364

12✔

365

        case [][3]float32:

12✔

366

                for i := range data {

54✔

367

                        Float.PutVec3(b[e*i:], data[i])

42✔

368

42✔

369

        case [][4]float32:

6✔

370

                for i := range data {

18✔

371

                        Float.PutVec4(b[e*i:], data[i])

12✔

372

12✔

373

        case [][2][2]float32:

6✔

374

                for i := range data {

18✔

375

                        Float.PutMat2(b[e*i:], data[i])

12✔

376

12✔

377

        case [][3][3]float32:

6✔

378

                for i := range data {

18✔

379

                        Float.PutMat3(b[e*i:], data[i])

12✔

380

12✔

381

        case [][4][4]float32:

6✔

382

                for i := range data {

18✔

383

                        Float.PutMat4(b[e*i:], data[i])

12✔

384

12✔

385

        case []uint32:

12✔

386

                for i := range data {

42✔

387

                        Uint.PutScalar(b[e*i:], data[i])

30✔

388

30✔

389

        case [][2]uint32:

6✔

390

                for i := range data {

18✔

391

                        Uint.PutVec2(b[e*i:], data[i])

12✔

392

12✔

393

        case [][3]uint32:

6✔

394

                for i := range data {

18✔

395

                        Uint.PutVec3(b[e*i:], data[i])

12✔

396

12✔

397

        case [][4]uint32:

6✔

398

                for i := range data {

18✔

399

                        Uint.PutVec4(b[e*i:], data[i])

12✔

400

12✔

401

        case [][2][2]uint32:

6✔

402

                for i := range data {

18✔

403

                        Uint.PutMat2(b[e*i:], data[i])

12✔

404

12✔

405

        case [][3][3]uint32:

6✔

406

                for i := range data {

18✔

407

                        Uint.PutMat3(b[e*i:], data[i])

12✔

408

12✔

409

        case [][4][4]uint32:

6✔

410

                for i := range data {

18✔

411

                        Uint.PutMat4(b[e*i:], data[i])

12✔

412

12✔

414

        return nil

312✔

qmuntal / gltf / 9713813290

Source File
Press 'n' to go to next uncovered line, 'b' for previous

1	package binary
2
3	import (
4	"bytes"
5	"encoding/binary"
6	"image/color"
7	"io"
8
9	"github.com/qmuntal/gltf"
10	)
11
12	// Read reads structured binary data from b into data.
13	// byteStride can be zero for non-interleaved buffer views.
14	//
15	// Data should be a slice of glTF predefined fixed-size types.
16	// If data length is greater than the length of b, Read returns io.ErrShortBuffer.
17	func Read(b []byte, byteStride uint32, data any) error {	324✔
18	c, t, n := Type(data)	324✔
19	size := gltf.SizeOfElement(c, t)	324✔
20	if byteStride == 0 {	648✔
21	byteStride = size	324✔
22	}	324✔
23	e := int(byteStride)	324✔
24	high := int(n) * e	324✔
25	if byteStride != size {	324✔
26	high -= int(byteStride - size)	×
27	}	×
28	if len(b) < high {	330✔
29	return io.ErrShortBuffer	6✔
30	}	6✔
31	switch data := data.(type) {	318✔
32	case []color.RGBA:	6✔
33	for i := range data {	18✔
34	c := Ubyte.Vec4(b[e*i:])	12✔
35	data[i] = color.RGBA{R: c[0], G: c[1], B: c[2], A: c[3]}	12✔
36	}	12✔
37	case []color.RGBA64:	6✔
38	for i := range data {	18✔
39	c := Ushort.Vec4(b[e*i:])	12✔
40	data[i] = color.RGBA64{R: c[0], G: c[1], B: c[2], A: c[3]}	12✔
41	}	12✔
42	case []int8:	18✔
43	for i, x := range b {	48✔
44	data[i] = int8(x)	30✔
45	}	30✔
46	case [][2]int8:	6✔
47	for i := range data {	18✔
48	data[i] = Byte.Vec2(b[e*i:])	12✔
49	}	12✔
50	case [][3]int8:	6✔
51	for i := range data {	18✔
52	data[i] = Byte.Vec3(b[e*i:])	12✔
53	}	12✔
54	case [][4]int8:	6✔
55	for i := range data {	18✔
56	data[i] = Byte.Vec4(b[e*i:])	12✔
57	}	12✔
58	case [][2][2]int8:	6✔
59	for i := range data {	18✔
60	data[i] = Byte.Mat2(b[e*i:])	12✔
61	}	12✔
62	case [][3][3]int8:	6✔
63	for i := range data {	18✔
64	data[i] = Byte.Mat3(b[e*i:])	12✔
65	}	12✔
66	case [][4][4]int8:	6✔
67	for i := range data {	18✔
68	data[i] = Byte.Mat4(b[e*i:])	12✔
69	}	12✔
70	case []uint8:	18✔
71	if byteStride != 1 {	18✔
72	copy(data, b)	×
73	} else {	18✔
74	for i := range data {	156✔
75	data[i] = Ubyte.Scalar(b[e*i:])	138✔
76	}	138✔
77	}
78	case [][2]uint8:	6✔
79	for i := range data {	18✔
80	data[i] = Ubyte.Vec2(b[e*i:])	12✔
81	}	12✔
82	case [][3]uint8:	6✔
83	for i := range data {	18✔
84	data[i] = Ubyte.Vec3(b[e*i:])	12✔
85	}	12✔
86	case [][4]uint8:	6✔
87	for i := range data {	18✔
88	data[i] = Ubyte.Vec4(b[e*i:])	12✔
89	}	12✔
90	case [][2][2]uint8:	6✔
91	for i := range data {	18✔
92	data[i] = Ubyte.Mat2(b[e*i:])	12✔
93	}	12✔
94	case [][3][3]uint8:	6✔
95	for i := range data {	18✔
96	data[i] = Ubyte.Mat3(b[e*i:])	12✔
97	}	12✔
98	case [][4][4]uint8:	6✔
99	for i := range data {	18✔
100	data[i] = Ubyte.Mat4(b[e*i:])	12✔
101	}	12✔
102	case []int16:	12✔
103	for i := range data {	42✔
104	data[i] = Short.Scalar(b[e*i:])	30✔
105	}	30✔
106	case [][2]int16:	6✔
107	for i := range data {	18✔
108	data[i] = Short.Vec2(b[e*i:])	12✔
109	}	12✔
110	case [][3]int16:	6✔
111	for i := range data {	18✔
112	data[i] = Short.Vec3(b[e*i:])	12✔
113	}	12✔
114	case [][4]int16:	6✔
115	for i := range data {	18✔
116	data[i] = Short.Vec4(b[e*i:])	12✔
117	}	12✔
118	case [][2][2]int16:	6✔
119	for i := range data {	18✔
120	data[i] = Short.Mat2(b[e*i:])	12✔
121	}	12✔
122	case [][3][3]int16:	6✔
123	for i := range data {	18✔
124	data[i] = Short.Mat3(b[e*i:])	12✔
125	}	12✔
126	case [][4][4]int16:	6✔
127	for i := range data {	18✔
128	data[i] = Short.Mat4(b[e*i:])	12✔
129	}	12✔
130	case []uint16:	12✔
131	for i := range data {	42✔
132	data[i] = Ushort.Scalar(b[e*i:])	30✔
133	}	30✔
134	case [][2]uint16:	6✔
135	for i := range data {	18✔
136	data[i] = Ushort.Vec2(b[e*i:])	12✔
137	}	12✔
138	case [][3]uint16:	6✔
139	for i := range data {	18✔
140	data[i] = Ushort.Vec3(b[e*i:])	12✔
141	}	12✔
142	case [][4]uint16:	6✔
143	for i := range data {	18✔
144	data[i] = Ushort.Vec4(b[e*i:])	12✔
145	}	12✔
146	case [][2][2]uint16:	6✔
147	for i := range data {	18✔
148	data[i] = Ushort.Mat2(b[e*i:])	12✔
149	}	12✔
150	case [][3][3]uint16:	6✔
151	for i := range data {	18✔
152	data[i] = Ushort.Mat3(b[e*i:])	12✔
153	}	12✔
154	case [][4][4]uint16:	6✔
155	for i := range data {	18✔
156	data[i] = Ushort.Mat4(b[e*i:])	12✔
157	}	12✔
158	case []float32:	12✔
159	for i := range data {	42✔
160	data[i] = Float.Scalar(b[e*i:])	30✔
161	}	30✔
162	case [][2]float32:	6✔
163	for i := range data {	18✔
164	data[i] = Float.Vec2(b[e*i:])	12✔
165	}	12✔
166	case [][3]float32:	12✔
167	for i := range data {	54✔
168	data[i] = Float.Vec3(b[e*i:])	42✔
169	}	42✔
170	case [][4]float32:	6✔
171	for i := range data {	18✔
172	data[i] = Float.Vec4(b[e*i:])	12✔
173	}	12✔
174	case [][2][2]float32:	6✔
175	for i := range data {	18✔
176	data[i] = Float.Mat2(b[e*i:])	12✔
177	}	12✔
178	case [][3][3]float32:	6✔
179	for i := range data {	18✔
180	data[i] = Float.Mat3(b[e*i:])	12✔
181	}	12✔
182	case [][4][4]float32:	6✔
183	for i := range data {	18✔
184	data[i] = Float.Mat4(b[e*i:])	12✔
185	}	12✔
186	case []uint32:	12✔
187	for i := range data {	42✔
188	data[i] = Uint.Scalar(b[e*i:])	30✔
189	}	30✔
190	case [][2]uint32:	6✔
191	for i := range data {	18✔
192	data[i] = Uint.Vec2(b[e*i:])	12✔
193	}	12✔
194	case [][3]uint32:	6✔
195	for i := range data {	18✔
196	data[i] = Uint.Vec3(b[e*i:])	12✔
197	}	12✔
198	case [][4]uint32:	6✔
199	for i := range data {	18✔
200	data[i] = Uint.Vec4(b[e*i:])	12✔
201	}	12✔
202	case [][2][2]uint32:	6✔
203	for i := range data {	18✔
204	data[i] = Uint.Mat2(b[e*i:])	12✔
205	}	12✔
206	case [][3][3]uint32:	6✔
207	for i := range data {	18✔
208	data[i] = Uint.Mat3(b[e*i:])	12✔
209	}	12✔
210	case [][4][4]uint32:	6✔
211	for i := range data {	18✔
212	data[i] = Uint.Mat4(b[e*i:])	12✔
213	}	12✔
214	default:	×
215	panic("unsupported type")	×
216	}
217	return nil	318✔
218	}
219
220	// Write writes the binary representation of data into b.
221	// If stride is diferent than zero data will be interleaved.
222	//
223	// Data must be a slice of glTF predefined fixed-size types,
224	// else it fallbacks to `encoding/binary.Write`.
225	func Write(b []byte, stride uint32, data any) error {	324✔
226	c, t, n := Type(data)	324✔
227	if n == 0 {	330✔
228	return binary.Write(bytes.NewBuffer(b), binary.LittleEndian, data)	6✔
229	}	6✔
230	e := int(stride)	318✔
231	sizeOfElement := int(gltf.SizeOfElement(c, t))	318✔
232	if stride == 0 {	636✔
233	e = sizeOfElement	318✔
234	}	318✔
235	if len(b) < e*(int(n)-1)+sizeOfElement {	324✔
236	return io.ErrShortBuffer	6✔
237	}	6✔
238	switch data := data.(type) {	312✔
239	case []color.RGBA:	6✔
240	for i, x := range data {	18✔
241	Ubyte.PutVec4(b[e*i:], [4]uint8{x.R, x.G, x.B, x.A})	12✔
242	}	12✔
243	case []color.RGBA64:	6✔
244	for i, x := range data {	18✔
245	Ushort.PutVec4(b[e*i:], [4]uint16{x.R, x.G, x.B, x.A})	12✔
246	}	12✔
247	case []int8:	12✔
248	for i, x := range data {	42✔
249	b[e*i] = byte(x)	30✔
250	}	30✔
251	case [][2]int8:	6✔
252	for i := range data {	18✔
253	Byte.PutVec2(b[e*i:], data[i])	12✔
254	}	12✔
255	case [][3]int8:	6✔
256	for i := range data {	18✔
257	Byte.PutVec3(b[e*i:], data[i])	12✔
258	}	12✔
259	case [][4]int8:	6✔
260	for i := range data {	18✔
261	Byte.PutVec4(b[e*i:], data[i])	12✔
262	}	12✔
263	case [][2][2]int8:	6✔
264	for i := range data {	18✔
265	Byte.PutMat2(b[e*i:], data[i])	12✔
266	}	12✔
267	case [][3][3]int8:	6✔
268	for i := range data {	18✔
269	Byte.PutMat3(b[e*i:], data[i])	12✔
270	}	12✔
271	case [][4][4]int8:	6✔
272	for i := range data {	18✔
273	Byte.PutMat4(b[e*i:], data[i])	12✔
274	}	12✔
275	case []uint8:	18✔
276	copy(b, data)	18✔
277	case [][2]uint8:	6✔
278	for i := range data {	18✔
279	Ubyte.PutVec2(b[e*i:], data[i])	12✔
280	}	12✔
281	case [][3]uint8:	6✔
282	for i := range data {	18✔
283	Ubyte.PutVec3(b[e*i:], data[i])	12✔
284	}	12✔
285	case [][4]uint8:	6✔
286	for i := range data {	18✔
287	Ubyte.PutVec4(b[e*i:], data[i])	12✔
288	}	12✔
289	case [][2][2]uint8:	6✔
290	for i := range data {	18✔
291	Ubyte.PutMat2(b[e*i:], data[i])	12✔
292	}	12✔
293	case [][3][3]uint8:	6✔
294	for i := range data {	18✔
295	Ubyte.PutMat3(b[e*i:], data[i])	12✔
296	}	12✔
297	case [][4][4]uint8:	6✔
298	for i := range data {	18✔
299	Ubyte.PutMat4(b[e*i:], data[i])	12✔
300	}	12✔
301	case []int16:	12✔
302	for i := range data {	42✔
303	Short.PutScalar(b[e*i:], data[i])	30✔
304	}	30✔
305	case [][2]int16:	6✔
306	for i := range data {	18✔
307	Short.PutVec2(b[e*i:], data[i])	12✔
308	}	12✔
309	case [][3]int16:	6✔
310	for i := range data {	18✔
311	Short.PutVec3(b[e*i:], data[i])	12✔
312	}	12✔
313	case [][4]int16:	6✔
314	for i := range data {	18✔
315	Short.PutVec4(b[e*i:], data[i])	12✔
316	}	12✔
317	case [][2][2]int16:	6✔
318	for i := range data {	18✔
319	Short.PutMat2(b[e*i:], data[i])	12✔
320	}	12✔
321	case [][3][3]int16:	6✔
322	for i := range data {	18✔
323	Short.PutMat3(b[e*i:], data[i])	12✔
324	}	12✔
325	case [][4][4]int16:	6✔
326	for i := range data {	18✔
327	Short.PutMat4(b[e*i:], data[i])	12✔
328	}	12✔
329	case []uint16:	12✔
330	for i := range data {	42✔
331	Ushort.PutScalar(b[e*i:], data[i])	30✔
332	}	30✔
333	case [][2]uint16:	6✔
334	for i := range data {	18✔
335	Ushort.PutVec2(b[e*i:], data[i])	12✔
336	}	12✔
337	case [][3]uint16:	6✔
338	for i := range data {	18✔
339	Ushort.PutVec3(b[e*i:], data[i])	12✔
340	}	12✔
341	case [][4]uint16:	6✔
342	for i := range data {	18✔
343	Ushort.PutVec4(b[e*i:], data[i])	12✔
344	}	12✔
345	case [][2][2]uint16:	6✔
346	for i := range data {	18✔
347	Ushort.PutMat2(b[e*i:], data[i])	12✔
348	}	12✔
349	case [][3][3]uint16:	6✔
350	for i := range data {	18✔
351	Ushort.PutMat3(b[e*i:], data[i])	12✔
352	}	12✔
353	case [][4][4]uint16:	6✔
354	for i := range data {	18✔
355	Ushort.PutMat4(b[e*i:], data[i])	12✔
356	}	12✔
357	case []float32:	12✔
358	for i := range data {	42✔
359	Float.PutScalar(b[e*i:], data[i])	30✔
360	}	30✔
361	case [][2]float32:	6✔
362	for i := range data {	18✔
363	Float.PutVec2(b[e*i:], data[i])	12✔
364	}	12✔
365	case [][3]float32:	12✔
366	for i := range data {	54✔
367	Float.PutVec3(b[e*i:], data[i])	42✔
368	}	42✔
369	case [][4]float32:	6✔
370	for i := range data {	18✔
371	Float.PutVec4(b[e*i:], data[i])	12✔
372	}	12✔
373	case [][2][2]float32:	6✔
374	for i := range data {	18✔
375	Float.PutMat2(b[e*i:], data[i])	12✔
376	}	12✔
377	case [][3][3]float32:	6✔
378	for i := range data {	18✔
379	Float.PutMat3(b[e*i:], data[i])	12✔
380	}	12✔
381	case [][4][4]float32:	6✔
382	for i := range data {	18✔
383	Float.PutMat4(b[e*i:], data[i])	12✔
384	}	12✔
385	case []uint32:	12✔
386	for i := range data {	42✔
387	Uint.PutScalar(b[e*i:], data[i])	30✔
388	}	30✔
389	case [][2]uint32:	6✔
390	for i := range data {	18✔
391	Uint.PutVec2(b[e*i:], data[i])	12✔
392	}	12✔
393	case [][3]uint32:	6✔
394	for i := range data {	18✔
395	Uint.PutVec3(b[e*i:], data[i])	12✔
396	}	12✔
397	case [][4]uint32:	6✔
398	for i := range data {	18✔
399	Uint.PutVec4(b[e*i:], data[i])	12✔
400	}	12✔
401	case [][2][2]uint32:	6✔
402	for i := range data {	18✔
403	Uint.PutMat2(b[e*i:], data[i])	12✔
404	}	12✔
405	case [][3][3]uint32:	6✔
406	for i := range data {	18✔
407	Uint.PutMat3(b[e*i:], data[i])	12✔
408	}	12✔
409	case [][4][4]uint32:	6✔
410	for i := range data {	18✔
411	Uint.PutMat4(b[e*i:], data[i])	12✔
412	}	12✔
413	}
414	return nil	312✔
415	}

qmuntal / gltf / 9713813290

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous