Game Development Community

GuiObjectView, guiPlayerView

by Claude-Alain Fournier · in Torque Game Engine Advanced · 03/02/2007 (4:18 am) · 64 replies

Hi all,

No I don't have a solution. I am restarting this discussion because that's one of the last problem we have in our project after port from TGE to TGEA.

We had this working in a previous TSE release (before MSE 3.5) then after that it does not work and sofar I could not find any one who could make it work.

So I have 2 questions here :

1) Is GG planning to make one of these 2 class work in TGEA one day ? if yes, when (approx...)

2) Is anyone in the GG community who have one of these class working with latest TGEA release ?
If yes, would you care releasing this as a ressource. If not, please contact me to see if we can find an agreement either financial or with code/art exchange.

Thanks in advance.

CAF
Page «Previous 1 2 3 4 Last »
#1
03/03/2007 (11:47 am)
I co-sign on #2
#2
03/07/2007 (3:22 am)
I also need this :-/
#3
03/07/2007 (4:00 am)
I might have a resource coming up for this in the next few weeks, depending on other projects.
#4
03/07/2007 (6:31 am)
Nice...
#6
03/12/2007 (10:06 am)
I need it too

is a problem for all that have buy tgea and we hope community resolve it !!!
#7
03/13/2007 (1:52 pm)
I started working on something based on ShowTool class found in engine/game/ShowTSShape.cpp

I am working on it but so far no luck. But hopefully that give some idea to some.

@Stefan, you will be crowned "Emperor" if you could do it ;)
#8
04/07/2007 (7:07 am)
Bump for a working guiObjectView
#9
04/07/2007 (2:11 pm)
Well, in the interests of speeding things up a bit, here's a partial: (still need to work the kinks out of mounting and lighting)
guiobjectview.cc/cpp

#include "gui/core/guiCanvas.h"
#include "gui/controls/guiObjectView.h"
#include "console/consoleTypes.h"
#include "sceneGraph/sceneGraph.h"

#ifndef _GFXTEXTUREHANDLE_H_
#include "gfx/gfxTextureHandle.h"
#endif

extern SceneGraph* gClientSceneGraph;

static const F32 MaxOrbitDist = 50.0f;
static const S32 MaxAnimations = 6;

IMPLEMENT_CONOBJECT( GuiObjectView );


GuiObjectView::GuiObjectView() : GuiTSCtrl()
{
	mActive = true;

	mMouseState = None;

	// Can zoom and spin by default
	mZoom = true;
	mSpin = true;
	mLastMousePoint.set( 0, 0 );
	mLightDirection = VectorF(-0.57735f, -0.57735f, -0.57735f);
	mLightColor = ColorF(0.6f, 0.58f, 0.5f);
	mAmbientColor = ColorF(0.3f, 0.3f, 0.3f);
	mCameraRot.set(0,0,10);
}

GuiObjectView::~GuiObjectView()
{
	mMeshObjects.Clear();
}

// Script function handling for "setMouse"
ConsoleMethod( GuiObjectView, setMouse, void, 4, 4, "ObjectView.setMouse(canZoom, canSpin)" ) {
	argc;
	GuiObjectView* view = static_cast<GuiObjectView*>( object );
	view->setMouseOptions(dAtob(argv[2]), dAtob(argv[3]));
}

// Script function handling for "setObject"
ConsoleMethod( GuiObjectView, setObject, void, 6, 6, "ObjectView.setObject(name, model, skin, lod)" )
{
	argc;
	GuiObjectView* view = static_cast<GuiObjectView*>( object );
	view->loadObject(argv[2], argv[3], argv[4], "", "", dAtoi(argv[5]));
	view->setCamera();
}

// Script function handling for "mountObject"
ConsoleMethod( GuiObjectView, mountObject, void, 8, 8, "ObjectView.mountObject(name, model, skin, parentName, nodeName, lod)" ) {
	argc;
	GuiObjectView* view = static_cast<GuiObjectView*>( object );
	view->loadObject(argv[2], argv[3], argv[4], argv[5], argv[6] ,dAtoi(argv[7]));
}

