FirstPersonView.asc

void CellViewSchema::SetView(int width, int height, int row_count, int col_count) {
	row_count = Maths.Min(row_count, CELLVIEW_MAX_CELL_ROWS);
	col_count = Maths.Min(col_count, CELLVIEW_MAX_CELL_COLS);

	Width = width;
	Height = height;
	CellRowCount = row_count;
	CellColCount = col_count;
	CellColMiddle = CellColCount / 2;
	// Strips of vertices always have +1 element more than cells
	VxRowCount = row_count + 1;
	VxColCount = col_count + 1;
}

void CellViewSchema::SetUniformStrip(int vx_row, int y1, int y2, int x_start, int u_width) {
	if (vx_row < 0 || vx_row >= VxRowCount) {
		return;
	}

	Strips[vx_row].Valid = true;
	Strips[vx_row].Y1 = y1;
	Strips[vx_row].Y2 = y2;
	for (int col = 0; col < VxColCount; ++col) {
		Strips[vx_row].X[col] = x_start + u_width * col;
	}
}

void CellViewSchema::SetStrip(int vx_row, int y1, int y2, int x[]) {
	if (vx_row < 0 || vx_row >= VxRowCount || x.Length != VxColCount) {
		return;
	}
	
	Strips[vx_row].Valid = true;
	Strips[vx_row].Y1 = y1;
	Strips[vx_row].Y2 = y2;
	for (int col = 0; col < VxColCount; ++col) {
		Strips[vx_row].X[col] = x[col];
	}
}

void CellViewSchema::SetScaling(float base_scale, float row_scale, float col_scale) {
	float BaseScale = base_scale;
	float RowScaling = row_scale;
	float ColScaling = col_scale;

	float this_row_scale = base_scale;
	for (int row = 0; row < CellRowCount; ++row) {
		float this_col_sale = this_row_scale;
		CellScaling[row, CellColMiddle] = this_col_sale;
		for (int col = 0; col < CellColMiddle; ++col) {
			this_col_sale *= col_scale;
			CellScaling[row, CellColMiddle - col] = this_col_sale;
			CellScaling[row, CellColMiddle + col] = this_col_sale;
		}
		this_row_scale *= row_scale;
	}
}

void CellViewSchema::Finalize() {
	
	for (int row = 0; row < CellRowCount; ++row) {
		for (int col = 0; col < CellColCount; ++col) {
			int frame_front_row = row;
			int frame_back_row = row + 1;
			int frame_left_col = col;
			int frame_right_col = col + 1;
			
			int y1 = Strips[frame_back_row].Y2;
			int y2 = Strips[frame_front_row].Y2;
			int x11 = Strips[frame_front_row].X[frame_left_col];
			int x12 = Strips[frame_front_row].X[frame_right_col];
			int x21 = Strips[frame_back_row].X[frame_left_col];
			int x22 = Strips[frame_back_row].X[frame_right_col];
			int x1 = (x11 + x12) / 2;
			int x2 = (x21 + x22) / 2;
			
			CellCenterX[row, col] = (x1 + x2) / 2;
			CellCenterY[row, col] = (y1 + y2) / 2;
		}
	}
}

Point *CellViewSchema::ObjectToCellView(int objx, int objy) {
	Point *cvpt = new Point;
	cvpt.x = objx + CV_Schema.CellColMiddle;
	cvpt.y = objy;
	return cvpt;
}

CellViewSchema CV_Schema;
export CV_Schema;

managed struct TextureFrames {
	DynamicSprite *Textures[];
};

// DynamicSprites for generated (colored) textures
managed struct TileTextures {
	// Simple colored textures
	DynamicSprite *Textures[];
	// Sequences of colored textures
	TextureFrames *TxFrames[];
};

// Contains overlay and cached references to the applied texture
managed struct WallTile {
	Overlay *Over;
	int TexID; // assigned texture ID
	int Frame; // assigned texture frame
	// base position in the scene, necessary reference for any
	// adjustments because of shorter textures, etc
	int BaseX;
	int BaseY;
};

