void DefNewGeneration::save_marks() {
eden()->set_saved_mark();
to()->set_saved_mark();
from()->set_saved_mark();
}
void DefNewGeneration::adjust_desired_tenuring_threshold() {
// Set the desired survivor size to half the real survivor space
_tenuring_threshold =
age_table()->compute_tenuring_threshold(to()->capacity()/HeapWordSize);
}
void DefNewGeneration::collect(bool full,
bool clear_all_soft_refs,
size_t size,
bool is_tlab) {
assert(full || size > 0, "otherwise we don't want to collect");
GenCollectedHeap* gch = GenCollectedHeap::heap();
_gc_timer->register_gc_start();
DefNewTracer gc_tracer;
gc_tracer.report_gc_start(gch->gc_cause(), _gc_timer->gc_start());
_next_gen = gch->next_gen(this);
// If the next generation is too full to accommodate promotion
// from this generation, pass on collection; let the next generation
// do it.
if (!collection_attempt_is_safe()) {
if (Verbose && PrintGCDetails) {
gclog_or_tty->print(" :: Collection attempt not safe :: ");
}
gch->set_incremental_collection_failed(); // Slight lie: we did not even attempt one
return;
}
assert(to()->is_empty(), "Else not collection_attempt_is_safe");
init_assuming_no_promotion_failure();
GCTraceTime t1(GCCauseString("GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL);
// Capture heap used before collection (for printing).
size_t gch_prev_used = gch->used();
gch->trace_heap_before_gc(&gc_tracer);
SpecializationStats::clear();
// These can be shared for all code paths
IsAliveClosure is_alive(this);
ScanWeakRefClosure scan_weak_ref(this);
age_table()->clear();
to()->clear(SpaceDecorator::Mangle);
gch->rem_set()->prepare_for_younger_refs_iterate(false);
assert(gch->no_allocs_since_save_marks(0),
"save marks have not been newly set.");
// Not very pretty.
CollectorPolicy* cp = gch->collector_policy();
FastScanClosure fsc_with_no_gc_barrier(this, false);
FastScanClosure fsc_with_gc_barrier(this, true);
KlassScanClosure klass_scan_closure(&fsc_with_no_gc_barrier,
gch->rem_set()->klass_rem_set());
set_promo_failure_scan_stack_closure(&fsc_with_no_gc_barrier);
FastEvacuateFollowersClosure evacuate_followers(gch, _level, this,
&fsc_with_no_gc_barrier,
&fsc_with_gc_barrier);
assert(gch->no_allocs_since_save_marks(0),
"save marks have not been newly set.");
int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_CodeCache;
gch->gen_process_strong_roots(_level,
true, // Process younger gens, if any,
// as strong roots.
true, // activate StrongRootsScope
true, // is scavenging
SharedHeap::ScanningOption(so),
&fsc_with_no_gc_barrier,
true, // walk *all* scavengable nmethods
&fsc_with_gc_barrier,
&klass_scan_closure);
// "evacuate followers".
evacuate_followers.do_void();
FastKeepAliveClosure keep_alive(this, &scan_weak_ref);
ReferenceProcessor* rp = ref_processor();
rp->setup_policy(clear_all_soft_refs);
const ReferenceProcessorStats& stats =
rp->process_discovered_references(&is_alive, &keep_alive, &evacuate_followers,
NULL, _gc_timer);
gc_tracer.report_gc_reference_stats(stats);
if (!_promotion_failed) {
// Swap the survivor spaces.
eden()->clear(SpaceDecorator::Mangle);
from()->clear(SpaceDecorator::Mangle);
if (ZapUnusedHeapArea) {
// This is now done here because of the piece-meal mangling which
// can check for valid mangling at intermediate points in the
// collection(s). When a minor collection fails to collect
// sufficient space resizing of the young generation can occur
// an redistribute the spaces in the young generation. Mangle
// here so that unzapped regions don't get distributed to
// other spaces.
to()->mangle_unused_area();
}
swap_spaces();
assert(to()->is_empty(), "to space should be empty now");
adjust_desired_tenuring_threshold();
// A successful scavenge should restart the GC time limit count which is
// for full GC's.
AdaptiveSizePolicy* size_policy = gch->gen_policy()->size_policy();
size_policy->reset_gc_overhead_limit_count();
if (PrintGC && !PrintGCDetails) {
gch->print_heap_change(gch_prev_used);
}
assert(!gch->incremental_collection_failed(), "Should be clear");
} else {
assert(_promo_failure_scan_stack.is_empty(), "post condition");
_promo_failure_scan_stack.clear(true); // Clear cached segments.
remove_forwarding_pointers();
if (PrintGCDetails) {
gclog_or_tty->print(" (promotion failed) ");
}
// Add to-space to the list of space to compact
// when a promotion failure has occurred. In that
// case there can be live objects in to-space
// as a result of a partial evacuation of eden
// and from-space.
swap_spaces(); // For uniformity wrt ParNewGeneration.
from()->set_next_compaction_space(to());
gch->set_incremental_collection_failed();
// Inform the next generation that a promotion failure occurred.
_next_gen->promotion_failure_occurred();
gc_tracer.report_promotion_failed(_promotion_failed_info);
// Reset the PromotionFailureALot counters.
NOT_PRODUCT(Universe::heap()->reset_promotion_should_fail();)
}
// set new iteration safe limit for the survivor spaces
from()->set_concurrent_iteration_safe_limit(from()->top());
to()->set_concurrent_iteration_safe_limit(to()->top());
SpecializationStats::print();
// We need to use a monotonically non-decreasing time in ms
// or we will see time-warp warnings and os::javaTimeMillis()
// does not guarantee monotonicity.
jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
update_time_of_last_gc(now);
gch->trace_heap_after_gc(&gc_tracer);
gc_tracer.report_tenuring_threshold(tenuring_threshold());
_gc_timer->register_gc_end();
gc_tracer.report_gc_end(_gc_timer->gc_end(), _gc_timer->time_partitions());
}
void DefNewGeneration::compute_new_size() {
// This is called after a gc that includes the following generation
// (which is required to exist.) So from-space will normally be empty.
// Note that we check both spaces, since if scavenge failed they revert roles.
// If not we bail out (otherwise we would have to relocate the objects)
if (!from()->is_empty() || !to()->is_empty()) {
return;
}
int next_level = level() + 1;
GenCollectedHeap* gch = GenCollectedHeap::heap();
assert(next_level < gch->_n_gens,
"DefNewGeneration cannot be an oldest gen");
Generation* next_gen = gch->_gens[next_level];
size_t old_size = next_gen->capacity();
size_t new_size_before = _virtual_space.committed_size();
size_t min_new_size = spec()->init_size();
size_t max_new_size = reserved().byte_size();
assert(min_new_size <= new_size_before &&
new_size_before <= max_new_size,
"just checking");
// All space sizes must be multiples of Generation::GenGrain.
size_t alignment = Generation::GenGrain;
// Compute desired new generation size based on NewRatio and
// NewSizeThreadIncrease
size_t desired_new_size = old_size/NewRatio;
int threads_count = Threads::number_of_non_daemon_threads();
size_t thread_increase_size = threads_count * NewSizeThreadIncrease;
desired_new_size = align_size_up(desired_new_size + thread_increase_size, alignment);
// Adjust new generation size
desired_new_size = MAX2(MIN2(desired_new_size, max_new_size), min_new_size);
assert(desired_new_size <= max_new_size, "just checking");
bool changed = false;
if (desired_new_size > new_size_before) {
size_t change = desired_new_size - new_size_before;
assert(change % alignment == 0, "just checking");
if (expand(change)) {
changed = true;
}
// If the heap failed to expand to the desired size,
// "changed" will be false. If the expansion failed
// (and at this point it was expected to succeed),
// ignore the failure (leaving "changed" as false).
}
if (desired_new_size < new_size_before && eden()->is_empty()) {
// bail out of shrinking if objects in eden
size_t change = new_size_before - desired_new_size;
assert(change % alignment == 0, "just checking");
_virtual_space.shrink_by(change);
changed = true;
}
if (changed) {
// The spaces have already been mangled at this point but
// may not have been cleared (set top = bottom) and should be.
// Mangling was done when the heap was being expanded.
compute_space_boundaries(eden()->used(),
SpaceDecorator::Clear,
SpaceDecorator::DontMangle);
MemRegion cmr((HeapWord*)_virtual_space.low(),
(HeapWord*)_virtual_space.high());
Universe::heap()->barrier_set()->resize_covered_region(cmr);
if (Verbose && PrintGC) {
size_t new_size_after = _virtual_space.committed_size();
size_t eden_size_after = eden()->capacity();
size_t survivor_size_after = from()->capacity();
gclog_or_tty->print("New generation size " SIZE_FORMAT "K->"
SIZE_FORMAT "K [eden="
SIZE_FORMAT "K,survivor=" SIZE_FORMAT "K]",
new_size_before/K, new_size_after/K,
eden_size_after/K, survivor_size_after/K);
if (WizardMode) {
gclog_or_tty->print("[allowed " SIZE_FORMAT "K extra for %d threads]",
thread_increase_size/K, threads_count);
}
gclog_or_tty->cr();
}
}
}
void DefNewGeneration::space_iterate(SpaceClosure* blk,
bool usedOnly) {
blk->do_space(eden());
blk->do_space(from());
blk->do_space(to());
}
BindingDemo::BindingDemo( hkDemoEnvironment* env )
: hkDefaultAnimationDemo(env)
{
//
// Setup the camera
//
{
hkVector4 from( 0, -2.5f, 0.0f );
hkVector4 to ( 0,0,0 );
hkVector4 up ( 0,0,1 );
setupDefaultCameras( env, from, to, up );
}
m_loader = new hkLoader();
// Get the rig
{
hkString assetFile = hkAssetManagementUtil::getFilePath("Resources/Animation/HavokGirl/hkRig.hkx");
hkRootLevelContainer* container = m_loader->load( assetFile.cString() );
HK_ASSERT2(0x27343437, container != HK_NULL , "Could not load asset");
hkaAnimationContainer* ac = reinterpret_cast<hkaAnimationContainer*>( container->findObjectByType( hkaAnimationContainerClass.getName() ));
HK_ASSERT2(0x27343435, ac && (ac->m_numSkeletons > 0), "No skeleton loaded");
m_skeleton = ac->m_skeletons[0];
}
// Get the animations and the binding
{
hkString assetFile = hkAssetManagementUtil::getFilePath("Resources/Animation/HavokGirl/hkIdle.hkx");
hkRootLevelContainer* container = m_loader->load( assetFile.cString() );
HK_ASSERT2(0x27343437, container != HK_NULL , "Could not load asset");
hkaAnimationContainer* ac = reinterpret_cast<hkaAnimationContainer*>( container->findObjectByType( hkaAnimationContainerClass.getName() ));
HK_ASSERT2(0x27343435, ac && (ac->m_numAnimations > 0 ), "No animation loaded");
m_animation[0] = ac->m_animations[0];
HK_ASSERT2(0x27343435, ac && (ac->m_numBindings > 0), "No binding loaded");
m_binding[0] = ac->m_bindings[0];
assetFile = hkAssetManagementUtil::getFilePath("Resources/Animation/HavokGirl/hkWaveLoop.hkx");
container = m_loader->load( assetFile.cString() );
ac = reinterpret_cast<hkaAnimationContainer*>( container->findObjectByType( hkaAnimationContainerClass.getName() ));
HK_ASSERT2(0x27343435, ac && (ac->m_numAnimations > 0 ), "No animation loaded");
m_animation[1] = ac->m_animations[0];
HK_ASSERT2(0x27343435, ac && (ac->m_numBindings > 0), "No binding loaded");
m_binding[1] = ac->m_bindings[0];
}
// Create the skeleton
m_skeletonInstance = new hkaAnimatedSkeleton( m_skeleton );
// If the weight on any bone drops below this then it is filled with the T-Pose
m_skeletonInstance->setReferencePoseWeightThreshold(0.1f);
// Grab the animations
for (int i=0; i < NUM_ANIMS; i++)
{
m_control[i] = new hkaDefaultAnimationControl( m_binding[i] );
m_control[i]->setMasterWeight( 0.0f );
m_control[i]->setPlaybackSpeed( 1.0f );
m_skeletonInstance->addAnimationControl( m_control[i] );
m_control[i]->removeReference();
}
// make a world so that we can auto create a display world to hold the skin
setupGraphics( );
}
void DefNewGeneration::compute_space_boundaries(uintx minimum_eden_size,
bool clear_space,
bool mangle_space) {
uintx alignment =
GenCollectedHeap::heap()->collector_policy()->space_alignment();
// If the spaces are being cleared (only done at heap initialization
// currently), the survivor spaces need not be empty.
// Otherwise, no care is taken for used areas in the survivor spaces
// so check.
assert(clear_space || (to()->is_empty() && from()->is_empty()),
"Initialization of the survivor spaces assumes these are empty");
// Compute sizes
uintx size = _virtual_space.committed_size();
uintx survivor_size = compute_survivor_size(size, alignment);
uintx eden_size = size - (2*survivor_size);
assert(eden_size > 0 && survivor_size <= eden_size, "just checking");
if (eden_size < minimum_eden_size) {
// May happen due to 64Kb rounding, if so adjust eden size back up
minimum_eden_size = align_size_up(minimum_eden_size, alignment);
uintx maximum_survivor_size = (size - minimum_eden_size) / 2;
uintx unaligned_survivor_size =
align_size_down(maximum_survivor_size, alignment);
survivor_size = MAX2(unaligned_survivor_size, alignment);
eden_size = size - (2*survivor_size);
assert(eden_size > 0 && survivor_size <= eden_size, "just checking");
assert(eden_size >= minimum_eden_size, "just checking");
}
char *eden_start = _virtual_space.low();
char *from_start = eden_start + eden_size;
char *to_start = from_start + survivor_size;
char *to_end = to_start + survivor_size;
assert(to_end == _virtual_space.high(), "just checking");
assert(Space::is_aligned((HeapWord*)eden_start), "checking alignment");
assert(Space::is_aligned((HeapWord*)from_start), "checking alignment");
assert(Space::is_aligned((HeapWord*)to_start), "checking alignment");
MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)from_start);
MemRegion fromMR((HeapWord*)from_start, (HeapWord*)to_start);
MemRegion toMR ((HeapWord*)to_start, (HeapWord*)to_end);
// A minimum eden size implies that there is a part of eden that
// is being used and that affects the initialization of any
// newly formed eden.
bool live_in_eden = minimum_eden_size > 0;
// If not clearing the spaces, do some checking to verify that
// the space are already mangled.
if (!clear_space) {
// Must check mangling before the spaces are reshaped. Otherwise,
// the bottom or end of one space may have moved into another
// a failure of the check may not correctly indicate which space
// is not properly mangled.
if (ZapUnusedHeapArea) {
HeapWord* limit = (HeapWord*) _virtual_space.high();
eden()->check_mangled_unused_area(limit);
from()->check_mangled_unused_area(limit);
to()->check_mangled_unused_area(limit);
}
}
// Reset the spaces for their new regions.
eden()->initialize(edenMR,
clear_space && !live_in_eden,
SpaceDecorator::Mangle);
// If clear_space and live_in_eden, we will not have cleared any
// portion of eden above its top. This can cause newly
// expanded space not to be mangled if using ZapUnusedHeapArea.
// We explicitly do such mangling here.
if (ZapUnusedHeapArea && clear_space && live_in_eden && mangle_space) {
eden()->mangle_unused_area();
}
from()->initialize(fromMR, clear_space, mangle_space);
to()->initialize(toMR, clear_space, mangle_space);
// Set next compaction spaces.
eden()->set_next_compaction_space(from());
// The to-space is normally empty before a compaction so need
// not be considered. The exception is during promotion
// failure handling when to-space can contain live objects.
from()->set_next_compaction_space(NULL);
}
CollisionEventsDemo::CollisionEventsDemo( hkDemoEnvironment* env)
: hkDefaultPhysicsDemo(env)
{
//
// Setup the camera
//
{
hkVector4 from(3.0f, 4.0f, 8.0f);
hkVector4 to(0.0f, 1.0f, 0.0f);
hkVector4 up(0.0f, 1.0f, 0.0f);
setupDefaultCameras( env, from, to, up );
}
//
// Create the world
//
{
hkpWorldCinfo info;
info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM);
info.setBroadPhaseWorldSize( 100.0f );
info.m_simulationType = info.SIMULATION_TYPE_CONTINUOUS;
// Turn off deactivation so we can see continuous contact point processing
info.m_enableDeactivation = false;
m_world = new hkpWorld( info );
m_world->lock();
setupGraphics();
}
//
// Register the box-box collision agent
//
{
hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher());
}
//
// Create the floor
//
{
hkpRigidBodyCinfo info;
hkVector4 fixedBoxSize(5.0f, 0.5f , 5.0f );
hkpBoxShape* fixedBoxShape = new hkpBoxShape( fixedBoxSize , 0 );
info.m_shape = fixedBoxShape;
info.m_motionType = hkpMotion::MOTION_FIXED;
info.m_position.setZero4();
// Add some bounce.
info.m_restitution = 0.8f;
info.m_friction = 1.0f;
// Create fixed box
hkpRigidBody* floor = new hkpRigidBody(info);
m_world->addEntity(floor);
floor->removeReference();
fixedBoxShape->removeReference();
}
// For this demo we simply have two box shapes which are constructed in the usual manner using a hkpRigidBodyCinfo 'blueprint'.
// The dynamic box creation code in presented below. There are two key things to note in this example;
// the 'm_restitution' member variable, which we have explicitly set to value of 0.9.
// The restitution is over twice the default value of
// 0.4 and is set to give the box (the floor has been set likewise) a more 'bouncy' nature.
//
// Create a moving box
//
{
hkpRigidBodyCinfo boxInfo;
hkVector4 boxSize( .5f, .5f ,.5f );
boxInfo.m_shape = new hkpBoxShape( boxSize , 0 );
// Compute the box inertia tensor
hkpInertiaTensorComputer::setShapeVolumeMassProperties( boxInfo.m_shape, 1.0f, boxInfo );
boxInfo.m_qualityType = HK_COLLIDABLE_QUALITY_DEBRIS;
boxInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
// Place the box so it bounces interestingly
boxInfo.m_position.set(0.0f, 5.0f, 0.0f);
hkVector4 axis(1.0f, 2.0f, 3.0f);
axis.normalize3();
boxInfo.m_rotation.setAxisAngle(axis, -0.7f);
// Add some bounce.
boxInfo.m_restitution = 0.5f;
boxInfo.m_friction = 0.1f;
hkpRigidBody* boxRigidBody = new hkpRigidBody( boxInfo );
// remove reference from boxShape since rigid body "owns" it
boxInfo.m_shape->removeReference();
m_world->addEntity( boxRigidBody );
boxRigidBody->removeReference();
// Add the collision event listener to the rigid body
MyCollisionListener* listener = new MyCollisionListener( boxRigidBody );
listener->m_reportLevel = m_env->m_reportingLevel;
}
m_world->unlock();
}
void monster::knock_back_from(int x, int y)
{
if (x == posx() && y == posy())
return; // No effect
point to(posx(), posy());
if (x < posx())
to.x++;
if (x > posx())
to.x--;
if (y < posy())
to.y++;
if (y > posy())
to.y--;
bool u_see = g->u_see(to.x, to.y);
// First, see if we hit another monster
int mondex = g->mon_at(to.x, to.y);
if (mondex != -1) {
monster *z = &(g->zombie(mondex));
apply_damage( z, bp_torso, z->type->size );
add_effect("stunned", 1);
if (type->size > 1 + z->type->size) {
z->knock_back_from(posx(), posy()); // Chain reaction!
z->apply_damage( this, bp_torso, type->size );
z->add_effect("stunned", 1);
} else if (type->size > z->type->size) {
z->apply_damage( this, bp_torso, type->size );
z->add_effect("stunned", 1);
}
if (u_see)
add_msg(_("The %s bounces off a %s!"), name().c_str(), z->name().c_str());
return;
}
int npcdex = g->npc_at(to.x, to.y);
if (npcdex != -1) {
npc *p = g->active_npc[npcdex];
apply_damage( p, bp_torso, 3 );
add_effect("stunned", 1);
p->deal_damage( this, bp_torso, damage_instance( DT_BASH, type->size ) );
if (u_see)
add_msg(_("The %s bounces off %s!"), name().c_str(), p->name.c_str());
return;
}
// If we're still in the function at this point, we're actually moving a tile!
if (g->m.ter_at(to.x, to.y).has_flag(TFLAG_DEEP_WATER)) {
if (g->m.has_flag("LIQUID", to.x, to.y) && can_drown()) {
die( nullptr );
if (u_see) {
add_msg(_("The %s drowns!"), name().c_str());
}
} else if (has_flag(MF_AQUATIC)) { // We swim but we're NOT in water
die( nullptr );
if (u_see) {
add_msg(_("The %s flops around and dies!"), name().c_str());
}
}
}
if (g->m.move_cost(to.x, to.y) == 0) {
// It's some kind of wall.
apply_damage( nullptr, bp_torso, type->size );
add_effect("stunned", 2);
if (u_see) {
add_msg(_("The %s bounces off a %s."), name().c_str(),
g->m.tername(to.x, to.y).c_str());
}
} else { // It's no wall
setpos(to);
}
}
ProcessResult IqRouter::route(mtalk::talk::SessionPtr sessionPtr, const pugi::xml_node& node){
std::string toStr = node.attribute("to").value();
std::string fromStr = node.attribute("from").value();
JID to(toStr);
JID from(fromStr);
if(to.getEndpoint() == "muc.m.renren.com"){
long fromid = from.getUserId();
string sessionid = sessionPtr->getSessionId();
stringstream ss;
node.print(ss,"\t",pugi::format_raw);
string message=ss.str();
bool forward = MY_INSTANCE(ProxyRegister).getProxy<MucServiceProxy>("mucProxy")->forwardIq(fromid,sessionid,message); //推给muc服务器
// 如果forward成功，返回ok，否则返回error
if(forward){
ProcessResult result(ProcessResult::OK, "<success/>");
return result;
}else {
ProcessResult result(ProcessResult::ERROR, "forward muc fail");
return result;
}
}
//单聊信息
if(to.getEndpoint() == "talk.sixin.com" || to.getEndpoint() == "renren.sixin.com" || to.getEndpoint() == "talk.m.renren.com" ||to.getEndpoint() ==""){
if(node.child("msgType")){
return msgTypeHandlerPtr_->handler(sessionPtr, node);
}
stringstream os;
node.print(os,"\t",pugi::format_raw);
MY_INSTANCE(TalkServer).remotePush(from.getUserId(), to.getUserId(), os.str(), MessageType::ENTITY);
ProcessResult result;
return result;
} else {
long fromid = from.getUserId();
long toid = to.getUserId();
//string sessionid = sessionPtr->getSessionId();
stringstream ss;
node.print(ss,"\t",pugi::format_raw);
string message=ss.str();
string router=to.getRouter();
LOG_DEBUG("IqRoute::route forward "<< router<<"iq msg = "<<message);
router.append("ServiceProxy");
ProcessResult result;
bool forward = 0;
if(MY_INSTANCE(ProxyRegister).getProxy<RouterServiceProxy>(router).get()!=0){
LOG_DEBUG("IqRoute::get RouterServiceProxy and forward"<<router<<" iq msg = "<<message);
forward = MY_INSTANCE(ProxyRegister).getProxy<RouterServiceProxy>(router)->forwardIq(fromid,toid,message);
}
// 如果forward成功，返回ok，否则返回error
string id = node.attribute("id").value();
string type=node.attribute("type").value();
if(forward){
result.setCode(ProcessResult::OK);
stringstream ss;
ss<<"<success id='";
ss<<id;
ss << "' from='";
ss << from.toString();
ss << "' to='";
ss << to.toString();
ss<<"' type='";
ss<<type;
ss<<"'/>";
result.setMsg(ss.str());
return result;
}else {
ProcessResult result(ProcessResult::ERROR);
stringstream s;
s<<"<error id='";
s<<id;
s<<"'>fail to ";
s<<to.getEndpoint();
s<<" error</error>";
result.setMsg(s.str());
result.setMsg("<error>talk internal error</error>");
return result;
}
}
}
AdditiveBlendingDemo::AdditiveBlendingDemo( hkDemoEnvironment* env )
: hkDefaultAnimationDemo(env)
{
// Disable warnings: if no renderer
if( hkString::strCmp( m_env->m_options->m_renderer, "n" ) == 0 )
{
hkError::getInstance().setEnabled(0xf0d1e423, false); //'Could not realize an inplace texture of type PNG.'
}
//
// Setup the camera
//
{
hkVector4 from( 0.3f, -1, 1 );
hkVector4 to ( 0, 0, 0.5f );
hkVector4 up ( 0.0f, 0.0f, 1.0f );
setupDefaultCameras( env, from, to, up, 0.1f, 100 );
}
m_loader = new hkLoader();
// Convert the scene
{
hkString assetFile = hkAssetManagementUtil::getFilePath("Resources/Animation/Scene/hkScene.hkx");
hkRootLevelContainer* container = m_loader->load( assetFile.cString() );
HK_ASSERT2(0x27343437, container != HK_NULL , "Could not load asset");
hkxScene* scene = reinterpret_cast<hkxScene*>( container->findObjectByType( hkxSceneClass.getName() ));
HK_ASSERT2(0x27343635, scene, "No scene loaded");
removeLights(m_env);
env->m_sceneConverter->convert( scene );
}
// Get the rig
{
hkString assetFile = hkAssetManagementUtil::getFilePath("Resources/Animation/HavokGirl/hkRig.hkx");
hkRootLevelContainer* container = m_loader->load( assetFile.cString() );
HK_ASSERT2(0x27343437, container != HK_NULL , "Could not load asset");
hkaAnimationContainer* ac = reinterpret_cast<hkaAnimationContainer*>( container->findObjectByType( hkaAnimationContainerClass.getName() ));
HK_ASSERT2(0x27343435, ac && (ac->m_numSkeletons > 0), "No skeleton loaded");
m_skeleton = ac->m_skeletons[0];
}
// Get the animations and the binding
{
hkString assetFile = hkAssetManagementUtil::getFilePath("Resources/Animation/HavokGirl/hkWalkLoop.hkx");
hkRootLevelContainer* container = m_loader->load( assetFile.cString() );
HK_ASSERT2(0x27343437, container != HK_NULL , "Could not load asset");
hkaAnimationContainer* ac = reinterpret_cast<hkaAnimationContainer*>( container->findObjectByType( hkaAnimationContainerClass.getName() ));
HK_ASSERT2(0x27343435, ac && (ac->m_numAnimations > 0 ), "No animation loaded");
m_animation[HK_WALK_ANIM] = ac->m_animations[0];
HK_ASSERT2(0x27343435, ac && (ac->m_numBindings > 0), "No binding loaded");
m_binding[HK_WALK_ANIM] = ac->m_bindings[0];
assetFile = hkAssetManagementUtil::getFilePath("Resources/Animation/HavokGirl/hkHeadMovement.hkx");
container = m_loader->load( assetFile.cString() );
ac = reinterpret_cast<hkaAnimationContainer*>( container->findObjectByType( hkaAnimationContainerClass.getName() ));
HK_ASSERT2(0x27343435, ac && (ac->m_numAnimations > 0 ), "No animation loaded");
m_animation[HK_ADDITIVE_ANIM] = ac->m_animations[0];
HK_ASSERT2(0x27343435, ac && (ac->m_numBindings > 0), "No binding loaded");
m_binding[HK_ADDITIVE_ANIM] = ac->m_bindings[0];
}
// Create an additive animation
// This can also be done offline in the toolchain using the CreateAdditiveAnimation filter
// See the Additive configuration of hkHeadMovement.max
{
hkaInterleavedUncompressedAnimation* interleavedAnim = static_cast< hkaInterleavedUncompressedAnimation* >(m_animation[ HK_ADDITIVE_ANIM ]);
hkaAdditiveAnimationUtility::Input input;
input.m_originalData = interleavedAnim->m_transforms;
input.m_numberOfPoses = interleavedAnim->m_numTransforms / interleavedAnim->m_numberOfTransformTracks;
input.m_numberOfTransformTracks = interleavedAnim->m_numberOfTransformTracks;
input.m_baseData = interleavedAnim->m_transforms;
// We create an additive animation by subtracting off the iniital pose for the first frame of the animation
// This is done by passing the same animation for both the originalData and the baseData
// Note that only the first frame of the basedata is used so this initial frame is subtracted
// from each of the frames in the animation
hkaAdditiveAnimationUtility::createAdditiveFromPose( input, interleavedAnim->m_transforms );
// Switch the binding to additive so this animation will be blended differently in sample and combine.
m_binding[HK_ADDITIVE_ANIM]->m_blendHint = hkaAnimationBinding::ADDITIVE;
}
// Convert the skin
{
const char* skinFile = "Resources/Animation/HavokGirl/hkLowResSkinWithEyes.hkx";
hkString assetFile = hkAssetManagementUtil::getFilePath( skinFile );
hkRootLevelContainer* container = m_loader->load( assetFile.cString() );
HK_ASSERT2(0x27343437, container != HK_NULL , "Could not load asset");
hkxScene* scene = reinterpret_cast<hkxScene*>( container->findObjectByType( hkxSceneClass.getName() ));
HK_ASSERT2(0x27343435, scene , "No scene loaded");
hkaAnimationContainer* ac = reinterpret_cast<hkaAnimationContainer*>( container->findObjectByType( hkaAnimationContainerClass.getName() ));
HK_ASSERT2(0x27343435, ac && (ac->m_numSkins > 0), "No animation loaded");
m_numSkinBindings = ac->m_numSkins;
m_skinBindings = ac->m_skins;
m_numAttachments = ac->m_numAttachments;
m_attachments = ac->m_attachments;
// Make graphics output buffers for the skins
env->m_sceneConverter->convert( scene );
for (int a=0; a < m_numAttachments; ++a)
{
hkaBoneAttachment* ba = m_attachments[a];
hkgDisplayObject* hkgObject = HK_NULL;
//Check the attachment is a mesh
if ( hkString::strCmp(ba->m_attachment.m_class->getName(), hkxMeshClass.getName()) == 0)
{
hkgObject = env->m_sceneConverter->findFirstDisplayObjectUsingMesh((hkxMesh*)ba->m_attachment.m_object);
if (hkgObject)
{
hkgObject->setStatusFlags( hkgObject->getStatusFlags() | HKG_DISPLAY_OBJECT_DYNAMIC);
}
}
m_attachmentObjects.pushBack(hkgObject);
}
}
// Create the animated skeleton
m_skeletonInstance = new hkaAnimatedSkeleton( m_skeleton );
// Set the fill threshold
m_skeletonInstance->setReferencePoseWeightThreshold( 0.05f );
// Grab the animations and build controls
for (int i=0; i < NUM_ANIMS; i++)
{
m_control[i] = new hkaDefaultAnimationControl( m_binding[i] );
m_control[i]->setMasterWeight( 1.0f );
m_control[i]->setPlaybackSpeed( 1.0f );
m_skeletonInstance->addAnimationControl( m_control[i] );
m_control[i]->removeReference();
}
// We initially turn the additive animation off and allow the user to ramp it in
m_control[HK_ADDITIVE_ANIM]->setMasterWeight( 0.0f );
m_control[HK_ADDITIVE_ANIM]->setPlaybackSpeed( 1.0f );
setupGraphics( );
}
SimpleShapesDemo::SimpleShapesDemo(hkDemoEnvironment* env)
: hkDefaultPhysicsDemo(env)
{
const ShapeVariant& variant = g_variants[m_variantId];
// Setup the camera.
{
hkVector4 from(0.0f, 5.0f, 10.0f);
hkVector4 to (0.0f, 0.0f, 0.0f);
hkVector4 up (0.0f, 1.0f, 0.0f);
setupDefaultCameras(env, from, to, up);
}
// Create the world, setting gravity to zero so body floats.
hkpWorldCinfo info;
info.m_gravity.set(0.0f, 0.0f, 0.0f);
info.setBroadPhaseWorldSize( 100.0f );
m_world = new hkpWorld(info);
m_world->lock();
setupGraphics();
// Create the shape variant
hkpShape* shape = 0;
switch (variant.m_shapeType)
{
// Box
case HK_SHAPE_BOX:
{
// Data specific to this shape.
hkVector4 halfExtents(1.0f, 1.0f, 1.0f);
/////////////////// SHAPE CONSTRUCTION ////////////////
shape = new hkpBoxShape(halfExtents, 0 );
break;
}
// Sphere
case HK_SHAPE_SPHERE:
{
// The box is of side 2, so we must bound it by a sphere of radius >= sqrt(3)
hkReal radius = 1.75f;
/////////////////// SHAPE CONSTRUCTION ////////////////
shape = new hkpSphereShape(radius);
break;
}
// Triangle
case HK_SHAPE_TRIANGLE:
{
// Disable face culling
setGraphicsState(HKG_ENABLED_CULLFACE, false);
float vertices[] = {
-0.5f, -0.5f, 0.0f, 0.0f, // v0
0.5f, -0.5f, 0.0f, 0.0f, // v1
0.0f, 0.5f, 0.0f, 0.0f, // v2
};
/////////////////// SHAPE CONSTRUCTION ////////////////
shape = new hkpTriangleShape();
int index = 0;
for (int i = 0; i < 3; i++)
{
static_cast<hkpTriangleShape*>(shape)->setVertex(i, hkVector4(vertices[index], vertices[index + 1], vertices[index + 2]));
index = index + 4;
}
break;
}
// Capsule
case HK_SHAPE_CAPSULE:
{
hkReal radius = 1.5f;
hkVector4 top(0.0f, 1.5f, 0.0f);
hkVector4 bottom(0.0f, -1.0f, 0.0f);
/////////////////// SHAPE CONSTRUCTION ////////////////
shape = new hkpCapsuleShape(top, bottom, radius);
break;
}
// Cylinder
case HK_SHAPE_CYLINDER:
{
hkReal radius = 1.5f;
hkVector4 top(0.0f, 1.5f, 0.0f);
hkVector4 bottom(0.0f, -1.0f, 0.0f);
/////////////////// SHAPE CONSTRUCTION ////////////////
shape = new hkpCylinderShape(top, bottom, radius);
break;
}
// Convex vertices
case HK_SHAPE_CONVEX_VERTICES:
{
// Data specific to this shape.
int numVertices = 4;
// 16 = 4 (size of "each float group", 3 for x,y,z, 1 for padding) * 4 (size of float)
int stride = sizeof(float) * 4;
float vertices[] = { // 4 vertices plus padding
-2.0f, 2.0f, 1.0f, 0.0f, // v0
1.0f, 3.0f, 0.0f, 0.0f, // v1
0.0f, 1.0f, 3.0f, 0.0f, // v2
1.0f, 0.0f, 0.0f, 0.0f // v3
};
/////////////////// SHAPE CONSTRUCTION ////////////////
hkStridedVertices stridedVerts;
{
stridedVerts.m_numVertices = numVertices;
stridedVerts.m_striding = stride;
stridedVerts.m_vertices = vertices;
}
shape = new hkpConvexVerticesShape(stridedVerts);
break;
}
default:
break;
}
// Make sure that a shape was created
HK_ASSERT(0, shape);
// To illustrate using the shape, first define a rigid body template.
hkpRigidBodyCinfo rigidBodyInfo;
rigidBodyInfo.m_position.set(0.0f, 0.0f, 0.0f);
rigidBodyInfo.m_angularDamping = 0.0f;
rigidBodyInfo.m_linearDamping = 0.0f;
rigidBodyInfo.m_shape = shape;
// Compute the rigid body inertia.
rigidBodyInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
hkpInertiaTensorComputer::setShapeVolumeMassProperties( rigidBodyInfo.m_shape, 100.0f, rigidBodyInfo );
// Create a rigid body (using the template above).
hkpRigidBody* rigidBody = new hkpRigidBody(rigidBodyInfo);
// Remove reference since the body now "owns" the Shape.
shape->removeReference();
// Finally add body so we can see it, and remove reference since the world now "owns" it.
m_world->addEntity(rigidBody);
rigidBody->removeReference();
m_world->unlock();
}
void HistoryConfig::copy()
{
int cur = cmbStyle->currentItem();
if ((cur < 0) || (!m_styles.size()))
return;
QString name = m_styles[cur].name;
QString newName;
QRegExp re("\\.[0-9]+$");
unsigned next = 0;
for (vector<StyleDef>::iterator it = m_styles.begin(); it != m_styles.end(); ++it){
QString nn = (*it).name;
int n = nn.find(re);
if (n < 0)
continue;
nn = nn.mid(n + 1);
next = QMAX(next, nn.toUInt());
}
int nn = name.find(re);
if (nn >= 0){
newName = name.left(nn);
}else{
newName = name;
}
newName += ".";
newName += QString::number(next + 1);
string n;
n = STYLES;
n += QFile::encodeName(name);
n += EXT;
if (m_styles[cur].bCustom){
n = user_file(n.c_str());
}else{
n = app_file(n.c_str());
}
QFile from(QFile::decodeName(n.c_str()));
if (!from.open(IO_ReadOnly)){
log(L_WARN, "Can't open %s", n.c_str());
return;
}
n = STYLES;
n += QFile::encodeName(newName);
n += EXT;
n = user_file(n.c_str());
QFile to(QFile::decodeName((n + BACKUP_SUFFIX).c_str()));
if (!to.open(IO_WriteOnly | IO_Truncate)){
log(L_WARN, "Cam't create %s", n.c_str());
return;
}
string s;
s.append(from.size(), '\x00');
from.readBlock((char*)(s.c_str()), from.size());
to.writeBlock(s.c_str(), s.length());
from.close();
const int status = to.status();
#if COMPAT_QT_VERSION >= 0x030200
const QString errorMessage = to.errorString();
#else
const QString errorMessage = "write file fail";
#endif
to.close();
if (status != IO_Ok) {
log(L_ERROR, "IO error during writting to file %s : %s", (const char*)to.name().local8Bit(), (const char*)errorMessage.local8Bit());
return;
}
// rename to normal file
QFileInfo fileInfo(to.name());
QString desiredFileName = fileInfo.fileName();
desiredFileName = desiredFileName.left(desiredFileName.length() - strlen(BACKUP_SUFFIX));
#ifdef WIN32
fileInfo.dir().remove(desiredFileName);
#endif
if (!fileInfo.dir().rename(fileInfo.fileName(), desiredFileName)) {
log(L_ERROR, "Can't rename file %s to %s", (const char*)fileInfo.fileName().local8Bit(), (const char*)desiredFileName.local8Bit());
return;
}
s = "";
StyleDef d;
d.name = newName;
d.bCustom = true;
m_styles.push_back(d);
fillCombo(QFile::encodeName(newName));
}
Finder::Impl::Impl() : helper(funcs) {
const auto funcDecl = functionDecl().bind("func");
matchFinder.addMatcher(funcDecl, &helper);
const auto funcRef = declRefExpr(to(functionDecl())).bind("ref");
matchFinder.addMatcher(funcRef, &helper);
}
BreakOffPartsAndSpuDemo::BreakOffPartsAndSpuDemo(hkDemoEnvironment* env)
: hkDefaultPhysicsDemo(env)
{
m_list0 = m_list1 = HK_NULL;
m_debugViewerNames.pushBack( hkpMidphaseViewer::getName() );
m_bootstrapIterations = 150;
const BreakOffPartsAndSpuVariant& variant = g_variants[m_variantId];
//
// Setup the camera
//
{
hkVector4 from(0.0f, 35.0f, -50.0f);
hkVector4 to (0.0f, 0.0f, 0.0f);
hkVector4 up (0.0f, 1.0f, 0.0f);
setupDefaultCameras( env, from, to, up );
}
//
// Create the world
//
{
hkpWorldCinfo info;
info.m_gravity.set(0.0f, -9.8f, 0.0f);
if ( variant.m_type == BREAK_OFF_PARTS_DEMO_COLLISION_RESPONSE)
{
info.m_contactRestingVelocity = 0.5f;
}
m_world = new hkpWorld( info );
m_world->lock();
hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher());
setupGraphics();
}
//
// Create the break off utility
//
{
m_breakUtil = new hkpBreakOffPartsUtil( m_world, this );
}
// Create ground
//
{
hkVector4 size (100.0f, 1.0f, 100.0f);
hkReal mass = 0.0f;
hkVector4 position (0.0f, -0.5f, 0.0f);
hkpRigidBody* ground = GameUtils::createBox(size, mass, position);
m_world->addEntity(ground);
ground->removeReference();
}
// Create two big shapes
//
{
hkVector4 size(0.5f, 0.5f, 0.5f);
hkReal radius = 0.02f;
hkReal dist = size(0)*2.0f + radius + 0.1f;
hkArray<hkpConvexShape*> shapes; shapes.reserve(400);
{
hkpBoxShape* terminal = new hkpBoxShape(size, radius);
int dim = 20;
for (int i = 0; i < dim; i++)
{
for (int j = (i+1)%2; j < dim; j+=2)
{
hkTransform transform = hkTransform::getIdentity();
hkReal offset = (hkReal(dim)-1.0f)*-0.5f;
transform.setTranslation(hkVector4( (offset+hkReal(i))*dist, (offset+hkReal(j))*dist, 0.0f));
hkpConvexTransformShape* cts = new hkpConvexTransformShape(terminal, transform);
shapes.pushBack(cts);
}
}
terminal->removeReference();
}
// Create new list/mesh shape
//
hkpShapeCollection* collectionShape0;
hkpShapeCollection* collectionShape1;
if (!variant.m_useMeshCollection)
{
collectionShape0 = m_list0 = new hkpListShape(reinterpret_cast<hkpShape**>(static_cast<hkpConvexShape**>(shapes.begin())), shapes.getSize());
collectionShape1 = m_list1 = new hkpListShape(reinterpret_cast<hkpShape**>(static_cast<hkpConvexShape**>(shapes.begin())), shapes.getSize());
if (variant.m_extraListInHierarchy)
{
collectionShape0 = new hkpListShape((hkpShape**)&collectionShape0, 1);
collectionShape1 = new hkpListShape((hkpShape**)&collectionShape1, 1);
m_list0->removeReference();
m_list1->removeReference();
}
}
else
{
// This is a share shape because it's not destructible
hkpExtendedMeshShape* meshShape = new hkpExtendedMeshShape(radius);
collectionShape0 = meshShape;
collectionShape1 = meshShape;
hkpExtendedMeshShape::ShapesSubpart part(shapes.begin(), shapes.getSize());
meshShape->addShapesSubpart(part);
// Add a reference to meshShape.
// collectionShape0 and collectionShape1 both reference it, which means there has to be a second reference to remove later.
meshShape->addReference();
}
hkReferencedObject::removeReferences(shapes.begin(), shapes.getSize());
// Wrap it with a mopp
//
hkpShape* finalShape0 = collectionShape0;
hkpShape* finalShape1 = collectionShape1;
if (variant.m_useMopp)
{
hkpMoppCompilerInput mci;
mci.m_enableChunkSubdivision = true;
hkpMoppCode* code0 = hkpMoppUtility::buildCode( collectionShape0->getContainer(),mci);
hkpMoppCode* code1 = hkpMoppUtility::buildCode( collectionShape1->getContainer(),mci);
finalShape0 = new hkpMoppBvTreeShape( collectionShape0, code0 );
finalShape1 = new hkpMoppBvTreeShape( collectionShape1, code1 );
code0->removeReference();
code1->removeReference();
collectionShape0->removeReference();
collectionShape1->removeReference();
}
// finally add create two bodies with the shape
//
{
hkpRigidBodyCinfo info;
info.m_shape = finalShape0;
hkpInertiaTensorComputer::setShapeVolumeMassProperties(finalShape0, 10.0f, info);
info.m_motionType = hkpMotion::MOTION_DYNAMIC;
info.m_numUserDatasInContactPointProperties = 1;
info.m_position.set(0.0f, 15.0f, 0.0f);
m_body0 = new hkpRigidBody(info);
info.m_rotation.setAxisAngle(hkVector4(0.0f,1.0f, 0.0f), 90.0f * HK_REAL_DEG_TO_RAD);
info.m_position(0) += dist;
info.m_shape = finalShape1;
if (variant.m_fixOneBody)
{
info.m_motionType = hkpMotion::MOTION_FIXED;
}
m_body1 = new hkpRigidBody(info);
finalShape0->removeReference();
finalShape1->removeReference();
m_world->addEntity(m_body0);
m_world->addEntity(m_body1);
}
}
// Mark bodies breakable
//
if (variant.m_useMeshCollection != 1 && variant.m_extraListInHierarchy != 1)
{
m_breakUtil->markEntityBreakable(m_body0, 1.0f);
m_breakUtil->markEntityBreakable(m_body1, 1.0f);
}
m_world->unlock();
}
void NGLScene::initializeGL()
{
// we must call this first before any other GL commands to load and link the
// gl commands from the lib, if this is not done program will crash
ngl::NGLInit::instance();
// Now we will create a basic Camera from the graphics library
// This is a static camera so it only needs to be set once
// First create Values for the camera position
ngl::Vec3 from(0.0f,2.0f,5.0f);
ngl::Vec3 to(0.0f,0.0f,0.0f);
ngl::Vec3 up(0.0f,1.0f,0.0f);
// now load to our new camera
m_cam.set(from,to,up);
// set the shape using FOV 45 Aspect Ratio based on Width and Height
// The final two are near and far clipping planes of 0.5 and 10
m_cam.setShape(45.0f,(float)float(width()/height()),0.05f,350.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Grey Background
// enable depth testing for drawing
glEnable(GL_DEPTH_TEST);
// enable multisampling for smoother drawing
glEnable(GL_MULTISAMPLE);
// now to load the shader and set the values
// grab an instance of shader manager
ngl::ShaderLib *shader=ngl::ShaderLib::instance();
// we are creating a shader for Pass 1
shader->createShaderProgram("Pass1");
// now we are going to create empty shaders for Frag and Vert
shader->attachShader("Pass1Vertex",ngl::ShaderType::VERTEX);
shader->attachShader("Pass1Fragment",ngl::ShaderType::FRAGMENT);
// attach the source
shader->loadShaderSource("Pass1Vertex","shaders/Pass1Vert.glsl");
shader->loadShaderSource("Pass1Fragment","shaders/Pass1Frag.glsl");
// compile the shaders
shader->compileShader("Pass1Vertex");
shader->compileShader("Pass1Fragment");
// add them to the program
shader->attachShaderToProgram("Pass1","Pass1Vertex");
shader->attachShaderToProgram("Pass1","Pass1Fragment");
// shader->bindFragDataLocation("Pass1",0,"pointDeferred");
// shader->bindFragDataLocation("Pass1",1,"normalDeferred");
// shader->bindFragDataLocation("Pass1",2,"colourDeferred");
// shader->bindFragDataLocation("Pass1",3,"shadingDeferred");
shader->linkProgramObject("Pass1");
shader->use("Pass1");
// we are creating a shader for Pass 2
shader->createShaderProgram("Pass2");
// now we are going to create empty shaders for Frag and Vert
shader->attachShader("Pass2Vertex",ngl::ShaderType::VERTEX);
shader->attachShader("Pass2Fragment",ngl::ShaderType::FRAGMENT);
// attach the source
shader->loadShaderSource("Pass2Vertex","shaders/Pass2Vert.glsl");
shader->loadShaderSource("Pass2Fragment","shaders/Pass2Frag.glsl");
// compile the shaders
shader->compileShader("Pass2Vertex");
shader->compileShader("Pass2Fragment");
// add them to the program
shader->attachShaderToProgram("Pass2","Pass2Vertex");
shader->attachShaderToProgram("Pass2","Pass2Fragment");
shader->linkProgramObject("Pass2");
shader->use("Pass2");
shader->setShaderParam1i("pointTex",0);
shader->setShaderParam1i("normalTex",1);
shader->setShaderParam1i("colourTex",2);
shader->setShaderParam1i("lightPassTex",3);
shader->setShaderParam1i("diffusePassTex",4);
// we are creating a shader for Debug pass
shader->createShaderProgram("Debug");
// now we are going to create empty shaders for Frag and Vert
shader->attachShader("DebugVertex",ngl::ShaderType::VERTEX);
shader->attachShader("DebugFragment",ngl::ShaderType::FRAGMENT);
// attach the source
shader->loadShaderSource("DebugVertex","shaders/DebugVert.glsl");
shader->loadShaderSource("DebugFragment","shaders/DebugFrag.glsl");
// compile the shaders
shader->compileShader("DebugVertex");
shader->compileShader("DebugFragment");
// add them to the program
shader->attachShaderToProgram("Debug","DebugVertex");
shader->attachShaderToProgram("Debug","DebugFragment");
shader->linkProgramObject("Debug");
shader->use("Debug");
shader->setShaderParam1i("pointTex",0);
shader->setShaderParam1i("normalTex",1);
shader->setShaderParam1i("colourTex",2);
shader->setShaderParam1i("lightPassTex",3);
shader->setShaderParam1i("diffusePassTex",4);
shader->setRegisteredUniform1i("mode",1);
// we are creating a shader for Lighting pass
shader->createShaderProgram("Lighting");
// now we are going to create empty shaders for Frag and Vert
shader->attachShader("LightingVertex",ngl::ShaderType::VERTEX);
shader->attachShader("LightingFragment",ngl::ShaderType::FRAGMENT);
// attach the source
shader->loadShaderSource("LightingVertex","shaders/LightingPassVert.glsl");
shader->loadShaderSource("LightingFragment","shaders/LightingPassFrag.glsl");
// compile the shaders
shader->compileShader("LightingVertex");
shader->compileShader("LightingFragment");
// add them to the program
shader->attachShaderToProgram("Lighting","LightingVertex");
shader->attachShaderToProgram("Lighting","LightingFragment");
shader->linkProgramObject("Lighting");
shader->use("Lighting");
shader->setShaderParam1i("pointTex",0);
shader->setShaderParam1i("normalTex",1);
shader->setShaderParam1i("colourTex",2);
shader->setShaderParam1i("lightPassTex",3);
shader->setShaderParam2f("wh",width()*devicePixelRatio(),height()*devicePixelRatio());
m_text.reset(new ngl::Text(QFont("Arial",14)));
m_text->setScreenSize(width(),height());
m_screenQuad = new ScreenQuad("Debug");
ngl::VAOPrimitives *prim=ngl::VAOPrimitives::instance();
prim->createSphere("sphere",0.5f,50.0f);
prim->createSphere("lightSphere",0.1f,10.0f);
prim->createCylinder("cylinder",0.5f,1.4f,40.0f,40.0f);
prim->createCone("cone",0.5f,1.4f,20.0f,20.0f);
prim->createDisk("disk",0.8f,120.0f);
prim->createTorus("torus",0.15f,0.4f,40.0f,40.0f);
prim->createTrianglePlane("plane",14.0f,14.0f,80.0f,80.0f,ngl::Vec3(0.0f,1.0f,0.0f));
createFrameBuffer();
printFrameBufferInfo(m_gbuffer);
printFrameBufferInfo(m_lightBuffer);
m_fpsTimer =startTimer(0);
}
