~thumper/glint/simple-app : revision 46

53

54

void

55

UniformVariableImpl::

56

check(const char* verb) const

56

check() const

57

{

58

GLenum err = clear_gl_error();

59

if (err != GL_NO_ERROR)

60

{

61

ostringstream msg;

62

msg << "cannot " << verb << " uniform variable \"" << name() << "\" at location " << to_string(location())

62

msg << "cannot set uniform variable \"" << name() << "\" at location " << to_string(location())

63

<< "; size = " << to_string(size()) << ", program id = " << to_string(program_id());

64

if (ProgramImpl::current_id() != program_id())

65

{

74

75

void

76

UniformVariableImpl::

77

check_get() const

78

{

79

check("get");

80

}

81

82

void

83

UniformVariableImpl::

84

check_set() const

85

{

86

check("set");

87

}

88

89

void

90

UniformVariableImpl::

91

77

check_size(size_t vector_size) const

92

78

{

93

79

if (vector_size != static_cast<size_t>(size()))

117

103

{

118

104

}

119

105

106

// No calls to check_gl() in any of the getters because these can fail only if the program_id or location are

107

// invalid, which is impossible.

108

120

109

GLint

121

110

IntUniformVariableBaseImpl::

122

111

get() const

123

112

{

124

113

GLint v;

125

114

glGetUniformiv(program_id(), location(), &v);

126

check_get();

127

115

return v;

128

116

}

129

117

132

120

set(GLint v)

133

121

{

134

122

glUniform1i(location(), v);

135

check_set();

123

check();

136

124

}

137

125

138

126

// IntArrayUniformVariableBase

158

146

{

159

147

glGetUniformiv(program_id(), location() + i, &v[i]);

160

148

}

161

check_get();

162

149

return v;

163

150

}

164

151

168

155

{

169

156

check_size(v.size());

170

157

glUniform1iv(location(), size(), &v[0]);

171

check_set();

158

check();

172

159

}

173

160

174

161

// Float

190

177

{

191

178

GLfloat v;

192

179

glGetUniformfv(program_id(), location(), &v);

193

check_get();

194

180

return v;

195

181

}

196

182

199

185

set(GLfloat v)

200

186

{

201

187

glUniform1f(location(), v);

202

check_set();

188

check();

203

189

}

204

190

205

191

// FloatVec2

221

207

{

222

208

FloatVec2 v;

223

209

glGetUniformfv(program_id(), location(), &v[0]);

224

check_get();

225

210

return v;

226

211

}

227

212

230

215

set(const FloatVec2& v)

231

216

{

232

217

glUniform2fv(location(), size(), &v[0]);

233

check_set();

218

check();

234

219

}

235

220

236

221

// FloatVec3

252

237

{

253

238

FloatVec3 v;

254

239

glGetUniformfv(program_id(), location(), &v[0]);

255

check_get();

256

240

return v;

257

241

}

258

242

261

245

set(const FloatVec3& v)

262

246

{

263

247

glUniform3fv(location(), size(), &v[0]);

264

check_set();

248

check();

265

249

}

266

250

267

251

// FloatVec4

283

267

{

284

268

FloatVec4 v;

285

269

glGetUniformfv(program_id(), location(), &v[0]);

286

check_get();

287

270

return v;

288

271

}

289

272

292

275

set(const FloatVec4& v)

293

276

{

294

277

glUniform4fv(location(), size(), &v[0]);

295

check_set();

278

check();

296

279

}

297

280

298

281

// FloatMat2

314

297

{

315

298

FloatMat2 v;

316

299

glGetUniformfv(program_id(), location(), &v[0][0]);

317

check_get();

318

300

return v;

319

301

}

320

302

323

305

set(const FloatMat2& v)

324

306

{

325

307

glUniformMatrix2fv(location(), size(), GL_FALSE, &v[0][0]);

326

check_set();

308

check();

327

309

}

328

310

329

311

// FloatMat3

345

327

{

346

328

FloatMat3 v;

347

329

glGetUniformfv(program_id(), location(), &v[0][0]);

348

check_get();

349

330

return v;

350

331

}

351

332

354

335

set(const FloatMat3& v)

355

336

{

356

337

glUniformMatrix3fv(location(), size(), GL_FALSE, &v[0][0]);

357

check_set();

338

check();

358

339

}

359

340

360

341

// FloatMat4

376

357

{

377

358

FloatMat4 v;

378

359

glGetUniformfv(program_id(), location(), &v[0][0]);

379

check_get();

380

360

return v;

381

361

}

382

362

385

365

set(const FloatMat4& v)

386

366

{

387

367

glUniformMatrix4fv(location(), size(), GL_FALSE, &v[0][0]);

388

check_set();

368

check();

389

369

}

390

370

391

371

// FloatArray

411

391

{

412

392

glGetUniformfv(program_id(), location() + i, &v[i]);

413

393

}

414

check_get();

415

394

return v;

416

395

}

417

396

421

400

{

422

401

check_size(v.size());

423

402

glUniform1fv(location(), size(), &v[0]);

424

check_set();

403

check();

425

404

}

426

405

427

406

// FloatVec2Array

447

426

{

448

427

glGetUniformfv(program_id(), location() + i, &v[i][0]);

449

428

}

450

check_get();

451

429

return v;

452

430

}

453

431

457

435

{

458

436

check_size(v.size());

459

437

glUniform2fv(location(), size(), &v[0][0]);

460

check_set();

438

check();

461

439

}

462

440

463

441

// FloatVec3Array

483

461

{

484

462

glGetUniformfv(program_id(), location() + i, &v[i][0]);

485

463

}

486

check_get();

487

464

return v;

488

465

}