// internal data
struct FirstPersonViewData {
	// Camera offsets to use when constructing the scene using overlays
	int CameraX;
	int CameraY;
	// Tells to draw walls half-height
	bool HalfWallMode;
	// Cell Walls per row, per col, per tile type
	TileTextures SprWalls[CELLVIEW_MAX_CELL_ROWS, CELLVIEW_MAX_CELL_COLS, eCVTileNum];
	WallTile OverWalls[CELLVIEW_MAX_CELL_ROWS, CELLVIEW_MAX_CELL_COLS, eCVTileNum];
	// Relative z-order for each tile type
	int TileZorders[eCVTileNum];
};

FirstPersonViewData FPV;


protected static void FirstPersonView::ResetTileCache() {
	for (int x = 0; x < CELLVIEW_MAX_CELL_ROWS; ++x) {
		for (int y = 0; y < CELLVIEW_MAX_CELL_COLS; ++y) {
			for (int t = 0; t < eCVTileNum; ++t) {
				FPV.OverWalls[x, y, t] = null;
				FPV.SprWalls[x, y, t] = null;
			}
		}
	}
}

static void FirstPersonView::SetHalfWallMode(bool half_wall) {
	FPV.HalfWallMode = half_wall;
}

static void FirstPersonView::DrawViewport(DrawingSurface* ds, int color) {
	ds.DrawingColor = color;
	ds.DrawFrame(0, 0, CV_Schema.Width - 1, CV_Schema.Height - 1);
}

static void FirstPersonView::DrawGridFrame(DrawingSurface* ds, int cell_color, int wall_color) {
	if (cell_color > 0) {
		ds.DrawingColor = cell_color;
		// horizontal lines (cells fronts)
		for (int row = 0; row < CV_Schema.VxRowCount && CV_Schema.Strips[row].Valid; ++row) {
			for (int col = 0; col < CV_Schema.VxColCount - 1; ++col) {
				ds.DrawLine(CV_Schema.Strips[row].X[col], 
							CV_Schema.Strips[row].Y1, 
							CV_Schema.Strips[row].X[col + 1], 
							CV_Schema.Strips[row].Y1);
				ds.DrawLine(CV_Schema.Strips[row].X[col], 
							CV_Schema.Strips[row].Y2, 
							CV_Schema.Strips[row].X[col + 1], 
							CV_Schema.Strips[row].Y2);
			}
		}
		
		// directional lines (cell sides)
		for (int row = 0; row < CV_Schema.VxRowCount - 1 && CV_Schema.Strips[row + 1].Valid; ++row) {
			for (int col = 0; col < CV_Schema.VxColCount; ++col) {
				ds.DrawLine(CV_Schema.Strips[row].X[col], 
							CV_Schema.Strips[row].Y1, 
							CV_Schema.Strips[row + 1].X[col], 
							CV_Schema.Strips[row + 1].Y1);
				ds.DrawLine(CV_Schema.Strips[row].X[col], 
							CV_Schema.Strips[row].Y2, 
							CV_Schema.Strips[row + 1].X[col], 
							CV_Schema.Strips[row + 1].Y2);
			}
		}
	}
	
	if (wall_color > 0) {
		ds.DrawingColor = wall_color;
		for (int row = 0; row < CV_Schema.VxRowCount; ++row) {
			for (int col = 0; col < CV_Schema.VxColCount; ++col) {
				ds.DrawLine(CV_Schema.Strips[row].X[col], 
							CV_Schema.Strips[row].Y1, 
							CV_Schema.Strips[row].X[col], 
							CV_Schema.Strips[row].Y2);
			}
		}
	}
}

