예제 #1
0
파일: grutil.cpp 프로젝트: chagge/gym_torcs
bool grLoadPngTexture (const char *fname, ssgTextureInfo* info)
{
	GLubyte *tex;
	int w, h;
	int mipmap = 1;

	TRACE_GL("Load: grLoadPngTexture start");

	tex = (GLubyte*)GfImgReadPng(fname, &w, &h, 2.0);
	if (!tex) {
		return false;
    }

	if (info) {
		info -> width  = w;
		info -> height = h;
		info -> depth  = 4;
		info -> alpha  = true;
    }

	TRACE_GL("Load: grLoadPngTexture stop");

	// TODO: Check if tex is freed.
	// 		 Check/fix potential problems related to malloc/delete mixture
	//       (instead of malloc/free or new/delete).

	mipmap = doMipMap(fname, mipmap);

	GLubyte* tex2 = new GLubyte[w*h*4];
	memcpy(tex2, tex, w*h*4);
	free(tex);
	tex = tex2;
	
	return grMakeMipMaps(tex, w, h, 4, mipmap);
}
예제 #2
0
void grDrawBackground(class cGrCamera *cam, class cGrBackgroundCam *bgCam)
{
    TRACE_GL("grDrawBackground: ssgCullAndDraw start");

    bgCam->update(cam);
    bgCam->action();

    ssgCullAndDraw(TheBackground);

    TRACE_GL("grDrawBackground: ssgCullAndDraw");
}
예제 #3
0
파일: grmain.cpp 프로젝트: fre13131b/TORCAR
int
refresh(tSituation *s)
{
    int			i;

    START_PROFILE("refresh");

    nFrame++;
    grCurTime = GfTimeClock();
    grDeltaTime = grCurTime - OldTime;
    if ((grCurTime - OldTime) > 1.0) {
	/* The Frames Per Second (FPS) display is refreshed every second */
	grFps = (tdble)nFrame / (grCurTime - OldTime);
	nFrame = 0;
	OldTime = grCurTime;
    }

    TRACE_GL("refresh: start");

    START_PROFILE("grRefreshSound*");
    grRefreshSound(s, grScreens[0]->getCurCamera());
    STOP_PROFILE("grRefreshSound*");

    START_PROFILE("grDrawBackground/glClear");
    glDepthFunc(GL_LEQUAL);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    STOP_PROFILE("grDrawBackground/glClear");

    for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
	grScreens[i]->update(s, grFps);
    }

    grUpdateSmoke(s->currentTime);

    STOP_PROFILE("refresh");
    return 0;
}
예제 #4
0
파일: grcar.cpp 프로젝트: andypassion/torcs
void grDrawCar(tCarElt *car, tCarElt *curCar, int dispCarFlag, int dispDrvFlag, double curTime, class cGrPerspCamera *curCam)
{
	sgCoord wheelpos;
	int index, i, j;
	static float maxVel[3] = { 20.0, 40.0, 70.0 };
	float lod;

	TRACE_GL("cggrDrawCar: start");

	index = car->index;
	if (car->priv.collision_state.collision_count > 0) {
		tCollisionState* collision_state = &car->priv.collision_state;
		grPropagateDamage (grCarInfo[index].carEntity, collision_state->pos, collision_state->force, 0);
		collision_state->collision_count = 0;
	}
	
	grCarInfo[index].distFromStart=grGetDistToStart(car);
	grCarInfo[index].envAngle=RAD2DEG(car->_yaw);

	if ((car == curCar) && (dispCarFlag != 1)) {
		grCarInfo[index].LODSelector->select(0);
	} else {
		lod = curCam->getLODFactor(car->_pos_X, car->_pos_Y, car->_pos_Z);
		i = 0;
		while (lod < grCarInfo[index].LODThreshold[i] * grLodFactorValue) {
			i++;
		}
		if ((car->_state & RM_CAR_STATE_DNF) && (grCarInfo[index].LODThreshold[i] > 0.0)) {
			i++;
		}
		grCarInfo[index].LODSelector->select(grCarInfo[index].LODSelectMask[i]);
		if (dispDrvFlag) {
			grCarInfo[index].driverSelector->select(1);
		} else {
			grCarInfo[index].driverSelector->select(0);
		}
	}

	sgCopyMat4(grCarInfo[index].carPos, car->_posMat);
	grCarInfo[index].px=car->_pos_X;
	grCarInfo[index].py=car->_pos_Y;

	grCarInfo[index].carTransform->setTransform(grCarInfo[index].carPos);

	if ((car == curCar) && (dispCarFlag != 1)) {
		grDrawShadow(car, 0);
	} else {
		grDrawShadow(car, 1);
	}
	
	grUpdateSkidmarks(car, curTime); 
	grDrawSkidmarks(car);
	grAddSmoke(car, curTime);
	
	if ((car == curCar) && (dispCarFlag != 1)) {
		grUpdateCarlight(car, curCam, 0);
	} else {
		grUpdateCarlight(car, curCam, 1);
	}

	/* Env mapping selection by the position on the track */
	grCarInfo[index].envSelector->selectStep(car->_trkPos.seg->envIndex);

	/* wheels */
	for (i = 0; i < 4; i++) {
		float	*clr;

		sgSetCoord(&wheelpos, car->priv.wheel[i].relPos.x, car->priv.wheel[i].relPos.y, car->priv.wheel[i].relPos.z,
					RAD2DEG(car->priv.wheel[i].relPos.az), RAD2DEG(car->priv.wheel[i].relPos.ax), 0);
		grCarInfo[index].wheelPos[i]->setTransform(&wheelpos);
		sgSetCoord(&wheelpos, 0, 0, 0, 0, 0, RAD2DEG(car->priv.wheel[i].relPos.ay));
		grCarInfo[index].wheelRot[i]->setTransform(&wheelpos);
		for (j = 0; j < 3; j++) {
			if (fabs(car->_wheelSpinVel(i)) < maxVel[j]) 
				break;
		}
		grCarInfo[index].wheelselector[i]->select(1<<j);
		clr = grCarInfo[index].brkColor[i]->get(0);
		clr[0] = 0.1 + car->_brakeTemp(i) * 1.5;
		clr[1] = 0.1 + car->_brakeTemp(i) * 0.3;
		clr[2] = 0.1 - car->_brakeTemp(i) * 0.3;
	}

	/* push the car at the end of the display order */
	CarsAnchorTmp->addKid(grCarInfo[index].carTransform);
	CarsAnchor->removeKid(grCarInfo[index].carTransform);
	CarsAnchor->addKid(grCarInfo[index].carTransform);
	CarsAnchorTmp->removeKid(grCarInfo[index].carTransform);

	TRACE_GL("cggrDrawCar: end");
}
예제 #5
0
파일: grcar.cpp 프로젝트: andypassion/torcs
void 
grInitCar(tCarElt *car)
{
	const int BUFSIZE=4096;
	char buf[BUFSIZE];
	int index;
	int selIndex;
	ssgEntity *carEntity;
	ssgSelector *LODSel;
	ssgTransform *wheel[4];
	int nranges;
	int i, j;
	void *handle;
	const char *param;
	int lg;
	const int PATHSIZE=256;
	char path[PATHSIZE];
	myLoaderOptions options;
	sgVec3 lightPos;
	int lightNum;
	const char *lightType;
	int lightTypeNum;


	if (!CarsAnchorTmp) {
		CarsAnchorTmp = new ssgBranch();
	}

	grInitBoardCar(car);

	TRACE_GL("loadcar: start");

	ssgSetCurrentOptions ( &options ) ;

	grCarIndex = index = car->index;	/* current car's index */
	handle = car->_carHandle;

	/* Load visual attributes */
	car->_exhaustNb = GfParmGetEltNb(handle, SECT_EXHAUST);
	car->_exhaustNb = MIN(car->_exhaustNb, 2);
	car->_exhaustPower = GfParmGetNum(handle, SECT_EXHAUST, PRM_POWER, NULL, 1.0);
	for (i = 0; i < car->_exhaustNb; i++) {
		snprintf(path, PATHSIZE, "%s/%d", SECT_EXHAUST, i + 1);
		car->_exhaustPos[i].x = GfParmGetNum(handle, path, PRM_XPOS, NULL, -car->_dimension_x / 2.0);
		car->_exhaustPos[i].y = -GfParmGetNum(handle, path, PRM_YPOS, NULL, car->_dimension_y / 2.0);
		car->_exhaustPos[i].z = GfParmGetNum(handle, path, PRM_ZPOS, NULL, 0.1);
	}

	snprintf(path, PATHSIZE, "%s/%s", SECT_GROBJECTS, SECT_LIGHT);
	lightNum = GfParmGetEltNb(handle, path);
	for (i = 0; i < lightNum; i++) {
		snprintf(path, PATHSIZE, "%s/%s/%d", SECT_GROBJECTS, SECT_LIGHT, i + 1);
		lightPos[0] = GfParmGetNum(handle, path, PRM_XPOS, NULL, 0);
		lightPos[1] = GfParmGetNum(handle, path, PRM_YPOS, NULL, 0);
		lightPos[2] = GfParmGetNum(handle, path, PRM_ZPOS, NULL, 0);
		lightType = GfParmGetStr(handle, path, PRM_TYPE, "");
		lightTypeNum = LIGHT_NO_TYPE;
		if (!strcmp(lightType, VAL_LIGHT_HEAD1)) {
			lightTypeNum = LIGHT_TYPE_FRONT;
		} else if (!strcmp(lightType, VAL_LIGHT_HEAD2)) {
			lightTypeNum = LIGHT_TYPE_FRONT2;
		} else if (!strcmp(lightType, VAL_LIGHT_BRAKE)) {
			lightTypeNum = LIGHT_TYPE_BRAKE;
		} else if (!strcmp(lightType, VAL_LIGHT_BRAKE2)) {
			lightTypeNum = LIGHT_TYPE_BRAKE2;
		} else if (!strcmp(lightType, VAL_LIGHT_REAR)) {
			lightTypeNum = LIGHT_TYPE_REAR;
		}
		grAddCarlight(car, lightTypeNum, lightPos, GfParmGetNum(handle, path, PRM_SIZE, NULL, 0.2));
	}

	grLinkCarlights(car);


	GfOut("[gr] Init(%d) car %s for driver %s index %d\n", index, car->_carName, car->_modName, car->_driverIndex);

	grFilePath = (char*)malloc(BUFSIZE);
	lg = 0;
	lg += snprintf(grFilePath + lg, BUFSIZE - lg, "drivers/%s/%d/%s;", car->_modName, car->_driverIndex, car->_carName);
	lg += snprintf(grFilePath + lg, BUFSIZE - lg, "drivers/%s/%d;", car->_modName, car->_driverIndex);
	lg += snprintf(grFilePath + lg, BUFSIZE - lg, "drivers/%s/%s;", car->_modName, car->_carName);
	lg += snprintf(grFilePath + lg, BUFSIZE - lg, "drivers/%s;", car->_modName);
	lg += snprintf(grFilePath + lg, BUFSIZE - lg, "cars/%s", car->_carName);

	param = GfParmGetStr(handle, SECT_GROBJECTS, PRM_WHEEL_TEXTURE, "");
	if (strlen(param) != 0) {
		grGammaValue = 1.8;
		grMipMap = 0;
		grCarInfo[index].wheelTexture = grSsgLoadTexState(param);
	}
    
	grCarInfo[index].envSelector = (ssgStateSelector*)grEnvSelector->clone();
	grCarInfo[index].envSelector->ref();

	/* the base transformation of the car (rotation + translation) */
	grCarInfo[index].carTransform = new ssgTransform;
	DBG_SET_NAME(grCarInfo[index].carTransform, car->_modName, index, -1);

	/* Level of details */
	grCarInfo[index].LODSelector = LODSel = new ssgSelector;
	grCarInfo[index].carTransform->addKid(LODSel);
	snprintf(path, PATHSIZE, "%s/%s", SECT_GROBJECTS, LST_RANGES);
	nranges = GfParmGetEltNb(handle, path) + 1;
	if (nranges < 2) {
		GfOut("Error not enough levels of detail\n");
		FREEZ(grFilePath);
		return;
	}

	/* First LOD */
	ssgBranch *carBody = new ssgBranch;
	DBG_SET_NAME(carBody, "LOD", index, 0);
	LODSel->addKid(carBody);

	/* The car's model is under cars/<model> */
	snprintf(buf, BUFSIZE, "cars/%s", car->_carName);
	ssgModelPath(buf);
	snprintf(buf, BUFSIZE, "drivers/%s/%d;drivers/%s;cars/%s", car->_modName, car->_driverIndex, car->_modName, car->_carName);
	ssgTexturePath(buf);
	grTexturePath = strdup(buf);

	/* loading raw car level 0*/
	selIndex = 0; 	/* current selector index */
	snprintf(buf, BUFSIZE, "%s.ac", car->_carName); /* default car name */
	snprintf(path, PATHSIZE, "%s/%s/1", SECT_GROBJECTS, LST_RANGES);
	param = GfParmGetStr(handle, path, PRM_CAR, buf);
	grCarInfo[index].LODThreshold[selIndex] = GfParmGetNum(handle, path, PRM_THRESHOLD, NULL, 0.0);
	/*carEntity = ssgLoad(param);*/
	carEntity = grssgCarLoadAC3D(param, NULL, index);
	grCarInfo[index].carEntity = carEntity;

	/* Set a selector on the driver */
	char* stmp = strdup("DRIVER");
	ssgBranch *b = (ssgBranch *)carEntity->getByName(stmp);
	free(stmp);

	grCarInfo[index].driverSelector = new ssgSelector;
	if (b) {
		ssgBranch *bp = b->getParent(0);
		bp->addKid(grCarInfo[index].driverSelector);
		grCarInfo[index].driverSelector->addKid(b);
		bp->removeKid(b);
		grCarInfo[index].driverSelector->select(1);
		grCarInfo[index].driverSelectorinsg = true;
	} else {
		grCarInfo[index].driverSelectorinsg = false;
	}


	DBG_SET_NAME(carEntity, "Body", index, -1);
	carBody->addKid(carEntity);
	/* add wheels */
	for (i = 0; i < 4; i++){
		wheel[i] = initWheel(car, i);
		carBody->addKid(wheel[i]);
	}
	grCarInfo[index].LODSelectMask[0] = 1 << selIndex; /* car mask */
	selIndex++;
	grCarInfo[index].sx=carTrackRatioX;
	grCarInfo[index].sy=carTrackRatioY;

	/* Other LODs */
	for (i = 2; i < nranges; i++) {
		carBody = new ssgBranch;
		snprintf(buf, BUFSIZE, "%s/%s/%d", SECT_GROBJECTS, LST_RANGES, i);
		param = GfParmGetStr(handle, buf, PRM_CAR, "");
		grCarInfo[index].LODThreshold[selIndex] = GfParmGetNum(handle, buf, PRM_THRESHOLD, NULL, 0.0);
		/* carEntity = ssgLoad(param); */
		carEntity = grssgCarLoadAC3D(param, NULL, index);;
		DBG_SET_NAME(carEntity, "LOD", index, i-1);
		carBody->addKid(carEntity);
		if (!strcmp(GfParmGetStr(handle, buf, PRM_WHEELSON, "no"), "yes")) {
			/* add wheels */
			for (j = 0; j < 4; j++){
				carBody->addKid(wheel[j]);
			}
		}
		LODSel->addKid(carBody);
		grCarInfo[index].LODSelectMask[i-1] = 1 << selIndex; /* car mask */
		selIndex++;
	}
	/* default range selection */
	LODSel->select(grCarInfo[index].LODSelectMask[0]);

	CarsAnchor->addKid(grCarInfo[index].carTransform);
    
    //grCarInfo[index].carTransform->print(stdout, "-", 1);

	FREEZ(grTexturePath);
	FREEZ(grFilePath);

	TRACE_GL("loadcar: end");
}
예제 #6
0
파일: grmain.cpp 프로젝트: fre13131b/TORCAR
int
initCars(tSituation *s)
{
	const int IDXSIZE = 16;
	char idx[IDXSIZE];
	int index;
	int i;
	tCarElt *elt;
	void *hdle;
	const int BUFSIZE = 1024;
	char buf[1024];
	
	TRACE_GL("initCars: start");

	snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), GR_PARAM_FILE);
	grHandle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);

	grInitCommonState();
	grInitCarlight(s->_ncars);
	grMaxDammage = (tdble)s->_maxDammage;
	grNbCars = s->_ncars;

	grCustomizePits();

	grCarInfo = (tgrCarInfo*)calloc(s->_ncars, sizeof(tgrCarInfo));

	for (i = 0; i < s->_ncars; i++) {
		elt = s->cars[i];
		/* Shadow init (Should be done before the cars for display order) */
		grInitShadow(elt);
		/* Skidmarks init */
		grInitSkidmarks(elt);
	}

	grNbScreen = 0;
	for (i = 0; i < s->_ncars; i++) {
		elt = s->cars[i];
		index = elt->index;
		hdle = elt->_paramsHandle;
		snprintf(idx, IDXSIZE, "Robots/index/%d", elt->_driverIndex);
		grCarInfo[index].iconColor[0] = GfParmGetNum(hdle, idx, "red",   (char*)NULL, 0);
		grCarInfo[index].iconColor[1] = GfParmGetNum(hdle, idx, "green", (char*)NULL, 0);
		grCarInfo[index].iconColor[2] = GfParmGetNum(hdle, idx, "blue",  (char*)NULL, 0);
		grCarInfo[index].iconColor[3] = 1.0;
		grInitCar(elt);
		if ((elt->_driverType == RM_DRV_HUMAN) && (grNbScreen < GR_NB_MAX_SCREEN)) {
			grScreens[grNbScreen]->setCurrentCar(elt);
			grNbScreen++;
		}
	}

	if (grNbScreen == 0) {
		grNbScreen = (int)GfParmGetNum(grHandle, GR_SCT_DISPMODE, GR_ATT_NB_SCREENS, NULL, 1.0);
	}

	for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
		grScreens[i]->initCams(s);
	}

	TRACE_GL("initCars: end");

	grInitSmoke(s->_ncars);
	grInitSound(s, s->_ncars);

	grAdaptScreenSize();

	return 0;
}
예제 #7
0
void grDrawScene(void)
{
    TRACE_GL("refresh: ssgCullAndDraw start");
    ssgCullAndDraw(TheScene);
    TRACE_GL("refresh: ssgCullAndDraw");
}