int main(int argc, char *argv[])
{
// Initialize GLUT
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(640, 480);
glutCreateWindow("AntTweakBar string example");
glutCreateMenu(NULL);
// Set GLUT callbacks
glutDisplayFunc(OnDisplay);
glutReshapeFunc(OnReshape);
atexit(OnTerminate); // Called after glutMainLoop ends
// Initialize AntTweakBar
TwInit(TW_OPENGL, NULL);
// Set GLUT event callbacks
// - Directly redirect GLUT mouse button events to AntTweakBar
glutMouseFunc(OnMouseButton);
// - Directly redirect GLUT mouse motion events to AntTweakBar
glutMotionFunc(OnMouseMotion);
// - Directly redirect GLUT mouse "passive" motion events to AntTweakBar (same as MouseMotion)
glutPassiveMotionFunc(OnMouseMotion);
// - Directly redirect GLUT key events to AntTweakBar
glutKeyboardFunc(OnKeyboard);
// - Directly redirect GLUT special key events to AntTweakBar
glutSpecialFunc(OnSpecial);
// - Send 'glutGetModifers' function pointer to AntTweakBar;
// required because the GLUT key event functions do not report key modifiers states.
TwGLUTModifiersFunc(glutGetModifiers);
// Create a tweak bar
TwBar *bar = TwNewBar("Main");
TwDefine(" Main label='~ String variable examples ~' fontSize=3 position='180 16' size='270 440' valuesWidth=100 ");
//
// 1) C++ std::string variable example
//
TwAddButton(bar, "Info1.1", NULL, NULL, " label='1) This example uses' ");
TwAddButton(bar, "Info1.2", NULL, NULL, " label='std::string variables' ");
// Define the required callback function to copy a std::string (see TwCopyStdStringToClientFunc documentation)
TwCopyStdStringToClientFunc(CopyStdStringToClient);
// Adding a std::string variable
std::string newBarTitle = "a title";
TwAddVarRW(bar, "NewBarTitle", TW_TYPE_STDSTRING, &newBarTitle,
" label='Bar title' group=StdString help='Define a title for the new tweak bar.' ");
// Add a button to create a new bar using the title
TwAddButton(bar, "NewBarCreate", CreateBarCB, &newBarTitle,
" label='--> Create' group=StdString key=c help='Create a new tweak bar.' ");
// Set the group label & separator
TwDefine(" Main/StdString label='Create a new tweak bar' help='This example demonstates different use of std::string variables.' ");
TwAddSeparator(bar, "Sep1", "");
TwAddButton(bar, "Blank1", NULL, NULL, " label=' ' ");
//
// 2) C-Dynamic string variable example
//
TwAddButton(bar, "Info2.1", NULL, NULL, "label='2) This example uses' ");
TwAddButton(bar, "Info2.2", NULL, NULL, "label='C-Dynamic string variables' ");
// Define the required callback function to copy a CDString (see TwCopyCDStringToClientFunc documentation)
TwCopyCDStringToClientFunc(CopyCDStringToClient);
// Add a CDString variable
char *someText = NULL;
TwAddVarRW(bar, "Input", TW_TYPE_CDSTRING, &someText,
" label='Text input' group=CDString help=`The text to be copied to 'Text output'.` ");
TwAddVarRO(bar, "Output", TW_TYPE_CDSTRING, &someText,
" label='Text output' group=CDString help=`Carbon copy of the text entered in 'Text input'.` ");
// Add a line of text (we will use the label of a inactive button)
#define TEXTLINE "a line of text"
TwAddButton(bar, "Echo", NULL, NULL,
" label=`" TEXTLINE "` group=CDString help='Echo of the text entered in the next field' ");
// Add a CDString variable accessed through callbacks
char *textLine = (char *)malloc(sizeof(TEXTLINE)+1);
strncpy(textLine, TEXTLINE, sizeof(TEXTLINE));
TwAddVarCB(bar, "TextLine", TW_TYPE_CDSTRING, SetTextLineCB, GetTextLineCB, &textLine,
" label='Change text above' group=CDString help='The text to be echoed.' ");
// Set the group label & separator
TwDefine(" Main/CDString label='Echo some text' help='This example demonstates different use of C-Dynamic string variables.' ");
TwAddSeparator(bar, "Sep2", "");
TwAddButton(bar, "Blank2", NULL, NULL, " label=' ' ");
//
// 3) C-Static string variable example
//
TwAddButton(bar, "Info3.1", NULL, NULL, "label='3) This example uses' ");
TwAddButton(bar, "Info3.2", NULL, NULL, "label='C strings of fixed size' ");
// Add a CSString
char tenStr[] = "0123456789"; // 10 characters + null_termination_char -> size = 11
TwAddVarRW(bar, "Ten", TW_TYPE_CSSTRING(sizeof(tenStr)), tenStr,
" label='10 chars max' group=CSString help='A string with a length of 10 characters max.' ");
// Add a CSString accessed through callbacks. The callbacks will convert the string characters to upper or lower case
int capCase = 1; // O: lower-case, 1: upper-case
TwAddVarCB(bar, "Capitalize", TW_TYPE_CSSTRING(sizeof(g_CapStr)), SetCapStrCB, GetCapStrCB, &capCase,
" group=CSString help='A string of fixed size to be converted to upper or lower case.' ");
// Add a bool variable
TwAddVarRW(bar, "Case", TW_TYPE_BOOL32, &capCase,
" false=lower true=UPPER group=CSString key=Space help=`Changes the characters case of the 'Capitalize' string.` ");
// Set the group label & separator
TwDefine(" Main/CSString label='Character capitalization' help='This example demonstates different use of C-Static sized variables.' ");
TwAddSeparator(bar, "Sep3", "");
// Call the GLUT main loop
glutMainLoop();
return 0;
}
int APIENTRY WinMain(HINSTANCE hInst,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
MSG msg; // Windows message structure
WNDCLASS wc; // Windows class structure
HWND hWnd; // Storeage for window handle
hInstance = hInst;
// Register Window style
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC)WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
// No need for background brush for OpenGL window
wc.hbrBackground = NULL;
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU);
wc.lpszClassName = lpszAppName;
// Register the window class
if (RegisterClass(&wc) == 0)
return FALSE;
// Create the main application window
hWnd = CreateWindow(
lpszAppName,
lpszAppName,
// OpenGL requires WS_CLIPCHILDREN and WS_CLIPSIBLINGS
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
// Window position and size
50, 50,
1000, 1000,
NULL,
NULL,
hInstance,
NULL);
TwInit(TW_OPENGL, NULL);
TwWindowSize(800,800);
TwBar *bar;
bar = TwNewBar("Moonlander");
TwDefine(" Moonlander size='240 400' ");
TwDefine(" Moonlander text=dark refresh=0.1 ");
TwAddSeparator(bar, NULL, " group='Velocity' ");
TwAddVarRO(bar, "Velocity[m/s]", TW_TYPE_FLOAT, &velocity,"precision=1");
TwAddVarRO(bar, "Velocity X[m/s]", TW_TYPE_FLOAT, &velocityx, "precision=1");
TwAddVarRO(bar, "Velocity Z[m/s]", TW_TYPE_FLOAT, &velocityz, "precision=1");
TwAddSeparator(bar, NULL, " group='Engines' ");
TwAddVarRO(bar, "Main Engine", TW_TYPE_BOOLCPP, &spisSet, "");
TwAddVarRO(bar, "Engine 1", TW_TYPE_BOOLCPP, &w, "");
TwAddVarRO(bar, "Engine 2", TW_TYPE_BOOLCPP, &s, "");
TwAddVarRO(bar, "Engine 3", TW_TYPE_BOOLCPP, &a, "");
TwAddVarRO(bar, "Engine 4", TW_TYPE_BOOLCPP, &d, "");
TwAddVarRO(bar, "Fuel Left[kg]", TW_TYPE_FLOAT, &fuel, "precision=2");
TwAddSeparator(bar, NULL, " group='Position' ");
TwAddVarRO(bar, "x", TW_TYPE_FLOAT, &position.x, "precision=1");
TwAddVarRO(bar, "y", TW_TYPE_FLOAT, &position.y, "precision=1");
TwAddVarRO(bar, "z", TW_TYPE_FLOAT, &position.z, "precision=1");
TwAddSeparator(bar, NULL, " group='--------------------------------' ");
TwAddVarRO(bar, "Actual score:", TW_TYPE_INT32, &score, "");
TwAddVarRO(bar, "Highscore:", TW_TYPE_INT32, &highscore, "");
// If window was not created, quit
if (hWnd == NULL)
return FALSE;
static HDC hDC = GetDC(hWnd);
world->initiate();
world->populate();
// Display the window
ShowWindow(hWnd, SW_SHOW);
UpdateWindow(hWnd);
// Process application messages until the application closes
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
// Main
int main(int argc, char *argv[])
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutInitWindowSize( 800, 600 );
glutCreateWindow( "Font rendering advanced tweaking" );
glutCreateMenu( NULL );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
glutDisplayFunc( display );
glutReshapeFunc( reshape );
atexit( terminate );
TwInit( TW_OPENGL, NULL );
glutMouseFunc( (GLUTmousebuttonfun)TwEventMouseButtonGLUT );
glutMotionFunc( (GLUTmousemotionfun)TwEventMouseMotionGLUT );
glutPassiveMotionFunc( (GLUTmousemotionfun)TwEventMouseMotionGLUT );
glutKeyboardFunc( (GLUTkeyboardfun)TwEventKeyboardGLUT );
glutSpecialFunc( (GLUTspecialfun)TwEventSpecialGLUT );
TwGLUTModifiersFunc( glutGetModifiers );
// Create a new tweak bar
bar = TwNewBar("TweakBar");
TwDefine("GLOBAL "
"help = 'This example shows how to tune all font parameters.' ");
TwDefine("TweakBar "
"size = '280 400' "
"position = '500 20' "
"color = '127 127 127' "
"alpha = 240 "
"label = 'Parameters' "
"resizable = True "
"fontresizable = True "
"iconifiable = True ");
{
TwEnumVal familyEV[NUM_FONTS] = {
{VERA, "Vera"},
{VERA_MONO, "Vera Mono"},
{LUCKIEST_GUY, "Luckiest Guy"},
{SOURCE_SANS, "Source Sans Pro"},
{SOURCE_CODE, "Source Code Pro"},
{OLD_STANDARD, "Old Standard TT"},
{LOBSTER, "Lobster"} };
TwType family_type = TwDefineEnum("Family", familyEV, NUM_FONTS);
TwAddVarCB(bar, "Family", family_type, set_family, get_family, NULL,
"label = 'Family' "
"group = 'Font' "
"help = ' ' ");
}
TwAddVarCB(bar, "Size", TW_TYPE_FLOAT, set_size, get_size, NULL,
"label = 'Size' "
"group = 'Font' "
"min = 6.0 "
"max = 24.0 "
"step = 0.05 "
"help = ' ' ");
TwAddVarCB(bar, "LCD filtering", TW_TYPE_BOOL32, set_lcd_filtering, get_lcd_filtering, NULL,
"label = 'LCD filtering' "
"group = 'Font' "
"help = ' ' ");
// Rendering
TwAddVarCB(bar, "Kerning", TW_TYPE_BOOL32, set_kerning, get_kerning, NULL,
"label = 'Kerning' "
"group = 'Rendering' "
"help = ' ' ");
TwAddVarCB(bar, "Hinting", TW_TYPE_BOOL32, set_hinting, get_hinting, NULL,
"label = 'Hinting' "
"group = 'Rendering' "
"help = ' ' ");
// Color
TwAddVarCB(bar, "Invert", TW_TYPE_BOOL32, set_invert, get_invert, NULL,
"label = 'Invert' "
"group = 'Color' "
"help = ' ' ");
// Glyph
TwAddVarCB(bar, "Width", TW_TYPE_FLOAT, set_width, get_width, NULL,
"label = 'Width' "
"group = 'Glyph' "
"min = 0.75 "
"max = 1.25 "
"step = 0.01 "
"help = ' ' ");
TwAddVarCB(bar, "Interval", TW_TYPE_FLOAT, set_interval, get_interval, NULL,
"label = 'Spacing' "
"group = 'Glyph' "
"min = -0.2 "
"max = 0.2 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Faux italic", TW_TYPE_FLOAT, set_faux_italic, get_faux_italic, NULL,
"label = 'Faux italic' "
"group = 'Glyph' "
"min = -30.0 "
"max = 30.0 "
"step = 0.1 "
"help = ' ' ");
// Energy distribution
TwAddVarCB(bar, "Primary", TW_TYPE_FLOAT, set_primary, get_primary, NULL,
"label = 'Primary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Secondary", TW_TYPE_FLOAT, set_secondary, get_secondary, NULL,
"label = 'Secondy weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Tertiary", TW_TYPE_FLOAT, set_tertiary, get_tertiary, NULL,
"label = 'Tertiary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddSeparator(bar, "",
"group = 'Energy distribution' " );
TwAddVarCB(bar, "Gamma", TW_TYPE_FLOAT, set_gamma, get_gamma, NULL,
"label = 'Gamma correction' "
"group = 'Energy distribution' "
"min = 0.50 "
"max = 2.5 "
"step = 0.01 "
"help = ' ' ");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Reset", (TwButtonCallback) reset, NULL,
"help='Reset all parameters to default values.'");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Quit", (TwButtonCallback) quit, NULL,
"help='Quit.'");
buffer_a = text_buffer_new( 1 );
buffer_rgb = text_buffer_new( 3 );
buffer = buffer_rgb;
reset();
glutTimerFunc( 1000.0/60.0, timer, 60 );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop();
return EXIT_SUCCESS;
}
void CreateBar(){
TwBar *bar = TwNewBar("Gestures_controller");
TwDefine(" Gestures_controller label='Gestures controller' fontSize=3 position='16 16' size='300 230' valuesWidth=100 ");
TwCopyStdStringToClientFunc(CopyStdStringToClient);
TwAddVarCB(bar, "Gesture name", TW_TYPE_STDSTRING, SetMyStdStringCB, GetMyStdStringCB, NULL, "");
TwAddButton(bar, "NewGestureCreate", CreateGesture, NULL, " label='--> Create <--' ");
TwAddButton(bar, "GestureRecognize", RecognizeGesture, NULL, " label='--> Recognize <--' ");
TwAddSeparator(bar, NULL, "");
TwAddVarRO(bar, "Hands:", TW_TYPE_INT32, &g_leapListener.numHands, "group='Captured values'");
TwAddVarRO(bar, "Extended fingers:", TW_TYPE_INT32, &g_leapListener.numFingers, "group='Captured values'");
TwAddSeparator(bar, NULL, "");
TwAddVarRO(bar, "Recognized gesture", TW_TYPE_STDSTRING, &g_leapListener.recognizedGesture, "");
TwAddVarRO(bar, "F_crit", TW_TYPE_FLOAT, &g_leapListener.f_crit, "");
TwAddVarRO(bar, "F_value", TW_TYPE_FLOAT, &g_leapListener.f_value, "");
TwBar *trials = TwNewBar("trials");
TwDefine("trials label='Trials Controller' fontSize=3 position='16 250' size='300 130'");
TwAddVarRO(trials, "Active trial:", TW_TYPE_STDSTRING, &trial, "");
TwAddVarRO(trials, "Attempt:", TW_TYPE_INT32, &g_leapListener.nRecognize, "");
TwAddButton(trials, "trial1", Trial1, NULL, " label='--> Trial 1 <--' ");
TwAddButton(trials, "trial2", Trial2, NULL, " label='--> Trial 2 <--' ");
TwAddButton(trials, "trial3", Trial3, NULL, " label='--> Trial 3 <--' ");
bar2 = TwNewBar("gestures");
TwDefine("gestures label='Saved Gestures' fontSize=3 position='780 16' size='250 650'");
TwAddButton(bar2, "ClearDatabase", ClearDatabase, NULL, " label='--> Clear Database <--' ");
TwAddSeparator(bar2, NULL, "");
for (int i = 0; i < g_gestureManager.gestures.size(); i++){
std::string params;
params.append("");
if (i >= next_gesture_id){
params.append("visible='false'");
}
std::string varname;
varname.append(std::to_string(i+1));
varname.append(" - Name:");
TwAddVarRO(bar2, varname.c_str(), TW_TYPE_STDSTRING, &g_gestureManager.gestures[i].name, params.c_str());
varname.clear();
varname.append(std::to_string(i+1));
varname.append(" - ID:");
TwAddVarRO(bar2, varname.c_str(), TW_TYPE_INT32, &g_gestureManager.gestures[i].id, params.c_str());
varname.clear();
varname.append(std::to_string(i+1));
varname.append(" - Hands:");
TwAddVarRO(bar2, varname.c_str(), TW_TYPE_INT32, &g_gestureManager.gestures[i].numHands, params.c_str());
varname.clear();
varname.append(std::to_string(i+1));
varname.append(" - Fingers:");
TwAddVarRO(bar2, varname.c_str(), TW_TYPE_INT32, &g_gestureManager.gestures[i].numFingers, params.c_str());
varname.clear();
varname.append(std::to_string(i+1));
varname.append(" - sep:");
TwAddSeparator(bar2, varname.c_str(), params.c_str());
}
glfwSetWindowSizeCallback(WindowSizeCB);
glfwSetMouseButtonCallback((GLFWmousebuttonfun)TwEventMouseButtonGLFW);
glfwSetMousePosCallback((GLFWmouseposfun)TwEventMousePosGLFW);
glfwSetMouseWheelCallback((GLFWmousewheelfun)TwEventMouseWheelGLFW);
glfwSetKeyCallback((GLFWkeyfun)TwEventKeyGLFW);
glfwSetCharCallback((GLFWcharfun)TwEventCharGLFW);
}
void InterfaceGl::addSeparator( const std::string &name, const std::string &optionsStr )
{
TwAddSeparator( mBar.get(), name.c_str(), optionsStr.c_str() );
}
// ------ AntTweakBar setup -----------------
bool rtvsD3dApp::setupAntTW(LPDIRECT3DDEVICE9 pd3dDevice)
{
TwInit(TW_DIRECT3D9, pd3dDevice); // for Direct3D 9
TwBar *myBar;
myBar = TwNewBar("Options");
TwDefine(" Options label='Raytracer Options' refresh=0.5 position='16 16' size='260 320' alpha=0");
// for camera position..
struct position { float x, y, z; };
TwStructMember positionMembers[] = {
{"x", TW_TYPE_FLOAT, offsetof(position, x), " Min=-12 Max=12 " },
{"y", TW_TYPE_FLOAT, offsetof(position, y), " Min=-7 Max=7 " },
{"z", TW_TYPE_FLOAT, offsetof(position, z), " Min=-5 Max=25 " }
};
TwType positionType = TwDefineStruct("Position", positionMembers, 3, sizeof(position), NULL, NULL);
Raytracer::Primitive* primitive;
int primCount = m_pTracer->tracer->GetScene()->GetNrPrimitives();
for (int i = 0; i < primCount; i++) {
static char label[32];
static char def[128];
static char grouping[64];
primitive = m_pTracer->tracer->GetScene()->GetPrimitive(i);
int type = primitive->GetType();
switch (type)
{
case Raytracer::Primitive::SPHERE:
if(primitive->IsLight())
{
// add a light
sprintf_s(label, 32, "Color%d", i+1);
sprintf_s(def, 128, " group='Light%d' label='Color' ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_COLOR3F, &primitive->m_Material->m_Color, def );
sprintf_s(label, 32, "Position%d", i+1);
sprintf_s(def, 128, " group='Light%d' label='Position' ", i+1);
TwAddVarRW(myBar, label, positionType, &((Raytracer::Sphere*)primitive)->m_Centre, def );
sprintf_s(grouping, 64, " Options/Light%d group='Lights'", i+1);
TwDefine(grouping);
}
else
{
// add a sphere
sprintf_s(label, 32, "Color%d", i+1);
sprintf_s(def, 128, " group='Sphere%d' label='Color' ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_COLOR3F, &primitive->m_Material->m_Color, def );
sprintf_s(label, 32, "Position%d", i+1);
sprintf_s(def, 128, " group='Sphere%d' label='Position' ", i+1);
TwAddVarRW(myBar, label, positionType, &((Raytracer::Sphere*)primitive)->m_Centre, def );
sprintf_s(label, 32, "Reflection%d", i+1);
sprintf_s(def, 128, " group='Sphere%d' label='Reflection' Min=0 Max=2.0 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_Refl, def );
sprintf_s(label, 32, "Refraction%d", i+1);
sprintf_s(def, 128, " group='Sphere%d' label='Refraction' Min=0 Max=2.0 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_Refr, def );
sprintf_s(label, 32, "Diffuse%d", i+1);
sprintf_s(def, 128, " group='Sphere%d' label='Diffuse' Min=0 Max=5.0 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_Diff, def );
sprintf_s(label, 32, "Specular%d", i+1);
sprintf_s(def, 128, " group='Sphere%d' label='Specular' Min=0 Max=2.5 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_Spec, def );
sprintf_s(label, 32, "Refraction Index%d", i+1);
sprintf_s(def, 128, " group='Sphere%d' label='Refraction Index' Min=0 Max=5 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_RIndex, def );
sprintf_s(grouping, 64, " Options/Sphere%d group='Spheres' opened=false ", i+1);
TwDefine(grouping);
}
break;
case Raytracer::Primitive::PLANE:
// add a plane
break;
case Raytracer::Primitive::AABB:
// add a box
sprintf_s(label, 32, "Color%d", i+1);
sprintf_s(def, 128, " group='Box%d' label='Color' ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_COLOR3F, &primitive->m_Material->m_Color, def );
sprintf_s(label, 32, "Position%d", i+1);
sprintf_s(def, 128, " group='Box%d' label='Position' ", i+1);
TwAddVarRW(myBar, label, positionType, &((Raytracer::Sphere*)primitive)->m_Centre, def );
sprintf_s(label, 32, "Reflection%d", i+1);
sprintf_s(def, 128, " group='Box%d' label='Reflection' Min=0 Max=2.0 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_Refl, def );
sprintf_s(label, 32, "Refraction%d", i+1);
sprintf_s(def, 128, " group='Box%d' label='Refraction' Min=0 Max=2.0 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_Refr, def );
sprintf_s(label, 32, "Diffuse%d", i+1);
sprintf_s(def, 128, " group='Box%d' label='Diffuse' Min=0 Max=5.0 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_Diff, def );
sprintf_s(label, 32, "Specular%d", i+1);
sprintf_s(def, 128, " group='Box%d' label='Specular' Min=0 Max=2.5 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_Spec, def );
sprintf_s(label, 32, "Refraction Index%d", i+1);
sprintf_s(def, 128, " group='Box%d' label='Refraction Index' Min=0 Max=5 step=0.1 precision=1 ", i+1);
TwAddVarRW(myBar, label, TW_TYPE_FLOAT, &((Raytracer::Sphere*)primitive)->m_Material->m_RIndex, def );
sprintf_s(grouping, 64, " Options/Box%d group='Box' opened=false ", i+1);
TwDefine(grouping);
break;
}
}
TwDefine(" Options/Lights group='Settings' opened=false "); // put light group into settings group
TwDefine(" Options/Spheres group='Settings' opened=false "); // put sphere group into settings group
TwDefine(" Options/Box group='Settings' opened=false "); // put box group into settings group
TwAddVarRW(myBar, "Position", positionType, &m_pTracer->m_cameraPosition, " group='Camera' ");
TwAddVarRW(myBar, "Target", TW_TYPE_DIR3F, &m_pTracer->m_cameraTarget, " group='Camera' ");
TwDefine(" Options/Camera group='Settings' "); // put camera group into settings group
TwAddSeparator(myBar, "sepReset", " group='Settings' ");
TwAddButton(myBar, "Reset Positions", TW_reset, this, " group='Settings' " );
TwAddSeparator(myBar, "sepActions", " group='Settings' ");
TwAddVarRW(myBar, "Render", TW_TYPE_BOOLCPP, &m_antShouldRender, " key=SPACE ");
TwAddButton(myBar, "Cancel", TW_cancel, this, NULL);
TwAddButton(myBar, "Save", TW_save, this, " key=ENTER " );
return true;
}
int main( void )
{
crap::audiodevice audio_device;
/*
openalcode
*/
//setup window
crap::window_setup win_setup;
win_setup.title = "Funny Window";
win_setup.width = 1024;
win_setup.height = 768;
win_setup.multisampling_count = 8;
win_setup.opengl_version = 3.3f;
win_setup.opengl_profile = crap::compat;
//create window
crap::window window( win_setup );
window.open();
//get keyboard and mouse
crap::keyboard keyboard;
crap::mouse mouse;
// temporary
crap::opengl::enable(crap::opengl::depth_test);
crap::opengl::setDepthComparison(crap::opengl::less);
crap::opengl::enable(crap::opengl::cull_face);
//camera setup
camera cam;
cam.setPosition( glm::vec3( 0.0f, 0.0f, 5.0f ) );
mouse_pos = mouse.position();
//create contentmanager
content_manager cm;
cm.init( "spg.ini" );
//create vertex array
crap::vertex_array vert_array;
vert_array.bind();
//test: load vbo onto GPU
vbo cube_vbo( "cube", &cm, vbo::static_draw );
vbo ape_vbo("ape", &cm, vbo::static_draw );
vbo cube_big_vbo( "cube", &cm, vbo::static_draw );
//vbo people_vbo("people", &cm, vbo::static_draw );
//////////////////////////
// Read our .obj file
std::vector<glm::vec3> vertices;
std::vector<glm::vec2> uvs;
std::vector<glm::vec3> normals;
bool res = loadOBJ("../../../data/geometry/dupercube.obj", vertices, uvs, normals);
std::vector<glm::vec3> tangents;
std::vector<glm::vec3> bitangents;
computeTangentBasis(
vertices, uvs, normals, // input
tangents, bitangents // output
);
std::vector<unsigned short> indices;
std::vector<glm::vec3> indexed_vertices;
std::vector<glm::vec2> indexed_uvs;
std::vector<glm::vec3> indexed_normals;
std::vector<glm::vec3> indexed_tangents;
std::vector<glm::vec3> indexed_bitangents;
indexVBO_TBN(
vertices, uvs, normals, tangents, bitangents,
indices, indexed_vertices, indexed_uvs, indexed_normals, indexed_tangents, indexed_bitangents
);
GLuint vertexbuffer;
glGenBuffers(1, &vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, indexed_vertices.size() * sizeof(glm::vec3), &indexed_vertices[0], GL_STATIC_DRAW);
GLuint uvbuffer;
glGenBuffers(1, &uvbuffer);
glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
glBufferData(GL_ARRAY_BUFFER, indexed_uvs.size() * sizeof(glm::vec2), &indexed_uvs[0], GL_STATIC_DRAW);
GLuint normalbuffer;
glGenBuffers(1, &normalbuffer);
glBindBuffer(GL_ARRAY_BUFFER, normalbuffer);
glBufferData(GL_ARRAY_BUFFER, indexed_normals.size() * sizeof(glm::vec3), &indexed_normals[0], GL_STATIC_DRAW);
GLuint tangentbuffer;
glGenBuffers(1, &tangentbuffer);
glBindBuffer(GL_ARRAY_BUFFER, tangentbuffer);
glBufferData(GL_ARRAY_BUFFER, indexed_tangents.size() * sizeof(glm::vec3), &indexed_tangents[0], GL_STATIC_DRAW);
GLuint bitangentbuffer;
glGenBuffers(1, &bitangentbuffer);
glBindBuffer(GL_ARRAY_BUFFER, bitangentbuffer);
glBufferData(GL_ARRAY_BUFFER, indexed_bitangents.size() * sizeof(glm::vec3), &indexed_bitangents[0], GL_STATIC_DRAW);
// Generate a buffer for the indices as well
GLuint elementbuffer;
glGenBuffers(1, &elementbuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned short), &indices[0], GL_STATIC_DRAW);
/////////////////////////
geometry_content ig;
cm.create_content( "cube" , &ig, type_name::geometry );
//test: load texture onto GPU
tbo diffuse_tbo( "stone_diff", &cm, tbo::tga );
tbo normal_tbo( "stone_norm", &cm, tbo::tga );
tbo height_tbo( "stone_height", &cm, tbo::tga );
//shadow stuff
crap::frame_buffer frame_buffer;
frame_buffer.bind();
tbo depthmap( "", &cm, tbo::depth );
frame_buffer.unbind();
//shadow stuff
crap::quad_buffer quad_buffer;
//test: load linked shader progam onto GPU
shader_manager sm(&cm);
sm.add("epr_vert", "epr_frag");
sm.add("shadow_vert", "shadow_frag");
//get stuff from shader program
//shadow shader
sm.set_current("shadow_vert", "shadow_frag");
crap::uniform DepthBiasMVPID = sm.current()->uniform_location("depthMVP");
//vertex shader
sm.set_current("epr_vert", "epr_frag");
crap::uniform WorldMatrixID = sm.current()->uniform_location("world_matrix4x4");
crap::uniform ViewMatrixID = sm.current()->uniform_location("view_matrix4x4");
crap::uniform ModelMatrixID = sm.current()->uniform_location("model_matrix4x4");
crap::uniform ModelView3x3MatrixID = sm.current()->uniform_location("model_view_matrix3x3");
//fragment shader
crap::uniform DiffuseTextureID = sm.current()->uniform_location("diffuse_texture");
crap::uniform NormalTextureID = sm.current()->uniform_location("normal_texture");
crap::uniform HeightTextureID = sm.current()->uniform_location("height_texture");
crap::uniform LightAmbientPowerID = sm.current()->uniform_location("ambient_power");
crap::uniform LightPowerArrayID = sm.current()->uniform_location("light_power");
crap::uniform LightSpecularTypeArrayID = sm.current()->uniform_location("light_specular_type");
crap::uniform LightSpecularLobeArrayID = sm.current()->uniform_location("light_specular_lobe");
crap::uniform LightColorArrayID = sm.current()->uniform_location("light_color");
crap::uniform LightSelfShadowingOnID = sm.current()->uniform_location("selfshadowing_on");
crap::uniform DisplacementOnID = sm.current()->uniform_location("displacement_on");
crap::uniform DisplacementStepsID = sm.current()->uniform_location("displacement_steps");
crap::uniform DisplacementRefinementStepsID = sm.current()->uniform_location("displacement_refinement_steps");
crap::uniform DisplacementUVFactorID = sm.current()->uniform_location("displacement_uv_factor");
//both shaders
crap::uniform LightPositionArrayID = sm.current()->uniform_location("light_position");
crap::uniform LightDirectionArrayID = sm.current()->uniform_location("light_direction");
crap::uniform LightTypeArrayID = sm.current()->uniform_location("light_type");
crap::uniform LightStateArrayID = sm.current()->uniform_location("light_state");
crap::uniform LightNormalMappingOnID = sm.current()->uniform_location("normal_mapping_on");
//shadow stuff
crap::uniform ShadowMapID = sm.current()->uniform_location("shadow_map");
crap::uniform ShadowMappingOnID = sm.current()->uniform_location("shadow_mapping_on");
crap::uniform ShadowDepthBiasMVPID = sm.current()->uniform_location("depth_bias_mvp");
//SHADER DATA
// Projection matrix : 60° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
float display_field_of_view = 60.f; //60°
float display_ratio_horizontal = 4.f;
float display_ratio_vertical = 3.f;
float display_range_near = 0.1f;
float display_range_far = 100.f;
glm::mat4 projection_matrix = glm::perspective(
display_field_of_view,
display_ratio_horizontal / display_ratio_vertical,
display_range_near,
display_range_far);
glm::mat4 model_matrix(1.0f);
glm::mat4 model_view_matrix(1.0f);
glm::mat4 view_matrix = cam.view();
glm::mat4 world_matrix(1.0f);
glm::mat3 model_view_matrix3x3(1.0f);
//light stuff
float light_ambient_power = 0.5f;
float light_power_array[MAX_LIGHTS] = { 1.f, 1.f, 1.f };
int light_specular_type_array[MAX_LIGHTS] = { 1, 1, 1 };
float light_specular_lobe_array[MAX_LIGHTS] = { 100.f, 100.f, 100.f };
glm::vec3 light_color_array[MAX_LIGHTS] = { glm::vec3(1.f), glm::vec3(1.f), glm::vec3(1.f) };
int light_self_shadowing_on = 1;
glm::vec3 light_position_array[MAX_LIGHTS] = { glm::vec3(4,0,0), glm::vec3(0,0,-4), glm::vec3(4,4,4) };
glm::vec3 light_direction_array[MAX_LIGHTS] = { glm::vec3(-4,0,0), glm::vec3(0,0,4), glm::vec3(-4,-4,-4) };
int light_type_array[MAX_LIGHTS] = { 0, 0, 0 };
int light_state_array[MAX_LIGHTS] = { 1, 0, 0 };
int light_normal_mapping_on = 1;
//shadowstuff
int shadow_mapping_on = 1;
//displacement stuff
int displacement_on = 1;
float displacement_steps = 20;
float displacement_refinement_steps = 20;
float displacmenet_uv_factor = 20;
//GUI
TwInit(TW_OPENGL, NULL);
TwWindowSize(1024, 768);
TwBar * GeneralGUI = TwNewBar("General settings");
TwBar * LightGUI = TwNewBar("Light Settings");
TwBar * DisplacementGUI = TwNewBar("Displacement Settings");
TwSetParam(GeneralGUI, NULL, "refresh", TW_PARAM_CSTRING, 1, "0.1");
TwSetParam(LightGUI, NULL, "refresh", TW_PARAM_CSTRING, 1, "0.1");
TwSetParam(DisplacementGUI, NULL, "refresh", TW_PARAM_CSTRING, 1, "0.1");
//general gui
TwAddSeparator(GeneralGUI, "Funny seperator", NULL);
TwAddVarRW(GeneralGUI, "Field of View", TW_TYPE_FLOAT , &display_field_of_view, "help='Field of View value'");
TwAddVarRW(GeneralGUI, "Ratio Horizontal", TW_TYPE_FLOAT , &display_ratio_horizontal, "help='Ratio Horizontal'");
TwAddVarRW(GeneralGUI, "Ratio Vertical", TW_TYPE_FLOAT , &display_ratio_vertical, "help='Ratio Vertical'");
TwAddVarRW(GeneralGUI, "Range Near", TW_TYPE_FLOAT , &display_range_near, "help='Range near'");
TwAddVarRW(GeneralGUI, "Range far", TW_TYPE_FLOAT , &display_range_far, "help='Range far'");
//light gui
TwAddVarRW(LightGUI, "Ambient light", TW_TYPE_FLOAT , &light_ambient_power, "help='Ambient power'");
TwAddVarRW(LightGUI, "Self Shadowing", TW_TYPE_BOOL32, &light_self_shadowing_on, NULL);
TwAddVarRW(LightGUI, "Normal Mapping", TW_TYPE_BOOL32, &light_normal_mapping_on, NULL);
TwType gui_light_type = TwDefineEnumFromString("LightType", "Directionallight,Pointlight");
TwType gui_light_specular_type = TwDefineEnumFromString("LightSpecularType", "Blinn,Phong");
//shadow
TwAddVarRW(LightGUI, "Cast Shadows", TW_TYPE_BOOL32, &shadow_mapping_on, NULL);
//light1
TwAddVarRW(LightGUI, "Light 1", TW_TYPE_BOOL32, light_state_array, NULL);
TwAddVarRW(LightGUI, "Light Type 1", gui_light_type, light_type_array, NULL);
TwAddVarRW(LightGUI, "Light Specular Type 1", gui_light_specular_type, light_specular_type_array, NULL);
TwAddVarRW(LightGUI, "Light Power 1", TW_TYPE_FLOAT , light_power_array, NULL);
TwAddVarRW(LightGUI, "Light Specular Lobe 1", TW_TYPE_FLOAT , light_specular_lobe_array, NULL);
TwAddVarRW(LightGUI, "Light Color 1", TW_TYPE_COLOR3F , light_color_array, NULL);
TwAddVarRW(LightGUI, "Light Position 1", TW_TYPE_DIR3F , light_position_array, NULL);
TwAddVarRW(LightGUI, "Light Direction 1", TW_TYPE_DIR3F , light_direction_array, NULL);
//light2
TwAddVarRW(LightGUI, "Light 2", TW_TYPE_BOOL32, light_state_array+1, NULL);
TwAddVarRW(LightGUI, "Light Type 2", gui_light_type, light_type_array+1, NULL);
TwAddVarRW(LightGUI, "Light Specular Type 2", gui_light_specular_type, light_specular_type_array+1, NULL);
TwAddVarRW(LightGUI, "Light Power 2", TW_TYPE_FLOAT , light_power_array+1, NULL);
TwAddVarRW(LightGUI, "Light Specular Lobe 2", TW_TYPE_FLOAT , light_specular_lobe_array+1, NULL);
TwAddVarRW(LightGUI, "Light Color 2", TW_TYPE_COLOR3F , light_color_array+1, NULL);
TwAddVarRW(LightGUI, "Light Position 2", TW_TYPE_DIR3F , light_position_array+1, NULL);
TwAddVarRW(LightGUI, "Light Direction 2", TW_TYPE_DIR3F , light_direction_array+1, NULL);
//light3
TwAddVarRW(LightGUI, "Light 3", TW_TYPE_BOOL32, light_state_array+2, NULL);
TwAddVarRW(LightGUI, "Light Type 3", gui_light_type, light_type_array+2, NULL);
TwAddVarRW(LightGUI, "Light Specular Type 3", gui_light_specular_type, light_specular_type_array+2, NULL);
TwAddVarRW(LightGUI, "Light Power 3", TW_TYPE_FLOAT , light_power_array+2, NULL);
TwAddVarRW(LightGUI, "Light Specular Lobe 3", TW_TYPE_FLOAT , light_specular_lobe_array+2, NULL);
TwAddVarRW(LightGUI, "Light Color 3", TW_TYPE_COLOR3F , light_color_array+2, NULL);
TwAddVarRW(LightGUI, "Light Position 3", TW_TYPE_DIR3F , light_position_array+2, NULL);
TwAddVarRW(LightGUI, "Light Direction 3", TW_TYPE_DIR3F , light_direction_array+2, NULL);
//displacement gui
TwAddVarRW(DisplacementGUI, "Displacement ON/OFF", TW_TYPE_BOOL32, &displacement_on, NULL);
TwAddVarRW(DisplacementGUI, "Displacment steps", TW_TYPE_FLOAT , &displacement_steps, NULL);
TwAddVarRW(DisplacementGUI, "Displacement refinement", TW_TYPE_FLOAT , &displacement_refinement_steps, NULL);
TwAddVarRW(DisplacementGUI, "Displacement UV factor", TW_TYPE_FLOAT , &displacmenet_uv_factor, NULL);
//gui mouse setup
mouse.set_on_pressed_function( (crap::mouse::user_button_callback_function)gui_mouse_down );
mouse.set_on_release_function( (crap::mouse::user_button_callback_function)gui_mouse_up );
mouse.set_on_move_function( (crap::mouse::user_move_callback_function)TwEventMousePosGLFW );
mouse.set_on_wheel_function( (crap::mouse::user_wheel_callback_function)TwEventMouseWheelGLFW );
keyboard.set_on_pressed_function( (crap::keyboard::user_callback_function)TwEventKeyGLFW );
//todo set char input
// temporary
crap::opengl::clearColor(1.0f, 1.0f, 1.0f, 0.0f);
while( !keyboard.is_pressed( crap::keyboard::key_escape ) && window.is_open() )
{
// update positions
handleInput(keyboard, mouse, cam);
crap::opengl::clear(crap::opengl::color_depth_buffer);
frame_buffer.bind();
glViewport(0,0,1024,1024); // Render on the whole framebuffer, complete from the lower left corner to the upper right
sm.set_current("shadow_vert", "shadow_frag");
sm.activate();
glm::vec3 lightInvDir = light_direction_array[0]; //glm::vec3(0.5f,2,2);
// Compute the MVP matrix from the light's point of view
glm::mat4 depthProjectionMatrix = glm::ortho<float>(-10,10,-10,10,-10,20);
glm::mat4 depthViewMatrix = glm::lookAt(lightInvDir, glm::vec3(0,0,0), glm::vec3(0,1,0));
glm::mat4 depthModelMatrix = glm::mat4(1.0);
glm::mat4 depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;
sm.current()->uniform_matrix4f_value( DepthBiasMVPID, 1, &depthMVP[0][0]);
sm.current()->vertex_attribute_array.enable(0);
cube_vbo.bind_buffer( vbo::verticies );
sm.current()->vertex_attribute_array.pointer( 0, 3, crap::gl_float, false, 0, (void*)0);
cube_vbo.bind_buffer( vbo::indicies );
crap::opengl::draw_elements(
crap::opengl::triangles, // mode
cube_vbo.indicies_size, // count
crap::opengl::unsigned_short // type
);
sm.current()->vertex_attribute_array.disable(0);
frame_buffer.unbind();
glViewport(0,0,1024,768); // Render on the whole framebuffer, complete from the lower left corner to the upper right
crap::opengl::clear(crap::opengl::color_depth_buffer);
sm.set_current("epr_vert", "epr_frag");
sm.activate();
///////////////////////////////////////
//////////////////////////////////////
projection_matrix = glm::perspective(
display_field_of_view,
display_ratio_horizontal / display_ratio_vertical,
display_range_near,
display_range_far);
view_matrix = cam.view();
model_view_matrix = view_matrix * world_matrix;
model_view_matrix3x3 = glm::mat3(model_view_matrix);
world_matrix = projection_matrix * view_matrix * model_matrix;
glm::mat4 biasMatrix(
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0
);
glm::mat4 depthBiasMVP = biasMatrix*depthMVP;
sm.current()->uniform_matrix4f_value( ShadowDepthBiasMVPID, 1, &depthBiasMVP[0][0]);
sm.current()->uniform_1i(ShadowMappingOnID, shadow_mapping_on);
//activate shader porgram and connect data
//sm.activate();
//default stuff
sm.current()->uniform_matrix4f_value( WorldMatrixID, 1, &world_matrix[0][0]);
sm.current()->uniform_matrix4f_value( ModelMatrixID, 1, &model_matrix[0][0]);
sm.current()->uniform_matrix4f_value( ViewMatrixID, 1, &view_matrix[0][0]);
sm.current()->uniform_matrix3f_value( ModelView3x3MatrixID, 1, &model_view_matrix3x3[0][0]);
//light
sm.activate();
sm.current()->uniform_1f(LightAmbientPowerID, light_ambient_power);
sm.current()->uniform_1i(LightSelfShadowingOnID, light_self_shadowing_on);
sm.current()->uniform_1i(LightNormalMappingOnID, light_normal_mapping_on);
sm.current()->uniform_1f_value( LightPowerArrayID, 3, light_power_array );
sm.current()->uniform_1i_value( LightSpecularTypeArrayID, 3, light_specular_type_array );
sm.current()->uniform_1f_value( LightSpecularLobeArrayID, 3, light_specular_lobe_array );
sm.current()->uniform_3f_value( LightColorArrayID, 3, (f32*)light_color_array );
sm.current()->uniform_3f_value( LightPositionArrayID, 3, (f32*)light_position_array );
sm.current()->uniform_3f_value( LightDirectionArrayID, 3, (f32*)light_direction_array );
sm.current()->uniform_1i_value( LightTypeArrayID, 3, light_type_array );
sm.current()->uniform_1i_value( LightStateArrayID, 3, light_state_array );
//displacement
sm.current()->uniform_1i( DisplacementOnID, displacement_on );
sm.current()->uniform_1f( DisplacementStepsID, displacement_steps);
sm.current()->uniform_1f( DisplacementRefinementStepsID, displacement_refinement_steps);
sm.current()->uniform_1f( DisplacementUVFactorID, displacmenet_uv_factor);
//activate texture buffer and connect data
diffuse_tbo.activate();
diffuse_tbo.bind_buffer();
sm.current()->uniform_1i( DiffuseTextureID, 0);
normal_tbo.activate();
normal_tbo.bind_buffer();
sm.current()->uniform_1i( NormalTextureID, 1);
height_tbo.activate();
height_tbo.bind_buffer();
sm.current()->uniform_1i( HeightTextureID, 2 );
depthmap.activate();
depthmap.bind_buffer();
sm.current()->uniform_1i( ShadowMapID, 4);
//define data of buffers
sm.current()->vertex_attribute_array.enable(0);
//cube_vbo.bind_buffer( vbo::verticies );
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
sm.current()->vertex_attribute_array.pointer( 0, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(1);
glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
//cube_vbo.bind_buffer( vbo::uvs );
sm.current()->vertex_attribute_array.pointer( 1, 2, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(2);
glBindBuffer(GL_ARRAY_BUFFER, normalbuffer);
//cube_vbo.bind_buffer( vbo::normals );
sm.current()->vertex_attribute_array.pointer( 2, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(3);
glBindBuffer(GL_ARRAY_BUFFER, tangentbuffer);
//cube_vbo.bind_buffer( vbo::tangents );
sm.current()->vertex_attribute_array.pointer( 3, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(4);
glBindBuffer(GL_ARRAY_BUFFER, bitangentbuffer);
//cube_vbo.bind_buffer( vbo::binormals );
sm.current()->vertex_attribute_array.pointer( 4, 3, crap::gl_float, false, 0, (void*)0);
////draw the f**k
cube_vbo.bind_buffer( vbo::indicies );
crap::opengl::draw_elements(
crap::opengl::triangles, // mode
cube_vbo.indicies_size, // count
crap::opengl::unsigned_short // type
);
sm.current()->vertex_attribute_array.disable(0);
sm.current()->vertex_attribute_array.disable(1);
sm.current()->vertex_attribute_array.disable(2);
sm.current()->vertex_attribute_array.disable(3);
sm.current()->vertex_attribute_array.disable(4);
//next object
glm::mat4 model_matrix_2 = model_matrix * glm::translate(3.f,0.f,0.f);
model_view_matrix = view_matrix * model_matrix_2;
model_view_matrix3x3 = glm::mat3(model_view_matrix);
world_matrix = projection_matrix * view_matrix * model_matrix_2;
//activate shader porgram and connect data
//sm.activate();
sm.current()->uniform_matrix4f_value( WorldMatrixID, 1, &world_matrix[0][0]);
sm.current()->uniform_matrix4f_value( ModelMatrixID, 1, &model_matrix_2[0][0]);
sm.current()->uniform_matrix3f_value( ModelView3x3MatrixID, 1, &model_view_matrix3x3[0][0]);
//attempt
//define data of buffers
sm.current()->vertex_attribute_array.enable(0);
ape_vbo.bind_buffer( vbo::verticies );
sm.current()->vertex_attribute_array.pointer( 0, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(1);
ape_vbo.bind_buffer( vbo::uvs );
sm.current()->vertex_attribute_array.pointer( 1, 2, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(2);
ape_vbo.bind_buffer( vbo::normals );
sm.current()->vertex_attribute_array.pointer( 2, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(3);
ape_vbo.bind_buffer( vbo::tangents );
sm.current()->vertex_attribute_array.pointer(3, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(4);
ape_vbo.bind_buffer( vbo::binormals );
sm.current()->vertex_attribute_array.pointer( 4, 3, crap::gl_float, false, 0, (void*)0);
//draw the f**k
ape_vbo.bind_buffer( vbo::indicies );
crap::opengl::draw_elements(
crap::opengl::triangles, // mode
ape_vbo.indicies_size, // count
crap::opengl::unsigned_short // type
);
//disable data define stuff
sm.current()->vertex_attribute_array.disable(0);
sm.current()->vertex_attribute_array.disable(1);
sm.current()->vertex_attribute_array.disable(2);
sm.current()->vertex_attribute_array.disable(3);
sm.current()->vertex_attribute_array.disable(4);
//next object
glm::mat4 model_matrix_3 = model_matrix * glm::translate(0.f,-2.f,0.f);
model_view_matrix = view_matrix * model_matrix_2;
model_view_matrix3x3 = glm::mat3(model_view_matrix);
world_matrix = projection_matrix * view_matrix * model_matrix_3;
//activate shader porgram and connect data
//sm.activate();
sm.current()->uniform_matrix4f_value( WorldMatrixID, 1, &world_matrix[0][0]);
sm.current()->uniform_matrix4f_value( ModelMatrixID, 1, &model_matrix_3[0][0]);
sm.current()->uniform_matrix3f_value( ModelView3x3MatrixID, 1, &model_view_matrix3x3[0][0]);
//attempt
//define data of buffers
sm.current()->vertex_attribute_array.enable(0);
cube_big_vbo.bind_buffer( vbo::verticies );
sm.current()->vertex_attribute_array.pointer( 0, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(1);
cube_big_vbo.bind_buffer( vbo::uvs );
sm.current()->vertex_attribute_array.pointer( 1, 2, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(2);
cube_big_vbo.bind_buffer( vbo::normals );
sm.current()->vertex_attribute_array.pointer( 2, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(3);
cube_big_vbo.bind_buffer( vbo::tangents );
sm.current()->vertex_attribute_array.pointer(3, 3, crap::gl_float, false, 0, (void*)0);
sm.current()->vertex_attribute_array.enable(4);
cube_big_vbo.bind_buffer( vbo::binormals );
sm.current()->vertex_attribute_array.pointer( 4, 3, crap::gl_float, false, 0, (void*)0);
//draw the f**k
cube_big_vbo.bind_buffer( vbo::indicies );
crap::opengl::draw_elements(
crap::opengl::triangles, // mode
cube_big_vbo.indicies_size, // count
crap::opengl::unsigned_short // type
);
//disable data define stuff
sm.current()->vertex_attribute_array.disable(0);
sm.current()->vertex_attribute_array.disable(1);
sm.current()->vertex_attribute_array.disable(2);
sm.current()->vertex_attribute_array.disable(3);
sm.current()->vertex_attribute_array.disable(4);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf((const GLfloat*)&projection_matrix[0]);
glMatrixMode(GL_MODELVIEW);
glm::mat4 MV = view_matrix * model_matrix;
glLoadMatrixf((const GLfloat*)&MV[0]);
sm.activate();
// normals
glColor3f(0,0,1);
glBegin(GL_LINES);
for (unsigned int i=0; i<ig.indices_size; i++){
glm::vec3 p = glm::vec3(ig.positions[ig.indices[i]].x, ig.positions[ig.indices[i]].y, ig.positions[ig.indices[i]].z );
glVertex3fv(&p.x);
glm::vec3 o = glm::normalize( glm::vec3(ig.normals[ig.indices[i]].x, ig.normals[ig.indices[i]].y, ig.normals[ig.indices[i]].z) );
p+=o*0.1f;
glVertex3fv(&p.x);
}
glEnd();
// tangents
glColor3f(1,0,0);
glBegin(GL_LINES);
for (unsigned int i=0; i<ig.indices_size; i++){
glm::vec3 p = glm::vec3(ig.positions[ig.indices[i]].x, ig.positions[ig.indices[i]].y, ig.positions[ig.indices[i]].z );
glVertex3fv(&p.x);
glm::vec3 o = glm::normalize( glm::vec3(ig.tangents[ig.indices[i]].x, ig.tangents[ig.indices[i]].y, ig.tangents[ig.indices[i]].z) );
p+=o*0.1f;
glVertex3fv(&p.x);
}
glEnd();
// bitangents
glColor3f(0,1,0);
glBegin(GL_LINES);
for (unsigned int i=0; i<ig.indices_size; i++){
glm::vec3 p = glm::vec3(ig.positions[ig.indices[i]].x, ig.positions[ig.indices[i]].y, ig.positions[ig.indices[i]].z );
glVertex3fv(&p.x);
glm::vec3 o = glm::normalize( glm::vec3(ig.binormals[ig.indices[i]].x, ig.binormals[ig.indices[i]].y, ig.binormals[ig.indices[i]].z) );
p+=o*0.1f;
glVertex3fv(&p.x);
}
glEnd();
glm::vec3 debug_light;
// light pos 1
glColor3f(1,1,1);
glBegin(GL_LINES);
debug_light = light_position_array[0];
glVertex3fv(&debug_light.x);
debug_light+=glm::vec3(1,0,0)*0.1f;
glVertex3fv(&debug_light.x);
debug_light-=glm::vec3(1,0,0)*0.1f;
glVertex3fv(&debug_light.x);
debug_light+=glm::vec3(0,1,0)*0.1f;
glVertex3fv(&debug_light.x);
glEnd();
// light pos 2
glColor3f(1,1,1);
glBegin(GL_LINES);
debug_light = light_position_array[1];
glVertex3fv(&debug_light.x);
debug_light+=glm::vec3(1,0,0)*0.1f;
glVertex3fv(&debug_light.x);
debug_light-=glm::vec3(1,0,0)*0.1f;
glVertex3fv(&debug_light.x);
debug_light+=glm::vec3(0,1,0)*0.1f;
glVertex3fv(&debug_light.x);
glEnd();
// light pos3
glColor3f(1,1,1);
glBegin(GL_LINES);
debug_light = light_position_array[2];
glVertex3fv(&debug_light.x);
debug_light+=glm::vec3(1,0,0)*0.1f;
glVertex3fv(&debug_light.x);
debug_light-=glm::vec3(1,0,0)*0.1f;
glVertex3fv(&debug_light.x);
debug_light+=glm::vec3(0,1,0)*0.1f;
glVertex3fv(&debug_light.x);
glEnd();
// Draw GUI
TwDraw();
//poll and swap
window.swap();
window.poll_events();
}
TwTerminate();
//geometry_content ig;
//cm.create_content( "ape" , &ig, type_name::geometry );
//texture_content tc;
//cm.create_content( "color", &tc, type_name::texture );
//shader_content sc;
//cm.create_content( "fragment_texture_only", &sc, type_name::shader );
//cm.save_content( "fragment_texture_only", &sc, type_name::shader );
return 0;
}
void CreateMenus (void)
{
{
TwBar *bar = TwNewBar ("pentachoron");
TwDefine ("pentachoron label='Pentachoron'");
TwType rendermodeType;
TwEnumVal rendermodeEV[] = {
{ 0, "compose" },
{ 1, "color" },
{ 2, "normal" },
{ 3, "specular" },
{ 4, "depth" },
{ 5, "glow" },
{ 6, "shadow" }
};
rendermodeType = TwDefineEnum ("rendermode", rendermodeEV, 7);
TwAddVarCB (bar, "FPS", TW_TYPE_UINT32,
NULL, [&] (void *v, void*) {
*(unsigned int*)v = fps;
}, NULL, NULL);
TwAddVarCB (bar, "rendermode", rendermodeType,
[&] (const void *v, void*) {
r->postprocess.SetRenderMode (*(unsigned int*)v);
}, [&] (void *v, void*) {
*(unsigned int*)v = r->postprocess.GetRenderMode ();
}, NULL, NULL);
TwAddVarCB (bar, "tile-based light culling", TW_TYPE_BOOLCPP,
[&] (const void *v, void*) {
r->composition.SetTileBased (*(bool*)v);
}, [&] (void *v, void*){
*(bool*)v = r->composition.GetTileBased ();
}, NULL, NULL);
TwAddVarCB (bar, "wireframe", TW_TYPE_BOOLCPP,
[&] (const void *v, void*) {
r->gbuffer.SetWireframe (*(bool*)v);
}, [&] (void *v, void*) {
*(bool*)v = r->gbuffer.GetWireframe ();
}, NULL, NULL);
TwAddVarCB (bar, "tesslevel", TW_TYPE_UINT32,
[&] (const void *v, void*) {
r->geometry.SetTessLevel (*(uint32_t*)v);
}, [&] (void *v, void*) {
*(uint32_t*)v = r->geometry.GetTessLevel ();
}, NULL, "label='tessellation level' min=1 max=64");
TwAddVarCB (bar, "displacement", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->geometry.SetDisplacement (*(float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->geometry.GetDisplacement ();
}, NULL, "label='displacement' min=0 step=0.01");
}
{
TwBar *bar = TwNewBar ("lights");
TwDefine ("lights label='Lights' iconified=true");
TwAddButton (bar, "add light", [&] (void*) {
AddLight ();
}, NULL, NULL);
TwAddButton (bar, "remove", [&] (void*) {
RemoveLight ();
}, NULL, "label='remove light' visible=false");
TwAddVarRW (bar, "active", TW_TYPE_UINT32,
&active_light, "label='active light' visible=false");
TwAddSeparator (bar, NULL, NULL);
TwStructMember lightposDesc[] = {
{ "x", TW_TYPE_FLOAT, offsetof (glm::vec4, x), "step=0.1" },
{ "y", TW_TYPE_FLOAT, offsetof (glm::vec4, y), "step=0.1" },
{ "z", TW_TYPE_FLOAT, offsetof (glm::vec4, z), "step=0.1" }
};
TwStructMember attenuationDesc[] = {
{ "constant", TW_TYPE_FLOAT, offsetof (glm::vec4, x), "step=0.01" },
{ "linear", TW_TYPE_FLOAT, offsetof (glm::vec4, y), "step=0.01" },
{ "quadratic", TW_TYPE_FLOAT, offsetof (glm::vec4, z), "step=0.01" },
{ "cull distance", TW_TYPE_FLOAT, offsetof (glm::vec4, w), "step=0.1" }
};
typedef struct spotparam {
float angle;
float penumbra_angle;
float exponent;
} spotparam_t;
TwStructMember spotDesc[] = {
{ "angle", TW_TYPE_FLOAT,
offsetof (spotparam_t, angle), "step=1 min=0 max=360" },
{ "penumbra angle", TW_TYPE_FLOAT,
offsetof (spotparam_t, penumbra_angle), "step=1 min=0 max=360" },
{ "exponent", TW_TYPE_FLOAT,
offsetof (spotparam_t, exponent), "step=0.1" }
};
TwType lightposType = TwDefineStruct ("lightpos", lightposDesc, 3,
sizeof (glm::vec4),
NULL, NULL);
TwType spotdescType = TwDefineStruct ("spotdesc", spotDesc, 3,
sizeof (spotparam_t),
NULL, NULL);
TwType attenuationType = TwDefineStruct ("attenuation", attenuationDesc, 4,
sizeof (glm::vec4),
NULL, NULL);
TwAddVarCB (bar, "position", lightposType,
[&] (const void *v, void*) {
r->GetLight (active_light).position
= *(glm::vec4*)v;
r->UpdateLight (active_light);
}, [&] (void *v, void*) {
*(glm::vec4*)v = r->GetLight (active_light).position;
}, NULL, "visible=false");
TwAddVarCB (bar, "direction", TW_TYPE_DIR3F,
[&] (const void *v, void*) {
r->GetLight (active_light).direction
= glm::vec4 (*(const glm::vec3*)v, 0.0f);
r->UpdateLight (active_light);
}, [&] (void *v, void*) {
*(glm::vec3*)v
= glm::vec3 (r->GetLight (active_light).direction);
}, NULL, "visible=false");
TwAddVarCB (bar, "color", TW_TYPE_COLOR3F,
[&] (const void *v, void*) {
r->GetLight (active_light).color
= glm::vec4 (*(const glm::vec3*)v, 1.0f);
r->UpdateLight (active_light);
}, [&] (void *v, void*) {
*(glm::vec3*)v
= glm::vec3 (r->GetLight (active_light).color);
}, NULL, "visible=false");
TwAddVarCB (bar, "spot", spotdescType,
[&] (const void *v, void*) {
Light &light = r->GetLight (active_light);
light.spot.exponent = ((spotparam_t*)v)->exponent;
light.spot.angle = (((spotparam_t*)v)->angle)
* PCH_PI / 180.0f;
light.spot.cosine = cosf (light.spot.angle);
light.spot.tangent = tanf (light.spot.angle);
light.spot.penumbra_angle
= ((spotparam_t*)v)->penumbra_angle * PCH_PI / 180.0f;
light.spot.penumbra_cosine
= cosf (light.spot.penumbra_angle);
r->UpdateLight (active_light);
}, [&] (void *v, void*){
const Light &light = r->GetLight (active_light);
((spotparam_t*)v)->exponent = light.spot.exponent;
((spotparam_t*)v)->angle = light.spot.angle
* 180.0f / PCH_PI;
((spotparam_t*)v)->penumbra_angle
= light.spot.penumbra_angle * 180.0f / PCH_PI;
}, NULL, "visible=false");
TwAddVarCB (bar, "attenuation", attenuationType,
[&] (const void *v, void*) {
r->GetLight (active_light).attenuation
= *(glm::vec4*)v;
r->GetLight (active_light).attenuation.z /= 100.0f;
r->UpdateLight (active_light);
}, [&] (void *v, void*) {
*(glm::vec4*)v = r->GetLight (active_light).attenuation;
((glm::vec4*)v)->z *= 100.0f;
}, NULL, "visible=false");
TwAddVarCB (bar, "specular", TW_TYPE_COLOR3F,
[&] (const void *v, void*) {
r->GetLight (active_light).specular.color
= *(const glm::vec3*)v;
r->UpdateLight (active_light);
}, [&] (void *v, void*) {
*(glm::vec3*)v
= r->GetLight (active_light).specular.color;
}, NULL, "label='specular color' visible=false");
}
{
TwBar *bar = TwNewBar ("sky");
TwDefine ("sky label='Sky' iconified=true");
typedef struct perezcoefficients {
union {
struct {
float A, B, C, D, E;
};
float p[5];
};
} perezcoefficients_t;
TwStructMember perezDesc[] = {
{ "Darkening/Brightening to the horizon",
TW_TYPE_FLOAT, offsetof (perezcoefficients_t, A),
"step=0.01" },
{ "Luminance gradient near the horizon",
TW_TYPE_FLOAT, offsetof (perezcoefficients_t, B),
"step=0.01" },
{ "Relative intensity of circumsolar region",
TW_TYPE_FLOAT, offsetof (perezcoefficients_t, C),
"step=0.01" },
{ "Width of the circumsolar region",
TW_TYPE_FLOAT, offsetof (perezcoefficients_t, D),
"step=0.01" },
{ "Relative backscatered light at the earth surface",
TW_TYPE_FLOAT, offsetof (perezcoefficients_t, E),
"step=0.01" }
};
TwType perezType = TwDefineStruct ("perez", perezDesc, 5,
sizeof (perezcoefficients_t),
NULL, NULL);
TwAddVarCB (bar, "turbidity", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->composition.SetTurbidity (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->composition.GetTurbidity ();
}, NULL, "step=0.1 min=1.0 max=10.0");
TwAddVarCB (bar, "time", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->composition.SetTimeOfDay (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->composition.GetTimeOfDay ();
}, NULL, "step=0.01 min=0.0 max=24.0");
TwType monthType;
TwEnumVal monthEV[] = {
{ 0, "January" },
{ 1, "February" },
{ 2, "March" },
{ 3, "April" },
{ 4, "May" },
{ 5, "June" },
{ 6, "July" },
{ 7, "August" },
{ 8, "September" },
{ 9, "October" },
{ 10, "November" },
{ 11, "December" }
};
monthType = TwDefineEnum ("month", monthEV, 12);
TwAddVarCB (bar, "month", monthType,
[&] (const void *v, void*) {
int month, day;
ToCalendarDate (r->composition.GetDate (), &month, &day);
month = *(const unsigned int*)v;
r->composition.SetDate (ToOrdinalDate (month, day));
}, [&] (void *v, void*) {
int month, day;
ToCalendarDate (r->composition.GetDate (), &month, &day);
*(unsigned int*)v = month;
}, NULL, NULL);
TwAddVarCB (bar, "day", TW_TYPE_UINT8,
[&] (const void *v, void*) {
int month, day;
ToCalendarDate (r->composition.GetDate (), &month, &day);
day = *(const unsigned char*)v;
r->composition.SetDate (ToOrdinalDate (month, day));
}, [&] (void *v, void*) {
int month, day;
ToCalendarDate (r->composition.GetDate (), &month, &day);
*(unsigned char*)v = day;
}, NULL, "min=1 max=31");
TwAddVarCB (bar, "luminosity", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->composition.SetSkyLuminosity (0.01f * *(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->composition.GetSkyLuminosity () * 100.0f;
}, NULL, "step=0.01");
TwAddVarCB (bar, "latitude", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->composition.SetLatitude (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->composition.GetLatitude ();
}, NULL, "step=0.1 min=0.0 max=90.0");
TwAddVarCB (bar, "Y", perezType,
[&] (const void *v, void*) {
for (auto i = 0; i < 5; i++)
r->composition.SetPerezY
(i, ((perezcoefficients_t*)v)->p[i]);
}, [&] (void *v, void *) {
for (auto i = 0; i < 5; i++)
((perezcoefficients_t*)v)->p[i]
= r->composition.GetPerezY (i);
}, NULL, "label='Coefficients Y'");
TwAddVarCB (bar, "x", perezType,
[&] (const void *v, void*) {
for (auto i = 0; i < 5; i++)
r->composition.SetPerezx
(i, ((perezcoefficients_t*)v)->p[i]);
}, [&] (void *v, void *) {
for (auto i = 0; i < 5; i++)
((perezcoefficients_t*)v)->p[i]
= r->composition.GetPerezx (i);
}, NULL, "label='Coefficients x'");
TwAddVarCB (bar, "y", perezType,
[&] (const void *v, void*) {
for (auto i = 0; i < 5; i++)
r->composition.SetPerezy
(i, ((perezcoefficients_t*)v)->p[i]);
}, [&] (void *v, void *) {
for (auto i = 0; i < 5; i++)
((perezcoefficients_t*)v)->p[i]
= r->composition.GetPerezy (i);
}, NULL, "label='Coefficients y'");
}
{
TwBar *bar = TwNewBar ("tonemapping");
TwDefine ("tonemapping label='Tonemapping' iconified=true");
TwEnumVal tonemappingmodeEV[] = {
{ 0, "Default" },
{ 1, "Reinhard" },
{ 2, "Logarithmic" },
{ 3, "URQ" },
{ 4, "Exponential" },
{ 5, "Drago" },
};
TwType tonemappingmodeType;
tonemappingmodeType = TwDefineEnum ("tonemappingmode",
tonemappingmodeEV, 6);
TwAddVarCB (bar, "Mode", tonemappingmodeType,
[&] (const void *v, void*) {
r->postprocess.SetTonemappingMode (*(const unsigned int*)v);
}, [&] (void *v, void*) {
*(unsigned int*)v
= r->postprocess.GetTonemappingMode ();
}, NULL, NULL);
TwAddVarCB (bar, "Image Key", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->postprocess.SetImageKey (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v
= r->postprocess.GetImageKey ();
}, NULL, "step=0.001 min=0.001 max=5.0");
TwAddVarCB (bar, "White threshold", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->postprocess.SetWhiteThreshold (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->postprocess.GetWhiteThreshold ();
}, NULL, "step=0.01 min=0.0 max=5.0");
TwAddVarCB (bar, "Sigma", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->postprocess.SetTonemappingSigma (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->postprocess.GetTonemappingSigma ();
}, NULL, "step=0.01 min=0.0 max=5.0");
TwAddVarCB (bar, "Exponent", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->postprocess.SetTonemappingExponent (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->postprocess.GetTonemappingExponent ();
}, NULL, "step=0.01 min=0.0");
TwStructMember avglumDesc[] = {
{ "constant", TW_TYPE_FLOAT, offsetof (glm::vec4, x), "step=0.01" },
{ "linear", TW_TYPE_FLOAT, offsetof (glm::vec4, y), "step=0.01" },
{ "delta", TW_TYPE_FLOAT, offsetof (glm::vec4, z), "step=0.01" },
{ "lod", TW_TYPE_FLOAT, offsetof (glm::vec4, w), "step=0.1" }
};
TwType avglumType = TwDefineStruct ("avglum", avglumDesc, 4,
sizeof (glm::vec4),
NULL, NULL);
TwAddVarCB (bar, "avgLum", avglumType,
[&] (const void *v, void*) {
r->postprocess.SetAvgLumConst (((const glm::vec4*)v)->x);
r->postprocess.SetAvgLumLinear (((const glm::vec4*)v)->y);
r->postprocess.SetAvgLumDelta (((const glm::vec4*)v)->z);
r->postprocess.SetAvgLumLod (((const glm::vec4*)v)->w);
}, [&] (void *v, void*) {
((glm::vec4*)v)->x = r->postprocess.GetAvgLumConst ();
((glm::vec4*)v)->y = r->postprocess.GetAvgLumLinear ();
((glm::vec4*)v)->z = r->postprocess.GetAvgLumDelta ();
((glm::vec4*)v)->w = r->postprocess.GetAvgLumLod ();
}, NULL, "label='Average Luminance'");
TwEnumVal rgbworkingspaceEV[] = {
{ 0, "Adobe RGB (1998)" },
{ 1, "AppleRGB" },
{ 2, "Best RGB" },
{ 3, "Beta RGB" },
{ 4, "Bruce RGB" },
{ 5, "CIE RGB" },
{ 6, "ColorMatch RGB" },
{ 7, "Don RGB 4" },
{ 8, "ECI RGB" },
{ 9, "Ekta Space PS5" },
{ 10, "NTSC RGB" },
{ 11, "PAL/SECAM RGB" },
{ 12, "ProPhoto RGB" },
{ 13, "SMPTE-C RGB" },
{ 14, "sRGB" },
{ 15, "Wide Gamut RGB" }
};
TwType rgbworkingspaceType;
rgbworkingspaceType = TwDefineEnum ("rgbworkingspace",
rgbworkingspaceEV, 16);
TwAddVarCB (bar, "RGB Working Space", rgbworkingspaceType,
[&] (const void *v, void*) {
r->postprocess.SetRGBWorkingSpace (*(const unsigned int*)v);
}, [&] (void *v, void*) {
*(unsigned int*)v
= r->postprocess.GetRGBWorkingSpace ();
}, NULL, NULL);
}
{
TwBar *bar = TwNewBar ("antialiasing");
TwDefine ("antialiasing label='Antialiasing' iconified=true");
TwEnumVal samplesEV[] = {
{ 0, "disabled" },
{ 4, "4x" },
{ 8, "8x" },
{ 12, "12x" },
{ 16, "16x" },
};
TwType samplesType;
samplesType = TwDefineEnum ("samples",
samplesEV, 5);
TwAddVarCB (bar, "Mode", samplesType,
[&] (const void *v, void*) {
r->SetAntialiasing (*(const unsigned int*)v);
}, [&] (void *v, void*) {
*(unsigned int*)v
= r->GetAntialiasing ();
}, NULL, NULL);
TwAddVarCB (bar, "Threshold", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->postprocess.SetAntialiasingThreshold
(0.01f * *(const float*)v);
}, [&] (void *v, void*) {
*(float*)v
= 100.0f * r->postprocess.GetAntialiasingThreshold ();
}, NULL, "step=0.1 min=0.0");
}
{
TwBar *bar = TwNewBar ("glow");
TwDefine ("glow label='Glow' iconified=true");
TwAddVarCB (bar, "blur size", TW_TYPE_UINT32,
[&] (const void *v, void*) {
r->composition.GetGlow ().SetSize (*(const unsigned int*)v);
}, [&] (void *v, void*) {
*(unsigned int*)v = r->composition.GetGlow ().GetSize ();
}, NULL, "min=0 max=256");
TwAddVarCB (bar, "luminance threshold", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->composition.SetLuminanceThreshold (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->composition.GetLuminanceThreshold ();
}, NULL, "step=0.01 min=0");
// TODO: NOT YET REIMPLEMENTED!
TwAddVarCB (bar, "limit", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->composition.GetGlow ().SetLimit (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->composition.GetGlow ().GetLimit ();
}, NULL, "step=0.01 min=0 visible=false");
TwAddVarCB (bar, "exponent", TW_TYPE_FLOAT,
[&] (const void *v, void*) {
r->composition.GetGlow ().SetExponent (*(const float*)v);
}, [&] (void *v, void*) {
*(float*)v = r->composition.GetGlow ().GetExponent ();
}, NULL, "step=0.01 min=0 visible=false");
}
{
TwBar *bar = TwNewBar ("parameter");
TwDefine ("parameter label='Material Parameters' iconified=true");
{
std::vector<TwEnumVal> paramNames;
for (auto i = 0; i < r->GetNumParameters (); i++)
{
paramNames.push_back (TwEnumVal ());
paramNames.back ().Value = i;
paramNames.back ().Label = r->GetParameterName (i).c_str ();
}
TwType paramnameType;
paramnameType = TwDefineEnum ("paramname", ¶mNames[0],
paramNames.size ());
TwAddVarRW (bar, "active", paramnameType,
&active_light, "label='active parameter set'");
}
TwAddSeparator (bar, NULL, NULL);
TwEnumVal specmodelEV[] = {
{ 0, "None" },
{ 1, "Gaussian" },
{ 2, "Phong" },
{ 3, "Beckmann" }
};
TwType specmodelType;
specmodelType = TwDefineEnum ("specmodel",
specmodelEV, 4);
typedef struct matspec {
unsigned int model;
float param1;
float param2;
float fresnel_n;
float fresnel_k;
} matspec_t;
TwStructMember matspecDesc[] = {
{ "Specular Model",
specmodelType, offsetof (matspec_t, model), NULL},
{ "Smoothness/Shininess",
TW_TYPE_FLOAT, offsetof (matspec_t, param1),
"step=0.01" },
{ "Gauss Factor/Ignored",
TW_TYPE_FLOAT, offsetof (matspec_t, param2),
"step=0.01" },
{ "Fresnel n",
TW_TYPE_FLOAT, offsetof (matspec_t, fresnel_n),
"step=0.01" },
{ "Fresnel k",
TW_TYPE_FLOAT, offsetof (matspec_t, fresnel_k),
"step=0.01" }
};
TwType matspecType = TwDefineStruct ("matspectype", matspecDesc, 5,
sizeof (matspec_t),
NULL, NULL);
TwAddVarCB (bar, "matspec", matspecType,
[&] (const void *v, void*) {
Parameter &p = r->GetParameters (active_parameter);
const matspec_t *m = (const matspec_t*) v;
p.specular.model = m->model;
p.specular.param1 = m->param1;
p.specular.param2 = m->param2;
p.specular.fresnel.n = m->fresnel_n;
p.specular.fresnel.k = m->fresnel_k;
r->UpdateParameters (active_parameter);
}, [&] (void *v, void*) {
Parameter &p = r->GetParameters (active_parameter);
matspec_t *m = (matspec_t*) v;
m->model = p.specular.model;
m->param1 = p.specular.param1;
m->param2 = p.specular.param2;
m->fresnel_n = p.specular.fresnel.n;
m->fresnel_k = p.specular.fresnel.k;
}, NULL, "label='Specular Parameters'");
typedef struct matrefl {
float factor;
float fresnel_n;
float fresnel_k;
} matrefl_t;
TwStructMember matreflDesc[] = {
{ "Factor",
TW_TYPE_FLOAT, offsetof (matrefl_t, factor),
"step=0.01 min=0.0 max=1.0" },
{ "Fresnel n",
TW_TYPE_FLOAT, offsetof (matrefl_t, fresnel_n),
"step=0.01" },
{ "Fresnel k",
TW_TYPE_FLOAT, offsetof (matrefl_t, fresnel_k),
"step=0.01" }
};
TwType matreflType = TwDefineStruct ("matrefltype", matreflDesc, 3,
sizeof (matrefl_t),
NULL, NULL);
TwAddVarCB (bar, "matrefl", matreflType,
[&] (const void *v, void*) {
Parameter &p = r->GetParameters (active_parameter);
const matrefl_t *m = (const matrefl_t*) v;
p.reflection.factor = m->factor;
p.reflection.fresnel.n = m->fresnel_n;
p.reflection.fresnel.k = m->fresnel_k;
r->UpdateParameters (active_parameter);
}, [&] (void *v, void*) {
Parameter &p = r->GetParameters (active_parameter);
matrefl_t *m = (matrefl_t*) v;
m->factor = p.reflection.factor;
m->fresnel_n = p.reflection.fresnel.n;
m->fresnel_k = p.reflection.fresnel.k;
}, NULL, "label='Reflection'");
}
}