static void FirstPersonView::GenerateAssetsForLevel() {
	FirstPersonView.ResetTileCache();
	// Generate wall sprites required for the "colored textures"
	readonly int gen_tex_num = (CLevel.TileDefs != null) ?
		CLevel.TileDefs.Length : 0;
	if (gen_tex_num == 0) {
		return; // nothing to generate
	}

	for (int row = 0; row < CV_Schema.CellRowCount; ++row) {
		for (int col = 0; col < CV_Schema.CellColCount; ++col) {
			for (int tile = 0; tile < eCVTile_Base; ++tile) {
				TileTextures *tt = new TileTextures;
				tt.Textures = new DynamicSprite[gen_tex_num];
				tt.TxFrames = new TextureFrames[gen_tex_num];
				// Scan all tile definitions, and generate textures for those
				// that depend purely on colors (no defined sprites or views)
				for (int tex_id = 0; tex_id < gen_tex_num; ++tex_id) {
					TileDefinition *tiledef = CLevel.TileDefs[tex_id];
					if (tiledef.Seq[tile] != null) {
						tt.TxFrames[tex_id] = new TextureFrames;
						TextureSequence *tx_seq = tiledef.Seq[tile];
						int frame_count = tx_seq.Color1.Length;
						tt.TxFrames[tex_id].Textures = new DynamicSprite[frame_count];
						for (int frame = 0; frame < frame_count; ++frame) {
							tt.TxFrames[tex_id].Textures[frame] =
								FirstPersonView.CreateWallSprite(row, col, tile, tex_id, frame);
						}
					} else if (tiledef.Color1[tile] != 0){
						tt.Textures[tex_id] = FirstPersonView.CreateWallSprite(row, col, tile, tex_id);
					}
				}
				FPV.SprWalls[row, col, tile] = tt;
			}
		}
	}
}

static void FirstPersonView::SetCameraOffset(int camx, int camy) {
	FPV.CameraX = camx;
	FPV.CameraY = camy;
}

static void FirstPersonView::ConstructLocation(ObjectPosition *eye) {
	if (CV_Schema.CellRowCount == 0 || CV_Schema.CellColCount == 0) {
		return;
	}

	readonly int num_rows = CV_Schema.CellRowCount;
	readonly int num_cols = CV_Schema.CellColCount;
	readonly int mid = CV_Schema.CellColMiddle;

	// Prepare the transform axes.
	MapTransform *t = Level.GetObjectToMapTransform(eye);
	// Look around the map cells and draw what can be seen;
	// we start from the further row and come closer, far sides first.
	for (int row = num_rows - 1; row >= 0; --row) {
		// Draw columns in following order: first side columns from left and
		// right coming to the middle step by step, and then finally the middle one.
		for (int col = 0; col < mid; col++) {
			//System.Log(eLogDebug, "ConstructLocation: row %d col %d (%d)", row, col, num_cols - col - 1);
			FirstPersonView.ConstructCell(eye,
				t.originX + row * t.viewRowAxisX + (col - mid) * t.viewColAxisX,
				t.originY + row * t.viewRowAxisY + (col - mid) * t.viewColAxisY,
				row, col);
			FirstPersonView.ConstructCell(eye,
				t.originX + row * t.viewRowAxisX + (mid - col) * t.viewColAxisX,
				t.originY + row * t.viewRowAxisY + (mid - col) * t.viewColAxisY,
				row, num_cols - col - 1);
		}
		//System.Log(eLogDebug, "ConstructLocation: row %d col %d", row, mid);
		FirstPersonView.ConstructCell(eye,
			t.originX + row * t.viewRowAxisX + 0 * t.viewColAxisX,
			t.originY + row * t.viewRowAxisY + 0 * t.viewColAxisY,
			row, mid);
	}
}