// Script function handling for "unMountObject"
ConsoleMethod( GuiObjectView, unMountObject, void, 4, 4, "ObjectView.unMountObject(name, node)" ) {
	argc;
	GuiObjectView* view = static_cast<GuiObjectView*>( object );
	view->unLoadObject(argv[2], argv[3]);
}

// Script function handling for "setEmpty"
ConsoleMethod( GuiObjectView, setEmpty, void, 2, 2, "ObjectView.setEmpty( )" ) {
	argc;
	GuiObjectView* view = static_cast<GuiObjectView*>( object );
	view->Clear();
}

// Script function handling for "loadDSQ"
ConsoleMethod( GuiObjectView, loadDSQ, void, 4, 4, "ObjectView.loadDSQ(name, dsq)" ) {
	argc;
	GuiObjectView* view = static_cast<GuiObjectView*>( object );
	view->loadDSQ(argv[2], argv[3]);
}

// Script function handling for "setSequence"
ConsoleMethod( GuiObjectView, setSequence, void, 5, 5, "ObjectView.setSequence(name, seq, time)" ) {
	argc;
	GuiObjectView* view = static_cast<GuiObjectView*>( object );
	view->setSequence(argv[2], argv[3], dAtof(argv[4]));
}

void GuiObjectView::consoleInit()
{

}

void GuiObjectView::initPersistFields()
{
	Parent::initPersistFields();
	addField("lightDirection",   TypePoint3F, Offset(mLightDirection,   GuiObjectView));
	addField("lightColor",   TypeColorF, Offset(mLightColor,   GuiObjectView));
	addField("ambientColor",   TypeColorF, Offset(mAmbientColor,   GuiObjectView));
}

bool GuiObjectView::onWake()
{
	if ( !Parent::onWake() )
		return( false );
      
	mCameraMatrix.identity();
	mCameraRot.set( 0, 0, 3.9 );
	mCameraPos.set( 0, 1.75, 1.25 );
	mCameraMatrix.setColumn( 3, mCameraPos );
	mOrbitPos.set( 0, 0, 0 );
	mOrbitDist = 19.0f;

	return( true );
}

// Function to determine the ways the mouse can interact with the gui object
void GuiObjectView::setMouseOptions( bool zoom, bool spin  )
{
	mZoom = zoom;
	mSpin = spin;
}

// Mouse is down, lock mouse input and get the mouse pointer coordinates and set mode to spin
void GuiObjectView::onMouseDown( const GuiEvent &event )
{
	if ( !mActive || !mVisible || !mAwake || !mSpin )
		return;

	mMouseState = Rotating;

	mLastMousePoint = event.mousePoint;
	mouseLock();
}

// Mouse is up, unlock mouse input
void GuiObjectView::onMouseUp( const GuiEvent &/*event*/ )
{
	mouseUnlock();
	mMouseState = None;
}

// If mouse is dragged, adjust camera position accordingly. Makes model rotate
void GuiObjectView::onMouseDragged( const GuiEvent &event )
{
	if ( mMouseState != Rotating )
		return;

	Point2I delta = event.mousePoint - mLastMousePoint;
	mLastMousePoint = event.mousePoint;

	mCameraRot.x += ( delta.y * 0.01 );
	mCameraRot.z += ( delta.x * 0.01 );
}

// Right mouse is down, lock mouse input and get the mouse pointer coordinates and set mode to zoom
void GuiObjectView::onRightMouseDown( const GuiEvent &event )
{
	if ( !mActive || !mVisible || !mAwake || !mZoom )
		return;

	mMouseState = Zooming;

	mLastMousePoint = event.mousePoint;
	mouseLock();
}

