void MySample::UpdateMatrixBuffers()
{
// Update GUI
int rows = currentRowCount;
int columns = currentColCount;
int index = 0;
float angle_value = 360.0 / columns;
float radius = (columns / k2Pi);
for (int i = 0; i < rows; ++i)
{
int add_value = 0;
for (int j = 0; j < columns; ++j)
{
if( (i % 2) == 0 )
{
add_value = angle_value + (angle_value / 2.0);
}
world[index] = float4x4RotationY( kPi / 2.0f) *
float4x4Translation(float3(0.0f, 0.0f + (100.0f * i), 100.0f * radius)) *
float4x4RotationY( DegreesToRadians(add_value + (angle_value * j)));
++index;
}
}
// Now update buffer
const int numInstances = columns * rows;
// Support shader
CPUTMaterialEffectOGL *pMatEffect = (CPUTMaterialEffectOGL*) supportMaterial->GetMaterialEffects()[0];
DEBUG_PRINT("pMatEffect: %p", pMatEffect);
GLuint shaderProgID = pMatEffect->GetShaderID();
DEBUG_PRINT("shaderProgID: %d", shaderProgID);
GLuint worldMatrixBufferLoc = glGetUniformLocation( shaderProgID, "instancedWorld" );
DEBUG_PRINT("worldMatrixBufferLoc: %d", worldMatrixBufferLoc);
GL_CHECK(glUseProgram(shaderProgID));
GL_CHECK(glUniformMatrix4fv( worldMatrixBufferLoc, numInstances, GL_FALSE, (const GLfloat *) &world[0] ));
// Tech unit shader
pMatEffect = (CPUTMaterialEffectOGL*) techMaterial->GetMaterialEffects()[0];
assert(pMatEffect);
shaderProgID = pMatEffect->GetShaderID();
worldMatrixBufferLoc = glGetUniformLocation( shaderProgID, "instancedWorld" );
GL_CHECK(glUseProgram(shaderProgID));
GL_CHECK(glUniformMatrix4fv( worldMatrixBufferLoc, numInstances, GL_FALSE, (const GLfloat *) &world[0] ));
GL_CHECK(glUseProgram(0));
}
void MySample::Update(double deltaSeconds)
{
static double time = 0.0f;
float rows = 0.0f;
float columns = 0.0f;
float angle_value = 0.0f;
// Update cam
lookY = cameraY / 4.0f;
lookZ = lookY / 3.0f;
time += (deltaSeconds);
/* DEMO SECTION */
if (time > 360.0f)
time = 0.0f;
float4 temp = float4(1.0f, 1.0f, 1.0f, 1.0f) * (float4x4RotationY( kPi / 2.0f) *
float4x4Translation(float3(0.0f, 0.0f, 50.0f * (9 / k2Pi))) *
float4x4RotationY( DegreesToRadians((40.0f * ( 0.5f * time)))));
mpCamera->SetPosition( temp.x, cameraY, temp.z );
mpCamera->LookAt( 1.0f, lookY, lookZ );
/* END DEMO SECTION */
mpCameraController->Update((float)deltaSeconds);
currentTime = (float)deltaSeconds;
fpsTime += (float) deltaSeconds;
fpsCount++;
fps = fpsCount / fpsTime;
if( fpsTime >= 1.0f )
{
fpsTime = 0.0f;
fpsCount = 0;
}
// Update GUI
rows = (float) currentRowCount; // for slider
columns = (float) currentColCount; // for slider
angle_value = 360.0 / columns;
stringstream textStream;
const int numInstances = (int)columns * (int) rows;
textStream << "FPS:"<< fps;
pTextMethod->SetText(PrepareText(textStream), 0.5f);
}
//-----------------------------------------------------------------------------
CPUTEventHandledCode CPUTCameraControllerFPS::HandleMouseEvent(
int x,
int y,
int wheel,
CPUTMouseState state,
CPUTEventID message
)
{
if( !mpCamera )
{
return CPUT_EVENT_UNHANDLED;
}
if(state & CPUT_MOUSE_LEFT_DOWN)
{
float3 position = mpCamera->GetPosition();
if(!(mPrevFrameState & CPUT_MOUSE_LEFT_DOWN)) // Mouse was just clicked
{
mnPrevFrameX = x;
mnPrevFrameY = y;
}
float nDeltaX = (float)(x-mnPrevFrameX);
float nDeltaY = (float)(y-mnPrevFrameY);
//Compute animation as an offset from the current basis
float degreeY = nDeltaX*mfLookSpeed;
float degreeX = nDeltaY*mfLookSpeed;
mpCamera->mRotation += float3(degreeX,degreeY,0);
float4x4 rotationX = float4x4RotationX(degreeX);
float4x4 rotationY = float4x4RotationY(degreeY);
mpCamera->SetPosition(0.0f, 0.0f, 0.0f); // Rotate about camera center
float4x4 parent = *mpCamera->GetParentMatrix();
float4x4 orientation = rotationX *parent * rotationY;
orientation.orthonormalize();
mpCamera->SetParentMatrix( orientation );
mpCamera->SetPosition( position.x, position.y, position.z ); // Move back to original position
mpCamera->Update();
mnPrevFrameX = x;
mnPrevFrameY = y;
mPrevFrameState = state;
return CPUT_EVENT_HANDLED;
} else
{
mPrevFrameState = state;
return CPUT_EVENT_UNHANDLED;
}
}
void CPUTCameraModelViewer::Update(float deltaSeconds)
{
float prevDistance = mDistance;
float lerp = floatClamp( deltaSeconds * 6, 0.0f, 1.0f);
mDistance = floatLerp(mDistance, mDstDistance, lerp);
float3 look = (float4x4RotationX(mViewAngles.x) * float4x4RotationY(mViewAngles.y)) * float3( 0, 0, 1 );
float3 pos = mTarget - look * mDistance;
mpCamera->SetPosition(pos);
((CPUTCamera*)mpCamera)->LookAt(mTarget);
mpCamera->Update(deltaSeconds);
}
//-----------------------------------------------------------------------------
CPUTEventHandledCode CPUTCameraControllerArcBall::HandleMouseEvent(
int x,
int y,
int wheel,
CPUTMouseState state,
CPUTEventID message
)
{
// TODO: We want move-in-x to orbit light in view space, not object space.
if( !mpCamera )
{
return CPUT_EVENT_UNHANDLED;
}
if(state & CPUT_MOUSE_RIGHT_DOWN) // TODO: How to make this flexible? Want to choose which mouse button has effect.
{
float4x4 rotationX, rotationY;
if(!(mPrevFrameState & CPUT_MOUSE_RIGHT_DOWN)) // Mouse was just clicked
{
mnPrevFrameX = x;
mnPrevFrameY = y;
}
int nDeltaX = x-mnPrevFrameX;
int nDeltaY = y-mnPrevFrameY;
rotationY = float4x4RotationX(nDeltaY*mfLookSpeed);
rotationX = float4x4RotationY(nDeltaX*mfLookSpeed);
float4x4 orientation = *mpCamera->GetParentMatrix() * rotationY * rotationX;
orientation.orthonormalize();
mpCamera->SetParentMatrix( orientation );
mnPrevFrameX = x;
mnPrevFrameY = y;
mPrevFrameState = state;
return CPUT_EVENT_HANDLED;
} else
{
mPrevFrameState = state;
return CPUT_EVENT_UNHANDLED;
}
}
//-----------------------------------------------------------------------------
void CPUTCameraControllerFPS::Update(float deltaSeconds)
{
if( !mpCamera )
{
return;
}
float speed = mfMoveSpeed * deltaSeconds;
if (keyPressed[KEY_SHIFT] == CPUT_KEY_DOWN || keyPressed[KEY_CTRL] == CPUT_KEY_DOWN) {
speed *= 0.1f;
}
float4x4 *pParentMatrix = mpCamera->GetParentMatrix();
float3 vRight(pParentMatrix->getXAxis());
float3 vUp(pParentMatrix->getYAxis());
float3 vLook(pParentMatrix->getZAxis());
float3 vPositionDelta(0.0f);
int rotateX = 0;
int rotateY = 0;
bool bRotate = false;
// Added the ability to toggle on/off rotation mode
if (keyPressed[KEY_SPACE] == CPUT_KEY_DOWN) {
bRotate = true;
}
if(keyPressed[KEY_W] == CPUT_KEY_DOWN) {
vPositionDelta += vLook * speed;
rotateY = -1;
}
if(keyPressed[KEY_A] == CPUT_KEY_DOWN) {
vPositionDelta += vRight * -speed;
rotateX = -1;
}
if(keyPressed[KEY_S] == CPUT_KEY_DOWN) {
vPositionDelta += vLook * -speed;
rotateY = 1;
}
if(keyPressed[KEY_D] == CPUT_KEY_DOWN) {
vPositionDelta += vRight * speed;
rotateX = 1;
}
if(keyPressed[KEY_E] == CPUT_KEY_DOWN) {
vPositionDelta += vUp * speed;
}
if(keyPressed[KEY_Q] == CPUT_KEY_DOWN) {
vPositionDelta += vUp * -speed;
}
if (bRotate && (rotateX || rotateY))
{
// this lets you rotate the camera with the keyboard if you don't have a mouse. like if you only have one
// usb slot available on a mobile.
float nDeltaX = (float)(rotateX) * speed * 10.0f;
float nDeltaY = (float)(rotateY) * speed * 10.0f;
float4x4 rotationX = float4x4RotationX(nDeltaY*mfLookSpeed);
float4x4 rotationY = float4x4RotationY(nDeltaX*mfLookSpeed);
float3 position = mpCamera->GetPosition();
mpCamera->SetPosition(0.0f, 0.0f, 0.0f); // Rotate about camera center
float4x4 parent = *mpCamera->GetParentMatrix();
float4x4 orientation = rotationX *parent * rotationY;
orientation.orthonormalize();
mpCamera->SetParentMatrix( orientation );
mpCamera->SetPosition( position.x, position.y, position.z ); // Move back to original position
}
else
{
float x,y,z;
mpCamera->GetPosition( &x, &y, &z );
mpCamera->SetPosition( x+vPositionDelta.x, y+vPositionDelta.y, z+vPositionDelta.z );
}
mpCamera->Update();
//Compute animation as an offset from the current position
mpCamera->mPosition += float3( vPositionDelta.x, vPositionDelta.y, vPositionDelta.z );
//END
return;
}