static void FirstPersonView::ConstructCell(ObjectPosition *eye,
			int mapx, int mapy, int row, int col) {
	if (mapx < 0 || mapx >= CLevel.MapWidth || mapy < 0 || mapy >= CLevel.MapHeight ||
			row < 0 || row >= CV_Schema.CellRowCount ||
			col < 0 || col >= CV_Schema.CellColCount) {
		FirstPersonView.HideWallTile(row, col, eCVTile_Ceil);
		FirstPersonView.HideWallTile(row, col, eCVTile_Floor);
		FirstPersonView.HideWallTile(row, col, eCVTile_Front);
		FirstPersonView.HideWallTile(row, col, eCVTile_Side);
		FirstPersonView.HideWallTile(row, col, eCVTile_Base);
		return;
	}

	// We only draw front walls for the farthest row
	bool row_too_far = !CV_Schema.Strips[row + 1].Valid;
	int cell_index = mapy * CLevel.MapWidth + mapx;
	int base_tile = CLevel.CellTiles[cell_index].Base.DefID;
	int floor_tile = CLevel.CellTiles[cell_index].Floor.DefID;
	int ceil_tile = CLevel.CellTiles[cell_index].Ceil.DefID;
	if (base_tile < 0 ||
		(CLevel.TileDefs[base_tile].HasTextures & eTxTypeFlag_WallOrBaseMask) == 0) {
		// No tile definition: don't draw anything
		FirstPersonView.HideWallTile(row, col, eCVTile_Front);
		FirstPersonView.HideWallTile(row, col, eCVTile_Side);
		FirstPersonView.HideWallTile(row, col, eCVTile_Base);
	} else if (CLevel.TileDefs[base_tile].HasTextures & eTxTypeFlag_Base) {
		// Defined as a single cell sprite
		FirstPersonView.HideWallTile(row, col, eCVTile_Front);
		FirstPersonView.HideWallTile(row, col, eCVTile_Side);
		FirstPersonView.DisplayWallTile(row, col, eCVTile_Base,
				CLevel.CellTiles[cell_index].Base.DefID);
	} else {
		// Defined as a combination of walls (front + side + ...?)
		FirstPersonView.HideWallTile(row, col, eCVTile_Base);

		// Draw front wall, unless it's a base row
		if (row != 0) {
			FirstPersonView.DisplayWallTile(row, col, eCVTile_Front,
				CLevel.CellTiles[cell_index].Base.DefID);
		} else {
			FirstPersonView.HideWallTile(row, col, eCVTile_Front);
		}
		// Draw side wall, unless it's a far row, or middle columns
		if (!row_too_far && col != CV_Schema.CellColMiddle) {
			FirstPersonView.DisplayWallTile(row, col, eCVTile_Side,
				CLevel.CellTiles[cell_index].Base.DefID);
		} else {
			FirstPersonView.HideWallTile(row, col, eCVTile_Side);
		}
	}
	
	if (!row_too_far && floor_tile >= 0) {
		FirstPersonView.DisplayWallTile(row, col, eCVTile_Floor,
				CLevel.CellTiles[cell_index].Floor.DefID, CLevel.CellTiles[cell_index].Floor.Frame);
	} else {
		FirstPersonView.HideWallTile(row, col, eCVTile_Floor);
	}
	
	if (!row_too_far && ceil_tile >= 0) {
		FirstPersonView.DisplayWallTile(row, col, eCVTile_Ceil,
				CLevel.CellTiles[cell_index].Ceil.DefID, CLevel.CellTiles[cell_index].Ceil.Frame);
	} else {
		FirstPersonView.HideWallTile(row, col, eCVTile_Ceil);
	}
}