// Right mouse is up, unlock mouse input
void GuiObjectView::onRightMouseUp( const GuiEvent &/*event*/ )
{
	mouseUnlock();
	mMouseState = None;
}

// If mouse is dragged, adjust camera position accordingly. Makes model zoom
void GuiObjectView::onRightMouseDragged( const GuiEvent &event )
{
	if ( mMouseState != Zooming )
		return;

	S32 delta = event.mousePoint.y - mLastMousePoint.y;
	mLastMousePoint = event.mousePoint;

	mOrbitDist += ( delta * 0.01 ); 
}

//-----------------------------------------------------------
void GuiObjectView::setCamera()
{
	// Make sure there is a main object in the scene
	if (mMeshObjects.mMainObject)
	{
		// Initialize camera values:
		mOrbitPos = mMeshObjects.mMainObject->getShape()->center;
		mMinOrbitDist = mMeshObjects.mMainObject->getShape()->radius;
		mOrbitDist = mMinOrbitDist + 1;
	}
}
#10
04/07/2007 (2:12 pm)
//------------------------------------------------------------------------------
bool GuiObjectView::processCameraQuery( CameraQuery* query )
{
	// Make sure the orbit distance is within the acceptable range:
	mOrbitDist = ( mOrbitDist < mMinOrbitDist ) ? mMinOrbitDist : ( ( mOrbitDist > MaxOrbitDist ) ? MaxOrbitDist : mOrbitDist );
	// Adjust the camera so that we are still facing the model:
	Point3F vec;
	MatrixF xRot, yRot, zRot;
	xRot.set( EulerF( mCameraRot.x, 0, 0 ) );
	zRot.set( EulerF( 0, 0, mCameraRot.z ) );

	mCameraMatrix.mul( zRot, xRot );
	mCameraMatrix.getColumn( 1, &vec );

	vec *= mOrbitDist;
	mCameraPos = mOrbitPos - vec;
	query->nearPlane = 0.1;
	query->farPlane = 2100.0;
	query->fov = 3.1415 / 3.5;
	mCameraMatrix.setColumn( 3, mCameraPos );
	query->cameraMatrix = mCameraMatrix;
	return( true );
}


//------------------------------------------------------------------------------
void GuiObjectView::renderWorld( const RectI &updateRect )
{
   if (!(bool)mMeshObjects.mMainObject)
	   return; 

   GFX->clear( GFXClearZBuffer, ColorI(0,0,0), 1.0f, 0);
   GFX->setZEnable(true);
   GFX->setZWriteEnable(true);
   GFX->setZFunc(GFXCmpLessEqual);
   GFX->setLightingEnable(true);
   GFX->setAmbientLightColor(mAmbientColor);

   // Determine the camera position, and store off render state...
   MatrixF modelview;
   MatrixF mv;
   Point3F cp;
   modelview = GFX->getWorldMatrix();
   mv = modelview;
   mv.inverse();
   mv.getColumn(3, &cp);
   // Set up the base SceneState.
   F32 left, right, top, bottom, nearPlane, farPlane;
   RectI viewport;
   GFX->getFrustum( &left, &right, &bottom, &top, &nearPlane, &farPlane );
   viewport = GFX->getViewport();

   SceneState* pBaseState = new SceneState(NULL,
	   0,
	   left, right,
	   bottom, top,
	   nearPlane,
	   farPlane,
	   viewport, 
	   cp,
	   modelview,
	   1000,
	   1000,
	   ColorF(0.1,0.1,0.1),
	   0,
	   NULL,
	   1);

	

   pBaseState->mFlipCull = false;
   TSMesh::setSceneState( pBaseState );

	gClientSceneGraph->buildFogTexture(pBaseState);

   TSMesh::setRefract(false);
	DetailManager::beginPrepRender();
	DetailManager::endPrepRender();

   for (S32 i=0; i<33; i++)
   {
	   if (mMeshObjects.mMesh[i].mesh)
	   {
		   // Animate and render
		   if(mMeshObjects.mMesh[i].mode == 1)
		   {
			   S32 time = Platform::getVirtualMilliseconds();
			   S32 dt = time - mMeshObjects.mMesh[i].lastRenderTime;
			   mMeshObjects.mMesh[i].lastRenderTime = time;
			   F32 fdt = dt;
			   mMeshObjects.mMesh[i].mesh->advanceTime( fdt/1000.f, mMeshObjects.mMesh[i].thread );
			   mMeshObjects.mMesh[i].mesh->animate();
		   }
		   // If this is a mounted object transform to the correct position
		   if (mMeshObjects.mMesh[i].parentNode != -1)
		   {
			   MatrixF mat;
			   getObjectTransform( &mat, i );
			   GFX->pushWorldMatrix();
			   GFX->multWorld(mat);
			   mMeshObjects.mMesh[i].mesh->render();
			   GFX->popWorldMatrix();
		   }
		   else
		   {
			   mMeshObjects.mMesh[i].mesh->render();
		   }
	   }
   }


	gClientSceneGraph->renderScene();

   TSMesh::setSceneState( NULL );
   delete pBaseState;  

   GFX->setLightingEnable(false);
   GFX->setZEnable(false);
   GFX->setClipRect( updateRect);
	GFX_Canonizer("GuiObjectView", __FILE__, __LINE__);	
}

