Ptex: PtexReader.h Source File

Ptex

PtexReader.h
Go to the documentation of this file.
1#ifndef PtexReader_h
2#define PtexReader_h
3
4/*
5PTEX SOFTWARE
6Copyright 2014 Disney Enterprises, Inc. All rights reserved
7
8Redistribution and use in source and binary forms, with or without
9modification, are permitted provided that the following conditions are
10met:
11
12 * Redistributions of source code must retain the above copyright
13 notice, this list of conditions and the following disclaimer.
14
15 * Redistributions in binary form must reproduce the above copyright
16 notice, this list of conditions and the following disclaimer in
17 the documentation and/or other materials provided with the
18 distribution.
19
20 * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation
21 Studios" or the names of its contributors may NOT be used to
22 endorse or promote products derived from this software without
23 specific prior written permission from Walt Disney Pictures.
24
25Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND
26CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
27BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
28FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED.
29IN NO EVENT SHALL WALT DISNEY PICTURES, THE COPYRIGHT HOLDER OR
30CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND BASED ON ANY
34THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
37*/
38#include <stdio.h>
39#include <zlib.h>
40#include <vector>
41#include <string>
42#include <map>
43#include <errno.h>
44#include "Ptexture.h"
45#include "PtexIO.h"
46#include "PtexUtils.h"
47
48#include "PtexHashMap.h"
49
50 PTEX_NAMESPACE_BEGIN
51
52 class PtexReader : public PtexTexture {
53public:
54 PtexReader(bool premultiply, PtexInputHandler* inputHandler, PtexErrorHandler* errorHandler);
55 virtual ~PtexReader();
56 virtual void release() { delete this; }
57 bool needToOpen() const { return _needToOpen; }
58 bool open(const char* path, Ptex::String& error);
59 void prune();
60 void purge();
61 void setPendingPurge() { _pendingPurge = true; }
62 bool pendingPurge() const { return _pendingPurge; }
63 bool tryClose();
64 bool ok() const { return _ok; }
65 bool isOpen() { return _fp; }
66 void invalidate() {
67 _ok = false;
68 _needToOpen = false;
69 }
70
71 void increaseMemUsed(size_t amount) { if (amount) AtomicAdd(&_memUsed, amount); }
72 void logOpen() { AtomicIncrement(&_opens); }
73 void logBlockRead() { AtomicIncrement(&_blockReads); }
74
75 virtual const char* path() { return _path.c_str(); }
76
77 virtual Info getInfo() {
78 Info info;
79 info.meshType = MeshType(_header.meshtype);
80 info.dataType = DataType(_header.datatype);
81 info.uBorderMode = BorderMode(_extheader.ubordermode);
82 info.vBorderMode = BorderMode(_extheader.vbordermode);
83 info.edgeFilterMode = EdgeFilterMode(_extheader.edgefiltermode);
84 info.alphaChannel = _header.alphachan;
85 info.numChannels = _header.nchannels;
86 info.numFaces = _header.nfaces;
87 return info;
88 }
89
90 virtual Ptex::MeshType meshType() { return MeshType(_header.meshtype); }
91 virtual Ptex::DataType dataType() { return DataType(_header.datatype); }
92 virtual Ptex::BorderMode uBorderMode() { return BorderMode(_extheader.ubordermode); }
93 virtual Ptex::BorderMode vBorderMode() { return BorderMode(_extheader.vbordermode); }
94 virtual Ptex::EdgeFilterMode edgeFilterMode() { return EdgeFilterMode(_extheader.edgefiltermode); }
95 virtual int alphaChannel() { return _header.alphachan; }
96 virtual int numChannels() { return _header.nchannels; }
97 virtual int numFaces() { return _header.nfaces; }
98 virtual bool hasEdits() { return _hasEdits; }
99 virtual bool hasMipMaps() { return _header.nlevels > 1; }
100
101 virtual PtexMetaData* getMetaData();
102 virtual const Ptex::FaceInfo& getFaceInfo(int faceid);
103 virtual void getData(int faceid, void* buffer, int stride);
104 virtual void getData(int faceid, void* buffer, int stride, Res res);
105 virtual PtexFaceData* getData(int faceid);
106 virtual PtexFaceData* getData(int faceid, Res res);
107 virtual void getPixel(int faceid, int u, int v,
108 float* result, int firstchan, int nchannels);
109 virtual void getPixel(int faceid, int u, int v,
110 float* result, int firstchan, int nchannels,
111 Ptex::Res res);
112
113 DataType datatype() const { return DataType(_header.datatype); }
114 int nchannels() const { return _header.nchannels; }
115 int pixelsize() const { return _pixelsize; }
116 const Header& header() const { return _header; }
117 const ExtHeader& extheader() const { return _extheader; }
118 const LevelInfo& levelinfo(int level) const { return _levelinfo[level]; }
119
120 class MetaData : public PtexMetaData {
121 public:
122 MetaData(PtexReader* reader)
123 : _reader(reader) {}
124 ~MetaData() {}
125 virtual void release() {}
126
127 virtual int numKeys() { return int(_entries.size()); }
128 virtual void getKey(int index, const char*& key, MetaDataType& type)
129 {
130 if (index < 0 || index >= int(_entries.size())) {
131 return;
132 }
133 Entry* e = _entries[index];
134 key = e->key;
135 type = e->type;
136 }
137
138 virtual bool findKey(const char* key, int& index, MetaDataType& type)
139 {
140 MetaMap::iterator iter = _map.find(key);
141 if (iter==_map.end()) {
142 index = -1;
143 return false;
144 }
145 index = iter->second.index;
146 type = iter->second.type;
147 return true;
148 }
149
150 virtual void getValue(const char* key, const char*& value)
151 {
152 int index = -1;
153 MetaDataType type;
154 if (!findKey(key, index, type)) {
155 value = 0;
156 return;
157 }
158 Entry* e = getEntry(index);
159 if (e && e->type == mdt_string) value = (const char*) e->data;
160 else value = 0;
161 }
162
163 virtual void getValue(int index, const char*& value)
164 {
165 if (index < 0 || index >= int(_entries.size())) { value = 0; return; }
166 Entry* e = getEntry(index);
167 if (e && e->type == mdt_string) value = (const char*) e->data;
168 else value = 0;
169 }
170
171 template<typename T>
172 void getValue(int index, MetaDataType requestedType, const T*& value, int& count)
173 {
174 if (index < 0 || index >= int(_entries.size())) {
175 value = 0;
176 count = 0;
177 return;
178 }
179 Entry* e = getEntry(index);
180 if (e && e->type == requestedType) {
181 value = (const T*) e->data;
182 count = int(e->datasize/sizeof(T));
183 }
184 else { value = 0; count = 0; }
185 }
186
187 template<typename T>
188 void getValue(const char* key, MetaDataType requestedType, const T*& value, int& count)
189 {
190 int index = -1;
191 MetaDataType type;
192 findKey(key, index, type);
193 getValue<T>(index, requestedType, value, count);
194 }
195
196 virtual void getValue(const char* key, const int8_t*& value, int& count)
197 {
198 getValue<int8_t>(key, mdt_int8, value, count);
199 }
200
201 virtual void getValue(int index, const int8_t*& value, int& count)
202 {
203 getValue<int8_t>(index, mdt_int8, value, count);
204 }
205
206 virtual void getValue(const char* key, const int16_t*& value, int& count)
207 {
208 getValue<int16_t>(key, mdt_int16, value, count);
209 }
210
211 virtual void getValue(int index, const int16_t*& value, int& count)
212 {
213 getValue<int16_t>(index, mdt_int16, value, count);
214 }
215
216 virtual void getValue(const char* key, const int32_t*& value, int& count)
217 {
218 getValue<int32_t>(key, mdt_int32, value, count);
219 }
220
221 virtual void getValue(int index, const int32_t*& value, int& count)
222 {
223 getValue<int32_t>(index, mdt_int32, value, count);
224 }
225
226 virtual void getValue(const char* key, const float*& value, int& count)
227 {
228 getValue<float>(key, mdt_float, value, count);
229 }
230
231 virtual void getValue(int index, const float*& value, int& count)
232 {
233 getValue<float>(index, mdt_float, value, count);
234 }
235
236 virtual void getValue(const char* key, const double*& value, int& count)
237 {
238 getValue<double>(key, mdt_double, value, count);
239 }
240
241 virtual void getValue(int index, const double*& value, int& count)
242 {
243 getValue<double>(index, mdt_double, value, count);
244 }
245
246 void addEntry(uint8_t keysize, const char* key, uint8_t datatype,
247 uint32_t datasize, const void* data, size_t& metaDataMemUsed)
248 {
249 Entry* e = newEntry(keysize, key, datatype, datasize, metaDataMemUsed);
250 e->data = new char[datasize];
251 memcpy(e->data, data, datasize);
252 metaDataMemUsed += datasize;
253 }
254
255 void addLmdEntry(uint8_t keysize, const char* key, uint8_t datatype,
256 uint32_t datasize, FilePos filepos, uint32_t zipsize,
257 size_t& metaDataMemUsed)
258 {
259 Entry* e = newEntry(keysize, key, datatype, datasize, metaDataMemUsed);
260 e->isLmd = true;
261 e->lmdData = 0;
262 e->lmdPos = filepos;
263 e->lmdZipSize = zipsize;
264 }
265
266 size_t selfDataSize()
267 {
268 return sizeof(*this) + sizeof(Entry*) * _entries.capacity();
269 }
270
271 protected:
272 class LargeMetaData
273 {
274 public:
275 LargeMetaData(int size)
276 : _data(new char [size]) {}
277 virtual ~LargeMetaData() { delete [] _data; }
278 void* data() { return _data; }
279 private:
280 LargeMetaData(const LargeMetaData&);
281 char* _data;
282 };
283
284 struct Entry {
285 const char* key; // ptr to map key string
286 MetaDataType type; // meta data type
287 uint32_t datasize; // size of data in bytes
288 char* data; // if lmd, data only valid when lmd is loaded and ref'ed
289 bool isLmd; // true if data is a large meta data block
290 LargeMetaData* lmdData; // large meta data (lazy-loaded)
291 FilePos lmdPos; // large meta data file position
292 uint32_t lmdZipSize; // large meta data size on disk
293 uint32_t index; // index in vector
294
295 Entry() :
296 key(0), type(MetaDataType(0)), datasize(0), data(0),
297 isLmd(0), lmdData(0), lmdPos(0), lmdZipSize(0) {}
298 ~Entry() { clear(); }
299 void clear() {
300 if (isLmd) {
301 isLmd = 0;
302 if (lmdData) { delete lmdData; lmdData = 0; }
303 lmdPos = 0;
304 lmdZipSize = 0;
305 }
306 else {
307 if (data) { delete [] data; }
308 }
309 data = 0;
310 }
311 };
312
313 Entry* newEntry(uint8_t keysize, const char* key, uint8_t datatype, uint32_t datasize, size_t& metaDataMemUsed)
314 {
315 std::pair<MetaMap::iterator,bool> result =
316 _map.insert(std::make_pair(std::string(key, keysize), Entry()));
317 Entry* e = &result.first->second;
318 bool newentry = result.second;
319 uint32_t index = 0;
320 if (newentry) {
321 index = uint32_t(_entries.size());
322 _entries.push_back(e);
323 }
324 else {
325 index = e->index;
326 e->clear();
327 }
328 e->key = result.first->first.c_str();
329 e->type = MetaDataType(datatype);
330 e->datasize = datasize;
331 e->index = index;
332 metaDataMemUsed += sizeof(std::string) + keysize + 1 + sizeof(Entry);
333 return e;
334 }
335
336 PTEXAPI Entry* getEntry(int index);
337
338 PtexReader* _reader;
339 typedef std::map<std::string, Entry> MetaMap;
340 MetaMap _map;
341 std::vector<Entry*> _entries;
342 };
343
344
345 class ConstDataPtr : public PtexFaceData {
346 public:
347 ConstDataPtr(void* data, int pixelsize)
348 : _data(data), _pixelsize(pixelsize) {}
349 virtual void release() { delete this; }
350 virtual Ptex::Res res() { return 0; }
351 virtual bool isConstant() { return true; }
352 virtual void getPixel(int, int, void* result)
353 { memcpy(result, _data, _pixelsize); }
354 virtual void* getData() { return _data; }
355 virtual bool isTiled() { return false; }
356 virtual Ptex::Res tileRes() { return 0; }
357 virtual PtexFaceData* getTile(int) { return 0; }
358
359 protected:
360 void* _data;
361 int _pixelsize;
362 };
363
364
365 class FaceData : public PtexFaceData {
366 public:
367 FaceData(Res resArg)
368 : _res(resArg) {}
369 virtual ~FaceData() {}
370 virtual void release() { }
371 virtual Ptex::Res res() { return _res; }
372 virtual FaceData* reduce(PtexReader*, Res newres, PtexUtils::ReduceFn, size_t& newMemUsed) = 0;
373 protected:
374 Res _res;
375 };
376
377 class PackedFace : public FaceData {
378 public:
379 PackedFace(Res resArg, int pixelsize, int size)
380 : FaceData(resArg),
381 _pixelsize(pixelsize), _data(new char [size]) {}
382 void* data() { return _data; }
383 virtual bool isConstant() { return false; }
384 virtual void getPixel(int u, int v, void* result)
385 {
386 memcpy(result, _data + (v*_res.u() + u) * _pixelsize, _pixelsize);
387 }
388 virtual void* getData() { return _data; }
389 virtual bool isTiled() { return false; }
390 virtual Ptex::Res tileRes() { return _res; }
391 virtual PtexFaceData* getTile(int) { return 0; }
392 virtual FaceData* reduce(PtexReader*, Res newres, PtexUtils::ReduceFn, size_t& newMemUsed);
393
394 protected:
395 virtual ~PackedFace() { delete [] _data; }
396
397 int _pixelsize;
398 char* _data;
399 };
400
401 class ConstantFace : public PackedFace {
402 public:
403 ConstantFace(int pixelsize)
404 : PackedFace(0, pixelsize, pixelsize) {}
405 virtual bool isConstant() { return true; }
406 virtual void getPixel(int, int, void* result) { memcpy(result, _data, _pixelsize); }
407 virtual FaceData* reduce(PtexReader*, Res newres, PtexUtils::ReduceFn, size_t& newMemUsed);
408 };
409
410 class ErrorFace : public ConstantFace {
411 bool _deleteOnRelease;
412 public:
413 ErrorFace(void* errorPixel, int pixelsize, bool deleteOnRelease)
414 : ConstantFace(pixelsize), _deleteOnRelease(deleteOnRelease)
415 {
416 memcpy(_data, errorPixel, pixelsize);
417 }
418 virtual void release() { if (_deleteOnRelease) delete this; }
419 };
420
421 class TiledFaceBase : public FaceData {
422 public:
423 TiledFaceBase(PtexReader* reader, Res resArg, Res tileresArg)
424 : FaceData(resArg),
425 _reader(reader),
426 _tileres(tileresArg)
427 {
428 _dt = reader->datatype();
429 _nchan = reader->nchannels();
430 _pixelsize = DataSize(_dt)*_nchan;
431 _ntilesu = _res.ntilesu(tileresArg);
432 _ntilesv = _res.ntilesv(tileresArg);
433 _ntiles = _ntilesu*_ntilesv;
434 _tiles.resize(_ntiles);
435 }
436
437 virtual void release() { }
438 virtual bool isConstant() { return false; }
439 virtual void getPixel(int u, int v, void* result);
440 virtual void* getData() { return 0; }
441 virtual bool isTiled() { return true; }
442 virtual Ptex::Res tileRes() { return _tileres; }
443 virtual FaceData* reduce(PtexReader*, Res newres, PtexUtils::ReduceFn, size_t& newMemUsed);
444 Res tileres() const { return _tileres; }
445 int ntilesu() const { return _ntilesu; }
446 int ntilesv() const { return _ntilesv; }
447 int ntiles() const { return _ntiles; }
448
449 protected:
450 size_t baseExtraMemUsed() { return _tiles.size() * sizeof(_tiles[0]); }
451
452 virtual ~TiledFaceBase() {
453 for (std::vector<FaceData*>::iterator i = _tiles.begin(); i != _tiles.end(); ++i) {
454 if (*i) delete *i;
455 }
456 }
457
458 PtexReader* _reader;
459 Res _tileres;
460 DataType _dt;
461 int _nchan;
462 int _ntilesu;
463 int _ntilesv;
464 int _ntiles;
465 int _pixelsize;
466 std::vector<FaceData*> _tiles;
467 };
468
469
470 class TiledFace : public TiledFaceBase {
471 public:
472 TiledFace(PtexReader* reader, Res resArg, Res tileresArg, int levelid)
473 : TiledFaceBase(reader, resArg, tileresArg),
474 _levelid(levelid)
475 {
476 _fdh.resize(_ntiles),
477 _offsets.resize(_ntiles);
478 }
479 virtual PtexFaceData* getTile(int tile)
480 {
481 FaceData*& f = _tiles[tile];
482 if (!f) readTile(tile, f);
483 return f;
484 }
485 void readTile(int tile, FaceData*& data);
486 size_t memUsed() {
487 return sizeof(*this) + baseExtraMemUsed() + _fdh.size() * (sizeof(_fdh[0]) + sizeof(_offsets[0]));
488 }
489
490 protected:
491 friend class PtexReader;
492 int _levelid;
493 std::vector<FaceDataHeader> _fdh;
494 std::vector<FilePos> _offsets;
495 };
496
497
498 class TiledReducedFace : public TiledFaceBase {
499 public:
500 TiledReducedFace(PtexReader* reader, Res resArg, Res tileresArg,
501 TiledFaceBase* parentface, PtexUtils::ReduceFn reducefn)
502 : TiledFaceBase(reader, resArg, tileresArg),
503 _parentface(parentface),
504 _reducefn(reducefn)
505 {
506 }
507 ~TiledReducedFace()
508 {
509 }
510 virtual PtexFaceData* getTile(int tile);
511
512 size_t memUsed() { return sizeof(*this) + baseExtraMemUsed(); }
513
514 protected:
515 TiledFaceBase* _parentface;
516 PtexUtils::ReduceFn* _reducefn;
517 };
518
519
520 class Level {
521 public:
522 std::vector<FaceDataHeader> fdh;
523 std::vector<FilePos> offsets;
524 std::vector<FaceData*> faces;
525
526 Level(int nfaces)
527 : fdh(nfaces),
528 offsets(nfaces),
529 faces(nfaces) {}
530
531 ~Level() {
532 for (std::vector<FaceData*>::iterator i = faces.begin(); i != faces.end(); ++i) {
533 if (*i) delete *i;
534 }
535 }
536
537 size_t memUsed() {
538 return sizeof(*this) + fdh.size() * (sizeof(fdh[0]) +
539 sizeof(offsets[0]) +
540 sizeof(faces[0]));
541 }
542 };
543
544
545protected:
546 void setError(const char* error)
547 {
548 std::string msg = error;
549 msg += " PtexFile: ";
550 msg += _path;
551 msg += "\n";
552 if (_err) _err->reportError(msg.c_str());
553 else std::cerr << msg;
554 _ok = 0;
555 }
556
557 FilePos tell() { return _pos; }
558 void seek(FilePos pos)
559 {
560 if (!_fp && !reopenFP()) return;
561 logBlockRead();
562 if (pos != _pos) {
563 _io->seek(_fp, pos);
564 _pos = pos;
565 }
566 }
567
568 void closeFP();
569 bool reopenFP();
570 bool readBlock(void* data, int size, bool reportError=true);
571 bool readZipBlock(void* data, int zipsize, int unzipsize);
572 Level* getLevel(int levelid)
573 {
574 Level*& level = _levels[levelid];
575 if (!level) readLevel(levelid, level);
576 return level;
577 }
578
579 uint8_t* getConstData() { return _constdata; }
580 FaceData* getFace(int levelid, Level* level, int faceid, Res res)
581 {
582 FaceData*& face = level->faces[faceid];
583 if (!face) readFace(levelid, level, faceid, res);
584 return face;
585 }
586
587 void readFaceInfo();
588 void readLevelInfo();
589 void readConstData();
590 void readLevel(int levelid, Level*& level);
591 void readFace(int levelid, Level* level, int faceid, Res res);
592 void readFaceData(FilePos pos, FaceDataHeader fdh, Res res, int levelid, FaceData*& face);
593 void readMetaData();
594 void readMetaDataBlock(MetaData* metadata, FilePos pos, int zipsize, int memsize, size_t& metaDataMemUsed);
595 void readLargeMetaDataHeaders(MetaData* metadata, FilePos pos, int zipsize, int memsize, size_t& metaDataMemUsed);
596 void readEditData();
597 void readEditFaceData();
598 void readEditMetaData();
599
600 FaceData* errorData(bool deleteOnRelease=false)
601 {
602 return new ErrorFace(&_errorPixel[0], _pixelsize, deleteOnRelease);
603 }
604
605 void computeOffsets(FilePos pos, int noffsets, const FaceDataHeader* fdh, FilePos* offsets)
606 {
607 FilePos* end = offsets + noffsets;
608 while (offsets != end) { *offsets++ = pos; pos += fdh->blocksize(); fdh++; }
609 }
610
611 class DefaultInputHandler : public PtexInputHandler
612 {
613 char* buffer;
614 public:
615 DefaultInputHandler() : buffer(0) {}
616 virtual Handle open(const char* path) {
617 FILE* fp = fopen(path, "rb");
618 if (fp) {
619 buffer = new char [IBuffSize];
620 setvbuf(fp, buffer, _IOFBF, IBuffSize);
621 }
622 else buffer = 0;
623 return (Handle) fp;
624 }
625 virtual void seek(Handle handle, int64_t pos) { fseeko((FILE*)handle, pos, SEEK_SET); }
626 virtual size_t read(void* bufferArg, size_t size, Handle handle) {
627 return fread(bufferArg, size, 1, (FILE*)handle) == 1 ? size : 0;
628 }
629 virtual bool close(Handle handle) {
630 bool ok = handle && (fclose((FILE*)handle) == 0);
631 if (buffer) { delete [] buffer; buffer = 0; }
632 return ok;
633 }
634 virtual const char* lastError() { return strerror(errno); }
635 };
636
637 Mutex readlock;
638 DefaultInputHandler _defaultIo; // Default IO handler
639 PtexInputHandler* _io; // IO handler
640 PtexErrorHandler* _err; // Error handler
641 bool _premultiply; // true if reader should premultiply the alpha chan
642 bool _ok; // flag set to false if open or read error occurred
643 bool _needToOpen; // true if file needs to be opened (or reopened after a purge)
644 bool _pendingPurge; // true if a purge attempt was made but file was busy
645 PtexInputHandler::Handle _fp; // file pointer
646 FilePos _pos; // current seek position
647 std::string _path; // current file path
648 Header _header; // the header
649 ExtHeader _extheader; // extended header
650 FilePos _faceinfopos; // file positions of data sections
651 FilePos _constdatapos; // ...
652 FilePos _levelinfopos;
653 FilePos _leveldatapos;
654 FilePos _metadatapos;
655 FilePos _lmdheaderpos;
656 FilePos _lmddatapos;
657 FilePos _editdatapos;
658 int _pixelsize; // size of a pixel in bytes
659 uint8_t* _constdata; // constant pixel value per face
660 MetaData* _metadata; // meta data (read on demand)
661 bool _hasEdits; // has edit blocks
662
663 std::vector<FaceInfo> _faceinfo; // per-face header info
664 std::vector<uint32_t> _rfaceids; // faceids sorted in reduction order
665 std::vector<LevelInfo> _levelinfo; // per-level header info
666 std::vector<FilePos> _levelpos; // file position of each level's data
667 std::vector<Level*> _levels; // level data (read on demand)
668
669 struct MetaEdit
670 {
671 FilePos pos;
672 int zipsize;
673 int memsize;
674 };
675 std::vector<MetaEdit> _metaedits;
676
677 struct FaceEdit
678 {
679 FilePos pos;
680 int faceid;
681 FaceDataHeader fdh;
682 };
683 std::vector<FaceEdit> _faceedits;
684
685 class ReductionKey {
686 int64_t _val;
687 public:
688 ReductionKey() : _val(-1) {}
689 ReductionKey(uint32_t faceid, Res res)
690 : _val( int64_t(faceid)<<32 | uint32_t(16777619*((res.val()<<16) ^ faceid)) ) {}
691
692 void copy(volatile ReductionKey& key) volatile
693 {
694 _val = key._val;
695 }
696
697 void move(volatile ReductionKey& key) volatile
698 {
699 _val = key._val;
700 }
701
702 bool matches(const ReductionKey& key) volatile
703 {
704 return _val == key._val;
705 }
706 bool isEmpty() volatile { return _val==-1; }
707 uint32_t hash() volatile
708 {
709 return uint32_t(_val);
710 }
711 };
712 typedef PtexHashMap<ReductionKey, FaceData*> ReductionMap;
713 ReductionMap _reductions;
714 std::vector<char> _errorPixel; // referenced by errorData()
715
716 z_stream_s _zstream;
717 size_t _baseMemUsed;
718 volatile size_t _memUsed;
719 volatile size_t _opens;
720 volatile size_t _blockReads;
721};
722
723 PTEX_NAMESPACE_END
724
725#endif
PTEXAPI
#define PTEXAPI
Definition: PtexExports.h:60
PtexHashMap.h
Contains PtexHashMap, a lightweight multi-threaded hash table.
PtexIO.h
IBuffSize
const int IBuffSize
Definition: PtexIO.h:113
FilePos
off_t FilePos
Definition: PtexPlatform.h:99
AtomicAdd
PTEX_INLINE T AtomicAdd(volatile T *target, T value)
Definition: PtexPlatform.h:209
AtomicIncrement
PTEX_INLINE T AtomicIncrement(volatile T *target)
Definition: PtexPlatform.h:225
PtexUtils.h
PTEX_NAMESPACE_END
#define PTEX_NAMESPACE_END
Definition: PtexVersion.h:62
Ptexture.h
Public API classes for reading, writing, caching, and filtering Ptex files.
Mutex
Definition: PtexPlatform.h:137
PtexErrorHandler
Custom handler interface redirecting Ptex error messages.
Definition: Ptexture.h:658
PtexErrorHandler::reportError
virtual void reportError(const char *error)=0
PtexFaceData
Per-face texture data accessor.
Definition: Ptexture.h:406
PtexHashMap
Definition: PtexHashMap.h:152
PtexInputHandler
Custom handler interface for intercepting and redirecting Ptex input stream calls.
Definition: Ptexture.h:619
PtexInputHandler::seek
virtual void seek(Handle handle, int64_t pos)=0
Seek to an absolute byte position in the input stream.
PtexInputHandler::Handle
void * Handle
Definition: Ptexture.h:624
PtexMetaData
Meta data accessor.
Definition: Ptexture.h:328
PtexReader::ConstDataPtr
Definition: PtexReader.h:345
PtexReader::ConstDataPtr::isConstant
virtual bool isConstant()
True if this data block is constant.
Definition: PtexReader.h:351
PtexReader::ConstDataPtr::_data
void * _data
Definition: PtexReader.h:360
PtexReader::ConstDataPtr::res
virtual Ptex::Res res()
Resolution of the texture held by this data block.
Definition: PtexReader.h:350
PtexReader::ConstDataPtr::release
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:349
PtexReader::ConstDataPtr::isTiled
virtual bool isTiled()
True if this data block is tiled.
Definition: PtexReader.h:355
PtexReader::ConstDataPtr::getData
virtual void * getData()
Access the data from this data block.
Definition: PtexReader.h:354
PtexReader::ConstDataPtr::getPixel
virtual void getPixel(int, int, void *result)
Read a single texel from the data block.
Definition: PtexReader.h:352
PtexReader::ConstDataPtr::_pixelsize
int _pixelsize
Definition: PtexReader.h:361
PtexReader::ConstDataPtr::tileRes
virtual Ptex::Res tileRes()
Resolution of each tile in this data block.
Definition: PtexReader.h:356
PtexReader::ConstDataPtr::getTile
virtual PtexFaceData * getTile(int)
Access a tile from the data block.
Definition: PtexReader.h:357
PtexReader::ConstDataPtr::ConstDataPtr
ConstDataPtr(void *data, int pixelsize)
Definition: PtexReader.h:347
PtexReader::ConstantFace
Definition: PtexReader.h:401
PtexReader::ConstantFace::getPixel
virtual void getPixel(int, int, void *result)
Read a single texel from the data block.
Definition: PtexReader.h:406
PtexReader::ConstantFace::ConstantFace
ConstantFace(int pixelsize)
Definition: PtexReader.h:403
PtexReader::ConstantFace::isConstant
virtual bool isConstant()
True if this data block is constant.
Definition: PtexReader.h:405
PtexReader::ConstantFace::reduce
virtual FaceData * reduce(PtexReader *, Res newres, PtexUtils::ReduceFn, size_t &newMemUsed)
Definition: PtexReader.cpp:966
PtexReader::DefaultInputHandler
Definition: PtexReader.h:612
PtexReader::DefaultInputHandler::buffer
char * buffer
Definition: PtexReader.h:613
PtexReader::DefaultInputHandler::seek
virtual void seek(Handle handle, int64_t pos)
Seek to an absolute byte position in the input stream.
Definition: PtexReader.h:625
PtexReader::DefaultInputHandler::DefaultInputHandler
DefaultInputHandler()
Definition: PtexReader.h:615
PtexReader::DefaultInputHandler::close
virtual bool close(Handle handle)
Close a file.
Definition: PtexReader.h:629
PtexReader::DefaultInputHandler::read
virtual size_t read(void *bufferArg, size_t size, Handle handle)
Read a number of bytes from the file.
Definition: PtexReader.h:626
PtexReader::DefaultInputHandler::open
virtual Handle open(const char *path)
Open a file in read mode.
Definition: PtexReader.h:616
PtexReader::DefaultInputHandler::lastError
virtual const char * lastError()
Return the last error message encountered.
Definition: PtexReader.h:634
PtexReader::ErrorFace
Definition: PtexReader.h:410
PtexReader::ErrorFace::_deleteOnRelease
bool _deleteOnRelease
Definition: PtexReader.h:411
PtexReader::ErrorFace::release
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:418
PtexReader::ErrorFace::ErrorFace
ErrorFace(void *errorPixel, int pixelsize, bool deleteOnRelease)
Definition: PtexReader.h:413
PtexReader::FaceData
Definition: PtexReader.h:365
PtexReader::FaceData::res
virtual Ptex::Res res()
Resolution of the texture held by this data block.
Definition: PtexReader.h:371
PtexReader::FaceData::reduce
virtual FaceData * reduce(PtexReader *, Res newres, PtexUtils::ReduceFn, size_t &newMemUsed)=0
PtexReader::FaceData::release
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:370
PtexReader::FaceData::~FaceData
virtual ~FaceData()
Definition: PtexReader.h:369
PtexReader::FaceData::_res
Res _res
Definition: PtexReader.h:374
PtexReader::FaceData::FaceData
FaceData(Res resArg)
Definition: PtexReader.h:367
PtexReader::Level
Definition: PtexReader.h:520
PtexReader::Level::Level
Level(int nfaces)
Definition: PtexReader.h:526
PtexReader::Level::offsets
std::vector< FilePos > offsets
Definition: PtexReader.h:523
PtexReader::Level::fdh
std::vector< FaceDataHeader > fdh
Definition: PtexReader.h:522
PtexReader::Level::faces
std::vector< FaceData * > faces
Definition: PtexReader.h:524
PtexReader::Level::memUsed
size_t memUsed()
Definition: PtexReader.h:537
PtexReader::Level::~Level
~Level()
Definition: PtexReader.h:531
PtexReader::MetaData::LargeMetaData
Definition: PtexReader.h:273
PtexReader::MetaData::LargeMetaData::data
void * data()
Definition: PtexReader.h:278
PtexReader::MetaData::LargeMetaData::LargeMetaData
LargeMetaData(int size)
Definition: PtexReader.h:275
PtexReader::MetaData::LargeMetaData::LargeMetaData
LargeMetaData(const LargeMetaData &)
PtexReader::MetaData::LargeMetaData::_data
char * _data
Definition: PtexReader.h:281
PtexReader::MetaData::LargeMetaData::~LargeMetaData
virtual ~LargeMetaData()
Definition: PtexReader.h:277
PtexReader::MetaData
Definition: PtexReader.h:120
PtexReader::MetaData::getValue
virtual void getValue(int index, const int8_t *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:201
PtexReader::MetaData::selfDataSize
size_t selfDataSize()
Definition: PtexReader.h:266
PtexReader::MetaData::release
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:125
PtexReader::MetaData::newEntry
Entry * newEntry(uint8_t keysize, const char *key, uint8_t datatype, uint32_t datasize, size_t &metaDataMemUsed)
Definition: PtexReader.h:313
PtexReader::MetaData::getKey
virtual void getKey(int index, const char *&key, MetaDataType &type)
Definition: PtexReader.h:128
PtexReader::MetaData::getValue
virtual void getValue(int index, const double *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:241
PtexReader::MetaData::getValue
virtual void getValue(const char *key, const int8_t *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:196
PtexReader::MetaData::getValue
virtual void getValue(int index, const char *&value)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:163
PtexReader::MetaData::~MetaData
~MetaData()
Definition: PtexReader.h:124
PtexReader::MetaData::addEntry
void addEntry(uint8_t keysize, const char *key, uint8_t datatype, uint32_t datasize, const void *data, size_t &metaDataMemUsed)
Definition: PtexReader.h:246
PtexReader::MetaData::getValue
virtual void getValue(int index, const float *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:231
PtexReader::MetaData::getValue
void getValue(const char *key, MetaDataType requestedType, const T *&value, int &count)
Definition: PtexReader.h:188
PtexReader::MetaData::findKey
virtual bool findKey(const char *key, int &index, MetaDataType &type)
Definition: PtexReader.h:138
PtexReader::MetaData::getValue
virtual void getValue(int index, const int16_t *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:211
PtexReader::MetaData::MetaData
MetaData(PtexReader *reader)
Definition: PtexReader.h:122
PtexReader::MetaData::getValue
virtual void getValue(const char *key, const int32_t *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:216
PtexReader::MetaData::numKeys
virtual int numKeys()
Query number of meta data entries stored in file.
Definition: PtexReader.h:127
PtexReader::MetaData::getValue
virtual void getValue(int index, const int32_t *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:221
PtexReader::MetaData::getValue
virtual void getValue(const char *key, const double *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:236
PtexReader::MetaData::_reader
PtexReader * _reader
Definition: PtexReader.h:338
PtexReader::MetaData::_map
MetaMap _map
Definition: PtexReader.h:340
PtexReader::MetaData::getValue
virtual void getValue(const char *key, const char *&value)
Query the value of a given meta data entry.
Definition: PtexReader.h:150
PtexReader::MetaData::MetaMap
std::map< std::string, Entry > MetaMap
Definition: PtexReader.h:339
PtexReader::MetaData::getValue
virtual void getValue(const char *key, const float *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:226
PtexReader::MetaData::addLmdEntry
void addLmdEntry(uint8_t keysize, const char *key, uint8_t datatype, uint32_t datasize, FilePos filepos, uint32_t zipsize, size_t &metaDataMemUsed)
Definition: PtexReader.h:255
PtexReader::MetaData::getValue
void getValue(int index, MetaDataType requestedType, const T *&value, int &count)
Definition: PtexReader.h:172
PtexReader::MetaData::getEntry
Entry * getEntry(int index)
Definition: PtexReader.cpp:343
PtexReader::MetaData::_entries
std::vector< Entry * > _entries
Definition: PtexReader.h:341
PtexReader::MetaData::getValue
virtual void getValue(const char *key, const int16_t *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:206
PtexReader::PackedFace
Definition: PtexReader.h:377
PtexReader::PackedFace::~PackedFace
virtual ~PackedFace()
Definition: PtexReader.h:395
PtexReader::PackedFace::data
void * data()
Definition: PtexReader.h:382
PtexReader::PackedFace::getTile
virtual PtexFaceData * getTile(int)
Access a tile from the data block.
Definition: PtexReader.h:391
PtexReader::PackedFace::PackedFace
PackedFace(Res resArg, int pixelsize, int size)
Definition: PtexReader.h:379
PtexReader::PackedFace::isTiled
virtual bool isTiled()
True if this data block is tiled.
Definition: PtexReader.h:389
PtexReader::PackedFace::_pixelsize
int _pixelsize
Definition: PtexReader.h:397
PtexReader::PackedFace::tileRes
virtual Ptex::Res tileRes()
Resolution of each tile in this data block.
Definition: PtexReader.h:390
PtexReader::PackedFace::_data
char * _data
Definition: PtexReader.h:398
PtexReader::PackedFace::reduce
virtual FaceData * reduce(PtexReader *, Res newres, PtexUtils::ReduceFn, size_t &newMemUsed)
Definition: PtexReader.cpp:949
PtexReader::PackedFace::isConstant
virtual bool isConstant()
True if this data block is constant.
Definition: PtexReader.h:383
PtexReader::PackedFace::getPixel
virtual void getPixel(int u, int v, void *result)
Read a single texel from the data block.
Definition: PtexReader.h:384
PtexReader::PackedFace::getData
virtual void * getData()
Access the data from this data block.
Definition: PtexReader.h:388
PtexReader::ReductionKey
Definition: PtexReader.h:685
PtexReader::ReductionKey::_val
int64_t _val
Definition: PtexReader.h:686
PtexReader::ReductionKey::isEmpty
bool isEmpty() volatile
Definition: PtexReader.h:706
PtexReader::ReductionKey::ReductionKey
ReductionKey(uint32_t faceid, Res res)
Definition: PtexReader.h:689
PtexReader::ReductionKey::move
void move(volatile ReductionKey &key) volatile
Definition: PtexReader.h:697
PtexReader::ReductionKey::ReductionKey
ReductionKey()
Definition: PtexReader.h:688
PtexReader::ReductionKey::hash
uint32_t hash() volatile
Definition: PtexReader.h:707
PtexReader::ReductionKey::matches
bool matches(const ReductionKey &key) volatile
Definition: PtexReader.h:702
PtexReader::ReductionKey::copy
void copy(volatile ReductionKey &key) volatile
Definition: PtexReader.h:692
PtexReader::TiledFaceBase
Definition: PtexReader.h:421
PtexReader::TiledFaceBase::TiledFaceBase
TiledFaceBase(PtexReader *reader, Res resArg, Res tileresArg)
Definition: PtexReader.h:423
PtexReader::TiledFaceBase::baseExtraMemUsed
size_t baseExtraMemUsed()
Definition: PtexReader.h:450
PtexReader::TiledFaceBase::_tiles
std::vector< FaceData * > _tiles
Definition: PtexReader.h:466
PtexReader::TiledFaceBase::isTiled
virtual bool isTiled()
True if this data block is tiled.
Definition: PtexReader.h:441
PtexReader::TiledFaceBase::reduce
virtual FaceData * reduce(PtexReader *, Res newres, PtexUtils::ReduceFn, size_t &newMemUsed)
Definition: PtexReader.cpp:979
PtexReader::TiledFaceBase::tileres
Res tileres() const
Definition: PtexReader.h:444
PtexReader::TiledFaceBase::ntilesu
int ntilesu() const
Definition: PtexReader.h:445
PtexReader::TiledFaceBase::_dt
DataType _dt
Definition: PtexReader.h:460
PtexReader::TiledFaceBase::getData
virtual void * getData()
Access the data from this data block.
Definition: PtexReader.h:440
PtexReader::TiledFaceBase::_ntilesv
int _ntilesv
Definition: PtexReader.h:463
PtexReader::TiledFaceBase::_ntilesu
int _ntilesu
Definition: PtexReader.h:462
PtexReader::TiledFaceBase::_nchan
int _nchan
Definition: PtexReader.h:461
PtexReader::TiledFaceBase::ntilesv
int ntilesv() const
Definition: PtexReader.h:446
PtexReader::TiledFaceBase::_ntiles
int _ntiles
Definition: PtexReader.h:464
PtexReader::TiledFaceBase::release
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:437
PtexReader::TiledFaceBase::_tileres
Res _tileres
Definition: PtexReader.h:459
PtexReader::TiledFaceBase::tileRes
virtual Ptex::Res tileRes()
Resolution of each tile in this data block.
Definition: PtexReader.h:442
PtexReader::TiledFaceBase::ntiles
int ntiles() const
Definition: PtexReader.h:447
PtexReader::TiledFaceBase::_pixelsize
int _pixelsize
Definition: PtexReader.h:465
PtexReader::TiledFaceBase::isConstant
virtual bool isConstant()
True if this data block is constant.
Definition: PtexReader.h:438
PtexReader::TiledFaceBase::_reader
PtexReader * _reader
Definition: PtexReader.h:458
PtexReader::TiledFaceBase::getPixel
virtual void getPixel(int u, int v, void *result)
Read a single texel from the data block.
Definition: PtexReader.cpp:1104
PtexReader::TiledFaceBase::~TiledFaceBase
virtual ~TiledFaceBase()
Definition: PtexReader.h:452
PtexReader::TiledFace
Definition: PtexReader.h:470
PtexReader::TiledFace::_fdh
std::vector< FaceDataHeader > _fdh
Definition: PtexReader.h:493
PtexReader::TiledFace::TiledFace
TiledFace(PtexReader *reader, Res resArg, Res tileresArg, int levelid)
Definition: PtexReader.h:472
PtexReader::TiledFace::_levelid
int _levelid
Definition: PtexReader.h:492
PtexReader::TiledFace::memUsed
size_t memUsed()
Definition: PtexReader.h:486
PtexReader::TiledFace::getTile
virtual PtexFaceData * getTile(int tile)
Access a tile from the data block.
Definition: PtexReader.h:479
PtexReader::TiledFace::readTile
void readTile(int tile, FaceData *&data)
Definition: PtexReader.cpp:635
PtexReader::TiledFace::_offsets
std::vector< FilePos > _offsets
Definition: PtexReader.h:494
PtexReader::TiledReducedFace
Definition: PtexReader.h:498
PtexReader::TiledReducedFace::_parentface
TiledFaceBase * _parentface
Definition: PtexReader.h:515
PtexReader::TiledReducedFace::getTile
virtual PtexFaceData * getTile(int tile)
Access a tile from the data block.
Definition: PtexReader.cpp:1115
PtexReader::TiledReducedFace::~TiledReducedFace
~TiledReducedFace()
Definition: PtexReader.h:507
PtexReader::TiledReducedFace::_reducefn
PtexUtils::ReduceFn * _reducefn
Definition: PtexReader.h:516
PtexReader::TiledReducedFace::memUsed
size_t memUsed()
Definition: PtexReader.h:512
PtexReader::TiledReducedFace::TiledReducedFace
TiledReducedFace(PtexReader *reader, Res resArg, Res tileresArg, TiledFaceBase *parentface, PtexUtils::ReduceFn reducefn)
Definition: PtexReader.h:500
PtexReader
Definition: PtexReader.h:52
PtexReader::readLevelInfo
void readLevelInfo()
Definition: PtexReader.cpp:298
PtexReader::_reductions
ReductionMap _reductions
Definition: PtexReader.h:713
PtexReader::reopenFP
bool reopenFP()
Definition: PtexReader.cpp:240
PtexReader::ok
bool ok() const
Definition: PtexReader.h:64
PtexReader::datatype
DataType datatype() const
Definition: PtexReader.h:113
PtexReader::readEditFaceData
void readEditFaceData()
Definition: PtexReader.cpp:502
PtexReader::_premultiply
bool _premultiply
Definition: PtexReader.h:641
PtexReader::_constdatapos
FilePos _constdatapos
Definition: PtexReader.h:651
PtexReader::readMetaDataBlock
void readMetaDataBlock(MetaData *metadata, FilePos pos, int zipsize, int memsize, size_t &metaDataMemUsed)
Definition: PtexReader.cpp:414
PtexReader::extheader
const ExtHeader & extheader() const
Definition: PtexReader.h:117
PtexReader::numFaces
virtual int numFaces()
Number of faces stored in file.
Definition: PtexReader.h:97
PtexReader::setPendingPurge
void setPendingPurge()
Definition: PtexReader.h:61
PtexReader::readFaceInfo
void readFaceInfo()
Definition: PtexReader.cpp:277
PtexReader::vBorderMode
virtual Ptex::BorderMode vBorderMode()
Mode for filtering texture access beyond mesh border.
Definition: PtexReader.h:93
PtexReader::_path
std::string _path
Definition: PtexReader.h:647
PtexReader::_constdata
uint8_t * _constdata
Definition: PtexReader.h:659
PtexReader::_levelpos
std::vector< FilePos > _levelpos
Definition: PtexReader.h:666
PtexReader::readEditData
void readEditData()
Definition: PtexReader.cpp:468
PtexReader::getPixel
virtual void getPixel(int faceid, int u, int v, float *result, int firstchan, int nchannels)
Access a single texel from the highest resolution texture .
Definition: PtexReader.cpp:893
PtexReader::getInfo
virtual Info getInfo()
Definition: PtexReader.h:77
PtexReader::_faceedits
std::vector< FaceEdit > _faceedits
Definition: PtexReader.h:683
PtexReader::_opens
volatile size_t _opens
Definition: PtexReader.h:719
PtexReader::isOpen
bool isOpen()
Definition: PtexReader.h:65
PtexReader::release
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:56
PtexReader::increaseMemUsed
void increaseMemUsed(size_t amount)
Definition: PtexReader.h:71
PtexReader::path
virtual const char * path()
Path that file was opened with.
Definition: PtexReader.h:75
PtexReader::getFace
FaceData * getFace(int levelid, Level *level, int faceid, Res res)
Definition: PtexReader.h:580
PtexReader::purge
void purge()
Definition: PtexReader.cpp:115
PtexReader::_editdatapos
FilePos _editdatapos
Definition: PtexReader.h:657
PtexReader::tell
FilePos tell()
Definition: PtexReader.h:557
PtexReader::getLevel
Level * getLevel(int levelid)
Definition: PtexReader.h:572
PtexReader::errorData
FaceData * errorData(bool deleteOnRelease=false)
Definition: PtexReader.h:600
PtexReader::~PtexReader
virtual ~PtexReader()
Definition: PtexReader.cpp:93
PtexReader::_hasEdits
bool _hasEdits
Definition: PtexReader.h:661
PtexReader::_needToOpen
bool _needToOpen
Definition: PtexReader.h:643
PtexReader::uBorderMode
virtual Ptex::BorderMode uBorderMode()
Mode for filtering texture access beyond mesh border.
Definition: PtexReader.h:92
PtexReader::computeOffsets
void computeOffsets(FilePos pos, int noffsets, const FaceDataHeader *fdh, FilePos *offsets)
Definition: PtexReader.h:605
PtexReader::readConstData
void readConstData()
Definition: PtexReader.cpp:319
PtexReader::getMetaData
virtual PtexMetaData * getMetaData()
Access meta data.
Definition: PtexReader.cpp:335
PtexReader::needToOpen
bool needToOpen() const
Definition: PtexReader.h:57
PtexReader::alphaChannel
virtual int alphaChannel()
Index of alpha channel (if any).
Definition: PtexReader.h:95
PtexReader::_extheader
ExtHeader _extheader
Definition: PtexReader.h:649
PtexReader::_leveldatapos
FilePos _leveldatapos
Definition: PtexReader.h:653
PtexReader::getData
virtual void getData(int faceid, void *buffer, int stride)
Access texture data for a face at highest-resolution.
Definition: PtexReader.cpp:711
PtexReader::_err
PtexErrorHandler * _err
Definition: PtexReader.h:640
PtexReader::header
const Header & header() const
Definition: PtexReader.h:116
PtexReader::readEditMetaData
void readEditMetaData()
Definition: PtexReader.cpp:533
PtexReader::_faceinfopos
FilePos _faceinfopos
Definition: PtexReader.h:650
PtexReader::_levelinfo
std::vector< LevelInfo > _levelinfo
Definition: PtexReader.h:665
PtexReader::ReductionMap
PtexHashMap< ReductionKey, FaceData * > ReductionMap
Definition: PtexReader.h:712
PtexReader::hasMipMaps
virtual bool hasMipMaps()
True if the file has mipmaps.
Definition: PtexReader.h:99
PtexReader::_zstream
z_stream_s _zstream
Definition: PtexReader.h:716
PtexReader::_io
PtexInputHandler * _io
Definition: PtexReader.h:639
PtexReader::getFaceInfo
virtual const Ptex::FaceInfo & getFaceInfo(int faceid)
Access resolution and adjacency information about a face.
Definition: PtexReader.cpp:267
PtexReader::_metadatapos
FilePos _metadatapos
Definition: PtexReader.h:654
PtexReader::readLargeMetaDataHeaders
void readLargeMetaDataHeaders(MetaData *metadata, FilePos pos, int zipsize, int memsize, size_t &metaDataMemUsed)
Definition: PtexReader.cpp:440
PtexReader::closeFP
void closeFP()
Definition: PtexReader.cpp:230
PtexReader::_pixelsize
int _pixelsize
Definition: PtexReader.h:658
PtexReader::_pendingPurge
bool _pendingPurge
Definition: PtexReader.h:644
PtexReader::pendingPurge
bool pendingPurge() const
Definition: PtexReader.h:62
PtexReader::readlock
Mutex readlock
Definition: PtexReader.h:637
PtexReader::readFace
void readFace(int levelid, Level *level, int faceid, Res res)
Definition: PtexReader.cpp:627
PtexReader::_levelinfopos
FilePos _levelinfopos
Definition: PtexReader.h:652
PtexReader::_lmdheaderpos
FilePos _lmdheaderpos
Definition: PtexReader.h:655
PtexReader::hasEdits
virtual bool hasEdits()
True if the file has edit blocks.
Definition: PtexReader.h:98
PtexReader::nchannels
int nchannels() const
Definition: PtexReader.h:114
PtexReader::_lmddatapos
FilePos _lmddatapos
Definition: PtexReader.h:656
PtexReader::prune
void prune()
Definition: PtexReader.cpp:104
PtexReader::_rfaceids
std::vector< uint32_t > _rfaceids
Definition: PtexReader.h:664
PtexReader::_metaedits
std::vector< MetaEdit > _metaedits
Definition: PtexReader.h:675
PtexReader::_memUsed
volatile size_t _memUsed
Definition: PtexReader.h:718
PtexReader::_defaultIo
DefaultInputHandler _defaultIo
Definition: PtexReader.h:638
PtexReader::_blockReads
volatile size_t _blockReads
Definition: PtexReader.h:720
PtexReader::_header
Header _header
Definition: PtexReader.h:648
PtexReader::readFaceData
void readFaceData(FilePos pos, FaceDataHeader fdh, Res res, int levelid, FaceData *&face)
Definition: PtexReader.cpp:641
PtexReader::seek
void seek(FilePos pos)
Definition: PtexReader.h:558
PtexReader::readBlock
bool readBlock(void *data, int size, bool reportError=true)
Definition: PtexReader.cpp:548
PtexReader::_metadata
MetaData * _metadata
Definition: PtexReader.h:660
PtexReader::_levels
std::vector< Level * > _levels
Definition: PtexReader.h:667
PtexReader::_baseMemUsed
size_t _baseMemUsed
Definition: PtexReader.h:717
PtexReader::_faceinfo
std::vector< FaceInfo > _faceinfo
Definition: PtexReader.h:663
PtexReader::invalidate
void invalidate()
Definition: PtexReader.h:66
PtexReader::meshType
virtual Ptex::MeshType meshType()
Type of mesh for which texture data is defined.
Definition: PtexReader.h:90
PtexReader::edgeFilterMode
virtual Ptex::EdgeFilterMode edgeFilterMode()
Mode for filtering textures across edges.
Definition: PtexReader.h:94
PtexReader::pixelsize
int pixelsize() const
Definition: PtexReader.h:115
PtexReader::_fp
PtexInputHandler::Handle _fp
Definition: PtexReader.h:645
PtexReader::readZipBlock
bool readZipBlock(void *data, int zipsize, int unzipsize)
Definition: PtexReader.cpp:563
PtexReader::readMetaData
void readMetaData()
Definition: PtexReader.cpp:381
PtexReader::logBlockRead
void logBlockRead()
Definition: PtexReader.h:73
PtexReader::logOpen
void logOpen()
Definition: PtexReader.h:72
PtexReader::readLevel
void readLevel(int levelid, Level *&level)
Definition: PtexReader.cpp:595
PtexReader::dataType
virtual Ptex::DataType dataType()
Type of data stored in file.
Definition: PtexReader.h:91
PtexReader::_errorPixel
std::vector< char > _errorPixel
Definition: PtexReader.h:714
PtexReader::getConstData
uint8_t * getConstData()
Definition: PtexReader.h:579
PtexReader::numChannels
virtual int numChannels()
Number of channels stored in file.
Definition: PtexReader.h:96
PtexReader::_pos
FilePos _pos
Definition: PtexReader.h:646
PtexReader::open
bool open(const char *path, Ptex::String &error)
Definition: PtexReader.cpp:137
PtexReader::levelinfo
const LevelInfo & levelinfo(int level) const
Definition: PtexReader.h:118
PtexReader::tryClose
bool tryClose()
Definition: PtexReader.cpp:219
PtexReader::setError
void setError(const char *error)
Definition: PtexReader.h:546
PtexReader::_ok
bool _ok
Definition: PtexReader.h:642
PtexTexture
Interface for reading data from a ptex file.
Definition: Ptexture.h:457
Ptex::String
Memory-managed string.
Definition: Ptexture.h:296
PTEX_NAMESPACE_BEGIN
Definition: PtexSeparableKernel.cpp:42
PtexUtils::ReduceFn
void ReduceFn(const void *src, int sstride, int ures, int vres, void *dst, int dstride, DataType dt, int nchannels)
Definition: PtexUtils.h:185
Ptex::DataType
DataType
Type of data stored in texture file.
Definition: Ptexture.h:72
Ptex::MeshType
MeshType
Type of base mesh for which the textures are defined.
Definition: Ptexture.h:66
Ptex::BorderMode
BorderMode
How to handle mesh border when filtering.
Definition: Ptexture.h:86
Ptex::EdgeFilterMode
EdgeFilterMode
How to handle transformation across edges when filtering.
Definition: Ptexture.h:80
ExtHeader
Definition: PtexIO.h:64
ExtHeader::edgefiltermode
uint16_t edgefiltermode
Definition: PtexIO.h:68
ExtHeader::vbordermode
uint16_t vbordermode
Definition: PtexIO.h:67
ExtHeader::ubordermode
uint16_t ubordermode
Definition: PtexIO.h:65
FaceDataHeader
Definition: PtexIO.h:82
FaceDataHeader::blocksize
uint32_t blocksize() const
Definition: PtexIO.h:84
Header
Definition: PtexIO.h:44
Header::nlevels
uint16_t nlevels
Definition: PtexIO.h:51
Header::nchannels
uint16_t nchannels
Definition: PtexIO.h:50
Header::meshtype
uint32_t meshtype
Definition: PtexIO.h:47
Header::datatype
uint32_t datatype
Definition: PtexIO.h:48
Header::alphachan
int32_t alphachan
Definition: PtexIO.h:49
Header::nfaces
uint32_t nfaces
Definition: PtexIO.h:52
LevelInfo
Definition: PtexIO.h:75
PtexReader::FaceEdit
Definition: PtexReader.h:678
PtexReader::FaceEdit::pos
FilePos pos
Definition: PtexReader.h:679
PtexReader::FaceEdit::faceid
int faceid
Definition: PtexReader.h:680
PtexReader::FaceEdit::fdh
FaceDataHeader fdh
Definition: PtexReader.h:681
PtexReader::MetaData::Entry
Definition: PtexReader.h:284
PtexReader::MetaData::Entry::key
const char * key
Definition: PtexReader.h:285
PtexReader::MetaData::Entry::type
MetaDataType type
Definition: PtexReader.h:286
PtexReader::MetaData::Entry::lmdPos
FilePos lmdPos
Definition: PtexReader.h:291
PtexReader::MetaData::Entry::clear
void clear()
Definition: PtexReader.h:299
PtexReader::MetaData::Entry::~Entry
~Entry()
Definition: PtexReader.h:298
PtexReader::MetaData::Entry::lmdZipSize
uint32_t lmdZipSize
Definition: PtexReader.h:292
PtexReader::MetaData::Entry::isLmd
bool isLmd
Definition: PtexReader.h:289
PtexReader::MetaData::Entry::Entry
Entry()
Definition: PtexReader.h:295
PtexReader::MetaData::Entry::datasize
uint32_t datasize
Definition: PtexReader.h:287
PtexReader::MetaData::Entry::lmdData
LargeMetaData * lmdData
Definition: PtexReader.h:290
PtexReader::MetaData::Entry::index
uint32_t index
Definition: PtexReader.h:293
PtexReader::MetaData::Entry::data
char * data
Definition: PtexReader.h:288
PtexReader::MetaEdit
Definition: PtexReader.h:670
PtexReader::MetaEdit::zipsize
int zipsize
Definition: PtexReader.h:672
PtexReader::MetaEdit::memsize
int memsize
Definition: PtexReader.h:673
PtexReader::MetaEdit::pos
FilePos pos
Definition: PtexReader.h:671
PtexTexture::Info
Get most commonly used info in a single call for convenience / efficiency.
Definition: Ptexture.h:486
PtexTexture::Info::numChannels
int numChannels
Definition: Ptexture.h:493
PtexTexture::Info::uBorderMode
BorderMode uBorderMode
Definition: Ptexture.h:489
PtexTexture::Info::vBorderMode
BorderMode vBorderMode
Definition: Ptexture.h:490
PtexTexture::Info::edgeFilterMode
EdgeFilterMode edgeFilterMode
Definition: Ptexture.h:491
PtexTexture::Info::alphaChannel
int alphaChannel
Definition: Ptexture.h:492
PtexTexture::Info::dataType
DataType dataType
Definition: Ptexture.h:488
PtexTexture::Info::numFaces
int numFaces
Definition: Ptexture.h:494
PtexTexture::Info::meshType
MeshType meshType
Definition: Ptexture.h:487
Ptex::FaceInfo
Information about a face, as stored in the Ptex file header.
Definition: Ptexture.h:229
Ptex::Res
Pixel resolution of a given texture.
Definition: Ptexture.h:159