protected static DynamicSprite *FirstPersonView::CreateWallSprite(int row, int col,
		CellViewTile tile, int tex_id, int frame) {

	// Only draw front walls for far cell row
	if (!CV_Schema.Strips[row + 1].Valid && tile != eCVTile_Front) {
		return null;
	}
	if (tex_id < 0) {
		return null; // invalid texture id
	}

	// Calculate wall quad from the cell position
	int frame_front_row = row;
	int frame_back_row = row + 1;
	int frame_left_col = col;
	int frame_right_col = col + 1;
	int front_x1 = CV_Schema.Strips[frame_front_row].X[frame_left_col];
	int front_x2 = CV_Schema.Strips[frame_front_row].X[frame_right_col];
	int front_y1 = CV_Schema.Strips[frame_front_row].Y1;
	int front_y2 = CV_Schema.Strips[frame_front_row].Y2;

	// xy11 - xy21
	// |         |
	// xy12 - xy22
	int x11, x12, x21, x22, y11, y12, y21, y22;
	bool vertical_wall = false;
	switch (tile) {
	case eCVTile_Floor:
		x11 = CV_Schema.Strips[frame_back_row].X[frame_left_col];
		x12 = front_x1;
		x21 = CV_Schema.Strips[frame_back_row].X[frame_right_col];
		x22 = front_x2;
		y11 = CV_Schema.Strips[frame_back_row].Y2;
		y21 = CV_Schema.Strips[frame_back_row].Y2;
		y12 = front_y2;
		y22 = front_y2;
		break;
	case eCVTile_Ceil:
		x11 = front_x1;
		x12 = CV_Schema.Strips[frame_back_row].X[frame_left_col];
		x21 = front_x2;
		x22 = CV_Schema.Strips[frame_back_row].X[frame_right_col];
		y11 = front_y1;
		y21 = front_y1;
		y12 = CV_Schema.Strips[frame_back_row].Y1;
		y22 = CV_Schema.Strips[frame_back_row].Y1;
		break;
	case eCVTile_Front:
		x11 = front_x1; x12 = x11;
		x21 = front_x2; x22 = x21;
		y11 = front_y1;
		y21 = front_y1;
		y12 = front_y2;
		y22 = front_y2;
		vertical_wall = true;
		break;
	case eCVTile_Side:
		if (col < CV_Schema.CellColMiddle) { // is a right wall
			x11 = front_x2; x12 = front_x2;
			x21 = CV_Schema.Strips[frame_back_row].X[frame_right_col];
			x22 = x21;
			y11 = front_y1;
			y12 = front_y2;
			y21 = CV_Schema.Strips[frame_back_row].Y1;
			y22 = CV_Schema.Strips[frame_back_row].Y2;
		} else {
			x11 = CV_Schema.Strips[frame_back_row].X[frame_left_col];
			x12 = x11;
			x21 = front_x1; x22 = x21;
			y11 = CV_Schema.Strips[frame_back_row].Y1;
			y12 = CV_Schema.Strips[frame_back_row].Y2;
			y21 = front_y1;
			y22 = front_y2;
		}
		vertical_wall = true;
		break;
	default: break;
	}

	if (vertical_wall && FPV.HalfWallMode) {
		y11 = y11 + (y12 - y11) / 2;
		y21 = y21 + (y22 - y21) / 2;
	}

	int x_min = Maths.Min(x11, x12);
	int x_max = Maths.Max(x21, x22);
	int y_min = Maths.Min(y11, y21);
	int x_width = x_max - x_min;
	int y_height = Maths.Max(y12 - y11, y22 - y21);
	int draw_color1, draw_color2;
	//System.Log(eLogDebug, "CreateWallSprite: row,col,tile = %d,%d,%d, tex_id,frame = %d,%d", row, col, tile, tex_id, frame);
	if (frame < 0 || CLevel.TileDefs[tex_id].Seq[tile] == null) {
		draw_color1 = CLevel.TileDefs[tex_id].Color1[tile];
		draw_color2 = CLevel.TileDefs[tex_id].Color2[tile];
	} else {
		draw_color1 = CLevel.TileDefs[tex_id].Seq[tile].Color1[frame];
		draw_color2 = CLevel.TileDefs[tex_id].Seq[tile].Color2[frame];
	}
	DynamicSprite *dspr = DynamicSprite.Create(x_width, y_height);
	DrawingSurface *ds = dspr.GetDrawingSurface();
	ds.DrawQuadSplit(
				x11 - x_min, y11 - y_min, x21 - x_min, y21 - y_min,
				x22 - x_min, y22 - y_min, x12 - x_min, y12 - y_min, 
				draw_color1, draw_color2);
	ds.Release();
	return dspr;
}

