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(); } }