void Initialize() // must be called only once
{
//do some initialization and create the regions in here
SDL_WM_SetCaption("Scorpion", NULL); // Set the window title
font1 = initFont("font/data/font1");
font2 = initFont("font/data/font2");
InitDeck(screen);
Scorpion.Initialize(screen);
//index 0: The Stock
Scorpion.CreateRegion(CRD_STOCK,
CRD_VISIBLE|CRD_3D,
0,
0,
CRD_OSYMBOL,
(SCREEN_WIDTH / 2) - (CARDWIDTH / 2), 400,
2, 2);
//index 1-7: The tableau
for(int i=1; i <= 7; i++){
Scorpion.CreateRegion(CRD_TABLEAU,
CRD_VISIBLE|CRD_FACEUP|CRD_DODRAG|CRD_DODROP,
CRD_DOLOWER|CRD_DOKING,
CRD_DRAGCARDS,
CRD_HSYMBOL,
(CARDWIDTH * (i - 1)) + (i * 35), 10,
0, 25);
}
}
void zaFont::initbyPath(const char * path ,int size)
{
m_dpi = bbutil_calculate_dpi(0);
if (path ==NULL || path[0]==0)
{
if (access("/usr/fonts/font_repository/adobe/AdobeHeitiStd-Regular.otf",F_OK)>=0)
{
sprintf(m_path,"%s","/usr/fonts/font_repository/adobe/AdobeHeitiStd-Regular.otf");
}
else if (access("/usr/fonts/font_repository/monotype/MHeiB.GB18030_200910.ttf",F_OK)>=0)
{
sprintf(m_path,"%s","/usr/fonts/font_repository/monotype/MHeiB.GB18030_200910.ttf");
}
initFont(m_path);
}
else
{
sprintf(m_path,"%s",path);
initFont(m_path);
}
m_size = size;
char en_charmap[128*2];
for (int i = 0 ; i < 128; i ++)
{
en_charmap[i*2] = (char) (i % 256);
en_charmap[i*2+1] =(char) (i/ 256);
}
load_font(en_charmap,128*2);
}
// set the callbacks up in the constructor
Engine::Engine()
{
glictGlobals.paintrectCallback = Engine::draw_rectangle;
glictGlobals.paintrectlinesCallback = Engine::draw_rectangle_lines;
glictGlobals.enableGlTranslate = false;
glictGlobals.windowTitleColor.r = glictGlobals.windowTitleColor.g = glictGlobals.windowTitleColor.b = 0.6;
doResize(options.w, options.h);
m_video_bpp = options.bpp;
m_screen = NULL;
initFont(&m_sysfont, "system");
initFont(&m_minifont, "minifont");
initFont(&m_aafont, "aafont");
initFont(&m_gamefont, "gamefont");
m_fps = 0.;
m_ui = NULL;
m_light = NULL;
m_cursorBasic = m_cursorUse = NULL;
// remember default cursor
resetDefaultCursor();
g_frames = 0;
m_lastfpsupdate = SDL_GetTicks();
}
// ...
GLWidget::GLWidget(QWidget* parent) : QGLWidget(QGLFormat(QGL::DoubleBuffer | QGL::Rgba | QGL::DepthBuffer), parent)
{
makeCurrent();
initFont();
resetSelection();
}
/*
* SetFont - process a set font command
*/
vi_rc SetFont( const char *data )
{
LOGFONT l;
STUPIDNTINT index;
if( !getInt( &index, &data ) ) {
return( ERR_INVALID_FONT );
}
if( index >= MAX_FONTS || index < 0 ) {
return( ERR_INVALID_FONT );
}
initFont( index, &l );
/*
* Either the user can specify 'setfont x' and choose a font
* using the common dialog - or he/she can do the full
* 'setfont x n n n n n n... ad nauseum to define a font.
*/
while( isspace( *data ) ) {
data++;
}
if( *data == 0 ) {
if( !userPickFont( &l, root_window_id ) ) {
return( ERR_NO_ERR );
}
} else {
if( !getLogFont( &l, &data ) ) {
return( ERR_INVALID_FONT );
}
}
SetUpFont( &l, index );
return( ERR_NO_ERR );
} /* SetFont */
void CustomLabel::init() {
initFont();
processText();
edit_ = new QLineEdit(this);
edit_->hide();
connect(edit_, SIGNAL(editingFinished()), this, SLOT(editingFinished()));
}
const char *font_init(font_t *self, const char *filename, int ptsize) {
const char *errmsg = NULL;
void *data = NULL;
FILE *fp = NULL;
memset(self, 0, sizeof(*self));
/* Load font file */
int size;
data = filesystem_read(filename, &size);
if (!data) {
errmsg = "could not open font file";
goto fail;
}
/* Init font */
errmsg = initFont(self, data, ptsize);
if (errmsg) {
goto fail;
}
/* Free font data */
filesystem_free(data);
data = NULL;
return NULL;
fail:
if (fp) fclose(fp);
filesystem_free(data);
return errmsg;
}
bool init(HWND hWnd)
{
g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
if(!g_pD3D) {
return false;
}
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &g_pd3dDevice);
if(!g_pd3dDevice) {
return false;
}
bool res = initFont();
initSystem();
return res;
}
irr::gui::IGUIFont* FontEngine::getFont(unsigned int font_size, FontMode mode)
{
if (mode == FM_Unspecified) {
mode = m_currentMode;
}
else if ((mode == FM_Mono) && (m_currentMode == FM_Simple)) {
mode = FM_SimpleMono;
}
if (font_size == FONT_SIZE_UNSPECIFIED) {
font_size = m_default_size[mode];
}
if ((font_size == m_lastSize) && (mode == m_lastMode)) {
return m_lastFont;
}
if (m_font_cache[mode].find(font_size) == m_font_cache[mode].end()) {
initFont(font_size, mode);
}
if (m_font_cache[mode].find(font_size) == m_font_cache[mode].end()) {
return NULL;
}
m_lastSize = font_size;
m_lastMode = mode;
m_lastFont = m_font_cache[mode][font_size];
return m_font_cache[mode][font_size];
}
int main(void) {
volatile unsigned int initFlg = 1;
platformInit();
static char buf[512];
static char fmmirrorbuf[512];
for(int i=0;i < sizeof buf; i++){
buf[i] = i;
}
////////////////////////////////////////////
//dmtimerInitForMatch(MODULE_ID_TIMER3,0xffffffff-0x7ffffff,(0xffffffff-0x7ffffff/2),DMTIMER_FLAG_INTENABLE_MATCH);
//////////////////////////////////////////////////////
/* spiFmromInit(fmmirrorbuf, sizeof fmmirrorbuf);
spiFmromRead(0, buf, 1);
spiFmromWren();
delay(500);
spiFmromWrite(0, buf, sizeof buf);
delay(500);
spiFmromRead(0, buf, sizeof buf);
while (1);*/
moduleEnable(MODULE_ID_GPIO0);
LCDRasterStart(); //lcd
LCDBackLightON();
MMCSDP_CtrlInfoInit(&mmcsdctr[0], MODULE_ID_MMCSD0, 48000000, MMCSD_BUSWIDTH_4BIT, 0,
&card0, NULL, NULL, NULL);
MMCSDP_CtrlInit(&mmcsdctr[0]);
MMCSDP_CardInit(&mmcsdctr[0], MMCSD_CARD_AUTO);
TouchCalibrate(0);
static FATFS inandfs;
f_mount(0, &inandfs);
initFont(FONT_LOAD_ADDR);
drawText();
}
void
GLHelper::drawTextBox(const std::string& text, const Position& pos,
const double layer, const double size,
const RGBColor& txtColor, const RGBColor& bgColor, const RGBColor& borderColor,
const double angle,
const double relBorder,
const double relMargin) {
if (!initFont()) {
return;
};
if (bgColor.alpha() != 0) {
const double boxAngle = 90;
const double stringWidth = size / myFontSize * fonsTextBounds(myFont, 0, 0, text.c_str(), nullptr, nullptr);
const double borderWidth = size * relBorder;
const double boxHeight = size * (0.32 + 0.6 * relMargin);
const double boxWidth = stringWidth + size * relMargin;
glPushMatrix();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glTranslated(pos.x(), pos.y(), layer);
glRotated(-angle, 0, 0, 1);
Position left(-boxWidth * 0.5, 0);
setColor(borderColor);
drawBoxLine(left, boxAngle, boxWidth, boxHeight);
left.add(borderWidth * 1.5, 0);
setColor(bgColor);
glTranslated(0, 0, 0.01);
drawBoxLine(left, boxAngle, boxWidth - 3 * borderWidth, boxHeight - 2 * borderWidth);
glPopMatrix();
}
drawText(text, pos, layer + 0.02, size, txtColor, angle);
}
Caches::Caches(): Singleton<Caches>(), mInitialized(false) {
init();
initFont();
initExtensions();
initConstraints();
initProperties();
mDebugLevel = readDebugLevel();
ALOGD("Enabling debug mode %d", mDebugLevel);
}
static int loadGraphics(void)
{
LOADPNG(background);
LOADPNG(logo);
LOADPNG(device_generic);
LOADPNG(device_hfsplus);
LOADPNG(device_ext3);
LOADPNG(device_fat16);
LOADPNG(device_fat32);
LOADPNG(device_ntfs);
LOADPNG(device_cdrom);
LOADPNG(device_selection);
LOADPNG(device_scroll_prev);
LOADPNG(device_scroll_next);
LOADPNG(menu_boot);
LOADPNG(menu_verbose);
LOADPNG(menu_ignore_caches);
LOADPNG(menu_single_user);
LOADPNG(menu_memory_info);
LOADPNG(menu_video_info);
LOADPNG(menu_help);
LOADPNG(menu_verbose_disabled);
LOADPNG(menu_ignore_caches_disabled);
LOADPNG(menu_single_user_disabled);
LOADPNG(menu_selection);
LOADPNG(progress_bar);
LOADPNG(progress_bar_background);
LOADPNG(text_scroll_prev);
LOADPNG(text_scroll_next);
LOADPNG(font_console);
LOADPNG(font_small);
initFont( &font_console, &images[iFontConsole]);
initFont( &font_small, &images[iFontSmall]);
return 0;
}
/*
* PickFont - pick a new font with the font dialog
*/
void PickFont( font_type index, HWND parent )
{
LOGFONT l;
initFont( index, &l );
if( !userPickFont( &l, parent ) ) {
return;
}
SetUpFont( &l, index );
} /* PickFont */
void FontEngine::updateFontCache()
{
/* the only font to be initialized is default one,
* all others are re-initialized on demand */
initFont(m_default_size[m_currentMode], m_currentMode);
/* reset font quick access */
m_lastMode = FM_Unspecified;
m_lastSize = 0;
m_lastFont = NULL;
}
sSpellSlot(int posX_, int posY_, int width_, int height_)
{
posX = posX_;
posY = posY_;
width = width_;
height = height_;
action = NULL;
font = NULL;
tooltip = NULL;
initFont();
}
Text::Text(
std::string _text,
fontName _name,
fontSize _size,
const Color& _color,
const float _originX,
const float _originY,
const u16 _flags) :
Rectangle(TEXT_LAYER,0,0,_originX,_originY),
name(_name),
size(_size),
color(_color),
gxFont(new FreeTypeGX),
flags(_flags)
{
initFont();
setText(_text);
update();
}
View::View(int x, int y, bool fullScreen, Model* model, int border)
{
VIDEOFLAG = SDL_SWSURFACE;
if (fullScreen)
{
VIDEOFLAG = VIDEOFLAG | SDL_FULLSCREEN;
}
modeX = x;
modeY = y;
this->border = border;
this->model = model;
if (!initGUI())
{
string errorText = "Error: Video Failed To Initialise.\n";
errorText += SDL_GetError();
throw CAException(&errorText[0]);
}
initSurfaces();
initFont();
}
void
GLHelper::drawText(const std::string& text, const Position& pos,
const double layer, const double size,
const RGBColor& col, const double angle, const int align,
double width) {
if (width <= 0) {
width = size;
}
if (!initFont()) {
return;
};
glPushMatrix();
glAlphaFunc(GL_GREATER, 0.5);
glEnable(GL_ALPHA_TEST);
glTranslated(pos.x(), pos.y(), layer);
glScaled(width / myFontSize, size / myFontSize, 1.);
glRotated(-angle, 0, 0, 1);
fonsSetAlign(myFont, align == 0 ? FONS_ALIGN_CENTER | FONS_ALIGN_MIDDLE : align);
fonsSetColor(myFont, glfonsRGBA(col.red(), col.green(), col.blue(), col.alpha()));
fonsDrawText(myFont, 0., 0., text.c_str(), nullptr);
glPopMatrix();
}
void glInit()
{
initFont();
// create openGL functions
for (int i=0; i<NUM_GL_NAMES; i++) glFP[i] = (GenFP)wglGetProcAddress(glnames[i]);
// Create and link shader and stuff:
// I will have to separate these to be able to use more than one shader...
// TODO: I should make some sort of compiling and linking loop...
// create noise Texture
#ifdef FLOAT_TEXTURE
for (int i = 0; i < NOISE_TEXTURE_SIZE * NOISE_TEXTURE_SIZE * NOISE_TEXTURE_SIZE * 4; i++)
{
noiseData[i] = frand() - 0.5f;
}
#else
for (int i = 0; i < NOISE_TEXTURE_SIZE * NOISE_TEXTURE_SIZE * NOISE_TEXTURE_SIZE * 4; i++)
{
noiseData[i] = (unsigned char)rand();
}
#endif
// init objects:
GLuint vMainObject = glCreateShader(GL_VERTEX_SHADER);
GLuint fMainBackground = glCreateShader(GL_FRAGMENT_SHADER);
GLuint fOffscreenCopy = glCreateShader(GL_FRAGMENT_SHADER);
shaderPrograms[0] = glCreateProgram();
shaderPrograms[1] = glCreateProgram();
// compile sources:
glShaderSource(vMainObject, 1, &vertexMainObject, NULL);
glCompileShader(vMainObject);
glShaderSource(fMainBackground, 1, &fragmentMainBackground, NULL);
glCompileShader(fMainBackground);
glShaderSource(fOffscreenCopy, 1, &fragmentOffscreenCopy, NULL);
glCompileShader(fOffscreenCopy);
// Check programs
int tmp, tmp2;
glGetShaderiv(vMainObject, GL_COMPILE_STATUS, &tmp);
if (!tmp)
{
glGetShaderInfoLog(vMainObject, 4096, &tmp2, err);
err[tmp2]=0;
MessageBox(hWnd, err, "vMainObject shader error", MB_OK);
return;
}
glGetShaderiv(fMainBackground, GL_COMPILE_STATUS, &tmp);
if (!tmp)
{
glGetShaderInfoLog(fMainBackground, 4096, &tmp2, err);
err[tmp2]=0;
MessageBox(hWnd, err, "fMainBackground shader error", MB_OK);
return;
}
glGetShaderiv(fOffscreenCopy, GL_COMPILE_STATUS, &tmp);
if (!tmp)
{
glGetShaderInfoLog(fOffscreenCopy, 4096, &tmp2, err);
err[tmp2]=0;
MessageBox(hWnd, err, "fOffscreeCopy shader error", MB_OK);
return;
}
// link shaders:
glAttachShader(shaderPrograms[0], vMainObject);
glAttachShader(shaderPrograms[0], fMainBackground);
glLinkProgram(shaderPrograms[0]);
glAttachShader(shaderPrograms[1], vMainObject);
glAttachShader(shaderPrograms[1], fOffscreenCopy);
glLinkProgram(shaderPrograms[1]);
// Create a rendertarget texture
glGenTextures(1, &offscreenTexture);
glBindTexture(GL_TEXTURE_2D, offscreenTexture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, OFFSCREEN_WIDTH, OFFSCREEN_HEIGHT, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
#if 1
// RLE uncompress
int pos = 0;
for (int k = 0; k < numValues; k++)
{
for (int i = 0; i < fontLength[k]; i++)
{
fontCompressed[0][0][pos+fontLength[k]-i-1] = fontValues[k];
}
pos += fontLength[k];
}
// uncompress font
for (int color = 0; color < 4; color++)
{
for (int y = 0; y < fontHeight; y++)
{
for (int x = 0; x < fontWidth; x++)
{
font[y][x][color] = fontCompressed[color][y][x];
}
}
}
// Set texture.
glEnable(GL_TEXTURE_3D); // automatic?
glGenTextures(1, &noiseTexture);
glBindTexture(GL_TEXTURE_3D, noiseTexture);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
#ifdef FLOAT_TEXTURE
glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA32F,
NOISE_TEXTURE_SIZE, NOISE_TEXTURE_SIZE, NOISE_TEXTURE_SIZE,
0, GL_RGBA, GL_FLOAT, noiseData);
#else
glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA8,
NOISE_TEXTURE_SIZE, NOISE_TEXTURE_SIZE, NOISE_TEXTURE_SIZE,
0, GL_RGBA, GL_UNSIGNED_BYTE, noiseData);
#endif
// Load font texture
glGenTextures(1, &fontTexture);
glBindTexture(GL_TEXTURE_2D, fontTexture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// TODO: Mip Mapping!!!!
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA8, fontWidth, fontHeight,
GL_BGRA, GL_UNSIGNED_BYTE, font);
glDisable(GL_TEXTURE_2D); // Enable Texture Mapping
#endif
}
const char *font_initEmbedded(font_t *self, int ptsize) {
#include "font_ttf.h"
return initFont(self, font_ttf, ptsize);
}
/**
* Gibt Infos, über die Unterbrechungspunkte in einem Text
*
* @param[in] text Text, der auf Zeilen verteilt werden soll
* @param[in] primary_width Maximale Breite der ersten Zeile
* @param[in] secondary_width Maximale Breite der weiteren Zeilen
*/
glArchivItem_Font::WrapInfo glArchivItem_Font::GetWrapInfo(const std::string& text, const unsigned short primary_width,
const unsigned short secondary_width)
{
if(!fontNoOutline)
initFont();
RTTR_Assert(isValidUTF8(text)); // Can only handle UTF-8 strings!
// Current line width
unsigned line_width = 0;
// Width of current word
unsigned word_width = 0;
unsigned curMaxLineWidth = primary_width;
WrapInfo wi;
// We start the first line at the first char (so wi.positions.size() == numLines)
wi.positions.push_back(0);
utf8Iterator it(text.begin(), text.begin(), text.end());
utf8Iterator itEnd(text.end(), text.begin(), text.end());
utf8Iterator itWordStart = it;
const unsigned spaceWidth = CharWidth(' ');
for(;; ++it)
{
uint32_t curChar = (it != itEnd) ? *it : 0;
// Word ended
if(curChar == 0 || curChar == '\n' || curChar == ' ')
{
// Is the current word to long for the current line
if(word_width + line_width > curMaxLineWidth)
{
// Word does not fit -> Start new line
// Can we fit the word in one line?
if(word_width <= secondary_width)
{
// New line starts at index of word start
wi.positions.push_back(static_cast<unsigned>(itWordStart.base() - text.begin()));
line_width = 0;
} else
{
// Word does not even fit on one line -> Put as many letters in one line as possible
for(utf8Iterator itWord = itWordStart; itWord != it; ++itWord)
{
unsigned letter_width = CharWidth(*itWord);
// Can we fit the letter onto current line?
if(line_width + letter_width <= curMaxLineWidth)
line_width += letter_width; // Add it
else
{
// Create new line at this letter
wi.positions.push_back(static_cast<unsigned>(itWord.base() - text.begin()));
line_width = letter_width;
itWordStart = nextIt(itWord);
}
}
// Restart word
word_width = 0;
}
curMaxLineWidth = secondary_width;
}
if(curChar == 0)
break;
else if(curChar == ' ')
{
// Set up this line if we are going to continue it (not at line break or text end)
// Line contains word and whitespace
line_width += word_width + spaceWidth;
word_width = 0;
itWordStart = nextIt(it);
} else
{
// If line break add new line (after all the word-breaking above)
itWordStart = nextIt(it);
if(itWordStart == itEnd)
break; // Reached end
word_width = 0;
line_width = 0;
wi.positions.push_back(static_cast<unsigned>(itWordStart.base() - text.begin()));
}
} else
{
// Some char -> Add its width
word_width += CharWidth(curChar);
}
}
// Ignore trailing newline
if(wi.positions.back() + 1 >= text.length() && wi.positions.size() > 1)
wi.positions.pop_back();
return wi;
}
/**
* Zeichnet einen Text.
*
* @param[in] x X-Koordinate
* @param[in] y Y-Koordinate
* @param[in] text Der Text
* @param[in] format Format des Textes (verodern)
* @p FontStyle::LEFT - Text links ( standard )
* @p FontStyle::CENTER - Text mittig
* @p FontStyle::RIGHT - Text rechts
* @p FontStyle::TOP - Text oben ( standard )
* @p FontStyle::VCENTER - Text vertikal zentriert
* @p FontStyle::BOTTOM - Text unten
* @param[in] color Farbe des Textes
* @param[in] length Länge des Textes
* @param[in] max maximale Länge
* @param end Suffix for displaying a truncation of the text (...)
*/
void glArchivItem_Font::Draw(DrawPoint pos, const std::string& text, FontStyle format, unsigned color, unsigned short length,
unsigned short maxWidth, const std::string& end)
{
if(!fontNoOutline)
initFont();
RTTR_Assert(isValidUTF8(text));
// Breite bestimmen
if(length == 0)
length = (unsigned short)text.length();
unsigned maxNumChars;
unsigned short textWidth;
bool drawEnd;
if(maxWidth == 0xFFFF)
{
maxNumChars = length;
textWidth = getWidth(text, length);
drawEnd = false;
} else
{
RTTR_Assert(isValidUTF8(end));
textWidth = getWidth(text, length, maxWidth, &maxNumChars);
if(!end.empty() && maxNumChars < length)
{
unsigned short endWidth = getWidth(end);
// If "end" does not fit, draw nothing
if(textWidth < endWidth)
return;
// Wieviele Buchstaben gehen in den "Rest" (ohne "end")
textWidth = getWidth(text, length, textWidth - endWidth, &maxNumChars) + endWidth;
drawEnd = true;
} else
drawEnd = false;
}
if(maxNumChars == 0)
return;
auto itEnd = text.cbegin();
std::advance(itEnd, maxNumChars);
// Vertical alignment (assumes 1 line only!)
if(format.is(FontStyle::BOTTOM))
pos.y -= dy;
else if(format.is(FontStyle::VCENTER))
pos.y -= dy / 2;
// Horizontal center must change current line only. Everything else changes the start point
DrawPoint curPos(pos);
// Horizontal alignment
if(format.is(FontStyle::RIGHT))
curPos.x = pos.x -= textWidth;
else if(format.is(FontStyle::CENTER))
{
unsigned short line_width;
const auto itNl = std::find(text.cbegin(), itEnd, '\n');
if(itNl != itEnd)
line_width = getWidthInternal(text.cbegin(), itNl);
else
line_width = textWidth;
curPos.x = pos.x - line_width / 2;
}
texList.texCoords.clear();
texList.vertices.clear();
for(auto it = text.begin(); it != itEnd;)
{
const uint32_t curChar = utf8::next(it, itEnd);
if(curChar == '\n')
{
if(format.is(FontStyle::CENTER))
{
unsigned short line_width;
const auto itNl = std::find(it, itEnd, '\n');
line_width = getWidthInternal(it, itNl);
curPos.x = pos.x - line_width / 2;
} else
curPos.x = pos.x;
curPos.y += dy;
} else
DrawChar(curChar, texList, curPos);
}
if(drawEnd)
{
for(auto it = end.begin(); it != end.end();)
{
const uint32_t curChar = utf8::next(it, end.end());
if(curChar == '\n')
{
curPos.x = pos.x;
curPos.y += dy;
} else
DrawChar(curChar, texList, curPos);
}
}
if(texList.vertices.empty())
return;
// Get texture first as it might need to be created
glArchivItem_Bitmap& usedFont = format.is(FontStyle::NO_OUTLINE) ? *fontNoOutline : *fontWithOutline;
unsigned texture = usedFont.GetTexture();
if(!texture)
return;
const GlPoint texSize(usedFont.GetTexSize());
RTTR_Assert(texList.texCoords.size() == texList.vertices.size());
RTTR_Assert(texList.texCoords.size() % 4u == 0);
// Vectorizable loop
for(unsigned i = 0; i < texList.texCoords.size(); i += 4)
{
for(int j = 0; j < 4; j++)
texList.texCoords[i + j] /= texSize;
}
glVertexPointer(2, GL_FLOAT, 0, &texList.vertices[0]);
glTexCoordPointer(2, GL_FLOAT, 0, &texList.texCoords[0]);
VIDEODRIVER.BindTexture(texture);
glColor4ub(GetRed(color), GetGreen(color), GetBlue(color), GetAlpha(color));
glDrawArrays(GL_QUADS, 0, texList.vertices.size());
}
int main(int argc, char* argv[])
{
b3SetCustomEnterProfileZoneFunc(b3ProfileManager::Start_Profile);
b3SetCustomLeaveProfileZoneFunc(b3ProfileManager::Stop_Profile);
b3SetCustomPrintfFunc(myprintf);
b3Vector3 test=b3MakeVector3(1,2,3);
test.x = 1;
test.y = 4;
b3Printf("main start");
b3CommandLineArgs args(argc,argv);
if (args.CheckCmdLineFlag("help"))
{
Usage();
return 0;
}
args.GetCmdLineArgument("selected_demo",selectedDemo);
bool benchmark=args.CheckCmdLineFlag("benchmark");
args.GetCmdLineArgument("max_framecount",maxFrameCount);
dump_timings=args.CheckCmdLineFlag("dump_timings");
#ifndef B3_NO_PROFILE
b3ProfileManager::Reset();
#endif //B3_NO_PROFILE
window = new b3gDefaultOpenGLWindow();
b3gWindowConstructionInfo wci(g_OpenGLWidth,g_OpenGLHeight);
window->createWindow(wci);
window->setResizeCallback(MyResizeCallback);
window->setMouseMoveCallback(MyMouseMoveCallback);
window->setMouseButtonCallback(MyMouseButtonCallback);
window->setKeyboardCallback(MyKeyboardCallback);
window->setWindowTitle("Bullet 3.x GPU Rigid Body http://bulletphysics.org");
#ifndef __APPLE__
glewInit();
#endif
gui = new GwenUserInterface();
b3Printf("started GwenUserInterface\n");
GLPrimitiveRenderer prim(g_OpenGLWidth,g_OpenGLHeight);
stash = initFont(&prim);
if (gui)
{
gui->init(g_OpenGLWidth,g_OpenGLHeight,stash,window->getRetinaScale());
b3Printf("init fonts\n");
gui->setToggleButtonCallback(MyButtonCallback);
gui->registerToggleButton(MYPAUSE,"Pause");
gui->registerToggleButton(MYPROFILE,"Profile");
gui->registerToggleButton(MYRESET,"Reset");
int numItems = sizeof(allDemos)/sizeof(CpuDemo::CreateFunc*);
demoNames.clear();
for (int i=0;i<numItems;i++)
{
CpuDemo* demo = allDemos[i]();
demoNames.push_back(demo->getName());
delete demo;
}
gui->registerComboBox(MYCOMBOBOX1,numItems,&demoNames[0]);
gui->setComboBoxCallback(MyComboBoxCallback);
}
do
{
bool syncOnly = false;
gReset = false;
static bool once=true;
//glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
glClearColor(1,1,1,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
window->setWheelCallback(b3DefaultWheelCallback);
{
CpuDemo* demo = allDemos[selectedDemo]();
sDemo = demo;
// demo->myinit();
bool useGpu = false;
int maxObjectCapacity=1024*1024;//128*1024;
int maxShapeCapacityInBytes=10*1024*1024;
//maxObjectCapacity = b3Max(maxObjectCapacity,ci.arraySizeX*ci.arraySizeX*ci.arraySizeX+10);
CpuDemo::ConstructionInfo ci;
ci.m_instancingRenderer = new GLInstancingRenderer(maxObjectCapacity,maxShapeCapacityInBytes);
ci.m_window = window;
ci.m_gui = gui;
ci.m_instancingRenderer->init();
ci.m_instancingRenderer->resize(g_OpenGLWidth,g_OpenGLHeight);
ci.m_instancingRenderer->InitShaders();
ci.m_primRenderer = &prim;
// render.init();
{
demo->initPhysics(ci);
}
FILE* csvFile = 0;
FILE* detailsFile = 0;
if (benchmark)
{
gPause = false;
char prefixFileName[1024];
char csvFileName[1024];
char detailsFileName[1024];
//todo: move this time stuff into the Platform/Window class
#ifdef _WIN32
SYSTEMTIME time;
GetLocalTime(&time);
char buf[1024];
DWORD dwCompNameLen = 1024;
if (0 != GetComputerName(buf, &dwCompNameLen))
{
printf("%s", buf);
} else
{
printf("unknown", buf);
}
sprintf(prefixFileName,"%s_%s_%s_date_%d-%d-%d_time_%d-%d-%d","CPU",buf,demoNames[selectedDemo],time.wDay,time.wMonth,time.wYear,time.wHour,time.wMinute,time.wSecond);
#else
timeval now;
gettimeofday(&now,0);
struct tm* ptm;
ptm = localtime (&now.tv_sec);
char buf[1024];
#ifdef __APPLE__
sprintf(buf,"MacOSX");
#else
sprintf(buf,"Unix");
#endif
sprintf(prefixFileName,"%s_%s_%s_%d_%d_%d_date_%d-%d-%d_time_%d-%d-%d",info.m_deviceName,buf,demoNames[selectedDemo],ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ,
ptm->tm_mday,
ptm->tm_mon+1,
ptm->tm_year+1900,
ptm->tm_hour,
ptm->tm_min,
ptm->tm_sec);
#endif
sprintf(csvFileName,"%s.csv",prefixFileName);
sprintf(detailsFileName,"%s.txt",prefixFileName);
printf("Open csv file %s and details file %s\n", csvFileName,detailsFileName);
//GetSystemTime(&time2);
csvFile=fopen(csvFileName,"w");
detailsFile = fopen(detailsFileName,"w");
if (detailsFile)
defaultOutput = detailsFile;
//if (f)
// fprintf(f,"%s (%dx%dx%d=%d),\n", g_deviceName,ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ,ci.arraySizeX*ci.arraySizeY*ci.arraySizeZ);
}
do
{
GLint err = glGetError();
assert(err==GL_NO_ERROR);
if (exportFrame || exportMovie)
{
if (!renderTexture)
{
renderTexture = new GLRenderToTexture();
GLuint renderTextureId;
glGenTextures(1, &renderTextureId);
// "Bind" the newly created texture : all future texture functions will modify this texture
glBindTexture(GL_TEXTURE_2D, renderTextureId);
// Give an empty image to OpenGL ( the last "0" )
//glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, g_OpenGLWidth,g_OpenGLHeight, 0,GL_RGBA, GL_UNSIGNED_BYTE, 0);
//glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA32F, g_OpenGLWidth,g_OpenGLHeight, 0,GL_RGBA, GL_FLOAT, 0);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA32F, g_OpenGLWidth,g_OpenGLHeight, 0,GL_RGBA, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
renderTexture->init(g_OpenGLWidth,g_OpenGLHeight,renderTextureId, RENDERTEXTURE_COLOR);
}
bool result = renderTexture->enable();
}
err = glGetError();
assert(err==GL_NO_ERROR);
b3ProfileManager::Reset();
b3ProfileManager::Increment_Frame_Counter();
// render.reshape(g_OpenGLWidth,g_OpenGLHeight);
ci.m_instancingRenderer->resize(g_OpenGLWidth,g_OpenGLHeight);
prim.setScreenSize(g_OpenGLWidth,g_OpenGLHeight);
err = glGetError();
assert(err==GL_NO_ERROR);
window->startRendering();
err = glGetError();
assert(err==GL_NO_ERROR);
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);//|GL_STENCIL_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
if (!gPause)
{
B3_PROFILE("clientMoveAndDisplay");
demo->clientMoveAndDisplay();
}
else
{
}
{
B3_PROFILE("renderScene");
demo->renderScene();
}
err = glGetError();
assert(err==GL_NO_ERROR);
/*if (demo->getDynamicsWorld() && demo->getDynamicsWorld()->getNumCollisionObjects())
{
B3_PROFILE("renderPhysicsWorld");
b3AlignedObjectArray<b3CollisionObject*> arr = demo->getDynamicsWorld()->getCollisionObjectArray();
b3CollisionObject** colObjArray = &arr[0];
render.renderPhysicsWorld(demo->getDynamicsWorld()->getNumCollisionObjects(),colObjArray, syncOnly);
syncOnly = true;
}
*/
if (exportFrame || exportMovie)
{
char fileName[1024];
sprintf(fileName,"screenShot%d.png",frameIndex++);
writeTextureToPng(g_OpenGLWidth,g_OpenGLHeight,fileName);
exportFrame = false;
renderTexture->disable();
}
{
B3_PROFILE("gui->draw");
if (gui && gDrawGui)
gui->draw(g_OpenGLWidth,g_OpenGLHeight);
}
err = glGetError();
assert(err==GL_NO_ERROR);
{
B3_PROFILE("window->endRendering");
window->endRendering();
}
err = glGetError();
assert(err==GL_NO_ERROR);
{
B3_PROFILE("glFinish");
}
if (dump_timings)
{
b3ProfileManager::dumpAll(stdout);
}
if (csvFile)
{
static int frameCount=0;
if (frameCount>0)
{
DumpSimulationTime(csvFile);
if (detailsFile)
{
fprintf(detailsFile,"\n==================================\nFrame %d:\n", frameCount);
b3ProfileManager::dumpAll(detailsFile);
}
}
if (frameCount>=maxFrameCount)
window->setRequestExit();
frameCount++;
}
if (gStep)
gPause=true;
} while (!window->requestedExit() && !gReset);
demo->exitPhysics();
b3ProfileManager::CleanupMemory();
delete ci.m_instancingRenderer;
delete demo;
sDemo = 0;
if (detailsFile)
{
fclose(detailsFile);
detailsFile=0;
}
if (csvFile)
{
fclose(csvFile);
csvFile=0;
}
}
} while (gReset);
if (gui)
gui->setComboBoxCallback(0);
{
delete gui;
gui=0;
exitFont();
window->closeWindow();
delete window;
window = 0;
}
return 0;
}
int main(int argc, char* argv[])
{
b3SetCustomPrintfFunc(myprintf);
b3Vector3 test(1,2,3);
test.x = 1;
test.y = 4;
printf("main start");
b3CommandLineArgs args(argc,argv);
ParticleDemo::ConstructionInfo ci;
if (args.CheckCmdLineFlag("help"))
{
Usage();
return 0;
}
args.GetCmdLineArgument("selected_demo",selectedDemo);
if (args.CheckCmdLineFlag("new_batching"))
{
useNewBatchingKernel = true;
}
bool benchmark=args.CheckCmdLineFlag("benchmark");
dump_timings=args.CheckCmdLineFlag("dump_timings");
ci.useOpenCL = !args.CheckCmdLineFlag("disable_opencl");
ci.m_useConcaveMesh = true;//args.CheckCmdLineFlag("use_concave_mesh");
if (ci.m_useConcaveMesh)
{
enableExperimentalCpuConcaveCollision = true;
}
args.GetCmdLineArgument("cl_device", ci.preferredOpenCLDeviceIndex);
args.GetCmdLineArgument("cl_platform", ci.preferredOpenCLPlatformIndex);
args.GetCmdLineArgument("x_dim", ci.arraySizeX);
args.GetCmdLineArgument("y_dim", ci.arraySizeY);
args.GetCmdLineArgument("z_dim", ci.arraySizeZ);
args.GetCmdLineArgument("x_gap", ci.gapX);
args.GetCmdLineArgument("y_gap", ci.gapY);
args.GetCmdLineArgument("z_gap", ci.gapZ);
#ifndef B3_NO_PROFILE
b3ProfileManager::Reset();
#endif //B3_NO_PROFILE
window = new b3gDefaultOpenGLWindow();
b3gWindowConstructionInfo wci(g_OpenGLWidth,g_OpenGLHeight);
window->createWindow(wci);
window->setResizeCallback(MyResizeCallback);
window->setMouseMoveCallback(MyMouseMoveCallback);
window->setMouseButtonCallback(MyMouseButtonCallback);
window->setKeyboardCallback(MyKeyboardCallback);
window->setWindowTitle("Bullet 3.x GPU Rigid Body http://bulletphysics.org");
printf("-----------------------------------------------------\n");
#ifndef __APPLE__
glewInit();
#endif
gui = new GwenUserInterface();
printf("started GwenUserInterface");
GLPrimitiveRenderer prim(g_OpenGLWidth,g_OpenGLHeight);
stash = initFont(&prim);
gui->init(g_OpenGLWidth,g_OpenGLHeight,stash,window->getRetinaScale());
printf("init fonts");
gui->setToggleButtonCallback(MyButtonCallback);
gui->registerToggleButton(MYPAUSE,"Pause");
gui->registerToggleButton(MYPROFILE,"Profile");
gui->registerToggleButton(MYRESET,"Reset");
int numItems = sizeof(allDemos)/sizeof(ParticleDemo::CreateFunc*);
demoNames.clear();
for (int i=0;i<numItems;i++)
{
GpuDemo* demo = allDemos[i]();
demoNames.push_back(demo->getName());
delete demo;
}
gui->registerComboBox(MYCOMBOBOX1,numItems,&demoNames[0]);
gui->setComboBoxCallback(MyComboBoxCallback);
do
{
bool syncOnly = false;
gReset = false;
static bool once=true;
glClearColor(1,0,0,1);
glClear(GL_COLOR_BUFFER_BIT);
{
window->startRendering();
glFinish();
float color[4] = {1,1,1,1};
prim.drawRect(0,0,200,200,color);
float retinaScale = 1;
float x = 10;
float y=220;
float dx=0;
if (1)
{
B3_PROFILE("font sth_draw_text");
glEnable(GL_BLEND);
GLint err = glGetError();
assert(err==GL_NO_ERROR);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
err = glGetError();
assert(err==GL_NO_ERROR);
glDisable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
glDisable(GL_CULL_FACE);
sth_begin_draw(stash);
sth_flush_draw(stash);
sth_draw_text(stash, droidRegular,20.f, x, y, "Non-retina font rendering !@#$", &dx,g_OpenGLWidth,g_OpenGLHeight,0,1);//retinaScale);
if (retinaScale!=1.f)
sth_draw_text(stash, droidRegular,20.f*retinaScale, x, y+20, "Retina font rendering!@#$", &dx,g_OpenGLWidth,g_OpenGLHeight,0,retinaScale);
sth_flush_draw(stash);
sth_end_draw(stash);
}
gui->draw(g_OpenGLWidth,g_OpenGLHeight);
window->endRendering();
glFinish();
}
once=false;
// OpenGL3CoreRenderer render;
glClearColor(0,1,0,1);
glClear(GL_COLOR_BUFFER_BIT);
window->endRendering();
glFinish();
window->setWheelCallback(b3DefaultWheelCallback);
{
GpuDemo* demo = allDemos[selectedDemo]();
// demo->myinit();
bool useGpu = false;
int maxObjectCapacity=128*1024;
ci.m_instancingRenderer = new GLInstancingRenderer(maxObjectCapacity);//render.getInstancingRenderer();
ci.m_window = window;
ci.m_gui = gui;
ci.m_instancingRenderer->init();
ci.m_instancingRenderer->InitShaders();
ci.m_primRenderer = &prim;
// render.init();
demo->initPhysics(ci);
printf("-----------------------------------------------------\n");
FILE* csvFile = 0;
FILE* detailsFile = 0;
if (benchmark)
{
gPause = false;
char prefixFileName[1024];
char csvFileName[1024];
char detailsFileName[1024];
b3OpenCLDeviceInfo info;
b3OpenCLUtils::getDeviceInfo(demo->getInternalData()->m_clDevice,&info);
//todo: move this time stuff into the Platform/Window class
#ifdef _WIN32
SYSTEMTIME time;
GetLocalTime(&time);
char buf[1024];
DWORD dwCompNameLen = 1024;
if (0 != GetComputerName(buf, &dwCompNameLen))
{
printf("%s", buf);
} else
{
printf("unknown", buf);
}
sprintf(prefixFileName,"%s_%s_%s_%d_%d_%d_date_%d-%d-%d_time_%d-%d-%d",info.m_deviceName,buf,demoNames[selectedDemo],ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ,time.wDay,time.wMonth,time.wYear,time.wHour,time.wMinute,time.wSecond);
#else
timeval now;
gettimeofday(&now,0);
struct tm* ptm;
ptm = localtime (&now.tv_sec);
char buf[1024];
#ifdef __APPLE__
sprintf(buf,"MacOSX");
#else
sprintf(buf,"Unix");
#endif
sprintf(prefixFileName,"%s_%s_%s_%d_%d_%d_date_%d-%d-%d_time_%d-%d-%d",info.m_deviceName,buf,demoNames[selectedDemo],ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ,
ptm->tm_mday,
ptm->tm_mon+1,
ptm->tm_year+1900,
ptm->tm_hour,
ptm->tm_min,
ptm->tm_sec);
#endif
sprintf(csvFileName,"%s.csv",prefixFileName);
sprintf(detailsFileName,"%s.txt",prefixFileName);
printf("Open csv file %s and details file %s\n", csvFileName,detailsFileName);
//GetSystemTime(&time2);
csvFile=fopen(csvFileName,"w");
detailsFile = fopen(detailsFileName,"w");
if (detailsFile)
defaultOutput = detailsFile;
//if (f)
// fprintf(f,"%s (%dx%dx%d=%d),\n", g_deviceName,ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ,ci.arraySizeX*ci.arraySizeY*ci.arraySizeZ);
}
fprintf(defaultOutput,"Demo settings:\n");
fprintf(defaultOutput," SelectedDemo=%d, demoname = %s\n", selectedDemo, demo->getName());
fprintf(defaultOutput," x_dim=%d, y_dim=%d, z_dim=%d\n",ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ);
fprintf(defaultOutput," x_gap=%f, y_gap=%f, z_gap=%f\n",ci.gapX,ci.gapY,ci.gapZ);
fprintf(defaultOutput,"\nOpenCL settings:\n");
fprintf(defaultOutput," Preferred cl_device index %d\n", ci.preferredOpenCLDeviceIndex);
fprintf(defaultOutput," Preferred cl_platform index%d\n", ci.preferredOpenCLPlatformIndex);
fprintf(defaultOutput,"\n");
b3OpenCLUtils::printPlatformInfo( demo->getInternalData()->m_platformId);
fprintf(defaultOutput,"\n");
b3OpenCLUtils::printDeviceInfo( demo->getInternalData()->m_clDevice);
fprintf(defaultOutput,"\n");
do
{
GLint err = glGetError();
assert(err==GL_NO_ERROR);
b3ProfileManager::Reset();
b3ProfileManager::Increment_Frame_Counter();
// render.reshape(g_OpenGLWidth,g_OpenGLHeight);
ci.m_instancingRenderer->resize(g_OpenGLWidth,g_OpenGLHeight);
prim.setScreenSize(g_OpenGLWidth,g_OpenGLHeight);
window->startRendering();
glClearColor(0.6,0.6,0.6,1);
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
if (!gPause)
{
B3_PROFILE("clientMoveAndDisplay");
demo->clientMoveAndDisplay();
}
else
{
}
{
B3_PROFILE("renderScene");
demo->renderScene();
}
err = glGetError();
assert(err==GL_NO_ERROR);
/*if (demo->getDynamicsWorld() && demo->getDynamicsWorld()->getNumCollisionObjects())
{
B3_PROFILE("renderPhysicsWorld");
b3AlignedObjectArray<b3CollisionObject*> arr = demo->getDynamicsWorld()->getCollisionObjectArray();
b3CollisionObject** colObjArray = &arr[0];
render.renderPhysicsWorld(demo->getDynamicsWorld()->getNumCollisionObjects(),colObjArray, syncOnly);
syncOnly = true;
}
*/
{
B3_PROFILE("gui->draw");
gui->draw(g_OpenGLWidth,g_OpenGLHeight);
}
err = glGetError();
assert(err==GL_NO_ERROR);
{
B3_PROFILE("window->endRendering");
window->endRendering();
}
err = glGetError();
assert(err==GL_NO_ERROR);
{
B3_PROFILE("glFinish");
}
if (dump_timings)
{
b3ProfileManager::dumpAll(stdout);
}
if (csvFile)
{
static int frameCount=0;
if (frameCount>0)
{
DumpSimulationTime(csvFile);
if (detailsFile)
{
fprintf(detailsFile,"\n==================================\nFrame %d:\n", frameCount);
b3ProfileManager::dumpAll(detailsFile);
}
}
if (frameCount>=102)
window->setRequestExit();
frameCount++;
}
} while (!window->requestedExit() && !gReset);
demo->exitPhysics();
b3ProfileManager::CleanupMemory();
delete demo;
if (detailsFile)
{
fclose(detailsFile);
detailsFile=0;
}
if (csvFile)
{
fclose(csvFile);
csvFile=0;
}
}
} while (gReset);
gui->setComboBoxCallback(0);
delete gui;
gui=0;
window->closeWindow();
delete window;
window = 0;
return 0;
}
int main(int argc, char* argv[])
{
CommandLineArgs args(argc,argv);
if (args.CheckCmdLineFlag("help"))
{
Usage();
return 0;
}
args.GetCmdLineArgument("enable_interop", useInterop);
printf("useInterop=%d\n",useInterop);
args.GetCmdLineArgument("pause_simulation", pauseSimulation);
printf("pause_simulation=%d\n",pauseSimulation);
args.GetCmdLineArgument("x_dim", NUM_OBJECTS_X);
args.GetCmdLineArgument("y_dim", NUM_OBJECTS_Y);
args.GetCmdLineArgument("z_dim", NUM_OBJECTS_Z);
args.GetCmdLineArgument("x_gap", X_GAP);
args.GetCmdLineArgument("y_gap", Y_GAP);
args.GetCmdLineArgument("z_gap", Z_GAP);
printf("x_dim=%d, y_dim=%d, z_dim=%d\n",NUM_OBJECTS_X,NUM_OBJECTS_Y,NUM_OBJECTS_Z);
printf("x_gap=%f, y_gap=%f, z_gap=%f\n",X_GAP,Y_GAP,Z_GAP);
args.GetCmdLineArgument("enable_static", keepStaticObjects);
printf("enable_static=%d\n",keepStaticObjects);
char* tmpfile = 0;
args.GetCmdLineArgument("load_bulletfile", tmpfile );
if (tmpfile)
fileName = tmpfile;
printf("load_bulletfile=%s\n",fileName);
printf("\n");
#ifdef __APPLE__
MacOpenGLWindow* window = new MacOpenGLWindow();
window->init(g_OpenGLWidth,g_OpenGLHeight);
#else
Win32OpenGLWindow* window = new Win32OpenGLWindow();
btgWindowConstructionInfo wci;
wci.m_width = g_OpenGLWidth;
wci.m_height = g_OpenGLHeight;
window->createWindow(wci);
window->setWindowTitle("render test");
#endif
float retinaScale = 1;
#ifndef __APPLE__
GLenum err = glewInit();
#else
retinaScale = window->getRetinaScale();
#endif
window->runMainLoop();
window->startRendering();
window->endRendering();
int maxObjectCapacity=128*1024;
GLInstancingRenderer render(maxObjectCapacity);
sth_stash* stash = initFont();
render.InitShaders();
createSceneProgrammatically(render);
render.writeTransforms();
window->runMainLoop();
window->setMouseButtonCallback(MyMouseButtonCallback);
window->setMouseMoveCallback(MyMouseMoveCallback);
window->setResizeCallback(MyResizeCallback);
window->setKeyboardCallback(btDefaultKeyboardCallback);
window->setWheelCallback(btDefaultWheelCallback);
GLPrimitiveRenderer* pprender = new GLPrimitiveRenderer(g_OpenGLWidth,g_OpenGLHeight);
glUseProgram(0);
////////////////////////////////
setupGUI(g_OpenGLWidth,g_OpenGLHeight,stash,retinaScale);
/////////////////////////////////////
if (pCanvas)
{
pCanvas->SetSize(g_OpenGLWidth,g_OpenGLHeight);
}
class CProfileIterator* m_profileIterator;
m_profileIterator = CProfileManager::Get_Iterator();
glClearColor(1,1,1,1);
while (!window->requestedExit())
{
CProfileManager::Reset();
{
BT_PROFILE("loop");
if (shootObject)
{
shootObject = false;
btVector3 linVel;// = (m_cameraPosition-m_cameraTargetPosition).normalize()*-100;
int x,y;
window->getMouseCoordinates(x,y);
render.getMouseDirection(&linVel[0],x,y);
linVel.normalize();
linVel*=100;
// btVector3 startPos;
float orn[4] = {0,0,0,1};
float pos[4];
render.getCameraPosition(pos);
// demo.setObjectTransform(pos,orn,0);
//render.writeSingleInstanceTransformToGPU(pos,orn,0);
// createScene(render, demo);
// printf("numPhysicsInstances= %d\n", demo.m_numPhysicsInstances);
// printf("numDynamicPhysicsInstances= %d\n", demo.m_numDynamicPhysicsInstances);
// render.writeTransforms();
}
{
BT_PROFILE("startRendering");
window->startRendering();
}
render.RenderScene();
glFinish();
float col[4]={0,1,0,1};
// pprender->drawRect(10,50,120,60,col);
// glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
//glEnable(GL_TEXTURE_2D);
float x = 10;
float y=220;
float dx=0;
if (0)
{
BT_PROFILE("font sth_draw_text");
sth_begin_draw(stash);
sth_flush_draw(stash);
sth_draw_text(stash, droidRegular,20.f, x, y, "Non-retina font rendering !@#$", &dx,g_OpenGLWidth,g_OpenGLHeight,0,1);//retinaScale);
if (retinaScale!=1.f)
sth_draw_text(stash, droidRegular,20.f*retinaScale, x, y+20, "Retina font rendering!@#$", &dx,g_OpenGLWidth,g_OpenGLHeight,0,retinaScale);
sth_flush_draw(stash);
sth_end_draw(stash);
}
if (1)
{
BT_PROFILE("gwen RenderCanvas");
if (pCanvas)
{
glEnable(GL_BLEND);
GLint err = glGetError();
assert(err==GL_NO_ERROR);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glDisable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
//glColor4ub(255,0,0,255);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
// saveOpenGLState(width,height);//m_glutScreenWidth,m_glutScreenHeight);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glEnable(GL_BLEND);
err = glGetError();
assert(err==GL_NO_ERROR);
pCanvas->RenderCanvas();
//restoreOpenGLState();
}
}
window->endRendering();
}
CProfileManager::Increment_Frame_Counter();
static bool printStats = true;
if (printStats && !pauseSimulation)
{
static int count = 0;
count--;
if (count<0)
{
count = 100;
{
//BT_PROFILE("processProfileData");
processProfileData(m_profileIterator,false);
}
//CProfileManager::dumpAll();
//printStats = false;
} else
{
// printf(".");
}
}
}
delete pprender;
// render.CleanupShaders();
#ifdef _WIN32
window->closeWindow();
#else
window->exit();
#endif
delete window;
return 0;
}
void init(void) {
// Clear screen
PORTA = 0xff;
for(uint8_t i=0;i<8;i++)
{
PORTB = (0x01 << i);
PORTA = 0xff;
_delay_ms(5);
PORTB = 0x00;
}
for(uint8_t i=0;i<8;i++)
{
PORTD = (0x01<<i);
PORTA = 0xff;
_delay_ms(5);
PORTD = 0x00;
}
// Clear out displayList
for (uint8_t i = 0; i < 8; i++) {
displayList[i] = NULL;
}
localBuffer = (char*) malloc(256 * sizeof(char));
// Init patterns and fonts.
// Pattern list contains all the patterns on the chip. Add image uses this to look up pattern memory locations.
initPattern(&commencement, 32, 120, COMMENCEMENT);
patternList[0] = &commencement;
initPattern(&congrats, 32, 120, CONGRATS);
patternList[1] = &congrats;
initPattern(&dearmichelle, 32, 120, DEARMICHELLE);
patternList[2] = &dearmichelle;
initPattern(&gobobcats, 32, 120, GOBOBCATS);
patternList[3] = &gobobcats;
initPattern(&ns, 32, 120, NS);
patternList[4] = &ns;
initPattern(&soe, 32, 120, SOE);
patternList[5] = &soe;
initPattern(&ssha, 32, 120, SSHA);
patternList[6] = &ssha;
initPattern(&ucmlogo, 32, 120, UCMLOGO);
patternList[7] = &ucmlogo;
initPattern(&welcome, 32, 120, WELCOME);
patternList[8] = &welcome;
initPattern(&welcomemichelle, 32, 120, WELCOMEMICHELLE);
patternList[9] = &welcomemichelle;
initPattern(&ucmerced, 32, 192, UCMERCED);
patternList[10] = &ucmerced;
initPattern(&proggy, 22, 1144, PROGGY);
patternList[11] = &proggy;
initPattern(&hperror, 32, 392, HPERROR);
patternList[12] = &hperror;
initFont(&proggyFont, 12, &proggy);
listSize = 0;
pattern_t* p;
// Add all the patterns to the display list, but make them invisible.
for (int i = 0; i < 10; i++) {
p = patternList[i];
addImage(i, p, 0, 0, 0, 120, -1, -p->cols, true);
changeVisibility(i, false);
}
}
int main()
{
b3gDefaultOpenGLWindow* window = new b3gDefaultOpenGLWindow();
window->setKeyboardCallback(keyCallback);
b3gWindowConstructionInfo wci;
wci.m_openglVersion = 2;
wci.m_width = sWidth;
wci.m_height = sHeight;
// wci.m_resizeCallback = MyResizeCallback;
window->createWindow(wci);
window->setResizeCallback(MyResizeCallback);
int majorGlVersion, minorGlVersion;
if (!sscanf((const char*)glGetString(GL_VERSION), "%d.%d", &majorGlVersion, &minorGlVersion)==2)
{
printf("Exit: Error cannot extract OpenGL version from GL_VERSION string\n");
exit(0);
}
char title[1024];
if (wci.m_openglVersion>2)
{
sprintf(title,"Gwen with OpenGL %d.%d\n",majorGlVersion,minorGlVersion);
} else
{
sprintf(title,"Gwen with OpenGL %d\n",wci.m_openglVersion);
}
window->setWindowTitle(title);
if (majorGlVersion>=3 && wci.m_openglVersion>=3)
{
float retinaScale = 1.f;
#ifndef __APPLE__
#ifndef _WIN32
//we need glewExperimental on Linux
glewExperimental = GL_TRUE;
#endif // _WIN32
glewInit();
#endif
//we ned to call glGetError twice, because of some Ubuntu/Intel/OpenGL issue
GLuint err = glGetError();
err = glGetError();
assert(err==GL_NO_ERROR);
retinaScale = window->getRetinaScale();
primRenderer = new GLPrimitiveRenderer(sWidth,sHeight);
sth_stash* font = initFont(primRenderer );
gwenRenderer = new GwenOpenGL3CoreRenderer(primRenderer,font,sWidth,sHeight,retinaScale);
} else
{
//OpenGL 2.x
gwenRenderer = new Gwen::Renderer::OpenGL_DebugFont();
skin.SetRender( gwenRenderer );
glClearColor(1,0,0,1);
}
//
// Create a GWEN OpenGL Renderer
//
// Gwen::Renderer::OpenGL_DebugFont * pRenderer = new Gwen::Renderer::OpenGL_DebugFont();
//
// Create a GWEN skin
//
#ifdef USE_TEXTURED_SKIN
Gwen::Skin::TexturedBase skin;
skin.SetRender( pRenderer );
skin.Init("DefaultSkin.png");
#else
skin.SetRender( gwenRenderer );
#endif
//
// Create a Canvas (it's root, on which all other GWEN panels are created)
//
pCanvas = new Gwen::Controls::Canvas( &skin );
pCanvas->SetSize( sWidth, sHeight);
pCanvas->SetDrawBackground( true );
pCanvas->SetBackgroundColor( Gwen::Color( 150, 170, 170, 255 ) );
window->setMouseButtonCallback(MyMouseButtonCallback);
window->setMouseMoveCallback(MyMouseMoveCallback);
//
// Create our unittest control (which is a Window with controls in it)
//
UnitTest* pUnit = new UnitTest( pCanvas );
pUnit->SetPos( 10, 10 );
//
// Create a Windows Control helper
// (Processes Windows MSG's and fires input at GWEN)
//
//Gwen::Input::Windows GwenInput;
//GwenInput.Initialize( pCanvas );
//
// Begin the main game loop
//
// MSG msg;
while( !window->requestedExit() )
{
if (majorGlVersion<3 || wci.m_openglVersion<3)
{
saveOpenGLState(sWidth,sHeight);
}
// Skip out if the window is closed
//if ( !IsWindowVisible( g_pHWND ) )
//break;
// If we have a message from windows..
// if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
// .. give it to the input handler to process
// GwenInput.ProcessMessage( msg );
// if it's QUIT then quit..
// if ( msg.message == WM_QUIT )
// break;
// Handle the regular window stuff..
// TranslateMessage(&msg);
// DispatchMessage(&msg);
}
window->startRendering();
// Main OpenGL Render Loop
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable(GL_BLEND);
GLint err = glGetError();
assert(err==GL_NO_ERROR);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glDisable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
//glColor4ub(255,0,0,255);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
// saveOpenGLState(width,height);//m_glutScreenWidth,m_glutScreenHeight);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glEnable(GL_BLEND);
err = glGetError();
assert(err==GL_NO_ERROR);
pCanvas->RenderCanvas();
if (avoidUpdate<=0)
avoidUpdate++;
// SwapBuffers( GetDC( g_pHWND ) );
}
window->endRendering();
if (majorGlVersion<3 || wci.m_openglVersion<3)
{
restoreOpenGLState();
}
}
window->closeWindow();
delete window;
}
int main(int argc, char* argv[])
{
int sz = sizeof(b3Generic6DofConstraint);
int sz2 = sizeof(b3Point2PointConstraint);
int sz3 = sizeof(b3TypedConstraint);
int sz4 = sizeof(b3TranslationalLimitMotor);
int sz5 = sizeof(b3RotationalLimitMotor);
int sz6 = sizeof(b3Transform);
//b3OpenCLUtils::setCachePath("/Users/erwincoumans/develop/mycache");
b3SetCustomEnterProfileZoneFunc(b3ProfileManager::Start_Profile);
b3SetCustomLeaveProfileZoneFunc(b3ProfileManager::Stop_Profile);
b3SetCustomPrintfFunc(myprintf);
b3Vector3 test=b3MakeVector3(1,2,3);
test.x = 1;
test.y = 4;
printf("main start");
b3CommandLineArgs args(argc,argv);
ParticleDemo::ConstructionInfo ci;
if (args.CheckCmdLineFlag("help"))
{
Usage();
return 0;
}
selectedDemo = loadCurrentDemoEntry(sStartFileName);
args.GetCmdLineArgument("selected_demo",selectedDemo);
if (args.CheckCmdLineFlag("new_batching"))
{
useNewBatchingKernel = true;
}
bool benchmark=args.CheckCmdLineFlag("benchmark");
args.GetCmdLineArgument("max_framecount",maxFrameCount);
args.GetCmdLineArgument("shadowmap_size",shadowMapWorldSize);
args.GetCmdLineArgument("shadowmap_resolution",shadowMapWidth);
shadowMapHeight=shadowMapWidth;
if (args.CheckCmdLineFlag("disable_shadowmap"))
{
useShadowMap = false;
}
args.GetCmdLineArgument("pair_benchmark_file",gPairBenchFileName);
gDebugLauncherCL = args.CheckCmdLineFlag("debug_kernel_launch");
dump_timings=args.CheckCmdLineFlag("dump_timings");
ci.useOpenCL = !args.CheckCmdLineFlag("disable_opencl");
ci.m_useConcaveMesh = true;//args.CheckCmdLineFlag("use_concave_mesh");
if (ci.m_useConcaveMesh)
{
enableExperimentalCpuConcaveCollision = true;
}
ci.m_useInstancedCollisionShapes = !args.CheckCmdLineFlag("no_instanced_collision_shapes");
args.GetCmdLineArgument("cl_device", ci.preferredOpenCLDeviceIndex);
args.GetCmdLineArgument("cl_platform", ci.preferredOpenCLPlatformIndex);
gAllowCpuOpenCL = args.CheckCmdLineFlag("allow_opencl_cpu");
gUseLargeBatches = args.CheckCmdLineFlag("use_large_batches");
gUseJacobi = args.CheckCmdLineFlag("use_jacobi");
gUseDbvt = args.CheckCmdLineFlag("use_dbvt");
gDumpContactStats = args.CheckCmdLineFlag("dump_contact_stats");
gCalcWorldSpaceAabbOnCpu = args.CheckCmdLineFlag("calc_aabb_cpu");
gUseCalculateOverlappingPairsHost = args.CheckCmdLineFlag("calc_pairs_cpu");
gIntegrateOnCpu = args.CheckCmdLineFlag("integrate_cpu");
gConvertConstraintOnCpu = args.CheckCmdLineFlag("convert_constraints_cpu");
useUniformGrid = args.CheckCmdLineFlag("use_uniform_grid");
args.GetCmdLineArgument("x_dim", ci.arraySizeX);
args.GetCmdLineArgument("y_dim", ci.arraySizeY);
args.GetCmdLineArgument("z_dim", ci.arraySizeZ);
args.GetCmdLineArgument("x_gap", ci.gapX);
args.GetCmdLineArgument("y_gap", ci.gapY);
args.GetCmdLineArgument("z_gap", ci.gapZ);
gPause = args.CheckCmdLineFlag("paused");
gDebugForceLoadingFromSource = args.CheckCmdLineFlag("load_cl_kernels_from_disk");
gDebugSkipLoadingBinary = args.CheckCmdLineFlag("disable_cached_cl_kernels");
#ifndef B3_NO_PROFILE
b3ProfileManager::Reset();
#endif //B3_NO_PROFILE
window = new b3gDefaultOpenGLWindow();
b3gWindowConstructionInfo wci(g_OpenGLWidth,g_OpenGLHeight);
window->createWindow(wci);
window->setResizeCallback(MyResizeCallback);
window->setMouseMoveCallback(MyMouseMoveCallback);
window->setMouseButtonCallback(MyMouseButtonCallback);
window->setKeyboardCallback(MyKeyboardCallback);
window->setWindowTitle("Bullet 3.x GPU Rigid Body http://bulletphysics.org");
printf("-----------------------------------------------------\n");
#ifndef __APPLE__
glewInit();
#endif
gui = new GwenUserInterface();
printf("started GwenUserInterface");
GLPrimitiveRenderer prim(g_OpenGLWidth,g_OpenGLHeight);
stash = initFont(&prim);
if (gui)
{
gui->init(g_OpenGLWidth,g_OpenGLHeight,stash,window->getRetinaScale());
printf("init fonts");
gui->setToggleButtonCallback(MyButtonCallback);
gui->registerToggleButton(MYPAUSE,"Pause");
gui->registerToggleButton(MYPROFILE,"Profile");
gui->registerToggleButton(MYRESET,"Reset");
int numItems = sizeof(allDemos)/sizeof(ParticleDemo::CreateFunc*);
demoNames.clear();
for (int i=0;i<numItems;i++)
{
GpuDemo* demo = allDemos[i]();
demoNames.push_back(demo->getName());
delete demo;
}
gui->registerComboBox(MYCOMBOBOX1,numItems,&demoNames[0],selectedDemo);
gui->setComboBoxCallback(MyComboBoxCallback);
}
do
{
bool syncOnly = false;
gReset = false;
{
GLint err;
glEnable(GL_BLEND);
err = glGetError();
b3Assert(err==GL_NO_ERROR);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
err = glGetError();
b3Assert(err==GL_NO_ERROR);
window->startRendering();
glClearColor(1,1,1,1);
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);//|GL_STENCIL_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
sth_begin_draw(stash);
//sth_draw_text(stash, droidRegular,12.f, dx, dy-50, "How does this OpenGL True Type font look? ", &dx,width,height);
int spacing = 0;//g_OpenGLHeight;
float sx,sy,dx,dy,lh;
sx = 0;
sy = g_OpenGLHeight;
dx = sx; dy = sy;
//if (1)
const char* msg[] = {"Please wait, initializing the OpenCL demo",
"Please make sure to run the demo on a high-end discrete GPU with OpenCL support",
"The first time it can take a bit longer to compile the OpenCL kernels.",
"Check the console if it takes longer than 1 minute or if a demos has issues.",
"Please share the full commandline output when reporting issues:",
"App_Bullet3_OpenCL_Demos_* >> error.log",
"",
"",
#ifdef _DEBUG
"Some of the demos load a large .obj file,",
"please use an optimized build of this app for faster parsing",
"",
"",
#endif
"You can press F1 to create a single screenshot,",
"or press F2 toggle screenshot (useful to create movies)",
"",
"",
"There are various command-line options such as --benchmark",
"See http://github.com/erwincoumans/bullet3 for more information"
};
int fontSize = 68;
int nummsg = sizeof(msg)/sizeof(const char*);
for (int i=0;i<nummsg;i++)
{
char txt[512];
sprintf(txt,"%s",msg[i]);
//sth_draw_text(stash, droidRegular,i, 10, dy-spacing, txt, &dx,g_OpenGLWidth,g_OpenGLHeight);
sth_draw_text(stash, droidRegular,fontSize, 10, spacing, txt, &dx,g_OpenGLWidth,g_OpenGLHeight);
spacing+=fontSize;
fontSize = 32;
}
sth_end_draw(stash);
sth_flush_draw(stash);
window->endRendering();
}
static bool once=true;
//glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
glClearColor(1,1,1,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
window->setWheelCallback(b3DefaultWheelCallback);
{
GpuDemo* demo = allDemos[selectedDemo]();
sDemo = demo;
// demo->myinit();
bool useGpu = false;
//int maxObjectCapacity=128*1024;
int maxObjectCapacity=1024*1024;
maxObjectCapacity = b3Max(maxObjectCapacity,ci.arraySizeX*ci.arraySizeX*ci.arraySizeX+10);
{
ci.m_instancingRenderer = new GLInstancingRenderer(maxObjectCapacity);//render.getInstancingRenderer();
ci.m_window = window;
ci.m_gui = gui;
ci.m_instancingRenderer->init();
ci.m_instancingRenderer->resize(g_OpenGLWidth,g_OpenGLHeight);
ci.m_instancingRenderer->InitShaders();
ci.m_primRenderer = &prim;
// render.init();
}
{
demo->initPhysics(ci);
}
printf("-----------------------------------------------------\n");
FILE* csvFile = 0;
FILE* detailsFile = 0;
if (benchmark)
{
char prefixFileName[1024];
char csvFileName[1024];
char detailsFileName[1024];
b3OpenCLDeviceInfo info;
b3OpenCLUtils::getDeviceInfo(demo->getInternalData()->m_clDevice,&info);
//todo: move this time stuff into the Platform/Window class
#ifdef _WIN32
SYSTEMTIME time;
GetLocalTime(&time);
char buf[1024];
DWORD dwCompNameLen = 1024;
if (0 != GetComputerName(buf, &dwCompNameLen))
{
printf("%s", buf);
} else
{
printf("unknown", buf);
}
sprintf(prefixFileName,"%s_%s_%s_%d_%d_%d_date_%d-%d-%d_time_%d-%d-%d",info.m_deviceName,buf,demoNames[selectedDemo],ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ,time.wDay,time.wMonth,time.wYear,time.wHour,time.wMinute,time.wSecond);
#else
timeval now;
gettimeofday(&now,0);
struct tm* ptm;
ptm = localtime (&now.tv_sec);
char buf[1024];
#ifdef __APPLE__
sprintf(buf,"MacOSX");
#else
sprintf(buf,"Unix");
#endif
sprintf(prefixFileName,"%s_%s_%s_%d_%d_%d_date_%d-%d-%d_time_%d-%d-%d",info.m_deviceName,buf,demoNames[selectedDemo],ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ,
ptm->tm_mday,
ptm->tm_mon+1,
ptm->tm_year+1900,
ptm->tm_hour,
ptm->tm_min,
ptm->tm_sec);
#endif
sprintf(csvFileName,"%s.csv",prefixFileName);
sprintf(detailsFileName,"%s.txt",prefixFileName);
printf("Open csv file %s and details file %s\n", csvFileName,detailsFileName);
//GetSystemTime(&time2);
csvFile=fopen(csvFileName,"w");
detailsFile = fopen(detailsFileName,"w");
if (detailsFile)
defaultOutput = detailsFile;
//if (f)
// fprintf(f,"%s (%dx%dx%d=%d),\n", g_deviceName,ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ,ci.arraySizeX*ci.arraySizeY*ci.arraySizeZ);
}
fprintf(defaultOutput,"Demo settings:\n");
fprintf(defaultOutput," SelectedDemo=%d, demoname = %s\n", selectedDemo, demo->getName());
fprintf(defaultOutput," x_dim=%d, y_dim=%d, z_dim=%d\n",ci.arraySizeX,ci.arraySizeY,ci.arraySizeZ);
fprintf(defaultOutput," x_gap=%f, y_gap=%f, z_gap=%f\n",ci.gapX,ci.gapY,ci.gapZ);
fprintf(defaultOutput,"\nOpenCL settings:\n");
fprintf(defaultOutput," Preferred cl_device index %d\n", ci.preferredOpenCLDeviceIndex);
fprintf(defaultOutput," Preferred cl_platform index%d\n", ci.preferredOpenCLPlatformIndex);
fprintf(defaultOutput,"\n");
if (demo->getInternalData()->m_platformId)
{
b3OpenCLUtils::printPlatformInfo( demo->getInternalData()->m_platformId);
fprintf(defaultOutput,"\n");
b3OpenCLUtils::printDeviceInfo( demo->getInternalData()->m_clDevice);
fprintf(defaultOutput,"\n");
}
do
{
GLint err = glGetError();
assert(err==GL_NO_ERROR);
if (exportFrame || exportMovie)
{
if (!renderTexture)
{
renderTexture = new GLRenderToTexture();
GLuint renderTextureId;
glGenTextures(1, &renderTextureId);
// "Bind" the newly created texture : all future texture functions will modify this texture
glBindTexture(GL_TEXTURE_2D, renderTextureId);
// Give an empty image to OpenGL ( the last "0" )
//glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, g_OpenGLWidth,g_OpenGLHeight, 0,GL_RGBA, GL_UNSIGNED_BYTE, 0);
//glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA32F, g_OpenGLWidth,g_OpenGLHeight, 0,GL_RGBA, GL_FLOAT, 0);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA32F, g_OpenGLWidth,g_OpenGLHeight, 0,GL_RGBA, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
renderTexture->init(g_OpenGLWidth,g_OpenGLHeight,renderTextureId, RENDERTEXTURE_COLOR);
}
bool result = renderTexture->enable();
}
err = glGetError();
assert(err==GL_NO_ERROR);
b3ProfileManager::Reset();
b3ProfileManager::Increment_Frame_Counter();
// render.reshape(g_OpenGLWidth,g_OpenGLHeight);
ci.m_instancingRenderer->resize(g_OpenGLWidth,g_OpenGLHeight);
prim.setScreenSize(g_OpenGLWidth,g_OpenGLHeight);
err = glGetError();
assert(err==GL_NO_ERROR);
window->startRendering();
err = glGetError();
assert(err==GL_NO_ERROR);
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);//|GL_STENCIL_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
if (!gPause)
{
B3_PROFILE("clientMoveAndDisplay");
demo->clientMoveAndDisplay();
}
else
{
}
{
B3_PROFILE("renderScene");
demo->renderScene();
}
err = glGetError();
assert(err==GL_NO_ERROR);
/*if (demo->getDynamicsWorld() && demo->getDynamicsWorld()->getNumCollisionObjects())
{
B3_PROFILE("renderPhysicsWorld");
b3AlignedObjectArray<b3CollisionObject*> arr = demo->getDynamicsWorld()->getCollisionObjectArray();
b3CollisionObject** colObjArray = &arr[0];
render.renderPhysicsWorld(demo->getDynamicsWorld()->getNumCollisionObjects(),colObjArray, syncOnly);
syncOnly = true;
}
*/
if (exportFrame || exportMovie)
{
char fileName[1024];
sprintf(fileName,"screenShot%d.png",frameIndex++);
writeTextureToPng(g_OpenGLWidth,g_OpenGLHeight,fileName);
exportFrame = false;
renderTexture->disable();
}
{
B3_PROFILE("gui->draw");
if (gui && gDrawGui)
gui->draw(g_OpenGLWidth,g_OpenGLHeight);
}
err = glGetError();
assert(err==GL_NO_ERROR);
{
B3_PROFILE("window->endRendering");
window->endRendering();
}
err = glGetError();
assert(err==GL_NO_ERROR);
{
B3_PROFILE("glFinish");
}
if (dump_timings)
{
b3ProfileManager::dumpAll(stdout);
}
if (csvFile)
{
static int frameCount=0;
if (frameCount>0)
{
DumpSimulationTime(csvFile);
if (detailsFile)
{
fprintf(detailsFile,"\n==================================\nFrame %d:\n", frameCount);
b3ProfileManager::dumpAll(detailsFile);
}
}
if (frameCount>=maxFrameCount)
window->setRequestExit();
frameCount++;
}
if (gStep)
gPause=true;
} while (!window->requestedExit() && !gReset);
demo->exitPhysics();
b3ProfileManager::CleanupMemory();
delete ci.m_instancingRenderer;
delete demo;
sDemo = 0;
if (detailsFile)
{
fclose(detailsFile);
detailsFile=0;
}
if (csvFile)
{
fclose(csvFile);
csvFile=0;
}
}
} while (gReset);
if (gui)
gui->setComboBoxCallback(0);
{
delete gui;
gui=0;
exitFont();
window->closeWindow();
delete window;
window = 0;
}
return 0;
}
void drawStatusBar()
{
char *p;
float c[4];
int ic[4];
Console_writeToHud = 1;
//Console_writeToCRT = 1;
//Console_writeToFile = 0;
//if(showButtons)
//{
// renderButtons();
// return;
//}
if (0){ //!sb_hasString ){ //&& !showConText &&!butStatus[8] &&!butStatus[9] && !butStatus[10]) {
if(hadString)
{
/* clear the status bar because there's nothing to show */
FW_GL_SCISSOR(0,0,screenWidth,clipPlane);
glEnable(GL_SCISSOR_TEST);
FW_GL_CLEAR(GL_COLOR_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
hadString = 0;
}
return;
}
/* to improve frame rates we don't need to update the status bar every loop,
because the mainloop scene rendering should be using a scissor test to avoid FW_GL_CLEAR()ing
the statusbar area.
*/
hadString = 1;
sb_hasString = 1;
clipPlane = 16;
loopcount++;
if(loopcount < 15 && !hadString) return;
loopcount = 0;
/* OK time to update the status bar */
if(!fontInitialized) initFont();
/* unconditionally clear the statusbar area */
FW_GL_SCISSOR(0,0,screenWidth,clipPlane);
glEnable(GL_SCISSOR_TEST);
FW_GL_CLEAR(GL_COLOR_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
// you must call drawStatusBar() from render() just before swapbuffers
FW_GL_DEPTHMASK(FALSE);
glDisable(GL_DEPTH_TEST);
//glWindowPos seems to set the bitmap color correctly in windows
FW_GL_WINDOWPOS2I(5,0);
if(sb_hasString)
{
p = buffer;
/* print status bar text - things like PLANESENSOR */
printString(p);
hadString = 1;
}
FW_GL_WINDOWPOS2I(300,0);
printString(messagebar);
printConsoleText();
FW_GL_DEPTHMASK(TRUE);
glEnable(GL_DEPTH_TEST);
FW_GL_FLUSH();
}
