void Init(void)
{
//Check if Opengl version is at least 3.0
const GLubyte* glVersion( glGetString(GL_VERSION) );
int major = glVersion[0] - '0';
int minor = glVersion[2] - '0';
if( major < 3 || minor < 0 )
{
std::cerr<<"ERROR: Minimum OpenGL version required for this demo is 3.0. Your current version is "<<major<<"."<<minor<<std::endl;
exit(-1);
}
//Init glew
glewInit();
//Set clear color
glClearColor(1.0, 1.0, 1.0, 0.0);
//Create and bind the shader program
gProgram = CompileShaders( gVertexShaderSource, gFragmentShaderSource );
glUseProgram(gProgram);
glUniform1i(0,0); //Sampler refers to texture unit 0
GenerateGeometry();
GenerateArrayTexture();
}
// Called during render after backgrounds, borders, decorators, but before children, are rendered.
void ElementCircularBar::OnRender()
{
if(geometry_dirty)
GenerateGeometry();
gauge_geometry.Render(GetAbsoluteOffset(Rocket::Core::Box::CONTENT));
}
//#include "hpcg.hpp"
int main(int argc, char * argv[]) {
/*
HPCG_Params params;
HPCG_Init(&argc, &argv, params);
int size = params.comm_size, rank = params.comm_rank; // Number of MPI processes, My process ID
local_int_t nx,ny,nz;
nx = (local_int_t)params.nx;
ny = (local_int_t)params.ny;
nz = (local_int_t)params.nz;
int ierr = 0; // Used to check return codes on function calls
*/
// Construct the geometry and linear system
Geometry geom;
int size = 2048;
int rank = 2047;
int numThreads = 1;
int nx, ny, nz;
nx = ny = nz = 200;
GenerateGeometry(size, rank, numThreads, nx, ny, nz, geom);
global_int_t index = ((global_int_t) (nx * ny * nz)) * size - 1;
std::cout << "Global Index = " << index << std::endl;
int owningRank = ComputeRankOfMatrixRow(geom, index);
std::cout << "Owning rank should be " << size - 1 << ". Computed to be " << owningRank << "." << std::endl;
//HPCG_Finalize();
return 0 ;
}
void ElementImage::OnPropertyChange(const PropertyNameList& changed_properties)
{
Element::OnPropertyChange(changed_properties);
if (changed_properties.find(BACKGROUND_COLOR) != changed_properties.end() ||
changed_properties.find(OPACITY) != changed_properties.end()) {
GenerateGeometry();
}
}
// Renders the element.
void ElementImage::OnRender()
{
// Regenerate the geometry if required (this will be set if 'coords' changes but does not
// result in a resize).
if (geometry_dirty)
GenerateGeometry();
// Render the geometry beginning at this element's content region.
geometry.Render(GetAbsoluteOffset(Rocket::Core::Box::CONTENT));
}
// Regenerates the element's geometry.
void ElementImage::ProcessEvent(Rocket::Core::Event& event)
{
Element::ProcessEvent(event);
if (event.GetTargetElement() == this &&
event == "resize")
{
GenerateGeometry();
}
}
// Clears and regenerates all of the text's geometry.
void ElementTextDefault::GenerateGeometry(FontFaceHandle* font_face_handle)
{
// Release the old geometry ...
for (size_t i = 0; i < geometry.size(); ++i)
geometry[i].Release(true);
/// ... and generate it all again!
for (size_t i = 0; i < lines.size(); ++i)
GenerateGeometry(font_face_handle, lines[i]);
geometry_dirty = false;
}
// Adds a new line into the text element.
void ElementTextDefault::AddLine(const Vector2f& line_position, const WString& line)
{
FontFaceHandle* font_face_handle = GetFontFaceHandle();
if (font_face_handle == NULL)
return;
if (font_dirty)
UpdateFontConfiguration();
Vector2f baseline_position = line_position + Vector2f(0.0f, (float) font_face_handle->GetLineHeight() - font_face_handle->GetBaseline());
lines.push_back(Line(line, baseline_position));
GenerateGeometry(font_face_handle, lines.back());
geometry_dirty = false;
if (decoration_property != TEXT_DECORATION_NONE)
GenerateDecoration(font_face_handle, lines.back());
}
void ElementTextDefault::OnRender()
{
FontFaceHandle* font_face_handle = GetFontFaceHandle();
if (!font_face_handle)
return;
// If our font configuration has potentially changed, update it and force a geometry
// generation if necessary.
if (font_dirty &&
UpdateFontConfiguration())
{
geometry_dirty = true;
}
// Regenerate the geometry if the colour or font configuration has altered.
if (geometry_dirty)
GenerateGeometry(font_face_handle);
Vector2f translation = GetAbsoluteOffset();
bool render = true;
Vector2i clip_origin;
Vector2i clip_dimensions;
if (GetContext()->GetActiveClipRegion(clip_origin, clip_dimensions))
{
float clip_top = clip_origin.y;
float clip_left = clip_origin.x;
float clip_right = (clip_origin.x + clip_dimensions.x);
float clip_bottom = (clip_origin.y + clip_dimensions.y);
float line_height = GetFontFaceHandle()->GetLineHeight();
render = false;
for (size_t i = 0; i < lines.size(); ++i)
{
const Line& line = lines[i];
float x = translation.x + line.position.x;
float y = translation.y + line.position.y;
bool render_line = !(x > clip_right);
render_line = render_line && !(x + line.width < clip_left);
render_line = render_line && !(y - line_height > clip_bottom);
render_line = render_line && !(y < clip_top);
if (render_line)
{
render = true;
break;
}
}
}
if (render)
{
for (size_t i = 0; i < geometry.size(); ++i)
geometry[i].Render(translation);
}
if (decoration_property != TEXT_DECORATION_NONE)
decoration.Render(translation);
}
