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

17

func Read(b []byte, byteStride int, 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 := range data {

48✔

44

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

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

                for i := range data {

156✔

72

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

138✔

73

138✔

74

        case [][2]uint8:

6✔

75

                for i := range data {

18✔

76

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

12✔

77

12✔

78

        case [][3]uint8:

6✔

79

                for i := range data {

18✔

80

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

12✔

81

12✔

82

        case [][4]uint8:

6✔

83

                for i := range data {

18✔

84

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

12✔

85

12✔

86

        case [][2][2]uint8:

6✔

87

                for i := range data {

18✔

88

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

12✔

89

12✔

90

        case [][3][3]uint8:

6✔

91

                for i := range data {

18✔

92

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

12✔

93

12✔

94

        case [][4][4]uint8:

6✔

95

                for i := range data {

18✔

96

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

12✔

97

12✔

98

        case []int16:

12✔

99

                for i := range data {

42✔

100

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

30✔

101

30✔

102

        case [][2]int16:

6✔

103

                for i := range data {

18✔

104

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

12✔

105

12✔

106

        case [][3]int16:

6✔

107

                for i := range data {

18✔

108

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

12✔

109

12✔

110

        case [][4]int16:

6✔

111

                for i := range data {

18✔

112

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

12✔

113

12✔

114

        case [][2][2]int16:

6✔

115

                for i := range data {

18✔

116

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

12✔

117

12✔

118

        case [][3][3]int16:

6✔

119

                for i := range data {

18✔

120

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

12✔

121

12✔

122

        case [][4][4]int16:

6✔

123

                for i := range data {

18✔

124

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

12✔

125

12✔

126

        case []uint16:

12✔

127

                for i := range data {

42✔

128

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

30✔

129

30✔

130

        case [][2]uint16:

6✔

131

                for i := range data {

18✔

132

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

12✔

133

12✔

134

        case [][3]uint16:

6✔

135

                for i := range data {

18✔

136

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

12✔

137

12✔

138

        case [][4]uint16:

6✔

139

                for i := range data {

18✔

140

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

12✔

141

12✔

142

        case [][2][2]uint16:

6✔

143

                for i := range data {

18✔

144

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

12✔

145

12✔

146

        case [][3][3]uint16:

6✔

147

                for i := range data {

18✔

148

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

12✔

149

12✔

150

        case [][4][4]uint16:

6✔

151

                for i := range data {

18✔

152

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

12✔

153

12✔

154

        case []float32:

12✔

155

                for i := range data {

42✔

156

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

30✔

157

30✔

158

        case [][2]float32:

6✔

159

                for i := range data {

18✔

160

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

12✔

161

12✔

162

        case [][3]float32:

12✔

163

                for i := range data {

54✔

164

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

42✔

165

42✔

166

        case [][4]float32:

6✔

167

                for i := range data {

18✔

168

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

12✔

169

12✔

170

        case [][2][2]float32:

6✔

171

                for i := range data {

18✔

172

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

12✔

173

12✔

174

        case [][3][3]float32:

6✔

175

                for i := range data {

18✔

176

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

12✔

177

12✔

178

        case [][4][4]float32:

6✔

179

                for i := range data {

18✔

180

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

12✔

181

12✔

182

        case []uint32:

12✔

183

                for i := range data {

42✔

184

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

30✔

185

30✔

186

        case [][2]uint32:

6✔

187

                for i := range data {

18✔

188

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

12✔

189

12✔

190

        case [][3]uint32:

6✔

191

                for i := range data {

18✔

192

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

12✔

193

12✔

194

        case [][4]uint32:

6✔

195

                for i := range data {

18✔

196

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

12✔

197

12✔

198

        case [][2][2]uint32:

6✔

199

                for i := range data {

18✔

200

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

12✔

201

12✔

202

        case [][3][3]uint32:

6✔

203

                for i := range data {

18✔

204

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

12✔

205

12✔

206

        case [][4][4]uint32:

6✔

207

                for i := range data {

18✔

208

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

12✔

209

12✔

213

        return nil

318✔

221

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

324✔

222

        c, t, n := Type(data)

324✔

223

        if n == 0 {

330✔

224

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

6✔

225

6✔

226

        e := int(stride)

318✔

227

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

318✔

228

        if stride == 0 {

636✔

229

                e = sizeOfElement

318✔

230

318✔

231

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

324✔

232

                return io.ErrShortBuffer

6✔

233

6✔

234

        switch data := data.(type) {

312✔

235

        case []color.RGBA:

6✔

236

                for i, x := range data {

18✔

237

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

12✔

238

12✔

239

        case []color.RGBA64:

6✔

240

                for i, x := range data {

18✔

241

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

12✔

242

12✔

243

        case []int8:

12✔

244

                for i, x := range data {

42✔

245

                        b[e*i] = byte(x)

30✔

246

30✔

247

        case [][2]int8:

6✔

248

                for i := range data {

18✔

249

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

12✔

250

12✔

251

        case [][3]int8:

6✔

252

                for i := range data {

18✔

253

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

12✔

254

12✔

255

        case [][4]int8:

6✔

256

                for i := range data {

18✔

257

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

12✔

258

12✔

259

        case [][2][2]int8:

6✔

260

                for i := range data {

18✔

261

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

12✔

262

12✔

263

        case [][3][3]int8:

6✔

264

                for i := range data {

18✔

265

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

12✔

266

12✔

267

        case [][4][4]int8:

6✔

268

                for i := range data {

18✔

269

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

12✔

270

12✔

271

        case []uint8:

18✔

272

                if e == 1 {

36✔

273

                        copy(b, data)

18✔

274

                } else {

18✔

279

        case [][2]uint8:

6✔

280

                for i := range data {

18✔

281

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

12✔

282

12✔

283

        case [][3]uint8:

6✔

284

                for i := range data {

18✔

285

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

12✔

286

12✔

287

        case [][4]uint8:

6✔

288

                for i := range data {

18✔

289

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

12✔

290

12✔

291

        case [][2][2]uint8:

6✔

292

                for i := range data {

18✔

293

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

12✔

294

12✔

295

        case [][3][3]uint8:

6✔

296

                for i := range data {

18✔

297

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

12✔

298

12✔

299

        case [][4][4]uint8:

6✔

300

                for i := range data {

18✔

301

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

12✔

302

12✔

303

        case []int16:

12✔

304

                for i := range data {

42✔

305

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

30✔

306

30✔

307

        case [][2]int16:

6✔

308

                for i := range data {

18✔

309

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

12✔

310

12✔

311

        case [][3]int16:

6✔

312

                for i := range data {

18✔

313

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

12✔

314

12✔

315

        case [][4]int16:

6✔

316

                for i := range data {

18✔

317

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

12✔

318

12✔

319

        case [][2][2]int16:

6✔

320

                for i := range data {

18✔

321

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

12✔

322

12✔

323

        case [][3][3]int16:

6✔

324

                for i := range data {

18✔

325

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

12✔

326

12✔

327

        case [][4][4]int16:

6✔

328

                for i := range data {

18✔

329

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

12✔

330

12✔

331

        case []uint16:

12✔

332

                for i := range data {

42✔

333

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

30✔

334

30✔

335

        case [][2]uint16:

6✔

336

                for i := range data {

18✔

337

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

12✔

338

12✔

339

        case [][3]uint16:

6✔

340

                for i := range data {

18✔

341

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

12✔

342

12✔

343

        case [][4]uint16:

6✔

344

                for i := range data {

18✔

345

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

12✔

346

12✔

347

        case [][2][2]uint16:

6✔

348

                for i := range data {

18✔

349

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

12✔

350

12✔

351

        case [][3][3]uint16:

6✔

352

                for i := range data {

18✔

353

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

12✔

354

12✔

355

        case [][4][4]uint16:

6✔

356

                for i := range data {

18✔

357

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

12✔

358

12✔

359

        case []float32:

12✔

360

                for i := range data {

42✔

361

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

30✔

362

30✔

363

        case [][2]float32:

6✔

364

                for i := range data {

18✔

365

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

12✔

366

12✔

367

        case [][3]float32:

12✔

368

                for i := range data {

54✔

369

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

42✔

370

42✔

371

        case [][4]float32:

6✔

372

                for i := range data {

18✔

373

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

12✔

374

12✔

375

        case [][2][2]float32:

6✔

376

                for i := range data {

18✔

377

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

12✔

378

12✔

379

        case [][3][3]float32:

6✔

380

                for i := range data {

18✔

381

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

12✔

382

12✔

383

        case [][4][4]float32:

6✔

384

                for i := range data {

18✔

385

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

12✔

386

12✔

387

        case []uint32:

12✔

388

                for i := range data {

42✔

389

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

30✔

390

30✔

391

        case [][2]uint32:

6✔

392

                for i := range data {

18✔

393

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

12✔

394

12✔

395

        case [][3]uint32:

6✔

396

                for i := range data {

18✔

397

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

12✔

398

12✔

399

        case [][4]uint32:

6✔

400

                for i := range data {

18✔

401

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

12✔

402

12✔

403

        case [][2][2]uint32:

6✔

404

                for i := range data {

18✔

405

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

12✔

406

12✔

407

        case [][3][3]uint32:

6✔

408

                for i := range data {

18✔

409

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

12✔

410

12✔

411

        case [][4][4]uint32:

6✔

412

                for i := range data {

18✔

413

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

12✔

414

12✔

416

        return nil

312✔

qmuntal / gltf / 26519180179

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

qmuntal / gltf / 26519180179

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