void RPG_HighlightableComponentManager::OnHandleCallback(IVisCallbackDataObject_cl *data)
{
if(data->m_pSender == &Vision::Callbacks.OnWorldInit)
{
InitShaders();
}
else if(data->m_pSender == &Vision::Callbacks.OnWorldDeInit)
{
m_xrayTechnique = NULL;
m_highlightTechnique = NULL;
}
else if(data->m_pSender == &Vision::Callbacks.OnReassignShaders)
{
InitShaders();
}
else if(data->m_pSender == &Vision::Callbacks.OnRenderHook)
{
VisRenderHookDataObject_cl const *const renderHookData = static_cast<VisRenderHookDataObject_cl *>(data);
switch(renderHookData->m_iEntryConst)
{
// XRay renders before opaque entities
case VRH_PRE_PRIMARY_OPAQUE_PASS_ENTITIES:
{
if(m_xrayTechnique)
{
RenderHighlightableEntities(m_xrayTechnique, m_xrayPassColorRegisters, GetHighlightables());
}
}
break;
// Highlight renders after opaque entities
case VRH_PRE_OCCLUSION_TESTS:
{
if(m_highlightTechnique)
{
RenderHighlightableEntities(m_highlightTechnique, m_highlightPassColorRegisters, GetHighlightables());
}
}
break;
default:
break;
}
}
else if (data->m_pSender == &Vision::Callbacks.OnUpdateSceneFinished)
{
UpdateHighlightableEntities(GetHighlightables());
}
}
void dx103DFluidRenderer::Initialize(int gridWidth, int gridHeight, int gridDepth)
{
Destroy();
m_vGridDim[0] = float(gridWidth);
m_vGridDim[1] = float(gridHeight);
m_vGridDim[2] = float(gridDepth);
m_fMaxDim = _max( _max( m_vGridDim[0], m_vGridDim[1] ), m_vGridDim[2] );
// Initialize the grid offset matrix
{
// Make a scale matrix to scale the unit-sided box to be unit-length on the
// side/s with maximum dimension
D3DXMATRIX scaleM;
D3DXMatrixIdentity(&scaleM);
D3DXMatrixScaling(&scaleM, m_vGridDim[0] / m_fMaxDim, m_vGridDim[1] / m_fMaxDim, m_vGridDim[2] / m_fMaxDim);
// offset grid to be centered at origin
D3DXMATRIX translationM;
D3DXMatrixTranslation(&translationM, -0.5, -0.5, -0.5);
m_gridMatrix = translationM * scaleM;
//m_gridMatrix.scale(m_vGridDim[0] / m_fMaxDim, m_vGridDim[1] / m_fMaxDim, m_vGridDim[2] / m_fMaxDim);
//m_gridMatrix.translate_over(-0.5, -0.5, -0.5);
}
InitShaders();
CreateGridBox();
CreateScreenQuad();
CreateJitterTexture();
CreateHHGGTexture();
m_bInited = true;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample50::Initialize(CFrmFontGLES &m_Font, CFrmTexture* m_pLogoTexture)
{
// We need the Font for later
m_pFont = &m_Font;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Demos/AdrenoShaders/Textures/50_Textures.pak" ) )
return FALSE;
m_ColorTexture = resource.GetTexture( "ColorPic" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5, m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( (char *)"Press \200 for Help", 1.0f, -1.0f );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, (char *)"Previous color space" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, (char *)"Next color space" );
// Initialize the shaders
if( FALSE == InitShaders() )
{
return FALSE;
}
return TRUE;
}
bool Renderer::Init(int width, int height)
{
// Create our SDL window
mWindow = SDL_CreateWindow("ITP Engine 2 Demo!", 100, 100, width, height,
0);
if (!mWindow)
{
SDL_Log("Could not create window.");
return false;
}
mGraphicsDriver = std::make_shared<GraphicsDriver>(GetActiveWindow());
mInputLayoutCache = std::make_shared<InputLayoutCache>();
mWidth = width;
mHeight = height;
if (!InitFrameBuffer())
{
return false;
}
if (!InitShaders())
{
return false;
}
if (!InitSpriteVerts())
{
return false;
}
return true;
}
void RPG_GuiMinimap_VisionGUI::OnHandleCallback(IVisCallbackDataObject_cl *pData)
{
if (pData->m_pSender == &Vision::Callbacks.OnReassignShaders)
{
InitShaders();
}
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
m_bShouldRotate = TRUE;
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/NPR30.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Create the cel shading texture
m_pCelShadingTexture = resource.GetTexture( "Cel-Shading" );
// Create the ray gun texture
m_pRayGunTexture = resource.GetTexture( "RayGun" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f );
m_UserInterface.AddFloatVariable( &m_fOutlineWidth , "Outline Width", "%3.2f" );
m_UserInterface.AddFloatVariable( &m_vLightPosition.x, "Light Pos", "%4.2f" );
m_UserInterface.AddFloatVariable( &m_fAmbient, "Ambient Light", "%4.2f" );
m_UserInterface.AddBoolVariable( &m_bShouldRotate, "Should Rotate" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, "Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Info Pane" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Decrease Outline Width" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Increase Outline Width" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Decrease Ambient Light" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Increase Ambient Light" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, "Toggle Rotation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_DPAD, "Move Light" );
// Load the mesh
if( FALSE == m_Mesh.Load( "Samples/Meshes/RayGun.mesh" ) )
return FALSE;
if( FALSE == m_Mesh.MakeDrawable() )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
glClearColor( 0.5f, 0.5f, 0.5f, 0.0f );
glEnable( GL_DEPTH_TEST );
Resize();
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample31::Initialize(CFrmFontGLES &m_Font, CFrmTexture* m_pLogoTexture)
{
m_ShouldRotate = TRUE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Demos/AdrenoShaders/Textures/31_Textures.pak" ) )
return FALSE;
// Create textures
m_GodRayTexture = resource.GetTexture( "GodRay1" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5, m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( (char *)"Press \200 for Help", 1.0f, -1.0f );
m_UserInterface.AddBoolVariable( &m_ShouldRotate, (char *)"Should Rotate" );
m_UserInterface.AddFloatVariable( &m_RayExtruderShader.RayLength, (char *)"Ray length" );
m_UserInterface.AddFloatVariable( &m_CutoutShader.OccluderThreshold, (char *)"Occluder pickup distance" );
m_UserInterface.AddFloatVariable( &m_CutoutShader.OccluderFadeout, (char *)"Occluder fade distance" );
m_UserInterface.AddFloatVariable( &m_CombineShader.RayOpacity, (char *)"Ray opacity" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, (char *)"Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, (char *)"Decrease ray length" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, (char *)"Increase ray length" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, (char *)"Decrease pickup dist" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, (char *)"Increase pickup dist" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, (char *)"Decrease pickup fade" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_6, (char *)"Increase pickup fade" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_7, (char *)"Decrease opacity" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_8, (char *)"Increase opacity" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_9, (char *)"Toggle Rotation" );
// Load the mesh
if( FALSE == m_Mesh.Load( "Demos/AdrenoShaders/Meshes/Map3.mesh" ) )
return FALSE;
m_CameraPos = FRMVECTOR3( 6.2f, 2.0f, 0.0f );
float Split = 1.1f;
float yAdjust = -0.05f;
ModelScale31 = 1.0f;
if( FALSE == m_Mesh.MakeDrawable( &resource ) )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
{
return FALSE;
}
m_AmbientLight = FRMVECTOR4( 0.05f, 0.05f, 0.05f, 0.0f );
// Set up the objects
m_Object.Drawable = &m_Mesh;
m_Object.Position.y += yAdjust;
return TRUE;
}
void RPG_GuiMinimap_VisionGUI::OnActivate()
{
VImageControl::OnActivate();
InitShaders();
// Reload shaders for reloading in vForge
Vision::Callbacks.OnReassignShaders += this;
}
void CS_Renderer::Initialize()
{
CreateBuffers();
if (!shader && !computeshader && !texture)
{
InitShaders();
LoadTexture();
}
}
void InitGL(RenderContext *rcx)
{
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK)
{
std::cout << "Unable to initilize GLEW..." << std::endl;
Cleanup(rcx);
exit(0);
}
InitShaders();
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc: Initialize the scene.
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/MultiSample.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f );
m_UserInterface.AddBoolVariable( &m_bRotationOn, "Rotation", "On", "Off" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, "Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Info Pane" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Start Rotating" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Stop Rotating" );
InitProjectionMatrix();
/* Set up line width */
glLineWidth(1.0f);
/* Set up a Framebuffer Object */
glGenFramebuffers(1,&m_fboId);
glBindFramebuffer(GL_FRAMEBUFFER, m_fboId);
InitVertexBufferObject();
/* Note that our FBO does not use a depth attachment. Safe to disable the depth writes */
glDepthMask(GL_FALSE);
InitVertexArrayObject();
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
InitTexture();
/* Set up clear color */
glClearColor(0.0f, 0.75f, 1.0f, 1.0f);
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
m_bShouldRotate = TRUE;
m_fCheckerFrequency = 30.0f;
m_fWoodFrequency = 10.0f;
m_MarbleTurbScale = 50.0f;
m_nPTIndex = PT_CHECKER;
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/ProceduralTexture.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Create the 3D noise texture
CreateNoiseTexture3D( 128 );
// Create the 3D turbulence texture
CreateTurbTexture3D( 64 );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f );
m_UserInterface.AddFloatVariable( &m_fCheckerFrequency, "Checker Freq", "%4.2f" );
m_UserInterface.AddFloatVariable( &m_fWoodFrequency, "Wood Freq", "%4.2f" );
m_UserInterface.AddFloatVariable( &m_MarbleTurbScale, "Marble Scale", "%4.2f" );
m_UserInterface.AddBoolVariable( &m_bShouldRotate, "Should Rotate" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, "Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Info Pane" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Decr Frequency" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Incr Frequency" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Next Procedural Texture" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Toggle Rotation" );
// Create the mesh
if( FALSE == m_Mesh.Load( "Samples/Meshes/Bunny.mesh" ) )
return FALSE;
if( FALSE == m_Mesh.MakeDrawable() )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
return TRUE;
}
void LandscapeDebugNode::SetDebugHeightmapImage(Heightmap * _debugHeightmapImage, const AABBox3 & _box)
{
box = _box;
SafeRelease(heightmap);
heightmap = SafeRetain(_debugHeightmapImage);
debugVertices.resize(heightmap->Size() * heightmap->Size());
debugIndices.resize(heightmap->Size() * heightmap->Size() * 6);
ReleaseShaders();
InitShaders();
}
/**
* Creates the OpenGL ES 2.X context and builds the shaders.
* @param raspitex_state A pointer to the GL preview state.
* @return Zero if successful.
*/
static int motion_init(RASPITEX_STATE *state)
{
int rc = raspitexutil_gl_init_2_0(state);
if (rc != 0)
goto end;
rc = raspitexutil_build_shader_program(&motion_shader);
//Call initialisation functions in c++ part (Graphics.cpp)
InitTextures(state->width, state->height);
InitShaders();
end:
return rc;
}
void ModelCanvas::InitGL()
{
video.InitGL();
GLenum err = 0;
init = true;
// load up our shaders
InitShaders();
// init the default view
InitView();
}
void glut_viewer_hdr_init() {
glut_viewer_get_screen_size(&WINDOW_WIDTH, &WINDOW_HEIGHT) ;
if(!InitShaders()) {
std::cerr << "could not init shaders" << std::endl ;
exit(-1) ;
}
if(!InitFBO()) {
std::cerr << "could not init FBO" << std::endl ;
exit(-1) ;
}
glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE) ;
glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE) ;
InitBlur() ;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample34::Initialize(CFrmFontGLES &Font, CFrmTexture* m_pLogoTexture)
{
m_ShouldRotate = TRUE;
m_Preview = false;
// Create the font
// Load the packed resources
// NOTE SAME TEXTURES AS 27
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Demos/AdrenoShaders/Textures/27_Textures.pak" ) )
return FALSE;
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( (char *)"Press \200 for Help", 1.0f, -1.0f );
m_UserInterface.AddBoolVariable( &m_ShouldRotate, (char *)"Should Rotate" );
m_UserInterface.AddFloatVariable( &m_CombineShader.GaussSpread, (char *)"Gauss filter spread" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, (char *)"Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_6, (char *)"Decrease gauss spread" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_7, (char *)"Increase gauss spread" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_8, (char *)"Toggle Rotation" );
// Load the mesh
if( FALSE == m_Mesh.Load( "Demos/AdrenoShaders/Meshes/Map3.mesh" ) )
return FALSE;
m_CameraPos = FRMVECTOR3( 6.2f, 2.0f, 0.0f );
float Split = 1.1f;
float yAdjust = -0.05f;
if( FALSE == m_Mesh.MakeDrawable( &resource ) )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
{
return FALSE;
}
m_AmbientLight = FRMVECTOR4( 0.1f, 0.1f, 0.1f, 0.0f );
// Set up the objects
m_Object.Drawable = &m_Mesh;
m_Object.Position.y += yAdjust;
return TRUE;
}
void GLWidget::initializeGL()
{
initializeOpenGLFunctions();
glEnable (GL_DEPTH_TEST);
glEnable (GL_CULL_FACE);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
#define PROGRAM_VERTEX_ATTRIBUTE 0
#define PROGRAM_TEXCOORD_ATTRIBUTE 1
#define ProgramColor 2
InitShaders();
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/SWE.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
m_pBaseTexture = resource.GetTexture( "Marble" );
m_pEnvTexture = resource.GetTexture( "Env" );
m_pNormalTexture = resource.GetTexture( "Normal" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Info Pane" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Reset Simulation" );
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
glClearColor( 0.5f, 0.5f, 0.5f, 1.0f );
// initialize simulation
m_pLiquid = new Liquid();
#ifdef UNDER_CE
m_pLiquid->Init(15, 20);
m_pLiquid->ResetValues();
m_pLiquid->Finger(0.7,0.3);
#else
m_pLiquid->Init(24, 32);
m_pLiquid->ResetValues();
m_UserInterface.AddTextString( "Click mouse to start", 1.f, -1.f);
#endif // UNDER_CE
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/MotionBlur.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f );
m_UserInterface.AddBoolVariable( &m_bMotionBlurOn, "Motion Blur", "On", "Off" );
m_UserInterface.AddFloatVariable( &m_fSpeed, "Speed", "%4.2f" );
m_UserInterface.AddFloatVariable( &m_fShutterDuration, "Shutter Duration", "%4.4f sec" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, "Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Info Pane" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Decrease Speed" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Increase Speed" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Decrease Shutter Duration" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Increase Shutter Duration" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, "Toggle Motion Blur (on/off)" );
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
// Setup the view
FRMVECTOR3 vPosition = FRMVECTOR3( 0.0f, 0.0f, 4.0f );
FRMVECTOR3 vLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
FRMVECTOR3 vUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matView = FrmMatrixLookAtRH( vPosition, vLookAt, vUp );
glClearColor( 0.5f, 0.5f, 0.5f, 1.0f );
return TRUE;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample14b::Initialize(CFrmFontGLES &m_Font, CFrmTexture* m_pLogoTexture)
{
m_bShouldRotate = TRUE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Demos/AdrenoShaders/Textures/14b_Textures.pak" ) )
return FALSE;
// load the color ramp for the toon shader
m_ToonShader.ColorRampTexture = resource.GetTexture( "ToonColorRamp" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( (char *)"Press \200 for Help", 1.0f, -1.0f );
m_UserInterface.AddBoolVariable( &m_bShouldRotate, (char *)"Should Rotate" );
m_UserInterface.AddFloatVariable( &m_EdgeBias , (char *)"Edge detection", (char *)"%3.4f" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, (char *)"Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, (char *)"Toggle Info Pane" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, (char *)"Decrease edge detection" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, (char *)"Increase edge detection" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, (char *)"Toggle Rotation" );
// Load the mesh
if( FALSE == m_Mesh.Load( "Demos/AdrenoShaders/Meshes/Teapot.mesh" ) )
return FALSE;
if( FALSE == m_Mesh.MakeDrawable() )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
{
return FALSE;
}
glEnable( GL_DEPTH_TEST );
return TRUE;
}
// Initialize SDL and Opengl and others
void MainGame::InitSystems()
{
// Initialize SDL
SDL_Init(SDL_INIT_EVERYTHING);
// Using double buffer to prevent flickering
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
//Open an SDL window
_window = SDL_CreateWindow("Lemon Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, _screenWidth, _screenHeight, SDL_WINDOW_OPENGL);
if (_window == nullptr)
{
FatalError("SDL window could not be created");
}
// Set up OpenGL context
SDL_GLContext glContext = SDL_GL_CreateContext(_window);
if (glContext == nullptr)
{
FatalError("SDL_GL_Context could not be created");
}
// Set up glew (optional but recommended)
//glewExperimental = true; // For any crashes
GLenum error = glewInit();
if (error != GLEW_OK)
{
FatalError("Could not initalize glew");
}
// Check the OpenGL version
std::printf("*** OpenGL Version: %s ***\n", glGetString(GL_VERSION));
//Set the background color to blue
glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
// set Vsync to monitor rate
SDL_GL_SetSwapInterval(0);
InitShaders();
}
/**
* Initialize the render manager
*
* @param inBufferSizeX Width of the full screen render buffer
* @param inBufferSizeY Height of the full screen render buffer
*/
bool RenderManager::Init(const int inBufferSizeX, const int inBufferSizeY)
{
// Set the size of the render buffers
fullScreenBufferSizeX = inBufferSizeX;
fullScreenBufferSizeY = inBufferSizeY;
gRenderAPI->Init(fullScreenBufferSizeX, fullScreenBufferSizeY, defaultSceneColorBuffer, defaultSceneDepthBuffer);
InitRenderTargets();
InitShaders();
InitFonts();
// Create full-screen buffers
VertexContainer_P3U2 VertexData[] =
{
-1,1,0, 0,0,
1,1,0, 1,0,
-1,-1,0, 0,1,
1,-1,0, 1,1
};
short IndexData[] =
{
0, 1, 2,
1, 3, 2
};
// Init full screen buffers
fullScreenVB = gRenderAPI->CreateVertexBuffer(VFMT_P3U2, 4, &VertexData);
fullScreenIB = gRenderAPI->CreateIndexBuffer(IFMT_16Bit, 6, &IndexData);
// Init simple primitives
unitSphereMesh = gMeshManager.LoadStaticMesh("UnitSphere.nff");
unitConeMesh = gMeshManager.LoadStaticMesh("UnitCone.nff");
// Init textures
defaultTexture = gRenderAPI->CreateTexture2DFromFile("checkerboard.png");
return true;
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/CubeMapReflection.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Create the textures
m_pSatelliteTexture = resource.GetTexture( "TennisBall" );
m_pPlaqueTexture = resource.GetTexture( "Trophy_Plaque" );
m_pEnvironmentMap = resource.GetCubeMap( "BedroomCubeMap" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_STAR, "Toggle Orientation" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Info Pane" );
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
// Load a mesh for the center of the screen
if( FALSE == m_MainObject.Load( "Samples/Meshes/trophy.mesh" ) )
return FALSE;
if( FALSE == m_MainObject.MakeDrawable( &resource ) )
return FALSE;
// Load a mesh to use for the satellite objects
if( FALSE == m_SatelliteObject.Load( "Samples/Meshes/tennisBall.mesh" ) )
return FALSE;
if( FALSE == m_SatelliteObject.MakeDrawable( &resource ) )
return FALSE;
// Create the reflection cube map
FrmCreateCubeMap( ENVMAP_SIZE, GL_UNSIGNED_SHORT_5_5_5_1, &m_hReflectionMap );
// Create an FBO for offscreen rendering
glGenFramebuffers( 1, &m_hFBOFramebufferID );
// Create a depth-buffer for offscreen rendering
FrmCreateRenderBuffer( ENVMAP_SIZE, ENVMAP_SIZE, GL_DEPTH_COMPONENT16,
&m_hFBODepthbufferID );
FRMVECTOR3 vPosition = FRMVECTOR3( -0.2f, 0.25f, 1.0f );
FRMVECTOR3 vLookAt = FRMVECTOR3( 0.0f, -0.1f, 0.0f );
FRMVECTOR3 vUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matView = FrmMatrixLookAtRH( vPosition, vLookAt, vUp );
return TRUE;
}
pipeline::pipeline(HWND hWndin):hWnd(hWndin)
{
InitDevSwap();
InitShaders();
InitConstBuff();
}
void InitPipeline(){
InitShaders();
//initializing other things later
}
int Initialize (int argc, char *argv[])
{
/*---*/PrintLog ("Initializing data\n");
signal (SIGABRT, D2SignalHandler);
signal (SIGFPE, D2SignalHandler);
signal (SIGILL, D2SignalHandler);
signal (SIGINT, D2SignalHandler);
signal (SIGSEGV, D2SignalHandler);
signal (SIGTERM, D2SignalHandler);
#ifdef _WIN32
SDL_SetSpecialKeyHandling (0);
#endif
hogFileManager.Init ("", "");
InitGameStates ();
gameData.Init ();
InitExtraGameInfo ();
InitNetworkData ();
InitGameOptions (0);
InitArgs (argc, argv);
GetAppFolders ();
if (FindArg ("-debug-printlog") || FindArg ("-printlog")) {
char fnErr [FILENAME_LEN];
#ifdef __unix__
sprintf (fnErr, "%s/d2x.log", getenv ("HOME"));
fErr = fopen (fnErr, "wt");
#else
sprintf (fnErr, "%s/d2x.log", gameFolders.szGameDir);
fErr = fopen (fnErr, "wt");
#endif
}
PrintLog ("%s\n", DESCENT_VERSION);
InitArgs (argc, argv);
GetAppFolders ();
#ifdef D2X_MEM_HANDLER
MemInit ();
#endif
error_init (NULL, NULL);
*szAutoHogFile =
*szAutoMission = '\0';
EvalArgs ();
InitGameOptions (1);
DefaultAllSettings ();
gameOpts->render.nMathFormat = gameOpts->render.nDefMathFormat;
/*---*/PrintLog ("Loading text resources\n");
/*---*/PrintLog ("Loading main hog file\n");
if (!(hogFileManager.Init ("descent2.hog", gameFolders.szDataDir) ||
(gameStates.app.bDemoData = hogFileManager.Init ("d2demo.hog", gameFolders.szDataDir)))) {
/*---*/PrintLog ("Descent 2 data not found\n");
Error (TXT_NO_HOG2);
}
LoadGameTexts ();
/*---*/PrintLog ("Reading configuration file\n");
ReadConfigFile ();
if (!InitGraphics ())
return 1;
console.Setup (SMALL_FONT, &screen, CON_NUM_LINES, 0, 0, screen.Width (), screen.Height () / 2);
if (gameStates.app.bProgressBars && gameOpts->menus.nStyle)
InitializeGauge ();
else {
CMenu m (1);
int key = 0;
m.AddGauge ("", -1, 1000); // dummy for InitializePoll()
messageBox.Show (TXT_INITIALIZING);
for (loadOp = 0; loadOp < InitGaugeSize (); )
InitializePoll (m, key, 0, 0);
}
messageBox.Clear ();
PrintBanner ();
if (!gameStates.app.bAutoRunMission) {
/*---*/PrintLog ("Showing title screens\n");
if (!ShowTitleScreens ())
ShowLoadingScreen ();
}
if (FindArg ("-norun"))
return 0;
/*---*/PrintLog ("Loading hires models\n");
LoadHiresModels (0);
LoadModelData ();
InitShaders (); //required for some menus to show all possible choices
return 0;
}
void
OpenGL::SetupContext()
{
#if defined(HAVE_DYNAMIC_EGL)
egl = EGLInit();
#endif
texture_non_power_of_two = SupportsNonPowerOfTwoTextures();
#ifdef HAVE_OES_DRAW_TEXTURE
oes_draw_texture = CheckOESDrawTexture();
#endif
#ifdef ANDROID
native_view->SetTexturePowerOfTwo(texture_non_power_of_two);
vertex_buffer_object = EnableVBO();
#endif
#ifdef HAVE_OES_MAPBUFFER
mapbuffer = IsExtensionSupported("GL_OES_mapbuffer");
#endif
#ifdef HAVE_DYNAMIC_MAPBUFFER
if (mapbuffer) {
GLExt::map_buffer = (PFNGLMAPBUFFEROESPROC)
eglGetProcAddress("glMapBufferOES");
GLExt::unmap_buffer = (PFNGLUNMAPBUFFEROESPROC)
eglGetProcAddress("glUnmapBufferOES");
if (GLExt::map_buffer == nullptr || GLExt::unmap_buffer == nullptr)
mapbuffer = false;
}
#endif
#ifdef HAVE_DYNAMIC_MULTI_DRAW_ARRAYS
if (IsExtensionSupported("GL_EXT_multi_draw_arrays")) {
GLExt::multi_draw_arrays = (PFNGLMULTIDRAWARRAYSEXTPROC)
dlsym(RTLD_DEFAULT, "glMultiDrawArraysEXT");
GLExt::multi_draw_elements = (PFNGLMULTIDRAWELEMENTSEXTPROC)
dlsym(RTLD_DEFAULT, "glMultiDrawElementsEXT");
} else {
GLExt::multi_draw_arrays = nullptr;
GLExt::multi_draw_elements = nullptr;
}
#endif
frame_buffer_object = CheckFBO() && FBO::Initialise();
if (frame_buffer_object) {
render_buffer_depth_stencil = CheckDepthStencil();
render_buffer_stencil = CheckStencil();
if (!render_buffer_stencil)
/* fall back to a packed depth+stencil format */
render_buffer_stencil = render_buffer_depth_stencil;
}
GLfloat lineWidthRange[2] = {0.0f, 0.0f};
glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, lineWidthRange);
max_line_width = lineWidthRange[1];
glDisable(GL_DEPTH_TEST);
glDisable(GL_DITHER);
#ifndef HAVE_GLES2
glDisable(GL_LIGHTING);
#endif
#ifndef USE_GLSL
glEnableClientState(GL_VERTEX_ARRAY);
#endif
InitShapes();
#ifdef USE_GLSL
InitShaders();
#endif
#ifndef HAVE_GLES
::glGetIntegerv(GL_MAX_ATTRIB_STACK_DEPTH, &max_attrib_stack_depth);
#endif
}
//--------------------------------------------------------------------------------------
// Name: Initialize()
// Desc:
//--------------------------------------------------------------------------------------
BOOL CSample::Initialize()
{
// Initialize sample variables
m_nCurMeshIndex = CUBE_MESH;
m_bShowShadowMap = TRUE;
m_vLightPosition = FRMVECTOR3( 0.0f, 8.0f, 0.01f );
// Create the font
if( FALSE == m_Font.Create( "Samples/Fonts/Tuffy12.pak" ) )
return FALSE;
// Load the packed resources
CFrmPackedResourceGLES resource;
if( FALSE == resource.LoadFromFile( "Samples/Textures/ShadowMap30.pak" ) )
return FALSE;
// Create the logo texture
m_pLogoTexture = resource.GetTexture( "Logo" );
// Setup the user interface
if( FALSE == m_UserInterface.Initialize( &m_Font, m_strName ) )
return FALSE;
m_UserInterface.AddOverlay( m_pLogoTexture->m_hTextureHandle, -5, -5,
m_pLogoTexture->m_nWidth, m_pLogoTexture->m_nHeight );
m_UserInterface.AddTextString( "Press " FRM_FONT_KEY_0 " for Help", 1.0f, -1.0f, 1.0f );
m_UserInterface.AddIntVariable( &m_nShadowMapFBOTextureWidth , "Shadow Map Size", "%d" );
m_UserInterface.AddBoolVariable( &m_bUsePCF , "PCF On", "True", "False" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_0, "Toggle Help" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_1, "Next Model" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_2, "Next Floor" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_3, "Decrease Shadow Map Size" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_4, "Increase Shadow Map Size" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_5, "Toggle PCF" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_6, "Toggle Shadow Map Display" );
m_UserInterface.AddHelpKey( FRM_FONT_KEY_DPAD, "Rotate light" );
// Load the meshes
if( FALSE == m_Floor[ PLANE_FLOOR ].Load( "Samples/Meshes/Plane.mesh" ) )
return FALSE;
if( FALSE == m_Floor[ PLANE_FLOOR ].MakeDrawable() )
return FALSE;
if( FALSE == m_Floor[ TERRAIN_FLOOR ].Load( "Samples/Meshes/Terrain.mesh" ) )
return FALSE;
if( FALSE == m_Floor[ TERRAIN_FLOOR ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ CUBE_MESH ].Load( "Samples/Meshes/Cube.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ CUBE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ SPHERE_MESH ].Load( "Samples/Meshes/Sphere.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ SPHERE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ BUMPY_SPHERE_MESH ].Load( "Samples/Meshes/BumpySphere.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ BUMPY_SPHERE_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ TORUS_MESH ].Load( "Samples/Meshes/Torus.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ TORUS_MESH ].MakeDrawable() )
return FALSE;
if( FALSE == m_Meshes[ ROCKET_MESH ].Load( "Samples/Meshes/Rocket.mesh" ) )
return FALSE;
if( FALSE == m_Meshes[ ROCKET_MESH ].MakeDrawable() )
return FALSE;
// Initialize the shaders
if( FALSE == InitShaders() )
return FALSE;
// Initialize the camera and light perspective matrices
FLOAT32 fAspect = (FLOAT32)m_nWidth / (FLOAT32)m_nHeight;
m_matCameraPersp = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, fAspect, 1.0f, 100.0f );
m_matLightPersp = FrmMatrixPerspectiveFovRH( FRM_PI/4.0f, 1.0f, 5.0f, 20.0f );
// Initialize the viewport
glViewport( 0, 0, m_nWidth, m_nHeight );
// Setup the FBOs
m_nShadowMapFBOTextureExp = 7;
m_nShadowMapFBOTextureWidth = 2 << m_nShadowMapFBOTextureExp;
m_nShadowMapFBOTextureHeight = 2 << m_nShadowMapFBOTextureExp;
CreateShadowMapFBO();
CreateLightingFBO();
// Setup the camera view matrix
FRMVECTOR3 vCameraPosition = FRMVECTOR3( 0.0f, 5.0f, 10.0f );
FRMVECTOR3 vCameraLookAt = FRMVECTOR3( 0.0f, 0.0f, -2.0f );
FRMVECTOR3 vCameraUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
m_matCameraView = FrmMatrixLookAtRH( vCameraPosition, vCameraLookAt, vCameraUp );
// Setup the floor's camera relative model view projection matrix
FRMMATRIX4X4 matFloorScale = FrmMatrixScale( 5.0f, 5.0f, 5.0f );
FRMMATRIX4X4 matFloorTranslate = FrmMatrixTranslate( 0.0f, -0.5f, 0.0f );
m_matFloorModel = FrmMatrixMultiply( matFloorScale, matFloorTranslate );
m_matCameraFloorModelView = FrmMatrixMultiply( m_matFloorModel, m_matCameraView );
m_matCameraFloorModelViewProj = FrmMatrixMultiply( m_matCameraFloorModelView, m_matCameraPersp );
m_matCameraFloorNormal = FrmMatrixNormal( m_matCameraFloorModelView );
// Setup the light look at and up vectors
m_vLightLookAt = FRMVECTOR3( 0.0f, 0.0f, 0.0f );
m_vLightUp = FRMVECTOR3( 0.0f, 1.0f, 0.0f );
// Create our scale and bias matrix that is used to convert the coordinates of vertices that are multiplied by a
// model view projection matrix from the range [-1, 1] to the range [0, 1], so that they can be used for texture lookups
m_matScaleAndBias.M( 0, 0 ) = 0.5f; m_matScaleAndBias.M( 0, 1 ) = 0.0f; m_matScaleAndBias.M( 0, 2 ) = 0.0f; m_matScaleAndBias.M( 0, 3 ) = 0.0f;
m_matScaleAndBias.M( 1, 0 ) = 0.0f; m_matScaleAndBias.M( 1, 1 ) = 0.5f; m_matScaleAndBias.M( 1, 2 ) = 0.0f; m_matScaleAndBias.M( 1, 3 ) = 0.0f;
m_matScaleAndBias.M( 2, 0 ) = 0.0f; m_matScaleAndBias.M( 2, 1 ) = 0.0f; m_matScaleAndBias.M( 2, 2 ) = 0.5f; m_matScaleAndBias.M( 2, 3 ) = 0.0f;
m_matScaleAndBias.M( 3, 0 ) = 0.5f; m_matScaleAndBias.M( 3, 1 ) = 0.5f; m_matScaleAndBias.M( 3, 2 ) = 0.5f; m_matScaleAndBias.M( 3, 3 ) = 1.0f;
// Setup GL state
glClearColor( 0.5f, 0.5f, 0.5f, 1.0f );
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
// Initialization complete
m_Initialize = TRUE;
return TRUE;
}
int main(int argc, char *argv[])
{
string inputSkeleton;
string inputMotion;
SMRMotion motion;
ParamHandler argh;
argh.AddLong("motion", 'm').SetString().SetDesc("input motion file" , "<file>");
argh.AddLong("skeleton", 's').SetString().SetDesc("input skeleton file" , "<file>");
argh.AddLong("help", 'h').SetBool().SetDesc("Displays quick manual.");
argh.StartParse(argc, argv);
for(;;)
{
int c = argh.GetParam();
if(c == -1)break;
switch(c)
{
case 's': inputSkeleton = argh.GetString(); break;//worst = argh.GetBool(); break;
case 'm': inputMotion = argh.GetString(); break;
default :
printf(
"*** SMR simple viewer demo ***\n"
"\n Usage: motionPlayer [<option> [<...>]] \n"
"\n This demo lets you play bvh or asf/amc animations\n");
argh.ListOptions();
printf("\nNo warranty whatsoever.\n");
return 0;
}
}
if (inputMotion.find(".amc",0) != string::npos )
{
if (inputSkeleton.find(".asf") == string::npos )
{
cout << "You shall specify an asf skeleton file with an amc file" << endl;
return 0;
}else
{
motion = loadMotionFromAcclaim( getFileName(inputSkeleton), getFileName(inputMotion) );
myMotionPlayer = new SMRMotionPlayer( &motion );
}
}else if (inputMotion.find(".bvh",0) != string::npos )
{
motion = loadMotionFromBVH( getFileName(inputMotion) );
myMotionPlayer = new SMRMotionPlayer( &motion );
}else if (inputSkeleton.find(".vsk",0) != string::npos )
{
motion = loadMotionFromVSK( inputSkeleton, inputMotion);
myMotionPlayer = new SMRMotionPlayer( &motion );
//SMRSkeleton mySkeleton = loadSkeletonFromVSK(inputSkeleton);
//SMRQuaternion identity;
//identity.identity();
//for(int i = 0; i< mySkeleton.getNumJoints(); i++)
//{
// mySkeleton.getJoint(i)->setOrientation(identity);
//}
//save the file as bvh
//exportMotionToBVH("shrug.bvh",motion, mySkeleton);
//
//exportPoseToBVH("blah.bvh", mySkeleton);
//mySkeleton.setMode(RELATIVEMODE);
}
else
{
cout << "unknown file format" << endl;
return 0;
}
// get GLUT to work
InitializeGlut(&argc, argv);
// Init the Smr Library
Smr::initSmr();
// Init the shaders capability
InitShaders();
// Get my scene prepared
InitScene();
// Enter the endless loop
glutMainLoop();
// Exit properly
ShutDown();
//delete(motion);
return 0;
}