489

466

493

470

{

494

471

check_size(v.size());

495

472

glUniform3fv(location(), size(), &v[0][0]);

496

check_set();

473

check();

497

474

}

498

475

499

476

// FloatVec4Array

519

496

{

520

497

glGetUniformfv(program_id(), location() + i, &v[i][0]);

521

498

}

522

check_get();

523

499

return v;

524

500

}

525

501

529

505

{

530

506

check_size(v.size());

531

507

glUniform4fv(location(), size(), &v[0][0]);

532

check_set();

508

check();

533

509

}

534

510

535

511

// FloatMat2Array

555

531

{

556

532

glGetUniformfv(program_id(), location() + i, &v[i][0][0]);

557

533

}

558

check_get();

559

534

return v;

560

535

}

561

536

565

540

{

566

541

check_size(v.size());

567

542

glUniformMatrix2fv(location(), size(), GL_FALSE, &v[0][0][0]);

568

check_set();

543

check();

569

544

}

570

545

571

546

// FloatMat3Array

591

566

{

592

567

glGetUniformfv(program_id(), location() + i, &v[i][0][0]);

593

568

}

594

check_get();

595

569

return v;

596

570

}

597

571

601

575

{

602

576

check_size(v.size());

603

577

glUniformMatrix3fv(location(), size(), GL_FALSE, &v[0][0][0]);

604

check_set();

578

check();

605

579

}

606

580

607

581

// FloatMat4Array

627

601

{

628

602

glGetUniformfv(program_id(), location() + i, &v[i][0][0]);

629

603

}

630

check_get();

631

604

return v;

632

605

}

633

606

637

610

{

638

611

check_size(v.size());

639

612

glUniformMatrix4fv(location(), size(), GL_FALSE, &v[0][0][0]);

640

check_set();

613

check();

641

614

}

642

615

643

616

// Int

672

645

{

673

646

IntVec2 v;

674

647

glGetUniformiv(program_id(), location(), &v[0]);

675

check_get();

676

648

return v;

677

649

}

678

650

681

653

set(const IntVec2& v)

682

654

{

683

655

glUniform2iv(location(), size(), &v[0]);

684

check_set();

656

check();

685

657

}

686

658

687

659

// IntVec3

703

675

{

704

676

IntVec3 v;

705

677

glGetUniformiv(program_id(), location(), &v[0]);

706

check_get();

707

678

return v;

708

679

}

709

680

712

683

set(const IntVec3& v)

713

684

{

714

685

glUniform3iv(location(), size(), &v[0]);

715

check_set();

686

check();

716

687

}

717

688

718

689

// IntVec4

734

705

{

735

706

IntVec4 v;

736

707

glGetUniformiv(program_id(), location(), &v[0]);

737

check_get();

738

708

return v;

739

709

}

740

710

743

713

set(const IntVec4& v)

744

714

{

745

715

glUniform4iv(location(), size(), &v[0]);

746

check_set();

716

check();

747

717

}

748

718

749

719

// IntArray

782

752

{

783

753

glGetUniformiv(program_id(), location() + i, &v[i][0]);

784

754

}

785

check_get();

786

755

return v;

787

756

}

788

757

792

761

{

793

762

check_size(v.size());

794

763

glUniform2iv(location(), size(), &v[0][0]);

795

check_set();

764

check();

796

765

}

797

766

798

767

// IntVec3Array

818

787

