void CubeMapRenderer::render(const CubeMapTextureObject& cubeMapTexture, const ICamera<float>& camera, const TriangleBuffer& buffer)
{
const auto& positions = buffer.getPositions().get();// buffers[0].get();
const auto& normals = buffer.getNormals().get();//buffers[1].get();
if (positions.empty()) {
return;
}
cubeMapTexture.bind();
glEnable(GL_DEPTH_TEST);
glUseProgram(shader.getId());
//cubeMapTexture.bind();
// glUniform1f(shader.getUniformLocation("reflectFactor"), 0.8f);
// glUniform1f(shader.getUniformLocation("refractFactor"), 1.2f);
assert(GL_NO_ERROR == glGetError());
glUniform1i(shader.getUniformLocation("cubeMapTex"), cubeMapTexture.getId());// volumeTexture.getId());
glUniform3fv(shader.getUniformLocation("eyePosition"), 1, camera.getPosition().toArray().data());
assert(GL_NO_ERROR == glGetError());
glUniformMatrix4fv(shader.getUniformLocation("modelviewMatrix"), 1, false, camera.getModelviewMatrix().toArray().data());
glUniformMatrix4fv(shader.getUniformLocation("projectionMatrix"), 1, false, camera.getProjectionMatrix().toArray().data());
assert(GL_NO_ERROR == glGetError());
glVertexAttribPointer(shader.getAttribLocation("position"), 3, GL_FLOAT, GL_FALSE, 0, positions.data());
glVertexAttribPointer(shader.getAttribLocation("normal"), 3, GL_FLOAT, GL_FALSE, 0, normals.data());
assert(GL_NO_ERROR == glGetError());
assert(GL_NO_ERROR == glGetError());
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
for (const auto& b : buffer.getBlocks()) {
const auto& indices = b.getIndices();
glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(indices.size()), GL_UNSIGNED_INT, indices.data());
}
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glBindFragDataLocation(shader.getId(), 0, "fragColor");
cubeMapTexture.unbind();
glDisable(GL_DEPTH_TEST);
glUseProgram(0);
}
//--------------------------------------------------------------------------------------
void ModelSpotLightPerpixel::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
Environment* env = engine.GetEnvironment();
ICamera* camera = engine.GetCamera();
device->SetShaderParameter(m_hTransform, *(Matrix44f*)(m_pMaterial->Attribute( IAttributeNode::ATT_WORLDTRANSFORM )) );
device->SetShaderParameter(m_hNormalTransform, *(Matrix33f*)(m_pMaterial->Attribute( IAttributeNode::ATT_NORMALTRANSFORM )) );
device->SetShaderParameter(m_hViewProjMatrixLoc, camera->GetViewProj());
device->SetShaderParameter(m_hLightDirectionLoc, env->GetCurrentLight().GetWorldDirection() );
device->SetShaderParameter(m_hLightPosition, env->GetCurrentLight().GetWorldPosition() );
device->SetShaderParameter(m_hCameraPositionLoc, camera->GetPosition() );
device->SetShaderParameter(m_hLightRangeInv, 1.0f / env->GetCurrentLight().GetRange() );
device->SetShaderParameter(m_hInner_DiffInv, env->GetCurrentLight().GetLightInnerDiffInv() );
device->SetShaderParameter(m_hAttenuation, env->GetCurrentLight().GetAttenuation() );
Matrix44f Bais( 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 );
Matrix44f PBais = env->GetCurrentLight().GetCaster().GetFirstCamera().GetViewProj() * Bais;
device->SetShaderParameter(m_hshadowMatrixBasi, PBais );
device->SetShaderParameter(m_hCameraLineDepthParam, env->GetCurrentLight().GetCaster().GetFirstCamera().LineDepthParam() );
device->SetShaderParameter( m_hTextureBase, *((Texture*)m_pMaterial->Attribute(Material::ATT_TEX_DIFFUSE)) );
device->SetShaderParameter( m_hTextureDepth, env->GetCurrentLight().GetCaster().GetFirstDepthTexture() );
device->SetShaderParameter(m_hAmbient_AmbientLight, env->GetAmbient() * m_pMaterial->Ambient() );
device->SetShaderParameter(m_hSpecular_Light, env->GetCurrentLight().GetColor() * m_pMaterial->Specular() * m_pMaterial->SpeLevel() );
device->SetShaderParameter(m_hLight, m_pMaterial->Diffuse() * env->GetCurrentLight().GetColor() );
device->SetShaderParameter(m_hShininess, m_pMaterial->Shininess() );
}
//--------------------------------------------------------------------------------------
void PrePixelLightTransform::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
Environment* env = engine.GetEnvironment();
ICamera* camera = engine.GetCamera();
Matrix44f wvp = *m_pTransform * camera->GetViewProj();
device->SetShaderParameter(m_hTransform, *m_pTransform);
if( NULL == m_pColor )
{
device->SetShaderParameter(m_hColor, vector4f(1,1,1,1) );
}
else
{
device->SetShaderParameter(m_hColor, *m_pColor);
}
device->SetShaderParameter(m_hNormalTransform, Matrix33f( *m_pTransform ) );
device->SetShaderParameter(m_hWorldViewProjMatrixLoc, wvp);
device->SetShaderParameter(m_hLightDirectionLoc, -env->GetCurrentLight().GetWorldDirection());//phong光是像素到光源的方向，所以这里反向
device->SetShaderParameter(m_hCameraPositionLoc, camera->GetPosition() );
device->SetShaderParameter(m_hAmbientLoc, env->GetAmbient());
device->SetShaderParameter(m_hLightLoc, env->GetCurrentLight().GetColor());
//clean up
m_pTransform = NULL;
m_pColor = NULL;
}
void VolumeRenderer::Render(const ICamera &camera) {
Matrix objectMatrix;
transform->GetTransformMatrixQuaternion(objectMatrix);
Vector3 camPos;
camera.GetPosition(camPos);
Matrix wvpMatrix = objectMatrix*camera.GetViewProjectionMatrix();
mVolumeRenderShader->SetVertexBufferValues(wvpMatrix, objectMatrix);
//mVolumeRenderShader->SetTransform(*transform);
if (mPrevCameraPos != camPos) {
mVolumeRenderShader->SetCameraPosition(camPos);
mPrevCameraPos = camPos;
}
auto context = pD3dGraphicsObj->GetDeviceContext();
primitive->Draw(mVolumeRenderShader.get(), mVolumeRenderShader->GetInputLayout(), false, false, [=]
{
auto blendState = pCommonStates->NonPremultiplied();
auto rasterizeState = pCommonStates->CullClockwise();
context->OMSetBlendState(blendState, nullptr, 0xFFFFFFFF);
context->RSSetState(rasterizeState);
}
);
ID3D11ShaderResourceView *const pSRVNULL[2] = {nullptr, nullptr};
context->PSSetShaderResources(0, 2, pSRVNULL);
}
//--------------------------------------------------------------------------------------
void ShadowVolumeInstance::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
Environment* env = engine.GetEnvironment();
ICamera* camera = engine.GetCamera();
device->SetShaderParameter(m_hLightDirectionLoc, env->GetCurrentLight().GetWorldDirection());
device->SetShaderParameter(m_hViewProjLoc, camera->GetViewProjBias());
}
void LegacyRenderer::render(const ICamera<float>& camera, const PointLight<float>& light, const TriangleBuffer& buffer)
{
const auto& positions = buffer.getPositions().get();// buffers[0].get();
const auto& normals = buffer.getNormals().get();//buffers[1].get();
if (positions.empty()) {
return;
}
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
const auto& projectionMatrix = camera.getProjectionMatrix();
const auto& modelviewMatrix = camera.getModelviewMatrix();;
std::vector<float> lightPos = { light.getPos().getX(), light.getPos().getY(), light.getPos().getZ(), 1.0 };
glLightfv(GL_LIGHT0, GL_POSITION, lightPos.data());
glLightfv(GL_LIGHT0, GL_DIFFUSE, light.getDiffuse().toArray4().data());
// glLightfv(GL_LIGHT0, GL_SPECULAR, light.getSpecular().toArray4().data());
glLightfv(GL_LIGHT0, GL_AMBIENT, white);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glLoadMatrixf(projectionMatrix.toArray().data());
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glLoadMatrixf(modelviewMatrix.toArray().data());
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, yellow);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, positions.data());
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, normals.data());
//glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(positions.size()) / 3);
for (const auto& b : buffer.getBlocks()) {
const auto& indices = b.getIndices();
glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(indices.size()), GL_UNSIGNED_INT, indices.data());
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
glDisable(GL_DEPTH_TEST);
}
//--------------------------------------------------------------------------------------
void PrePixelLight::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
Environment* env = engine.GetEnvironment();
ICamera* camera = engine.GetCamera();
device->SetShaderParameter(m_hWorldViewProjMatrixLoc, camera->GetViewProj());
device->SetShaderParameter(m_hLightDirectionLoc, -env->GetCurrentLight().GetWorldDirection());//phong光是像素到光源的方向，所以这里反向
device->SetShaderParameter(m_hCameraPositionLoc, camera->GetPosition() );
device->SetShaderParameter(m_hAmbientLoc, env->GetAmbient());
device->SetShaderParameter(m_hLightLoc, env->GetCurrentLight().GetColor());
}
void gkOculus::Flush()
{
if(HMD)
{
// OVERRIDE MAIN CAMERA
ICamera* cam = gEnv->p3DEngine->getMainCamera();
static ovrTrackingState HmdState;
ovrVector3f hmdToEyeViewOffset[2] = { EyeRenderDesc[0].HmdToEyeViewOffset, EyeRenderDesc[1].HmdToEyeViewOffset };
ovrHmd_GetEyePoses(HMD, 0, hmdToEyeViewOffset, eyeRenderPose, &HmdState);
Quat camOrientation;
camOrientation.v.x = eyeRenderPose->Orientation.x;
camOrientation.v.y = -eyeRenderPose->Orientation.z;
camOrientation.v.z = eyeRenderPose->Orientation.y;
camOrientation.w = eyeRenderPose->Orientation.w;
cam->setAdditionalOrientation( camOrientation );
Quat dRot = cam->getDerivedOrientation();
Vec3 eyeOffsetL = Vec3(eyeRenderPose[0].Position.x, -eyeRenderPose[0].Position.z, eyeRenderPose[0].Position.y);
Vec3 eyeOffsetR = Vec3(eyeRenderPose[1].Position.x, -eyeRenderPose[1].Position.z, eyeRenderPose[1].Position.y);
cam->setStereoOffset( dRot * eyeOffsetL, dRot * eyeOffsetR );
Matrix44 leftMat,rightMat;
OVR::Matrix4f projLeft;
OVR::Matrix4f projRight;
projLeft = ovrMatrix4f_Projection(EyeRenderDesc[0].Fov, 0.01f, 10000.0f, true);
projRight = ovrMatrix4f_Projection(EyeRenderDesc[1].Fov, 0.01f, 10000.0f, true);
leftMat = *((Matrix44*)(&projLeft));
rightMat = *((Matrix44*)(&projRight));
leftMat.Transpose();
rightMat.Transpose();
cam->setStereoProjMatrix( leftMat, rightMat );
IRenderSequence* rs = gEnv->pRenderer->RT_GetRenderSequence();
if (rs)
{
rs->addToRenderSequence( m_disortation_renderable_eyes[0], RENDER_LAYER_STEREO_DEVICE );
rs->addToRenderSequence( m_disortation_renderable_eyes[1], RENDER_LAYER_STEREO_DEVICE );
}
}
}
void PointRenderer::render(const ICamera<float>& camera, const PointBuffer& buffer)
{
const auto positions = buffer.getPosition().get();
const auto colors = buffer.getColor().get();
const auto sizes = buffer.getSize().get();
if (positions.empty()) {
return;
}
const auto& projectionMatrix = camera.getProjectionMatrix().toArray();
const auto& modelviewMatrix = camera.getModelviewMatrix().toArray();
glEnable(GL_DEPTH_TEST);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
glEnable(GL_POINT_SPRITE);
//glEnable(GL_DEPTH_TEST);
glUseProgram(shader.getId());
glUniformMatrix4fv(shader.getUniformLocation("projectionMatrix"), 1, GL_FALSE, projectionMatrix.data());
glUniformMatrix4fv(shader.getUniformLocation("modelviewMatrix"), 1, GL_FALSE, modelviewMatrix.data());
glVertexAttribPointer(shader.getAttribLocation("positions"), 3, GL_FLOAT, GL_FALSE, 0, positions.data());
glVertexAttribPointer(shader.getAttribLocation("color"), 4, GL_FLOAT, GL_FALSE, 0, colors.data());
glVertexAttribPointer(shader.getAttribLocation("pointSize"), 1, GL_FLOAT, GL_FALSE, 0, sizes.data());
//const auto positions = buffer.getPositions();
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>( positions.size() / 3) );
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(0);
glBindFragDataLocation(shader.getId(), 0, "fragColor");
glDisable(GL_DEPTH_TEST);
glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
glDisable(GL_POINT_SPRITE);
glUseProgram(0);
}
virtual void OnInit()
{
// set camera
ICamera* maincam = gEnv->p3DEngine->getMainCamera();
//maincam->setFOVy( DEG2RAD(60.0f) );
//maincam->setNearPlane( 1.0 );
//maincam->setFarPlane( 400.0 );
maincam->setPosition(-2, -36, 2);
maincam->setOrientation( Quat::CreateRotationXYZ( Ang3( DEG2RAD(-5), 0,0 ) ) );
gEnv->pGameFramework->LoadLevel( _T("level/village/village.gks") );
//gEnv->pGameFramework->LoadLevel( _T("level/conf_room/conf_room.gks") );
//gEnv->p3DEngine->getTimeOfDay()->setSpeed( 0.5 );
}
void Mesh::drawAOG(ICamera& camera) {
mProgramAOGeometry->use();
core::Uniform::push(mULCMVPAmbientOcclusion,
camera.getViewProjection() * mPhysicsMMC);
core::Uniform::push(mULCPositionAmbientOcclusion,
camera.getEye() * mPhysicsMMC);
mVAO->bind();
onDraw();
core::VertexArray::unbindVAO();
}
void SkyObject::Render(const ICamera &camera) {
camera.GetPosition(transform->position);
Matrix objectMatrix;
transform->GetTransformMatrixQuaternion(objectMatrix);
Matrix wvpMatrix = objectMatrix*camera.GetViewProjectionMatrix();
mSkyShader->SetVertexBufferValues(wvpMatrix, objectMatrix);
ID3D11DeviceContext *context = pD3dGraphicsObj->GetDeviceContext();
primitive->Draw(mSkyShader.get(), mSkyShader->GetInputLayout(), false, false, [=]
{
ID3D11RasterizerState* rasterizeState = pCommonStates->CullNone();
context->RSSetState(rasterizeState);
}
);
}
void getCameraTimeSpan(ICamera iCam, chrono_t& first, chrono_t& last) {
ICameraSchema cam = iCam.getSchema();
TimeSamplingPtr ts = cam.getTimeSampling();
first = std::min(first, ts->getSampleTime(0) );
last = std::max(last, ts->getSampleTime(cam.getNumSamples()-1) );
}
void NormalFilter::render(const ITextureObject& texture, const ICamera<float>& renderedCamera)
{
const Box2d<float> box(Vector2d<float>(-1.0, -1.0), Vector2d<float>(1.0, 1.0));
const auto& positions = box.toArray();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
//glDisable(GL_DEPTH_TEST);
glUseProgram(shader.getId());
texture.bind();
//glGetUniformLocation( texture.getId()
glUniform1i(shader.getUniformLocation("depthTex"), texture.getId());
glUniform1f(shader.getUniformLocation("texelSizeW"), 1.0f / static_cast<float>(texture.getWidth()));
glUniform1f(shader.getUniformLocation("texelSizeH"), 1.0f / static_cast<float>(texture.getHeight()));
glUniformMatrix4fv(shader.getUniformLocation("projectionMatrix"), 1, GL_FALSE, renderedCamera.getProjectionMatrix().toArray().data());
glVertexAttribPointer(shader.getAttribLocation("positions"), 2, GL_FLOAT, GL_FALSE, 0, positions.data());
glEnableVertexAttribArray(0);
glDrawArrays(GL_QUADS, 0, static_cast<GLsizei>( positions.size() / 2) );
glDisableVertexAttribArray(0);
glBindFragDataLocation(shader.getId(), 0, "fragColor");
texture.unbind();
glDisable(GL_DEPTH_TEST);
glUseProgram(0);
}
void Mesh::drawPBRP(ICamera& camera) {
#ifdef FILLWAVE_GLES_3_0
#else
if (mAnimator || mOcclusionQuery.getResultAsync(1))
#endif
{
core::Uniform::push(mULCModelMatrix, mPhysicsMMC);
core::Uniform::push(mULCLightAmbientIntensity, mMaterial.getAmbient());
core::Uniform::push(mULCLightDiffuseIntensity, mMaterial.getDiffuse());
core::Uniform::push(mULCLightSpecularIntensity, mMaterial.getSpecular());
core::Uniform::push(mULCCameraPosition, camera.getTranslation());
core::Uniform::push(mULCViewProjectionMatrix, camera.getViewProjection());
coreDraw();
}
}
int main(int argc, char** argv){
//Create gesture object
GestureControl gesture = GestureControl();
//create ROI
int roi_rect_width = FRAME_WIDTH * 0.5;
int roi_rect_height = FRAME_HEIGHT * 0.4;
int xmin = (FRAME_WIDTH - roi_rect_width) * 0.5 ;
int ymin = (FRAME_HEIGHT - roi_rect_height) * 0.5;
int xmax = xmin + roi_rect_width;
int ymax = ymin + roi_rect_height;
//Set Depth range
int start_depth = 65;
int end_depth = 80;
gesture.setGestureROI(xmin, ymin, xmax, ymax,
start_depth, end_depth);
//Get Camera
Mat depth_frame;
ICamera* cam = new XtionCam();
for(;;){
//Get Depth Frame
cam->getDepthImage(depth_frame);
//Process Next Depth Frame
gesture.processNextFrame(depth_frame);
//Draw ROI
rectangle( gesture.drawing, gesture.roi_rect, Scalar(181,186,10), 2, 8 );
//Show Depth result image
imshow("Contour tracking Object", gesture.drawing);
//Key Control
int key_code = waitKey(30);
if(key_code == 27) break;
}
//ShutdownGesture
gesture.shutdownGesture();
//Release
delete cam;
return 0;
}
void LegacyRenderer::render(const ICamera<float>& camera, const PointBuffer& buffer, const float pointSize)
{
const auto& positions = buffer.getPosition().get();// buffers[0].get();
const auto& colors = buffer.getColor().get();
if (positions.empty()) {
return;
}
GLfloat distance[] = { 0.0, 0.0, 1.0 };
glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, distance);
glEnable(GL_POINT_SPRITE);
glEnable(GL_DEPTH_TEST);
glPointSize(pointSize);
Matrix4d<float> projectionMatrix = camera.getProjectionMatrix();
Matrix4d<float> modelviewMatrix = camera.getModelviewMatrix();;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glLoadMatrixf(projectionMatrix.toArray().data());
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glLoadMatrixf(modelviewMatrix.toArray().data());
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, positions.data());
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_FLOAT, 0, colors.data());
assert(glGetError() == GL_NO_ERROR);
glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(positions.size()) / 3);
//glDrawElements(GL_POINTS, indices.size(), GL_UNSIGNED_INT, indices.data());
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_DEPTH_TEST);
glDisable(GL_POINT_SPRITE);
}
void GradientBall::draw(ICamera& camera) {
mProgram->use();
mProgram->uniformPush("uModelMatrix", mParentMMC * mMMC);
mProgram->uniformPush("uSize", mSize);
mProgram->uniformPush("uTextureUnit", FILLWAVE_DIFFUSE_UNIT);
mProgram->uniformPush("uViewProjectionMatrix", camera.getViewProjection());
coreDraw();
}
//--------------------------------------------------------------------------------------
void ShadowVolume::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
Environment* env = engine.GetEnvironment();
ICamera* camera = engine.GetCamera();
Matrix44f wvp = *m_pTransform * camera->GetViewProj();
Matrix33f normalTransform(*m_pTransform);
device->SetShaderParameter(m_hNormalTransformLoc, normalTransform);
device->SetShaderParameter(m_hModelViewProjLoc, wvp);
device->SetShaderParameter(m_hLightDirectionLoc, env->GetCurrentLight().GetWorldDirection());
device->SetShaderParameter(m_hViewProjLoc, camera->GetViewProjBias());
//clean up
m_pTransform = NULL;
}
//--------------------------------------------------------------------------------------
void ModelNormal::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
ICamera* camera = engine.GetCamera();
device->SetShaderParameter(m_hWorldViewProjMatrixLoc, *(Matrix44f*)(m_pMaterial->Attribute( IAttributeNode::ATT_WORLDTRANSFORM )) * camera->GetViewProj() );
device->SetShaderParameter(m_hNormalTransform, *(Matrix33f*)(m_pMaterial->Attribute( IAttributeNode::ATT_NORMALTRANSFORM )) );
}
void LegacyRenderer::renderAlphaBlend(const ICamera<float>& camera, const PointBuffer& buffer)
{
const auto& positions = buffer.getPosition().get();// buffers[0].get();
const auto& colors = buffer.getColor().get();
if (positions.empty()) {
return;
}
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glPointSize(10.0f);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
Matrix4d<float> projectionMatrix = camera.getProjectionMatrix();
Matrix4d<float> modelviewMatrix = camera.getModelviewMatrix();;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glLoadMatrixf(projectionMatrix.toArray().data());
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glLoadMatrixf(modelviewMatrix.toArray().data());
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, positions.data());
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_FLOAT, 0, colors.data());
assert(glGetError() == GL_NO_ERROR);
glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(positions.size()) / 3);
//glDrawElements(GL_POINTS, indices.size(), GL_UNSIGNED_INT, indices.data());
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
//--------------------------------------------------------------------------------------
void ModelPrePixelLight::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
Environment* env = engine.GetEnvironment();
ICamera* camera = engine.GetCamera();
device->SetShaderParameter(m_hTransform, *(Matrix44f*)(m_pMaterial->Attribute( IAttributeNode::ATT_WORLDTRANSFORM )) );
device->SetShaderParameter(m_hNormalTransform, *(Matrix33f*)(m_pMaterial->Attribute( IAttributeNode::ATT_NORMALTRANSFORM )) );
device->SetShaderParameter(m_hViewProjMatrixLoc, camera->GetViewProj());
device->SetShaderParameter(m_hLightDirectionLoc, -env->GetCurrentLight().GetWorldDirection() );//phong光是像素到光源的方向，所以这里反向
device->SetShaderParameter(m_hCameraPositionLoc, camera->GetPosition() );
device->SetShaderParameter( m_hTextureBase, *((Texture*)m_pMaterial->Attribute(Material::ATT_TEX_DIFFUSE)) );
device->SetShaderParameter(m_hAmbient_AmbientLight, env->GetAmbient() * m_pMaterial->Ambient() );
device->SetShaderParameter(m_hSpecular_Light, env->GetCurrentLight().GetColor() * m_pMaterial->Specular() * m_pMaterial->SpeLevel() );
device->SetShaderParameter(m_hLight, m_pMaterial->Diffuse() * env->GetCurrentLight().GetColor() );
device->SetShaderParameter(m_hShininess, m_pMaterial->Shininess() );
}
void CMeshNode::UpdateImp(int elapsedTime)
{
if (m_pSceneParent)
{
ICamera *pCamera = m_pSceneParent->GetCamera();
if (pCamera)
{
if (m_pMesh)
{
const CFrustum &frustum = pCamera->GetFrustum();
CVector3 camPos;
pCamera->GetViewMatrix().TransformVect(camPos, GetPosition());
if (!frustum.CullSphere(camPos, m_pMesh->GetMaxRadius()))
{
SetActive(true);
for (uint i = 0; i < m_pMesh->GetTrianglesNum(); ++i)
{
if (m_pRenderableObject[i])
{
render::IShaderProgram *shaderProgram = m_pRenderableObject[i]->GetShaderProgram();
if (shaderProgram)
{
CMatrix4 modelMat4;
modelMat4.SetTranslation(GetPosition());
CMatrix4 mat4 = modelMat4 * pCamera->GetViewProjectionMatrix();
shaderProgram->SetUniform("mvpMatrix", &mat4.m);
}
}
}
}
else
{
SetActive(false);
}
}
}
}
}
//--------------------------------------------------------------------------------------
void ModelDepth::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
ICamera* camera = engine.GetCamera();
Matrix44f& mat = *(Matrix44f*)(m_pMaterial->Attribute( IAttributeNode::ATT_WORLDTRANSFORM ));
device->SetShaderParameter(m_hWorldTransform, mat );
if ( m_pMaterial->Attribute( IAttributeNode::ATT_USER_0 ) )
{
device->SetShaderParameter(m_hCameraLineDepthParam, camera->LineDepthParamBais() );
device->SetShaderParameter(m_hWorldViewProjMatrixLoc, mat * camera->GetViewProjBias() );
}
else
{
device->SetShaderParameter(m_hCameraLineDepthParam, camera->LineDepthParam() );
device->SetShaderParameter(m_hWorldViewProjMatrixLoc, mat * camera->GetViewProj() );
}
device->SetShaderParameter(m_hLightPositionLoc, engine.GetEnvironment()->GetCurrentLight().GetWorldPosition() );
}
//--------------------------------------------------------------------------------------
void ModelLightMaped::_SetParameters ()
{
Engine& engine = Engine::Instance();
Device* device = engine.GetDevice();
Environment* env = engine.GetEnvironment();
ICamera* camera = engine.GetCamera();
device->SetShaderParameter(m_hWorldViewProj, *(Matrix44f*)(m_pMaterial->Attribute( IAttributeNode::ATT_WORLDTRANSFORM )) * camera->GetViewProj() );
device->SetShaderParameter( m_hBaseTexture, *((Texture*)m_pMaterial->Attribute(Material::ATT_TEX_DIFFUSE)) );
device->SetShaderParameter( m_hLightMapedTexture, *((Texture*)m_pMaterial->Attribute(Material::ATT_TEX_LIGHT_MAP)) );
}
inline void RendererDR::drawLightsSpotPass(ICamera& camera,
GLint& textureUnit) {
for (size_t i = 0; i < mLights->mLightsSpot.size(); i++) {
mProgramSpotLight->use();
mLights->updateDeferredBufferSpot(i, mProgramSpotLight,
textureUnit++);
core::Uniform::push(mULCCameraPositionSpot,
camera.getTranslation());
core::Uniform::push(mULCIsAOSpot, mIsAO ? 1 : 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
}
void CCollisionMgr::OnScreenTouch(glm::vec2 _vTouchPoint)
{
m_bIsTouch = true;
m_vTouch2DPoint = _vTouchPoint;
ICamera* pCamera = CSceneMgr::Instance()->Get_Camera();
if(pCamera == NULL)
{
return;
}
glm::mat4x4 mView = pCamera->Get_View();
glm::mat4x4 mProjection = pCamera->Get_Projection();
glm::ivec4 vViewport;
vViewport[0] = 0;
vViewport[1] = 0;
vViewport[2] = CWindow::Get_ScreenHeight();
vViewport[3] = CWindow::Get_ScreenWidth();
m_vTouchRay = Unproject(m_vTouch2DPoint, mView, mProjection, vViewport);
CEventMgr::Instance()->OnEvent(CEventMgr::E_EVENT_TOUCH);
}
void Mesh::drawPicking(ICamera& camera) {
if (isPickable()) {
mProgram->use();
core::Uniform::push(mULCModelMatrix, mPhysicsMMC);
core::Uniform::push(mULCCameraPosition, camera.getTranslation());
core::Uniform::push(mULCViewProjectionMatrix, camera.getViewProjection());
core::Uniform::push(mULCColorPicking, true);
core::Uniform::push(mULCPainterColor, glm::vec4(getPickableColor(), 1.0));
mVAO->bind();
onDraw();
core::VertexArray::unbindVAO();
core::Uniform::push(mULCColorPicking, false);
core::Program::disusePrograms();
}
}
void Mesh::drawAOC(ICamera& camera) {
mProgramAOColor->use();
// core::Uniform::push(mULCTextureMap, FILLWAVE_DIFFUSE_ATTACHMENT);
core::Uniform::push(mULCSampleRadius, FILLWAVE_AO_SAMPLE_RADIUS);
core::Uniform::push(mULCProjectionMatrix, camera.getProjection());
// core::Uniform::push(mULCRandomVectors, camera.getEye() * mPhysicsMMC);
mVAO->bind();
onDraw();
core::VertexArray::unbindVAO();
}
void CUnit::UpdateImp(int delta)
{
//没有被剔除掉，加入到渲染列表
if (true)
{
IShaderProgram *pShaderProgram = m_pRenderable->GetShaderProgram();
if (pShaderProgram)
{
CMatrix4 vpMat4;
if (SCENEMGR->GetCurrentScene())
{
ICamera *pCam = SCENEMGR->GetCurrentScene()->GetCamera();
if (pCam)
{
vpMat4 = pCam->GetViewProjectionMatrix();
}
}
CMatrix4 mvpMat4 = GetAbsluateTransformation() * vpMat4;
pShaderProgram->SetUniform("mvpMatrix", mvpMat4.m);
}
m_pRenderable->SumbitToRenderList();
}
}