protected static void FirstPersonView::CreateWallTile(int row, int col, CellViewTile tile) {
	readonly bool is_right_wall = col < CV_Schema.CellColMiddle;
	
	int x, y;
	switch (tile) {
	case eCVTile_Floor:
		x = Maths.Min(CV_Schema.Strips[row].X[col], CV_Schema.Strips[row + 1].X[col]);
		y = CV_Schema.Strips[row + 1].Y2;
		break;
	case eCVTile_Ceil:
		x = Maths.Min(CV_Schema.Strips[row].X[col], CV_Schema.Strips[row + 1].X[col]);
		y = CV_Schema.Strips[row].Y1;
		break;
	case eCVTile_Front:
		x = CV_Schema.Strips[row].X[col];
		y = CV_Schema.Strips[row].Y1;
		break;
	case eCVTile_Side:
		if (is_right_wall) {
			x = CV_Schema.Strips[row].X[col + 1];
			y = CV_Schema.Strips[row].Y1;
		} else {
			x = CV_Schema.Strips[row + 1].X[col];
			y = CV_Schema.Strips[row].Y1;
		}
		break;
	case eCVTile_Base:
		x = Maths.Min(CV_Schema.Strips[row].X[col], CV_Schema.Strips[row + 1].X[col]);
		y = CV_Schema.Strips[row].Y1;
		break;
	default:
		break;
	}
	
	Overlay *new_over = Overlay.CreateRoomGraphical(x, y, 0);
	new_over.ZOrder = FirstPersonView.CalcZorder(row, col, tile);
	WallTile *wall = new WallTile;
	wall.Over = new_over;
	wall.TexID = -2; // unassigned
	wall.Frame = -2; // unassigned
	wall.BaseX = x;
	wall.BaseY = y;
	FPV.OverWalls[row, col, tile] = wall;
}

protected static void FirstPersonView::DisplayWallTile(int row, int col,
			CellViewTile tile, int tex_id, int frame) {
	TileDefinition tiledef = CLevel.TileDefs[tex_id];
	if (tex_id < 0 ||
		(tiledef.HasTextures & (1 << tile)) == 0) {
		return; // invalid texture id
	}
	if (FPV.OverWalls[row, col, tile] == null) {
		FirstPersonView.CreateWallTile(row, col, tile);
	}
	
	WallTile *wall = FPV.OverWalls[row, col, tile];
	Overlay *over = wall.Over;
	// Apply the proper texture
	if (wall.TexID != tex_id || wall.Frame != frame) {
		//System.Log(eLogDebug, "Get texture for row %d, col %d, tile %d, tex_id %d", row, col, tile, tex_id);
		int sprite_num = 0;
		if (tiledef.Sprite[tile] > 0) {
			sprite_num = tiledef.Sprite[tile];
		} else {
			TileTextures *txs = FPV.SprWalls[row, col, tile];
			DynamicSprite *dspr;
			if (frame < 0 || CLevel.TileDefs[tex_id].Seq[tile] == null) {
				dspr = txs.Textures[tex_id];
			} else {
				dspr = txs.TxFrames[tex_id].Textures[frame];
			}
			sprite_num = dspr.Graphic;
		}
		over.Graphic = sprite_num;
		wall.TexID = tex_id;
		wall.Frame = frame;
	}

	// Adjust pos if necessary
	int x = wall.BaseX + FPV.CameraX;
	int y = wall.BaseY + FPV.CameraY;
	if (tile != eCVTile_Floor && tile != eCVTile_Ceil && FPV.HalfWallMode) {
		y += Game.SpriteHeight[over.Graphic];
	}
	if (tiledef.Scaled) {
		float scaling = CV_Schema.CellScaling[row, col];
		over.Width = FloatToInt(IntToFloat(over.GraphicWidth) * scaling);
		over.Height = FloatToInt(IntToFloat(over.GraphicHeight) * scaling);
		x = CV_Schema.CellCenterX[row, col] + FPV.CameraX - over.Width / 2;
		y = CV_Schema.CellCenterY[row, col] + FPV.CameraY - over.Height
			+ FloatToInt(IntToFloat(tiledef.OriginY) * scaling);
	}
	over.X = x;
	over.Y = y;
	over.Transparency = 0; // make visible
}