//-----------------------------------------------------------
void GuiObjectView::getObjectTransform( MatrixF *mat , S32 index)
{

	MatrixF subTrans = mMeshObjects.mMesh[index].mesh->mNodeTransforms[mMeshObjects.mMesh[index].node];
	Point3F subOffset = -subTrans.getPosition();

	S32 pIndex = mMeshObjects.mMesh[index].parentIndex;
	MatrixF parentTrans = mMeshObjects.mMesh[pIndex].mesh->mNodeTransforms[mMeshObjects.mMesh[index].parentNode];
	parentTrans.mulP( subOffset );
	parentTrans.setPosition( subOffset );
	*mat = parentTrans;
}
#11
04/07/2007 (2:12 pm)
//-----------------------------------------------------------
void GuiObjectView::loadObject(const char* name, const char* shape, const char* skin, const char* parentName, const char* nodeName, S32 detail)
{ 
	bool main = (dStrcmp(nodeName,"") == 0);
	S32 index = 0;

	if (main)
	{
		// This is the main object clear out any meshs already loaded
		Clear();

		mMeshObjects.load(0, name, shape, skin, 0, -1, detail);
	}
	else
	{
		// Make sure there is a mMainObject
		if (!mMeshObjects.mMainObject)
		{
			Con::printf("Error: Main object not found");
			return;
		}

		// Check for target node
		S32 pNode;
		S32 pIndex;
		for(S32 i=0; i<33; i++)
		{
			if(dStrcmp(mMeshObjects.mMesh[i].name, parentName) == 0)
			{
				pNode = mMeshObjects.mMesh[i].mesh->getShape()->findNode(nodeName);
				pIndex = i;
				if(pNode == -1)
				{
					Con::printf("Error: Unable to find node %s", nodeName);
					return;
				}

				continue;
			}
		}

		// Check to see if something is already mounted to this object's mountPoint, or if the object name already exists.
		for (S32 i=0; i<33; i++)
		{
			if (mMeshObjects.mMesh[i].parentNode == pNode && mMeshObjects.mMesh[i].parentIndex == pIndex || dStrcmp(mMeshObjects.mMesh[i].name, name) == 0)
			{
				Con::printf("Unloading object %s at %s", mMeshObjects.mMesh[i].name, nodeName);
				mMeshObjects.unLoad(i);
			}
		}

		// This is a mounted object find an open spot for this mesh
		index = mMeshObjects.findOpen();
		if (index == -1)
		{
			Con::printf("Error: Maximum mountable objects reached. Please unMount an object");
			return;
		}

		mMeshObjects.load(index, name, shape, skin, pIndex, pNode, detail);
	}
}

