Mirrors/overte-JulianGro
3
0
Fork 0
mirror of https://github.com/JulianGro/overte.git synced 2025-04-25 17:14:59 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'upstream/master'

Browse source
This commit is contained in:
Jeffrey Ventrella 2013-05-22 11:43:12 -07:00
commit f7b101b4aa
42 changed files with 1104 additions and 1390 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
interface/src/Application.cpp
View file

@ -37,13 +37,10 @@
#include <AgentTypes.h>
#include <PacketHeaders.h>
#include <PerfStat.h>
#include <shared_Log.h>
#include <voxels_Log.h>
#include <avatars_Log.h>
#include "Application.h"
#include "InterfaceConfig.h"
#include "Log.h"
#include "LogDisplay.h"
#include "OculusManager.h"
#include "Util.h"
#include "renderer/ProgramObject.h"
@ -161,10 +158,6 @@ Application::Application(int& argc, char** argv) :
_voxels.setViewFrustum(&_viewFrustum);
shared_lib::printLog = & ::printLog;
voxels_lib::printLog = & ::printLog;
avatars_lib::printLog = & ::printLog;
unsigned int listenPort = AGENT_SOCKET_LISTEN_PORT;
const char** constArgv = const_cast<const char**>(argv);
const char* portStr = getCmdOption(argc, constArgv, "--listenPort");
@ -1774,7 +1767,7 @@ void Application::displayOverlay() {
glPointSize(1.0f);
if (_renderStatsOn->isChecked()) { displayStats(); }
if (_logOn->isChecked()) { logger.render(_glWidget->width(), _glWidget->height()); }
if (_logOn->isChecked()) { LogDisplay::instance.render(_glWidget->width(), _glWidget->height()); }
// Show chat entry field
if (_chatEntryOn) {

321
interface/src/Log.cpp
View file

@ -1,321 +0,0 @@
//
// Log.cpp
// interface
//
// Created by Tobias Schwinger on 4/14/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "Log.h"
#include "InterfaceConfig.h"
#include <string.h>
#include <stdarg.h>
#include "Util.h"
#include "ui/TextRenderer.h"
namespace {
// anonymous namespace - everything in here only exists within this very .cpp file
// just as 'static' on every effective line in plain C
unsigned const CHARACTER_BUFFER_SIZE = 16384; // number of character that are buffered
unsigned const LINE_BUFFER_SIZE = 256; // number of lines that are buffered
unsigned const MAX_MESSAGE_LENGTH = 512; // maximum number of characters for a message
const char* FONT_FAMILY = SANS_FONT_FAMILY;
bool const TEXT_MONOSPACED = true;
float const TEXT_RED = 0.7f;
float const TEXT_GREEN = 0.6f;
float const TEXT_BLUE = 1.0f;
// magic constants from the GLUT spec
// http://www.opengl.org/resources/libraries/glut/spec3/node78.html
// ultimately this stuff should be in Util.h??
float const CHAR_UP = 119.05f;
float const CHAR_DOWN = 33.33f;
float const CHAR_WIDTH = 104.76f;
// derived values
float const CHAR_HEIGHT = CHAR_UP + CHAR_DOWN;
float const CHAR_FRACT_BASELINE = CHAR_DOWN / CHAR_HEIGHT;
// unsigned integer division rounded towards infinity
unsigned divRoundUp(unsigned l, unsigned r) { return (l + r - 1) / r; }
}
Log::Log(FILE* tPipeTo, unsigned bufferedLines,
unsigned defaultLogWidth, unsigned defaultCharWidth, unsigned defaultCharHeight) :
_ptrStream(tPipeTo),
_arrChars(0l),
_arrLines(0l),
_valLogWidth(defaultLogWidth) {
pthread_mutex_init(& _mtx, 0l);
// allocate twice as much (so we have spare space for a copy not to block
// logging from other threads during 'render')
_arrChars = new char[CHARACTER_BUFFER_SIZE * 2];
_ptrCharsEnd = _arrChars + CHARACTER_BUFFER_SIZE;
_arrLines = new char*[LINE_BUFFER_SIZE * 2];
_ptrLinesEnd = _arrLines + LINE_BUFFER_SIZE;
// initialize the log to all empty lines
_arrChars[0] = '\0';
_itrWritePos = _arrChars;
_itrWriteLineStart = _arrChars;
_itrLastLine = _arrLines;
_valWrittenInLine = 0;
memset(_arrLines, 0, LINE_BUFFER_SIZE * sizeof(char*));
setCharacterSize(defaultCharWidth, defaultCharHeight);
}
Log::~Log() {
delete[] _arrChars;
delete[] _arrLines;
}
inline void Log::addMessage(char const* ptr) {
// precondition: mutex is locked so noone gets in our way
// T-pipe, if requested
if (_ptrStream != 0l) {
fprintf(_ptrStream, "%s", ptr);
}
while (*ptr != '\0') {
// process the characters
char c = *ptr++;
if (c == '\t') {
// found TAB -> write SPACE
c = ' ';
} else if (c == '\n') {
// found LF -> write NUL (c == '\0' tells us to wrap, below)
c = '\0';
}
*_itrWritePos++ = c;
if (_itrWritePos == _ptrCharsEnd) {
// reached the end of the circular character buffer? -> start over
_itrWritePos = _arrChars;
}
if (++_valWrittenInLine >= _valLineLength || c == '\0') {
// new line? store its start to the line buffer and mark next line as empty
++_itrLastLine;
if (_itrLastLine == _ptrLinesEnd) {
_itrLastLine = _arrLines;
_itrLastLine[1] = 0l;
} else if (_itrLastLine + 1 != _ptrLinesEnd) {
_itrLastLine[1] = 0l;
} else {
_arrLines[0] = 0l;
}
*_itrLastLine = _itrWriteLineStart;
// debug mode: make sure all line pointers we write here are valid
assert(! (_itrLastLine < _arrLines || _itrLastLine >= _ptrLinesEnd));
assert(! (*_itrLastLine < _arrChars || *_itrLastLine >= _ptrCharsEnd));
// terminate line, unless done already
if (c != '\0') {
*_itrWritePos++ = '\0';
if (_itrWritePos == _ptrCharsEnd) {
_itrWritePos = _arrChars;
}
}
// remember start position in character buffer for next line and reset character count
_itrWriteLineStart = _itrWritePos;
_valWrittenInLine = 0;
}
}
}
int Log::vprint(char const* fmt, va_list args) {
pthread_mutex_lock(& _mtx);
// print to buffer
char buf[MAX_MESSAGE_LENGTH];
int n = vsnprintf(buf, MAX_MESSAGE_LENGTH, fmt, args);
if (n > 0) {
// all fine? log the message
addMessage(buf);
} else {
// error? -> mutter on stream or stderr
fprintf(_ptrStream != 0l ? _ptrStream : stderr,
"Log: Failed to log message with format string = \"%s\".\n", fmt);
}
pthread_mutex_unlock(& _mtx);
return n;
}
void Log::operator()(char const* fmt, ...) {
va_list args;
va_start(args,fmt);
vprint(fmt, args);
va_end(args);
}
void Log::setLogWidth(unsigned pixels) {
pthread_mutex_lock(& _mtx);
_valLogWidth = pixels;
_valLineLength = _valLogWidth / _valCharWidth;
pthread_mutex_unlock(& _mtx);
}
void Log::setCharacterSize(unsigned width, unsigned height) {
pthread_mutex_lock(& _mtx);
_valCharWidth = width;
_valCharHeight = height;
_valCharYoffset = height * CHAR_FRACT_BASELINE;
_valCharScale = float(width) / CHAR_WIDTH;
_valCharAspect = (height * CHAR_WIDTH) / (width * CHAR_HEIGHT);
_valLineLength = _valLogWidth / _valCharWidth;
pthread_mutex_unlock(& _mtx);
}
static TextRenderer* textRenderer() {
static TextRenderer* renderer = new TextRenderer(FONT_FAMILY, -1, -1, false, TextRenderer::SHADOW_EFFECT);
return renderer;
}
void Log::render(unsigned screenWidth, unsigned screenHeight) {
// rendering might take some time, so create a local copy of the portion we need
// instead of having to hold the mutex all the time
pthread_mutex_lock(& _mtx);
// determine number of visible lines
unsigned showLines = divRoundUp(screenHeight, _valCharHeight);
char** lastLine = _itrLastLine;
char** firstLine = _itrLastLine;
if (! *lastLine) {
// empty log
pthread_mutex_unlock(& _mtx);
return;
}
// scan for first line
for (int n = 2; n <= showLines; ++n) {
char** prevFirstLine = firstLine;
--firstLine;
if (firstLine < _arrLines) {
firstLine = _ptrLinesEnd - 1;
}
if (! *firstLine) {
firstLine = prevFirstLine;
showLines = n - 1;
break;
}
// debug mode: make sure all line pointers we find here are valid
assert(! (firstLine < _arrLines || firstLine >= _ptrLinesEnd));
assert(! (*firstLine < _arrChars || *firstLine >= _ptrCharsEnd));
}
// copy the line buffer portion into a contiguous region at _ptrLinesEnd
if (firstLine <= lastLine) {
memcpy(_ptrLinesEnd, firstLine, showLines * sizeof(char*));
} else {
unsigned atEnd = _ptrLinesEnd - firstLine;
memcpy(_ptrLinesEnd, firstLine, atEnd * sizeof(char*));
memcpy(_ptrLinesEnd + atEnd, _arrLines, (showLines - atEnd) * sizeof(char*));
}
// copy relevant char buffer portion and determine information to remap the pointers
char* firstChar = *firstLine;
char* lastChar = *lastLine + strlen(*lastLine) + 1;
ptrdiff_t charOffset = _ptrCharsEnd - firstChar, charOffsetBeforeFirst = 0;
if (firstChar <= lastChar) {
memcpy(_ptrCharsEnd, firstChar, lastChar - firstChar + 1);
} else {
unsigned atEnd = _ptrCharsEnd - firstChar;
memcpy(_ptrCharsEnd, firstChar, atEnd);
memcpy(_ptrCharsEnd + atEnd, _arrChars, lastChar + 1 - _arrChars);
charOffsetBeforeFirst = _ptrCharsEnd + atEnd - _arrChars;
}
// get values for rendering
int yStep = textRenderer()->metrics().lineSpacing();
int yStart = screenHeight - textRenderer()->metrics().descent();
// render text
char** line = _ptrLinesEnd + showLines;
int x = screenWidth - _valLogWidth;
pthread_mutex_unlock(& _mtx);
// ok, we got all we need
for (int y = yStart; y > 0; y -= yStep) {
// debug mode: check line pointer is valid
assert(! (line < _ptrLinesEnd || line >= _ptrLinesEnd + (_ptrLinesEnd - _arrLines)));
// get character pointer
if (--line < _ptrLinesEnd) {
break;
}
char* chars = *line;
// debug mode: check char pointer we find is valid
assert(! (chars < _arrChars || chars >= _ptrCharsEnd));
// remap character pointer it to copied buffer
chars += chars >= firstChar ? charOffset : charOffsetBeforeFirst;
// debug mode: check char pointer is still valid (in new range)
assert(! (chars < _ptrCharsEnd || chars >= _ptrCharsEnd + (_ptrCharsEnd - _arrChars)));
// render the string
glColor3f(TEXT_RED, TEXT_GREEN, TEXT_BLUE);
textRenderer()->draw(x, y, chars);
//fprintf(stderr, "Log::render, message = \"%s\"\n", chars);
}
}
Log logger;
int printLog(char const* fmt, ...) {
int result;
va_list args;
va_start(args,fmt);
result = logger.vprint(fmt, args);
va_end(args);
return result;
}

80
interface/src/Log.h
View file

@ -1,80 +0,0 @@
//
// Log.h
// interface
//
// Created by Tobias Schwinger on 4/14/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __interface__Log__
#define __interface__Log__
#include <stdio.h>
#include <stdarg.h>
#include <glm/glm.hpp>
#include <pthread.h>
class Log;
//
// Call it as you would call 'printf'.
//
int printLog(char const* fmt, ...);
//
// Global instance.
//
extern Log logger;
//
// Logging subsystem.
//
class Log {
FILE* _ptrStream;
char* _arrChars;
char* _ptrCharsEnd;
char** _arrLines;
char** _ptrLinesEnd;
char* _itrWritePos; // character position to write to
char* _itrWriteLineStart; // character position where line being written starts
char** _itrLastLine; // last line in the log
unsigned _valWrittenInLine; // character counter for line wrapping
unsigned _valLineLength; // number of characters before line wrap
unsigned _valLogWidth; // width of the log in pixels
unsigned _valCharWidth; // width of a character in pixels
unsigned _valCharHeight; // height of a character in pixels
unsigned _valCharYoffset; // baseline offset in pixels
float _valCharScale; // scale factor
float _valCharAspect; // aspect (h/w)
pthread_mutex_t _mtx;
public:
explicit Log(FILE* tPipeTo = stdout, unsigned bufferedLines = 1024,
unsigned defaultLogWidth = 400, unsigned defaultCharWidth = 6, unsigned defaultCharHeight = 20);
~Log();
void setLogWidth(unsigned pixels);
void setCharacterSize(unsigned width, unsigned height);
void render(unsigned screenWidth, unsigned screenHeight);
void operator()(char const* fmt, ...);
int vprint(char const* fmt, va_list);
private:
// don't copy/assign
Log(Log const&); // = delete;
Log& operator=(Log const&); // = delete;
inline void addMessage(char const*);
friend class LogStream; // for optional iostream-style interface that has to be #included separately
};
#endif

306
interface/src/LogDisplay.cpp Normal file
View file

@ -0,0 +1,306 @@
//
// LogDisplay.cpp
// interface
//
// Created by Tobias Schwinger on 4/14/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "LogDisplay.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "Util.h"
using namespace std;
FILE* const LogDisplay::DEFAULT_STREAM = stdout;
//
// Singleton constructor
//
LogDisplay LogDisplay::instance;
//
// State management
//
LogDisplay::LogDisplay() :
_textRenderer(MONO_FONT_FAMILY, -1, -1, false, TextRenderer::SHADOW_EFFECT),
_stream(DEFAULT_STREAM),
_chars(0l),
_lines(0l),
_logWidth(DEFAULT_CONSOLE_WIDTH) {
pthread_mutex_init(& _mutex, 0l);
// allocate twice as much (so we have spare space for a copy not to block
// logging from other threads during 'render')
_chars = new char[CHARACTER_BUFFER_SIZE * 2];
_charsEnd = _chars + CHARACTER_BUFFER_SIZE;
_lines = new char*[LINE_BUFFER_SIZE * 2];
_linesEnd = _lines + LINE_BUFFER_SIZE;
// initialize the log to all empty lines
_chars[0] = '\0';
_writePos = _chars;
_writeLineStartPos = _chars;
_lastLinePos = _lines;
_writtenInLine = 0;
memset(_lines, 0, LINE_BUFFER_SIZE * sizeof(char*));
setCharacterSize(DEFAULT_CHAR_WIDTH, DEFAULT_CHAR_HEIGHT);
printLog = & printLogHandler;
}
LogDisplay::~LogDisplay() {
delete[] _chars;
delete[] _lines;
}
void LogDisplay::setStream(FILE* stream) {
pthread_mutex_lock(& _mutex);
_stream = stream;
pthread_mutex_unlock(& _mutex);
}
void LogDisplay::setLogWidth(unsigned pixels) {
pthread_mutex_lock(& _mutex);
_logWidth = pixels;
_lineLength = _logWidth / _charWidth;
pthread_mutex_unlock(& _mutex);
}
void LogDisplay::setCharacterSize(unsigned width, unsigned height) {
pthread_mutex_lock(& _mutex);
_charWidth = width;
_charHeight = height;
_lineLength = _logWidth / _charWidth;
pthread_mutex_unlock(& _mutex);
}
//
// Logging
//
int LogDisplay::printLogHandler(char const* fmt, ...) {
va_list args;
int n;
char buf[MAX_MESSAGE_LENGTH];
va_start(args,fmt);
// print to buffer
n = vsnprintf(buf, MAX_MESSAGE_LENGTH, fmt, args);
if (n > 0) {
// all fine? log the message
instance.addMessage(buf);
} else {
// error? -> mutter on stream or stderr
fprintf(instance._stream != 0l ? instance._stream : stderr,
"Log: Failed to log message with format string = \"%s\".\n", fmt);
}
va_end(args);
return n;
}
inline void LogDisplay::addMessage(char const* ptr) {
pthread_mutex_lock(& _mutex);
// T-pipe, if requested
if (_stream != 0l) {
fprintf(_stream, "%s", ptr);
}
while (*ptr != '\0') {
// process the characters
char c = *ptr++;
if (c == '\t') {
// found TAB -> write SPACE
c = ' ';
} else if (c == '\n') {
// found LF -> write NUL (c == '\0' tells us to wrap, below)
c = '\0';
}
*_writePos++ = c;
if (_writePos == _charsEnd) {
// reached the end of the circular character buffer? -> start over
_writePos = _chars;
}
if (++_writtenInLine >= _lineLength || c == '\0') {
// new line? store its start to the line buffer and mark next line as empty
++_lastLinePos;
if (_lastLinePos == _linesEnd) {
_lastLinePos = _lines;
_lastLinePos[1] = 0l;
} else if (_lastLinePos + 1 != _linesEnd) {
_lastLinePos[1] = 0l;
} else {
_lines[0] = 0l;
}
*_lastLinePos = _writeLineStartPos;
// debug mode: make sure all line pointers we write here are valid
assert(! (_lastLinePos < _lines || _lastLinePos >= _linesEnd));
assert(! (*_lastLinePos < _chars || *_lastLinePos >= _charsEnd));
// terminate line, unless done already
if (c != '\0') {
*_writePos++ = '\0';
if (_writePos == _charsEnd) {
_writePos = _chars;
}
}
// remember start position in character buffer for next line and reset character count
_writeLineStartPos = _writePos;
_writtenInLine = 0;
}
}
pthread_mutex_unlock(& _mutex);
}
//
// Rendering
//
void LogDisplay::render(unsigned screenWidth, unsigned screenHeight) {
// rendering might take some time, so create a local copy of the portion we need
// instead of having to hold the mutex all the time
pthread_mutex_lock(& _mutex);
// determine number of visible lines (integer division rounded up)
unsigned showLines = (screenHeight + _charHeight - 1) / _charHeight;
char** lastLine = _lastLinePos;
char** firstLine = _lastLinePos;
if (! *lastLine) {
// empty log
pthread_mutex_unlock(& _mutex);
return;
}
// scan for first line
for (int n = 2; n <= showLines; ++n) {
char** prevFirstLine = firstLine;
--firstLine;
if (firstLine < _lines) {
firstLine = _linesEnd - 1;
}
if (! *firstLine) {
firstLine = prevFirstLine;
showLines = n - 1;
break;
}
// debug mode: make sure all line pointers we find here are valid
assert(! (firstLine < _lines || firstLine >= _linesEnd));
assert(! (*firstLine < _chars || *firstLine >= _charsEnd));
}
// copy the line buffer portion into a contiguous region at _linesEnd
if (firstLine <= lastLine) {
memcpy(_linesEnd, firstLine, showLines * sizeof(char*));
} else {
unsigned atEnd = _linesEnd - firstLine;
memcpy(_linesEnd, firstLine, atEnd * sizeof(char*));
memcpy(_linesEnd + atEnd, _lines, (showLines - atEnd) * sizeof(char*));
}
// copy relevant char buffer portion and determine information to remap the pointers
char* firstChar = *firstLine;
char* lastChar = *lastLine + strlen(*lastLine) + 1;
ptrdiff_t charOffset = _charsEnd - firstChar, charOffsetBeforeFirst = 0;
if (firstChar <= lastChar) {
memcpy(_charsEnd, firstChar, lastChar - firstChar + 1);
} else {
unsigned atEnd = _charsEnd - firstChar;
memcpy(_charsEnd, firstChar, atEnd);
memcpy(_charsEnd + atEnd, _chars, lastChar + 1 - _chars);
charOffsetBeforeFirst = _charsEnd + atEnd - _chars;
}
// determine geometry information from font metrics
QFontMetrics const& fontMetrics = _textRenderer.metrics();
int yStep = fontMetrics.lineSpacing();
// scale
float xScale = float(_charWidth) / fontMetrics.width('*');
float yScale = float(_charHeight) / yStep;
// scaled translation
int xStart = int((screenWidth - _logWidth) / xScale);
int yStart = screenHeight / yScale - fontMetrics.descent();
// first line to render
char** line = _linesEnd + showLines;
// ok, now the lock can be released - we have all we need
// and won't hold it while talking to OpenGL
pthread_mutex_unlock(& _mutex);
glPushMatrix();
glScalef(xScale, yScale, 1.0f);
glColor3ub(GLubyte(TEXT_COLOR >> 16),
GLubyte((TEXT_COLOR >> 8) & 0xff),
GLubyte(TEXT_COLOR & 0xff));
for (int y = yStart; y > 0; y -= yStep) {
// debug mode: check line pointer is valid
assert(! (line < _linesEnd || line >= _linesEnd + (_linesEnd - _lines)));
// get character pointer
if (--line < _linesEnd) {
break;
}
char* chars = *line;
// debug mode: check char pointer we find is valid
assert(! (chars < _chars || chars >= _charsEnd));
// remap character pointer it to copied buffer
chars += chars >= firstChar ? charOffset : charOffsetBeforeFirst;
// debug mode: check char pointer is still valid (in new range)
assert(! (chars < _charsEnd || chars >= _charsEnd + (_charsEnd - _chars)));
// render the string
_textRenderer.draw(xStart, y, chars);
//fprintf(stderr, "LogDisplay::render, message = \"%s\"\n", chars);
}
glPopMatrix();
}

80
interface/src/LogDisplay.h Normal file
View file

@ -0,0 +1,80 @@
//
// LogDisplay.h
// interface
//
// Created by Tobias Schwinger on 4/14/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __interface__LogDisplay__
#define __interface__LogDisplay__
#include <stdarg.h>
#include <pthread.h>
#include "Log.h"
#include "ui/TextRenderer.h"
class LogDisplay {
public:
static LogDisplay instance;
void render(unsigned screenWidth, unsigned screenHeight);
// settings
static unsigned const TEXT_COLOR = 0xb299ff; // text foreground color (bytes, RGB)
static FILE* const DEFAULT_STREAM; // = stdout; // stream to also log to (defined in .cpp)
static unsigned const DEFAULT_CHAR_WIDTH = 7; // width of a single character
static unsigned const DEFAULT_CHAR_HEIGHT = 16; // height of a single character
static unsigned const DEFAULT_CONSOLE_WIDTH = 400; // width of the (right-aligned) log console
void setStream(FILE* stream);
void setLogWidth(unsigned pixels);
void setCharacterSize(unsigned width, unsigned height);
// limits
static unsigned const CHARACTER_BUFFER_SIZE = 16384; // number of character that are buffered
static unsigned const LINE_BUFFER_SIZE = 256; // number of lines that are buffered
static unsigned const MAX_MESSAGE_LENGTH = 512; // maximum number of characters for a message
private:
// use static 'instance' to access the single instance
LogDisplay();
~LogDisplay();
// don't copy/assign
LogDisplay(LogDisplay const&); // = delete;
LogDisplay& operator=(LogDisplay const&); // = delete;
// format and log message - entrypoint used to replace global 'printLog'
static int printLogHandler(char const* fmt, ...);
// log formatted message (called by printLogHandler)
inline void addMessage(char const*);
TextRenderer _textRenderer;
FILE* _stream; // FILE as secondary destination for log messages
char* _chars; // character buffer base address
char* _charsEnd; // character buffer, exclusive end
char** _lines; // line buffer base address
char** _linesEnd; // line buffer, exclusive end
char* _writePos; // character position to write to
char* _writeLineStartPos; // character position where line being written starts
char** _lastLinePos; // last line in the log
unsigned _writtenInLine; // character counter for line wrapping
unsigned _lineLength; // number of characters before line wrap
unsigned _logWidth; // width of the log in pixels
unsigned _charWidth; // width of a character in pixels
unsigned _charHeight; // height of a character in pixels
pthread_mutex_t _mutex;
};
#endif

106
interface/src/LogStream.h
View file

@ -1,106 +0,0 @@
//
// LogStream.h
// interface
//
// Created by Tobias Schwinger on 4/17/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __interface__LogStream__
#define __interface__LogStream__
#include <sstream>
#include "Log.h"
//
// Makes the logging facility accessible as a C++ stream.
//
// Example:
//
// // somewhere central - ideally one per thread (else pass 'true' as
// // second constructor argument and compromise some efficiency)
// LogStream lOut(printLog);
//
// // elsewhere:
// lOut << "Hello there!" << std::endl;
//
class LogStream {
std::ostringstream _objOutStream;
Log& _refLog;
bool _flgThreadSafe;
public:
inline LogStream(Log& log, bool threadSafe = false);
class StreamRef; friend class StreamRef;
template< typename T > friend inline LogStream::StreamRef const operator<<(LogStream&, T const&);
private:
// don't
LogStream(LogStream const&); // = delete;
LogStream& operator=(LogStream const&); // = delete;
inline void ostreamBegin();
inline void ostreamEnd();
};
inline LogStream::LogStream(Log& log, bool threadSafe) :
_objOutStream(std::ios_base::out), _refLog(log), _flgThreadSafe(threadSafe) { }
inline void LogStream::ostreamBegin() {
if (_flgThreadSafe) {
// the user wants to share this LogStream among threads,
// so lock the global log here, already
pthread_mutex_lock(& _refLog._mtx);
}
_objOutStream.str("");
}
inline void LogStream::ostreamEnd() {
if (! _flgThreadSafe) {
// haven't locked, so far (we have memory for each thread)
pthread_mutex_lock(& _refLog._mtx);
}
_refLog.addMessage(_objOutStream.str().c_str());
pthread_mutex_unlock(& _refLog._mtx);
}
//
// The Log::StreamRef class makes operator<< work. It...
//
class LogStream::StreamRef {
mutable LogStream* _ptrLogStream;
typedef std::ostream& (*manipulator)(std::ostream&);
friend class LogStream;
template< typename T > friend inline LogStream::StreamRef const operator<<(LogStream&, T const&);
StreamRef(LogStream* log) : _ptrLogStream(log) { }
public:
// ...forwards << operator calls to stringstream...
template< typename T > StreamRef const operator<<(T const& x) const { _ptrLogStream->_objOutStream << x; return *this; }
// ...has to dance around to make manipulators (such as std::hex, std::endl) work...
StreamRef const operator<<(manipulator x) const { _ptrLogStream->_objOutStream << x; return *this; }
// ...informs the logger that a stream has ended when it has the responsibility...
~StreamRef() { if (_ptrLogStream != 0l) { _ptrLogStream->ostreamEnd(); } }
// ...which is passed on upon copy.
StreamRef(StreamRef const& other) : _ptrLogStream(other._ptrLogStream) { other._ptrLogStream = 0l; }
private:
// don't
StreamRef& operator=(StreamRef const&); // = delete;
};
template< typename T > inline LogStream::StreamRef const operator<<(LogStream& s, T const& x) {
s.ostreamBegin();
s._objOutStream << x;
return LogStream::StreamRef(& s); // calls streamEnd at the end of the stream expression
}
#endif

146
interface/src/OGlProgram.h
View file

@ -1,146 +0,0 @@
#ifndef __interface__OpenGlSupport__
#define __interface__OpenGlSupport__
#include "InterfaceConfig.h"
#include "Log.h"
//
// Macro to log OpenGl errors.
// Example: oglLog( glPushMatrix() );
//
#define oGlLog(stmt) \
stmt; \
{ \
GLenum e = glGetError(); \
if (e != GL_NO_ERROR) { \
printLog(__FILE__ ":" oGlLog_stringize(__LINE__) \
" [OpenGL] %s\n", gluErrorString(e)); \
} \
} \
(void) 0
#define oGlLog_stringize(x) oGlLog_stringize_i(x)
#define oGlLog_stringize_i(x) # x
//
// Encapsulation of the otherwise lengthy call sequence to compile
// and link shading pipelines.
//
class OGlProgram {
GLuint _hndProg;
public:
OGlProgram() : _hndProg(0) { }
~OGlProgram() { if (_hndProg != 0u) { glDeleteProgram(_hndProg); } }
// no copy/assign
OGlProgram(OGlProgram const&); // = delete;
OGlProgram& operator=(OGlProgram const&); // = delete;
#if 0 // let's keep this commented, for now (C++11)
OGlProgram(OGlProgram&& disposable) : _hndProg(disposable._hndProg) {
disposable._hndProg = 0;
}
OGlProgram& operator=(OGlProgram&& disposable) {
GLuint tmp = _hndProg;
_hndProg = disposable._hndProg;
disposable._hndProg = tmp;
}
#endif
//
// Activates the executable for rendering.
// Shaders must be added and linked before this will work.
//
void activate() const {
if (_hndProg != 0u) {
oGlLog( glUseProgram(_hndProg) );
}
}
//
// Adds a shader to the program.
//
bool addShader(GLenum type, GLchar const* cString) {
return addShader(type, 1, & cString);
}
//
// Adds a shader to the program and logs to stderr.
//
bool addShader(GLenum type, GLsizei nStrings, GLchar const** strings) {
if (! _hndProg && !! glCreateProgram) {
_hndProg = glCreateProgram();
}
if (! _hndProg) { return false; }
GLuint s = glCreateShader(type);
glShaderSource(s, nStrings, strings, 0l);
glCompileShader(s);
GLint status;
glGetShaderiv(s, GL_COMPILE_STATUS, & status);
if (status != 0)
glAttachShader(_hndProg, s);
#ifdef NDEBUG // always fetch log in debug mode
else
#endif
fetchLog(s, glGetShaderiv, glGetShaderInfoLog);
glDeleteShader(s);
return !! status;
}
//
// Links the program and logs to stderr.
//
bool link() {
if (! _hndProg) { return false; }
glLinkProgram(_hndProg);
GLint status;
glGetProgramiv(_hndProg, GL_LINK_STATUS, & status);
#ifndef NDEBUG // always fetch log in debug mode
fetchLog(_hndProg, glGetProgramiv, glGetProgramInfoLog);
#endif
if (status == 0) {
#ifdef NDEBUG // only on error in release mode
fetchLog(_hndProg, glGetProgramiv, glGetProgramInfoLog);
#endif
glDeleteProgram(_hndProg);
_hndProg = 0u;
return false;
} else {
return true;
}
}
private:
template< typename ParamFunc, typename GetLogFunc >
void fetchLog(GLint handle, ParamFunc getParam, GetLogFunc getLog) {
GLint logLength = 0;
getParam(handle, GL_INFO_LOG_LENGTH, &logLength);
if (!! logLength) {
GLchar* message = new GLchar[logLength];
getLog(handle, logLength, 0l, message);
printLog("%s\n", message);
delete[] message;
}
}
};
#endif

60
interface/src/Oscilloscope.cpp
View file

@ -32,31 +32,33 @@ namespace { // everything in here only exists while compiling this .cpp file
}
Oscilloscope::Oscilloscope(int w, int h, bool isEnabled) :
Oscilloscope::Oscilloscope(int w, int h, bool isEnabled) :
enabled(isEnabled),
inputPaused(false),
_valWidth(w),
_valHeight(h),
_arrSamples(0l),
_arrVertices(0l),
_valLowpass(0.4f),
_valDownsample(3) {
_width(w),
_height(h),
_samples(0l),
_vertices(0l),
// some filtering (see details in Log.h)
_lowPassCoeff(0.4f),
// three in -> one out
_downsampleRatio(3) {
// allocate enough space for the sample data and to turn it into
// vertices and since they're all 'short', do so in one shot
_arrSamples = new short[N_INT16_TO_ALLOC];
memset(_arrSamples, 0, N_INT16_TO_ALLOC * sizeof(short));
_arrVertices = _arrSamples + MAX_SAMPLES;
_samples = new short[N_INT16_TO_ALLOC];
memset(_samples, 0, N_INT16_TO_ALLOC * sizeof(short));
_vertices = _samples + MAX_SAMPLES;
// initialize write positions to start of each channel's region
for (unsigned ch = 0; ch < MAX_CHANNELS; ++ch) {
_arrWritePos[ch] = MAX_SAMPLES_PER_CHANNEL * ch;
_writePos[ch] = MAX_SAMPLES_PER_CHANNEL * ch;
}
}
Oscilloscope::~Oscilloscope() {
delete[] _arrSamples;
delete[] _samples;
}
void Oscilloscope::addSamples(unsigned ch, short const* data, unsigned n) {
@ -70,7 +72,7 @@ void Oscilloscope::addSamples(unsigned ch, short const* data, unsigned n) {
unsigned endOffs = baseOffs + MAX_SAMPLES_PER_CHANNEL;
// fetch write position for this channel
unsigned writePos = _arrWritePos[ch];
unsigned writePos = _writePos[ch];
// determine write position after adding the samples
unsigned newWritePos = writePos + n;
@ -83,13 +85,13 @@ void Oscilloscope::addSamples(unsigned ch, short const* data, unsigned n) {
}
// copy data
memcpy(_arrSamples + writePos, data, n * sizeof(short));
memcpy(_samples + writePos, data, n * sizeof(short));
if (n2 > 0) {
memcpy(_arrSamples + baseOffs, data + n, n2 * sizeof(short));
memcpy(_samples + baseOffs, data + n, n2 * sizeof(short));
}
// set new write position for this channel
_arrWritePos[ch] = newWritePos;
_writePos[ch] = newWritePos;
}
void Oscilloscope::render(int x, int y) {
@ -98,20 +100,20 @@ void Oscilloscope::render(int x, int y) {
return;
}
// determine lowpass / downsample factors
int lowpass = -int(std::numeric_limits<short>::min()) * _valLowpass;
unsigned downsample = _valDownsample;
// fetch low pass factor (and convert to fix point) / downsample factor
int lowPassFixPt = -int(std::numeric_limits<short>::min()) * _lowPassCoeff;
unsigned downsample = _downsampleRatio;
// keep half of the buffer for writing and ensure an even vertex count
unsigned usedWidth = min(_valWidth, MAX_SAMPLES_PER_CHANNEL / (downsample * 2)) & ~1u;
unsigned usedWidth = min(_width, MAX_SAMPLES_PER_CHANNEL / (downsample * 2)) & ~1u;
unsigned usedSamples = usedWidth * downsample;
// expand samples to vertex data
for (unsigned ch = 0; ch < MAX_CHANNELS; ++ch) {
// for each channel: determine memory regions
short const* basePtr = _arrSamples + MAX_SAMPLES_PER_CHANNEL * ch;
short const* basePtr = _samples + MAX_SAMPLES_PER_CHANNEL * ch;
short const* endPtr = basePtr + MAX_SAMPLES_PER_CHANNEL;
short const* inPtr = _arrSamples + _arrWritePos[ch];
short* outPtr = _arrVertices + MAX_COORDS_PER_CHANNEL * ch;
short const* inPtr = _samples + _writePos[ch];
short* outPtr = _vertices + MAX_COORDS_PER_CHANNEL * ch;
int sample = 0, x = usedWidth;
for (int i = int(usedSamples); --i >= 0 ;) {
if (inPtr == basePtr) {
@ -119,7 +121,7 @@ void Oscilloscope::render(int x, int y) {
inPtr = endPtr;
}
// read and (eventually) filter sample
sample += ((*--inPtr - sample) * lowpass) >> 15;
sample += ((*--inPtr - sample) * lowPassFixPt) >> 15;
// write every nth as y with a corresponding x-coordinate
if (i % downsample == 0) {
*outPtr++ = short(--x);
@ -128,13 +130,13 @@ void Oscilloscope::render(int x, int y) {
}
}
// set up rendering state (vertex data lives at _arrVertices)
// set up rendering state (vertex data lives at _vertices)
glLineWidth(1.0);
glDisable(GL_LINE_SMOOTH);
glPushMatrix();
glTranslatef((float)x + 0.0f, (float)y + _valHeight / 2.0f, 0.0f);
glScaled(1.0f, _valHeight / 32767.0f, 1.0f);
glVertexPointer(2, GL_SHORT, 0, _arrVertices);
glTranslatef((float)x + 0.0f, (float)y + _height / 2.0f, 0.0f);
glScaled(1.0f, _height / 32767.0f, 1.0f);
glVertexPointer(2, GL_SHORT, 0, _vertices);
glEnableClientState(GL_VERTEX_ARRAY);
// render channel 0

52
interface/src/Oscilloscope.h
View file

@ -17,17 +17,43 @@ public:
~Oscilloscope();
void addSamples(unsigned ch, short const* data, unsigned n);
void render(int x, int y);
static unsigned const MAX_CHANNELS = 3;
static unsigned const MAX_SAMPLES_PER_CHANNEL = 4096;
// Switches: On/Off, Stop Time
volatile bool enabled;
volatile bool inputPaused;
void setLowpass(float w) { assert(w > 0.0f && w <= 1.0f); _valLowpass = w; }
void setDownsampling(unsigned f) { assert(f > 0); _valDownsample = f; }
// Limits
static unsigned const MAX_CHANNELS = 3;
static unsigned const MAX_SAMPLES_PER_CHANNEL = 4096;
// Controls a simple one pole IIR low pass filter that is provided to
// reduce high frequencies aliasing (to lower ones) when downsampling.
//
// The parameter sets the influence of the input in respect to the
// feed-back signal on the output.
//
// +---------+
// in O--------------|+ ideal |--o--------------O out
// .---|- op amp | |
// | +---------+ |
// | |
// o-------||-------o
// | |
// | __V__
// -------------|_____|-------+
// : : |
// 0.0 - 1.0 (GND)
//
// The values in range 0.0 - 1.0 correspond to "all closed" (input has
// no influence on the output) to "all open" (feedback has no influence
// on the output) configurations.
void setLowpassOpenness(float w) { assert(w >= 0.0f && w <= 1.0f); _lowPassCoeff = w; }
// Sets the number of input samples per output sample. Without filtering
// just uses every nTh sample.
void setDownsampleRatio(unsigned n) { assert(n > 0); _downsampleRatio = n; }
private:
// don't copy/assign
@ -36,14 +62,14 @@ private:
// state variables
unsigned _valWidth;
unsigned _valHeight;
short* _arrSamples;
short* _arrVertices;
unsigned _arrWritePos[MAX_CHANNELS];
unsigned _width;
unsigned _height;
short* _samples;
short* _vertices;
unsigned _writePos[MAX_CHANNELS];
float _valLowpass;
unsigned _valDownsample;
float _lowPassCoeff;
unsigned _downsampleRatio;
};
#endif /* defined(__interface__oscilloscope__) */

14
interface/src/Stars.cpp
View file

@ -14,24 +14,24 @@
#undef __interface__Starfield_impl__
Stars::Stars() :
_ptrController(0l) {
_ptrController = new starfield::Controller;
_controller(0l) {
_controller = new starfield::Controller;
}
Stars::~Stars() {
delete _ptrController;
delete _controller;
}
bool Stars::readInput(const char* url, const char* cacheFile, unsigned limit) {
return _ptrController->readInput(url, cacheFile, limit);
return _controller->readInput(url, cacheFile, limit);
}
bool Stars::setResolution(unsigned k) {
return _ptrController->setResolution(k);
return _controller->setResolution(k);
}
float Stars::changeLOD(float fraction, float overalloc, float realloc) {
return float(_ptrController->changeLOD(fraction, overalloc, realloc));
return float(_controller->changeLOD(fraction, overalloc, realloc));
}
void Stars::render(float fovY, float aspect, float nearZ, float alpha) {
@ -46,7 +46,7 @@ void Stars::render(float fovY, float aspect, float nearZ, float alpha) {
// pull the modelview matrix off the GL stack
glm::mat4 view; glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(view));
_ptrController->render(fovDiagonal, aspect, glm::affineInverse(view), alpha);
_controller->render(fovDiagonal, aspect, glm::affineInverse(view), alpha);
}

8
interface/src/Stars.h
View file

@ -17,11 +17,7 @@ namespace starfield { class Controller; }
// Starfield rendering component.
//
class Stars {
starfield::Controller* _ptrController;
public:
Stars();
~Stars();
@ -73,6 +69,10 @@ class Stars {
// don't copy/assign
Stars(Stars const&); // = delete;
Stars& operator=(Stars const&); // delete;
// variables
starfield::Controller* _controller;
};

2
interface/src/VoxelSystem.cpp
View file

@ -659,7 +659,7 @@ void VoxelSystem::render(bool texture) {
// draw the number of voxels we have
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboIndicesID);
glScalef(TREE_SCALE, TREE_SCALE, TREE_SCALE);
glDrawRangeElementsEXT(GL_TRIANGLES, 0, VERTICES_PER_VOXEL * _voxelsInReadArrays,
glDrawRangeElementsEXT(GL_TRIANGLES, 0, VERTICES_PER_VOXEL * _voxelsInReadArrays - 1,
36 * _voxelsInReadArrays, GL_UNSIGNED_INT, 0);
glEnable(GL_BLEND);

2
interface/src/starfield/Config.h
View file

@ -38,7 +38,7 @@
//
#include "InterfaceConfig.h"
#include "OGlProgram.h"
#include "renderer/ProgramObject.h"
#include "Log.h"
#include <cstddef>

284
interface/src/starfield/Controller.h
View file

@ -55,60 +55,26 @@
namespace starfield {
class Controller {
InputVertices _seqInput;
#if STARFIELD_MULTITHREADING
mutex _mtxInput;
atomic<unsigned> _valTileResolution;
mutex _mtxLodState;
#else
unsigned _valTileResolution;
#endif
double _valLodFraction;
double _valLodLowWaterMark;
double _valLodHighWaterMark;
double _valLodOveralloc;
size_t _valLodNalloc;
size_t _valLodNrender;
BrightnessLevels _seqLodBrightness;
#if STARFIELD_MULTITHREADING
atomic<BrightnessLevel> _valLodBrightness;
BrightnessLevel _valLodAllocBrightness;
atomic<Renderer*> _ptrRenderer;
typedef lock_guard<mutex> lock;
#else
BrightnessLevel _valLodBrightness;
BrightnessLevel _valLodAllocBrightness;
Renderer* _ptrRenderer;
#define lock
#define _(x)
#endif
static inline size_t toBufSize(double f) {
return size_t(floor(f + 0.5f));
}
public:
Controller() :
_valTileResolution(20),
_valLodFraction(1.0),
_valLodLowWaterMark(0.8),
_valLodHighWaterMark(1.0),
_valLodOveralloc(1.2),
_valLodNalloc(0),
_valLodNrender(0),
_valLodBrightness(0),
_valLodAllocBrightness(0),
_ptrRenderer(0l) {
_tileResolution(20),
_lodFraction(1.0),
_lodLowWaterMark(0.8),
_lodHighWaterMark(1.0),
_lodOveralloc(1.2),
_lodNalloc(0),
_lodNRender(0),
_lodBrightness(0),
_lodAllocBrightness(0),
_renderer(0l) {
}
#if !STARFIELD_MULTITHREADING
#define lock
#define _(x)
#endif
bool readInput(const char* url, const char* cacheFile, unsigned limit)
{
InputVertices vertices;
@ -121,13 +87,13 @@ namespace starfield {
// input is read, now run the entire data pipeline on the new input
{ lock _(_mtxInput);
{ lock _(_inputMutex);
_seqInput.swap(vertices);
_inputSequence.swap(vertices);
#if STARFIELD_MULTITHREADING
unsigned k = _valTileResolution.load(memory_order_relaxed);
unsigned k = _tileResolution.load(memory_order_relaxed);
#else
unsigned k = _valTileResolution;
unsigned k = _tileResolution;
#endif
size_t n, nRender;
BrightnessLevel bMin, b;
@ -136,27 +102,27 @@ namespace starfield {
// we'll have to build a new LOD state for a new total N,
// ideally keeping allocation size and number of vertices
{ lock _(_mtxLodState);
{ lock _(_lodStateMutex);
size_t newLast = _seqInput.size() - 1;
size_t newLast = _inputSequence.size() - 1;
// reciprocal change N_old/N_new tells us how to scale
// the fractions
rcpChange = min(1.0, double(vertices.size()) / _seqInput.size());
rcpChange = min(1.0, double(vertices.size()) / _inputSequence.size());
// initialization? use defaults / previously set values
if (rcpChange == 0.0) {
rcpChange = 1.0;
nRender = toBufSize(_valLodFraction * newLast);
n = min(newLast, toBufSize(_valLodOveralloc * nRender));
nRender = toBufSize(_lodFraction * newLast);
n = min(newLast, toBufSize(_lodOveralloc * nRender));
} else {
// cannot allocate or render more than we have
n = min(newLast, _valLodNalloc);
nRender = min(newLast, _valLodNrender);
n = min(newLast, _lodNalloc);
nRender = min(newLast, _lodNRender);
}
// determine new minimum brightness levels
@ -178,26 +144,26 @@ namespace starfield {
} catch (...) {
// rollback transaction and rethrow
vertices.swap(_seqInput);
vertices.swap(_inputSequence);
throw;
}
// finally publish the new LOD state
{ lock _(_mtxLodState);
{ lock _(_lodStateMutex);
_seqLodBrightness.swap(brightness);
_valLodFraction *= rcpChange;
_valLodLowWaterMark *= rcpChange;
_valLodHighWaterMark *= rcpChange;
_valLodOveralloc *= rcpChange;
_valLodNalloc = n;
_valLodNrender = nRender;
_valLodAllocBrightness = bMin;
_lodBrightnessSequence.swap(brightness);
_lodFraction *= rcpChange;
_lodLowWaterMark *= rcpChange;
_lodHighWaterMark *= rcpChange;
_lodOveralloc *= rcpChange;
_lodNalloc = n;
_lodNRender = nRender;
_lodAllocBrightness = bMin;
#if STARFIELD_MULTITHREADING
_valLodBrightness.store(b, memory_order_relaxed);
_lodBrightness.store(b, memory_order_relaxed);
#else
_valLodBrightness = b;
_lodBrightness = b;
#endif
}
}
@ -214,24 +180,24 @@ namespace starfield {
// printLog("Stars.cpp: setResolution(%d)\n", k);
#if STARFIELD_MULTITHREADING
if (k != _valTileResolution.load(memory_order_relaxed))
if (k != _tileResolution.load(memory_order_relaxed))
#else
if (k != _valTileResolution)
if (k != _tileResolution)
#endif
{ lock _(_mtxInput);
{ lock _(_inputMutex);
unsigned n;
BrightnessLevel b, bMin;
{ lock _(_mtxLodState);
{ lock _(_lodStateMutex);
n = _valLodNalloc;
n = _lodNalloc;
#if STARFIELD_MULTITHREADING
b = _valLodBrightness.load(memory_order_relaxed);
b = _lodBrightness.load(memory_order_relaxed);
#else
b = _valLodBrightness;
b = _lodBrightness;
#endif
bMin = _valLodAllocBrightness;
bMin = _lodAllocBrightness;
}
this->retile(n, k, b, bMin);
@ -242,25 +208,6 @@ namespace starfield {
}
}
private:
void retile(size_t n, unsigned k,
BrightnessLevel b, BrightnessLevel bMin) {
Tiling tiling(k);
VertexOrder scanner(tiling);
radix2InplaceSort(_seqInput.begin(), _seqInput.end(), scanner);
// printLog(
// "Stars.cpp: recreateRenderer(%d, %d, %d, %d)\n", n, k, b, bMin);
recreateRenderer(n, k, b, bMin);
_valTileResolution = k;
}
public:
double changeLOD(double factor, double overalloc, double realloc) {
assert(overalloc >= realloc && realloc >= 0.0);
@ -273,13 +220,13 @@ namespace starfield {
BrightnessLevel bMin, b;
double fraction, lwm, hwm;
{ lock _(_mtxLodState);
{ lock _(_lodStateMutex);
// acuire a consistent copy of the current LOD state
fraction = _valLodFraction;
lwm = _valLodLowWaterMark;
hwm = _valLodHighWaterMark;
size_t last = _seqLodBrightness.size() - 1;
fraction = _lodFraction;
lwm = _lodLowWaterMark;
hwm = _lodHighWaterMark;
size_t last = _lodBrightnessSequence.size() - 1;
// apply factor
fraction = max(0.0, min(1.0, fraction * factor));
@ -288,23 +235,23 @@ namespace starfield {
// threshold
double oaFract = std::min(fraction * (1.0 + overalloc), 1.0);
n = toBufSize(oaFract * last);
bMin = _seqLodBrightness[n];
bMin = _lodBrightnessSequence[n];
n = std::upper_bound(
_seqLodBrightness.begin() + n - 1,
_seqLodBrightness.end(),
bMin, GreaterBrightness() ) - _seqLodBrightness.begin();
_lodBrightnessSequence.begin() + n - 1,
_lodBrightnessSequence.end(),
bMin, GreaterBrightness() ) - _lodBrightnessSequence.begin();
// also determine number of vertices to render and brightness
nRender = toBufSize(fraction * last);
// Note: nRender does not have to be accurate
b = _seqLodBrightness[nRender];
b = _lodBrightnessSequence[nRender];
// this setting controls the renderer, also keep b as the
// brightness becomes volatile as soon as the mutex is
// released, so keep b
#if STARFIELD_MULTITHREADING
_valLodBrightness.store(b, memory_order_relaxed);
_lodBrightness.store(b, memory_order_relaxed);
#else
_valLodBrightness = b;
_lodBrightness = b;
#endif
// printLog("Stars.cpp: "
@ -313,69 +260,54 @@ namespace starfield {
// will not have to reallocate? set new fraction right away
// (it is consistent with the rest of the state in this case)
if (fraction >= _valLodLowWaterMark
&& fraction <= _valLodHighWaterMark) {
if (fraction >= _lodLowWaterMark
&& fraction <= _lodHighWaterMark) {
_valLodFraction = fraction;
_lodFraction = fraction;
return fraction;
}
}
// reallocate
{ lock _(_mtxInput);
{ lock _(_inputMutex);
recreateRenderer(n, _valTileResolution, b, bMin);
recreateRenderer(n, _tileResolution, b, bMin);
// printLog("Stars.cpp: LOD reallocation\n");
// publish new lod state
{ lock _(_mtxLodState);
{ lock _(_lodStateMutex);
_valLodNalloc = n;
_valLodNrender = nRender;
_lodNalloc = n;
_lodNRender = nRender;
_valLodFraction = fraction;
_valLodLowWaterMark = fraction * (1.0 - realloc);
_valLodHighWaterMark = fraction * (1.0 + realloc);
_valLodOveralloc = fraction * (1.0 + overalloc);
_valLodAllocBrightness = bMin;
_lodFraction = fraction;
_lodLowWaterMark = fraction * (1.0 - realloc);
_lodHighWaterMark = fraction * (1.0 + realloc);
_lodOveralloc = fraction * (1.0 + overalloc);
_lodAllocBrightness = bMin;
}
}
return fraction;
}
private:
void recreateRenderer(size_t n, unsigned k,
BrightnessLevel b, BrightnessLevel bMin) {
#if STARFIELD_MULTITHREADING
delete _ptrRenderer.exchange(new Renderer(_seqInput, n, k, b, bMin) );
#else
delete _ptrRenderer;
_ptrRenderer = new Renderer(_seqInput, n, k, b, bMin);
#endif
}
public:
void render(float perspective, float angle, mat4 const& orientation, float alpha) {
#if STARFIELD_MULTITHREADING
// check out renderer
Renderer* renderer = _ptrRenderer.exchange(0l);
Renderer* renderer = _renderer.exchange(0l);
#else
Renderer* renderer = _ptrRenderer;
Renderer* renderer = _renderer;
#endif
// have it render
if (renderer != 0l) {
#if STARFIELD_MULTITHREADING
BrightnessLevel b = _valLodBrightness.load(memory_order_relaxed);
BrightnessLevel b = _lodBrightness.load(memory_order_relaxed);
#else
BrightnessLevel b = _valLodBrightness;
BrightnessLevel b = _lodBrightness;
#endif
renderer->render(perspective, angle, orientation, b, alpha);
}
@ -383,7 +315,7 @@ namespace starfield {
#if STARFIELD_MULTITHREADING
// check in - or dispose if there is a new one
Renderer* newOne = 0l;
if (! _ptrRenderer.compare_exchange_strong(newOne, renderer)) {
if (! _renderer.compare_exchange_strong(newOne, renderer)) {
assert(!! newOne);
delete renderer;
@ -396,6 +328,37 @@ namespace starfield {
private:
void retile(size_t n, unsigned k,
BrightnessLevel b, BrightnessLevel bMin) {
Tiling tiling(k);
VertexOrder scanner(tiling);
radix2InplaceSort(_inputSequence.begin(), _inputSequence.end(), scanner);
// printLog(
// "Stars.cpp: recreateRenderer(%d, %d, %d, %d)\n", n, k, b, bMin);
recreateRenderer(n, k, b, bMin);
_tileResolution = k;
}
void recreateRenderer(size_t n, unsigned k,
BrightnessLevel b, BrightnessLevel bMin) {
#if STARFIELD_MULTITHREADING
delete _renderer.exchange(new Renderer(_inputSequence, n, k, b, bMin) );
#else
delete _renderer;
_renderer = new Renderer(_inputSequence, n, k, b, bMin);
#endif
}
static inline size_t toBufSize(double f) {
return size_t(floor(f + 0.5f));
}
struct BrightnessSortScanner : Radix2IntegerScanner<BrightnessLevel> {
typedef Radix2IntegerScanner<BrightnessLevel> base;
@ -420,6 +383,39 @@ namespace starfield {
radix2InplaceSort(dst.begin(), dst.end(), BrightnessSortScanner());
}
InputVertices _inputSequence;
#if STARFIELD_MULTITHREADING
mutex _inputMutex;
atomic<unsigned> _tileResolution;
mutex _lodStateMutex;
#else
unsigned _tileResolution;
#endif
double _lodFraction;
double _lodLowWaterMark;
double _lodHighWaterMark;
double _lodOveralloc;
size_t _lodNalloc;
size_t _lodNRender;
BrightnessLevels _lodBrightnessSequence;
#if STARFIELD_MULTITHREADING
atomic<BrightnessLevel> _lodBrightness;
BrightnessLevel _lodAllocBrightness;
atomic<Renderer*> _renderer;
typedef lock_guard<mutex> lock;
#else
BrightnessLevel _lodBrightness;
BrightnessLevel _lodAllocBrightness;
Renderer* _renderer;
#undef lock
#undef _
#endif
};
}

75
interface/src/starfield/Loader.h
View file

@ -23,42 +23,32 @@
namespace starfield {
class Loader : UrlReader {
InputVertices* _ptrVertices;
unsigned _valLimit;
unsigned _valLineNo;
char const* _strUrl;
unsigned _valRecordsRead;
BrightnessLevel _valMinBrightness;
public:
bool loadVertices(
InputVertices& destination, char const* url, char const* cacheFile, unsigned limit)
{
_ptrVertices = & destination;
_valLimit = limit;
_vertices = & destination;
_limit = limit;
#if STARFIELD_SAVE_MEMORY
if (_valLimit == 0 || _valLimit > 60000u)
_valLimit = 60000u;
if (_limit == 0 || _limit > 60000u)
_limit = 60000u;
#endif
_strUrl = url; // in case we fail early
_urlStr = url; // in case we fail early
if (! UrlReader::readUrl(url, *this, cacheFile))
{
printLog("%s:%d: %s\n",
_strUrl, _valLineNo, getError());
_urlStr, _lineNo, getError());
return false;
}
printLog("Loaded %u stars.\n", _valRecordsRead);
printLog("Loaded %u stars.\n", _recordsRead);
return true;
}
protected:
friend class UrlReader;
void begin(char const* url,
@ -66,13 +56,13 @@ namespace starfield {
int64_t size,
int64_t stardate) {
_valLineNo = 0u;
_strUrl = url; // new value in http redirect
_lineNo = 0u;
_urlStr = url; // new value in http redirect
_valRecordsRead = 0u;
_recordsRead = 0u;
_ptrVertices->clear();
_ptrVertices->reserve(_valLimit);
_vertices->clear();
_vertices->reserve(_limit);
// printLog("Stars.cpp: loader begin %s\n", url);
}
@ -88,7 +78,7 @@ namespace starfield {
for (; next != end && isspace(*next); ++next);
consumed = next - input;
line = next;
++_valLineNo;
++_lineNo;
for (; next != end && *next != '\n' && *next != '\r'; ++next);
if (next == end)
return consumed;
@ -109,12 +99,12 @@ namespace starfield {
storeVertex(azi, alt, c);
}
++_valRecordsRead;
++_recordsRead;
} else {
printLog("Stars.cpp:%d: Bad input from %s\n",
_valLineNo, _strUrl);
_lineNo, _urlStr);
}
}
@ -126,7 +116,7 @@ namespace starfield {
private:
bool atLimit() { return _valLimit > 0u && _valRecordsRead >= _valLimit; }
bool atLimit() { return _limit > 0u && _recordsRead >= _limit; }
bool spaceFor(BrightnessLevel b) {
@ -136,44 +126,55 @@ namespace starfield {
// just reached the limit? -> establish a minimum heap and
// remember the brightness at its top
if (_valRecordsRead == _valLimit) {
if (_recordsRead == _limit) {
// printLog("Stars.cpp: vertex limit reached -> heap mode\n");
make_heap(
_ptrVertices->begin(), _ptrVertices->end(),
_vertices->begin(), _vertices->end(),
GreaterBrightness() );
_valMinBrightness = getBrightness(
_ptrVertices->begin()->getColor() );
_minBrightness = getBrightness(
_vertices->begin()->getColor() );
}
// not interested? say so
if (_valMinBrightness >= b)
if (_minBrightness >= b)
return false;
// otherwise free up space for the new vertex
pop_heap(
_ptrVertices->begin(), _ptrVertices->end(),
_vertices->begin(), _vertices->end(),
GreaterBrightness() );
_ptrVertices->pop_back();
_vertices->pop_back();
return true;
}
void storeVertex(float azi, float alt, unsigned color) {
_ptrVertices->push_back(InputVertex(azi, alt, color));
_vertices->push_back(InputVertex(azi, alt, color));
if (atLimit()) {
push_heap(
_ptrVertices->begin(), _ptrVertices->end(),
_vertices->begin(), _vertices->end(),
GreaterBrightness() );
_valMinBrightness = getBrightness(
_ptrVertices->begin()->getColor() );
_minBrightness = getBrightness(
_vertices->begin()->getColor() );
}
}
// variables
InputVertices* _vertices;
unsigned _limit;
unsigned _lineNo;
char const* _urlStr;
unsigned _recordsRead;
BrightnessLevel _minBrightness;
};
} // anonymous namespace

16
interface/src/starfield/data/GpuVertex.h
View file

@ -18,18 +18,12 @@
namespace starfield {
class GpuVertex {
unsigned _valColor;
float _valX;
float _valY;
float _valZ;
public:
GpuVertex() { }
GpuVertex(InputVertex const& in) {
_valColor = in.getColor();
_color = in.getColor();
float azi = in.getAzimuth();
float alt = in.getAltitude();
@ -44,7 +38,13 @@ namespace starfield {
_valZ = gz * exz;
}
unsigned getColor() const { return _valColor; }
unsigned getColor() const { return _color; }
private:
unsigned _color;
float _valX;
float _valY;
float _valZ;
};
} // anonymous namespace

21
interface/src/starfield/data/InputVertex.h
View file

@ -18,15 +18,11 @@
namespace starfield {
class InputVertex {
unsigned _valColor;
float _valAzimuth;
float _valAltitude;
public:
InputVertex(float azimuth, float altitude, unsigned color) {
_valColor = ((color >> 16) & 0xffu) | (color & 0xff00u) |
_color = ((color >> 16) & 0xffu) | (color & 0xff00u) |
((color << 16) & 0xff0000u) | 0xff000000u;
azimuth = angleConvert<Degrees,Radians>(azimuth);
@ -34,13 +30,18 @@ namespace starfield {
angleHorizontalPolar<Radians>(azimuth, altitude);
_valAzimuth = azimuth;
_valAltitude = altitude;
_azimuth = azimuth;
_altitude = altitude;
}
float getAzimuth() const { return _valAzimuth; }
float getAltitude() const { return _valAltitude; }
unsigned getColor() const { return _valColor; }
float getAzimuth() const { return _azimuth; }
float getAltitude() const { return _altitude; }
unsigned getColor() const { return _color; }
private:
unsigned _color;
float _azimuth;
float _altitude;
};
typedef std::vector<InputVertex> InputVertices;

1
interface/src/starfield/data/Tile.h
View file

@ -25,6 +25,7 @@ namespace starfield {
BrightnessLevel lod;
nuint flags;
// flags
static uint16_t const checked = 1;
static uint16_t const visited = 2;
static uint16_t const render = 4;

198
interface/src/starfield/renderer/Renderer.h
View file

@ -13,8 +13,6 @@
#error "This is an implementation file - not intended for direct inclusion."
#endif
#include "renderer/ProgramObject.h"
#include "starfield/Config.h"
#include "starfield/data/InputVertex.h"
#include "starfield/data/BrightnessLevel.h"
@ -66,22 +64,6 @@
namespace starfield {
class Renderer {
GpuVertex* _arrData;
Tile* _arrTile;
GLint* _arrBatchOffs;
GLsizei* _arrBatchCount;
GLuint _hndVertexArray;
ProgramObject _objProgram;
int _alphaLocation;
Tiling _objTiling;
unsigned* _itrOutIndex;
vec3 _vecWxform;
float _valHalfPersp;
BrightnessLevel _valMinBright;
public:
Renderer(InputVertices const& src,
@ -90,9 +72,9 @@ namespace starfield {
BrightnessLevel b,
BrightnessLevel bMin) :
_arrData(0l),
_arrTile(0l),
_objTiling(k) {
_dataArray(0l),
_tileArray(0l),
_tiling(k) {
this->glAlloc();
@ -103,10 +85,10 @@ namespace starfield {
// REVISIT: batch arrays are probably oversized, but - hey - they
// are not very large (unless for insane tiling) and we're better
// off safe than sorry
_arrData = new GpuVertex[n];
_arrTile = new Tile[nTiles + 1];
_arrBatchOffs = new GLint[nTiles * 2];
_arrBatchCount = new GLsizei[nTiles * 2];
_dataArray = new GpuVertex[n];
_tileArray = new Tile[nTiles + 1];
_batchOffs = new GLint[nTiles * 2];
_batchCountArray = new GLsizei[nTiles * 2];
prepareVertexData(src, n, tiling, b, bMin);
@ -115,10 +97,10 @@ namespace starfield {
~Renderer() {
delete[] _arrData;
delete[] _arrTile;
delete[] _arrBatchCount;
delete[] _arrBatchOffs;
delete[] _dataArray;
delete[] _tileArray;
delete[] _batchCountArray;
delete[] _batchOffs;
this->glFree();
}
@ -174,30 +156,31 @@ namespace starfield {
matrix = glm::frustum(-hw,hw, -hh,hh, nearClip,10.0f) * glm::affineInverse(matrix);
this->_itrOutIndex = (unsigned*) _arrBatchOffs;
this->_vecWxform = vec3(row(matrix, 3));
this->_valHalfPersp = halfPersp;
this->_valMinBright = minBright;
this->_outIndexPos = (unsigned*) _batchOffs;
this->_wRowVec = vec3(row(matrix, 3));
this->_halfPerspectiveAngle = halfPersp;
this->_minBright = minBright;
TileSelection::Cursor cursor;
cursor.current = _arrTile + _objTiling.getTileIndex(azimuth, altitude);
cursor.firstInRow = _arrTile + _objTiling.getTileIndex(0.0f, altitude);
cursor.current = _tileArray + _tiling.getTileIndex(azimuth, altitude);
cursor.firstInRow = _tileArray + _tiling.getTileIndex(0.0f, altitude);
floodFill(cursor, TileSelection(*this, _arrTile, _arrTile + _objTiling.getTileCount(),
(TileSelection::Cursor*) _arrBatchCount));
floodFill(cursor, TileSelection(*this, _tileArray, _tileArray + _tiling.getTileCount(),
(TileSelection::Cursor*) _batchCountArray));
#if STARFIELD_DEBUG_CULLING
# define matrix matrix_debug
#endif
this->glBatch(glm::value_ptr(matrix), prepareBatch(
(unsigned*) _arrBatchOffs, _itrOutIndex), alpha);
(unsigned*) _batchOffs, _outIndexPos), alpha);
#if STARFIELD_DEBUG_CULLING
# undef matrix
#endif
}
private: // renderer construction
private:
// renderer construction
void prepareVertexData(InputVertices const& src,
size_t n, // <-- at bMin and brighter
@ -208,9 +191,9 @@ namespace starfield {
size_t nTiles = tiling.getTileCount();
size_t vertexIndex = 0u, currTileIndex = 0u, count_active = 0u;
_arrTile[0].offset = 0u;
_arrTile[0].lod = b;
_arrTile[0].flags = 0u;
_tileArray[0].offset = 0u;
_tileArray[0].lod = b;
_tileArray[0].flags = 0u;
for (InputVertices::const_iterator i =
src.begin(), e = src.end(); i != e; ++i) {
@ -227,8 +210,8 @@ namespace starfield {
// moved on to another tile? -> flush
if (tileIndex != currTileIndex) {
Tile* t = _arrTile + currTileIndex;
Tile* tLast = _arrTile + tileIndex;
Tile* t = _tileArray + currTileIndex;
Tile* tLast = _tileArray + tileIndex;
// set count of active vertices (upcoming lod)
t->count = count_active;
@ -253,21 +236,20 @@ namespace starfield {
// printLog("Stars.cpp: Vertex %d on tile #%d\n", vertexIndex, tileIndex);
// write converted vertex
_arrData[vertexIndex++] = *i;
_dataArray[vertexIndex++] = *i;
}
}
assert(vertexIndex == n);
// flush last tile (see above)
Tile* t = _arrTile + currTileIndex;
Tile* t = _tileArray + currTileIndex;
t->count = count_active;
for (Tile* e = _arrTile + nTiles + 1; ++t != e;) {
for (Tile* e = _tileArray + nTiles + 1; ++t != e;) {
t->offset = vertexIndex, t->count = 0u,
t->lod = b, t->flags = 0;
}
}
private: // FOV culling / LOD
// FOV culling / LOD
class TileSelection;
friend class Renderer::TileSelection;
@ -277,22 +259,22 @@ namespace starfield {
public:
struct Cursor { Tile* current, * firstInRow; };
private:
Renderer& _refRenderer;
Cursor* const _arrStack;
Cursor* _itrStack;
Tile const* const _arrTile;
Tile const* const _ptrTilesEnd;
Renderer& _rendererRef;
Cursor* const _stackArray;
Cursor* _stackPos;
Tile const* const _tileArray;
Tile const* const _tilesEnd;
public:
TileSelection(Renderer& renderer, Tile const* tiles,
Tile const* tiles_end, Cursor* stack) :
_refRenderer(renderer),
_arrStack(stack),
_itrStack(stack),
_arrTile(tiles),
_ptrTilesEnd(tiles_end) {
_rendererRef(renderer),
_stackArray(stack),
_stackPos(stack),
_tileArray(tiles),
_tilesEnd(tiles_end) {
}
protected:
@ -302,7 +284,7 @@ namespace starfield {
bool select(Cursor const& c) {
Tile* t = c.current;
if (t < _arrTile || t >= _ptrTilesEnd ||
if (t < _tileArray || t >= _tilesEnd ||
!! (t->flags & Tile::checked)) {
// out of bounds or been here already
@ -311,7 +293,7 @@ namespace starfield {
// will check now and never again
t->flags |= Tile::checked;
if (_refRenderer.visitTile(t)) {
if (_rendererRef.visitTile(t)) {
// good one -> remember (for batching) and propagate
t->flags |= Tile::render;
@ -334,39 +316,39 @@ namespace starfield {
void right(Cursor& c) const {
c.current += 1;
if (c.current == c.firstInRow + _refRenderer._objTiling.getAzimuthalTiles()) {
if (c.current == c.firstInRow + _rendererRef._tiling.getAzimuthalTiles()) {
c.current = c.firstInRow;
}
}
void left(Cursor& c) const {
if (c.current == c.firstInRow) {
c.current = c.firstInRow + _refRenderer._objTiling.getAzimuthalTiles();
c.current = c.firstInRow + _rendererRef._tiling.getAzimuthalTiles();
}
c.current -= 1;
}
void up(Cursor& c) const {
unsigned d = _refRenderer._objTiling.getAzimuthalTiles();
unsigned d = _rendererRef._tiling.getAzimuthalTiles();
c.current += d;
c.firstInRow += d;
}
void down(Cursor& c) const {
unsigned d = _refRenderer._objTiling.getAzimuthalTiles();
unsigned d = _rendererRef._tiling.getAzimuthalTiles();
c.current -= d;
c.firstInRow -= d;
}
void defer(Cursor const& t) {
*_itrStack++ = t;
*_stackPos++ = t;
}
bool deferred(Cursor& cursor) {
if (_itrStack != _arrStack) {
cursor = *--_itrStack;
if (_stackPos != _stackArray) {
cursor = *--_stackPos;
return true;
}
return false;
@ -375,35 +357,35 @@ namespace starfield {
bool visitTile(Tile* t) {
unsigned index = t - _arrTile;
*_itrOutIndex++ = index;
unsigned index = t - _tileArray;
*_outIndexPos++ = index;
if (! tileVisible(t, index)) {
return false;
}
if (t->lod != _valMinBright) {
updateVertexCount(t, _valMinBright);
if (t->lod != _minBright) {
updateVertexCount(t, _minBright);
}
return true;
}
bool tileVisible(Tile* t, unsigned i) {
float slice = _objTiling.getSliceAngle();
float slice = _tiling.getSliceAngle();
float halfSlice = 0.5f * slice;
unsigned stride = _objTiling.getAzimuthalTiles();
unsigned stride = _tiling.getAzimuthalTiles();
float azimuth = (i % stride) * slice;
float altitude = (i / stride) * slice - Radians::halfPi();
float gx = sin(azimuth);
float gz = -cos(azimuth);
float exz = cos(altitude);
vec3 tileCenter = vec3(gx * exz, sin(altitude), gz * exz);
float w = dot(_vecWxform, tileCenter);
float w = dot(_wRowVec, tileCenter);
float daz = halfSlice * cos(std::max(0.0f, abs(altitude) - halfSlice));
float dal = halfSlice;
float adjustedNear = cos(_valHalfPersp + sqrt(daz * daz + dal * dal));
float adjustedNear = cos(_halfPerspectiveAngle + sqrt(daz * daz + dal * dal));
// printLog("Stars.cpp: checking tile #%d, w = %f, near = %f\n", i, w, nearClip);
@ -417,8 +399,8 @@ namespace starfield {
// perform a binary search in the so found partition for the
// new vertex count of this tile
GpuVertex const* start = _arrData + t[0].offset;
GpuVertex const* end = _arrData + t[1].offset;
GpuVertex const* start = _dataArray + t[0].offset;
GpuVertex const* end = _dataArray + t[1].offset;
assert(end >= start);
@ -433,9 +415,9 @@ namespace starfield {
end = std::upper_bound(
start, end, minBright, GreaterBrightness());
assert(end >= _arrData + t[0].offset);
assert(end >= _dataArray + t[0].offset);
t->count = end - _arrData - t[0].offset;
t->count = end - _dataArray - t[0].offset;
t->lod = minBright;
}
@ -443,13 +425,13 @@ namespace starfield {
unsigned const* indicesEnd) {
unsigned nRanges = 0u;
GLint* offs = _arrBatchOffs;
GLsizei* count = _arrBatchCount;
GLint* offs = _batchOffs;
GLsizei* count = _batchCountArray;
for (unsigned* i = (unsigned*) _arrBatchOffs;
for (unsigned* i = (unsigned*) _batchOffs;
i != indicesEnd; ++i) {
Tile* t = _arrTile + *i;
Tile* t = _tileArray + *i;
if ((t->flags & Tile::render) > 0u && t->count > 0u) {
*offs++ = t->offset;
@ -461,7 +443,7 @@ namespace starfield {
return nRanges;
}
private: // gl API handling
// GL API handling
void glAlloc() {
@ -478,28 +460,28 @@ namespace starfield {
" gl_PointSize = s;\n"
"}\n";
_objProgram.addShaderFromSourceCode(QGLShader::Vertex, VERTEX_SHADER);
_program.addShaderFromSourceCode(QGLShader::Vertex, VERTEX_SHADER);
GLchar const* const FRAGMENT_SHADER =
"#version 120\n"
"void main(void) {\n"
" gl_FragColor = gl_Color;\n"
"}\n";
_objProgram.addShaderFromSourceCode(QGLShader::Fragment, FRAGMENT_SHADER);
_objProgram.link();
_alphaLocation = _objProgram.uniformLocation("alpha");
_program.addShaderFromSourceCode(QGLShader::Fragment, FRAGMENT_SHADER);
_program.link();
_alphaLocationHandle = _program.uniformLocation("alpha");
glGenBuffersARB(1, & _hndVertexArray);
glGenBuffersARB(1, & _vertexArrayHandle);
}
void glFree() {
glDeleteBuffersARB(1, & _hndVertexArray);
glDeleteBuffersARB(1, & _vertexArrayHandle);
}
void glUpload(GLsizei n) {
glBindBufferARB(GL_ARRAY_BUFFER, _hndVertexArray);
glBindBufferARB(GL_ARRAY_BUFFER, _vertexArrayHandle);
glBufferData(GL_ARRAY_BUFFER,
n * sizeof(GpuVertex), _arrData, GL_STATIC_DRAW);
n * sizeof(GpuVertex), _dataArray, GL_STATIC_DRAW);
//glInterleavedArrays(GL_C4UB_V3F, sizeof(GpuVertex), 0l);
glBindBufferARB(GL_ARRAY_BUFFER, 0);
@ -511,7 +493,7 @@ namespace starfield {
// for (int i = 0; i < n_ranges; ++i)
// printLog("Stars.cpp: Batch #%d - %d stars @ %d\n", i,
// _arrBatchOffs[i], _arrBatchCount[i]);
// _batchOffs[i], _batchCountArray[i]);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
@ -533,24 +515,42 @@ namespace starfield {
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
// select shader and vertex array
_objProgram.bind();
_objProgram.setUniformValue(_alphaLocation, alpha);
glBindBufferARB(GL_ARRAY_BUFFER, _hndVertexArray);
_program.bind();
_program.setUniformValue(_alphaLocationHandle, alpha);
glBindBufferARB(GL_ARRAY_BUFFER, _vertexArrayHandle);
glInterleavedArrays(GL_C4UB_V3F, sizeof(GpuVertex), 0l);
// render
glMultiDrawArrays(GL_POINTS,
_arrBatchOffs, _arrBatchCount, n_ranges);
_batchOffs, _batchCountArray, n_ranges);
// restore state
glBindBufferARB(GL_ARRAY_BUFFER, 0);
_objProgram.release();
_program.release();
glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
glDisable(GL_POINT_SMOOTH);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
// variables
GpuVertex* _dataArray;
Tile* _tileArray;
GLint* _batchOffs;
GLsizei* _batchCountArray;
GLuint _vertexArrayHandle;
ProgramObject _program;
int _alphaLocationHandle;
Tiling _tiling;
unsigned* _outIndexPos;
vec3 _wRowVec;
float _halfPerspectiveAngle;
BrightnessLevel _minBright;
};
} // anonymous namespace

20
interface/src/starfield/renderer/Tiling.h
View file

@ -18,22 +18,17 @@
namespace starfield {
class Tiling {
unsigned _valK;
float _valRcpSlice;
unsigned _valBits;
public:
Tiling(unsigned k) :
_valK(k),
_valRcpSlice(k / Radians::twicePi()) {
_valBits = ceil(log(getTileCount()) * 1.4426950408889634); // log2
_rcpSlice(k / Radians::twicePi()) {
_nBits = ceil(log(getTileCount()) * 1.4426950408889634); // log2
}
unsigned getAzimuthalTiles() const { return _valK; }
unsigned getAltitudinalTiles() const { return _valK / 2 + 1; }
unsigned getTileIndexBits() const { return _valBits; }
unsigned getTileIndexBits() const { return _nBits; }
unsigned getTileCount() const {
return getAzimuthalTiles() * getAltitudinalTiles();
@ -45,14 +40,14 @@ namespace starfield {
}
float getSliceAngle() const {
return 1.0f / _valRcpSlice;
return 1.0f / _rcpSlice;
}
private:
unsigned discreteAngle(float unsigned_angle) const {
return unsigned(floor(unsigned_angle * _valRcpSlice + 0.5f));
return unsigned(floor(unsigned_angle * _rcpSlice + 0.5f));
}
unsigned discreteAzimuth(float a) const {
@ -64,6 +59,11 @@ namespace starfield {
discreteAngle(a + Radians::halfPi()) );
}
// variables
unsigned _valK;
float _rcpSlice;
unsigned _nBits;
};
} // anonymous namespace

13
interface/src/starfield/renderer/VertexOrder.h
View file

@ -25,25 +25,26 @@ namespace starfield {
*/
class VertexOrder : public Radix2IntegerScanner<unsigned>
{
Tiling _objTiling;
typedef Radix2IntegerScanner<unsigned> base;
public:
explicit VertexOrder(Tiling const& tiling) :
base(tiling.getTileIndexBits() + BrightnessBits),
_objTiling(tiling) {
_tiling(tiling) {
}
bool bit(InputVertex const& v, state_type const& s) const {
// inspect (tile_index, brightness) tuples
unsigned key = getBrightness(v.getColor()) ^ BrightnessMask;
key |= _objTiling.getTileIndex(
key |= _tiling.getTileIndex(
v.getAzimuth(), v.getAltitude()) << BrightnessBits;
return base::bit(key, s);
}
private:
Tiling _tiling;
typedef Radix2IntegerScanner<unsigned> base;
};
} // anonymous namespace

2
interface/src/ui/TextRenderer.h
View file

@ -15,6 +15,8 @@
#include <QImage>
#include <QVector>
#include "InterfaceConfig.h"
// a special "character" that renders as a solid block
const char SOLID_BLOCK_CHAR = 127;

4
libraries/avatars/src/AvatarData.cpp
View file

@ -14,10 +14,8 @@
#include <PacketHeaders.h>
#include "AvatarData.h"
#include "avatars_Log.h"
using namespace std;
using avatars_lib::printLog;
int packFloatAngleToTwoByte(unsigned char* buffer, float angle) {
const float ANGLE_CONVERSION_RATIO = (std::numeric_limits<uint16_t>::max() / 360.0);
@ -236,4 +234,4 @@ int AvatarData::parseData(unsigned char* sourceBuffer, int numBytes) {
_wantDelta = oneAtBit(wantItems,WANT_DELTA_AT_BIT);
return sourceBuffer - startPosition;
}
}

3
libraries/avatars/src/Orientation.cpp
View file

@ -7,9 +7,6 @@
#include "Orientation.h"
#include "SharedUtil.h"
//#include "avatars_Log.h"
//using avatars_lib::printLog;
static const bool USING_QUATERNIONS = true;

17
libraries/avatars/src/avatars_Log.cpp
View file

@ -1,17 +0,0 @@
//
// avatars_Log.cpp
// hifi
//
// Created by Tobias Schwinger on 4/17/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "shared_Log.h"
#include <cstdio>
namespace avatars_lib {
using namespace std;
int (* printLog)(char const*, ...) = & printf;
}

20
libraries/avatars/src/avatars_Log.h
View file

@ -1,20 +0,0 @@
//
// avatars_Log.h
// hifi
//
// Created by Tobias Schwinger on 4/17/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __hifi__avatars_Log__
#define __hifi__avatars_Log__
namespace avatars_lib {
// variable that can be set from outside to redirect the log output
// of this library
extern int (* printLog)(char const*, ...);
}
#endif /* defined(__hifi__avatars_Log__) */

6
libraries/shared/src/Agent.cpp
View file

@ -10,7 +10,7 @@
#include "Agent.h"
#include "AgentTypes.h"
#include <cstring>
#include "shared_Log.h"
#include "Log.h"
#include "UDPSocket.h"
#include "SharedUtil.h"
@ -20,8 +20,6 @@
#include <arpa/inet.h>
#endif
using shared_lib::printLog;
int unpackAgentId(unsigned char* packedData, uint16_t* agentId) {
memcpy(agentId, packedData, sizeof(uint16_t));
return sizeof(uint16_t);
@ -150,4 +148,4 @@ void Agent::printLog(Agent const& agent) {
agent._type,
publicAddressBuffer,
publicAddressPort);
}
}

4
libraries/shared/src/AgentList.cpp
View file

@ -15,7 +15,7 @@
#include "AgentTypes.h"
#include "PacketHeaders.h"
#include "SharedUtil.h"
#include "shared_Log.h"
#include "Log.h"
#ifdef _WIN32
#include "Syssocket.h"
@ -23,8 +23,6 @@
#include <arpa/inet.h>
#endif
using shared_lib::printLog;
const char SOLO_AGENT_TYPES[3] = {
AGENT_TYPE_AVATAR_MIXER,
AGENT_TYPE_AUDIO_MIXER,

10
libraries/voxels/src/voxels_Log.cpp → libraries/shared/src/Log.cpp
View file

@ -1,17 +1,15 @@
//
// voxels_Log.cpp
// Log.cpp
// hifi
//
// Created by Tobias Schwinger on 4/17/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "voxels_Log.h"
#include "Log.h"
#include <cstdio>
namespace voxels_lib {
using namespace std;
using namespace std;
int (* printLog)(char const*, ...) = & printf;
int (* printLog)(char const*, ...) = & printf;
}

15
libraries/shared/src/shared_Log.h → libraries/shared/src/Log.h
View file

@ -1,5 +1,5 @@
//
// shared_Log.h
// Log.h
// hifi
//
// Created by Tobias Schwinger on 4/17/13.
@ -9,12 +9,13 @@
#ifndef __hifi__shared_Log__
#define __hifi__shared_Log__
namespace shared_lib {
// variable that can be set from outside to redirect the log output
// of this library
extern int (* printLog)(char const*, ...);
}
//
// Pointer to log function
//
// An application may reset this variable to receive the log messages
// issued using 'printLog'. It defaults to a pointer to 'printf'.
//
extern int (* printLog)(char const*, ...);
#endif /* defined(__hifi__shared_Log__) */

4
libraries/shared/src/OctalCode.cpp
View file

@ -11,9 +11,7 @@
#include <cstring>
#include "SharedUtil.h"
#include "OctalCode.h"
#include "shared_Log.h"
using shared_lib::printLog;
#include "Log.h"
int numberOfThreeBitSectionsInCode(unsigned char * octalCode) {
if (*octalCode == 255) {

4
libraries/shared/src/PerfStat.cpp
View file

@ -14,9 +14,7 @@
#include <string>
#include <map>
#include "shared_Log.h"
using shared_lib::printLog;
#include "Log.h"
// Static class members initialization here!
std::map<std::string,PerfStatHistory,std::less<std::string> > PerfStat::groupHistoryMap;

4
libraries/shared/src/SharedUtil.cpp
View file

@ -14,7 +14,7 @@
#ifdef _WIN32
#include "Syssocket.h"
#endif
#include "shared_Log.h"
#include "Log.h"
#include "SharedUtil.h"
#include "OctalCode.h"
@ -22,8 +22,6 @@
#include <CoreFoundation/CoreFoundation.h>
#endif
using shared_lib::printLog;
double usecTimestamp(timeval *time) {
return (time->tv_sec * 1000000.0 + time->tv_usec);
}

4
libraries/shared/src/UDPSocket.cpp
View file

@ -21,9 +21,7 @@
#include <unistd.h>
#endif
#include "shared_Log.h"
using shared_lib::printLog;
#include "Log.h"
sockaddr_in destSockaddr, senderAddress;

191
libraries/shared/src/UrlReader.cpp
View file

@ -10,121 +10,166 @@
#include <new>
#ifdef _WIN32
#define NOCURL_IN_WINDOWS
#endif
#include <sys/types.h>
#include <sys/stat.h>
#ifndef NOCURL_IN_WINDOWS
#include <curl/curl.h>
size_t const UrlReader::max_read_ahead = CURL_MAX_WRITE_SIZE;
#else
size_t const UrlReader::max_read_ahead = 0;
#endif
#include "Log.h"
char const* const UrlReader::success = "UrlReader: Success!";
char const* const UrlReader::success_cached = "UrlReader:: Using local file.";
#ifndef _WIN32
// (Windows port is incomplete and the build files do not support CURL, yet)
#include <curl/curl.h>
//
// ATTENTION: A certain part of the implementation lives in inlined code
// (see the bottom of the header file).
//
// Why? Because it allows stream parsing without having to call around a
// lot (one static and one dynamic call per character if the parser just
// reads one character at a time).
//
// Here is an overview of the code structure:
//
// readUrl
// -> transferBegin (sets up state)
// -> perform (starts CURL transfer)
// -> (specialized, type-erased) callback_template
// -> getInfo (fetches HTTP header, eventually initiates caching)
// -> stream.begin (client code - called once)
// -> feedBuffered (the buffering logic)
// -> stream.transfer (client code - called repeatedly)
// -> stream.end (client code - called when the transfer is done)
// -> transferEnd (closes cache file, if used)
//
// "->" means "calls or inlines", here
//
size_t const UrlReader::max_read_ahead = CURL_MAX_WRITE_SIZE;
char const* const UrlReader::success = "UrlReader: Success!";
char const* const UrlReader::success_cached = "UrlReader: Using local file.";
char const* const UrlReader::error_init_failed = "UrlReader: Initialization failed.";
char const* const UrlReader::error_aborted = "UrlReader: Processing error.";
char const* const UrlReader::error_buffer_overflow = "UrlReader: Buffer overflow.";
char const* const UrlReader::error_leftover_input = "UrlReader: Incomplete processing.";
#define hnd_curl static_cast<CURL*>(_ptrImpl)
#define _curlPtr static_cast<CURL*>(_curlHandle)
UrlReader::UrlReader()
: _ptrImpl(0l), _arrXtra(0l), _strError(0l), _arrCacheRdBuf(0l) {
: _curlHandle(0l), _xtraBuffer(0l), _errorStr(0l), _cacheReadBuffer(0l) {
_arrXtra = new(std::nothrow) char[max_read_ahead];
if (! _arrXtra) { _strError = error_init_failed; return; }
#ifndef NOCURL_IN_WINDOWS
_ptrImpl = curl_easy_init();
if (! _ptrImpl) { _strError = error_init_failed; return; }
curl_easy_setopt(hnd_curl, CURLOPT_NOSIGNAL, 1l);
curl_easy_setopt(hnd_curl, CURLOPT_FAILONERROR, 1l);
curl_easy_setopt(hnd_curl, CURLOPT_FILETIME, 1l);
curl_easy_setopt(hnd_curl, CURLOPT_ENCODING, "");
#endif
_xtraBuffer = new(std::nothrow) char[max_read_ahead];
if (! _xtraBuffer) { _errorStr = error_init_failed; return; }
_curlHandle = curl_easy_init();
if (! _curlHandle) { _errorStr = error_init_failed; return; }
curl_easy_setopt(_curlPtr, CURLOPT_NOSIGNAL, 1l);
curl_easy_setopt(_curlPtr, CURLOPT_FAILONERROR, 1l);
curl_easy_setopt(_curlPtr, CURLOPT_FILETIME, 1l);
curl_easy_setopt(_curlPtr, CURLOPT_ENCODING, "");
}
UrlReader::~UrlReader() {
delete[] _arrXtra;
delete[] _arrCacheRdBuf;
#ifndef NOCURL_IN_WINDOWS
if (! hnd_curl) return;
curl_easy_cleanup(hnd_curl);
#endif
delete[] _xtraBuffer;
delete[] _cacheReadBuffer;
if (! _curlHandle) {
return;
}
curl_easy_cleanup(_curlPtr);
}
bool UrlReader::perform(char const* url, transfer_callback* cb) {
#ifndef NOCURL_IN_WINDOWS
void UrlReader::perform(char const* url, transfer_callback* cb) {
curl_easy_setopt(hnd_curl, CURLOPT_URL, url);
curl_easy_setopt(hnd_curl, CURLOPT_WRITEFUNCTION, cb);
curl_easy_setopt(hnd_curl, CURLOPT_WRITEDATA, this);
curl_easy_setopt(_curlPtr, CURLOPT_URL, url);
curl_easy_setopt(_curlPtr, CURLOPT_WRITEFUNCTION, cb);
curl_easy_setopt(_curlPtr, CURLOPT_WRITEDATA, this);
CURLcode rc = curl_easy_perform(hnd_curl);
CURLcode rc = curl_easy_perform(_curlPtr);
if (rc == CURLE_OK)
{
while (_valXtraSize > 0 && _strError == success)
while (_xtraSize > 0 && _errorStr == success)
cb(0l, 0, 0, this);
}
else if (_strError == success)
_strError = curl_easy_strerror(rc);
return rc == CURLE_OK;
#else
return false;
#endif
else if (_errorStr == success)
_errorStr = curl_easy_strerror(rc);
}
void UrlReader::getinfo(char const*& url,
char const*& type, int64_t& length, int64_t& stardate) {
#ifndef NOCURL_IN_WINDOWS
void UrlReader::transferBegin(void* stream, char const* cacheFile) {
_errorStr = success;
_streamPtr = stream;
_cacheFileName = cacheFile;
_cacheFile = 0l;
_cacheMode = no_cache;
_xtraSize = ~size_t(0);
}
void UrlReader::getInfo(char const*& url,
char const*& type, int64_t& length, int64_t& stardate) {
// fetch information from HTTP header
double clen;
long time;
curl_easy_getinfo(hnd_curl, CURLINFO_FILETIME, & time);
curl_easy_getinfo(_curlPtr, CURLINFO_FILETIME, & time);
curl_easy_getinfo(_curlPtr, CURLINFO_EFFECTIVE_URL, & url);
curl_easy_getinfo(_curlPtr, CURLINFO_CONTENT_TYPE, & type);
curl_easy_getinfo(_curlPtr, CURLINFO_CONTENT_LENGTH_DOWNLOAD, & clen);
length = static_cast<int64_t>(clen);
curl_easy_getinfo(_curlPtr, CURLINFO_FILETIME, & time);
stardate = time;
// printLog("UrlReader: Ready to transfer from URL '%s'\n", url);
// check caching file time whether we actually want to download anything
if (_strCacheFile != 0l) {
if (_cacheFileName != 0l) {
struct stat s;
stat(_strCacheFile, & s);
stat(_cacheFileName, & s);
if (time > s.st_mtime) {
// file on server is newer -> update cache file
_ptrCacheFile = fopen(_strCacheFile, "wb");
printf("From URL: ");
if (_ptrCacheFile != 0l) {
_valCacheMode = cache_write;
_cacheFile = fopen(_cacheFileName, "wb");
// printLog("UrlReader: Also writing content to cache file '%s'\n", _cacheFileName);
if (_cacheFile != 0l) {
_cacheMode = cache_write;
}
} else {
// file on server is older -> use cache file
if (! _arrCacheRdBuf) {
_arrCacheRdBuf = new (std::nothrow) char[max_read_ahead];
if (! _arrCacheRdBuf) {
_valCacheMode = no_cache;
if (! _cacheReadBuffer) {
_cacheReadBuffer = new (std::nothrow) char[max_read_ahead];
if (! _cacheReadBuffer) {
// out of memory, no caching, have CURL catch it
return;
}
}
_ptrCacheFile = fopen(_strCacheFile, "rb");
printf("From file: ");
if (_ptrCacheFile != 0l) {
_valCacheMode = cache_read;
_cacheFile = fopen(_cacheFileName, "rb");
// printLog("UrlReader: Delivering cached content from file '%s'\n", _cacheFileName);
if (_cacheFile != 0l) {
_cacheMode = cache_read;
}
_strError = success_cached;
// override error code returned by CURL when we abort the download
_errorStr = success_cached;
}
}
curl_easy_getinfo(hnd_curl, CURLINFO_EFFECTIVE_URL, & url);
curl_easy_getinfo(hnd_curl, CURLINFO_CONTENT_TYPE, & type);
curl_easy_getinfo(hnd_curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, & clen);
length = static_cast<int64_t>(clen);
curl_easy_getinfo(hnd_curl, CURLINFO_FILETIME, & time);
stardate = time;
#endif
}
void UrlReader::transferEnd() {
if (_cacheFile != 0l) {
fclose(_cacheFile);
}
}
#else // no-op version for incomplete Windows build:
UrlReader::UrlReader() : _curlHandle(0l) { }
UrlReader::~UrlReader() { }
void UrlReader::perform(char const* url, transfer_callback* cb) { }
void UrlReader::transferBegin(void* stream, char const* cacheFile) { }
void UrlReader::getInfo(char const*& url, char const*& type,
int64_t& length, int64_t& stardate) { }
void UrlReader::transferEnd() { }
#endif

329
libraries/shared/src/UrlReader.h
View file

@ -19,177 +19,190 @@
// via URLs. Use one per thread.
//
class UrlReader {
public:
enum CacheMode { no_cache, cache_write, cache_read };
//
// Constructor - performs initialization, never throws.
//
UrlReader();
void* _ptrImpl;
char* _arrXtra;
char const* _strError;
void* _ptrStream;
char const* _strCacheFile;
FILE* _ptrCacheFile;
char* _arrCacheRdBuf;
CacheMode _valCacheMode;
size_t _valXtraSize;
public:
//
// Destructor - frees resources, never throws.
//
~UrlReader();
//
// Constructor - performs initialization, never throws.
//
UrlReader();
//
// Reads data from an URL and forwards it to the instance of a class
// fulfilling the ContentStream concept.
//
// The call protocol on the ContentStream is detailed as follows:
//
// 1. begin(char const* url,
// char const* content_type, uint64_t bytes, uint64_t stardate)
//
// All information except 'url' is optional; 'content_type' can
// be a null pointer - 'bytes' and 'stardate' can be equal to
// to 'unavailable'.
//
// 2. transfer(char* buffer, size_t bytes)
//
// Called until all data has been received. The number of bytes
// actually processed should be returned.
// Unprocessed data is stored in an extra buffer whose size is
// given by the constant UrlReader::max_read_ahead - it can be
// assumed to be reasonably large for on-the-fly parsing.
//
// 3. end(bool ok)
//
// Called at the end of the transfer.
//
// Returns the same success code
//
template< class ContentStream >
bool readUrl(char const* url, ContentStream& s, char const* cacheFile = 0l);
//
// Destructor - frees resources, never throws.
//
~UrlReader();
//
// Returns a pointer to a static C-string that describes the error
// condition.
//
inline char const* getError() const;
//
// Reads data from an URL and forwards it to the instance of a class
// fulfilling the ContentStream concept.
//
// The call protocol on the ContentStream is detailed as follows:
//
// 1. begin(char const* url,
// char const* content_type, uint64_t bytes, uint64_t stardate)
//
// All information except 'url' is optional; 'content_type' can
// be a null pointer - 'bytes' and 'stardate' can be equal to
// to 'unavailable'.
//
// 2. transfer(char* buffer, size_t bytes)
//
// Called until all data has been received. The number of bytes
// actually processed should be returned.
// Unprocessed data is stored in an extra buffer whose size is
// given by the constant UrlReader::max_read_ahead - it can be
// assumed to be reasonably large for on-the-fly parsing.
//
// 3. end(bool ok)
//
// Called at the end of the transfer.
//
// Returns the same success code
//
template< class ContentStream >
bool readUrl(char const* url, ContentStream& s, char const* cacheFile = 0l);
//
// Can be called by the stream to set a user-defined error string.
//
inline void setError(char const* static_c_string);
//
// Returns a pointer to a static C-string that describes the error
// condition.
//
inline char const* getError() const;
//
// Pointer to the C-string returned by a call to 'readUrl' when no
// error occurred.
//
static char const* const success;
//
// Can be called by the stream to set a user-defined error string.
//
inline void setError(char const* static_c_string);
//
// Pointer to the C-string returned by a call to 'readUrl' when no
// error occurred and a local file has been read instead of the
// network stream.
//
static char const* const success_cached;
//
// Pointer to the C-string returned by a call to 'readUrl' when no
// error occurred.
//
static char const* const success;
//
// Pointer to the C-string returned by a call to 'readUrl' when the
// initialization has failed.
//
static char const* const error_init_failed;
//
// Pointer to the C-string returned by a call to 'readUrl' when no
// error occurred and a local file has been read instead of the
// network stream.
//
static char const* const success_cached;
//
// Pointer to the C-string returned by a call to 'readUrl' when the
// initialization has failed.
//
static char const* const error_init_failed;
//
// Pointer to the C-string returned by a call to 'readUrl' when the
// transfer has been aborted by the client.
//
static char const* const error_aborted;
//
// Pointer to the C-string returned by a call to 'readUrl' when the
// transfer has been aborted by the client.
//
static char const* const error_aborted;
//
// Pointer to the C-string returned by a call to 'readUrl' when
// leftover input from incomplete processing caused a buffer
// overflow.
//
static char const* const error_buffer_overflow;
//
// Pointer to the C-string returned by a call to 'readUrl' when
// leftover input from incomplete processing caused a buffer
// overflow.
//
static char const* const error_buffer_overflow;
//
// Pointer to the C-string return by a call to 'readUrl' when the
// input provided was not completely consumed.
//
static char const* const error_leftover_input;
//
// Pointer to the C-string return by a call to 'readUrl' when the
// input provided was not completely consumed.
//
static char const* const error_leftover_input;
//
// Constant of the maximum number of bytes that are buffered
// between invocations of 'transfer'.
//
static size_t const max_read_ahead;
//
// Constant of the maximum number of bytes that are buffered
// between invocations of 'transfer'.
//
static size_t const max_read_ahead;
//
// Constant representing absent information in the call to the
// 'begin' member function of the target stream.
//
static int const unavailable = -1;
//
// Constant representing absent information in the call to the
// 'begin' member function of the target stream.
//
static int const unavailable = -1;
//
// Constant for requesting to abort the current transfer when
// returned by the 'transfer' member function of the target stream.
//
static size_t const abort = ~0u;
//
// Constant for requesting to abort the current transfer when
// returned by the 'transfer' member function of the target stream.
//
static size_t const abort = ~0u;
private:
// instances of this class shall not be copied
UrlReader(UrlReader const&); // = delete;
UrlReader& operator=(UrlReader const&); // = delete;
private:
// instances of this class shall not be copied
UrlReader(UrlReader const&); // = delete;
UrlReader& operator=(UrlReader const&); // = delete;
inline bool isSuccess();
// entrypoints to compiled code
// entrypoints to compiled code
typedef size_t transfer_callback(char*, size_t, size_t, void*);
typedef size_t transfer_callback(char*, size_t, size_t, void*);
bool perform(char const* url, transfer_callback* transfer);
enum CacheMode { no_cache, cache_write, cache_read };
void getinfo(char const*& url,
char const*& type, int64_t& length, int64_t& stardate);
void transferBegin(void* stream, char const* cacheFile);
void transferEnd();
// synthesized callback
void perform(char const* url, transfer_callback* transfer);
template< class Stream > static size_t callback_template(char *input, size_t size,
size_t nmemb, void* thiz);
void getInfo(char const*& url,
char const*& type, int64_t& length, int64_t& stardate);
template< class Stream > size_t feedBuffered(Stream* stream,
char* input, size_t size);
// synthesized callback
template< class Stream > static size_t callback_template(char *input, size_t size,
size_t nmemb, void* thiz);
template< class Stream > size_t feedBuffered(Stream* stream,
char* input, size_t size);
// state
void* _curlHandle;
char* _xtraBuffer;
char const* _errorStr;
void* _streamPtr;
char const* _cacheFileName;
FILE* _cacheFile;
char* _cacheReadBuffer;
CacheMode _cacheMode;
size_t _xtraSize;
};
// inline functions
inline char const* UrlReader::getError() const {
return _errorStr;
}
bool UrlReader::isSuccess() {
return _errorStr == success || _errorStr == success_cached;
}
template< class ContentStream >
bool UrlReader::readUrl(char const* url, ContentStream& s, char const* cacheFile) {
if (! _ptrImpl) return false;
_strCacheFile = cacheFile;
_ptrCacheFile = 0l;
_valCacheMode = no_cache; // eventually set later
_strError = success;
_ptrStream = & s;
_valXtraSize = ~size_t(0);
this->perform(url, & callback_template<ContentStream>);
s.end(_strError == success);
if (_ptrCacheFile != 0l) {
fclose(_ptrCacheFile);
}
return _strError == success || _strError == success_cached;
}
if (! _curlHandle) return false;
inline char const* UrlReader::getError() const { return this->_strError; }
this->transferBegin(& s, cacheFile);
this->perform(url, & callback_template<ContentStream>);
this->transferEnd();
bool ok = isSuccess();
s.end(ok);
return ok;
}
inline void UrlReader::setError(char const* staticCstring) {
if (this->_strError == success || this->_strError == success_cached)
this->_strError = staticCstring;
if (this->isSuccess())
this->_errorStr = staticCstring;
}
template< class Stream >
size_t UrlReader::feedBuffered(Stream* stream, char* input, size_t size) {
size_t inputOffset = 0u;
while (true) {
@ -198,15 +211,15 @@ size_t UrlReader::feedBuffered(Stream* stream, char* input, size_t size) {
size_t bytes = size - inputOffset;
// data in extra buffer?
if (_valXtraSize > 0) {
if (_xtraSize > 0) {
// fill extra buffer with beginning of input
size_t fill = max_read_ahead - _valXtraSize;
size_t fill = max_read_ahead - _xtraSize;
if (bytes < fill) fill = bytes;
memcpy(_arrXtra + _valXtraSize, buffer, fill);
memcpy(_xtraBuffer + _xtraSize, buffer, fill);
// use extra buffer for next transfer
buffer = _arrXtra;
bytes = _valXtraSize + fill;
buffer = _xtraBuffer;
bytes = _xtraSize + fill;
inputOffset += fill;
}
@ -225,9 +238,9 @@ size_t UrlReader::feedBuffered(Stream* stream, char* input, size_t size) {
size_t unprocessed = bytes - processed;
// can switch to input buffer, now?
if (buffer == _arrXtra && unprocessed <= inputOffset) {
if (buffer == _xtraBuffer && unprocessed <= inputOffset) {
_valXtraSize = 0u;
_xtraSize = 0u;
inputOffset -= unprocessed;
} else { // no? unprocessed data -> extra buffer
@ -237,10 +250,10 @@ size_t UrlReader::feedBuffered(Stream* stream, char* input, size_t size) {
setError(error_buffer_overflow);
return 0;
}
_valXtraSize = unprocessed;
memmove(_arrXtra, buffer + processed, unprocessed);
_xtraSize = unprocessed;
memmove(_xtraBuffer, buffer + processed, unprocessed);
if (inputOffset == size || buffer != _arrXtra) {
if (inputOffset == size || buffer != _xtraBuffer) {
return size;
}
@ -253,18 +266,18 @@ size_t UrlReader::callback_template(char *input, size_t size, size_t nmemb, void
size_t result = 0u;
UrlReader* me = static_cast<UrlReader*>(thiz);
Stream* stream = static_cast<Stream*>(me->_ptrStream);
Stream* stream = static_cast<Stream*>(me->_streamPtr);
size *= nmemb;
// first call?
if (me->_valXtraSize == ~size_t(0)) {
if (me->_xtraSize == ~size_t(0)) {
me->_valXtraSize = 0u;
me->_xtraSize = 0u;
// extract meta information and call 'begin'
char const* url, * type;
int64_t length, stardate;
me->getinfo(url, type, length, stardate);
if (me->_valCacheMode != cache_read) {
me->getInfo(url, type, length, stardate);
if (me->_cacheMode != cache_read) {
stream->begin(url, type, length, stardate);
}
}
@ -272,20 +285,20 @@ size_t UrlReader::callback_template(char *input, size_t size, size_t nmemb, void
// will have to repeat from here when reading a local file
// read from cache file?
if (me->_valCacheMode == cache_read) {
if (me->_cacheMode == cache_read) {
// change input buffer and start
input = me->_arrCacheRdBuf;
size = fread(input, 1, max_read_ahead, me->_ptrCacheFile);
input = me->_cacheReadBuffer;
size = fread(input, 1, max_read_ahead, me->_cacheFile);
nmemb = 1;
} else if (me->_valCacheMode == cache_write) {
fwrite(input, 1, size, me->_ptrCacheFile);
} else if (me->_cacheMode == cache_write) {
fwrite(input, 1, size, me->_cacheFile);
}
result = me->feedBuffered(stream, input, size);
} while (me->_valCacheMode == cache_read && result != 0 && ! feof(me->_ptrCacheFile));
} while (me->_cacheMode == cache_read && result != 0 && ! feof(me->_cacheFile));
return me->_valCacheMode != cache_read ? result : 0;
return me->_cacheMode != cache_read ? result : 0;
}
#endif /* defined(__hifi__UrlReader__) */

17
libraries/shared/src/shared_Log.cpp
View file

@ -1,17 +0,0 @@
//
// shared_Log.cpp
// hifi
//
// Created by Tobias Schwinger on 4/17/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "shared_Log.h"
#include <cstdio>
namespace shared_lib {
using namespace std;
int (* printLog)(char const*, ...) = & printf;
}

5
libraries/voxels/src/Plane.cpp
View file

@ -9,11 +9,10 @@
//
#include "Plane.h"
#include <stdio.h>
#include "voxels_Log.h"
using voxels_lib::printLog;
#include "Log.h"
// These are some useful utilities that vec3 is missing
void printVec3(const char* name, const glm::vec3& v) {

3
libraries/voxels/src/ViewFrustum.cpp
View file

@ -14,9 +14,8 @@
#include "ViewFrustum.h"
#include "SharedUtil.h"
#include "voxels_Log.h"
#include "Log.h"
using voxels_lib::printLog;
using namespace std;
ViewFrustum::ViewFrustum() :

5
libraries/voxels/src/VoxelNode.cpp
View file

@ -10,14 +10,11 @@
#include <cmath>
#include <cstring>
#include "SharedUtil.h"
#include "voxels_Log.h"
#include "Log.h"
#include "VoxelNode.h"
#include "VoxelConstants.h"
#include "OctalCode.h"
#include "AABox.h"
using voxels_lib::printLog;
// using voxels_lib::printLog;
VoxelNode::VoxelNode() {
unsigned char* rootCode = new unsigned char[1];

11
libraries/voxels/src/VoxelTree.cpp
View file

@ -13,7 +13,7 @@
#include <cstdio>
#include <cmath>
#include "SharedUtil.h"
#include "voxels_Log.h"
#include "Log.h"
#include "PacketHeaders.h"
#include "OctalCode.h"
#include "VoxelTree.h"
@ -24,8 +24,6 @@
#include <glm/gtc/noise.hpp>
using voxels_lib::printLog;
int boundaryDistanceForRenderLevel(unsigned int renderLevel) {
float voxelSizeScale = 50000.0f;
return voxelSizeScale / powf(2, renderLevel);
@ -352,10 +350,9 @@ void VoxelTree::readCodeColorBufferToTree(unsigned char *codeColorBuffer, bool d
}
void VoxelTree::processRemoveVoxelBitstream(unsigned char * bitstream, int bufferSizeBytes) {
// XXXBHG: validate buffer is at least 4 bytes long? other guards??
unsigned short int itemNumber = (*((unsigned short int*)&bitstream[1]));
int atByte = 3;
unsigned char* pVoxelData = (unsigned char*)&bitstream[3];
//unsigned short int itemNumber = (*((unsigned short int*)&bitstream[sizeof(PACKET_HEADER)]));
int atByte = sizeof(short int) + sizeof(PACKET_HEADER);
unsigned char* pVoxelData = (unsigned char*)&bitstream[atByte];
while (atByte < bufferSizeBytes) {
unsigned char octets = (unsigned char)*pVoxelData;
int voxelDataSize = bytesRequiredForCodeLength(octets)+3; // 3 for color!

20
libraries/voxels/src/voxels_Log.h
View file

@ -1,20 +0,0 @@
//
// voxels_Log.h
// hifi
//
// Created by Tobias Schwinger on 4/17/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __hifi__voxels_Log__
#define __hifi__voxels_Log__
namespace voxels_lib {
// variable that can be set from outside to redirect the log output
// of this library
extern int (* printLog)(char const*, ...);
}
#endif /* defined(__hifi__voxels_Log__) */