History

Basic rendering working again.

Andrzej Kapolka committed 12 years ago

Commit 4f5448f1 parent 57ca6062 files · +145 −325Browse files

Showing the changes to interface/src/MetavoxelSystem.cpp (1 of 2 files). Show all

Unified · Split

interface/src/MetavoxelSystem.cpp+134−310
@@ -31,20 +31,9 @@ REGISTER_META_OBJECT(StaticModelRenderer) · 30 unmodified lines
3131
3232 static int bufferPointVectorMetaTypeId = qRegisterMetaType<BufferPointVector>();
3333
34−ProgramObject MetavoxelSystem::_program;
35−int MetavoxelSystem::_pointScaleLocation;
36−
3734 void MetavoxelSystem::init() {
3835 MetavoxelClientManager::init();
39−
40− if (!_program.isLinked()) {
41− _program.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() + "shaders/metavoxel_point.vert");
42− _program.link();
43−
44− _program.bind();
45− _pointScaleLocation = _program.uniformLocation("pointScale");
46− _program.release();
47− }
36+ PointMetavoxelRendererImplementation::init();
4837 _pointBufferAttribute = AttributeRegistry::getInstance()->registerAttribute(new PointBufferAttribute());
4938 }
5039
@@ -91,35 +80,6 @@ void MetavoxelSystem::simulate(float deltaTime) { · 40 unmodified lines
9180 guide(spannerSimulateVisitor);
9281 }
9382
94−class PointBufferRenderVisitor : public MetavoxelVisitor {
95−public:
96−
97− PointBufferRenderVisitor();
98−
99− virtual int visit(MetavoxelInfo& info);
100−
101−private:
102−
103− int _order;
104−};
105−
106−PointBufferRenderVisitor::PointBufferRenderVisitor() :
107− MetavoxelVisitor(QVector<AttributePointer>() << Application::getInstance()->getMetavoxels()->getPointBufferAttribute(),
108− QVector<AttributePointer>(), Application::getInstance()->getMetavoxels()->getLOD()),
109− _order(encodeOrder(Application::getInstance()->getViewFrustum()->getDirection())) {
110−}
111−
112−int PointBufferRenderVisitor::visit(MetavoxelInfo& info) {
113− PointBufferPointer buffer = info.inputValues.at(0).getInlineValue<PointBufferPointer>();
114− if (buffer) {
115− buffer->render(1000);
116− }
117− if (info.isLeaf) {
118− return STOP_RECURSION;
119− }
120− return _order;
121−}
122−
12383 class SpannerRenderVisitor : public SpannerVisitor {
12484 public:
12585
@@ -165,64 +125,11 @@ int RenderVisitor::visit(MetavoxelInfo& info) { · 39 unmodified lines
165125 void MetavoxelSystem::render() {
166126 RenderVisitor renderVisitor(getLOD());
167127 guideToAugmented(renderVisitor);
168−
169− int viewport[4];
170− glGetIntegerv(GL_VIEWPORT, viewport);
171− const int VIEWPORT_WIDTH_INDEX = 2;
172− const int VIEWPORT_HEIGHT_INDEX = 3;
173− float viewportWidth = viewport[VIEWPORT_WIDTH_INDEX];
174− float viewportHeight = viewport[VIEWPORT_HEIGHT_INDEX];
175− float viewportDiagonal = sqrtf(viewportWidth*viewportWidth + viewportHeight*viewportHeight);
176− float worldDiagonal = glm::distance(Application::getInstance()->getViewFrustum()->getNearBottomLeft(),
177− Application::getInstance()->getViewFrustum()->getNearTopRight());
178−
179− _program.bind();
180− _program.setUniformValue(_pointScaleLocation, viewportDiagonal *
181− Application::getInstance()->getViewFrustum()->getNearClip() / worldDiagonal);
182−
183− glEnableClientState(GL_VERTEX_ARRAY);
184− glEnableClientState(GL_COLOR_ARRAY);
185− glEnableClientState(GL_NORMAL_ARRAY);
186−
187− glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
188−
189− glDisable(GL_BLEND);
190−
191− //PointBufferRenderVisitor pointBufferRenderVisitor;
192− //guide(pointBufferRenderVisitor);
193−
194− foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
195− if (node->getType() == NodeType::MetavoxelServer) {
196− QMutexLocker locker(&node->getMutex());
197− MetavoxelSystemClient* client = static_cast<MetavoxelSystemClient*>(node->getLinkedData());
198− if (client) {
199− client->render();
200− }
201− }
202− }
203−
204− glEnable(GL_BLEND);
205−
206− glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
207−
208− glDisableClientState(GL_VERTEX_ARRAY);
209− glDisableClientState(GL_COLOR_ARRAY);
210− glDisableClientState(GL_NORMAL_ARRAY);
211−
212− _program.release();
213128
214129 SpannerRenderVisitor spannerRenderVisitor;
215130 guide(spannerRenderVisitor);
216131 }
217132
218−void MetavoxelSystem::setClientPoints(const SharedNodePointer& node, const BufferPointVector& points) {
219− QMutexLocker locker(&node->getMutex());
220− MetavoxelSystemClient* client = static_cast<MetavoxelSystemClient*>(node->getLinkedData());
221− if (client) {
222− client->setPoints(points);
223− }
224−}
225−
226133 MetavoxelClient* MetavoxelSystem::createClient(const SharedNodePointer& node) {
227134 return new MetavoxelSystemClient(node, _updater);
228135 }
@@ -240,35 +147,7 @@ void MetavoxelSystem::guideToAugmented(MetavoxelVisitor& visitor) { · 11 unmodified lines
240147 }
241148
242149 MetavoxelSystemClient::MetavoxelSystemClient(const SharedNodePointer& node, MetavoxelUpdater* updater) :
243− MetavoxelClient(node, updater),
244− _pointCount(0) {
245−
246− _buffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
247− _buffer.create();
248−}
249−
250−void MetavoxelSystemClient::render() {
251− _buffer.bind();
252−
253− BufferPoint* point = 0;
254− glVertexPointer(4, GL_FLOAT, sizeof(BufferPoint), &point->vertex);
255− glColorPointer(3, GL_UNSIGNED_BYTE, sizeof(BufferPoint), &point->color);
256− glNormalPointer(GL_BYTE, sizeof(BufferPoint), &point->normal);
257−
258− glDrawArrays(GL_POINTS, 0, _pointCount);
259−
260− _buffer.release();
261−}
262−
263−void MetavoxelSystemClient::setPoints(const BufferPointVector& points) {
264− qint64 now = QDateTime::currentMSecsSinceEpoch();
265− _buffer.bind();
266− _buffer.allocate(points.constData(), points.size() * sizeof(BufferPoint));
267− _buffer.release();
268− _pointCount = points.size();
269− qDebug() << "upload" << (QDateTime::currentMSecsSinceEpoch() - now);
270− qDebug() << _pointCount;
271−
150+ MetavoxelClient(node, updater) {
272151 }
273152
274153 void MetavoxelSystemClient::setAugmentedData(const MetavoxelData& data) {
@@ -288,166 +167,6 @@ int MetavoxelSystemClient::parseData(const QByteArray& packet) { · 13 unmodified lines
288167 return packet.size();
289168 }
290169
291−class BufferBuilder : public MetavoxelVisitor {
292−public:
293−
294− BufferBuilder(const MetavoxelLOD& lod);
295−
296− virtual int visit(MetavoxelInfo& info);
297− virtual bool postVisit(MetavoxelInfo& info);
298−
299−private:
300−
301− QVector<BufferPointVectorPair> _depthPoints;
302−};
303−
304−BufferBuilder::BufferBuilder(const MetavoxelLOD& lod) :
305− MetavoxelVisitor(QVector<AttributePointer>() << AttributeRegistry::getInstance()->getColorAttribute() <<
306− AttributeRegistry::getInstance()->getNormalAttribute() <<
307− Application::getInstance()->getMetavoxels()->getPointBufferAttribute(), QVector<AttributePointer>() <<
308− Application::getInstance()->getMetavoxels()->getPointBufferAttribute(), lod) {
309−}
310−
311−const int ALPHA_RENDER_THRESHOLD = 0;
312−
313−const int BUFFER_LEVELS = 5;
314−const int LAST_BUFFER_LEVEL = BUFFER_LEVELS - 1;
315−
316−int BufferBuilder::visit(MetavoxelInfo& info) {
317− if (info.inputValues.at(2).getInlineValue<PointBufferPointer>()) {
318− info.outputValues[0] = AttributeValue(_outputs.at(0));
319− }
320− if (_depth >= _depthPoints.size()) {
321− _depthPoints.resize(_depth + 1);
322− }
323− QRgb color = info.inputValues.at(0).getInlineValue<QRgb>();
324− quint8 alpha = qAlpha(color);
325− if (alpha <= ALPHA_RENDER_THRESHOLD) {
326− return info.isLeaf ? STOP_RECURSION : DEFAULT_ORDER;
327− }
328− QRgb normal = info.inputValues.at(1).getInlineValue<QRgb>();
329− BufferPoint point = { glm::vec4(info.minimum + glm::vec3(info.size, info.size, info.size) * 0.5f, info.size),
330− { quint8(qRed(color)), quint8(qGreen(color)), quint8(qBlue(color)) },
331− { quint8(qRed(normal)), quint8(qGreen(normal)), quint8(qBlue(normal)) } };
332− if (info.isLeaf) {
333− _depthPoints[_depth].first.append(point);
334− return STOP_RECURSION;
335− }
336− _depthPoints[_depth].second.append(point);
337− return DEFAULT_ORDER | ((_depth % BUFFER_LEVELS) == LAST_BUFFER_LEVEL ? 0 : ALL_NODES);
338−}
339−
340−bool BufferBuilder::postVisit(MetavoxelInfo& info) {
341− if (_depth % BUFFER_LEVELS != 0) {
342− return false;
343− }
344− QVector<int> offsets;
345− offsets.append(0);
346− int leafCount = 0;
347− int totalPoints = 0;
348− int lastDepth = qMin(_depth + BUFFER_LEVELS, _depthPoints.size());
349− for (int i = _depth; i < lastDepth; i++) {
350− const BufferPointVectorPair& pair = _depthPoints.at(i);
351− offsets.append(totalPoints += ((leafCount += pair.first.size()) + pair.second.size()));
352− }
353− QOpenGLBuffer buffer;
354− buffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
355− buffer.create();
356− buffer.bind();
357− buffer.allocate(totalPoints * sizeof(BufferPoint));
358− int offset = 0;
359− for (int i = _depth; i < lastDepth; i++) {
360− // write the internal nodes from the current level
361− BufferPointVector& internal = _depthPoints[i].second;
362− int length = internal.size() * sizeof(BufferPoint);
363− buffer.write(offset, internal.constData(), length);
364− offset += length;
365− internal.clear();
366−
367− // and the leaves from the top down
368− for (int j = _depth; j <= i; j++) {
369− const BufferPointVector& leaves = _depthPoints.at(j).first;
370− length = leaves.size() * sizeof(BufferPoint);
371− buffer.write(offset, leaves.constData(), length);
372− offset += length;
373− }
374− }
375− // clear the leaves now that we're done with them
376− for (int i = _depth; i < lastDepth; i++) {
377− _depthPoints[i].first.clear();
378− }
379− buffer.release();
380− info.outputValues[0] = AttributeValue(_outputs.at(0), encodeInline(PointBufferPointer(
381− new PointBuffer(buffer, offsets, leafCount))));
382− return true;
383−}
384−
385−class PointCollector : public MetavoxelVisitor {
386−public:
387−
388− QVector<BufferPoint> points;
389−
390− PointCollector(const MetavoxelLOD& lod);
391−
392− virtual int visit(MetavoxelInfo& info);
393−};
394−
395−PointCollector::PointCollector(const MetavoxelLOD& lod) :
396− MetavoxelVisitor(QVector<AttributePointer>() << AttributeRegistry::getInstance()->getColorAttribute() <<
397− AttributeRegistry::getInstance()->getNormalAttribute(), QVector<AttributePointer>(), lod) {
398−}
399−
400−int PointCollector::visit(MetavoxelInfo& info) {
401− if (!info.isLeaf) {
402− return DEFAULT_ORDER;
403− }
404− QRgb color = info.inputValues.at(0).getInlineValue<QRgb>();
405− quint8 alpha = qAlpha(color);
406− if (alpha <= ALPHA_RENDER_THRESHOLD) {
407− return STOP_RECURSION;
408− }
409− QRgb normal = info.inputValues.at(1).getInlineValue<QRgb>();
410− BufferPoint point = { glm::vec4(info.minimum + glm::vec3(info.size, info.size, info.size) * 0.5f, info.size),
411− { quint8(qRed(color)), quint8(qGreen(color)), quint8(qBlue(color)) },
412− { quint8(qRed(normal)), quint8(qGreen(normal)), quint8(qBlue(normal)) } };
413− points.append(point);
414− return STOP_RECURSION;
415−}
416−
417−/// Builds a point buffer.
418−class PointBufferBuilder : public QRunnable {
419−public:
420−
421− PointBufferBuilder(const SharedNodePointer& node, const MetavoxelData& data, const MetavoxelLOD& lod);
422−
423− virtual void run();
424−
425−private:
426−
427− QWeakPointer<Node> _node;
428− MetavoxelData _data;
429− MetavoxelLOD _lod;
430−};
431−
432−PointBufferBuilder::PointBufferBuilder(const SharedNodePointer& node, const MetavoxelData& data, const MetavoxelLOD& lod) :
433− _node(node),
434− _data(data),
435− _lod(lod) {
436−}
437−
438−void PointBufferBuilder::run() {
439− SharedNodePointer node = _node;
440− if (!node) {
441− return;
442− }
443− qint64 now = QDateTime::currentMSecsSinceEpoch();
444− PointCollector collector(_lod);
445− _data.guide(collector);
446− QMetaObject::invokeMethod(Application::getInstance()->getMetavoxels(), "setClientPoints",
447− Q_ARG(const SharedNodePointer&, node), Q_ARG(const BufferPointVector&, collector.points));
448− qDebug() << "collect" << (QDateTime::currentMSecsSinceEpoch() - now);
449−}
450−
451170 class AugmentVisitor : public MetavoxelVisitor {
452171 public:
453172
@@ -506,26 +225,12 @@ void Augmenter::run() { · 52 unmodified lines
506225 }
507226 AugmentVisitor visitor(_lod, _previousData);
508227 _data.guide(visitor);
509− QMetaObject::invokeMethod(node.data(), "setAugmentedData", Q_ARG(const MetavoxelData&, _data));
228+ QMutexLocker locker(&node->getMutex());
229+ QMetaObject::invokeMethod(node->getLinkedData(), "setAugmentedData", Q_ARG(const MetavoxelData&, _data));
510230 }
511231
512232 void MetavoxelSystemClient::dataChanged(const MetavoxelData& oldData) {
513233 MetavoxelClient::dataChanged(oldData);
514−
515− /* BufferBuilder builder(_remoteDataLOD);
516− const AttributePointer& pointBufferAttribute = Application::getInstance()->getMetavoxels()->getPointBufferAttribute();
517− MetavoxelNode* oldRoot = oldData.getRoot(pointBufferAttribute);
518− if (oldRoot && oldData.getSize() == _data.getSize()) {
519− oldRoot->incrementReferenceCount();
520− _data.setRoot(pointBufferAttribute, oldRoot);
521− _data.guideToDifferent(oldData, builder);
522−
523− } else {
524− _data.clear(pointBufferAttribute);
525− _data.guide(builder);
526− } */
527− QThreadPool::globalInstance()->start(new PointBufferBuilder(_node, _data, _remoteDataLOD));
528−
529234 QThreadPool::globalInstance()->start(new Augmenter(_node, _data, getAugmentedData(), _remoteDataLOD));
530235 }
531236
@@ -534,13 +239,42 @@ void MetavoxelSystemClient::sendDatagram(const QByteArray& data) { · 2 unmodified lines
534239 Application::getInstance()->getBandwidthMeter()->outputStream(BandwidthMeter::METAVOXELS).updateValue(data.size());
535240 }
536241
537−PointBuffer::PointBuffer(const QOpenGLBuffer& buffer, const QVector<int>& offsets, int lastLeafCount) :
538− _buffer(buffer),
539− _offsets(offsets),
540− _lastLeafCount(lastLeafCount) {
242+PointBuffer::PointBuffer(const QVector<BufferPointVectorPair>& levelPoints) :
243+ _levelPoints(levelPoints) {
541244 }
542245
543246 void PointBuffer::render(int level) {
247+ // initalize buffer, etc. on first render
248+ if (!_buffer.isCreated()) {
249+ _offsets.append(0);
250+ _lastLeafCount = 0;
251+ int totalPoints = 0;
252+ foreach (const BufferPointVectorPair& pair, _levelPoints) {
253+ _offsets.append(totalPoints += ((_lastLeafCount += pair.first.size()) + pair.second.size()));
254+ }
255+ _buffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
256+ _buffer.create();
257+ _buffer.bind();
258+ _buffer.allocate(totalPoints * sizeof(BufferPoint));
259+ int offset = 0;
260+ for (int i = 0; i < _levelPoints.size(); i++) {
261+ // write the internal nodes from the current level
262+ const BufferPointVector& internal = _levelPoints.at(i).second;
263+ int length = internal.size() * sizeof(BufferPoint);
264+ _buffer.write(offset, internal.constData(), length);
265+ offset += length;
266+
267+ // and the leaves from the top down
268+ for (int j = 0; j <= i; j++) {
269+ const BufferPointVector& leaves = _levelPoints.at(j).first;
270+ length = leaves.size() * sizeof(BufferPoint);
271+ _buffer.write(offset, leaves.constData(), length);
272+ offset += length;
273+ }
274+ }
275+ _levelPoints.clear();
276+ _buffer.release();
277+ }
544278 int first, count;
545279 int nextLevel = level + 1;
546280 if (nextLevel >= _offsets.size()) {
@@ -587,6 +321,17 @@ AttributeValue PointBufferAttribute::inherit(const AttributeValue& parentValue) · 40 unmodified lines
587321 return AttributeValue(parentValue.getAttribute());
588322 }
589323
324+void PointMetavoxelRendererImplementation::init() {
325+ if (!_program.isLinked()) {
326+ _program.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() + "shaders/metavoxel_point.vert");
327+ _program.link();
328+
329+ _program.bind();
330+ _pointScaleLocation = _program.uniformLocation("pointScale");
331+ _program.release();
332+ }
333+}
334+
590335 PointMetavoxelRendererImplementation::PointMetavoxelRendererImplementation() {
591336 }
592337
@@ -596,6 +341,11 @@ public: · 3 unmodified lines
596341 PointAugmentVisitor(const MetavoxelLOD& lod);
597342
598343 virtual int visit(MetavoxelInfo& info);
344+ virtual bool postVisit(MetavoxelInfo& info);
345+
346+private:
347+
348+ QVector<BufferPointVectorPair> _depthPoints;
599349 };
600350
601351 PointAugmentVisitor::PointAugmentVisitor(const MetavoxelLOD& lod) :
@@ -604,11 +354,44 @@ PointAugmentVisitor::PointAugmentVisitor(const MetavoxelLOD& lod) : · 2 unmodified lines
604354 Application::getInstance()->getMetavoxels()->getPointBufferAttribute(), lod) {
605355 }
606356
357+const int ALPHA_RENDER_THRESHOLD = 0;
358+
607359 int PointAugmentVisitor::visit(MetavoxelInfo& info) {
608− if (!info.isLeaf) {
609− return DEFAULT_ORDER;
360+ if (_depth >= _depthPoints.size()) {
361+ _depthPoints.resize(_depth + 1);
610362 }
611− return STOP_RECURSION;
363+ QRgb color = info.inputValues.at(0).getInlineValue<QRgb>();
364+ quint8 alpha = qAlpha(color);
365+ if (alpha <= ALPHA_RENDER_THRESHOLD) {
366+ return info.isLeaf ? STOP_RECURSION : (DEFAULT_ORDER | ALL_NODES);
367+ }
368+ QRgb normal = info.inputValues.at(1).getInlineValue<QRgb>();
369+ BufferPoint point = { glm::vec4(info.minimum + glm::vec3(info.size, info.size, info.size) * 0.5f, info.size),
370+ { quint8(qRed(color)), quint8(qGreen(color)), quint8(qBlue(color)) },
371+ { quint8(qRed(normal)), quint8(qGreen(normal)), quint8(qBlue(normal)) } };
372+ if (info.isLeaf) {
373+ _depthPoints[_depth].first.append(point);
374+ return STOP_RECURSION;
375+ }
376+ _depthPoints[_depth].second.append(point);
377+ return DEFAULT_ORDER | ALL_NODES;
378+}
379+
380+bool PointAugmentVisitor::postVisit(MetavoxelInfo& info) {
381+ if (_depth != 0) {
382+ return false;
383+ }
384+ int lastDepth = _depthPoints.size();
385+ QVector<BufferPointVectorPair> levelPoints(lastDepth - _depth);
386+ for (int i = 0; i < levelPoints.size(); i++) {
387+ BufferPointVectorPair& levelPair = levelPoints[i];
388+ BufferPointVectorPair& depthPair = _depthPoints[_depth + i];
389+ levelPair.first.swap(depthPair.first);
390+ levelPair.second.swap(depthPair.second);
391+ }
392+ info.outputValues[0] = AttributeValue(_outputs.at(0), encodeInline(PointBufferPointer(
393+ new PointBuffer(levelPoints))));
394+ return true;
612395 }
613396
614397 void PointMetavoxelRendererImplementation::augment(MetavoxelData& data, const MetavoxelData& previous,
@@ -623,24 +406,65 @@ public: · 8 unmodified lines
623406 PointRenderVisitor(const MetavoxelLOD& lod);
624407
625408 virtual int visit(MetavoxelInfo& info);
409+
410+private:
411+
412+ int _order;
626413 };
627414
628415 PointRenderVisitor::PointRenderVisitor(const MetavoxelLOD& lod) :
629416 MetavoxelVisitor(QVector<AttributePointer>() << Application::getInstance()->getMetavoxels()->getPointBufferAttribute(),
630− QVector<AttributePointer>(), lod) {
417+ QVector<AttributePointer>(), lod),
418+ _order(encodeOrder(Application::getInstance()->getViewFrustum()->getDirection())) {
631419 }
632420
633421 int PointRenderVisitor::visit(MetavoxelInfo& info) {
634− if (!info.isLeaf) {
635− return DEFAULT_ORDER;
422+ PointBufferPointer buffer = info.inputValues.at(0).getInlineValue<PointBufferPointer>();
423+ if (buffer) {
424+ buffer->render(1000);
636425 }
637− return STOP_RECURSION;
426+ return info.isLeaf ? STOP_RECURSION : _order;
638427 }
639428
640429 void PointMetavoxelRendererImplementation::render(MetavoxelData& data, MetavoxelInfo& info, const MetavoxelLOD& lod) {
430+ int viewport[4];
431+ glGetIntegerv(GL_VIEWPORT, viewport);
432+ const int VIEWPORT_WIDTH_INDEX = 2;
433+ const int VIEWPORT_HEIGHT_INDEX = 3;
434+ float viewportWidth = viewport[VIEWPORT_WIDTH_INDEX];
435+ float viewportHeight = viewport[VIEWPORT_HEIGHT_INDEX];
436+ float viewportDiagonal = sqrtf(viewportWidth * viewportWidth + viewportHeight * viewportHeight);
437+ float worldDiagonal = glm::distance(Application::getInstance()->getViewFrustum()->getNearBottomLeft(),
438+ Application::getInstance()->getViewFrustum()->getNearTopRight());
439+
440+ _program.bind();
441+ _program.setUniformValue(_pointScaleLocation, viewportDiagonal *
442+ Application::getInstance()->getViewFrustum()->getNearClip() / worldDiagonal);
443+
444+ glEnableClientState(GL_VERTEX_ARRAY);
445+ glEnableClientState(GL_COLOR_ARRAY);
446+ glEnableClientState(GL_NORMAL_ARRAY);
447+
448+ glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
449+
450+ glDisable(GL_BLEND);
451+
641452 PointRenderVisitor visitor(lod);
642453 data.guide(visitor, &info);
454+
455+ glEnable(GL_BLEND);
456+
457+ glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
458+
459+ glDisableClientState(GL_VERTEX_ARRAY);
460+ glDisableClientState(GL_COLOR_ARRAY);
461+ glDisableClientState(GL_NORMAL_ARRAY);
462+
463+ _program.release();
643464 }
465+
466+ProgramObject PointMetavoxelRendererImplementation::_program;
467+int PointMetavoxelRendererImplementation::_pointScaleLocation;
644468
645469 static void enableClipPlane(GLenum plane, float x, float y, float z, float w) {
646470 GLdouble coefficients[] = { x, y, z, w };

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t