{

819

788

glGetUniformiv(program_id(), location() + i, &v[i][0]);

820

789

}

821

check_get();

822

790

return v;

823

791

}

824

792

828

796

{

829

797

check_size(v.size());

830

798

glUniform3iv(location(), size(), &v[0][0]);

831

check_set();

799

check();

832

800

}

833

801

834

802

// IntVec4Array

854

822

{

855

823

glGetUniformiv(program_id(), location() + i, &v[i][0]);

856

824

}

857

check_get();

858

825

return v;

859

826

}

860

827

864

831

{

865

832

check_size(v.size());

866

833

glUniform4iv(location(), size(), &v[0][0]);

867

check_set();

834

check();

868

835

}

869

836

870

837

// Bool

889

856

{

890

857

GLint v;

891

858

glGetUniformiv(program_id(), location(), &v);

892

check_get();

893

859

return v;

894

860

}

895

861

898

864

set(GLboolean v)

899

865

{

900

866

glUniform1i(location(), v);

901

check_set();

867

check();

902

868

}

903

869

904

870

// BoolVec2

920

886

{

921

887

IntVec2 i;

922

888

glGetUniformiv(program_id(), location(), &i[0]);

923

check_get();

924

889

BoolVec2 v;

925

890

v[0] = i[0];

926

891

v[1] = i[1];

935

900

i[0] = v[0];

936

901

i[1] = v[1];

937

902

glUniform2iv(location(), size(), &i[0]);

938

check_set();

903

check();

939

904

}

940

905

941

906

// BoolVec3

957

922

{

958

923

IntVec3 i;

959

924

glGetUniformiv(program_id(), location(), &i[0]);

960

check_get();

961

925

BoolVec3 v;

962

926

v[0] = i[0];

963

927

v[1] = i[1];

974

938

i[1] = v[1];

975

939

i[2] = v[2];

976

940

glUniform3iv(location(), size(), &i[0]);

977

check_set();

941

check();

978

942

}

979

943

980

944

// BoolVec4

996

960

{

997

961

IntVec4 i;

998

962

glGetUniformiv(program_id(), location(), &i[0]);

999

check_get();

1000

963

BoolVec4 v;

1001

964

v[0] = i[0];

1002

965

v[1] = i[1];

1015

978

i[2] = v[2];

1016

979

i[3] = v[3];

1017

980

glUniform4iv(location(), size(), &i[0]);

1018

check_set();

981

check();

1019

982

}

1020

983

1021

984

// BoolArray

1044

1007

glGetUniformiv(program_id(), location() + i, &a[i]);

1045

1008

v[i] = a[i];

1046

1009

}

1047

check_get();

1048

1010

return v;

1049

1011

}

1050

1012

1060

1022

a[i] = v[i];

1061

1023

}

1062

1024

glUniform1iv(location(), size(), &a[0]);

1063

check_set();

1025

check();

1064

1026

}

1065

1027

1066

1028

// BoolVec2Array

1086

1048

{

1087

1049

glGetUniformiv(program_id(), location() + i, &a[i][0]);

1088

1050

}

1089

check_get();

1090

1051

BoolVec2Array v;

1091

1052

v.resize(size());

1092

1053

for (int i = 0; i < size(); ++i)

1110

1071

a[i][1] = v[i][1];

1111

1072

}

1112

1073

glUniform2iv(location(), size(), &a[0][0]);

1113

check_set();

1074

check();

1114

1075

}

1115

1076

1116

1077

// BoolVec3Array

1136

1097

{

1137

1098

glGetUniformiv(program_id(), location() + i, &a[i][0]);

1138

1099

}

1139

check_get();

1140

1100

BoolVec3Array v;

1141

1101

v.resize(size());

1142

1102

for (int i = 0; i < size(); ++i)

1162

1122

a[i][2] = v[i][2];

1163

1123

}

1164

1124

glUniform3iv(location(), size(), &a[0][0]);

1165

check_set();

1125

check();

1166

1126

}

1167

1127

1168

1128

// BoolVec4Array

1188

1148

{

1189

1149

glGetUniformiv(program_id(), location() + i, &a[i][0]);

1190

1150

}

1191

check_get();

1192

1151

BoolVec4Array v;

1193

1152

v.resize(size());

1194

1153

for (int i = 0; i < size(); ++i)

1216

1175

a[i][3] = v[i][3];

1217

1176

}

1218

1177

glUniform4iv(location(), size(), &a[0][0]);

1219

check_set();

1178

check();

1220

1179

}

1221

1180

1222

1181

// Sampler2D