00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 INLINE const Filename Shader::
00022 get_filename(const ShaderType &type) const {
00023 if (_filename->_separate) {
00024 nassertr(type != ST_none || !_filename->_shared.empty(), "");
00025 switch (type) {
00026 case ST_vertex:
00027 return _filename->_vertex;
00028 break;
00029 case ST_fragment:
00030 return _filename->_fragment;
00031 break;
00032 case ST_geometry:
00033 return _filename->_geometry;
00034 break;
00035 default:
00036 return _filename->_shared;
00037 }
00038 } else {
00039 return _filename->_shared;
00040 }
00041 }
00042
00043
00044
00045
00046
00047
00048 INLINE const string &Shader::
00049 get_text(const ShaderType &type) const {
00050 if (_text->_separate) {
00051 nassertr(type != ST_none || !_text->_shared.empty(), _text->_shared);
00052 switch (type) {
00053 case ST_vertex:
00054 return _text->_vertex;
00055 break;
00056 case ST_fragment:
00057 return _text->_fragment;
00058 break;
00059 case ST_geometry:
00060 return _text->_geometry;
00061 break;
00062 default:
00063 return _text->_shared;
00064 }
00065 } else {
00066 return _text->_shared;
00067 }
00068 }
00069
00070
00071
00072
00073
00074
00075
00076
00077 INLINE const bool Shader::
00078 get_error_flag() const {
00079 return _error_flag;
00080 }
00081
00082
00083
00084
00085
00086
00087
00088
00089 INLINE void Shader::
00090 set_shader_utilization(ShaderUtilization sut) {
00091 _shader_utilization = sut;
00092 }
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103 INLINE ShaderUtilization Shader::
00104 get_shader_utilization() {
00105 if (_shader_utilization == SUT_unspecified) {
00106 return shader_utilization;
00107 } else {
00108 return _shader_utilization;
00109 }
00110 }
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120 INLINE bool Shader::
00121 have_shader_utilization() {
00122 return (_shader_utilization != SUT_unspecified);
00123 }
00124
00125
00126
00127
00128
00129
00130
00131 INLINE const Shader::ShaderLanguage Shader::
00132 get_language() const {
00133 return _language;
00134 }
00135
00136
00137
00138
00139
00140
00141 INLINE Shader::ShaderCaps::
00142 ShaderCaps() {
00143 clear();
00144 }
00145
00146
00147
00148
00149
00150
00151 INLINE bool Shader::ShaderCaps::
00152 operator == (const ShaderCaps &other) const {
00153 #ifdef HAVE_CG
00154 if ((_active_vprofile != other._active_vprofile) ||
00155 (_active_fprofile != other._active_fprofile) ||
00156 (_active_gprofile != other._active_gprofile) ||
00157 (_ultimate_vprofile != other._ultimate_vprofile) ||
00158 (_ultimate_fprofile != other._ultimate_fprofile) ||
00159 (_ultimate_gprofile != other._ultimate_gprofile)) {
00160 return false;
00161 }
00162 #endif
00163 return true;
00164 }
00165
00166
00167
00168
00169
00170
00171 INLINE Shader::ShaderPtrData::
00172 ShaderPtrData() :
00173 _ptr(NULL),
00174 _type(SPT_unknown),
00175 _updated(true),
00176 _size(0)
00177 {
00178 }
00179
00180
00181
00182
00183
00184
00185 INLINE Shader::ShaderPtrData::
00186 ShaderPtrData(const PTA_float &ptr):
00187 _pta(ptr.v0()),
00188 _ptr(ptr.p()),
00189 _type(SPT_float),
00190 _updated(true),
00191 _size(ptr.size())
00192 {
00193 }
00194
00195
00196
00197
00198
00199
00200 INLINE Shader::ShaderPtrData::
00201 ShaderPtrData(const PTA_LMatrix4f &ptr):
00202 _pta(ptr.v0()),
00203 _ptr(ptr.p()),
00204 _type(SPT_float),
00205 _updated(true),
00206 _size(ptr.size() * 16)
00207 {
00208 }
00209
00210
00211
00212
00213
00214
00215 INLINE Shader::ShaderPtrData::
00216 ShaderPtrData(const PTA_LMatrix3f &ptr):
00217 _pta(ptr.v0()),
00218 _ptr(ptr.p()),
00219 _type(SPT_float),
00220 _updated(true),
00221 _size(ptr.size() * 9)
00222 {
00223 }
00224
00225
00226
00227
00228
00229
00230 INLINE Shader::ShaderPtrData::
00231 ShaderPtrData(const PTA_LVecBase4f &ptr):
00232 _pta(ptr.v0()),
00233 _ptr(ptr.p()),
00234 _type(SPT_float),
00235 _updated(true),
00236 _size(ptr.size() * 4)
00237 {
00238 }
00239
00240
00241
00242
00243
00244
00245 INLINE Shader::ShaderPtrData::
00246 ShaderPtrData(const PTA_LVecBase3f &ptr):
00247 _pta(ptr.v0()),
00248 _ptr(ptr.p()),
00249 _type(SPT_float),
00250 _updated(true),
00251 _size(ptr.size() * 3)
00252 {
00253 }
00254
00255
00256
00257
00258
00259
00260 INLINE Shader::ShaderPtrData::
00261 ShaderPtrData(const PTA_LVecBase2f &ptr):
00262 _pta(ptr.v0()),
00263 _ptr(ptr.p()),
00264 _type(SPT_float),
00265 _updated(true),
00266 _size(ptr.size() * 2)
00267 {
00268 }
00269
00270
00271
00272
00273
00274
00275 INLINE Shader::ShaderPtrData::
00276 ShaderPtrData(const LVecBase4f &vec) :
00277 _type(SPT_float),
00278 _updated(true),
00279 _size(4)
00280 {
00281 PTA_float pta = PTA_float::empty_array(4);
00282 _pta = pta.v0();
00283 _ptr = pta.p();
00284 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
00285 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
00286 }
00287
00288
00289
00290
00291
00292
00293 INLINE Shader::ShaderPtrData::
00294 ShaderPtrData(const LVecBase3f &vec) :
00295 _type(SPT_float),
00296 _updated(true),
00297 _size(3)
00298 {
00299 PTA_float pta = PTA_float::empty_array(3);
00300 _pta = pta.v0();
00301 _ptr = pta.p();
00302 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
00303 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
00304 }
00305
00306
00307
00308
00309
00310
00311 INLINE Shader::ShaderPtrData::
00312 ShaderPtrData(const LVecBase2f &vec) :
00313 _type(SPT_float),
00314 _updated(true),
00315 _size(2)
00316 {
00317 PTA_float pta = PTA_float::empty_array(2);
00318 _pta = pta.v0();
00319 _ptr = pta.p();
00320 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
00321 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
00322 }
00323
00324
00325
00326
00327
00328
00329 INLINE Shader::ShaderPtrData::
00330 ShaderPtrData(const LMatrix4f &mat) :
00331 _type(SPT_float),
00332 _updated(true),
00333 _size(16)
00334 {
00335 PTA_float pta = PTA_float::empty_array(16);
00336 _pta = pta.v0();
00337 _ptr = pta.p();
00338 nassertv(sizeof(mat(0, 0)) * mat.get_num_components() == pta.size() * sizeof(pta[0]));
00339 memcpy(_ptr, mat.get_data(), sizeof(mat(0, 0)) * mat.get_num_components());
00340 }
00341
00342
00343
00344
00345
00346
00347 INLINE Shader::ShaderPtrData::
00348 ShaderPtrData(const LMatrix3f &mat) :
00349 _type(SPT_float),
00350 _updated(true),
00351 _size(9)
00352 {
00353 PTA_float pta = PTA_float::empty_array(9);
00354 _pta = pta.v0();
00355 _ptr = pta.p();
00356 nassertv(sizeof(mat(0, 0)) * mat.get_num_components() == pta.size() * sizeof(pta[0]));
00357 memcpy(_ptr, mat.get_data(), sizeof(mat(0, 0)) * mat.get_num_components());
00358 }
00359
00360
00361
00362
00363
00364
00365 INLINE Shader::ShaderPtrData::
00366 ShaderPtrData(const PTA_double &ptr):
00367 _pta(ptr.v0()),
00368 _ptr(ptr.p()),
00369 _type(SPT_double),
00370 _updated(true),
00371 _size(ptr.size())
00372 {
00373 }
00374
00375
00376
00377
00378
00379
00380 INLINE Shader::ShaderPtrData::
00381 ShaderPtrData(const PTA_LMatrix4d &ptr):
00382 _pta(ptr.v0()),
00383 _ptr(ptr.p()),
00384 _type(SPT_double),
00385 _updated(true),
00386 _size(ptr.size() * 16)
00387 {
00388 }
00389
00390
00391
00392
00393
00394
00395 INLINE Shader::ShaderPtrData::
00396 ShaderPtrData(const PTA_LMatrix3d &ptr):
00397 _pta(ptr.v0()),
00398 _ptr(ptr.p()),
00399 _type(SPT_double),
00400 _updated(true),
00401 _size(ptr.size() * 9)
00402 {
00403 }
00404
00405
00406
00407
00408
00409
00410 INLINE Shader::ShaderPtrData::
00411 ShaderPtrData(const PTA_LVecBase4d &ptr):
00412 _pta(ptr.v0()),
00413 _ptr(ptr.p()),
00414 _type(SPT_double),
00415 _updated(true),
00416 _size(ptr.size() * 4)
00417 {
00418 }
00419
00420
00421
00422
00423
00424
00425 INLINE Shader::ShaderPtrData::
00426 ShaderPtrData(const PTA_LVecBase3d &ptr):
00427 _pta(ptr.v0()),
00428 _ptr(ptr.p()),
00429 _type(SPT_double),
00430 _updated(true),
00431 _size(ptr.size() * 3)
00432 {
00433 }
00434
00435
00436
00437
00438
00439
00440 INLINE Shader::ShaderPtrData::
00441 ShaderPtrData(const PTA_LVecBase2d &ptr):
00442 _pta(ptr.v0()),
00443 _ptr(ptr.p()),
00444 _type(SPT_double),
00445 _updated(true),
00446 _size(ptr.size() * 2)
00447 {
00448 }
00449
00450
00451
00452
00453
00454
00455 INLINE Shader::ShaderPtrData::
00456 ShaderPtrData(const LVecBase4d &vec) :
00457 _type(SPT_double),
00458 _updated(true),
00459 _size(4)
00460 {
00461 PTA_double pta = PTA_double::empty_array(4);
00462 _pta = pta.v0();
00463 _ptr = pta.p();
00464 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
00465 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
00466 }
00467
00468
00469
00470
00471
00472
00473 INLINE Shader::ShaderPtrData::
00474 ShaderPtrData(const LVecBase3d &vec) :
00475 _type(SPT_double),
00476 _updated(true),
00477 _size(3)
00478 {
00479 PTA_double pta = PTA_double::empty_array(3);
00480 _pta = pta.v0();
00481 _ptr = pta.p();
00482 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
00483 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
00484 }
00485
00486
00487
00488
00489
00490
00491 INLINE Shader::ShaderPtrData::
00492 ShaderPtrData(const LVecBase2d &vec) :
00493 _type(SPT_double),
00494 _updated(true),
00495 _size(2)
00496 {
00497 PTA_double pta = PTA_double::empty_array(2);
00498 _pta = pta.v0();
00499 _ptr = pta.p();
00500 nassertv(sizeof(vec[0]) * vec.get_num_components() == pta.size() * sizeof(pta[0]));
00501 memcpy(_ptr, vec.get_data(), sizeof(vec[0]) * vec.get_num_components());
00502 }
00503
00504
00505
00506
00507
00508
00509 INLINE Shader::ShaderPtrData::
00510 ShaderPtrData(const LMatrix4d &mat) :
00511 _type(SPT_double),
00512 _updated(true),
00513 _size(16)
00514 {
00515 PTA_double pta = PTA_double::empty_array(16);
00516 _pta = pta.v0();
00517 _ptr = pta.p();
00518 nassertv(sizeof(mat(0, 0)) * mat.get_num_components() == pta.size() * sizeof(pta[0]));
00519 memcpy(_ptr, mat.get_data(), sizeof(mat(0, 0)) * mat.get_num_components());
00520 }
00521
00522
00523
00524
00525
00526
00527 INLINE Shader::ShaderPtrData::
00528 ShaderPtrData(const LMatrix3d &mat) :
00529 _type(SPT_double),
00530 _updated(true),
00531 _size(9)
00532 {
00533 PTA_double pta = PTA_double::empty_array(9);
00534 _pta = pta.v0();
00535 _ptr = pta.p();
00536 nassertv(sizeof(mat(0, 0)) * mat.get_num_components() == pta.size() * sizeof(pta[0]));
00537 memcpy(_ptr, mat.get_data(), sizeof(mat(0, 0)) * mat.get_num_components());
00538 }