//-----------------------------------------------------------
void GuiObjectView::unLoadObject(const char* name, const char* node)
{ 
	if (dStrcmp(name,"") != 0)
	{
		S32 index = mMeshObjects.findMeshByName(name);
		if (index != -1)
		{
			mMeshObjects.unLoad(index);
			Con::printf("Unloading object %s", name);
		}
		else
		{
			Con::printf("Error: Unable to find object %s", name);
		}
	}
	else if (dStrcmp(node,"") != 0)
	{
		S32 index = mMeshObjects.findMeshByNode(node);
		if (index != -1)
		{
			mMeshObjects.unLoad(index);
			Con::printf("Unloading object at %s", node);
		}
		else
		{
			Con::printf("Error: Unable to find object at %s", node);
		}
	}
}

void GuiObjectView::loadDSQ(const char* name, const char* dsq)
{
	S32 index = mMeshObjects.findMeshByName(name);
	if (index != -1)
	{
		mMeshObjects.mMesh[index].loadDSQ(dsq);
	}
	else
	{
		Con::printf("Error: Could not find object %s", name);
	}
}
//-----------------------------------------------------------
void GuiObjectView::setSequence(const char* name, const char* seq, F32 time)
{
	S32 index = mMeshObjects.findMeshByName(name);
	if (index != -1)
	{
		mMeshObjects.mMesh[index].setSequence(seq, time);
	}
	else
	{
		Con::printf("Error: Could not find object %s", name);
	}
}

//-----------------------------------------------------------
void GuiObjectView::Clear()
{ 
	mMeshObjects.Clear(); 
}


//-----------------------------------------------------------
GuiObjectView::meshObjects::meshObjects()
{
	mMainObject = NULL;
	mDetail = 0;
}

GuiObjectView::meshObjects::~meshObjects()
{
	
}

//-----------------------------------------------------------
void GuiObjectView::meshObjects::load(S32 index, const char* name, const char* shape, const char* skin, S32 pIndex, S32 pNode, S32 detail)
{
	char fileBuffer[256];
	
	// Load the shape
	dSprintf(fileBuffer, sizeof( fileBuffer ), "%s", shape);

	// Load the shape into the ResourceManager
	Resource<TSShape> hShape = ResourceManager->load(fileBuffer);
	if (!bool(hShape))
	{
		Con::printf("Error: Unable to load: %s", shape);
		return;
	}

	// Copy the shape to mMesh
	mMesh[index].mesh = new TSShapeInstance(hShape, true);
	AssertFatal(mMesh[index].mesh, "ERROR!  Failed to load object model!");

	/*
	// Load the skin
	if(dStrcmp(skin,"") != 0)
	{
		dSprintf(fileBuffer, sizeof( fileBuffer ), "%s", skin);
		TextureHandle texture = TextureHandle(fileBuffer, MeshTexture, false);
		TSMaterialList* materialList = mMesh[index].mesh->getMaterialList();
		materialList->mMaterials[0] = texture;
	}
	*/
	
	// If a parent Index exists store it.
	if(pIndex)
		mMesh[index].parentIndex = pIndex;

	if (pNode == -1)
	{
		// If this is the main object setup the pointer and global detail level
		mMainObject = mMesh[index].mesh;
		mDetail = detail;	
	}
	else
	{
		// If this is a mounted object set the mountPoint node and parentNode
		mMesh[index].node = mMesh[index].mesh->getShape()->findNode("mountPoint");
		mMesh[index].parentNode = pNode;
	}

	// Set the name
	dSprintf(mMesh[index].name, sizeof( mMesh[index].name ), "%s", name);

	// Set the detail level
	mMesh[index].detail = (detail != -1) ? detail : mDetail;

	// Check the detail level to make sure LOD is valid
	U32 dlNum = mMesh[index].mesh->getNumDetails();
	if(mMesh[index].detail >= dlNum)
	{
		mMesh[index].detail = dlNum - 1;
	}
	mMesh[index].mesh->setCurrentDetail(mMesh[index].detail);

	Con::printf("Loading object %s", shape);
}

