Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-06 16:36:54 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

improves naming consistency (mostly member variable prefixes)

Browse source
This commit is contained in:
tosh 2013-03-27 11:49:43 +01:00
parent fcec7bf62f
commit ecd64d3244
3 changed files with 46 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

52
interface/src/Stars.cpp
View file

@ -310,7 +310,7 @@ namespace
class Loader : UrlReader class Loader : UrlReader
{ {
InputVertices* arr_vertex; InputVertices& ref_vertices;
unsigned val_limit; unsigned val_limit;
unsigned val_lineno; unsigned val_lineno;
@ -323,7 +323,7 @@ namespace
bool loadVertices( bool loadVertices(
InputVertices& destination, char const* url, unsigned limit) InputVertices& destination, char const* url, unsigned limit)
{ {
arr_vertex = & destination; ref_vertices = destination;
val_limit = limit; val_limit = limit;
str_actual_url = url; // in case we fail early str_actual_url = url; // in case we fail early
@ -347,8 +347,8 @@ namespace
val_lineno = 0u; val_lineno = 0u;
str_actual_url = url; // new value in http redirect str_actual_url = url; // new value in http redirect
arr_vertex->clear(); ref_vertices.clear();
arr_vertex->reserve(val_limit); ref_vertices.reserve(val_limit);
} }
size_t transfer(char* input, size_t bytes) size_t transfer(char* input, size_t bytes)
@ -383,35 +383,35 @@ namespace
if (val_records_read++ == val_limit) if (val_records_read++ == val_limit)
{ {
std::make_heap( std::make_heap(
arr_vertex->begin(), arr_vertex->end(), ref_vertices.begin(), ref_vertices.end(),
GreaterBrightness() ); GreaterBrightness() );
val_min_brightness = getBrightness( val_min_brightness = getBrightness(
arr_vertex->begin()->getColor() ); ref_vertices.begin()->getColor() );
} }
if (arr_vertex->size() == val_limit) if (ref_vertices.size() == val_limit)
{ {
if (val_min_brightness >= getBrightness(c)) if (val_min_brightness >= getBrightness(c))
continue; continue;
std::pop_heap( std::pop_heap(
arr_vertex->begin(), arr_vertex->end(), ref_vertices.begin(), ref_vertices.end(),
GreaterBrightness() ); GreaterBrightness() );
arr_vertex->pop_back(); ref_vertices.pop_back();
} }
} }
arr_vertex->push_back( InputVertex(azi, alt, c) ); ref_vertices.push_back( InputVertex(azi, alt, c) );
if (val_limit > 0 && val_records_read > val_limit) if (val_limit > 0 && val_records_read > val_limit)
{ {
std::push_heap( std::push_heap(
arr_vertex->begin(), arr_vertex->end(), ref_vertices.begin(), ref_vertices.end(),
GreaterBrightness() ); GreaterBrightness() );
arr_vertex->pop_back(); ref_vertices.pop_back();
val_min_brightness = getBrightness( val_min_brightness = getBrightness(
arr_vertex->begin()->getColor() ); ref_vertices.begin()->getColor() );
} }
} }
else else
@ -433,9 +433,9 @@ namespace
class TileCulling class TileCulling
{ {
Renderer& ref_renderer; Renderer& ref_renderer;
Tile** ptr_stack; Tile** itr_stack;
Tile const* const arr_tile; Tile const* const arr_tile;
Tile const* const ptr_tiles_end; Tile const* const itr_tiles_end;
public: public:
@ -454,7 +454,7 @@ namespace
void up(Tile*& cursor) const { cursor += yStride(); } void up(Tile*& cursor) const { cursor += yStride(); }
void down(Tile*& cursor) const { cursor -= yStride(); } void down(Tile*& cursor) const { cursor -= yStride(); }
void defer(Tile* t) { *ptr_stack++ = t; } void defer(Tile* t) { *itr_stack++ = t; }
inline bool deferred(Tile*& cursor); inline bool deferred(Tile*& cursor);
private: private:
@ -787,12 +787,12 @@ namespace
Tile const* tiles, Tile const* tiles_end, Tile** stack) Tile const* tiles, Tile const* tiles_end, Tile** stack)
: ref_renderer(renderer), : ref_renderer(renderer),
ptr_stack(stack), arr_tile(tiles), ptr_tiles_end(tiles_end) itr_stack(stack), arr_tile(tiles), itr_tiles_end(tiles_end)
{ } { }
bool TileCulling::select(Tile* t) bool TileCulling::select(Tile* t)
{ {
if (t < arr_tile || t >= ptr_tiles_end || if (t < arr_tile || t >= itr_tiles_end ||
!! (t->flags & Tile::visited)) !! (t->flags & Tile::visited))
return false; return false;
@ -808,9 +808,9 @@ namespace
bool TileCulling::deferred(Tile*& cursor) bool TileCulling::deferred(Tile*& cursor)
{ {
if (ptr_stack != (Tile**) ref_renderer.arr_batch_count) if (itr_stack != (Tile**) ref_renderer.arr_batch_count)
{ {
cursor = *--ptr_stack; cursor = *--itr_stack;
return true; return true;
} }
return false; return false;
@ -824,7 +824,7 @@ namespace
struct Stars::body struct Stars::body
{ {
InputVertices vec_input; InputVertices seq_input;
unsigned val_tile_resolution; unsigned val_tile_resolution;
BrightnessLevels vec_lod_brightness; BrightnessLevels vec_lod_brightness;
@ -857,7 +857,7 @@ struct Stars::body
{ {
// TODO input mutex // TODO input mutex
vec_input.swap(new_vertices); seq_input.swap(new_vertices);
try try
{ {
@ -866,7 +866,7 @@ struct Stars::body
catch (...) catch (...)
{ {
// rollback transaction // rollback transaction
new_vertices.swap(vec_input); new_vertices.swap(seq_input);
throw; throw;
} }
@ -894,9 +894,9 @@ struct Stars::body
{ {
HorizontalTiling<Degrees> tiling(k); HorizontalTiling<Degrees> tiling(k);
TileSortScanner scanner(tiling); TileSortScanner scanner(tiling);
radix2InplaceSort(vec_input.begin(), vec_input.end(), scanner); radix2InplaceSort(seq_input.begin(), seq_input.end(), scanner);
recreateRenderer(vec_input.size(), k, recreateRenderer(seq_input.size(), k,
val_lod_brightness, val_lod_max_brightness); val_lod_brightness, val_lod_max_brightness);
val_tile_resolution = k; val_tile_resolution = k;
@ -944,7 +944,7 @@ struct Stars::body
void recreateRenderer( void recreateRenderer(
size_t n, unsigned k, BrightnessLevel b, BrightnessLevel b_max) size_t n, unsigned k, BrightnessLevel b, BrightnessLevel b_max)
{ {
Renderer* renderer = new Renderer(vec_input, n, k, b, b_max); Renderer* renderer = new Renderer(seq_input, n, k, b, b_max);
swap(ptr_renderer, renderer); // TODO make atomic swap(ptr_renderer, renderer); // TODO make atomic
delete renderer; // will be NULL when was in use delete renderer; // will be NULL when was in use
} }

10
shared/src/UrlReader.cpp
View file

@ -23,10 +23,10 @@ char const* const UrlReader::error_leftover_input = "UrlReader: Incomplete pro
#define hnd_curl static_cast<CURL*>(ptr_impl) #define hnd_curl static_cast<CURL*>(ptr_impl)
UrlReader::UrlReader() UrlReader::UrlReader()
: ptr_impl(0l), ptr_ra(0l), str_error(0l) : ptr_impl(0l), buf_xtra(0l), str_error(0l)
{ {
ptr_ra = new(std::nothrow) char[max_read_ahead]; buf_xtra = new(std::nothrow) char[max_read_ahead];
if (! ptr_ra) { str_error = error_init_failed; return; } if (! buf_xtra) { str_error = error_init_failed; return; }
ptr_impl = curl_easy_init(); ptr_impl = curl_easy_init();
if (! ptr_impl) { str_error = error_init_failed; return; } if (! ptr_impl) { str_error = error_init_failed; return; }
curl_easy_setopt(hnd_curl, CURLOPT_NOSIGNAL, 1l); curl_easy_setopt(hnd_curl, CURLOPT_NOSIGNAL, 1l);
@ -36,7 +36,7 @@ UrlReader::UrlReader()
UrlReader::~UrlReader() UrlReader::~UrlReader()
{ {
delete ptr_ra; delete buf_xtra;
if (! hnd_curl) return; if (! hnd_curl) return;
curl_easy_cleanup(hnd_curl); curl_easy_cleanup(hnd_curl);
} }
@ -51,7 +51,7 @@ bool UrlReader::perform(char const* url, transfer_callback* cb)
if (rc == CURLE_OK) if (rc == CURLE_OK)
{ {
while (val_ra_size > 0 && str_error == success) while (val_xtra_size_size > 0 && str_error == success)
cb(0l, 0, 0, this); cb(0l, 0, 0, this);
} }
else if (str_error == success) else if (str_error == success)

30
shared/src/UrlReader.h
View file

@ -20,10 +20,10 @@
class UrlReader class UrlReader
{ {
void* ptr_impl; void* ptr_impl;
char* ptr_ra; char* buf_xtra;
char const* str_error; char const* str_error;
void* ptr_stream; void* ptr_stream;
size_t val_ra_size; size_t val_xtra_size_size;
public: public:
@ -154,7 +154,7 @@ bool UrlReader::readUrl(char const* url, ContentStream& s)
if (! ptr_impl) return false; if (! ptr_impl) return false;
str_error = success; str_error = success;
ptr_stream = & s; ptr_stream = & s;
val_ra_size = ~size_t(0); val_xtra_size_size = ~size_t(0);
this->perform(url, & callback_template<ContentStream>); this->perform(url, & callback_template<ContentStream>);
s.end(str_error == success); s.end(str_error == success);
return str_error == success; return str_error == success;
@ -178,9 +178,9 @@ size_t UrlReader::callback_template(
Stream* stream = static_cast<Stream*>(me->ptr_stream); Stream* stream = static_cast<Stream*>(me->ptr_stream);
// first call? // first call?
if (me->val_ra_size == ~size_t(0)) if (me->val_xtra_size_size == ~size_t(0))
{ {
me->val_ra_size = 0u; me->val_xtra_size_size = 0u;
// extract meta information and call 'begin' // extract meta information and call 'begin'
char const* url, * type; char const* url, * type;
int64_t length, stardate; int64_t length, stardate;
@ -196,15 +196,15 @@ size_t UrlReader::callback_template(
size_t bytes = size - input_offset; size_t bytes = size - input_offset;
// data in extra buffer? // data in extra buffer?
if (me->val_ra_size > 0) if (me->val_xtra_size_size > 0)
{ {
// fill extra buffer with beginning of input // fill extra buffer with beginning of input
size_t fill = max_read_ahead - me->val_ra_size; size_t fill = max_read_ahead - me->val_xtra_size_size;
if (bytes < fill) fill = bytes; if (bytes < fill) fill = bytes;
memcpy(me->ptr_ra + me->val_ra_size, buffer, fill); memcpy(me->buf_xtra + me->val_xtra_size_size, buffer, fill);
// use extra buffer for next transfer // use extra buffer for next transfer
buffer = me->ptr_ra; buffer = me->buf_xtra;
bytes = me->val_ra_size + fill; bytes = me->val_xtra_size_size + fill;
input_offset += fill; input_offset += fill;
} }
@ -223,9 +223,9 @@ size_t UrlReader::callback_template(
size_t unprocessed = bytes - processed; size_t unprocessed = bytes - processed;
// can switch to input buffer, now? // can switch to input buffer, now?
if (buffer == me->ptr_ra && unprocessed <= input_offset) if (buffer == me->buf_xtra && unprocessed <= input_offset)
{ {
me->val_ra_size = 0u; me->val_xtra_size_size = 0u;
input_offset -= unprocessed; input_offset -= unprocessed;
} }
else // no? unprocessed data -> extra buffer else // no? unprocessed data -> extra buffer
@ -235,10 +235,10 @@ size_t UrlReader::callback_template(
me->setError(error_buffer_overflow); me->setError(error_buffer_overflow);
return 0; return 0;
} }
me->val_ra_size = unprocessed; me->val_xtra_size_size = unprocessed;
memmove(me->ptr_ra, buffer + processed, unprocessed); memmove(me->buf_xtra, buffer + processed, unprocessed);
if (input_offset == size || buffer != me->ptr_ra) if (input_offset == size || buffer != me->buf_xtra)
{ {
return size; return size;
} }