protected static void FirstPersonView::HideWallTile(int row, int col, CellViewTile tile) {
	WallTile *wall = FPV.OverWalls[row, col, tile];
	if (wall != null) {
		wall.Over.Transparency = 100;
	}
}

static void FirstPersonView::ConstructObject(ObjectPosition *eye, ObjectPosition *obj, 
		int view, int loop, int frame, bool directional, Overlay *over) {

	// First convert absolute object's coordinates into the player view's
	// coordinates. This is done through 2 transformations:
	// * map         -> player's local space (relative to player)
	// * local space -> cell view space (view row/col values)
	Point objlocpt = CLevel.MapToObject(eye, obj.X, obj.Y);
	Point cvpt = CV_Schema.ObjectToCellView(objlocpt.x, objlocpt.y);
	int col = cvpt.x;
	int row = cvpt.y;
	//
	//System.Log(eLogDebug, "ConstructObject: local to cellview: obj = %d,%d", 
	//	col, row);
	if (row < 0 || row >= CV_Schema.CellRowCount ||
		col < 0 || col >= CV_Schema.CellColCount ||
		!CV_Schema.Strips[row + 1].Valid) {
		// not in visible range
		//System.Log(eLogDebug, "ConstructObject: not in visible range");
		over.Transparency = 100;
		return;
	}

	// Now when we know that we're going to place it on screen, let's set up a
	// proper graphic. Calculate which loop to use, depending on the RELATIVE
	// direction of the object's facing.
	int use_loop = loop;
	if (directional) {
		ObjectDirection rel_dir = Level.MapToObjectDir(eye, obj.Dir);
		use_loop = Level.DirToAGSLoop(rel_dir);
	}
	//System.Log(eLogDebug, "ConstructObject: eyedir = %d, objdir = %d, rel_dir = %d, agsloop = %d", eye.Dir, obj.Dir, rel_dir, use_loop);
	ViewFrame *vf = Game.GetViewFrame(view, use_loop, frame);
	if (over.Graphic != vf.Graphic) {
		over.Graphic = vf.Graphic;
	}

	//System.Log(eLogDebug, "ConstructObject: pre scale w,h = %d,%d", over.Width, over.Height);
	float scaling = CV_Schema.CellScaling[row, col];
	over.Width = FloatToInt(IntToFloat(over.GraphicWidth) * scaling);
	over.Height = FloatToInt(IntToFloat(over.GraphicHeight) * scaling);
	//System.Log(eLogDebug, "ConstructObject: scaling = %f, w,h = %d,%d", scaling, over.Width, over.Height);
	// Object is located in the middle of a cell, in between the grid lines
	int x = CV_Schema.CellCenterX[row, col] + FPV.CameraX - over.Width / 2;
	int y = CV_Schema.CellCenterY[row, col] + FPV.CameraY - over.Height;
	over.X = x;
	over.Y = y;
	over.ZOrder = FirstPersonView.CalcZorder(row, col, eCVTile_Object);
	over.Transparency = 0;
}

protected static int FirstPersonView::CalcZorder(int row, int col, CellViewTile tile) {
	int mid = CV_Schema.CellColMiddle;
	// z-order is increasing from far sides to the front center
	int effective_col = col <= mid ? col : (mid - (col - mid));
	return ((CV_Schema.CellRowCount - row) * mid + effective_col) * eCVTileNum
		+ FPV.TileZorders[tile];
}


function game_start() {
	FPV.TileZorders[eCVTile_Floor]	= 0;
	FPV.TileZorders[eCVTile_Ceil]	= 1;
	FPV.TileZorders[eCVTile_Base]	= 2;
	FPV.TileZorders[eCVTile_Object]	= 3;
	FPV.TileZorders[eCVTile_Side]	= 4;
	FPV.TileZorders[eCVTile_Front]	= 5;
}