//-----------------------------------------------------------
void GuiObjectView::meshObjects::unLoad(S32 index)
{
	if (mMesh[index].mesh)
	{
		dStrcpy(mMesh[index].name, "");
		mMesh[index].mode = 0;
		mMesh[index].node = -1;
		mMesh[index].parentIndex = 0;
		mMesh[index].parentNode = -1;
		mMesh[index].detail = -1;
		mMesh[index].lastRenderTime = 0;
		if (mMesh[index].thread)
		{
			mMesh[index].mesh->destroyThread(mMesh[index].thread);
			mMesh[index].thread = 0;
		}
		
		delete mMesh[index].mesh;
		mMesh[index].mesh = NULL;
	}
}

//-----------------------------------------------------------
S32 GuiObjectView::meshObjects::findOpen()
{
	for (S32 i = 0; i<33; i++)
	{
		if (!mMesh[i].mesh)
		{
			return i;
		}
	}

	return -1;
}

//-----------------------------------------------------------
S32 GuiObjectView::meshObjects::findMeshByName(const char* name)
{
	for (S32 i = 0; i<33; i++)
	{
		if (dStrcmp(mMesh[i].name, name) == 0)
		{
			return i;
		}
	}

	return -1;
}

//-----------------------------------------------------------
S32 GuiObjectView::meshObjects::findMeshByNode(const char* node)
{
	S32 pNode = mMainObject->getShape()->findNode(node);
	if (pNode != -1)
	{
		for (S32 i = 0; i<33; i++)
		{
			if (mMesh[i].parentNode == pNode)
			{
				return i;
			}
		}
	}

	return -1;
}

//-----------------------------------------------------------
void GuiObjectView::meshObjects::Clear()
{
	for (S32 i = 0; i < 33; i++)
	{
		unLoad(i);
	}
	
	mMainObject = NULL;
	mDetail = -1;

}

//-----------------------------------------------------------
GuiObjectView::meshObjects::meshs::meshs()
{
	mesh = NULL;
	mode = 0;
	node = -1;
	parentIndex = 0;
	parentNode = -1;
	detail = 0;
	lastRenderTime = 0;
	thread = 0;
}

GuiObjectView::meshObjects::meshs::~meshs()
{
	if (mesh)
	{
		delete mesh;
		mesh = NULL;
	}

	if (thread)
	{
		mesh->destroyThread(thread);
		thread = 0;
	}
}
#12
04/07/2007 (2:13 pm)
//-----------------------------------------------------------
void GuiObjectView::meshObjects::meshs::loadDSQ(const char* dsq)
{
	Stream * f;
	char fileBuffer[256];

	dSprintf(fileBuffer, sizeof( fileBuffer ), "%s", dsq);

	f = ResourceManager->openStream(fileBuffer);
	if (f)
	{
		if (!mesh->getShape()->importSequences(f) || f->getStatus()!=Stream::Ok)
		{
			Con::errorf(ConsoleLogEntry::General,"Load sequence %s failed",dsq);
			return;
		}

		ResourceManager->closeStream(f);
		Con::printf("Loading dsq %s", dsq);
	}
	else
	{
		Con::printf("Error: Unable to open %s", dsq);
	}
}

