mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-06-25 21:10:31 +02:00
222 lines
8.2 KiB
C++
222 lines
8.2 KiB
C++
//
|
|
// Stars.cpp
|
|
// interface/src
|
|
//
|
|
// Created by Tobias Schwinger on 3/22/13.
|
|
// Copyright 2013 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#include "Stars.h"
|
|
|
|
#include <mutex>
|
|
|
|
#include <QElapsedTimer>
|
|
#include <gpu/Context.h>
|
|
#include <NumericalConstants.h>
|
|
#include <DependencyManager.h>
|
|
#include <GeometryCache.h>
|
|
#include <TextureCache.h>
|
|
#include <RenderArgs.h>
|
|
#include <ViewFrustum.h>
|
|
|
|
#include "../../libraries/render-utils/stars_vert.h"
|
|
#include "../../libraries/render-utils/stars_frag.h"
|
|
|
|
#include "../../libraries/render-utils/standardTransformPNTC_vert.h"
|
|
#include "../../libraries/render-utils/starsGrid_frag.h"
|
|
|
|
//static const float TILT = 0.23f;
|
|
static const float TILT = 0.0f;
|
|
static const unsigned int STARFIELD_NUM_STARS = 50000;
|
|
static const unsigned int STARFIELD_SEED = 1;
|
|
static const float STAR_COLORIZATION = 0.1f;
|
|
|
|
static const float TAU = 6.28318530717958f;
|
|
//static const float HALF_TAU = TAU / 2.0f;
|
|
//static const float QUARTER_TAU = TAU / 4.0f;
|
|
//static const float MILKY_WAY_WIDTH = TAU / 30.0f; // width in radians of one half of the Milky Way
|
|
//static const float MILKY_WAY_INCLINATION = 0.0f; // angle of Milky Way from horizontal in degrees
|
|
//static const float MILKY_WAY_RATIO = 0.4f;
|
|
static const char* UNIFORM_TIME_NAME = "iGlobalTime";
|
|
|
|
|
|
|
|
Stars::Stars() {
|
|
}
|
|
|
|
Stars::~Stars() {
|
|
}
|
|
|
|
// Produce a random float value between 0 and 1
|
|
static float frand() {
|
|
return (float)rand() / (float)RAND_MAX;
|
|
}
|
|
|
|
// Produce a random radian value between 0 and 2 PI (TAU)
|
|
/*
|
|
static float rrand() {
|
|
return frand() * TAU;
|
|
}
|
|
*/
|
|
|
|
// http://mathworld.wolfram.com/SpherePointPicking.html
|
|
static vec2 randPolar() {
|
|
vec2 result(frand(), frand());
|
|
result.x *= TAU;
|
|
result.y = powf(result.y, 2.0) / 2.0f;
|
|
if (frand() > 0.5f) {
|
|
result.y = 0.5f - result.y;
|
|
} else {
|
|
result.y += 0.5f;
|
|
}
|
|
result.y = acos((2.0f * result.y) - 1.0f);
|
|
return result;
|
|
}
|
|
|
|
|
|
static vec3 fromPolar(const vec2& polar) {
|
|
float sinTheta = sin(polar.x);
|
|
float cosTheta = cos(polar.x);
|
|
float sinPhi = sin(polar.y);
|
|
float cosPhi = cos(polar.y);
|
|
return vec3(
|
|
cosTheta * sinPhi,
|
|
cosPhi,
|
|
sinTheta * sinPhi);
|
|
}
|
|
|
|
|
|
// computeStarColor
|
|
// - Generate a star color.
|
|
//
|
|
// colorization can be a value between 0 and 1 specifying how colorful the resulting star color is.
|
|
//
|
|
// 0 = completely black & white
|
|
// 1 = very colorful
|
|
unsigned computeStarColor(float colorization) {
|
|
unsigned char red, green, blue;
|
|
if (randFloat() < 0.3f) {
|
|
// A few stars are colorful
|
|
red = 2 + (rand() % 254);
|
|
green = 2 + round((red * (1 - colorization)) + ((rand() % 254) * colorization));
|
|
blue = 2 + round((red * (1 - colorization)) + ((rand() % 254) * colorization));
|
|
} else {
|
|
// Most stars are dimmer and white
|
|
red = green = blue = 2 + (rand() % 128);
|
|
}
|
|
return red | (green << 8) | (blue << 16);
|
|
}
|
|
|
|
struct StarVertex {
|
|
vec4 position;
|
|
vec4 colorAndSize;
|
|
};
|
|
|
|
// FIXME star colors
|
|
void Stars::render(RenderArgs* renderArgs, float alpha) {
|
|
static gpu::BufferPointer vertexBuffer;
|
|
static gpu::Stream::FormatPointer streamFormat;
|
|
static gpu::Element positionElement, colorElement;
|
|
static gpu::PipelinePointer _gridPipeline;
|
|
static gpu::PipelinePointer _starsPipeline;
|
|
static int32_t _timeSlot{ -1 };
|
|
static std::once_flag once;
|
|
|
|
const int VERTICES_SLOT = 0;
|
|
const int COLOR_SLOT = 1;
|
|
|
|
std::call_once(once, [&] {
|
|
{
|
|
auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(standardTransformPNTC_vert)));
|
|
auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(starsGrid_frag)));
|
|
auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
|
|
gpu::Shader::makeProgram((*program));
|
|
_timeSlot = program->getBuffers().findLocation(UNIFORM_TIME_NAME);
|
|
if (_timeSlot == gpu::Shader::INVALID_LOCATION) {
|
|
_timeSlot = program->getUniforms().findLocation(UNIFORM_TIME_NAME);
|
|
}
|
|
auto state = gpu::StatePointer(new gpu::State());
|
|
// enable decal blend
|
|
state->setDepthTest(gpu::State::DepthTest(false));
|
|
state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA);
|
|
_gridPipeline.reset(gpu::Pipeline::create(program, state));
|
|
}
|
|
{
|
|
auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(stars_vert)));
|
|
auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(stars_frag)));
|
|
auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
|
|
gpu::Shader::makeProgram((*program));
|
|
auto state = gpu::StatePointer(new gpu::State());
|
|
// enable decal blend
|
|
state->setDepthTest(gpu::State::DepthTest(false));
|
|
state->setAntialiasedLineEnable(true); // line smoothing also smooth points
|
|
state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA);
|
|
_starsPipeline.reset(gpu::Pipeline::create(program, state));
|
|
|
|
}
|
|
|
|
QElapsedTimer startTime;
|
|
startTime.start();
|
|
vertexBuffer.reset(new gpu::Buffer);
|
|
|
|
srand(STARFIELD_SEED);
|
|
unsigned limit = STARFIELD_NUM_STARS;
|
|
std::vector<StarVertex> points;
|
|
points.resize(limit);
|
|
for (size_t star = 0; star < limit; ++star) {
|
|
points[star].position = vec4(fromPolar(randPolar()), 1);
|
|
float size = frand() * 2.5f + 0.5f;
|
|
if (frand() < STAR_COLORIZATION) {
|
|
vec3 color(frand() / 2.0f + 0.5f, frand() / 2.0f + 0.5f, frand() / 2.0f + 0.5f);
|
|
points[star].colorAndSize = vec4(color, size);
|
|
} else {
|
|
vec3 color(frand() / 2.0f + 0.5f);
|
|
points[star].colorAndSize = vec4(color, size);
|
|
}
|
|
}
|
|
double timeDiff = (double)startTime.nsecsElapsed() / 1000000.0; // ns to ms
|
|
qDebug() << "Total time to generate stars: " << timeDiff << " msec";
|
|
|
|
vertexBuffer->append(sizeof(StarVertex) * limit, (const gpu::Byte*)&points[0]);
|
|
streamFormat.reset(new gpu::Stream::Format()); // 1 for everyone
|
|
streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC4, gpu::FLOAT, gpu::XYZW), 0);
|
|
streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::FLOAT, gpu::RGBA));
|
|
positionElement = streamFormat->getAttributes().at(gpu::Stream::POSITION)._element;
|
|
colorElement = streamFormat->getAttributes().at(gpu::Stream::COLOR)._element;
|
|
});
|
|
|
|
auto geometryCache = DependencyManager::get<GeometryCache>();
|
|
auto textureCache = DependencyManager::get<TextureCache>();
|
|
|
|
gpu::Batch& batch = *renderArgs->_batch;
|
|
batch.setViewTransform(Transform());
|
|
batch.setProjectionTransform(renderArgs->_viewFrustum->getProjection());
|
|
batch.setModelTransform(Transform().setRotation(glm::inverse(renderArgs->_viewFrustum->getOrientation()) *
|
|
quat(vec3(TILT, 0, 0))));
|
|
batch.setResourceTexture(0, textureCache->getWhiteTexture());
|
|
|
|
// Render the world lines
|
|
batch.setPipeline(_gridPipeline);
|
|
static auto start = usecTimestampNow();
|
|
float msecs = (float)(usecTimestampNow() - start) / (float)USECS_PER_MSEC;
|
|
float secs = msecs / (float)MSECS_PER_SECOND;
|
|
batch._glUniform1f(_timeSlot, secs);
|
|
geometryCache->renderUnitCube(batch);
|
|
|
|
static const size_t VERTEX_STRIDE = sizeof(StarVertex);
|
|
size_t offset = offsetof(StarVertex, position);
|
|
gpu::BufferView posView(vertexBuffer, offset, vertexBuffer->getSize(), VERTEX_STRIDE, positionElement);
|
|
offset = offsetof(StarVertex, colorAndSize);
|
|
gpu::BufferView colView(vertexBuffer, offset, vertexBuffer->getSize(), VERTEX_STRIDE, colorElement);
|
|
|
|
// Render the stars
|
|
batch.setPipeline(_starsPipeline);
|
|
|
|
batch.setInputFormat(streamFormat);
|
|
batch.setInputBuffer(VERTICES_SLOT, posView);
|
|
batch.setInputBuffer(COLOR_SLOT, colView);
|
|
batch.draw(gpu::Primitive::POINTS, STARFIELD_NUM_STARS);
|
|
}
|