static void
sendData(ls_timer* tim)
{
unsigned char buf[1024];
int i;
ls_err err;
UNUSED_PARAM(tim);
config.numSentPkts++;
for (i = 0; i < 1; i++)
{
int len = (numChar * i);
/* TODO: parse this. */
memcpy(buf + len,
s1 + (config.numSentPkts % numChar) + (numChar * i),
numChar);
}
if ( !tube_data(config.t, buf, strlen(s1), &err) )
{
LS_LOG_ERR(err, "tube_data");
}
if ( !tube_manager_schedule_ms(mgr, 50, sendData, NULL, NULL, &err) )
{
LS_LOG_ERR(err, "tube_manager_schedule_ms");
return;
}
}
/*-------------------------------------
* Attach shader objects to a program
-------------------------------------*/
bool ShaderProgramAssembly::assemble(ShaderProgram& outProg, bool runLinker) noexcept {
LS_LOG_MSG("Attempting to assemble a Shader Program.");
if (!is_assembly_valid()) {
LS_LOG_ERR("\tFailed to assemble a Shader Program. Invalid inputs shader detected.\n");
return false;
}
if (outProg.gpu_id() != 0) {
LS_LOG_ERR("\tAttempted to assemble a preexisting program object.\n");
return false;
}
else {
const GLuint progId = glCreateProgram();
LS_LOG_GL_ERR();
if (progId == 0) {
LS_LOG_ERR("\tUnable to create a handle to an OpenGL Shader Program.\n");
return false;
}
outProg.gpuId = progId;
}
glAttachShader(outProg.gpu_id(), pVertShader->gpu_id());
LS_LOG_GL_ERR();
glAttachShader(outProg.gpu_id(), pFragShader->gpu_id());
LS_LOG_GL_ERR();
#ifdef LS_DRAW_BACKEND_GL
if (pGeomShader && pGeomShader->is_valid()) {
glAttachShader(outProg.gpu_id(), pGeomShader->gpu_id());
LS_LOG_GL_ERR();
}
#endif
// Ensure all shaders attached to the program correctly
if (!assign_shader_layouts(outProg, *pVertShader)
|| !assign_shader_layouts(outProg, *pFragShader)
) {
LS_LOG_ERR(
"\tAn Error occurred while attaching a shader to the shader program ",
outProg.gpu_id(), " during assembly. The shader program will be destroyed.\n"
);
outProg.terminate();
return false;
}
LS_LOG_MSG("\tSuccessfully assembled the Shader Program ", outProg.gpu_id(), ".\n");
if (runLinker) {
return link(outProg);
}
return true;
}
/*-------------------------------------
* Setup a shader's attributes
-------------------------------------*/
bool ShaderProgramAssembly::setup_program_attribs(ShaderProgram& outProg) const noexcept {
outProg.uniforms = draw::get_shader_attribs(outProg, vertex_attrib_t::UNIFORM_ATTRIB);
outProg.vertAttribs = get_linked_shader_attribs(outProg, shader_stage_t::SHADER_STAGE_VERTEX);
outProg.fragAttribs = get_linked_shader_attribs(outProg, shader_stage_t::SHADER_STAGE_FRAGMENT);
// not bothering to support geometry shader attributes.
// Shader stages all need attributes
if (!outProg.get_vertex_attribs().get_num_attribs()) {
LS_LOG_ERR("\tFailed to introspect the vertex shader of ", outProg.gpu_id(), ".\n");
LS_DEBUG_ASSERT(false);
return false;
}
if (!outProg.get_fragment_attribs().get_num_attribs()) {
LS_LOG_ERR("\tFailed to introspect the fragment shader of ", outProg.gpu_id(), ".\n");
LS_DEBUG_ASSERT(false);
return false;
}
const GLuint shaderId = outProg.gpu_id();
GLint totalUniformBlocks = 0;
glGetProgramiv(shaderId, GL_ACTIVE_UNIFORM_BLOCKS, &totalUniformBlocks);
LS_LOG_GL_ERR();
LS_LOG_MSG("\tLocated ", totalUniformBlocks, " uniform blocks in shader ", shaderId, '.');
outProg.uniformBlocks.reset(new(std::nothrow) ShaderBlockAttrib[totalUniformBlocks]);
if (!outProg.uniformBlocks) {
LS_LOG_ERR("\tFailed to allocate space for ", totalUniformBlocks, " uniform blocks!");
LS_DEBUG_ASSERT(false);
return false;
}
for (int i = 0; i < totalUniformBlocks; ++i) {
const bool isIntrospected = outProg.uniformBlocks[i].run_block_introspection(shaderId, i);
if (!isIntrospected) {
LS_LOG_ERR("\tFailed to introspect uniform block ", i, '.');
outProg.uniformBlocks.reset();
LS_DEBUG_ASSERT(false);
return false;
}
}
outProg.numUniformBlocks = totalUniformBlocks;
return true;
}
/*-------------------------------------
Render Context initialization
-------------------------------------*/
bool Context::init(const Display& disp, bool useVsync) {
terminate();
if (disp.is_running() == false) {
LS_LOG_ERR("\tAttempted to initialize a render context with no display.\n");
return false;
}
// Attach the OpenGL context to our window handle
LS_LOG_MSG("Initializing an OpenGL rendering context.");
pContext = SDL_GL_CreateContext(disp.get_window());
if (!pContext) {
LS_LOG_ERR(
"\tUnable to create a render context through SDL.",
"\n\t", SDL_GetError(),
'\n'
);
terminate();
return false;
}
LS_LOG_MSG("\tSuccessfully created a basic render context.");
// Quick setup in order to normalize OpenGL to the display coordinates.
this->make_current(disp);
const math::vec2i&& displayRes = disp.get_resolution();
glViewport(0, 0, displayRes[0], displayRes[1]);
LS_LOG_GL_ERR();
// Set the default back buffer color
const ls::draw::color::color& mgcPnk = ls::draw::color::magenta;
glClearColor(mgcPnk[0], mgcPnk[1], mgcPnk[2], mgcPnk[3]);
LS_LOG_GL_ERR();
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
LS_LOG_GL_ERR();
set_vsync(useVsync);
LS_LOG_MSG(
"\tSuccessfully initialized a OpenGL 3.3-compatible render context:"
"\n\tV-Sync: ", get_vsync()
);
LS_LOG_MSG("\tSuccessfully initialized the OpenGL 3.3 render context.\n");
return true;
}
/*-------------------------------------
* SDL initialization
-------------------------------------*/
bool MainState::bootstrap_subsystems() {
if (SDL_WasInit(0) == SDL_INIT_EVERYTHING) {
return true;
}
SDL_SetMainReady();
constexpr uint32_t sdlInitFlags = 0
| SDL_INIT_TIMER
| SDL_INIT_AUDIO
| SDL_INIT_VIDEO
| SDL_INIT_EVENTS
| SDL_INIT_JOYSTICK
| SDL_INIT_GAMECONTROLLER
| 0;
SDL_SetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION, "opengl");
SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengles2");
SDL_SetHint(SDL_HINT_RENDER_OPENGL_SHADERS, "1");
if (SDL_Init(sdlInitFlags) < 0) {
LS_LOG_ERR(
"Unable to initialize SDL due to an internal library error: \"",
SDL_GetError(), "\"\n",
"Complain to your local programmer.\n"
);
return false;
}
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_CRITICAL);
LS_LOG_MSG("Successfully initialized SDL.\n", SDL_GetError(), '\n');
/*
* Setup the necessary parameters for OpenGL 3.3
*/
#ifdef LS_DRAW_BACKEND_GL
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
#else
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
#endif
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS,
SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG
#ifdef LS_DEBUG
| SDL_GL_CONTEXT_DEBUG_FLAG
#endif
);
SDL_ClearError();
return true;
}
/*-------------------------------------
Determine if *this Buffer Object is currently active.
-------------------------------------*/
bool BufferObject::is_bound() const noexcept {
GLint typeToCheck = 0;
switch (get_type()) {
case buffer_use_t::VBO_BUFFER_ARRAY:
typeToCheck = GL_ARRAY_BUFFER_BINDING;
break;
case buffer_use_t::VBO_BUFFER_ELEMENT:
typeToCheck = GL_ELEMENT_ARRAY_BUFFER_BINDING;
break;
case buffer_use_t::VBO_BUFFER_TRANSFORM_FEEDBACK:
typeToCheck = GL_TRANSFORM_FEEDBACK_BUFFER_BINDING;
break;
case buffer_use_t::VBO_BUFFER_UNIFORM_BUFFER:
typeToCheck = GL_UNIFORM_BUFFER_BINDING;
break;
default:
LS_LOG_ERR("Forgot to implement an enumeration for the current buffer type!");
break;
}
// just fail, no room for debug statements here.
LS_ASSERT(typeToCheck != 0);
GLint currentBuffer = 0;
glGetIntegerv(typeToCheck, ¤tBuffer);
return currentBuffer == (GLint)this->gpuId;
}
void *listen_run(void *p)
{
CTEST_DATA(tube) *data = p;
data->listen_return = tube_manager_loop(data->mgr,& data->err);
if (!data->listen_return) {
LS_LOG_ERR(data->err, "tube_manager_loop");
}
return data;
}
void
done(ls_timer* tim)
{
ls_err err;
UNUSED_PARAM(tim);
printf("done\n");
if ( !tube_manager_stop(mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_stop");
}
}
static void *_pool_calloc(size_t count, size_t size, void *context)
{
ls_pool *pool = context;
ls_err err;
void *ptr;
if (!ls_pool_calloc(pool, count, size, &ptr, &err)) {
LS_LOG_ERR(err, "ls_pool_calloc");
return NULL;
}
return ptr;
}
static void*
socketListen(void* ptr)
{
ls_err err;
UNUSED_PARAM(ptr);
if ( !tube_manager_loop(mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_loop");
}
return NULL;
}
void
done()
{
ls_err err;
if ( !tube_manager_stop(mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_stop");
}
pthread_cancel(listenThread);
pthread_join(listenThread, NULL);
ls_log(LS_LOG_INFO, "DONE!");
exit(0);
}
static void
loopstart_cb(ls_event_data* evt,
void* arg)
{
ls_err err;
UNUSED_PARAM(evt);
UNUSED_PARAM(arg);
if ( !tube_manager_open_tube(mgr,
(const struct sockaddr*)&config.remoteAddr,
&config.t,
&err) )
{
LS_LOG_ERR(err, "tube_open");
return;
}
if ( !tube_print(config.t, &err) )
{
LS_LOG_ERR(err, "tube_print");
return;
}
}
/*-------------------------------------
* Initialize secondary substates
-------------------------------------*/
bool MainState::setup_substates() {
ls::game::GameSystem& sys = get_parent_system();
if (0
//||!sys.push_game_state(new(std::nothrow) HelloPropertyState{})
//|| !sys.push_game_state(new(std::nothrow) HelloTextState{})
//|| !sys.push_game_state(new(std::nothrow) HelloPrimState{})
|| !sys.push_game_state(new(std::nothrow) HelloMeshState{})
) {
LS_LOG_ERR("Unable to run the internal render systems.\n");
return false;
}
LS_LOG_MSG("Successfully created the internal rendering engine.\n");
return true;
}
/*-------------------------------------
* System Runtime
-------------------------------------*/
void MainState::on_run() {
LS_LOG_GL_ERR();
renderContext.make_current(*global::pDisplay);
LS_LOG_GL_ERR();
renderContext.flip(*global::pDisplay);
LS_LOG_GL_ERR();
const char* const pSdlErr = SDL_GetError();
if (pSdlErr && pSdlErr[0] != '\0') {
LS_LOG_ERR("SDL_ERROR: ", pSdlErr);
SDL_ClearError();
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
LS_LOG_GL_ERR();
}
/*-------------------------------------
-------------------------------------*/
bool ShaderProgramAssembly::link(ShaderProgram& outProg) const noexcept {
LS_LOG_MSG("Attempting to link the shader ", outProg.gpu_id(), '.');
GLint linkResult = 0;
glLinkProgram(outProg.gpu_id());
LS_LOG_GL_ERR();
glGetProgramiv(outProg.gpu_id(), GL_LINK_STATUS, &linkResult);
LS_LOG_GL_ERR();
GLint logLength = 0;
glGetProgramiv(outProg.gpu_id(), GL_INFO_LOG_LENGTH, &logLength);
LS_LOG_GL_ERR();
utils::Pointer <GLchar[]> logData {new GLchar[logLength + 1]};
logData[logLength] = '\0';
glGetProgramInfoLog(outProg.gpu_id(), logLength, nullptr, logData.get());
LS_LOG_GL_ERR();
LS_LOG_MSG("\tProgram linker log:\n", logData.get(), '\n');
if (linkResult != GL_TRUE) {
LS_DEBUG_ASSERT(false);
return false;
}
LS_LOG_MSG("\tSuccessfully linked shader ", outProg.gpu_id(), ". Now running introspection\n");
if (!setup_program_attribs(outProg)) {
LS_LOG_ERR("\tIntrospection of shader", outProg.gpu_id(), "failed during post-link setup.\n");
return false;
}
LS_LOG_MSG(
"\tDone. Successfully assembled and linked shader ", outProg.gpu_id(), ":",
"\n\t\tUniforms: ", outProg.uniforms.get_num_attribs(),
"\n\t\tVertex Attribs: ", outProg.vertAttribs.get_num_attribs(),
"\n\t\tFragment Attribs: ", outProg.fragAttribs.get_num_attribs(),
'\n'
);
return true;
}
static int
markov()
{
struct timespec timer;
struct timespec remaining;
tube* t;
ls_err err;
int i;
int* iptr;
timer.tv_sec = 0;
while ( tube_manager_running(mgr) )
{
timer.tv_nsec = gauss(50000000, 10000000);
nanosleep(&timer, &remaining);
i = random() % NUM_TUBES;
t = tubes[i];
if (!t)
{
if ( !tube_create(&t, &err) )
{
LS_LOG_ERR(err, "tube_create");
return 1;
}
tubes[i] = t;
iptr = malloc( sizeof(*iptr) );
*iptr = i;
tube_set_data(t, iptr);
}
switch ( tube_get_state(t) )
{
case TS_START:
ls_log(LS_LOG_ERROR, "invalid tube state");
return 1;
case TS_UNKNOWN:
if ( !tube_manager_open_tube(mgr,
(const struct sockaddr*)&remoteAddr,
&t,
&err) )
{
LS_LOG_ERR(err, "tube_manager_open_tube");
return 1;
}
break;
case TS_OPENING:
/* keep waiting by the mailbox, Charlie Brown */
break;
case TS_RUNNING:
/* .1% chance of close */
if ( (random() % 10000) < 10 )
{
if ( !tube_close(t, &err) )
{
LS_LOG_ERR(err, "tube_close");
return 1;
}
}
else
{
/* TODO: put something intersting in the buffer */
if ( !tube_data(t, data, random() % sizeof(data), &err) )
{
LS_LOG_ERR(err, "tube_data");
return 1;
}
}
case TS_RESUMING:
/* can't get here yet */
break;
}
}
return 0;
}
int
spudtest(int argc,
char** argv)
{
ls_err err;
size_t i;
const char nums[] = "0123456789";
if (argc < 2)
{
fprintf(stderr, "spudload <destination>\n");
exit(64);
}
#if defined(__APPLE__)
srandomdev();
#endif
#if defined(__LINUX__)
srandom( time(NULL) );
#endif
for (i = 0; i < sizeof(data); i++)
{
data[i] = nums[i % 10];
}
if ( !ls_sockaddr_get_remote_ip_addr(argv[1],
"1402",
(struct sockaddr*)&remoteAddr,
sizeof(remoteAddr),
&err) )
{
return 1;
}
if ( !tube_manager_create(0, &mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_create");
return 1;
}
if ( !tube_manager_socket(mgr, 0, &err) )
{
LS_LOG_ERR(err, "tube_manager_socket");
return 1;
}
if ( !tube_manager_signal(mgr, SIGINT, done, &err) )
{
LS_LOG_ERR(err, "tube_manager_signal");
return 1;
}
if ( !tube_manager_bind_event(mgr, EV_REMOVE_NAME, remove_cb, &err) )
{
LS_LOG_ERR(err, "tube_manager_bind_event");
return 1;
}
memset( tubes, 0, sizeof(tubes) );
/* Start and listen to the sockets. */
pthread_create(&listenThread, NULL, socketListen, NULL);
return markov();
}
int
spudtest(int argc,
char** argv)
{
ls_err err;
int ch;
struct sockaddr_storage addr;
/* bool has_addr = false;; */
while ( ( ch = getopt(argc, argv, "?hvs:") ) != -1 )
{
switch (ch)
{
case 'v':
ls_log_set_level(LS_LOG_VERBOSE);
break;
case 's':
if ( !ls_sockaddr_parse(optarg, (struct sockaddr*)&addr, sizeof(addr),
&err) )
{
LS_LOG_ERR(err, "Invalid address");
return 1;
}
/* has_addr = true; */
break;
case 'h':
case '?':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc < 1)
{
usage();
}
ls_log(LS_LOG_INFO, "entering spudtest");
memset( &config, 0, sizeof(config) );
if ( !ls_sockaddr_get_remote_ip_addr(argv[0],
"1402",
(struct sockaddr*)&config.remoteAddr,
sizeof(config.remoteAddr),
&err) )
{
LS_LOG_ERR(err, "ls_sockaddr_get_remote_ip_addr");
return 1;
}
if ( !tube_manager_create(0, &mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_create");
return 1;
}
if ( !tube_manager_socket(mgr, 0, &err) )
{
LS_LOG_ERR(err, "tube_manager_socket");
return 1;
}
/* TODO: make source addresses work (again?). */
/* if (has_addr) { */
/* LOGI("source address: %s\n", inet_ntop(AF_INET6, &addr, buf,
* sizeof(buf))); */
/* } */
if ( !tube_manager_bind_event(mgr, EV_LOOPSTART_NAME, loopstart_cb, &err) ||
!tube_manager_bind_event(mgr, EV_RUNNING_NAME, running_cb, &err) ||
!tube_manager_bind_event(mgr, EV_DATA_NAME, data_cb, &err) )
{
LS_LOG_ERR(err, "tube_manager_bind_event");
return 1;
}
if ( !tube_manager_signal(mgr, SIGINT, done_sig, &err) )
{
LS_LOG_ERR(err, "tube_manager_signal");
return 1;
}
if ( !tube_manager_schedule_ms(mgr, 5000, done, NULL, NULL, &err) )
{
LS_LOG_ERR(err, "tube_manager_schedule_ms");
return 1;
}
if ( !tube_manager_loop(mgr, &err) )
{
LS_LOG_ERR(err, "tube_manager_loop");
}
return 0;
}