//-----------------------------------------------------------
void GuiObjectView::meshObjects::meshs::setSequence(const char* seq, F32 time)
{
	S32 sequence = mesh->getShape()->findSequence(seq);

	if( sequence != -1 )
	{
		if (thread)
		{
			mesh->destroyThread(thread);
		}
		// If you found the sequence add the thread and set sequence and scale
		thread = mesh->addThread();
		lastRenderTime = Platform::getVirtualMilliseconds();
		mesh->setPos( thread, 0 );
		mesh->setTimeScale( thread, time );
		mesh->setSequence( thread, sequence, 0 );
		mode = 1;
		Con::printf("Loading sequence %s", seq);
	}
	else
	{
		Con::printf("Error: Could not locate sequence %s", seq);
	}
}
#13
04/07/2007 (11:26 pm)
Actually, the hint about the tsshowshape set assisted greatly in the first bug:

in

void GuiObjectView::renderWorld( const RectI &updateRect )
between
RectI viewport;
GFX->getFrustum( &left, &right, &bottom, &top, &nearPlane, &farPlane );
// setup light
	F32 emapAlpha = 0.0f;
	//bool gInitLightingSliders = false;
   LightInfo *sunlight = gClientSceneGraph->getLightManager()->sgGetSpecialLight(LightManager::sgSunLightType);

   sunlight->mType = LightInfo::Vector;
   sunlight->mDirection.set( -mLightDirection.x, -mLightDirection.y, -mLightDirection.z );
   sunlight->mColor.set(mLightColor.red, mLightColor.green, mLightColor.blue);
   sunlight->mAmbient.set(mAmbientColor.red, mAmbientColor.green, mAmbientColor.blue);
viewport = GFX->getViewport();

SceneState* pBaseState = new SceneState(NULL,

gets us as far as http://img171.imageshack.us/my.php?image=sucessgd3.jpg

now to tackle the mounting bit (always assuming it's not just a case of the wheel setup. the older versions of tse didnt show em either without some hackery)

(edit: refactored for clarity)
#14
04/09/2007 (10:25 am)
Good work Kirk !!!

I study this now !!!
#15
04/09/2007 (11:46 am)
Getting an error with this sectiobn of code and i just commented it out:
DetailManager::beginPrepRender();	
DetailManager::endPrepRender();

And

GFX_Canonizer("GuiObjectView", __FILE__,__LINE__);

Why is that? Am I doing something wrong?
#16
04/09/2007 (12:21 pm)
Thr detailmanager end is from david archetti's post: http://www.garagegames.com/mg/forums/result.thread.php?qt=24451

the cannonizer I found in one of the other ::renderWorld funcs

Rather obviously, the things still wip, and if somone comes along with a better working one, I'll be dropping this line of experimentation myself. wich is why the codes here for folks to collaborate on, and not in a rescource that folks would be taking at face value as working 100%.
#17
04/09/2007 (12:34 pm)
Understood, at least you have it working ;-)
I still get nothing... :-/ So I guess I'll get into back into the waiting line.

Edit: I can see something now...

If I think of a guiObjectview, I'm thinking of something that will have no background and just views an Object (DTS). When I'm using it I see the current Scene (Scenegraph I guess) with all the objects in it as they are in the current game/mission. So if I fly my ship in that area I can actually see it pass. I've noticed a lot of people using it in the GUi before they enter a mission. But has anyone used it while you are in a mission?
#18
04/16/2007 (6:23 am)
Hi,

Thanks to Kirk, I could now make the character appear in the objectView. But the problem I have is that like James I can see the mission behind. Any idea about how to remove that ?

At least we getting there slowly.
#19
04/16/2007 (9:29 am)
Yeah, I tried to play around with it, but my knowledge of how the scenegraph works is NULL.

I also need to know how to make it use a seperate camera (transform) please post it. Now for me to see it I have to fly to "0 0 0" in my map to see it. So something tells me its using the Gameconnections Camera in the game's worldspace. (Hope I worded that Correctly)
#20
04/16/2007 (12:56 pm)
Guys, are you adding your objects (that you want in the shapeView) into the correct sceneGraph? You do not want to use the same one as your mission.
Page «Previous 1 2 3 4 Last »